| blob | 82613b27dde9173463f5447e34c4d115f0379593 |
1 /* C++ Parser.
2 Copyright (C) 2000-2014 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/>. */
48 \f
49 /* The lexer. */
51 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
52 and c-lex.c) and the C++ parser. */
55 {
57 };
59 /* The various kinds of non integral constant we encounter. */
61 NIC_NONE,
62 /* floating-point literal */
63 NIC_FLOAT,
64 /* %<this%> */
65 NIC_THIS,
66 /* %<__FUNCTION__%> */
67 NIC_FUNC_NAME,
68 /* %<__PRETTY_FUNCTION__%> */
69 NIC_PRETTY_FUNC,
70 /* %<__func__%> */
71 NIC_C99_FUNC,
72 /* "%<va_arg%> */
73 NIC_VA_ARG,
74 /* a cast */
75 NIC_CAST,
76 /* %<typeid%> operator */
77 NIC_TYPEID,
78 /* non-constant compound literals */
79 NIC_NCC,
80 /* a function call */
81 NIC_FUNC_CALL,
82 /* an increment */
83 NIC_INC,
84 /* an decrement */
85 NIC_DEC,
86 /* an array reference */
87 NIC_ARRAY_REF,
88 /* %<->%> */
89 NIC_ARROW,
90 /* %<.%> */
91 NIC_POINT,
92 /* the address of a label */
93 NIC_ADDR_LABEL,
94 /* %<*%> */
95 NIC_STAR,
96 /* %<&%> */
97 NIC_ADDR,
98 /* %<++%> */
99 NIC_PREINCREMENT,
100 /* %<--%> */
101 NIC_PREDECREMENT,
102 /* %<new%> */
103 NIC_NEW,
104 /* %<delete%> */
105 NIC_DEL,
106 /* calls to overloaded operators */
107 NIC_OVERLOADED,
108 /* an assignment */
109 NIC_ASSIGNMENT,
110 /* a comma operator */
111 NIC_COMMA,
112 /* a call to a constructor */
113 NIC_CONSTRUCTOR,
114 /* a transaction expression */
115 NIC_TRANSACTION
118 /* The various kinds of errors about name-lookup failing. */
120 /* NULL */
121 NLE_NULL,
122 /* is not a type */
123 NLE_TYPE,
124 /* is not a class or namespace */
125 NLE_CXX98,
126 /* is not a class, namespace, or enumeration */
127 NLE_NOT_CXX98
130 /* The various kinds of required token */
132 RT_NONE,
154 /* The type is CPP_KEYWORD */
183 RT_TRANSACTION_CANCEL /* __transaction_cancel */
186 /* Prototypes. */
192 static void cp_lexer_destroy
194 static int cp_lexer_saving_tokens
198 static void cp_lexer_get_preprocessor_token
206 static bool cp_lexer_next_token_is_not
208 static bool cp_lexer_next_token_is_keyword
212 static void cp_lexer_purge_token
214 static void cp_lexer_purge_tokens_after
216 static void cp_lexer_save_tokens
218 static void cp_lexer_commit_tokens
220 static void cp_lexer_rollback_tokens
222 static void cp_lexer_print_token
226 static void cp_lexer_start_debugging
228 static void cp_lexer_stop_debugging
234 static void cp_parser_initial_pragma
237 static tree cp_literal_operator_id
240 static void cp_parser_cilk_simd
242 static tree cp_parser_cilk_for
244 static bool cp_parser_omp_declare_reduction_exprs
246 static tree cp_parser_cilk_simd_vectorlength
249 /* Manifest constants. */
250 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
251 #define CP_SAVED_TOKEN_STACK 5
253 /* Variables. */
255 /* The stream to which debugging output should be written. */
258 /* Nonzero if we are parsing an unevaluated operand: an operand to
259 sizeof, typeof, or alignof. */
262 /* Dump up to NUM tokens in BUFFER to FILE starting with token
263 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
264 first token in BUFFER. If NUM is 0, dump all the tokens. If
265 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
266 highlighted by surrounding it in [[ ]]. */
268 static void
272 {
289 {
292 }
297 {
304 nprinted++;
314 {
324 }
325 }
328 {
331 }
334 }
337 /* Dump all tokens in BUFFER to stderr. */
339 void
341 {
343 }
345 DEBUG_FUNCTION void
347 {
349 }
351 DEBUG_FUNCTION void
353 {
356 else
358 }
361 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
362 description for T. */
364 static void
366 {
368 {
371 }
372 }
375 /* Dump parser context C to FILE. */
377 static void
379 {
384 }
387 /* Print the stack of parsing contexts to FILE starting with FIRST. */
389 static void
391 {
397 {
400 }
401 }
404 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
406 static void
408 {
411 }
414 /* Print an unparsed function entry UF to FILE. */
416 static void
418 {
421 tree fn;
426 i++)
427 {
433 }
438 {
441 }
447 {
450 }
452 }
455 /* Print the stack of unparsed member functions S to FILE. */
457 static void
460 {
466 {
469 }
470 }
473 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
474 the given PARSER. If FILE is NULL, the output is printed on stderr. */
476 static void
478 {
490 next_token);
491 }
494 /* Dump debugging information for the given PARSER. If FILE is NULL,
495 the output is printed on stderr. */
497 void
499 {
502 expanded_location eloc;
580 }
582 DEBUG_FUNCTION void
584 {
586 }
588 DEBUG_FUNCTION void
590 {
593 else
595 }
597 /* Allocate memory for a new lexer object and return it. */
601 {
606 /* Allocate the memory. */
609 /* Initially we are not debugging. */
614 /* Create the buffer. */
618 }
621 /* Create a new main C++ lexer, the lexer that gets tokens from the
622 preprocessor. */
626 {
628 cp_token token;
630 /* It's possible that parsing the first pragma will load a PCH file,
631 which is a GC collection point. So we have to do that before
632 allocating any memory. */
637 /* Put the first token in the buffer. */
640 /* Get the remaining tokens from the preprocessor. */
642 {
645 }
654 /* Subsequent preprocessor diagnostics should use compiler
655 diagnostic functions to get the compiler source location. */
660 }
662 /* Create a new lexer whose token stream is primed with the tokens in
663 CACHE. When these tokens are exhausted, no new tokens will be read. */
667 {
672 /* We do not own the buffer. */
679 /* Initially we are not debugging. */
684 }
686 /* Frees all resources associated with LEXER. */
688 static void
690 {
694 }
696 /* Returns nonzero if debugging information should be output. */
700 {
702 }
707 {
711 }
715 {
717 }
721 {
723 }
727 {
730 else
732 }
736 {
740 }
742 /* nonzero if we are presently saving tokens. */
746 {
748 }
750 /* Store the next token from the preprocessor in *TOKEN. Return true
751 if we reach EOF. If LEXER is NULL, assume we are handling an
752 initial #pragma pch_preprocess, and thus want the lexer to return
753 processed strings. */
755 static void
757 {
760 /* Get a new token from the preprocessor. */
761 token->type
769 /* On some systems, some header files are surrounded by an
770 implicit extern "C" block. Set a flag in the token if it
771 comes from such a header. */
776 /* Check to see if this token is a keyword. */
778 {
780 {
781 /* Mark this token as a keyword. */
783 /* Record which keyword. */
785 }
786 else
787 {
791 {
792 /* Warn about the C++0x keyword (but still treat it as
793 an identifier). */
798 /* Clear out the C_RID_CODE so we don't warn about this
799 particular identifier-turned-keyword again. */
801 }
804 }
805 }
807 {
808 /* This only happens in Objective-C++; it must be a keyword. */
811 {
812 /* Replace 'class' with '@class', 'private' with '@private',
813 etc. This prevents confusion with the C++ keyword
814 'class', and makes the tokens consistent with other
815 Objective-C 'AT' keywords. For example '@class' is
816 reported as RID_AT_CLASS which is consistent with
817 '@synchronized', which is reported as
818 RID_AT_SYNCHRONIZED.
819 */
828 }
829 }
831 {
832 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
836 }
837 }
839 /* Update the globals input_location and the input file stack from TOKEN. */
842 {
844 {
846 }
847 }
849 /* Update the globals input_location and the input file stack from LEXER. */
852 {
855 }
857 /* Return a pointer to the next token in the token stream, but do not
858 consume it. */
862 {
864 {
868 }
870 }
872 /* Return true if the next token has the indicated TYPE. */
876 {
878 }
880 /* Return true if the next token does not have the indicated TYPE. */
884 {
886 }
888 /* Return true if the next token is the indicated KEYWORD. */
892 {
894 }
898 {
900 }
904 {
906 }
908 /* Return true if the next token is not the indicated KEYWORD. */
912 {
914 }
916 /* Return true if the next token is a keyword for a decl-specifier. */
918 static bool
920 {
925 {
926 /* auto specifier: storage-class-specifier in C++,
927 simple-type-specifier in C++0x. */
929 /* Storage classes. */
935 /* Elaborated type specifiers. */
941 /* Simple type specifiers. */
956 /* GNU extensions. */
959 /* C++0x extensions. */
966 }
967 }
969 /* Returns TRUE iff the token T begins a decltype type. */
971 static bool
973 {
976 }
978 /* Returns TRUE iff the next token begins a decltype type. */
980 static bool
982 {
985 }
987 /* Return a pointer to the Nth token in the token stream. If N is 1,
988 then this is precisely equivalent to cp_lexer_peek_token (except
989 that it is not inline). One would like to disallow that case, but
990 there is one case (cp_parser_nth_token_starts_template_id) where
991 the caller passes a variable for N and it might be 1. */
995 {
998 /* N is 1-based, not zero-based. */
1009 {
1012 {
1015 }
1019 }
1022 {
1025 }
1028 }
1030 /* Return the next token, and advance the lexer's next_token pointer
1031 to point to the next non-purged token. */
1035 {
1041 do
1042 {
1045 {
1048 }
1050 }
1055 /* Provide debugging output. */
1057 {
1061 }
1064 }
1066 /* Permanently remove the next token from the token stream, and
1067 advance the next_token pointer to refer to the next non-purged
1068 token. */
1070 static void
1072 {
1081 do
1082 {
1083 tok++;
1085 {
1088 }
1089 }
1092 }
1094 /* Permanently remove all tokens after TOK, up to, but not
1095 including, the token that will be returned next by
1096 cp_lexer_peek_token. */
1098 static void
1100 {
1109 {
1114 }
1115 }
1117 /* Begin saving tokens. All tokens consumed after this point will be
1118 preserved. */
1120 static void
1122 {
1123 /* Provide debugging output. */
1128 }
1130 /* Commit to the portion of the token stream most recently saved. */
1132 static void
1134 {
1135 /* Provide debugging output. */
1140 }
1142 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1143 to the token stream. Stop saving tokens. */
1145 static void
1147 {
1148 /* Provide debugging output. */
1153 }
1155 /* Print a representation of the TOKEN on the STREAM. */
1157 static void
1159 {
1160 /* We don't use cpp_type2name here because the parser defines
1161 a few tokens of its own. */
1163 /* cpplib-defined token types */
1164 #define OP(e, s) #e,
1165 #define TK(e, s) #e,
1166 TTYPE_TABLE
1167 #undef OP
1168 #undef TK
1169 /* C++ parser token types - see "Manifest constants", above. */
1173 };
1175 /* For some tokens, print the associated data. */
1177 {
1179 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1180 For example, `struct' is mapped to an INTEGER_CST. */
1183 /* else fall through */
1201 /* If we have a name for the token, print it out. Otherwise, we
1202 simply give the numeric code. */
1205 else
1208 }
1209 }
1211 DEBUG_FUNCTION void
1213 {
1216 }
1218 DEBUG_FUNCTION void
1220 {
1223 else
1225 }
1228 /* Start emitting debugging information. */
1230 static void
1232 {
1235 }
1237 /* Stop emitting debugging information. */
1239 static void
1241 {
1244 }
1246 /* Create a new cp_token_cache, representing a range of tokens. */
1250 {
1255 }
1257 /* Diagnose if #pragma omp declare simd isn't followed immediately
1258 by function declaration or definition. */
1262 {
1264 {
1268 }
1269 }
1271 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1272 and put that into "omp declare simd" attribute. */
1276 {
1278 {
1280 {
1283 }
1285 {
1288 }
1289 }
1290 }
1291 \f
1292 /* Decl-specifiers. */
1294 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1296 static void
1298 {
1300 }
1302 /* Declarators. */
1304 /* Nothing other than the parser should be creating declarators;
1305 declarators are a semi-syntactic representation of C++ entities.
1306 Other parts of the front end that need to create entities (like
1307 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1322 /* An erroneous declarator. */
1325 /* The obstack on which declarators and related data structures are
1326 allocated. */
1329 /* Alloc BYTES from the declarator memory pool. */
1333 {
1335 }
1337 /* Allocate a declarator of the indicated KIND. Clear fields that are
1338 common to all declarators. */
1342 {
1354 }
1356 /* Make a declarator for a generalized identifier. If
1357 QUALIFYING_SCOPE is non-NULL, the identifier is
1358 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1359 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1360 is, if any. */
1364 special_function_kind sfk)
1365 {
1368 /* It is valid to write:
1370 class C { void f(); };
1371 typedef C D;
1372 void D::f();
1374 The standard is not clear about whether `typedef const C D' is
1375 legal; as of 2002-09-15 the committee is considering that
1376 question. EDG 3.0 allows that syntax. Therefore, we do as
1377 well. */
1391 }
1393 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1394 of modifiers such as const or volatile to apply to the pointer
1395 type, represented as identifiers. ATTRIBUTES represent the attributes that
1396 appertain to the pointer or reference. */
1398 cp_declarator *
1400 tree attributes)
1401 {
1409 {
1413 }
1414 else
1420 }
1422 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1423 represent the attributes that appertain to the pointer or
1424 reference. */
1426 cp_declarator *
1429 {
1437 {
1441 }
1442 else
1448 }
1450 /* Like make_pointer_declarator -- but for a pointer to a non-static
1451 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1452 appertain to the pointer or reference. */
1454 cp_declarator *
1457 tree attributes)
1458 {
1467 {
1470 }
1471 else
1477 }
1479 /* Make a declarator for the function given by TARGET, with the
1480 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1481 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1482 indicates what exceptions can be thrown. */
1484 cp_declarator *
1486 tree parms,
1487 cp_cv_quals cv_qualifiers,
1488 cp_virt_specifiers virt_specifiers,
1489 cp_ref_qualifier ref_qualifier,
1490 tree exception_specification,
1491 tree late_return_type)
1492 {
1504 {
1508 }
1509 else
1513 }
1515 /* Make a declarator for an array of BOUNDS elements, each of which is
1516 defined by ELEMENT. */
1518 cp_declarator *
1520 {
1527 {
1531 }
1532 else
1536 }
1538 /* Determine whether the declarator we've seen so far can be a
1539 parameter pack, when followed by an ellipsis. */
1540 static bool
1542 {
1543 /* Search for a declarator name, or any other declarator that goes
1544 after the point where the ellipsis could appear in a parameter
1545 pack. If we find any of these, then this declarator can not be
1546 made into a parameter pack. */
1549 {
1551 {
1563 }
1564 }
1567 }
1571 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1572 DECLARATOR and DEFAULT_ARGUMENT. */
1574 cp_parameter_declarator *
1577 tree default_argument)
1578 {
1586 else
1593 }
1595 /* Returns true iff DECLARATOR is a declaration for a function. */
1597 static bool
1599 {
1601 {
1609 }
1611 }
1613 /* The parser. */
1615 /* Overview
1616 --------
1618 A cp_parser parses the token stream as specified by the C++
1619 grammar. Its job is purely parsing, not semantic analysis. For
1620 example, the parser breaks the token stream into declarators,
1621 expressions, statements, and other similar syntactic constructs.
1622 It does not check that the types of the expressions on either side
1623 of an assignment-statement are compatible, or that a function is
1624 not declared with a parameter of type `void'.
1626 The parser invokes routines elsewhere in the compiler to perform
1627 semantic analysis and to build up the abstract syntax tree for the
1628 code processed.
1630 The parser (and the template instantiation code, which is, in a
1631 way, a close relative of parsing) are the only parts of the
1632 compiler that should be calling push_scope and pop_scope, or
1633 related functions. The parser (and template instantiation code)
1634 keeps track of what scope is presently active; everything else
1635 should simply honor that. (The code that generates static
1636 initializers may also need to set the scope, in order to check
1637 access control correctly when emitting the initializers.)
1639 Methodology
1640 -----------
1642 The parser is of the standard recursive-descent variety. Upcoming
1643 tokens in the token stream are examined in order to determine which
1644 production to use when parsing a non-terminal. Some C++ constructs
1645 require arbitrary look ahead to disambiguate. For example, it is
1646 impossible, in the general case, to tell whether a statement is an
1647 expression or declaration without scanning the entire statement.
1648 Therefore, the parser is capable of "parsing tentatively." When the
1649 parser is not sure what construct comes next, it enters this mode.
1650 Then, while we attempt to parse the construct, the parser queues up
1651 error messages, rather than issuing them immediately, and saves the
1652 tokens it consumes. If the construct is parsed successfully, the
1653 parser "commits", i.e., it issues any queued error messages and
1654 the tokens that were being preserved are permanently discarded.
1655 If, however, the construct is not parsed successfully, the parser
1656 rolls back its state completely so that it can resume parsing using
1657 a different alternative.
1659 Future Improvements
1660 -------------------
1662 The performance of the parser could probably be improved substantially.
1663 We could often eliminate the need to parse tentatively by looking ahead
1664 a little bit. In some places, this approach might not entirely eliminate
1665 the need to parse tentatively, but it might still speed up the average
1666 case. */
1668 /* Flags that are passed to some parsing functions. These values can
1669 be bitwise-ored together. */
1671 enum
1672 {
1673 /* No flags. */
1675 /* The construct is optional. If it is not present, then no error
1676 should be issued. */
1678 /* When parsing a type-specifier, treat user-defined type-names
1679 as non-type identifiers. */
1681 /* When parsing a type-specifier, do not try to parse a class-specifier
1682 or enum-specifier. */
1684 /* When parsing a decl-specifier-seq, only allow type-specifier or
1685 constexpr. */
1687 };
1689 /* This type is used for parameters and variables which hold
1690 combinations of the above flags. */
1693 /* The different kinds of declarators we want to parse. */
1696 {
1697 /* We want an abstract declarator. */
1698 CP_PARSER_DECLARATOR_ABSTRACT,
1699 /* We want a named declarator. */
1700 CP_PARSER_DECLARATOR_NAMED,
1701 /* We don't mind, but the name must be an unqualified-id. */
1702 CP_PARSER_DECLARATOR_EITHER
1705 /* The precedence values used to parse binary expressions. The minimum value
1706 of PREC must be 1, because zero is reserved to quickly discriminate
1707 binary operators from other tokens. */
1709 enum cp_parser_prec
1710 {
1711 PREC_NOT_OPERATOR,
1712 PREC_LOGICAL_OR_EXPRESSION,
1713 PREC_LOGICAL_AND_EXPRESSION,
1714 PREC_INCLUSIVE_OR_EXPRESSION,
1715 PREC_EXCLUSIVE_OR_EXPRESSION,
1716 PREC_AND_EXPRESSION,
1717 PREC_EQUALITY_EXPRESSION,
1718 PREC_RELATIONAL_EXPRESSION,
1719 PREC_SHIFT_EXPRESSION,
1720 PREC_ADDITIVE_EXPRESSION,
1721 PREC_MULTIPLICATIVE_EXPRESSION,
1722 PREC_PM_EXPRESSION,
1723 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1724 };
1726 /* A mapping from a token type to a corresponding tree node type, with a
1727 precedence value. */
1730 {
1731 /* The token type. */
1733 /* The corresponding tree code. */
1735 /* The precedence of this operator. */
1740 {
1741 /* Left hand side of the binary operation we are currently
1742 parsing. */
1743 tree lhs;
1744 /* Original tree code for left hand side, if it was a binary
1745 expression itself (used for -Wparentheses). */
1747 /* Tree code for the binary operation we are parsing. */
1749 /* Precedence of the binary operation we are parsing. */
1751 /* Location of the binary operation we are parsing. */
1752 location_t loc;
1755 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1756 entries because precedence levels on the stack are monotonically
1757 increasing. */
1761 /* Prototypes. */
1763 /* Constructors and destructors. */
1768 /* Class variables. */
1772 /* The operator-precedence table used by cp_parser_binary_expression.
1773 Transformed into an associative array (binops_by_token) by
1774 cp_parser_new. */
1807 };
1809 /* The same as binops, but initialized by cp_parser_new so that
1810 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1811 for speed. */
1814 /* Constructors and destructors. */
1816 /* Construct a new context. The context below this one on the stack
1817 is given by NEXT. */
1821 {
1824 /* Allocate the storage. */
1826 {
1827 /* Pull the first entry from the free list. */
1831 }
1832 else
1835 /* No errors have occurred yet in this context. */
1837 /* If this is not the bottommost context, copy information that we
1838 need from the previous context. */
1840 {
1841 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1842 expression, then we are parsing one in this context, too. */
1844 /* Thread the stack. */
1846 }
1849 }
1851 /* Managing the unparsed function queues. */
1853 #define unparsed_funs_with_default_args \
1854 parser->unparsed_queues->last ().funs_with_default_args
1855 #define unparsed_funs_with_definitions \
1856 parser->unparsed_queues->last ().funs_with_definitions
1857 #define unparsed_nsdmis \
1858 parser->unparsed_queues->last ().nsdmis
1859 #define unparsed_classes \
1860 parser->unparsed_queues->last ().classes
1862 static void
1864 {
1867 }
1869 static void
1871 {
1874 }
1876 /* Prototypes. */
1878 /* Constructors and destructors. */
1883 /* Routines to parse various constructs.
1885 Those that return `tree' will return the error_mark_node (rather
1886 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1887 Sometimes, they will return an ordinary node if error-recovery was
1888 attempted, even though a parse error occurred. So, to check
1889 whether or not a parse error occurred, you should always use
1890 cp_parser_error_occurred. If the construct is optional (indicated
1891 either by an `_opt' in the name of the function that does the
1892 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1893 the construct is not present. */
1895 /* Lexical conventions [gram.lex] */
1897 static tree cp_parser_identifier
1899 static tree cp_parser_string_literal
1901 static tree cp_parser_userdef_char_literal
1903 static tree cp_parser_userdef_string_literal
1905 static tree cp_parser_userdef_numeric_literal
1908 /* Basic concepts [gram.basic] */
1910 static bool cp_parser_translation_unit
1913 /* Expressions [gram.expr] */
1915 static tree cp_parser_primary_expression
1917 static tree cp_parser_id_expression
1919 static tree cp_parser_unqualified_id
1921 static tree cp_parser_nested_name_specifier_opt
1923 static tree cp_parser_nested_name_specifier
1925 static tree cp_parser_qualifying_entity
1927 static tree cp_parser_postfix_expression
1929 static tree cp_parser_postfix_open_square_expression
1931 static tree cp_parser_postfix_dot_deref_expression
1935 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1937 static void cp_parser_pseudo_destructor_name
1939 static tree cp_parser_unary_expression
1941 static enum tree_code cp_parser_unary_operator
1943 static tree cp_parser_new_expression
1947 static tree cp_parser_new_type_id
1955 static tree cp_parser_delete_expression
1957 static tree cp_parser_cast_expression
1959 static tree cp_parser_binary_expression
1961 static tree cp_parser_question_colon_clause
1963 static tree cp_parser_assignment_expression
1965 static enum tree_code cp_parser_assignment_operator_opt
1967 static tree cp_parser_expression
1969 static tree cp_parser_constant_expression
1971 static tree cp_parser_builtin_offsetof
1973 static tree cp_parser_lambda_expression
1975 static void cp_parser_lambda_introducer
1977 static bool cp_parser_lambda_declarator_opt
1979 static void cp_parser_lambda_body
1982 /* Statements [gram.stmt.stmt] */
1984 static void cp_parser_statement
1986 static void cp_parser_label_for_labeled_statement
1988 static tree cp_parser_expression_statement
1990 static tree cp_parser_compound_statement
1992 static void cp_parser_statement_seq_opt
1994 static tree cp_parser_selection_statement
1996 static tree cp_parser_condition
1998 static tree cp_parser_iteration_statement
2000 static bool cp_parser_for_init_statement
2002 static tree cp_parser_for
2004 static tree cp_parser_c_for
2006 static tree cp_parser_range_for
2008 static void do_range_for_auto_deduction
2010 static tree cp_parser_perform_range_for_lookup
2012 static tree cp_parser_range_for_member_function
2014 static tree cp_parser_jump_statement
2016 static void cp_parser_declaration_statement
2019 static tree cp_parser_implicitly_scoped_statement
2021 static void cp_parser_already_scoped_statement
2024 /* Declarations [gram.dcl.dcl] */
2026 static void cp_parser_declaration_seq_opt
2028 static void cp_parser_declaration
2030 static void cp_parser_block_declaration
2032 static void cp_parser_simple_declaration
2034 static void cp_parser_decl_specifier_seq
2036 static tree cp_parser_storage_class_specifier_opt
2038 static tree cp_parser_function_specifier_opt
2040 static tree cp_parser_type_specifier
2043 static tree cp_parser_simple_type_specifier
2045 static tree cp_parser_type_name
2047 static tree cp_parser_nonclass_name
2049 static tree cp_parser_elaborated_type_specifier
2051 static tree cp_parser_enum_specifier
2053 static void cp_parser_enumerator_list
2055 static void cp_parser_enumerator_definition
2057 static tree cp_parser_namespace_name
2059 static void cp_parser_namespace_definition
2061 static void cp_parser_namespace_body
2063 static tree cp_parser_qualified_namespace_specifier
2065 static void cp_parser_namespace_alias_definition
2067 static bool cp_parser_using_declaration
2069 static void cp_parser_using_directive
2071 static tree cp_parser_alias_declaration
2073 static void cp_parser_asm_definition
2075 static void cp_parser_linkage_specification
2077 static void cp_parser_static_assert
2079 static tree cp_parser_decltype
2082 /* Declarators [gram.dcl.decl] */
2084 static tree cp_parser_init_declarator
2085 (cp_parser *, cp_decl_specifier_seq *, vec<deferred_access_check, va_gc> *, bool, bool, int, bool *, tree *);
2090 static enum tree_code cp_parser_ptr_operator
2092 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2094 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2096 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2098 static tree cp_parser_late_return_type_opt
2100 static tree cp_parser_declarator_id
2102 static tree cp_parser_type_id
2104 static tree cp_parser_template_type_arg
2107 static tree cp_parser_type_id_1
2109 static void cp_parser_type_specifier_seq
2111 static tree cp_parser_parameter_declaration_clause
2113 static tree cp_parser_parameter_declaration_list
2117 static tree cp_parser_default_argument
2119 static void cp_parser_function_body
2121 static tree cp_parser_initializer
2123 static tree cp_parser_initializer_clause
2125 static tree cp_parser_braced_list
2130 static bool cp_parser_ctor_initializer_opt_and_function_body
2133 static tree cp_parser_late_parsing_omp_declare_simd
2136 static tree cp_parser_late_parsing_cilk_simd_fn_info
2139 static tree synthesize_implicit_template_parm
2141 static tree finish_fully_implicit_template
2144 /* Classes [gram.class] */
2146 static tree cp_parser_class_name
2148 static tree cp_parser_class_specifier
2150 static tree cp_parser_class_head
2152 static enum tag_types cp_parser_class_key
2154 static void cp_parser_type_parameter_key
2156 static void cp_parser_member_specification_opt
2158 static void cp_parser_member_declaration
2160 static tree cp_parser_pure_specifier
2162 static tree cp_parser_constant_initializer
2165 /* Derived classes [gram.class.derived] */
2167 static tree cp_parser_base_clause
2169 static tree cp_parser_base_specifier
2172 /* Special member functions [gram.special] */
2174 static tree cp_parser_conversion_function_id
2176 static tree cp_parser_conversion_type_id
2180 static bool cp_parser_ctor_initializer_opt
2182 static void cp_parser_mem_initializer_list
2184 static tree cp_parser_mem_initializer
2186 static tree cp_parser_mem_initializer_id
2189 /* Overloading [gram.over] */
2191 static tree cp_parser_operator_function_id
2193 static tree cp_parser_operator
2196 /* Templates [gram.temp] */
2198 static void cp_parser_template_declaration
2200 static tree cp_parser_template_parameter_list
2202 static tree cp_parser_template_parameter
2204 static tree cp_parser_type_parameter
2206 static tree cp_parser_template_id
2208 static tree cp_parser_template_name
2210 static tree cp_parser_template_argument_list
2212 static tree cp_parser_template_argument
2214 static void cp_parser_explicit_instantiation
2216 static void cp_parser_explicit_specialization
2219 /* Exception handling [gram.exception] */
2221 static tree cp_parser_try_block
2223 static bool cp_parser_function_try_block
2225 static void cp_parser_handler_seq
2227 static void cp_parser_handler
2229 static tree cp_parser_exception_declaration
2231 static tree cp_parser_throw_expression
2233 static tree cp_parser_exception_specification_opt
2235 static tree cp_parser_type_id_list
2238 /* GNU Extensions */
2240 static tree cp_parser_asm_specification_opt
2242 static tree cp_parser_asm_operand_list
2244 static tree cp_parser_asm_clobber_list
2246 static tree cp_parser_asm_label_list
2248 static bool cp_next_tokens_can_be_attribute_p
2250 static bool cp_next_tokens_can_be_gnu_attribute_p
2252 static bool cp_next_tokens_can_be_std_attribute_p
2254 static bool cp_nth_tokens_can_be_std_attribute_p
2256 static bool cp_nth_tokens_can_be_gnu_attribute_p
2258 static bool cp_nth_tokens_can_be_attribute_p
2260 static tree cp_parser_attributes_opt
2262 static tree cp_parser_gnu_attributes_opt
2264 static tree cp_parser_gnu_attribute_list
2266 static tree cp_parser_std_attribute
2268 static tree cp_parser_std_attribute_spec
2270 static tree cp_parser_std_attribute_spec_seq
2272 static bool cp_parser_extension_opt
2274 static void cp_parser_label_declaration
2277 /* Transactional Memory Extensions */
2279 static tree cp_parser_transaction
2281 static tree cp_parser_transaction_expression
2283 static bool cp_parser_function_transaction
2285 static tree cp_parser_transaction_cancel
2289 pragma_external,
2290 pragma_member,
2291 pragma_objc_icode,
2292 pragma_stmt,
2293 pragma_compound
2294 };
2295 static bool cp_parser_pragma
2298 /* Objective-C++ Productions */
2300 static tree cp_parser_objc_message_receiver
2302 static tree cp_parser_objc_message_args
2304 static tree cp_parser_objc_message_expression
2306 static tree cp_parser_objc_encode_expression
2308 static tree cp_parser_objc_defs_expression
2310 static tree cp_parser_objc_protocol_expression
2312 static tree cp_parser_objc_selector_expression
2314 static tree cp_parser_objc_expression
2316 static bool cp_parser_objc_selector_p
2318 static tree cp_parser_objc_selector
2320 static tree cp_parser_objc_protocol_refs_opt
2322 static void cp_parser_objc_declaration
2324 static tree cp_parser_objc_statement
2326 static bool cp_parser_objc_valid_prefix_attributes
2328 static void cp_parser_objc_at_property_declaration
2330 static void cp_parser_objc_at_synthesize_declaration
2332 static void cp_parser_objc_at_dynamic_declaration
2334 static tree cp_parser_objc_struct_declaration
2337 /* Utility Routines */
2339 static tree cp_parser_lookup_name
2341 static tree cp_parser_lookup_name_simple
2343 static tree cp_parser_maybe_treat_template_as_class
2345 static bool cp_parser_check_declarator_template_parameters
2347 static bool cp_parser_check_template_parameters
2349 static tree cp_parser_simple_cast_expression
2351 static tree cp_parser_global_scope_opt
2353 static bool cp_parser_constructor_declarator_p
2355 static tree cp_parser_function_definition_from_specifiers_and_declarator
2357 static tree cp_parser_function_definition_after_declarator
2359 static void cp_parser_template_declaration_after_export
2361 static void cp_parser_perform_template_parameter_access_checks
2363 static tree cp_parser_single_declaration
2365 static tree cp_parser_functional_cast
2367 static tree cp_parser_save_member_function_body
2369 static tree cp_parser_save_nsdmi
2371 static tree cp_parser_enclosed_template_argument_list
2373 static void cp_parser_save_default_args
2375 static void cp_parser_late_parsing_for_member
2377 static tree cp_parser_late_parse_one_default_arg
2379 static void cp_parser_late_parsing_nsdmi
2381 static void cp_parser_late_parsing_default_args
2383 static tree cp_parser_sizeof_operand
2385 static tree cp_parser_trait_expr
2387 static bool cp_parser_declares_only_class_p
2389 static void cp_parser_set_storage_class
2391 static void cp_parser_set_decl_spec_type
2393 static void set_and_check_decl_spec_loc
2396 static bool cp_parser_friend_p
2398 static void cp_parser_required_error
2404 static bool cp_parser_token_starts_function_definition_p
2406 static bool cp_parser_next_token_starts_class_definition_p
2408 static bool cp_parser_next_token_ends_template_argument_p
2410 static bool cp_parser_nth_token_starts_template_argument_list_p
2412 static enum tag_types cp_parser_token_is_class_key
2414 static enum tag_types cp_parser_token_is_type_parameter_key
2416 static void cp_parser_check_class_key
2418 static void cp_parser_check_access_in_redeclaration
2420 static bool cp_parser_optional_template_keyword
2422 static void cp_parser_pre_parsed_nested_name_specifier
2424 static bool cp_parser_cache_group
2426 static tree cp_parser_cache_defarg
2428 static void cp_parser_parse_tentatively
2430 static void cp_parser_commit_to_tentative_parse
2432 static void cp_parser_commit_to_topmost_tentative_parse
2434 static void cp_parser_abort_tentative_parse
2436 static bool cp_parser_parse_definitely
2440 static bool cp_parser_uncommitted_to_tentative_parse_p
2442 static void cp_parser_error
2444 static void cp_parser_name_lookup_error
2446 static bool cp_parser_simulate_error
2448 static bool cp_parser_check_type_definition
2450 static void cp_parser_check_for_definition_in_return_type
2452 static void cp_parser_check_for_invalid_template_id
2454 static bool cp_parser_non_integral_constant_expression
2456 static void cp_parser_diagnose_invalid_type_name
2458 static bool cp_parser_parse_and_diagnose_invalid_type_name
2460 static int cp_parser_skip_to_closing_parenthesis
2462 static void cp_parser_skip_to_end_of_statement
2464 static void cp_parser_consume_semicolon_at_end_of_statement
2466 static void cp_parser_skip_to_end_of_block_or_statement
2468 static bool cp_parser_skip_to_closing_brace
2470 static void cp_parser_skip_to_end_of_template_parameter_list
2472 static void cp_parser_skip_to_pragma_eol
2474 static bool cp_parser_error_occurred
2476 static bool cp_parser_allow_gnu_extensions_p
2478 static bool cp_parser_is_pure_string_literal
2480 static bool cp_parser_is_string_literal
2482 static bool cp_parser_is_keyword
2484 static tree cp_parser_make_typename_type
2488 static bool cp_parser_compound_literal_p
2491 /* Returns nonzero if we are parsing tentatively. */
2495 {
2497 }
2499 /* Returns nonzero if TOKEN is a string literal. */
2501 static bool
2503 {
2509 }
2511 /* Returns nonzero if TOKEN is a string literal
2512 of a user-defined string literal. */
2514 static bool
2516 {
2523 }
2525 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2527 static bool
2529 {
2531 }
2533 /* If not parsing tentatively, issue a diagnostic of the form
2534 FILE:LINE: MESSAGE before TOKEN
2535 where TOKEN is the next token in the input stream. MESSAGE
2536 (specified by the caller) is usually of the form "expected
2537 OTHER-TOKEN". */
2539 static void
2541 {
2543 {
2545 /* This diagnostic makes more sense if it is tagged to the line
2546 of the token we just peeked at. */
2550 {
2555 }
2558 /* Because c_parser_error does not understand
2559 CPP_KEYWORD, keywords are treated like
2560 identifiers. */
2563 }
2564 }
2566 /* Issue an error about name-lookup failing. NAME is the
2567 IDENTIFIER_NODE DECL is the result of
2568 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2569 the thing that we hoped to find. */
2571 static void
2573 tree name,
2574 tree decl,
2575 name_lookup_error desired,
2576 location_t location)
2577 {
2578 /* If name lookup completely failed, tell the user that NAME was not
2579 declared. */
2581 {
2594 else
2596 }
2598 {
2600 {
2617 }
2618 }
2620 {
2622 {
2632 name);
2636 }
2637 }
2638 else
2639 {
2641 {
2654 }
2655 }
2656 }
2658 /* If we are parsing tentatively, remember that an error has occurred
2659 during this tentative parse. Returns true if the error was
2660 simulated; false if a message should be issued by the caller. */
2662 static bool
2664 {
2666 {
2669 }
2671 }
2673 /* This function is called when a type is defined. If type
2674 definitions are forbidden at this point, an error message is
2675 issued. */
2677 static bool
2679 {
2680 /* If types are forbidden here, issue a message. */
2682 {
2683 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2684 in the message need to be interpreted. */
2687 }
2689 }
2691 /* This function is called when the DECLARATOR is processed. The TYPE
2692 was a type defined in the decl-specifiers. If it is invalid to
2693 define a type in the decl-specifiers for DECLARATOR, an error is
2694 issued. TYPE_LOCATION is the location of TYPE and is used
2695 for error reporting. */
2697 static void
2700 {
2701 /* [dcl.fct] forbids type definitions in return types.
2702 Unfortunately, it's not easy to know whether or not we are
2703 processing a return type until after the fact. */
2711 {
2716 type);
2717 }
2718 }
2720 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2721 "<" in any valid C++ program. If the next token is indeed "<",
2722 issue a message warning the user about what appears to be an
2723 invalid attempt to form a template-id. LOCATION is the location
2724 of the type-specifier (TYPE) */
2726 static void
2728 tree type,
2730 location_t location)
2731 {
2735 {
2739 {
2742 else
2744 }
2745 else
2747 /* Remember the location of the invalid "<". */
2750 /* Consume the "<". */
2752 /* Parse the template arguments. */
2754 /* Permanently remove the invalid template arguments so that
2755 this error message is not issued again. */
2758 }
2759 }
2761 /* If parsing an integral constant-expression, issue an error message
2762 about the fact that THING appeared and return true. Otherwise,
2763 return false. In either case, set
2764 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2766 static bool
2768 non_integral_constant thing)
2769 {
2772 {
2774 {
2777 {
2784 "enumeration type cannot appear in a "
2875 }
2879 }
2880 }
2882 }
2884 /* Emit a diagnostic for an invalid type name. This function commits
2885 to the current active tentative parse, if any. (Otherwise, the
2886 problematic construct might be encountered again later, resulting
2887 in duplicate error messages.) LOCATION is the location of ID. */
2889 static void
2891 location_t location)
2892 {
2895 /* Try to lookup the identifier. */
2902 /* If the lookup was ambiguous, an error will already have
2903 been issued. */
2905 /* If the lookup found a template-name, it means that the user forgot
2906 to specify an argument list. Emit a useful error message. */
2910 decl);
2914 /* Something like 'unsigned A a;' */
2917 {
2918 /* Issue an error message. */
2920 /* If we're in a template class, it's possible that the user was
2921 referring to a type from a base class. For example:
2923 template <typename T> struct A { typedef T X; };
2924 template <typename T> struct B : public A<T> { X x; };
2926 The user should have said "typename A<T>::X". */
2939 {
2940 tree b;
2943 b;
2945 {
2949 {
2950 tree field;
2951 /* Go from a particular instantiation of the
2952 template (which will have an empty TYPE_FIELDs),
2953 to the main version. */
2956 field;
2960 {
2965 }
2968 }
2969 }
2970 }
2971 }
2972 /* Here we diagnose qualified-ids where the scope is actually correct,
2973 but the identifier does not resolve to a valid type name. */
2975 {
2977 {
2982 else
2986 }
2989 {
2990 /* A<T>::A<T>() */
2996 }
3003 {
3008 else
3012 }
3013 else
3015 }
3016 }
3018 /* Check for a common situation where a type-name should be present,
3019 but is not, and issue a sensible error message. Returns true if an
3020 invalid type-name was detected.
3022 The situation handled by this function are variable declarations of the
3023 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3024 Usually, `ID' should name a type, but if we got here it means that it
3025 does not. We try to emit the best possible error message depending on
3026 how exactly the id-expression looks like. */
3028 static bool
3030 {
3031 tree id;
3034 /* Avoid duplicate error about ambiguous lookup. */
3036 {
3040 }
3049 /* If the next token is a (, this is a function with no explicit return
3050 type, i.e. constructor, destructor or conversion op. */
3053 {
3056 }
3060 /* Emit a diagnostic for the invalid type. */
3062 out:
3063 /* If we aren't in the middle of a declarator (i.e. in a
3064 parameter-declaration-clause), skip to the end of the declaration;
3065 there's no point in trying to process it. */
3069 }
3071 /* Consume tokens up to, and including, the next non-nested closing `)'.
3072 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3073 are doing error recovery. Returns -1 if OR_COMMA is true and we
3074 found an unnested comma. */
3076 static int
3081 {
3091 {
3095 {
3098 /* If we've run out of tokens, then there is no closing `)'. */
3101 /* This is good for lambda expression capture-lists. */
3111 /* This matches the processing in skip_to_end_of_statement. */
3137 {
3141 }
3146 }
3148 /* Consume the token. */
3150 }
3151 }
3153 /* Consume tokens until we reach the end of the current statement.
3154 Normally, that will be just before consuming a `;'. However, if a
3155 non-nested `}' comes first, then we stop before consuming that. */
3157 static void
3159 {
3162 /* Unwind generic function template scope if necessary. */
3167 {
3171 {
3174 /* If we've run out of tokens, stop. */
3178 /* If the next token is a `;', we have reached the end of the
3179 statement. */
3185 /* If this is a non-nested '}', stop before consuming it.
3186 That way, when confronted with something like:
3188 { 3 + }
3190 we stop before consuming the closing '}', even though we
3191 have not yet reached a `;'. */
3195 /* If it is the closing '}' for a block that we have
3196 scanned, stop -- but only after consuming the token.
3197 That way given:
3199 void f g () { ... }
3200 typedef int I;
3202 we will stop after the body of the erroneously declared
3203 function, but before consuming the following `typedef'
3204 declaration. */
3206 {
3209 }
3217 }
3219 /* Consume the token. */
3221 }
3222 }
3224 /* This function is called at the end of a statement or declaration.
3225 If the next token is a semicolon, it is consumed; otherwise, error
3226 recovery is attempted. */
3228 static void
3230 {
3231 /* Look for the trailing `;'. */
3233 {
3234 /* If there is additional (erroneous) input, skip to the end of
3235 the statement. */
3237 /* If the next token is now a `;', consume it. */
3240 }
3241 }
3243 /* Skip tokens until we have consumed an entire block, or until we
3244 have consumed a non-nested `;'. */
3246 static void
3248 {
3251 /* Unwind generic function template scope if necessary. */
3256 {
3260 {
3263 /* If we've run out of tokens, stop. */
3267 /* Stop if this is an unnested ';'. */
3273 /* Stop if this is an unnested '}', or closes the outermost
3274 nesting level. */
3275 nesting_depth--;
3283 /* Nest. */
3284 nesting_depth++;
3289 }
3291 /* Consume the token. */
3293 }
3294 }
3296 /* Skip tokens until a non-nested closing curly brace is the next
3297 token, or there are no more tokens. Return true in the first case,
3298 false otherwise. */
3300 static bool
3302 {
3306 {
3310 {
3313 /* If we've run out of tokens, stop. */
3317 /* If the next token is a non-nested `}', then we have reached
3318 the end of the current block. */
3324 /* If it the next token is a `{', then we are entering a new
3325 block. Consume the entire block. */
3331 }
3333 /* Consume the token. */
3335 }
3336 }
3338 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3339 parameter is the PRAGMA token, allowing us to purge the entire pragma
3340 sequence. */
3342 static void
3344 {
3349 do
3353 /* Ensure that the pragma is not parsed again. */
3355 }
3357 /* Require pragma end of line, resyncing with it as necessary. The
3358 arguments are as for cp_parser_skip_to_pragma_eol. */
3360 static void
3362 {
3366 }
3368 /* This is a simple wrapper around make_typename_type. When the id is
3369 an unresolved identifier node, we can provide a superior diagnostic
3370 using cp_parser_diagnose_invalid_type_name. */
3372 static tree
3374 location_t id_location)
3375 {
3376 tree result;
3378 {
3384 }
3386 }
3388 /* This is a wrapper around the
3389 make_{pointer,ptrmem,reference}_declarator functions that decides
3390 which one to call based on the CODE and CLASS_TYPE arguments. The
3391 CODE argument should be one of the values returned by
3392 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3393 appertain to the pointer or reference. */
3397 cp_cv_quals cv_qualifiers,
3399 tree attributes)
3400 {
3407 else
3417 }
3419 /* Create a new C++ parser. */
3423 {
3428 /* cp_lexer_new_main is called before doing GC allocation because
3429 cp_lexer_new_main might load a PCH file. */
3432 /* Initialize the binops_by_token so that we can get the tree
3433 directly from the token. */
3441 /* For now, we always accept GNU extensions. */
3444 /* The `>' token is a greater-than operator, not the end of a
3445 template-id. */
3450 /* We are not parsing a constant-expression. */
3455 /* Local variable names are not forbidden. */
3458 /* We are not processing an `extern "C"' declaration. */
3461 /* We are not processing a declarator. */
3464 /* We are not processing a template-argument-list. */
3467 /* We are not in an iteration statement. */
3470 /* We are not in a switch statement. */
3473 /* We are not parsing a type-id inside an expression. */
3476 /* Declarations aren't implicitly extern "C". */
3479 /* String literals should be translated to the execution character set. */
3482 /* We are not parsing a function body. */
3485 /* We can correct until told otherwise. */
3488 /* The unparsed function queue is empty. */
3491 /* There are no classes being defined. */
3494 /* No template parameters apply. */
3497 /* Not declaring an implicit function template. */
3504 }
3506 /* Create a cp_lexer structure which will emit the tokens in CACHE
3507 and push it onto the parser's lexer stack. This is used for delayed
3508 parsing of in-class method bodies and default arguments, and should
3509 not be confused with tentative parsing. */
3510 static void
3512 {
3517 /* Move the current source position to that of the first token in the
3518 new lexer. */
3520 }
3522 /* Pop the top lexer off the parser stack. This is never used for the
3523 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3524 static void
3526 {
3531 /* Put the current source position back where it was before this
3532 lexer was pushed. */
3534 }
3536 /* Lexical conventions [gram.lex] */
3538 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3539 identifier. */
3541 static tree
3543 {
3546 /* Look for the identifier. */
3548 /* Return the value. */
3550 }
3552 /* Parse a sequence of adjacent string constants. Returns a
3553 TREE_STRING representing the combined, nul-terminated string
3554 constant. If TRANSLATE is true, translate the string to the
3555 execution character set. If WIDE_OK is true, a wide string is
3556 invalid here.
3558 C++98 [lex.string] says that if a narrow string literal token is
3559 adjacent to a wide string literal token, the behavior is undefined.
3560 However, C99 6.4.5p4 says that this results in a wide string literal.
3561 We follow C99 here, for consistency with the C front end.
3563 This code is largely lifted from lex_string() in c-lex.c.
3565 FUTURE: ObjC++ will need to handle @-strings here. */
3566 static tree
3569 {
3570 tree value;
3577 tree string_tree;
3583 {
3586 }
3589 {
3593 }
3594 else
3595 {
3598 }
3601 /* Try to avoid the overhead of creating and destroying an obstack
3602 for the common case of just one string. */
3605 {
3613 {
3617 }
3618 else
3622 }
3623 else
3624 {
3628 do
3629 {
3631 count++;
3636 {
3639 {
3642 }
3645 {
3650 }
3652 }
3653 else
3657 {
3662 "unsupported non-standard concatenation "
3664 }
3670 {
3674 }
3675 else
3676 {
3680 }
3681 }
3685 }
3688 {
3691 }
3695 {
3700 {
3715 }
3720 {
3725 else
3727 }
3728 }
3729 else
3730 /* cpp_interpret_string has issued an error. */
3737 }
3739 /* Look up a literal operator with the name and the exact arguments. */
3741 static tree
3743 {
3750 {
3756 {
3759 {
3769 }
3772 /* May be this should be sufficient_parms_p instead,
3773 depending on how exactly should user-defined literals
3774 work in presence of default arguments on the literal
3775 operator parameters. */
3778 }
3779 }
3782 }
3784 /* Parse a user-defined char constant. Returns a call to a user-defined
3785 literal operator taking the character as an argument. */
3787 static tree
3789 {
3797 /* Build up a call to the user-defined operator */
3798 /* Lookup the name we got back from the id-expression. */
3803 {
3808 }
3817 }
3819 /* A subroutine of cp_parser_userdef_numeric_literal to
3820 create a char... template parameter pack from a string node. */
3822 static tree
3824 {
3825 tree charvec;
3831 /* Fill in CHARVEC with all of the parameters. */
3836 /* Build the argument packs. */
3843 }
3845 /* A subroutine of cp_parser_userdef_numeric_literal to
3846 create a char... template parameter pack from a string node. */
3848 static tree
3850 {
3851 tree charvec;
3862 /* First template parm is character type. */
3865 /* Fill in CHARVEC with all of the parameters. */
3872 /* Build the argument packs. */
3879 }
3881 /* Parse a user-defined numeric constant. returns a call to a user-defined
3882 literal operator. */
3884 static tree
3886 {
3897 /* Look for a literal operator taking the exact type of numeric argument
3898 as the literal value. */
3903 {
3906 {
3910 long_long_unsigned_type_node);
3911 else
3912 {
3916 long_double_type_node);
3920 }
3923 }
3924 }
3927 /* If the numeric argument didn't work, look for a raw literal
3928 operator taking a const char* argument consisting of the number
3929 in string format. */
3934 {
3937 {
3940 }
3941 }
3944 /* If the raw literal didn't work, look for a non-type template
3945 function with parameter pack char.... Call the function with
3946 template parameter characters representing the number. */
3950 {
3955 {
3958 }
3959 }
3967 }
3969 /* Parse a user-defined string constant. Returns a call to a user-defined
3970 literal operator taking a character pointer and the length of the string
3971 as arguments. */
3973 static tree
3975 {
3984 /* Look for a template function with typename parameter CharT
3985 and parameter pack CharT... Call the function with
3986 template parameter characters representing the string. */
3990 {
3995 {
3998 }
3999 }
4002 /* Build up a call to the user-defined operator */
4003 /* Lookup the name we got back from the id-expression. */
4009 {
4013 }
4022 }
4025 /* Basic concepts [gram.basic] */
4027 /* Parse a translation-unit.
4029 translation-unit:
4030 declaration-seq [opt]
4032 Returns TRUE if all went well. */
4034 static bool
4036 {
4037 /* The address of the first non-permanent object on the declarator
4038 obstack. */
4043 /* Create the declarator obstack, if necessary. */
4045 {
4047 /* Create the error declarator. */
4049 /* Create the empty parameter list. */
4051 /* Remember where the base of the declarator obstack lies. */
4053 }
4057 /* If there are no tokens left then all went well. */
4059 {
4060 /* Get rid of the token array; we don't need it any more. */
4064 /* This file might have been a context that's implicitly extern
4065 "C". If so, pop the lang context. (Only relevant for PCH.) */
4067 {
4070 }
4072 /* Finish up. */
4076 }
4077 else
4078 {
4081 }
4083 /* Make sure the declarator obstack was fully cleaned up. */
4087 /* All went well. */
4089 }
4091 /* Return the appropriate tsubst flags for parsing, possibly in N3276
4092 decltype context. */
4096 {
4101 }
4103 /* Expressions [gram.expr] */
4105 /* Parse a primary-expression.
4107 primary-expression:
4108 literal
4109 this
4110 ( expression )
4111 id-expression
4112 lambda-expression (C++11)
4114 GNU Extensions:
4116 primary-expression:
4117 ( compound-statement )
4118 __builtin_va_arg ( assignment-expression , type-id )
4119 __builtin_offsetof ( type-id , offsetof-expression )
4121 C++ Extensions:
4122 __has_nothrow_assign ( type-id )
4123 __has_nothrow_constructor ( type-id )
4124 __has_nothrow_copy ( type-id )
4125 __has_trivial_assign ( type-id )
4126 __has_trivial_constructor ( type-id )
4127 __has_trivial_copy ( type-id )
4128 __has_trivial_destructor ( type-id )
4129 __has_virtual_destructor ( type-id )
4130 __is_abstract ( type-id )
4131 __is_base_of ( type-id , type-id )
4132 __is_class ( type-id )
4133 __is_convertible_to ( type-id , type-id )
4134 __is_empty ( type-id )
4135 __is_enum ( type-id )
4136 __is_final ( type-id )
4137 __is_literal_type ( type-id )
4138 __is_pod ( type-id )
4139 __is_polymorphic ( type-id )
4140 __is_std_layout ( type-id )
4141 __is_trivial ( type-id )
4142 __is_union ( type-id )
4144 Objective-C++ Extension:
4146 primary-expression:
4147 objc-expression
4149 literal:
4150 __null
4152 ADDRESS_P is true iff this expression was immediately preceded by
4153 "&" and therefore might denote a pointer-to-member. CAST_P is true
4154 iff this expression is the target of a cast. TEMPLATE_ARG_P is
4155 true iff this expression is a template argument.
4157 Returns a representation of the expression. Upon return, *IDK
4158 indicates what kind of id-expression (if any) was present. */
4160 static tree
4167 {
4170 /* Assume the primary expression is not an id-expression. */
4173 /* Peek at the next token. */
4176 {
4177 /* literal:
4178 integer-literal
4179 character-literal
4180 floating-literal
4181 string-literal
4182 boolean-literal
4183 pointer-literal
4184 user-defined-literal */
4194 {
4198 }
4199 /* Floating-point literals are only allowed in an integral
4200 constant expression if they are cast to an integral or
4201 enumeration type. */
4205 {
4206 /* CAST_P will be set even in invalid code like "int(2.7 +
4207 ...)". Therefore, we have to check that the next token
4208 is sure to end the cast. */
4210 {
4215 enumerator-definition. */
4217 /* The curly brace at the end of an enum-specifier. */
4219 /* The end of a statement. */
4221 /* The end of the cast-expression. */
4223 /* The end of an array bound. */
4225 /* The closing ">" in a template-argument-list. */
4228 /* C++0x only: A ">>" treated like two ">" tokens,
4229 in a template-argument-list. */
4234 }
4236 /* If we are within a cast, then the constraint that the
4237 cast is to an integral or enumeration type will be
4238 checked at that point. If we are not within a cast, then
4239 this code is invalid. */
4242 }
4261 /* ??? Should wide strings be allowed when parser->translate_strings_p
4262 is false (i.e. in attributes)? If not, we can kill the third
4263 argument to cp_parser_string_literal. */
4269 {
4270 tree expr;
4273 /* Consume the `('. */
4275 /* Within a parenthesized expression, a `>' token is always
4276 the greater-than operator. */
4277 saved_greater_than_is_operator_p
4280 /* If we see `( { ' then we are looking at the beginning of
4281 a GNU statement-expression. */
4284 {
4285 /* Statement-expressions are not allowed by the standard. */
4289 /* And they're not allowed outside of a function-body; you
4290 cannot, for example, write:
4292 int i = ({ int j = 3; j + 1; });
4294 at class or namespace scope. */
4297 {
4299 "statement-expressions are not allowed outside "
4303 }
4304 else
4305 {
4306 /* Start the statement-expression. */
4308 /* Parse the compound-statement. */
4310 /* Finish up. */
4312 }
4313 }
4314 else
4315 {
4316 /* Parse the parenthesized expression. */
4318 /* Let the front end know that this expression was
4319 enclosed in parentheses. This matters in case, for
4320 example, the expression is of the form `A::B', since
4321 `&A::B' might be a pointer-to-member, but `&(A::B)' is
4322 not. */
4324 /* DR 705: Wrapping an unqualified name in parentheses
4325 suppresses arg-dependent lookup. We want to pass back
4326 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4327 (c++/37862), but none of the others. */
4330 }
4331 /* The `>' token might be the end of a template-id or
4332 template-parameter-list now. */
4333 parser->greater_than_is_operator_p
4335 /* Consume the `)'. */
4340 }
4344 /* We have an Objective-C++ message. */
4346 {
4348 /* Don't warn about a failed tentative parse. */
4353 }
4357 /* We have an Objective-C++ string literal. */
4364 {
4365 /* These two are the boolean literals. */
4373 /* The `__null' literal. */
4378 /* The `nullptr' literal. */
4383 /* Recognize the `this' keyword. */
4387 {
4391 }
4392 /* Pointers cannot appear in constant-expressions. */
4397 /* The `operator' keyword can be the beginning of an
4398 id-expression. */
4405 {
4406 non_integral_constant name;
4408 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4409 __func__ are the names of variables -- but they are
4410 treated specially. Therefore, they are handled here,
4411 rather than relying on the generic id-expression logic
4412 below. Grammatically, these names are id-expressions.
4414 Consume the token. */
4418 {
4430 }
4435 /* Look up the name. */
4437 }
4440 {
4441 tree expression;
4442 tree type;
4443 source_location type_location;
4445 /* The `__builtin_va_arg' construct is used to handle
4446 `va_arg'. Consume the `__builtin_va_arg' token. */
4448 /* Look for the opening `('. */
4450 /* Now, parse the assignment-expression. */
4453 /* Look for the `,'. */
4456 /* Parse the type-id. */
4458 /* Look for the closing `)'. */
4460 /* Using `va_arg' in a constant-expression is not
4461 allowed. */
4463 NIC_VA_ARG))
4466 }
4494 /* Objective-C++ expressions. */
4504 {
4509 }
4513 }
4515 /* An id-expression can start with either an identifier, a
4516 `::' as the beginning of a qualified-id, or the "operator"
4517 keyword. */
4522 {
4523 tree id_expression;
4524 tree decl;
4530 id_expression:
4531 /* Parse the id-expression. */
4532 id_expression
4549 /* If we have a template-id, then no further lookup is
4550 required. If the template-id was for a template-class, we
4551 will sometimes have a TYPE_DECL at this point. */
4555 /* Look up the name. */
4556 else
4557 {
4558 tree ambiguous_decls;
4560 /* If we already know that this lookup is ambiguous, then
4561 we've already issued an error message; there's no reason
4562 to check again. */
4565 {
4568 }
4571 none_type,
4572 template_p,
4577 /* If the lookup was ambiguous, an error will already have
4578 been issued. */
4582 /* In Objective-C++, we may have an Objective-C 2.0
4583 dot-syntax for classes here. */
4588 {
4589 tree component;
4596 }
4598 /* In Objective-C++, an instance variable (ivar) may be preferred
4599 to whatever cp_parser_lookup_name() found. */
4602 /* If name lookup gives us a SCOPE_REF, then the
4603 qualifying scope was dependent. */
4605 {
4606 /* At this point, we do not know if DECL is a valid
4607 integral constant expression. We assume that it is
4608 in fact such an expression, so that code like:
4610 template <int N> struct A {
4611 int a[B<N>::i];
4612 };
4614 is accepted. At template-instantiation time, we
4615 will check that B<N>::i is actually a constant. */
4617 }
4618 /* Check to see if DECL is a local variable in a context
4619 where that is forbidden. */
4622 {
4623 /* It might be that we only found DECL because we are
4624 trying to be generous with pre-ISO scoping rules.
4625 For example, consider:
4627 int i;
4628 void g() {
4629 for (int i = 0; i < 10; ++i) {}
4630 extern void f(int j = i);
4631 }
4633 Here, name look up will originally find the out
4634 of scope `i'. We need to issue a warning message,
4635 but then use the global `i'. */
4638 {
4641 decl);
4643 }
4644 }
4645 }
4647 decl = (finish_id_expression
4649 idk,
4654 template_arg_p,
4660 }
4662 /* Anything else is an error. */
4666 }
4667 }
4675 {
4678 }
4680 /* Parse an id-expression.
4682 id-expression:
4683 unqualified-id
4684 qualified-id
4686 qualified-id:
4687 :: [opt] nested-name-specifier template [opt] unqualified-id
4688 :: identifier
4689 :: operator-function-id
4690 :: template-id
4692 Return a representation of the unqualified portion of the
4693 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
4694 a `::' or nested-name-specifier.
4696 Often, if the id-expression was a qualified-id, the caller will
4697 want to make a SCOPE_REF to represent the qualified-id. This
4698 function does not do this in order to avoid wastefully creating
4699 SCOPE_REFs when they are not required.
4701 If TEMPLATE_KEYWORD_P is true, then we have just seen the
4702 `template' keyword.
4704 If CHECK_DEPENDENCY_P is false, then names are looked up inside
4705 uninstantiated templates.
4707 If *TEMPLATE_P is non-NULL, it is set to true iff the
4708 `template' keyword is used to explicitly indicate that the entity
4709 named is a template.
4711 If DECLARATOR_P is true, the id-expression is appearing as part of
4712 a declarator, rather than as part of an expression. */
4714 static tree
4721 {
4725 /* Assume the `template' keyword was not used. */
4729 /* Look for the optional `::' operator. */
4730 global_scope_p
4733 /* Look for the optional nested-name-specifier. */
4734 nested_name_specifier_p
4737 check_dependency_p,
4739 declarator_p)
4741 /* If there is a nested-name-specifier, then we are looking at
4742 the first qualified-id production. */
4744 {
4745 tree saved_scope;
4746 tree saved_object_scope;
4747 tree saved_qualifying_scope;
4748 tree unqualified_id;
4751 /* See if the next token is the `template' keyword. */
4755 /* Name lookup we do during the processing of the
4756 unqualified-id might obliterate SCOPE. */
4760 /* Process the final unqualified-id. */
4762 check_dependency_p,
4763 declarator_p,
4765 /* Restore the SAVED_SCOPE for our caller. */
4771 }
4772 /* Otherwise, if we are in global scope, then we are looking at one
4773 of the other qualified-id productions. */
4775 {
4777 tree id;
4779 /* Peek at the next token. */
4782 /* If it's an identifier, and the next token is not a "<", then
4783 we can avoid the template-id case. This is an optimization
4784 for this common case. */
4786 && !cp_parser_nth_token_starts_template_argument_list_p
4791 /* Try a template-id. */
4795 none_type,
4796 declarator_p);
4797 /* If that worked, we're done. */
4801 /* Peek at the next token. (Changes in the token buffer may
4802 have invalidated the pointer obtained above.) */
4806 {
4813 /* Fall through. */
4818 }
4819 }
4820 else
4823 declarator_p,
4824 optional_p);
4825 }
4827 /* Parse an unqualified-id.
4829 unqualified-id:
4830 identifier
4831 operator-function-id
4832 conversion-function-id
4833 ~ class-name
4834 template-id
4836 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
4837 keyword, in a construct like `A::template ...'.
4839 Returns a representation of unqualified-id. For the `identifier'
4840 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
4841 production a BIT_NOT_EXPR is returned; the operand of the
4842 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
4843 other productions, see the documentation accompanying the
4844 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
4845 names are looked up in uninstantiated templates. If DECLARATOR_P
4846 is true, the unqualified-id is appearing as part of a declarator,
4847 rather than as part of an expression. */
4849 static tree
4855 {
4858 /* Peek at the next token. */
4862 {
4864 {
4865 tree id;
4867 /* We don't know yet whether or not this will be a
4868 template-id. */
4870 /* Try a template-id. */
4872 check_dependency_p,
4873 none_type,
4874 declarator_p);
4875 /* If it worked, we're done. */
4878 /* Otherwise, it's an ordinary identifier. */
4880 }
4884 check_dependency_p,
4885 none_type,
4886 declarator_p);
4889 {
4890 tree type_decl;
4891 tree qualifying_scope;
4892 tree object_scope;
4893 tree scope;
4896 /* Consume the `~' token. */
4898 /* Parse the class-name. The standard, as written, seems to
4899 say that:
4901 template <typename T> struct S { ~S (); };
4902 template <typename T> S<T>::~S() {}
4904 is invalid, since `~' must be followed by a class-name, but
4905 `S<T>' is dependent, and so not known to be a class.
4906 That's not right; we need to look in uninstantiated
4907 templates. A further complication arises from:
4909 template <typename T> void f(T t) {
4910 t.T::~T();
4911 }
4913 Here, it is not possible to look up `T' in the scope of `T'
4914 itself. We must look in both the current scope, and the
4915 scope of the containing complete expression.
4917 Yet another issue is:
4919 struct S {
4920 int S;
4921 ~S();
4922 };
4924 S::~S() {}
4926 The standard does not seem to say that the `S' in `~S'
4927 should refer to the type `S' and not the data member
4928 `S::S'. */
4930 /* DR 244 says that we look up the name after the "~" in the
4931 same scope as we looked up the qualifying name. That idea
4932 isn't fully worked out; it's more complicated than that. */
4937 /* Check for invalid scopes. */
4939 {
4943 }
4945 {
4949 scope);
4954 }
4957 /* If the name is of the form "X::~X" it's OK even if X is a
4958 typedef. */
4967 {
4970 }
4972 /* ~auto means the destructor of whatever the object is. */
4974 {
4977 "%<~auto%> only available with "
4981 }
4983 /* If there was an explicit qualification (S::~T), first look
4984 in the scope given by the qualification (i.e., S).
4986 Note: in the calls to cp_parser_class_name below we pass
4987 typename_type so that lookup finds the injected-class-name
4988 rather than the constructor. */
4992 {
4997 typename_type,
5000 declarator_p);
5003 }
5004 /* In "N::S::~S", look in "N" as well. */
5006 {
5011 type_decl
5015 typename_type,
5018 declarator_p);
5021 }
5022 /* In "p->S::~T", look in the scope given by "*p" as well. */
5024 {
5029 type_decl
5033 typename_type,
5036 declarator_p);
5039 }
5040 /* Look in the surrounding context. */
5042 {
5048 type_decl
5052 typename_type,
5055 declarator_p);
5058 {
5059 /* We couldn't find a type with this name, so just accept
5060 it and check for a match at instantiation time. */
5065 }
5066 }
5067 /* If an error occurred, assume that the name of the
5068 destructor is the same as the name of the qualifying
5069 class. That allows us to keep parsing after running
5070 into ill-formed destructor names. */
5076 /* Check that destructor name and scope match. */
5078 {
5085 }
5087 /* [class.dtor]
5089 A typedef-name that names a class shall not be used as the
5090 identifier in the declarator for a destructor declaration. */
5097 type_decl);
5100 }
5104 {
5105 tree id;
5107 /* This could be a template-id, so we try that first. */
5109 /* Try a template-id. */
5112 none_type,
5113 declarator_p);
5114 /* If that worked, we're done. */
5117 /* We still don't know whether we're looking at an
5118 operator-function-id or a conversion-function-id. */
5120 /* Try an operator-function-id. */
5122 /* If that didn't work, try a conversion-function-id. */
5126 {
5127 /* 17.6.3.3.5 */
5133 }
5136 }
5137 /* Fall through. */
5144 }
5145 }
5147 /* Parse an (optional) nested-name-specifier.
5149 nested-name-specifier: [C++98]
5150 class-or-namespace-name :: nested-name-specifier [opt]
5151 class-or-namespace-name :: template nested-name-specifier [opt]
5153 nested-name-specifier: [C++0x]
5154 type-name ::
5155 namespace-name ::
5156 nested-name-specifier identifier ::
5157 nested-name-specifier template [opt] simple-template-id ::
5159 PARSER->SCOPE should be set appropriately before this function is
5160 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
5161 effect. TYPE_P is TRUE if we non-type bindings should be ignored
5162 in name lookups.
5164 Sets PARSER->SCOPE to the class (TYPE) or namespace
5165 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
5166 it unchanged if there is no nested-name-specifier. Returns the new
5167 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
5169 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
5170 part of a declaration and/or decl-specifier. */
5172 static tree
5178 {
5183 /* Remember where the nested-name-specifier starts. */
5185 {
5188 }
5191 {
5192 tree new_scope;
5193 tree old_scope;
5194 tree saved_qualifying_scope;
5197 /* Spot cases that cannot be the beginning of a
5198 nested-name-specifier. */
5201 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
5202 the already parsed nested-name-specifier. */
5204 {
5205 /* Grab the nested-name-specifier and continue the loop. */
5207 /* If we originally encountered this nested-name-specifier
5208 with IS_DECLARATION set to false, we will not have
5209 resolved TYPENAME_TYPEs, so we must do so here. */
5212 {
5217 }
5220 }
5222 /* Spot cases that cannot be the beginning of a
5223 nested-name-specifier. On the second and subsequent times
5224 through the loop, we look for the `template' keyword. */
5226 ;
5227 /* A template-id can start a nested-name-specifier. */
5229 ;
5230 /* DR 743: decltype can be used in a nested-name-specifier. */
5232 ;
5233 else
5234 {
5235 /* If the next token is not an identifier, then it is
5236 definitely not a type-name or namespace-name. */
5239 /* If the following token is neither a `<' (to begin a
5240 template-id), nor a `::', then we are not looking at a
5241 nested-name-specifier. */
5247 {
5251 }
5254 && !cp_parser_nth_token_starts_template_argument_list_p
5257 }
5259 /* The nested-name-specifier is optional, so we parse
5260 tentatively. */
5263 /* Look for the optional `template' keyword, if this isn't the
5264 first time through the loop. */
5267 else
5270 /* Save the old scope since the name lookup we are about to do
5271 might destroy it. */
5274 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
5275 look up names in "X<T>::I" in order to determine that "Y" is
5276 a template. So, if we have a typename at this point, we make
5277 an effort to look through it. */
5279 && !typename_keyword_p
5284 /* Parse the qualifying entity. */
5285 new_scope
5287 typename_keyword_p,
5288 template_keyword_p,
5289 check_dependency_p,
5290 type_p,
5291 is_declaration);
5292 /* Look for the `::' token. */
5295 /* If we found what we wanted, we keep going; otherwise, we're
5296 done. */
5298 {
5301 /* Restore the OLD_SCOPE since it was valid before the
5302 failed attempt at finding the last
5303 class-or-namespace-name. */
5307 /* If the next token is a decltype, and the one after that is a
5308 `::', then the decltype has failed to resolve to a class or
5309 enumeration type. Give this error even when parsing
5310 tentatively since it can't possibly be valid--and we're going
5311 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
5312 won't get another chance.*/
5316 {
5323 /* As below. */
5326 }
5330 /* If the next token is an identifier, and the one after
5331 that is a `::', then any valid interpretation would have
5332 found a class-or-namespace-name. */
5338 {
5341 {
5343 {
5344 tree decl;
5345 tree ambiguous_decls;
5348 none_type,
5357 decl);
5359 {
5360 // cp_parser_lookup_name has the same diagnostic,
5361 // thus make sure to emit it at most once.
5364 {
5369 }
5371 }
5372 else
5373 {
5375 cp_parser_name_lookup_error
5378 else
5379 cp_parser_name_lookup_error
5382 }
5383 }
5386 /* Treat this as a successful nested-name-specifier
5387 due to:
5389 [basic.lookup.qual]
5391 If the name found is not a class-name (clause
5392 _class_) or namespace-name (_namespace.def_), the
5393 program is ill-formed. */
5395 }
5397 }
5399 }
5400 /* We've found one valid nested-name-specifier. */
5402 /* Name lookup always gives us a DECL. */
5405 /* Uses of "template" must be followed by actual templates. */
5417 new_scope);
5418 /* If it is a class scope, try to complete it; we are about to
5419 be looking up names inside the class. */
5421 /* Since checking types for dependency can be expensive,
5422 avoid doing it if the type is already complete. */
5424 /* Do not try to complete dependent types. */
5426 {
5428 /* If it is a typedef to current class, use the current
5429 class instead, as the typedef won't have any names inside
5430 it yet. */
5434 }
5435 /* Make sure we look in the right scope the next time through
5436 the loop. */
5438 }
5440 /* If parsing tentatively, replace the sequence of tokens that makes
5441 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
5442 token. That way, should we re-parse the token stream, we will
5443 not have to repeat the effort required to do the parse, nor will
5444 we issue duplicate error messages. */
5446 {
5450 /* Reset the contents of the START token. */
5452 /* Retrieve any deferred checks. Do not pop this access checks yet
5453 so the memory will not be reclaimed during token replacing below. */
5461 /* Purge all subsequent tokens. */
5463 }
5469 }
5471 /* Parse a nested-name-specifier. See
5472 cp_parser_nested_name_specifier_opt for details. This function
5473 behaves identically, except that it will an issue an error if no
5474 nested-name-specifier is present. */
5476 static tree
5482 {
5483 tree scope;
5485 /* Look for the nested-name-specifier. */
5487 typename_keyword_p,
5488 check_dependency_p,
5489 type_p,
5490 is_declaration);
5491 /* If it was not present, issue an error message. */
5493 {
5496 }
5499 }
5501 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
5502 this is either a class-name or a namespace-name (which corresponds
5503 to the class-or-namespace-name production in the grammar). For
5504 C++0x, it can also be a type-name that refers to an enumeration
5505 type or a simple-template-id.
5507 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
5508 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
5509 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
5510 TYPE_P is TRUE iff the next name should be taken as a class-name,
5511 even the same name is declared to be another entity in the same
5512 scope.
5514 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
5515 specified by the class-or-namespace-name. If neither is found the
5516 ERROR_MARK_NODE is returned. */
5518 static tree
5525 {
5526 tree saved_scope;
5527 tree saved_qualifying_scope;
5528 tree saved_object_scope;
5529 tree scope;
5533 /* DR 743: decltype can appear in a nested-name-specifier. */
5535 {
5539 {
5542 }
5546 }
5548 /* Before we try to parse the class-name, we must save away the
5549 current PARSER->SCOPE since cp_parser_class_name will destroy
5550 it. */
5554 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
5555 there is no need to look for a namespace-name. */
5556 only_class_p = template_keyword_p
5561 typename_keyword_p,
5562 template_keyword_p,
5564 check_dependency_p,
5566 is_declaration);
5568 /* If that didn't work and we're in C++0x mode, try for a type-name. */
5572 {
5573 /* Restore the saved scope. */
5578 /* Parse tentatively. */
5581 /* Parse a type-name */
5584 /* "If the name found does not designate a namespace or a class,
5585 enumeration, or dependent type, the program is ill-formed."
5587 We cover classes and dependent types above and namespaces below,
5588 so this code is only looking for enums. */
5594 }
5595 /* If that didn't work, try for a namespace-name. */
5597 {
5598 /* Restore the saved scope. */
5602 /* If we are not looking at an identifier followed by the scope
5603 resolution operator, then this is not part of a
5604 nested-name-specifier. (Note that this function is only used
5605 to parse the components of a nested-name-specifier.) */
5610 }
5613 }
5615 /* Return true if we are looking at a compound-literal, false otherwise. */
5617 static bool
5619 {
5620 /* Consume the `('. */
5625 /* Skip tokens until the next token is a closing parenthesis.
5626 If we find the closing `)', and the next token is a `{', then
5627 we are looking at a compound-literal. */
5628 bool compound_literal_p
5633 /* Roll back the tokens we skipped. */
5637 }
5639 /* Parse a postfix-expression.
5641 postfix-expression:
5642 primary-expression
5643 postfix-expression [ expression ]
5644 postfix-expression ( expression-list [opt] )
5645 simple-type-specifier ( expression-list [opt] )
5646 typename :: [opt] nested-name-specifier identifier
5647 ( expression-list [opt] )
5648 typename :: [opt] nested-name-specifier template [opt] template-id
5649 ( expression-list [opt] )
5650 postfix-expression . template [opt] id-expression
5651 postfix-expression -> template [opt] id-expression
5652 postfix-expression . pseudo-destructor-name
5653 postfix-expression -> pseudo-destructor-name
5654 postfix-expression ++
5655 postfix-expression --
5656 dynamic_cast < type-id > ( expression )
5657 static_cast < type-id > ( expression )
5658 reinterpret_cast < type-id > ( expression )
5659 const_cast < type-id > ( expression )
5660 typeid ( expression )
5661 typeid ( type-id )
5663 GNU Extension:
5665 postfix-expression:
5666 ( type-id ) { initializer-list , [opt] }
5668 This extension is a GNU version of the C99 compound-literal
5669 construct. (The C99 grammar uses `type-name' instead of `type-id',
5670 but they are essentially the same concept.)
5672 If ADDRESS_P is true, the postfix expression is the operand of the
5673 `&' operator. CAST_P is true if this expression is the target of a
5674 cast.
5676 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
5677 class member access expressions [expr.ref].
5679 Returns a representation of the expression. */
5681 static tree
5685 {
5687 location_t loc;
5694 /* Peek at the next token. */
5697 /* Some of the productions are determined by keywords. */
5700 {
5705 {
5706 tree type;
5707 tree expression;
5711 /* All of these can be handled in the same way from the point
5712 of view of parsing. Begin by consuming the token
5713 identifying the cast. */
5716 /* New types cannot be defined in the cast. */
5718 parser->type_definition_forbidden_message
5721 /* Look for the opening `<'. */
5723 /* Parse the type to which we are casting. */
5728 /* Look for the closing `>'. */
5730 /* Restore the old message. */
5733 bool saved_greater_than_is_operator_p
5737 /* And the expression which is being cast. */
5742 parser->greater_than_is_operator_p
5745 /* Only type conversions to integral or enumeration types
5746 can be used in constant-expressions. */
5752 {
5754 postfix_expression
5758 postfix_expression
5762 postfix_expression
5764 tf_warning_or_error);
5767 postfix_expression
5772 }
5773 }
5777 {
5778 tree type;
5782 /* Consume the `typeid' token. */
5784 /* Look for the `(' token. */
5786 /* Types cannot be defined in a `typeid' expression. */
5788 parser->type_definition_forbidden_message
5790 /* We can't be sure yet whether we're looking at a type-id or an
5791 expression. */
5793 /* Try a type-id first. */
5798 /* Look for the `)' token. Otherwise, we can't be sure that
5799 we're not looking at an expression: consider `typeid (int
5800 (3))', for example. */
5802 /* If all went well, simply lookup the type-id. */
5805 /* Otherwise, fall back to the expression variant. */
5806 else
5807 {
5808 tree expression;
5810 /* Look for an expression. */
5812 /* Compute its typeid. */
5814 /* Look for the `)' token. */
5816 }
5817 /* Restore the saved message. */
5819 /* `typeid' may not appear in an integral constant expression. */
5822 }
5826 {
5827 tree type;
5828 /* The syntax permitted here is the same permitted for an
5829 elaborated-type-specifier. */
5834 }
5838 {
5842 {
5847 }
5849 {
5854 }
5855 else
5856 {
5857 /* Consecutive _Cilk_spawns are not allowed in a statement. */
5860 }
5862 postfix_expression =
5866 {
5870 }
5872 {
5877 }
5878 else
5879 {
5881 postfix_expression);
5885 }
5887 }
5890 {
5893 tree p;
5907 tf_warning_or_error);
5910 tf_warning_or_error);
5911 else
5912 {
5916 }
5918 }
5921 {
5922 tree type;
5924 /* If the next thing is a simple-type-specifier, we may be
5925 looking at a functional cast. We could also be looking at
5926 an id-expression. So, we try the functional cast, and if
5927 that doesn't work we fall back to the primary-expression. */
5929 /* Look for the simple-type-specifier. */
5932 CP_PARSER_FLAGS_NONE);
5933 /* Parse the cast itself. */
5935 postfix_expression
5937 /* If that worked, we're done. */
5941 /* If the functional-cast didn't work out, try a
5942 compound-literal. */
5945 {
5950 /* Avoid calling cp_parser_type_id pointlessly, see comment
5951 in cp_parser_cast_expression about c++/29234. */
5954 else
5955 {
5956 /* Parse the type. */
5961 /* Look for the `)'. */
5963 }
5965 /* If things aren't going well, there's no need to
5966 keep going. */
5968 {
5970 /* Parse the brace-enclosed initializer list. */
5973 }
5974 /* If that worked, we're definitely looking at a
5975 compound-literal expression. */
5977 {
5978 /* Warn the user that a compound literal is not
5979 allowed in standard C++. */
5982 /* For simplicity, we disallow compound literals in
5983 constant-expressions. We could
5984 allow compound literals of integer type, whose
5985 initializer was a constant, in constant
5986 expressions. Permitting that usage, as a further
5987 extension, would not change the meaning of any
5988 currently accepted programs. (Of course, as
5989 compound literals are not part of ISO C++, the
5990 standard has nothing to say.) */
5992 NIC_NCC))
5993 {
5996 }
5997 /* Form the representation of the compound-literal. */
5998 postfix_expression
6000 tf_warning_or_error);
6002 }
6003 }
6005 /* It must be a primary-expression. */
6006 postfix_expression
6009 decltype_p,
6011 }
6013 }
6015 /* Note that we don't need to worry about calling build_cplus_new on a
6016 class-valued CALL_EXPR in decltype when it isn't the end of the
6017 postfix-expression; unary_complex_lvalue will take care of that for
6018 all these cases. */
6020 /* Keep looping until the postfix-expression is complete. */
6022 {
6026 /* It is not a Koenig lookup function call. */
6027 postfix_expression
6030 /* Peek at the next token. */
6034 {
6037 {
6039 "two consecutive %<[%> shall "
6042 }
6043 postfix_expression
6045 postfix_expression,
6047 decltype_p);
6053 /* postfix-expression ( expression-list [opt] ) */
6054 {
6064 is_builtin_constant_p
6067 {
6068 /* The whole point of __builtin_constant_p is to allow
6069 non-constant expressions to appear as arguments. */
6070 saved_integral_constant_expression_p
6072 saved_non_integral_constant_expression_p
6075 }
6076 args = (cp_parser_parenthesized_expression_list
6082 {
6083 parser->integral_constant_expression_p
6085 parser->non_integral_constant_expression_p
6087 }
6090 {
6093 }
6095 /* Function calls are not permitted in
6096 constant-expressions. */
6099 NIC_FUNC_CALL))
6100 {
6104 }
6109 {
6111 {
6113 {
6116 postfix_expression
6118 complain);
6119 }
6120 else
6121 postfix_expression
6123 }
6124 /* We do not perform argument-dependent lookup if
6125 normal lookup finds a non-function, in accordance
6126 with the expected resolution of DR 218. */
6129 {
6133 /* Do not do argument dependent lookup if regular
6134 lookup finds a member function or a block-scope
6135 function declaration. [basic.lookup.argdep]/3 */
6138 {
6141 postfix_expression
6143 complain);
6144 }
6145 }
6146 }
6149 {
6159 "%<memset%> used with constant zero length "
6160 "parameter; this could be due to transposed "
6163 /* Replace LITERAL_ZERO_P INTEGER_CSTs with normal ones
6164 to avoid leaking those into folder and middle-end. */
6166 tree arg;
6170 }
6173 {
6183 {
6184 postfix_expression
6188 }
6191 {
6192 postfix_expression
6193 = (build_new_method_call
6199 complain));
6200 }
6201 else
6202 postfix_expression
6206 complain);
6207 }
6211 postfix_expression = (build_offset_ref_call_from_tree
6213 complain));
6215 /* A call to a static class member, or a namespace-scope
6216 function. */
6217 postfix_expression
6220 koenig_p,
6221 complain);
6222 else
6223 /* All other function calls. */
6224 postfix_expression
6227 koenig_p,
6228 complain);
6230 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
6234 }
6239 /* postfix-expression . template [opt] id-expression
6240 postfix-expression . pseudo-destructor-name
6241 postfix-expression -> template [opt] id-expression
6242 postfix-expression -> pseudo-destructor-name */
6244 /* Consume the `.' or `->' operator. */
6247 postfix_expression
6249 postfix_expression,
6256 /* postfix-expression ++ */
6257 /* Consume the `++' token. */
6259 /* Generate a representation for the complete expression. */
6260 postfix_expression
6262 POSTINCREMENT_EXPR);
6263 /* Increments may not appear in constant-expressions. */
6271 /* postfix-expression -- */
6272 /* Consume the `--' token. */
6274 /* Generate a representation for the complete expression. */
6275 postfix_expression
6277 POSTDECREMENT_EXPR);
6278 /* Decrements may not appear in constant-expressions. */
6290 else
6292 }
6293 }
6295 /* We should never get here. */
6298 }
6300 /* This function parses Cilk Plus array notations. If a normal array expr. is
6301 parsed then the array index is passed back to the caller through *INIT_INDEX
6302 and the function returns a NULL_TREE. If array notation expr. is parsed,
6303 then *INIT_INDEX is ignored by the caller and the function returns
6304 a tree of type ARRAY_NOTATION_REF. If some error occurred it returns
6305 error_mark_node. */
6307 static tree
6309 tree array_value)
6310 {
6314 {
6317 }
6326 {
6329 }
6331 {
6332 /* Consume the ':'. */
6335 /* If we are here, then we have a case like this A[:]. */
6337 {
6341 }
6345 }
6346 else
6347 {
6348 /* If we are here, then there are three valid possibilities:
6349 1. ARRAY [ EXP ]
6350 2. ARRAY [ EXP : EXP ]
6351 3. ARRAY [ EXP : EXP : EXP ] */
6355 {
6356 /* This indicates that we have a normal array expression. */
6359 }
6361 /* Consume the ':'. */
6365 {
6368 }
6369 }
6374 {
6378 }
6384 }
6386 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6387 by cp_parser_builtin_offsetof. We're looking for
6389 postfix-expression [ expression ]
6390 postfix-expression [ braced-init-list ] (C++11)
6392 FOR_OFFSETOF is set if we're being called in that context, which
6393 changes how we deal with integer constant expressions. */
6395 static tree
6397 tree postfix_expression,
6400 {
6405 /* Consume the `[' token. */
6411 /* Parse the index expression. */
6412 /* ??? For offsetof, there is a question of what to allow here. If
6413 offsetof is not being used in an integral constant expression context,
6414 then we *could* get the right answer by computing the value at runtime.
6415 If we are in an integral constant expression context, then we might
6416 could accept any constant expression; hard to say without analysis.
6417 Rather than open the barn door too wide right away, allow only integer
6418 constant expressions here. */
6421 else
6422 {
6424 {
6431 {
6433 "braced list index is not allowed with array "
6437 }
6438 }
6440 {
6441 /* Here are have these two options:
6442 ARRAY[EXP : EXP] - Array notation expr with default
6443 stride of 1.
6444 ARRAY[EXP : EXP : EXP] - Array Notation with user-defined
6445 stride. */
6447 postfix_expression);
6450 }
6451 else
6453 }
6457 /* Look for the closing `]'. */
6460 /* Build the ARRAY_REF. */
6464 /* When not doing offsetof, array references are not permitted in
6465 constant-expressions. */
6471 }
6473 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6474 by cp_parser_builtin_offsetof. We're looking for
6476 postfix-expression . template [opt] id-expression
6477 postfix-expression . pseudo-destructor-name
6478 postfix-expression -> template [opt] id-expression
6479 postfix-expression -> pseudo-destructor-name
6481 FOR_OFFSETOF is set if we're being called in that context. That sorta
6482 limits what of the above we'll actually accept, but nevermind.
6483 TOKEN_TYPE is the "." or "->" token, which will already have been
6484 removed from the stream. */
6486 static tree
6489 tree postfix_expression,
6491 location_t location)
6492 {
6493 tree name;
6498 /* If this is a `->' operator, dereference the pointer. */
6501 tf_warning_or_error);
6502 /* Check to see whether or not the expression is type-dependent. */
6504 /* The identifier following the `->' or `.' is not qualified. */
6510 /* Enter the scope corresponding to the type of the object
6511 given by the POSTFIX_EXPRESSION. */
6513 {
6515 /* According to the standard, no expression should ever have
6516 reference type. Unfortunately, we do not currently match
6517 the standard in this respect in that our internal representation
6518 of an expression may have reference type even when the standard
6519 says it does not. Therefore, we have to manually obtain the
6520 underlying type here. */
6522 /* The type of the POSTFIX_EXPRESSION must be complete. */
6524 {
6526 postfix_expression);
6528 }
6529 /* Unlike the object expression in other contexts, *this is not
6530 required to be of complete type for purposes of class member
6531 access (5.2.5) outside the member function body. */
6535 /* Let the name lookup machinery know that we are processing a
6536 class member access expression. */
6538 /* If something went wrong, we want to be able to discern that case,
6539 as opposed to the case where there was no SCOPE due to the type
6540 of expression being dependent. */
6543 /* If the SCOPE was erroneous, make the various semantic analysis
6544 functions exit quickly -- and without issuing additional error
6545 messages. */
6548 }
6550 /* Assume this expression is not a pseudo-destructor access. */
6553 /* If the SCOPE is a scalar type, then, if this is a valid program,
6554 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
6555 is type dependent, it can be pseudo-destructor-name or something else.
6556 Try to parse it as pseudo-destructor-name first. */
6558 {
6559 tree s;
6560 tree type;
6563 /* Parse the pseudo-destructor-name. */
6572 {
6574 postfix_expression
6577 }
6578 }
6581 {
6582 /* If the SCOPE is not a scalar type, we are looking at an
6583 ordinary class member access expression, rather than a
6584 pseudo-destructor-name. */
6587 /* Parse the id-expression. */
6588 name = (cp_parser_id_expression
6595 /* In general, build a SCOPE_REF if the member name is qualified.
6596 However, if the name was not dependent and has already been
6597 resolved; there is no need to build the SCOPE_REF. For example;
6599 struct X { void f(); };
6600 template <typename T> void f(T* t) { t->X::f(); }
6602 Even though "t" is dependent, "X::f" is not and has been resolved
6603 to a BASELINK; there is no need to include scope information. */
6605 /* But we do need to remember that there was an explicit scope for
6606 virtual function calls. */
6610 /* If the name is a template-id that names a type, we will get a
6611 TYPE_DECL here. That is invalid code. */
6613 {
6616 }
6617 else
6618 {
6620 {
6622 {
6626 }
6627 else
6630 name,
6631 template_p);
6635 }
6637 adjust_result_of_qualified_name_lookup
6639 postfix_expression
6641 template_p,
6642 tf_warning_or_error);
6643 }
6644 }
6646 /* We no longer need to look up names in the scope of the object on
6647 the left-hand side of the `.' or `->' operator. */
6650 /* Outside of offsetof, these operators may not appear in
6651 constant-expressions. */
6653 && (cp_parser_non_integral_constant_expression
6658 }
6660 /* Cache of LITERAL_ZERO_P constants. */
6664 /* Parse a parenthesized expression-list.
6666 expression-list:
6667 assignment-expression
6668 expression-list, assignment-expression
6670 attribute-list:
6671 expression-list
6672 identifier
6673 identifier, expression-list
6675 CAST_P is true if this expression is the target of a cast.
6677 ALLOW_EXPANSION_P is true if this expression allows expansion of an
6678 argument pack.
6680 Returns a vector of trees. Each element is a representation of an
6681 assignment-expression. NULL is returned if the ( and or ) are
6682 missing. An empty, but allocated, vector is returned on no
6683 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
6684 if we are parsing an attribute list for an attribute that wants a
6685 plain identifier argument, normal_attr for an attribute that wants
6686 an expression, or non_attr if we aren't parsing an attribute list. If
6687 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
6688 not all of the expressions in the list were constant.
6689 WANT_LITERAL_ZERO_P is true if the caller is interested in
6690 LITERAL_ZERO_P INTEGER_CSTs. FIXME: once we don't fold everything
6691 immediately, this can be removed. */
6700 {
6706 /* Assume all the expressions will be constant. */
6715 /* Within a parenthesized expression, a `>' token is always
6716 the greater-than operator. */
6717 saved_greater_than_is_operator_p
6721 /* Consume expressions until there are no more. */
6724 {
6725 tree expr;
6727 /* At the beginning of attribute lists, check to see if the
6728 next token is an identifier. */
6731 {
6734 /* Consume the identifier. */
6736 /* Save the identifier. */
6738 }
6739 else
6740 {
6743 /* Parse the next assignment-expression. */
6745 {
6746 /* A braced-init-list. */
6752 }
6754 {
6755 expr = (cp_parser_constant_expression
6760 }
6761 else
6762 {
6766 {
6772 /* If a parameter is literal zero alone, remember it
6773 for -Wmemset-transposed-args warning. */
6776 && want_literal_zero_p
6778 == CPP_COMMA
6781 {
6788 else
6789 {
6794 }
6795 /* Consume the 0 token (or '\0', 0LL etc.). */
6797 }
6801 }
6804 NULL);
6805 }
6810 /* If we have an ellipsis, then this is an expression
6811 expansion. */
6814 {
6815 /* Consume the `...'. */
6818 /* Build the argument pack. */
6820 }
6822 /* Add it to the list. We add error_mark_node
6823 expressions to the list, so that we can still tell if
6824 the correct form for a parenthesized expression-list
6825 is found. That gives better errors. */
6830 }
6832 /* After the first item, attribute lists look the same as
6833 expression lists. */
6836 get_comma:;
6837 /* If the next token isn't a `,', then we are done. */
6841 /* Otherwise, consume the `,' and keep going. */
6843 }
6846 {
6849 skip_comma:;
6850 /* We try and resync to an unnested comma, as that will give the
6851 user better diagnostics. */
6859 {
6860 parser->greater_than_is_operator_p
6863 }
6864 }
6866 parser->greater_than_is_operator_p
6873 }
6875 /* Parse a pseudo-destructor-name.
6877 pseudo-destructor-name:
6878 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
6879 :: [opt] nested-name-specifier template template-id :: ~ type-name
6880 :: [opt] nested-name-specifier [opt] ~ type-name
6882 If either of the first two productions is used, sets *SCOPE to the
6883 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
6884 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
6885 or ERROR_MARK_NODE if the parse fails. */
6887 static void
6889 tree object,
6892 {
6895 /* Handle ~auto. */
6899 {
6902 "%<~auto%> only available with "
6909 }
6911 /* Assume that things will not work out. */
6914 /* Look for the optional `::' operator. */
6916 /* Look for the optional nested-name-specifier. */
6917 nested_name_specifier_p
6924 /* Now, if we saw a nested-name-specifier, we might be doing the
6925 second production. */
6928 {
6929 /* Consume the `template' keyword. */
6931 /* Parse the template-id. */
6935 class_type,
6937 /* Look for the `::' token. */
6939 }
6940 /* If the next token is not a `~', then there might be some
6941 additional qualification. */
6943 {
6944 /* At this point, we're looking for "type-name :: ~". The type-name
6945 must not be a class-name, since this is a pseudo-destructor. So,
6946 it must be either an enum-name, or a typedef-name -- both of which
6947 are just identifiers. So, we peek ahead to check that the "::"
6948 and "~" tokens are present; if they are not, then we can avoid
6949 calling type_name. */
6953 {
6956 }
6958 /* Look for the type-name. */
6963 /* Look for the `::' token. */
6965 }
6966 else
6969 /* Look for the `~'. */
6972 /* Once we see the ~, this has to be a pseudo-destructor. */
6976 /* Look for the type-name again. We are not responsible for
6977 checking that it matches the first type-name. */
6979 }
6981 /* Parse a unary-expression.
6983 unary-expression:
6984 postfix-expression
6985 ++ cast-expression
6986 -- cast-expression
6987 unary-operator cast-expression
6988 sizeof unary-expression
6989 sizeof ( type-id )
6990 alignof ( type-id ) [C++0x]
6991 new-expression
6992 delete-expression
6994 GNU Extensions:
6996 unary-expression:
6997 __extension__ cast-expression
6998 __alignof__ unary-expression
6999 __alignof__ ( type-id )
7000 alignof unary-expression [C++0x]
7001 __real__ cast-expression
7002 __imag__ cast-expression
7003 && identifier
7004 sizeof ( type-id ) { initializer-list , [opt] }
7005 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
7006 __alignof__ ( type-id ) { initializer-list , [opt] }
7008 ADDRESS_P is true iff the unary-expression is appearing as the
7009 operand of the `&' operator. CAST_P is true if this expression is
7010 the target of a cast.
7012 Returns a representation of the expression. */
7014 static tree
7017 {
7021 /* Peek at the next token. */
7023 /* Some keywords give away the kind of expression. */
7025 {
7029 {
7032 {
7035 location_t first_loc;
7038 /* Consume the token. */
7041 /* Parse the operand. */
7046 else
7047 {
7048 /* ISO C++ defines alignof only with types, not with
7049 expressions. So pedwarn if alignof is used with a non-
7050 type expression. However, __alignof__ is ok. */
7053 "ISO C++ does not allow %<alignof%> "
7057 }
7058 /* For SIZEOF_EXPR, just issue diagnostics, but keep
7059 SIZEOF_EXPR with the original operand. */
7061 {
7063 {
7065 {
7068 error_mark_node));
7070 }
7071 else
7075 }
7077 }
7079 }
7088 {
7089 /* The saved value of the PEDANTIC flag. */
7091 tree expr;
7093 /* Save away the PEDANTIC flag. */
7095 /* Parse the cast-expression. */
7097 /* Restore the PEDANTIC flag. */
7101 }
7105 {
7106 tree expression;
7108 /* Consume the `__real__' or `__imag__' token. */
7110 /* Parse the cast-expression. */
7112 /* Create the complete representation. */
7116 expression,
7117 tf_warning_or_error);
7118 }
7126 {
7127 tree expr;
7137 parser->type_definition_forbidden_message
7140 saved_integral_constant_expression_p
7142 saved_non_integral_constant_expression_p
7146 saved_greater_than_is_operator_p
7156 parser->greater_than_is_operator_p
7159 parser->integral_constant_expression_p
7161 parser->non_integral_constant_expression_p
7168 }
7172 }
7173 }
7175 /* Look for the `:: new' and `:: delete', which also signal the
7176 beginning of a new-expression, or delete-expression,
7177 respectively. If the next token is `::', then it might be one of
7178 these. */
7180 {
7183 /* See if the token after the `::' is one of the keywords in
7184 which we're interested. */
7186 /* If it's `new', we have a new-expression. */
7189 /* Similarly, for `delete'. */
7192 }
7194 /* Look for a unary operator. */
7196 /* The `++' and `--' operators can be handled similarly, even though
7197 they are not technically unary-operators in the grammar. */
7199 {
7204 /* Handle the GNU address-of-label extension. */
7207 {
7208 tree identifier;
7209 tree expression;
7212 /* Consume the '&&' token. */
7214 /* Look for the identifier. */
7216 /* Create an expression representing the address. */
7219 NIC_ADDR_LABEL))
7222 }
7223 }
7225 {
7226 tree cast_expression;
7232 /* Consume the operator token. */
7234 /* Parse the cast-expression. */
7235 cast_expression
7240 pidk);
7241 /* Now, build an appropriate representation. */
7243 {
7247 RO_UNARY_STAR,
7248 complain);
7253 /* Fall through. */
7256 cast_expression,
7257 complain);
7264 /* Fall through. */
7274 }
7278 non_constant_p))
7282 }
7286 decltype_p,
7287 pidk);
7288 }
7293 {
7296 }
7298 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
7299 unary-operator, the corresponding tree code is returned. */
7301 static enum tree_code
7303 {
7305 {
7326 }
7327 }
7329 /* Parse a new-expression.
7331 new-expression:
7332 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
7333 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
7335 Returns a representation of the expression. */
7337 static tree
7339 {
7342 tree type;
7345 tree ret;
7347 /* Look for the optional `::' operator. */
7348 global_scope_p
7352 /* Look for the `new' operator. */
7354 /* There's no easy way to tell a new-placement from the
7355 `( type-id )' construct. */
7357 /* Look for a new-placement. */
7359 /* If that didn't work out, there's no new-placement. */
7361 {
7365 }
7367 /* If the next token is a `(', then we have a parenthesized
7368 type-id. */
7370 {
7374 /* Consume the `('. */
7377 /* Parse the type-id. */
7378 parser->type_definition_forbidden_message
7383 /* Look for the closing `)'. */
7386 /* There should not be a direct-new-declarator in this production,
7387 but GCC used to allowed this, so we check and emit a sensible error
7388 message for this case. */
7390 {
7396 }
7397 }
7398 /* Otherwise, there must be a new-type-id. */
7399 else
7402 /* If the next token is a `(' or '{', then we have a new-initializer. */
7406 else
7409 /* A new-expression may not appear in an integral constant
7410 expression. */
7413 else
7414 {
7415 /* Create a representation of the new-expression. */
7417 tf_warning_or_error);
7418 }
7426 }
7428 /* Parse a new-placement.
7430 new-placement:
7431 ( expression-list )
7433 Returns the same representation as for an expression-list. */
7437 {
7440 /* Parse the expression-list. */
7441 expression_list = (cp_parser_parenthesized_expression_list
7447 }
7449 /* Parse a new-type-id.
7451 new-type-id:
7452 type-specifier-seq new-declarator [opt]
7454 Returns the TYPE allocated. If the new-type-id indicates an array
7455 type, *NELTS is set to the number of elements in the last array
7456 bound; the TYPE will not include the last array bound. */
7458 static tree
7460 {
7461 cp_decl_specifier_seq type_specifier_seq;
7467 /* The type-specifier sequence must not contain type definitions.
7468 (It cannot contain declarations of new types either, but if they
7469 are not definitions we will catch that because they are not
7470 complete.) */
7472 parser->type_definition_forbidden_message
7474 /* Parse the type-specifier-seq. */
7478 /* Restore the old message. */
7484 /* Parse the new-declarator. */
7487 /* Determine the number of elements in the last array dimension, if
7488 any. */
7490 /* Skip down to the last array dimension. */
7495 {
7498 }
7503 {
7506 }
7509 {
7516 else
7518 }
7521 }
7523 /* Parse an (optional) new-declarator.
7525 new-declarator:
7526 ptr-operator new-declarator [opt]
7527 direct-new-declarator
7529 Returns the declarator. */
7533 {
7536 cp_cv_quals cv_quals;
7538 /* We don't know if there's a ptr-operator next, or not. */
7540 /* Look for a ptr-operator. */
7542 /* If that worked, look for more new-declarators. */
7544 {
7547 /* Parse another optional declarator. */
7550 declarator = cp_parser_make_indirect_declarator
7554 }
7556 /* If the next token is a `[', there is a direct-new-declarator. */
7561 }
7563 /* Parse a direct-new-declarator.
7565 direct-new-declarator:
7566 [ expression ]
7567 direct-new-declarator [constant-expression]
7569 */
7573 {
7577 {
7578 tree expression;
7581 /* Look for the opening `['. */
7586 /* The standard requires that the expression have integral
7587 type. DR 74 adds enumeration types. We believe that the
7588 real intent is that these expressions be handled like the
7589 expression in a `switch' condition, which also allows
7590 classes with a single conversion to integral or
7591 enumeration type. */
7593 {
7594 expression
7596 expression,
7599 {
7601 "expression in new-declarator must have integral "
7604 }
7605 }
7607 /* Look for the closing `]'. */
7610 /* Add this bound to the declarator. */
7613 /* If the next token is not a `[', then there are no more
7614 bounds. */
7617 }
7620 }
7622 /* Parse a new-initializer.
7624 new-initializer:
7625 ( expression-list [opt] )
7626 braced-init-list
7628 Returns a representation of the expression-list. */
7632 {
7636 {
7637 tree t;
7644 }
7645 else
7646 expression_list = (cp_parser_parenthesized_expression_list
7652 }
7654 /* Parse a delete-expression.
7656 delete-expression:
7657 :: [opt] delete cast-expression
7658 :: [opt] delete [ ] cast-expression
7660 Returns a representation of the expression. */
7662 static tree
7664 {
7667 tree expression;
7669 /* Look for the optional `::' operator. */
7670 global_scope_p
7674 /* Look for the `delete' keyword. */
7676 /* See if the array syntax is in use. */
7678 {
7679 /* Consume the `[' token. */
7681 /* Look for the `]' token. */
7683 /* Remember that this is the `[]' construct. */
7685 }
7686 else
7689 /* Parse the cast-expression. */
7692 /* A delete-expression may not appear in an integral constant
7693 expression. */
7698 tf_warning_or_error);
7699 }
7701 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
7702 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
7703 0 otherwise. */
7705 static int
7707 {
7710 {
7752 /* In ((type ()) () the last () isn't a valid cast-expression,
7753 so the whole must be parsed as postfix-expression. */
7758 /* '[' may start a primary-expression in obj-c++ and in C++11,
7759 as a lambda-expression, eg, '(void)[]{}'. */
7766 /* '++' and '--' may or may not start a cast-expression:
7768 struct T { void operator++(int); };
7769 void f() { (T())++; }
7771 vs
7773 int a;
7774 (int)++a; */
7779 }
7780 }
7782 /* Parse a cast-expression.
7784 cast-expression:
7785 unary-expression
7786 ( type-id ) cast-expression
7788 ADDRESS_P is true iff the unary-expression is appearing as the
7789 operand of the `&' operator. CAST_P is true if this expression is
7790 the target of a cast.
7792 Returns a representation of the expression. */
7794 static tree
7797 {
7798 /* If it's a `(', then we might be looking at a cast. */
7800 {
7806 /* There's no way to know yet whether or not this is a cast.
7807 For example, `(int (3))' is a unary-expression, while `(int)
7808 3' is a cast. So, we resort to parsing tentatively. */
7810 /* Types may not be defined in a cast. */
7812 parser->type_definition_forbidden_message
7814 /* Consume the `('. */
7816 /* A very tricky bit is that `(struct S) { 3 }' is a
7817 compound-literal (which we permit in C++ as an extension).
7818 But, that construct is not a cast-expression -- it is a
7819 postfix-expression. (The reason is that `(struct S) { 3 }.i'
7820 is legal; if the compound-literal were a cast-expression,
7821 you'd need an extra set of parentheses.) But, if we parse
7822 the type-id, and it happens to be a class-specifier, then we
7823 will commit to the parse at that point, because we cannot
7824 undo the action that is done when creating a new class. So,
7825 then we cannot back up and do a postfix-expression.
7827 Another tricky case is the following (c++/29234):
7829 struct S { void operator () (); };
7831 void foo ()
7832 {
7833 ( S()() );
7834 }
7836 As a type-id we parse the parenthesized S()() as a function
7837 returning a function, groktypename complains and we cannot
7838 back up in this case either.
7840 Therefore, we scan ahead to the closing `)', and check to see
7841 if the tokens after the `)' can start a cast-expression. Otherwise
7842 we are dealing with an unary-expression, a postfix-expression
7843 or something else.
7845 Yet another tricky case, in C++11, is the following (c++/54891):
7847 (void)[]{};
7849 The issue is that usually, besides the case of lambda-expressions,
7850 the parenthesized type-id cannot be followed by '[', and, eg, we
7851 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
7852 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
7853 we don't commit, we try a cast-expression, then an unary-expression.
7855 Save tokens so that we can put them back. */
7858 /* We may be looking at a cast-expression. */
7861 cast_expression
7864 /* Roll back the tokens we skipped. */
7866 /* If we aren't looking at a cast-expression, simulate an error so
7867 that the call to cp_parser_error_occurred below returns true. */
7870 else
7871 {
7874 /* Look for the type-id. */
7876 /* Look for the closing `)'. */
7879 }
7881 /* Restore the saved message. */
7884 /* At this point this can only be either a cast or a
7885 parenthesized ctor such as `(T ())' that looks like a cast to
7886 function returning T. */
7888 {
7889 /* Only commit if the cast-expression doesn't start with
7890 '++', '--', or '[' in C++11. */
7898 pidk);
7901 {
7902 /* Warn about old-style casts, if so requested. */
7909 /* Only type conversions to integral or enumeration types
7910 can be used in constant-expressions. */
7913 NIC_CAST))
7916 /* Perform the cast. */
7919 }
7920 }
7921 else
7923 }
7925 /* If we get here, then it's not a cast, so it must be a
7926 unary-expression. */
7929 }
7931 /* Parse a binary expression of the general form:
7933 pm-expression:
7934 cast-expression
7935 pm-expression .* cast-expression
7936 pm-expression ->* cast-expression
7938 multiplicative-expression:
7939 pm-expression
7940 multiplicative-expression * pm-expression
7941 multiplicative-expression / pm-expression
7942 multiplicative-expression % pm-expression
7944 additive-expression:
7945 multiplicative-expression
7946 additive-expression + multiplicative-expression
7947 additive-expression - multiplicative-expression
7949 shift-expression:
7950 additive-expression
7951 shift-expression << additive-expression
7952 shift-expression >> additive-expression
7954 relational-expression:
7955 shift-expression
7956 relational-expression < shift-expression
7957 relational-expression > shift-expression
7958 relational-expression <= shift-expression
7959 relational-expression >= shift-expression
7961 GNU Extension:
7963 relational-expression:
7964 relational-expression <? shift-expression
7965 relational-expression >? shift-expression
7967 equality-expression:
7968 relational-expression
7969 equality-expression == relational-expression
7970 equality-expression != relational-expression
7972 and-expression:
7973 equality-expression
7974 and-expression & equality-expression
7976 exclusive-or-expression:
7977 and-expression
7978 exclusive-or-expression ^ and-expression
7980 inclusive-or-expression:
7981 exclusive-or-expression
7982 inclusive-or-expression | exclusive-or-expression
7984 logical-and-expression:
7985 inclusive-or-expression
7986 logical-and-expression && inclusive-or-expression
7988 logical-or-expression:
7989 logical-and-expression
7990 logical-or-expression || logical-and-expression
7992 All these are implemented with a single function like:
7994 binary-expression:
7995 simple-cast-expression
7996 binary-expression <token> binary-expression
7998 CAST_P is true if this expression is the target of a cast.
8000 The binops_by_token map is used to get the tree codes for each <token> type.
8001 binary-expressions are associated according to a precedence table. */
8003 #define TOKEN_PRECEDENCE(token) \
8004 (((token->type == CPP_GREATER \
8005 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
8006 && !parser->greater_than_is_operator_p) \
8007 ? PREC_NOT_OPERATOR \
8008 : binops_by_token[token->type].prec)
8010 static tree
8016 {
8017 cp_parser_expression_stack stack;
8019 cp_parser_expression_stack_entry current;
8020 tree rhs;
8024 tree overload;
8026 /* Parse the first expression. */
8037 {
8038 /* Get an operator token. */
8044 {
8046 "%<>>%> operator is treated"
8050 }
8054 /* Popping an entry off the stack means we completed a subexpression:
8055 - either we found a token which is not an operator (`>' where it is not
8056 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
8057 will happen repeatedly;
8058 - or, we found an operator which has lower priority. This is the case
8059 where the recursive descent *ascends*, as in `3 * 4 + 5' after
8060 parsing `3 * 4'. */
8062 {
8065 else
8067 }
8069 get_rhs:
8073 /* We used the operator token. */
8076 /* For "false && x" or "true || x", x will never be executed;
8077 disable warnings while evaluating it. */
8083 /* Extract another operand. It may be the RHS of this expression
8084 or the LHS of a new, higher priority expression. */
8089 /* Get another operator token. Look up its precedence to avoid
8090 building a useless (immediately popped) stack entry for common
8091 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
8095 {
8096 /* ... and prepare to parse the RHS of the new, higher priority
8097 expression. Since precedence levels on the stack are
8098 monotonically increasing, we do not have to care about
8099 stack overflows. */
8108 pop:
8110 /* If the stack is not empty, we have parsed into LHS the right side
8111 (`4' in the example above) of an expression we had suspended.
8112 We can use the information on the stack to recover the LHS (`3')
8113 from the stack together with the tree code (`MULT_EXPR'), and
8114 the precedence of the higher level subexpression
8115 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
8116 which will be used to actually build the additive expression. */
8121 }
8123 /* Undo the disabling of warnings done above. */
8134 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
8135 ERROR_MARK for everything that is not a binary expression.
8136 This makes warn_about_parentheses miss some warnings that
8137 involve unary operators. For unary expressions we should
8138 pass the correct tree_code unless the unary expression was
8139 surrounded by parentheses.
8140 */
8146 == tcc_comparison
8149 else
8158 /* If the binary operator required the use of an overloaded operator,
8159 then this expression cannot be an integral constant-expression.
8160 An overloaded operator can be used even if both operands are
8161 otherwise permissible in an integral constant-expression if at
8162 least one of the operands is of enumeration type. */
8166 NIC_OVERLOADED))
8168 }
8171 }
8173 static tree
8178 {
8181 }
8183 /* Parse the `? expression : assignment-expression' part of a
8184 conditional-expression. The LOGICAL_OR_EXPR is the
8185 logical-or-expression that started the conditional-expression.
8186 Returns a representation of the entire conditional-expression.
8188 This routine is used by cp_parser_assignment_expression.
8190 ? expression : assignment-expression
8192 GNU Extensions:
8194 ? : assignment-expression */
8196 static tree
8198 {
8199 tree expr;
8200 tree assignment_expr;
8204 /* Consume the `?' token. */
8209 {
8212 /* Implicit true clause. */
8216 }
8217 else
8218 {
8221 /* Parse the expression. */
8224 c_inhibit_evaluation_warnings +=
8228 }
8230 /* The next token should be a `:'. */
8232 /* Parse the assignment-expression. */
8236 /* Build the conditional-expression. */
8238 expr,
8239 assignment_expr,
8240 tf_warning_or_error);
8241 }
8243 /* Parse an assignment-expression.
8245 assignment-expression:
8246 conditional-expression
8247 logical-or-expression assignment-operator assignment_expression
8248 throw-expression
8250 CAST_P is true if this expression is the target of a cast.
8251 DECLTYPE_P is true if this expression is the operand of decltype.
8253 Returns a representation for the expression. */
8255 static tree
8258 {
8259 tree expr;
8261 /* If the next token is the `throw' keyword, then we're looking at
8262 a throw-expression. */
8265 /* Otherwise, it must be that we are looking at a
8266 logical-or-expression. */
8267 else
8268 {
8269 /* Parse the binary expressions (logical-or-expression). */
8271 decltype_p,
8273 /* If the next token is a `?' then we're actually looking at a
8274 conditional-expression. */
8277 else
8278 {
8281 /* If it's an assignment-operator, we're using the second
8282 production. */
8283 enum tree_code assignment_operator
8286 {
8288 location_t saved_input_location;
8290 /* Parse the right-hand side of the assignment. */
8296 /* An assignment may not appear in a
8297 constant-expression. */
8299 NIC_ASSIGNMENT))
8301 /* Build the assignment expression. Its default
8302 location is the location of the '=' token. */
8306 assignment_operator,
8307 rhs,
8310 }
8311 }
8312 }
8315 }
8317 static tree
8320 {
8323 }
8325 /* Parse an (optional) assignment-operator.
8327 assignment-operator: one of
8328 = *= /= %= += -= >>= <<= &= ^= |=
8330 GNU Extension:
8332 assignment-operator: one of
8333 <?= >?=
8335 If the next token is an assignment operator, the corresponding tree
8336 code is returned, and the token is consumed. For example, for
8337 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
8338 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
8339 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
8340 operator, ERROR_MARK is returned. */
8342 static enum tree_code
8344 {
8348 /* Peek at the next token. */
8352 {
8398 /* Nothing else is an assignment operator. */
8400 }
8402 /* If it was an assignment operator, consume it. */
8407 }
8409 /* Parse an expression.
8411 expression:
8412 assignment-expression
8413 expression , assignment-expression
8415 CAST_P is true if this expression is the target of a cast.
8416 DECLTYPE_P is true if this expression is the immediate operand of decltype,
8417 except possibly parenthesized or on the RHS of a comma (N3276).
8419 Returns a representation of the expression. */
8421 static tree
8424 {
8429 {
8430 tree assignment_expression;
8432 /* Parse the next assignment-expression. */
8433 assignment_expression
8436 /* We don't create a temporary for a call that is the immediate operand
8437 of decltype or on the RHS of a comma. But when we see a comma, we
8438 need to create a temporary for a call on the LHS. */
8443 assignment_expression
8447 /* If this is the first assignment-expression, we can just
8448 save it away. */
8451 else
8453 assignment_expression,
8455 /* If the next token is not a comma, then we are done with the
8456 expression. */
8459 /* Consume the `,'. */
8462 /* A comma operator cannot appear in a constant-expression. */
8465 }
8468 }
8470 /* Parse a constant-expression.
8472 constant-expression:
8473 conditional-expression
8475 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
8476 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
8477 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
8478 is false, NON_CONSTANT_P should be NULL. */
8480 static tree
8484 {
8488 tree expression;
8490 /* It might seem that we could simply parse the
8491 conditional-expression, and then check to see if it were
8492 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
8493 one that the compiler can figure out is constant, possibly after
8494 doing some simplifications or optimizations. The standard has a
8495 precise definition of constant-expression, and we must honor
8496 that, even though it is somewhat more restrictive.
8498 For example:
8500 int i[(2, 3)];
8502 is not a legal declaration, because `(2, 3)' is not a
8503 constant-expression. The `,' operator is forbidden in a
8504 constant-expression. However, GCC's constant-folding machinery
8505 will fold this operation to an INTEGER_CST for `3'. */
8507 /* Save the old settings. */
8509 saved_allow_non_integral_constant_expression_p
8512 /* We are now parsing a constant-expression. */
8514 parser->allow_non_integral_constant_expression_p
8517 /* Although the grammar says "conditional-expression", we parse an
8518 "assignment-expression", which also permits "throw-expression"
8519 and the use of assignment operators. In the case that
8520 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
8521 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
8522 actually essential that we look for an assignment-expression.
8523 For example, cp_parser_initializer_clauses uses this function to
8524 determine whether a particular assignment-expression is in fact
8525 constant. */
8527 /* Restore the old settings. */
8528 parser->integral_constant_expression_p
8530 parser->allow_non_integral_constant_expression_p
8533 {
8534 /* Require an rvalue constant expression here; that's what our
8535 callers expect. Reference constant expressions are handled
8536 separately in e.g. cp_parser_template_argument. */
8541 }
8544 parser->non_integral_constant_expression_p
8548 }
8550 /* Parse __builtin_offsetof.
8552 offsetof-expression:
8553 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
8555 offsetof-member-designator:
8556 id-expression
8557 | offsetof-member-designator "." id-expression
8558 | offsetof-member-designator "[" expression "]"
8559 | offsetof-member-designator "->" id-expression */
8561 static tree
8563 {
8566 cp_id_kind dummy;
8569 /* We're about to accept non-integral-constant things, but will
8570 definitely yield an integral constant expression. Save and
8571 restore these values around our local parsing. */
8575 /* Consume the "__builtin_offsetof" token. */
8577 /* Consume the opening `('. */
8579 /* Parse the type-id. */
8581 /* Look for the `,'. */
8585 /* Build the (type *)null that begins the traditional offsetof macro. */
8587 tf_warning_or_error);
8589 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
8593 {
8596 {
8598 /* offsetof-member-designator "[" expression "]" */
8604 /* offsetof-member-designator "->" identifier */
8607 /* FALLTHRU */
8610 /* offsetof-member-designator "." identifier */
8618 /* Consume the ")" token. */
8623 /* Error. We know the following require will fail, but
8624 that gives the proper error message. */
8629 }
8630 }
8632 success:
8633 /* If we're processing a template, we can't finish the semantics yet.
8634 Otherwise we can fold the entire expression now. */
8637 else
8640 failure:
8645 }
8647 /* Parse a trait expression.
8649 Returns a representation of the expression, the underlying type
8650 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
8652 static tree
8654 {
8655 cp_trait_kind kind;
8658 cp_decl_specifier_seq decl_specs;
8661 {
8738 }
8740 /* Consume the token. */
8750 /* Build a trivial decl-specifier-seq. */
8754 /* Call grokdeclarator to figure out what type this is. */
8759 {
8767 /* Build a trivial decl-specifier-seq. */
8771 /* Call grokdeclarator to figure out what type this is. */
8774 }
8778 /* Complete the trait expression, which may mean either processing
8779 the trait expr now or saving it for template instantiation. */
8781 {
8790 }
8791 }
8793 /* Lambdas that appear in variable initializer or default argument scope
8794 get that in their mangling, so we need to record it. We might as well
8795 use the count for function and namespace scopes as well. */
8799 {
8800 tree t;
8805 static void
8807 {
8808 tree_int ti;
8810 /* Once we're inside a function, we ignore other scopes and just push
8811 the function again so that popping works properly. */
8818 {
8819 /* Don't reset the count if we're still in the same function. */
8822 }
8823 }
8825 static void
8827 {
8830 }
8832 static void
8834 {
8837 {
8840 }
8842 }
8844 /* Parse a lambda expression.
8846 lambda-expression:
8847 lambda-introducer lambda-declarator [opt] compound-statement
8849 Returns a representation of the expression. */
8851 static tree
8853 {
8855 tree type;
8862 {
8864 {
8868 }
8870 }
8872 /* We may be in the middle of deferred access check. Disable
8873 it now. */
8884 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
8887 /* Now that we've started the type, add the capture fields for any
8888 explicit captures. */
8891 {
8892 /* Inside the class, surrounding template-parameter-lists do not apply. */
8893 unsigned int saved_num_template_parameter_lists
8897 bool fully_implicit_function_template_p
8901 bool auto_is_implicit_function_template_parm_p
8912 /* By virtue of defining a local class, a lambda expression has access to
8913 the private variables of enclosing classes. */
8920 {
8923 }
8925 /* The capture list was built up in reverse order; fix that now. */
8937 parser->fully_implicit_function_template_p
8941 parser->auto_is_implicit_function_template_parm_p
8943 }
8947 /* This field is only used during parsing of the lambda. */
8950 /* This lambda shouldn't have any proxies left at this point. */
8952 /* And now that we're done, push proxies for an enclosing lambda. */
8957 else
8959 }
8961 /* Parse the beginning of a lambda expression.
8963 lambda-introducer:
8964 [ lambda-capture [opt] ]
8966 LAMBDA_EXPR is the current representation of the lambda expression. */
8968 static void
8970 {
8971 /* Need commas after the first capture. */
8974 /* Eat the leading `['. */
8977 /* Record default capture mode. "[&" "[=" "[&," "[=," */
8985 {
8988 }
8991 {
8993 tree capture_id;
8994 tree capture_init_expr;
8998 enum capture_kind_type
8999 {
9000 BY_COPY,
9001 BY_REFERENCE
9002 };
9006 {
9009 }
9013 else
9016 /* Possibly capture `this'. */
9018 {
9028 explicit_init_p);
9030 }
9032 /* Remember whether we want to capture as a reference or not. */
9034 {
9037 }
9039 /* Get the identifier. */
9044 /* Would be nice to have a cp_parser_skip_to_closing_x for general
9045 delimiters, but I modified this to stop on unnested ']' as well. It
9046 was already changed to stop on unnested '}', so the
9047 "closing_parenthesis" name is no more misleading with my change. */
9048 {
9054 }
9056 /* Find the initializer for this capture. */
9060 {
9062 /* An explicit initializer exists. */
9065 "lambda capture initializers "
9071 {
9074 }
9075 }
9076 else
9077 {
9080 /* Turn the identifier into an id-expression. */
9081 capture_init_expr
9086 {
9089 }
9093 {
9096 capture_init_expr);
9099 }
9102 {
9105 capture_init_expr))
9108 }
9110 capture_init_expr
9111 = finish_id_expression
9113 capture_init_expr,
9127 {
9130 }
9131 else
9133 }
9137 {
9142 capture_id);
9146 "capture of %qD redundant with by-reference capture "
9148 }
9151 capture_id,
9152 capture_init_expr,
9154 explicit_init_p);
9155 }
9158 }
9160 /* Parse the (optional) middle of a lambda expression.
9162 lambda-declarator:
9163 < template-parameter-list [opt] >
9164 ( parameter-declaration-clause [opt] )
9165 attribute-specifier [opt]
9166 mutable [opt]
9167 exception-specification [opt]
9168 lambda-return-type-clause [opt]
9170 LAMBDA_EXPR is the current representation of the lambda expression. */
9172 static bool
9174 {
9175 /* 5.1.1.4 of the standard says:
9176 If a lambda-expression does not include a lambda-declarator, it is as if
9177 the lambda-declarator were ().
9178 This means an empty parameter list, no attributes, and no exception
9179 specification. */
9185 /* The template-parameter-list is optional, but must begin with
9186 an opening angle if present. */
9188 {
9191 "lambda templates are only available with "
9200 /* We just processed one more parameter list. */
9202 }
9204 /* The parameter-declaration-clause is optional (unless
9205 template-parameter-list was given), but must begin with an
9206 opening parenthesis if present. */
9208 {
9213 /* Parse parameters. */
9216 /* Default arguments shall not be specified in the
9217 parameter-declaration-clause of a lambda-declarator. */
9227 /* Parse optional `mutable' keyword. */
9229 {
9232 }
9234 /* Parse optional exception specification. */
9237 /* Parse optional trailing return type. */
9239 {
9243 }
9245 /* The function parameters must be in scope all the way until after the
9246 trailing-return-type in case of decltype. */
9248 }
9252 /* Create the function call operator.
9254 Messing with declarators like this is no uglier than building up the
9255 FUNCTION_DECL by hand, and this is less likely to get out of sync with
9256 other code. */
9257 {
9258 cp_decl_specifier_seq return_type_specs;
9260 tree fco;
9267 else
9268 /* Maybe we will deduce the return type later. */
9274 sfk_none);
9279 VIRT_SPEC_UNSPECIFIED,
9280 REF_QUAL_NONE,
9281 exception_spec,
9286 declarator,
9287 attributes);
9289 {
9292 /* Give the object parameter a different name. */
9296 }
9298 {
9302 }
9311 }
9312 }
9314 /* Parse the body of a lambda expression, which is simply
9316 compound-statement
9318 but which requires special handling.
9319 LAMBDA_EXPR is the current representation of the lambda expression. */
9321 static void
9323 {
9328 else
9329 /* Still increment function_depth so that we don't GC in the
9330 middle of an expression. */
9332 /* Clear this in case we're in the middle of a default argument. */
9335 /* Finish the function call operator
9336 - class_specifier
9337 + late_parsing_for_member
9338 + function_definition_after_declarator
9339 + ctor_initializer_opt_and_function_body */
9340 {
9342 tree body;
9344 tree compound_stmt;
9345 tree cap;
9347 /* Let the front end know that we are going to be defining this
9348 function. */
9350 NULL_TREE,
9359 /* Push the proxies for any explicit captures. */
9366 /* 5.1.1.4 of the standard says:
9367 If a lambda-expression does not include a trailing-return-type, it
9368 is as if the trailing-return-type denotes the following type:
9369 * if the compound-statement is of the form
9370 { return attribute-specifier [opt] expression ; }
9371 the type of the returned expression after lvalue-to-rvalue
9372 conversion (_conv.lval_ 4.1), array-to-pointer conversion
9373 (_conv.array_ 4.2), and function-to-pointer conversion
9374 (_conv.func_ 4.3);
9375 * otherwise, void. */
9377 /* In a lambda that has neither a lambda-return-type-clause
9378 nor a deducible form, errors should be reported for return statements
9379 in the body. Since we used void as the placeholder return type, parsing
9380 the body as usual will give such desired behavior. */
9384 {
9388 /* Parse tentatively in case there's more after the initial return
9389 statement. */
9400 {
9404 /* Will get error here if type not deduced yet. */
9408 }
9409 }
9412 {
9417 }
9421 out:
9425 /* Finish the function and generate code for it if necessary. */
9428 /* Only expand if the call op is not a template. */
9431 }
9436 else
9438 }
9440 /* Statements [gram.stmt.stmt] */
9442 /* Parse a statement.
9444 statement:
9445 labeled-statement
9446 expression-statement
9447 compound-statement
9448 selection-statement
9449 iteration-statement
9450 jump-statement
9451 declaration-statement
9452 try-block
9454 C++11:
9456 statement:
9457 labeled-statement
9458 attribute-specifier-seq (opt) expression-statement
9459 attribute-specifier-seq (opt) compound-statement
9460 attribute-specifier-seq (opt) selection-statement
9461 attribute-specifier-seq (opt) iteration-statement
9462 attribute-specifier-seq (opt) jump-statement
9463 declaration-statement
9464 attribute-specifier-seq (opt) try-block
9466 TM Extension:
9468 statement:
9469 atomic-statement
9471 IN_COMPOUND is true when the statement is nested inside a
9472 cp_parser_compound_statement; this matters for certain pragmas.
9474 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9475 is a (possibly labeled) if statement which is not enclosed in braces
9476 and has an else clause. This is used to implement -Wparentheses. */
9478 static void
9481 {
9486 restart:
9489 /* There is no statement yet. */
9495 /* In obj-c++, seeing '[[' might be the either the beginning of
9496 c++11 attributes, or a nested objc-message-expression. So
9497 let's parse the c++11 attributes tentatively. */
9501 {
9504 }
9506 /* Peek at the next token. */
9508 /* Remember the location of the first token in the statement. */
9510 /* If this is a keyword, then that will often determine what kind of
9511 statement we have. */
9513 {
9517 {
9520 /* Looks like a labeled-statement with a case label.
9521 Parse the label, and then use tail recursion to parse
9522 the statement. */
9539 {
9544 }
9545 else
9559 {
9564 }
9565 else
9566 {
9570 }
9574 /* Objective-C++ exception-handling constructs. */
9588 /* This must be a namespace alias definition. */
9601 /* It might be a keyword like `int' that can start a
9602 declaration-statement. */
9604 }
9605 }
9607 {
9608 /* If the next token is a `:', then we are looking at a
9609 labeled-statement. */
9612 {
9613 /* Looks like a labeled-statement with an ordinary label.
9614 Parse the label, and then use tail recursion to parse
9615 the statement. */
9619 }
9620 }
9621 /* Anything that starts with a `{' must be a compound-statement. */
9624 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
9625 a statement all its own. */
9627 {
9628 /* Only certain OpenMP pragmas are attached to statements, and thus
9629 are considered statements themselves. All others are not. In
9630 the context of a compound, accept the pragma as a "statement" and
9631 return so that we can check for a close brace. Otherwise we
9632 require a real statement and must go back and read one. */
9638 }
9640 {
9643 }
9645 /* Everything else must be a declaration-statement or an
9646 expression-statement. Try for the declaration-statement
9647 first, unless we are looking at a `;', in which case we know that
9648 we have an expression-statement. */
9650 {
9652 {
9654 {
9655 /* Attributes should be parsed as part of the the
9656 declaration, so let's un-parse them. */
9659 }
9662 /* Try to parse the declaration-statement. */
9664 /* If that worked, we're done. */
9667 }
9668 /* Look for an expression-statement instead. */
9670 }
9672 /* Set the line number for the statement. */
9676 /* Note that for now, we don't do anything with c++11 statements
9677 parsed at this level. */
9680 OPT_Wattributes,
9682 }
9684 /* Parse the label for a labeled-statement, i.e.
9686 identifier :
9687 case constant-expression :
9688 default :
9690 GNU Extension:
9691 case constant-expression ... constant-expression : statement
9693 When a label is parsed without errors, the label is added to the
9694 parse tree by the finish_* functions, so this function doesn't
9695 have to return the label. */
9697 static void
9699 {
9704 /* The next token should be an identifier. */
9708 {
9711 }
9715 {
9717 {
9721 /* Consume the `case' token. */
9723 /* Parse the constant-expression. */
9726 NULL);
9730 {
9731 /* Consume the `...' token. */
9733 expr_hi =
9736 NULL);
9737 /* We don't need to emit warnings here, as the common code
9738 will do this for us. */
9739 }
9740 else
9745 else
9748 expr);
9749 }
9753 /* Consume the `default' token. */
9758 else
9763 /* Anything else must be an ordinary label. */
9766 }
9768 /* Require the `:' token. */
9771 /* An ordinary label may optionally be followed by attributes.
9772 However, this is only permitted if the attributes are then
9773 followed by a semicolon. This is because, for backward
9774 compatibility, when parsing
9775 lab: __attribute__ ((unused)) int i;
9776 we want the attribute to attach to "i", not "lab". */
9779 {
9780 tree attrs;
9787 ;
9788 else
9790 }
9796 }
9798 /* Parse an expression-statement.
9800 expression-statement:
9801 expression [opt] ;
9803 Returns the new EXPR_STMT -- or NULL_TREE if the expression
9804 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
9805 indicates whether this expression-statement is part of an
9806 expression statement. */
9808 static tree
9810 {
9814 /* If the next token is a ';', then there is no expression
9815 statement. */
9817 {
9821 {
9824 }
9825 }
9827 /* Give a helpful message for "A<T>::type t;" and the like. */
9830 {
9837 {
9838 /* A::A a; */
9843 }
9844 }
9846 /* Consume the final `;'. */
9851 /* This is the final expression statement of a statement
9852 expression. */
9858 }
9860 /* Parse a compound-statement.
9862 compound-statement:
9863 { statement-seq [opt] }
9865 GNU extension:
9867 compound-statement:
9868 { label-declaration-seq [opt] statement-seq [opt] }
9870 label-declaration-seq:
9871 label-declaration
9872 label-declaration-seq label-declaration
9874 Returns a tree representing the statement. */
9876 static tree
9879 {
9880 tree compound_stmt;
9882 /* Consume the `{'. */
9889 /* Begin the compound-statement. */
9891 /* If the next keyword is `__label__' we have a label declaration. */
9894 /* Parse an (optional) statement-seq. */
9896 /* Finish the compound-statement. */
9898 /* Consume the `}'. */
9902 }
9904 /* Parse an (optional) statement-seq.
9906 statement-seq:
9907 statement
9908 statement-seq [opt] statement */
9910 static void
9912 {
9913 /* Scan statements until there aren't any more. */
9915 {
9918 /* If we are looking at a `}', then we have run out of
9919 statements; the same is true if we have reached the end
9920 of file, or have stumbled upon a stray '@end'. */
9927 /* If we are in a compound statement and find 'else' then
9928 something went wrong. */
9930 {
9933 else
9934 {
9937 }
9938 }
9940 /* Parse the statement. */
9942 }
9943 }
9945 /* Parse a selection-statement.
9947 selection-statement:
9948 if ( condition ) statement
9949 if ( condition ) statement else statement
9950 switch ( condition ) statement
9952 Returns the new IF_STMT or SWITCH_STMT.
9954 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9955 is a (possibly labeled) if statement which is not enclosed in
9956 braces and has an else clause. This is used to implement
9957 -Wparentheses. */
9959 static tree
9961 {
9968 /* Peek at the next token. */
9971 /* See what kind of keyword it is. */
9974 {
9977 {
9978 tree statement;
9979 tree condition;
9981 /* Look for the `('. */
9983 {
9986 }
9988 /* Begin the selection-statement. */
9991 else
9994 /* Parse the condition. */
9996 /* Look for the `)'. */
10002 {
10006 /* Add the condition. */
10009 /* Parse the then-clause. */
10013 {
10021 }
10022 else
10028 /* If the next token is `else', parse the else-clause. */
10030 RID_ELSE))
10031 {
10032 /* Consume the `else' keyword. */
10035 /* Parse the else-clause. */
10037 {
10038 location_t loc;
10045 }
10046 else
10051 /* If we are currently parsing a then-clause, then
10052 IF_P will not be NULL. We set it to true to
10053 indicate that this if statement has an else clause.
10054 This may trigger the Wparentheses warning below
10055 when we get back up to the parent if statement. */
10058 }
10059 else
10060 {
10061 /* This if statement does not have an else clause. If
10062 NESTED_IF is true, then the then-clause is an if
10063 statement which does have an else clause. We warn
10064 about the potential ambiguity. */
10067 "suggest explicit braces to avoid ambiguous"
10069 }
10071 /* Now we're all done with the if-statement. */
10073 }
10074 else
10075 {
10079 /* Add the condition. */
10082 /* Parse the body of the switch-statement. */
10091 /* Now we're all done with the switch-statement. */
10093 }
10096 }
10102 }
10103 }
10105 /* Parse a condition.
10107 condition:
10108 expression
10109 type-specifier-seq declarator = initializer-clause
10110 type-specifier-seq declarator braced-init-list
10112 GNU Extension:
10114 condition:
10115 type-specifier-seq declarator asm-specification [opt]
10116 attributes [opt] = assignment-expression
10118 Returns the expression that should be tested. */
10120 static tree
10122 {
10123 cp_decl_specifier_seq type_specifiers;
10127 /* Try the declaration first. */
10129 /* New types are not allowed in the type-specifier-seq for a
10130 condition. */
10132 parser->type_definition_forbidden_message
10134 /* Parse the type-specifier-seq. */
10136 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
10139 /* Restore the saved message. */
10141 /* If all is well, we might be looking at a declaration. */
10143 {
10144 tree decl;
10145 tree asm_specification;
10146 tree attributes;
10150 /* Parse the declarator. */
10156 /* Parse the attributes. */
10158 /* Parse the asm-specification. */
10160 /* If the next token is not an `=' or '{', then we might still be
10161 looking at an expression. For example:
10163 if (A(a).x)
10165 looks like a decl-specifier-seq and a declarator -- but then
10166 there is no `=', so this is an expression. */
10171 /* If we did see an `=' or '{', then we are looking at a declaration
10172 for sure. */
10174 {
10175 tree pushed_scope;
10179 /* Create the declaration. */
10185 /* Parse the initializer. */
10187 {
10191 }
10192 else
10193 {
10194 /* Consume the `='. */
10197 }
10201 /* Process the initializer. */
10204 asm_specification,
10205 flags);
10211 }
10212 }
10213 /* If we didn't even get past the declarator successfully, we are
10214 definitely not looking at a declaration. */
10215 else
10218 /* Otherwise, we are looking at an expression. */
10220 }
10222 /* Parses a for-statement or range-for-statement until the closing ')',
10223 not included. */
10225 static tree
10227 {
10231 /* Begin the for-statement. */
10234 /* Parse the initialization. */
10239 else
10241 }
10243 static tree
10245 {
10246 /* Normal for loop */
10249 tree stmt;
10252 /* The for-init-statement has already been parsed in
10253 cp_parser_for_init_statement, so no work is needed here. */
10256 /* If there's a condition, process it. */
10260 {
10264 }
10266 /* Look for the `;'. */
10269 /* If there's an expression, process it. */
10275 }
10277 /* Tries to parse a range-based for-statement:
10279 range-based-for:
10280 decl-specifier-seq declarator : expression
10282 The decl-specifier-seq declarator and the `:' are already parsed by
10283 cp_parser_for_init_statement. If processing_template_decl it returns a
10284 newly created RANGE_FOR_STMT; if not, it is converted to a
10285 regular FOR_STMT. */
10287 static tree
10290 {
10294 {
10297 }
10298 else
10301 /* If in template, STMT is converted to a normal for-statement
10302 at instantiation. If not, it is done just ahead. */
10304 {
10312 /* do_auto_deduction doesn't mess with template init-lists. */
10315 }
10316 else
10317 {
10320 }
10322 }
10324 /* Subroutine of cp_convert_range_for: given the initializer expression,
10325 builds up the range temporary. */
10327 static tree
10329 {
10332 /* Find out the type deduced by the declaration
10333 `auto &&__range = range_expr'. */
10338 /* Create the __range variable. */
10345 }
10347 /* Used by cp_parser_range_for in template context: we aren't going to
10348 do a full conversion yet, but we still need to resolve auto in the
10349 type of the for-range-declaration if present. This is basically
10350 a shortcut version of cp_convert_range_for. */
10352 static void
10354 {
10357 {
10360 iter_type = (cp_parser_perform_range_for_lookup
10363 {
10365 iter_type);
10367 tf_warning_or_error);
10370 }
10371 }
10372 }
10374 /* Converts a range-based for-statement into a normal
10375 for-statement, as per the definition.
10377 for (RANGE_DECL : RANGE_EXPR)
10378 BLOCK
10380 should be equivalent to:
10382 {
10383 auto &&__range = RANGE_EXPR;
10384 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
10385 __begin != __end;
10386 ++__begin)
10387 {
10388 RANGE_DECL = *__begin;
10389 BLOCK
10390 }
10391 }
10393 If RANGE_EXPR is an array:
10394 BEGIN_EXPR = __range
10395 END_EXPR = __range + ARRAY_SIZE(__range)
10396 Else if RANGE_EXPR has a member 'begin' or 'end':
10397 BEGIN_EXPR = __range.begin()
10398 END_EXPR = __range.end()
10399 Else:
10400 BEGIN_EXPR = begin(__range)
10401 END_EXPR = end(__range);
10403 If __range has a member 'begin' but not 'end', or vice versa, we must
10404 still use the second alternative (it will surely fail, however).
10405 When calling begin()/end() in the third alternative we must use
10406 argument dependent lookup, but always considering 'std' as an associated
10407 namespace. */
10409 tree
10412 {
10418 /* If an error happened previously do nothing or else a lot of
10419 unhelpful errors would be issued. */
10421 else
10422 {
10423 tree range_temp;
10427 /* Can't bind a reference to an array of runtime bound. */
10429 else
10430 {
10435 LOOKUP_ONLYCONVERTING);
10437 }
10440 }
10442 /* The new for initialization statement. */
10450 LOOKUP_ONLYCONVERTING);
10459 LOOKUP_ONLYCONVERTING);
10463 /* The new for condition. */
10470 /* The new increment expression. */
10473 tf_warning_or_error);
10476 /* The declaration is initialized with *__begin inside the loop body. */
10479 tf_warning_or_error),
10481 LOOKUP_ONLYCONVERTING);
10484 }
10486 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
10487 We need to solve both at the same time because the method used
10488 depends on the existence of members begin or end.
10489 Returns the type deduced for the iterator expression. */
10491 static tree
10493 {
10495 {
10498 }
10501 {
10506 }
10508 {
10509 /* If RANGE is an array, we will use pointer arithmetic. */
10512 range,
10516 }
10517 else
10518 {
10519 /* If it is not an array, we must do a bit of magic. */
10529 tf_warning_or_error);
10532 tf_warning_or_error);
10535 {
10536 /* Use the member functions. */
10539 else
10545 else
10548 }
10549 else
10550 {
10551 /* Use global functions with ADL. */
10558 tf_warning_or_error);
10560 tf_warning_or_error);
10562 tf_warning_or_error);
10564 tf_warning_or_error);
10567 }
10569 /* Last common checks. */
10571 {
10572 /* If one of the expressions is an error do no more checks. */
10575 }
10578 /* Can happen, when, eg, in a template context, Koenig lookup
10579 can't resolve begin/end (c++/58503). */
10581 else
10582 {
10584 /* The unqualified type of the __begin and __end temporaries should
10585 be the same, as required by the multiple auto declaration. */
10591 }
10592 }
10593 }
10595 /* Helper function for cp_parser_perform_range_for_lookup.
10596 Builds a tree for RANGE.IDENTIFIER(). */
10598 static tree
10600 {
10613 tf_warning_or_error);
10616 }
10618 /* Parse an iteration-statement.
10620 iteration-statement:
10621 while ( condition ) statement
10622 do statement while ( expression ) ;
10623 for ( for-init-statement condition [opt] ; expression [opt] )
10624 statement
10626 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
10628 static tree
10630 {
10633 tree statement;
10636 /* Peek at the next token. */
10641 /* Remember whether or not we are already within an iteration
10642 statement. */
10645 /* See what kind of keyword it is. */
10648 {
10650 {
10651 tree condition;
10653 /* Begin the while-statement. */
10655 /* Look for the `('. */
10657 /* Parse the condition. */
10660 /* Look for the `)'. */
10662 /* Parse the dependent statement. */
10666 /* We're done with the while-statement. */
10668 }
10672 {
10673 tree expression;
10675 /* Begin the do-statement. */
10677 /* Parse the body of the do-statement. */
10682 /* Look for the `while' keyword. */
10684 /* Look for the `('. */
10686 /* Parse the expression. */
10688 /* We're done with the do-statement. */
10690 /* Look for the `)'. */
10692 /* Look for the `;'. */
10694 }
10698 {
10699 /* Look for the `('. */
10704 /* Look for the `)'. */
10707 /* Parse the body of the for-statement. */
10712 /* We're done with the for-statement. */
10714 }
10721 }
10724 }
10726 /* Parse a for-init-statement or the declarator of a range-based-for.
10727 Returns true if a range-based-for declaration is seen.
10729 for-init-statement:
10730 expression-statement
10731 simple-declaration */
10733 static bool
10735 {
10736 /* If the next token is a `;', then we have an empty
10737 expression-statement. Grammatically, this is also a
10738 simple-declaration, but an invalid one, because it does not
10739 declare anything. Therefore, if we did not handle this case
10740 specially, we would issue an error message about an invalid
10741 declaration. */
10743 {
10749 {
10750 /* N3994 -- for (id : init) ... */
10753 "type-specifier only available with "
10761 }
10763 /* A colon is used in range-based for. */
10766 /* We're going to speculatively look for a declaration, falling back
10767 to an expression, if necessary. */
10769 /* Parse the declaration. */
10772 decl);
10775 {
10776 /* It is a range-for, consume the ':' */
10780 {
10782 "range-based %<for%> loops only available with "
10785 }
10786 }
10787 else
10788 /* The ';' is not consumed yet because we told
10789 cp_parser_simple_declaration not to. */
10794 /* If the tentative parse failed, then we shall need to look for an
10795 expression-statement. */
10796 }
10797 /* If we are here, it is an expression-statement. */
10800 }
10802 /* Parse a jump-statement.
10804 jump-statement:
10805 break ;
10806 continue ;
10807 return expression [opt] ;
10808 return braced-init-list ;
10809 goto identifier ;
10811 GNU extension:
10813 jump-statement:
10814 goto * expression ;
10816 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
10818 static tree
10820 {
10826 /* Peek at the next token. */
10831 /* See what kind of keyword it is. */
10834 {
10838 {
10858 }
10864 {
10871 /* Fall through. */
10881 }
10886 {
10887 tree expr;
10891 {
10895 }
10898 else
10899 /* If the next token is a `;', then there is no
10900 expression. */
10902 /* Build the return-statement. */
10904 /* Look for the final `;'. */
10906 }
10910 /* Create the goto-statement. */
10912 {
10913 /* Issue a warning about this use of a GNU extension. */
10915 /* Consume the '*' token. */
10917 /* Parse the dependent expression. */
10919 }
10920 else
10922 /* Look for the final `;'. */
10929 }
10932 }
10934 /* Parse a declaration-statement.
10936 declaration-statement:
10937 block-declaration */
10939 static void
10941 {
10944 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
10947 /* Parse the block-declaration. */
10950 /* Free any declarators allocated. */
10952 }
10954 /* Some dependent statements (like `if (cond) statement'), are
10955 implicitly in their own scope. In other words, if the statement is
10956 a single statement (as opposed to a compound-statement), it is
10957 none-the-less treated as if it were enclosed in braces. Any
10958 declarations appearing in the dependent statement are out of scope
10959 after control passes that point. This function parses a statement,
10960 but ensures that is in its own scope, even if it is not a
10961 compound-statement.
10963 If IF_P is not NULL, *IF_P is set to indicate whether the statement
10964 is a (possibly labeled) if statement which is not enclosed in
10965 braces and has an else clause. This is used to implement
10966 -Wparentheses.
10968 Returns the new statement. */
10970 static tree
10972 {
10973 tree statement;
10978 /* Mark if () ; with a special NOP_EXPR. */
10980 {
10984 }
10985 /* if a compound is opened, we simply parse the statement directly. */
10988 /* If the token is not a `{', then we must take special action. */
10989 else
10990 {
10991 /* Create a compound-statement. */
10993 /* Parse the dependent-statement. */
10995 /* Finish the dummy compound-statement. */
10997 }
10999 /* Return the statement. */
11001 }
11003 /* For some dependent statements (like `while (cond) statement'), we
11004 have already created a scope. Therefore, even if the dependent
11005 statement is a compound-statement, we do not want to create another
11006 scope. */
11008 static void
11010 {
11011 /* If the token is a `{', then we must take special action. */
11014 else
11015 {
11016 /* Avoid calling cp_parser_compound_statement, so that we
11017 don't create a new scope. Do everything else by hand. */
11019 /* If the next keyword is `__label__' we have a label declaration. */
11022 /* Parse an (optional) statement-seq. */
11025 }
11026 }
11028 /* Declarations [gram.dcl.dcl] */
11030 /* Parse an optional declaration-sequence.
11032 declaration-seq:
11033 declaration
11034 declaration-seq declaration */
11036 static void
11038 {
11040 {
11051 {
11052 /* A declaration consisting of a single semicolon is
11053 invalid. Allow it unless we're being pedantic. */
11058 }
11060 /* If we're entering or exiting a region that's implicitly
11061 extern "C", modify the lang context appropriately. */
11063 {
11066 }
11068 {
11071 }
11074 {
11075 /* A top-level declaration can consist solely of a #pragma.
11076 A nested declaration cannot, so this is done here and not
11077 in cp_parser_declaration. (A #pragma at block scope is
11078 handled in cp_parser_statement.) */
11081 }
11083 /* Parse the declaration itself. */
11085 }
11086 }
11088 /* Parse a declaration.
11090 declaration:
11091 block-declaration
11092 function-definition
11093 template-declaration
11094 explicit-instantiation
11095 explicit-specialization
11096 linkage-specification
11097 namespace-definition
11099 GNU extension:
11101 declaration:
11102 __extension__ declaration */
11104 static void
11106 {
11107 cp_token token1;
11108 cp_token token2;
11113 /* Check for the `__extension__' keyword. */
11115 {
11116 /* Parse the qualified declaration. */
11118 /* Restore the PEDANTIC flag. */
11122 }
11124 /* Try to figure out what kind of declaration is present. */
11129 else
11130 {
11133 }
11135 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
11138 /* If the next token is `extern' and the following token is a string
11139 literal, then we have a linkage specification. */
11143 /* If the next token is `template', then we have either a template
11144 declaration, an explicit instantiation, or an explicit
11145 specialization. */
11147 {
11148 /* `template <>' indicates a template specialization. */
11152 /* `template <' indicates a template declaration. */
11155 /* Anything else must be an explicit instantiation. */
11156 else
11158 }
11159 /* If the next token is `export', then we have a template
11160 declaration. */
11163 /* If the next token is `extern', 'static' or 'inline' and the one
11164 after that is `template', we have a GNU extended explicit
11165 instantiation directive. */
11172 /* If the next token is `namespace', check for a named or unnamed
11173 namespace definition. */
11179 /* An unnamed namespace definition. */
11183 /* An inline (associated) namespace definition. */
11187 /* Objective-C++ declaration/definition. */
11194 /* We must have either a block declaration or a function
11195 definition. */
11196 else
11197 /* Try to parse a block-declaration, or a function-definition. */
11200 /* Free any declarators allocated. */
11202 }
11204 /* Parse a block-declaration.
11206 block-declaration:
11207 simple-declaration
11208 asm-definition
11209 namespace-alias-definition
11210 using-declaration
11211 using-directive
11213 GNU Extension:
11215 block-declaration:
11216 __extension__ block-declaration
11218 C++0x Extension:
11220 block-declaration:
11221 static_assert-declaration
11223 If STATEMENT_P is TRUE, then this block-declaration is occurring as
11224 part of a declaration-statement. */
11226 static void
11229 {
11233 /* Check for the `__extension__' keyword. */
11235 {
11236 /* Parse the qualified declaration. */
11238 /* Restore the PEDANTIC flag. */
11242 }
11244 /* Peek at the next token to figure out which kind of declaration is
11245 present. */
11248 /* If the next keyword is `asm', we have an asm-definition. */
11250 {
11254 }
11255 /* If the next keyword is `namespace', we have a
11256 namespace-alias-definition. */
11259 /* If the next keyword is `using', we have a
11260 using-declaration, a using-directive, or an alias-declaration. */
11262 {
11267 /* If the token after `using' is `namespace', then we have a
11268 using-directive. */
11272 /* If the second token after 'using' is '=', then we have an
11273 alias-declaration. */
11279 /* Otherwise, it's a using-declaration. */
11280 else
11283 }
11284 /* If the next keyword is `__label__' we have a misplaced label
11285 declaration. */
11287 {
11291 /* If the next token is now a `;', consume it. */
11294 }
11295 /* If the next token is `static_assert' we have a static assertion. */
11298 /* Anything else must be a simple-declaration. */
11299 else
11302 }
11304 /* Parse a simple-declaration.
11306 simple-declaration:
11307 decl-specifier-seq [opt] init-declarator-list [opt] ;
11309 init-declarator-list:
11310 init-declarator
11311 init-declarator-list , init-declarator
11313 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
11314 function-definition as a simple-declaration.
11316 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
11317 parsed declaration if it is an uninitialized single declarator not followed
11318 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
11319 if present, will not be consumed. */
11321 static void
11325 {
11326 cp_decl_specifier_seq decl_specifiers;
11333 /* Defer access checks until we know what is being declared; the
11334 checks for names appearing in the decl-specifier-seq should be
11335 done as if we were in the scope of the thing being declared. */
11338 /* Parse the decl-specifier-seq. We have to keep track of whether
11339 or not the decl-specifier-seq declares a named class or
11340 enumeration type, since that is the only case in which the
11341 init-declarator-list is allowed to be empty.
11343 [dcl.dcl]
11345 In a simple-declaration, the optional init-declarator-list can be
11346 omitted only when declaring a class or enumeration, that is when
11347 the decl-specifier-seq contains either a class-specifier, an
11348 elaborated-type-specifier, or an enum-specifier. */
11350 CP_PARSER_FLAGS_OPTIONAL,
11353 /* We no longer need to defer access checks. */
11356 /* In a block scope, a valid declaration must always have a
11357 decl-specifier-seq. By not trying to parse declarators, we can
11358 resolve the declaration/expression ambiguity more quickly. */
11361 {
11364 }
11366 /* If the next two tokens are both identifiers, the code is
11367 erroneous. The usual cause of this situation is code like:
11369 T t;
11371 where "T" should name a type -- but does not. */
11374 {
11375 /* If parsing tentatively, we should commit; we really are
11376 looking at a declaration. */
11378 /* Give up. */
11380 }
11382 /* If we have seen at least one decl-specifier, and the next token
11383 is not a parenthesis, then we must be looking at a declaration.
11384 (After "int (" we might be looking at a functional cast.) */
11391 /* Keep going until we hit the `;' at the end of the simple
11392 declaration. */
11395 CPP_SEMICOLON))
11396 {
11399 tree decl;
11402 {
11403 /* If we are processing next declarator, coma is expected */
11409 }
11410 else
11413 /* Parse the init-declarator. */
11416 function_definition_allowed_p,
11418 declares_class_or_enum,
11420 maybe_range_for_decl);
11421 /* If an error occurred while parsing tentatively, exit quickly.
11422 (That usually happens when in the body of a function; each
11423 statement is treated as a declaration-statement until proven
11424 otherwise.) */
11427 /* Handle function definitions specially. */
11429 {
11430 /* If the next token is a `,', then we are probably
11431 processing something like:
11433 void f() {}, *p;
11435 which is erroneous. */
11437 {
11440 "mixing"
11442 }
11443 /* Otherwise, we're done with the list of declarators. */
11444 else
11445 {
11448 }
11449 }
11452 /* The next token should be either a `,' or a `;'. */
11454 /* If it's a `,', there are more declarators to come. */
11457 /* If it's a `;', we are done. */
11460 /* Anything else is an error. */
11461 else
11462 {
11463 /* If we have already issued an error message we don't need
11464 to issue another one. */
11468 /* Skip tokens until we reach the end of the statement. */
11470 /* If the next token is now a `;', consume it. */
11474 }
11475 /* After the first time around, a function-definition is not
11476 allowed -- even if it was OK at first. For example:
11478 int i, f() {}
11480 is not valid. */
11482 }
11484 /* Issue an error message if no declarators are present, and the
11485 decl-specifier-seq does not itself declare a class or
11486 enumeration: [dcl.dcl]/3. */
11488 {
11490 {
11494 /* Ensure an error is issued anyway when finish_decltype_type,
11495 called via cp_parser_decl_specifier_seq, returns a class or
11496 an enumeration (c++/51786). */
11499 }
11500 /* Perform any deferred access checks. */
11502 }
11504 /* Consume the `;'. */
11508 done:
11510 }
11512 /* Parse a decl-specifier-seq.
11514 decl-specifier-seq:
11515 decl-specifier-seq [opt] decl-specifier
11516 decl-specifier attribute-specifier-seq [opt] (C++11)
11518 decl-specifier:
11519 storage-class-specifier
11520 type-specifier
11521 function-specifier
11522 friend
11523 typedef
11525 GNU Extension:
11527 decl-specifier:
11528 attributes
11530 Set *DECL_SPECS to a representation of the decl-specifier-seq.
11532 The parser flags FLAGS is used to control type-specifier parsing.
11534 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
11535 flags:
11537 1: one of the decl-specifiers is an elaborated-type-specifier
11538 (i.e., a type declaration)
11539 2: one of the decl-specifiers is an enum-specifier or a
11540 class-specifier (i.e., a type definition)
11542 */
11544 static void
11546 cp_parser_flags flags,
11549 {
11553 cp_decl_spec ds;
11555 /* Clear DECL_SPECS. */
11558 /* Assume no class or enumeration type is declared. */
11561 /* Keep reading specifiers until there are no more to read. */
11563 {
11568 /* Peek at the next token. */
11571 /* Save the first token of the decl spec list for error
11572 reporting. */
11575 /* Handle attributes. */
11577 {
11578 /* Parse the attributes. */
11581 /* In a sequence of declaration specifiers, c++11 attributes
11582 appertain to the type that precede them. In that case
11583 [dcl.spec]/1 says:
11585 The attribute-specifier-seq affects the type only for
11586 the declaration it appears in, not other declarations
11587 involving the same type.
11589 But for now let's force the user to position the
11590 attribute either at the beginning of the declaration or
11591 after the declarator-id, which would clearly mean that it
11592 applies to the declarator. */
11594 {
11596 /* The c++11 attribute is at the beginning of the
11597 declaration. It appertains to the entity being
11599 else
11600 {
11602 {
11603 /* This is an attribute following a
11604 class-specifier. */
11609 }
11610 else
11611 {
11612 decl_specs->std_attributes
11614 attrs);
11617 }
11619 }
11620 }
11622 decl_specs->attributes
11624 attrs);
11628 }
11629 /* Assume we will find a decl-specifier keyword. */
11631 /* If the next token is an appropriate keyword, we can simply
11632 add it to the list. */
11634 {
11635 /* decl-specifier:
11636 friend
11637 constexpr */
11640 {
11643 }
11644 else
11645 {
11647 /* Consume the token. */
11649 }
11657 /* function-specifier:
11658 inline
11659 virtual
11660 explicit */
11667 /* decl-specifier:
11668 typedef */
11671 /* Consume the token. */
11673 /* A constructor declarator cannot appear in a typedef. */
11675 /* The "typedef" keyword can only occur in a declaration; we
11676 may as well commit at this point. */
11683 /* storage-class-specifier:
11684 auto
11685 register
11686 static
11687 extern
11688 mutable
11690 GNU Extension:
11691 thread */
11694 {
11695 /* Consume the token. */
11698 /* Complain about `auto' as a storage specifier, if
11699 we're complaining about C++0x compatibility. */
11703 /* Set the storage class anyway. */
11705 token);
11706 }
11707 else
11708 /* C++0x auto type-specifier. */
11716 /* Consume the token. */
11719 token);
11722 /* Consume the token. */
11728 /* We did not yet find a decl-specifier yet. */
11731 }
11741 /* Constructors are a special case. The `S' in `S()' is not a
11742 decl-specifier; it is the beginning of the declarator. */
11743 constructor_p
11744 = (!found_decl_spec
11745 && constructor_possible_p
11746 && (cp_parser_constructor_declarator_p
11749 /* If we don't have a DECL_SPEC yet, then we must be looking at
11750 a type-specifier. */
11752 {
11755 tree type_spec;
11757 type_spec
11759 decl_specs,
11765 /* If this type-specifier referenced a user-defined type
11766 (a typedef, class-name, etc.), then we can't allow any
11767 more such type-specifiers henceforth.
11769 [dcl.spec]
11771 The longest sequence of decl-specifiers that could
11772 possibly be a type name is taken as the
11773 decl-specifier-seq of a declaration. The sequence shall
11774 be self-consistent as described below.
11776 [dcl.type]
11778 As a general rule, at most one type-specifier is allowed
11779 in the complete decl-specifier-seq of a declaration. The
11780 only exceptions are the following:
11782 -- const or volatile can be combined with any other
11783 type-specifier.
11785 -- signed or unsigned can be combined with char, long,
11786 short, or int.
11788 -- ..
11790 Example:
11792 typedef char* Pc;
11793 void g (const int Pc);
11795 Here, Pc is *not* part of the decl-specifier seq; it's
11796 the declarator. Therefore, once we see a type-specifier
11797 (other than a cv-qualifier), we forbid any additional
11798 user-defined types. We *do* still allow things like `int
11799 int' to be considered a decl-specifier-seq, and issue the
11800 error message later. */
11803 /* A constructor declarator cannot follow a type-specifier. */
11805 {
11810 }
11811 }
11813 /* If we still do not have a DECL_SPEC, then there are no more
11814 decl-specifiers. */
11819 /* After we see one decl-specifier, further decl-specifiers are
11820 always optional. */
11822 }
11824 /* Don't allow a friend specifier with a class definition. */
11829 }
11831 /* Parse an (optional) storage-class-specifier.
11833 storage-class-specifier:
11834 auto
11835 register
11836 static
11837 extern
11838 mutable
11840 GNU Extension:
11842 storage-class-specifier:
11843 thread
11845 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
11847 static tree
11849 {
11851 {
11855 /* Fall through for C++98. */
11862 /* Consume the token. */
11867 }
11868 }
11870 /* Parse an (optional) function-specifier.
11872 function-specifier:
11873 inline
11874 virtual
11875 explicit
11877 Returns an IDENTIFIER_NODE corresponding to the keyword used.
11878 Updates DECL_SPECS, if it is non-NULL. */
11880 static tree
11883 {
11886 {
11892 /* 14.5.2.3 [temp.mem]
11894 A member function template shall not be virtual. */
11897 else
11907 }
11909 /* Consume the token. */
11911 }
11913 /* Parse a linkage-specification.
11915 linkage-specification:
11916 extern string-literal { declaration-seq [opt] }
11917 extern string-literal declaration */
11919 static void
11921 {
11922 tree linkage;
11924 /* Look for the `extern' keyword. */
11927 /* Look for the string-literal. */
11930 /* Transform the literal into an identifier. If the literal is a
11931 wide-character string, or contains embedded NULs, then we can't
11932 handle it as the user wants. */
11935 {
11937 /* Assume C++ linkage. */
11939 }
11940 else
11943 /* We're now using the new linkage. */
11946 /* If the next token is a `{', then we're using the first
11947 production. */
11949 {
11952 /* Consume the `{' token. */
11954 /* Parse the declarations. */
11956 /* Look for the closing `}'. */
11958 }
11959 /* Otherwise, there's just one declaration. */
11960 else
11961 {
11964 saved_in_unbraced_linkage_specification_p
11968 parser->in_unbraced_linkage_specification_p
11970 }
11972 /* We're done with the linkage-specification. */
11974 }
11976 /* Parse a static_assert-declaration.
11978 static_assert-declaration:
11979 static_assert ( constant-expression , string-literal ) ;
11981 If MEMBER_P, this static_assert is a class member. */
11983 static void
11985 {
11986 tree condition;
11987 tree message;
11989 location_t saved_loc;
11992 /* Peek at the `static_assert' token so we can keep track of exactly
11993 where the static assertion started. */
11997 /* Look for the `static_assert' keyword. */
11999 RT_STATIC_ASSERT))
12002 /* We know we are in a static assertion; commit to any tentative
12003 parse. */
12007 /* Parse the `(' starting the static assertion condition. */
12010 /* Parse the constant-expression. Allow a non-constant expression
12011 here in order to give better diagnostics in finish_static_assert. */
12012 condition =
12017 /* Parse the separating `,'. */
12020 /* Parse the string-literal message. */
12025 /* A `)' completes the static assertion. */
12032 /* A semicolon terminates the declaration. */
12035 /* Complete the static assertion, which may mean either processing
12036 the static assert now or saving it for template instantiation. */
12038 }
12040 /* Parse the expression in decltype ( expression ). */
12042 static tree
12045 {
12047 tree expr;
12049 /* First, try parsing an id-expression. */
12060 {
12063 cp_id_kind idk;
12067 /* Lookup the name we got back from the id-expression. */
12078 {
12079 /* Complete lookup of the id-expression. */
12080 expr = (finish_id_expression
12093 /* We found an id-expression, but it was something that we
12094 should not have found. This is an error, not something
12095 we can recover from, so note that we found an
12096 id-expression and we'll recover as gracefully as
12097 possible. */
12099 }
12104 /* We have an id-expression. */
12106 }
12109 {
12110 /* Abort the id-expression parse. */
12113 /* Parsing tentatively, again. */
12116 /* Parse a class member access. */
12124 /* We have an id-expression. */
12126 }
12129 /* We have parsed the complete id-expression or member access. */
12131 else
12132 {
12133 /* Abort our attempt to parse an id-expression or member access
12134 expression. */
12137 /* Parse a full expression. */
12140 }
12143 }
12145 /* Parse a `decltype' type. Returns the type.
12147 simple-type-specifier:
12148 decltype ( expression )
12149 C++14 proposal:
12150 decltype ( auto ) */
12152 static tree
12154 {
12155 tree expr;
12164 {
12165 /* Already parsed. */
12168 }
12170 /* Look for the `decltype' token. */
12174 /* Parse the opening `('. */
12178 /* decltype (auto) */
12181 {
12188 }
12190 /* Types cannot be defined in a `decltype' expression. Save away the
12191 old message. */
12194 /* And create the new one. */
12195 parser->type_definition_forbidden_message
12198 /* The restrictions on constant-expressions do not apply inside
12199 decltype expressions. */
12200 saved_integral_constant_expression_p
12202 saved_non_integral_constant_expression_p
12206 /* Within a parenthesized expression, a `>' token is always
12207 the greater-than operator. */
12208 saved_greater_than_is_operator_p
12212 /* Do not actually evaluate the expression. */
12215 /* Do not warn about problems with the expression. */
12220 /* Go back to evaluating expressions. */
12224 /* The `>' token might be the end of a template-id or
12225 template-parameter-list now. */
12226 parser->greater_than_is_operator_p
12229 /* Restore the old message and the integral constant expression
12230 flags. */
12232 parser->integral_constant_expression_p
12234 parser->non_integral_constant_expression_p
12237 /* Parse to the closing `)'. */
12239 {
12243 }
12246 tf_warning_or_error);
12248 rewrite:
12249 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
12250 it again. */
12257 }
12259 /* Special member functions [gram.special] */
12261 /* Parse a conversion-function-id.
12263 conversion-function-id:
12264 operator conversion-type-id
12266 Returns an IDENTIFIER_NODE representing the operator. */
12268 static tree
12270 {
12271 tree type;
12272 tree saved_scope;
12273 tree saved_qualifying_scope;
12274 tree saved_object_scope;
12277 /* Look for the `operator' token. */
12280 /* When we parse the conversion-type-id, the current scope will be
12281 reset. However, we need that information in able to look up the
12282 conversion function later, so we save it here. */
12286 /* We must enter the scope of the class so that the names of
12287 entities declared within the class are available in the
12288 conversion-type-id. For example, consider:
12290 struct S {
12291 typedef int I;
12292 operator I();
12293 };
12295 S::operator I() { ... }
12297 In order to see that `I' is a type-name in the definition, we
12298 must be in the scope of `S'. */
12301 /* Parse the conversion-type-id. */
12303 /* Leave the scope of the class, if any. */
12306 /* Restore the saved scope. */
12310 /* If the TYPE is invalid, indicate failure. */
12314 }
12316 /* Parse a conversion-type-id:
12318 conversion-type-id:
12319 type-specifier-seq conversion-declarator [opt]
12321 Returns the TYPE specified. */
12323 static tree
12325 {
12326 tree attributes;
12327 cp_decl_specifier_seq type_specifiers;
12329 tree type_specified;
12332 /* Parse the attributes. */
12336 parser->type_definition_forbidden_message
12339 /* Parse the type-specifiers. */
12346 /* If that didn't work, stop. */
12349 /* Parse the conversion-declarator. */
12357 /* Don't give this error when parsing tentatively. This happens to
12358 work because we always parse this definitively once. */
12361 {
12363 {
12366 }
12370 }
12373 }
12375 /* Parse an (optional) conversion-declarator.
12377 conversion-declarator:
12378 ptr-operator conversion-declarator [opt]
12380 */
12384 {
12387 cp_cv_quals cv_quals;
12389 /* We don't know if there's a ptr-operator next, or not. */
12391 /* Try the ptr-operator. */
12394 /* If it worked, look for more conversion-declarators. */
12396 {
12399 /* Parse another optional declarator. */
12402 declarator = cp_parser_make_indirect_declarator
12406 }
12409 }
12411 /* Parse an (optional) ctor-initializer.
12413 ctor-initializer:
12414 : mem-initializer-list
12416 Returns TRUE iff the ctor-initializer was actually present. */
12418 static bool
12420 {
12421 /* If the next token is not a `:', then there is no
12422 ctor-initializer. */
12424 {
12425 /* Do default initialization of any bases and members. */
12430 }
12432 /* Consume the `:' token. */
12434 /* And the mem-initializer-list. */
12438 }
12440 /* Parse a mem-initializer-list.
12442 mem-initializer-list:
12443 mem-initializer ... [opt]
12444 mem-initializer ... [opt] , mem-initializer-list */
12446 static void
12448 {
12453 /* Let the semantic analysis code know that we are starting the
12454 mem-initializer-list. */
12459 /* Loop through the list. */
12461 {
12462 tree mem_initializer;
12465 /* Parse the mem-initializer. */
12467 /* If the next token is a `...', we're expanding member initializers. */
12469 {
12470 /* Consume the `...'. */
12473 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
12474 can be expanded but members cannot. */
12477 {
12482 }
12484 /* Construct the pack expansion type. */
12487 }
12490 {
12494 }
12495 /* Look for a target constructor. */
12499 {
12502 {
12506 }
12508 }
12509 /* Add it to the list, unless it was erroneous. */
12511 {
12514 }
12515 /* If the next token is not a `,', we're done. */
12518 /* Consume the `,' token. */
12520 }
12522 /* Perform semantic analysis. */
12525 }
12527 /* Parse a mem-initializer.
12529 mem-initializer:
12530 mem-initializer-id ( expression-list [opt] )
12531 mem-initializer-id braced-init-list
12533 GNU extension:
12535 mem-initializer:
12536 ( expression-list [opt] )
12538 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
12539 class) or FIELD_DECL (for a non-static data member) to initialize;
12540 the TREE_VALUE is the expression-list. An empty initialization
12541 list is represented by void_list_node. */
12543 static tree
12545 {
12546 tree mem_initializer_id;
12547 tree expression_list;
12548 tree member;
12551 /* Find out what is being initialized. */
12553 {
12557 }
12558 else
12559 {
12563 }
12569 {
12576 }
12577 else
12578 {
12588 }
12598 }
12600 /* Parse a mem-initializer-id.
12602 mem-initializer-id:
12603 :: [opt] nested-name-specifier [opt] class-name
12604 identifier
12606 Returns a TYPE indicating the class to be initializer for the first
12607 production. Returns an IDENTIFIER_NODE indicating the data member
12608 to be initialized for the second production. */
12610 static tree
12612 {
12616 tree id;
12620 /* `typename' is not allowed in this context ([temp.res]). */
12622 {
12624 "keyword %<typename%> not allowed in this context (a qualified "
12627 }
12628 /* Look for the optional `::' operator. */
12629 global_scope_p
12633 /* Look for the optional nested-name-specifier. The simplest way to
12634 implement:
12636 [temp.res]
12638 The keyword `typename' is not permitted in a base-specifier or
12639 mem-initializer; in these contexts a qualified name that
12640 depends on a template-parameter is implicitly assumed to be a
12641 type name.
12643 is to assume that we have seen the `typename' keyword at this
12644 point. */
12645 nested_name_specifier_p
12654 /* If there is a `::' operator or a nested-name-specifier, then we
12655 are definitely looking for a class-name. */
12660 typename_type,
12664 /* Otherwise, we could also be looking for an ordinary identifier. */
12666 /* Try a class-name. */
12670 none_type,
12674 /* If we found one, we're done. */
12677 /* Otherwise, look for an ordinary identifier. */
12679 }
12681 /* Overloading [gram.over] */
12683 /* Parse an operator-function-id.
12685 operator-function-id:
12686 operator operator
12688 Returns an IDENTIFIER_NODE for the operator which is a
12689 human-readable spelling of the identifier, e.g., `operator +'. */
12691 static tree
12693 {
12694 /* Look for the `operator' keyword. */
12697 /* And then the name of the operator itself. */
12699 }
12701 /* Return an identifier node for a user-defined literal operator.
12702 The suffix identifier is chained to the operator name identifier. */
12704 static tree
12706 {
12707 tree identifier;
12714 }
12716 /* Parse an operator.
12718 operator:
12719 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
12720 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
12721 || ++ -- , ->* -> () []
12723 GNU Extensions:
12725 operator:
12726 <? >? <?= >?=
12728 Returns an IDENTIFIER_NODE for the operator which is a
12729 human-readable spelling of the identifier, e.g., `operator +'. */
12731 static tree
12733 {
12738 /* Peek at the next token. */
12740 /* Figure out which operator we have. */
12742 {
12744 {
12747 /* The keyword should be either `new' or `delete'. */
12752 else
12755 /* Consume the `new' or `delete' token. */
12758 /* Peek at the next token. */
12760 /* If it's a `[' token then this is the array variant of the
12761 operator. */
12763 {
12764 /* Consume the `[' token. */
12766 /* Look for the `]' token. */
12770 }
12771 /* Otherwise, we have the non-array variant. */
12772 else
12776 }
12923 /* Consume the `('. */
12925 /* Look for the matching `)'. */
12930 /* Consume the `['. */
12932 /* Look for the matching `]'. */
12947 {
12954 /* Consume the string. */
12960 {
12963 }
12964 else
12965 {
12967 /* Look for the suffix identifier. */
12972 {
12976 }
12977 else
12978 {
12981 }
12982 }
12987 {
12990 }
12993 {
12996 }
12998 {
13001 }
13003 }
13006 /* Anything else is an error. */
13008 }
13010 /* If we have selected an identifier, we need to consume the
13011 operator token. */
13014 /* Otherwise, no valid operator name was present. */
13015 else
13016 {
13019 }
13022 }
13024 /* Parse a template-declaration.
13026 template-declaration:
13027 export [opt] template < template-parameter-list > declaration
13029 If MEMBER_P is TRUE, this template-declaration occurs within a
13030 class-specifier.
13032 The grammar rule given by the standard isn't correct. What
13033 is really meant is:
13035 template-declaration:
13036 export [opt] template-parameter-list-seq
13037 decl-specifier-seq [opt] init-declarator [opt] ;
13038 export [opt] template-parameter-list-seq
13039 function-definition
13041 template-parameter-list-seq:
13042 template-parameter-list-seq [opt]
13043 template < template-parameter-list > */
13045 static void
13047 {
13048 /* Check for `export'. */
13050 {
13051 /* Consume the `export' token. */
13053 /* Warn that we do not support `export'. */
13055 }
13058 }
13060 /* Parse a template-parameter-list.
13062 template-parameter-list:
13063 template-parameter
13064 template-parameter-list , template-parameter
13066 Returns a TREE_LIST. Each node represents a template parameter.
13067 The nodes are connected via their TREE_CHAINs. */
13069 static tree
13071 {
13076 /* The loop below parses the template parms. We first need to know
13077 the total number of template parms to be able to compute proper
13078 canonical types of each dependent type. So after the loop, when
13079 we know the total number of template parms,
13080 end_template_parm_list computes the proper canonical types and
13081 fixes up the dependent types accordingly. */
13083 {
13084 tree parameter;
13087 location_t parm_loc;
13089 /* Parse the template-parameter. */
13094 /* Add it to the list. */
13097 parm_loc,
13098 parameter,
13099 is_non_type,
13100 is_parameter_pack);
13101 else
13102 {
13105 }
13107 /* If the next token is not a `,', we're done. */
13110 /* Otherwise, consume the `,' token. */
13112 }
13115 }
13117 /* Parse a template-parameter.
13119 template-parameter:
13120 type-parameter
13121 parameter-declaration
13123 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
13124 the parameter. The TREE_PURPOSE is the default value, if any.
13125 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
13126 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
13127 set to true iff this parameter is a parameter pack. */
13129 static tree
13132 {
13136 tree parm;
13138 /* Assume it is a type parameter or a template parameter. */
13140 /* Assume it not a parameter pack. */
13142 /* Peek at the next token. */
13144 /* If it is `class' or `template', we have a type-parameter. */
13147 /* If it is `class' or `typename' we do not know yet whether it is a
13148 type parameter or a non-type parameter. Consider:
13150 template <typename T, typename T::X X> ...
13152 or:
13154 template <class C, class D*> ...
13156 Here, the first parameter is a type parameter, and the second is
13157 a non-type parameter. We can tell by looking at the token after
13158 the identifier -- if it is a `,', `=', or `>' then we have a type
13159 parameter. */
13161 {
13162 /* Peek at the token after `class' or `typename'. */
13164 /* If it's an ellipsis, we have a template type parameter
13165 pack. */
13168 /* If it's an identifier, skip it. */
13171 /* Now, see if the token looks like the end of a template
13172 parameter. */
13177 }
13179 /* Otherwise, it is a non-type parameter.
13181 [temp.param]
13183 When parsing a default template-argument for a non-type
13184 template-parameter, the first non-nested `>' is taken as the end
13185 of the template parameter-list rather than a greater-than
13186 operator. */
13188 parameter_declarator
13195 /* If the parameter declaration is marked as a parameter pack, set
13196 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
13197 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
13198 grokdeclarator. */
13201 {
13204 }
13207 {
13208 /* Can happen in some cases of erroneous input (c++/34892). */
13210 /* Consume the `...' for better error recovery. */
13212 }
13213 /* If the next token is an ellipsis, and we don't already have it
13214 marked as a parameter pack, then we have a parameter pack (that
13215 has no declarator). */
13218 && (declarator_can_be_parameter_pack
13220 {
13221 /* Consume the `...'. */
13226 }
13227 /* We might end up with a pack expansion as the type of the non-type
13228 template parameter, in which case this is a non-type template
13229 parameter pack. */
13232 {
13236 }
13239 {
13240 /* Parameter packs cannot have default arguments. However, a
13241 user may try to do so, so we'll parse them and give an
13242 appropriate diagnostic here. */
13246 /* Find the name of the parameter pack. */
13255 else
13259 /* Parse the default argument, but throw away the result. */
13261 }
13271 }
13273 /* Parse a type-parameter.
13275 type-parameter:
13276 class identifier [opt]
13277 class identifier [opt] = type-id
13278 typename identifier [opt]
13279 typename identifier [opt] = type-id
13280 template < template-parameter-list > class identifier [opt]
13281 template < template-parameter-list > class identifier [opt]
13282 = id-expression
13284 GNU Extension (variadic templates):
13286 type-parameter:
13287 class ... identifier [opt]
13288 typename ... identifier [opt]
13290 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
13291 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
13292 the declaration of the parameter.
13294 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
13296 static tree
13298 {
13300 tree parameter;
13302 /* Look for a keyword to tell us what kind of parameter this is. */
13308 {
13311 {
13312 tree identifier;
13313 tree default_argument;
13315 /* If the next token is an ellipsis, we have a template
13316 argument pack. */
13318 {
13319 /* Consume the `...' token. */
13324 }
13326 /* If the next token is an identifier, then it names the
13327 parameter. */
13330 else
13333 /* Create the parameter. */
13336 /* If the next token is an `=', we have a default argument. */
13338 {
13339 /* Consume the `=' token. */
13341 /* Parse the default-argument. */
13345 /* Template parameter packs cannot have default
13346 arguments. */
13348 {
13351 "template parameter pack %qD cannot have a "
13353 else
13355 "template parameter packs cannot have "
13358 }
13360 }
13361 else
13364 /* Create the combined representation of the parameter and the
13365 default argument. */
13367 }
13371 {
13372 tree identifier;
13373 tree default_argument;
13375 /* Look for the `<'. */
13377 /* Parse the template-parameter-list. */
13379 /* Look for the `>'. */
13381 /* Look for the `class' or 'typename' keywords. */
13383 /* If the next token is an ellipsis, we have a template
13384 argument pack. */
13386 {
13387 /* Consume the `...' token. */
13392 }
13393 /* If the next token is an `=', then there is a
13394 default-argument. If the next token is a `>', we are at
13395 the end of the parameter-list. If the next token is a `,',
13396 then we are at the end of this parameter. */
13400 {
13402 /* Treat invalid names as if the parameter were nameless. */
13405 }
13406 else
13409 /* Create the template parameter. */
13411 identifier);
13413 /* If the next token is an `=', then there is a
13414 default-argument. */
13416 {
13419 /* Consume the `='. */
13421 /* Parse the id-expression. */
13423 /* save token before parsing the id-expression, for error
13424 reporting */
13426 default_argument
13434 /* If the id-expression was a template-id that refers to
13435 a template-class, we already have the declaration here,
13436 so no further lookup is needed. */
13437 ;
13438 else
13439 /* Look up the name. */
13440 default_argument
13442 none_type,
13448 /* See if the default argument is valid. */
13449 default_argument
13452 /* Template parameter packs cannot have default
13453 arguments. */
13455 {
13458 "template parameter pack %qD cannot "
13460 identifier);
13461 else
13465 }
13467 }
13468 else
13471 /* Create the combined representation of the parameter and the
13472 default argument. */
13474 }
13480 }
13483 }
13485 /* Parse a template-id.
13487 template-id:
13488 template-name < template-argument-list [opt] >
13490 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
13491 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
13492 returned. Otherwise, if the template-name names a function, or set
13493 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
13494 names a class, returns a TYPE_DECL for the specialization.
13496 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
13497 uninstantiated templates. */
13499 static tree
13505 {
13507 tree templ;
13508 tree arguments;
13509 tree template_id;
13516 /* If the next token corresponds to a template-id, there is no need
13517 to reparse it. */
13520 {
13523 /* Get the stored value. */
13525 /* Perform any access checks that were deferred. */
13528 {
13533 tf_warning_or_error);
13534 }
13535 /* Return the stored value. */
13537 }
13539 /* Avoid performing name lookup if there is no possibility of
13540 finding a template-id. */
13543 && !cp_parser_nth_token_starts_template_argument_list_p
13545 {
13548 }
13550 /* Remember where the template-id starts. */
13556 /* Parse the template-name. */
13559 check_dependency_p,
13560 is_declaration,
13561 tag_type,
13564 {
13567 }
13569 /* If we find the sequence `[:' after a template-name, it's probably
13570 a digraph-typo for `< ::'. Substitute the tokens and check if we can
13571 parse correctly the argument list. */
13578 {
13580 /* Change `:' into `::'. */
13582 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
13583 CPP_LESS. */
13586 /* Parse the arguments. */
13589 {
13590 /* If we couldn't parse an argument list, then we revert our changes
13591 and return simply an error. Maybe this is not a template-id
13592 after all. */
13597 }
13598 /* Otherwise, emit an error about the invalid digraph, but continue
13599 parsing because we got our argument list. */
13602 {
13605 "%<<:%> is an alternate spelling for %<[%>."
13608 {
13610 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
13613 }
13614 }
13615 }
13616 else
13617 {
13618 /* Look for the `<' that starts the template-argument-list. */
13620 {
13623 }
13624 /* Parse the arguments. */
13626 }
13628 /* Build a representation of the specialization. */
13631 TEMPLATE_ID_EXPR,
13635 {
13637 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
13638 template (rather than some instantiation thereof) only if
13639 is not nested within some other construct. For example, in
13640 "template <typename T> void f(T) { A<T>::", A<T> is just an
13641 instantiation of A. */
13644 CPP_SCOPE));
13645 template_id
13647 }
13649 {
13651 }
13652 else
13653 {
13654 /* If it's not a class-template or a template-template, it should be
13655 a function-template. */
13661 }
13663 /* If parsing tentatively, replace the sequence of tokens that makes
13664 up the template-id with a CPP_TEMPLATE_ID token. That way,
13665 should we re-parse the token stream, we will not have to repeat
13666 the effort required to do the parse, nor will we issue duplicate
13667 error messages about problems during instantiation of the
13668 template. */
13670 /* Don't do this if we had a parse error in a declarator; re-parsing
13671 might succeed if a name changes meaning (60361). */
13675 {
13678 /* Reset the contents of the START_OF_ID token. */
13680 /* Retrieve any deferred checks. Do not pop this access checks yet
13681 so the memory will not be reclaimed during token replacing below. */
13687 /* Purge all subsequent tokens. */
13690 /* ??? Can we actually assume that, if template_id ==
13691 error_mark_node, we will have issued a diagnostic to the
13692 user, as opposed to simply marking the tentative parse as
13693 failed? */
13696 }
13700 }
13702 /* Parse a template-name.
13704 template-name:
13705 identifier
13707 The standard should actually say:
13709 template-name:
13710 identifier
13711 operator-function-id
13713 A defect report has been filed about this issue.
13715 A conversion-function-id cannot be a template name because they cannot
13716 be part of a template-id. In fact, looking at this code:
13718 a.operator K<int>()
13720 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
13721 It is impossible to call a templated conversion-function-id with an
13722 explicit argument list, since the only allowed template parameter is
13723 the type to which it is converting.
13725 If TEMPLATE_KEYWORD_P is true, then we have just seen the
13726 `template' keyword, in a construction like:
13728 T::template f<3>()
13730 In that case `f' is taken to be a template-name, even though there
13731 is no way of knowing for sure.
13733 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
13734 name refers to a set of overloaded functions, at least one of which
13735 is a template, or an IDENTIFIER_NODE with the name of the template,
13736 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
13737 names are looked up inside uninstantiated templates. */
13739 static tree
13746 {
13747 tree identifier;
13748 tree decl;
13749 tree fns;
13752 /* If the next token is `operator', then we have either an
13753 operator-function-id or a conversion-function-id. */
13755 {
13756 /* We don't know whether we're looking at an
13757 operator-function-id or a conversion-function-id. */
13759 /* Try an operator-function-id. */
13761 /* If that didn't work, try a conversion-function-id. */
13763 {
13766 }
13767 }
13768 /* Look for the identifier. */
13769 else
13772 /* If we didn't find an identifier, we don't have a template-id. */
13776 /* If the name immediately followed the `template' keyword, then it
13777 is a template-name. However, if the next token is not `<', then
13778 we do not treat it as a template-name, since it is not being used
13779 as part of a template-id. This enables us to handle constructs
13780 like:
13782 template <typename T> struct S { S(); };
13783 template <typename T> S<T>::S();
13785 correctly. We would treat `S' as a template -- if it were `S<T>'
13786 -- but we do not if there is no `<'. */
13790 {
13791 /* In a declaration, in a dependent context, we pretend that the
13792 "template" keyword was present in order to improve error
13793 recovery. For example, given:
13795 template <typename T> void f(T::X<int>);
13797 we want to treat "X<int>" as a template-id. */
13799 && !template_keyword_p
13801 && check_dependency_p
13803 /* Do not do this for dtors (or ctors), since they never
13804 need the template keyword before their name. */
13806 {
13809 /* Explain what went wrong. */
13811 identifier);
13814 /* If parsing tentatively, find the location of the "<" token. */
13817 /* Parse the template arguments so that we can issue error
13818 messages about them. */
13821 /* Skip tokens until we find a good place from which to
13822 continue parsing. */
13827 /* If parsing tentatively, permanently remove the
13828 template argument list. That will prevent duplicate
13829 error messages from being issued about the missing
13830 "template" keyword. */
13836 }
13838 /* If the "template" keyword is present, then there is generally
13839 no point in doing name-lookup, so we just return IDENTIFIER.
13840 But, if the qualifying scope is non-dependent then we can
13841 (and must) do name-lookup normally. */
13847 }
13849 /* Look up the name. */
13851 tag_type,
13854 check_dependency_p,
13858 /* If DECL is a template, then the name was a template-name. */
13860 ;
13861 else
13862 {
13865 /* The standard does not explicitly indicate whether a name that
13866 names a set of overloaded declarations, some of which are
13867 templates, is a template-name. However, such a name should
13868 be a template-name; otherwise, there is no way to form a
13869 template-id for the overloaded templates. */
13877 {
13878 /* The name does not name a template. */
13881 }
13882 }
13884 /* If DECL is dependent, and refers to a function, then just return
13885 its name; we will look it up again during template instantiation. */
13887 {
13891 }
13894 }
13896 /* Parse a template-argument-list.
13898 template-argument-list:
13899 template-argument ... [opt]
13900 template-argument-list , template-argument ... [opt]
13902 Returns a TREE_VEC containing the arguments. */
13904 static tree
13906 {
13911 tree vec;
13918 /* Even if the template-id appears in an integral
13919 constant-expression, the contents of the argument list do
13920 not. */
13926 /* Parse the arguments. */
13927 do
13928 {
13929 tree argument;
13932 /* Consume the comma. */
13935 /* Parse the template-argument. */
13938 /* If the next token is an ellipsis, we're expanding a template
13939 argument pack. */
13941 {
13943 {
13947 }
13948 /* Consume the `...' token. */
13951 /* Make the argument into a TYPE_PACK_EXPANSION or
13952 EXPR_PACK_EXPANSION. */
13954 }
13957 {
13961 {
13964 }
13965 else
13967 }
13969 }
13982 #ifdef ENABLE_CHECKING
13984 #endif
13986 }
13988 /* Parse a template-argument.
13990 template-argument:
13991 assignment-expression
13992 type-id
13993 id-expression
13995 The representation is that of an assignment-expression, type-id, or
13996 id-expression -- except that the qualified id-expression is
13997 evaluated, so that the value returned is either a DECL or an
13998 OVERLOAD.
14000 Although the standard says "assignment-expression", it forbids
14001 throw-expressions or assignments in the template argument.
14002 Therefore, we use "conditional-expression" instead. */
14004 static tree
14006 {
14007 tree argument;
14013 cp_id_kind idk;
14015 /* There's really no way to know what we're looking at, so we just
14016 try each alternative in order.
14018 [temp.arg]
14020 In a template-argument, an ambiguity between a type-id and an
14021 expression is resolved to a type-id, regardless of the form of
14022 the corresponding template-parameter.
14024 Therefore, we try a type-id first. */
14027 /* If there was no error parsing the type-id but the next token is a
14028 '>>', our behavior depends on which dialect of C++ we're
14029 parsing. In C++98, we probably found a typo for '> >'. But there
14030 are type-id which are also valid expressions. For instance:
14032 struct X { int operator >> (int); };
14033 template <int V> struct Foo {};
14034 Foo<X () >> 5> r;
14036 Here 'X()' is a valid type-id of a function type, but the user just
14037 wanted to write the expression "X() >> 5". Thus, we remember that we
14038 found a valid type-id, but we still try to parse the argument as an
14039 expression to see what happens.
14041 In C++0x, the '>>' will be considered two separate '>'
14042 tokens. */
14046 {
14049 }
14050 else
14051 {
14052 /* If the next token isn't a `,' or a `>', then this argument wasn't
14053 really finished. This means that the argument is not a valid
14054 type-id. */
14057 /* If that worked, we're done. */
14060 }
14061 /* We're still not sure what the argument will be. */
14063 /* Try a template. */
14071 /* If the next token isn't a `,' or a `>', then this argument wasn't
14072 really finished. */
14076 {
14077 /* Figure out what is being referred to. If the id-expression
14078 was for a class template specialization, then we will have a
14079 TYPE_DECL at this point. There is no need to do name lookup
14080 at this point in that case. */
14083 none_type,
14092 }
14095 /* It must be a non-type argument. There permitted cases are given
14096 in [temp.arg.nontype]:
14098 -- an integral constant-expression of integral or enumeration
14099 type; or
14101 -- the name of a non-type template-parameter; or
14103 -- the name of an object or function with external linkage...
14105 -- the address of an object or function with external linkage...
14107 -- a pointer to member... */
14108 /* Look for a non-type template parameter. */
14110 {
14122 }
14124 /* If the next token is "&", the argument must be the address of an
14125 object or function with external linkage. */
14128 {
14131 }
14132 /* See if we might have an id-expression. */
14139 {
14142 address_p,
14149 else
14150 {
14151 tree probe;
14154 {
14155 /* Strip the dereference temporarily. */
14158 }
14160 /* If we're in a template, we represent a qualified-id referring
14161 to a static data member as a SCOPE_REF even if the scope isn't
14162 dependent so that we can check access control later. */
14167 {
14168 /* A variable without external linkage might still be a
14169 valid constant-expression, so no error is issued here
14170 if the external-linkage check fails. */
14173 }
14175 /* All overloaded functions are allowed; if the external
14176 linkage test does not pass, an error will be issued
14177 later. */
14178 ;
14182 /* A pointer-to-member. */
14183 ;
14185 ;
14186 else
14190 {
14193 tf_warning_or_error);
14194 else
14197 }
14198 }
14199 }
14200 /* If the argument started with "&", there are no other valid
14201 alternatives at this point. */
14203 {
14206 }
14208 /* If the argument wasn't successfully parsed as a type-id followed
14209 by '>>', the argument can only be a constant expression now.
14210 Otherwise, we try parsing the constant-expression tentatively,
14211 because the argument could really be a type-id. */
14223 /* We did our best to parse the argument as a non type-id, but that
14224 was the only alternative that matched (albeit with a '>' after
14225 it). We can assume it's just a typo from the user, and a
14226 diagnostic will then be issued. */
14228 }
14230 /* Parse an explicit-instantiation.
14232 explicit-instantiation:
14233 template declaration
14235 Although the standard says `declaration', what it really means is:
14237 explicit-instantiation:
14238 template decl-specifier-seq [opt] declarator [opt] ;
14240 Things like `template int S<int>::i = 5, int S<double>::j;' are not
14241 supposed to be allowed. A defect report has been filed about this
14242 issue.
14244 GNU Extension:
14246 explicit-instantiation:
14247 storage-class-specifier template
14248 decl-specifier-seq [opt] declarator [opt] ;
14249 function-specifier template
14250 decl-specifier-seq [opt] declarator [opt] ; */
14252 static void
14254 {
14256 cp_decl_specifier_seq decl_specifiers;
14261 /* Look for an (optional) storage-class-specifier or
14262 function-specifier. */
14264 {
14265 extension_specifier
14268 extension_specifier
14271 }
14273 /* Look for the `template' keyword. */
14275 /* Let the front end know that we are processing an explicit
14276 instantiation. */
14278 /* [temp.explicit] says that we are supposed to ignore access
14279 control while processing explicit instantiation directives. */
14281 /* Parse a decl-specifier-seq. */
14283 CP_PARSER_FLAGS_OPTIONAL,
14286 /* If there was exactly one decl-specifier, and it declared a class,
14287 and there's no declarator, then we have an explicit type
14288 instantiation. */
14290 {
14291 tree type;
14295 /* Turn access control back on for names used during
14296 template instantiation. */
14301 }
14302 else
14303 {
14305 tree decl;
14307 /* Parse the declarator. */
14308 declarator
14319 {
14322 "explicit instantiation shall not use"
14326 "explicit instantiation shall not use"
14331 /* Turn access control back on for names used during
14332 template instantiation. */
14334 /* Do the explicit instantiation. */
14336 }
14337 else
14338 {
14340 /* Skip the body of the explicit instantiation. */
14342 }
14343 }
14344 /* We're done with the instantiation. */
14350 }
14352 /* Parse an explicit-specialization.
14354 explicit-specialization:
14355 template < > declaration
14357 Although the standard says `declaration', what it really means is:
14359 explicit-specialization:
14360 template <> decl-specifier [opt] init-declarator [opt] ;
14361 template <> function-definition
14362 template <> explicit-specialization
14363 template <> template-declaration */
14365 static void
14367 {
14371 /* Look for the `template' keyword. */
14373 /* Look for the `<'. */
14375 /* Look for the `>'. */
14377 /* We have processed another parameter list. */
14379 /* [temp]
14381 A template ... explicit specialization ... shall not have C
14382 linkage. */
14384 {
14386 /* Give it C++ linkage to avoid confusing other parts of the
14387 front end. */
14390 }
14391 else
14393 /* Let the front end know that we are beginning a specialization. */
14395 {
14398 }
14400 /* If the next keyword is `template', we need to figure out whether
14401 or not we're looking a template-declaration. */
14403 {
14408 else
14410 }
14411 else
14412 /* Parse the dependent declaration. */
14418 /* We're done with the specialization. */
14420 /* For the erroneous case of a template with C linkage, we pushed an
14421 implicit C++ linkage scope; exit that scope now. */
14424 /* We're done with this parameter list. */
14426 }
14428 /* Parse a type-specifier.
14430 type-specifier:
14431 simple-type-specifier
14432 class-specifier
14433 enum-specifier
14434 elaborated-type-specifier
14435 cv-qualifier
14437 GNU Extension:
14439 type-specifier:
14440 __complex__
14442 Returns a representation of the type-specifier. For a
14443 class-specifier, enum-specifier, or elaborated-type-specifier, a
14444 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
14446 The parser flags FLAGS is used to control type-specifier parsing.
14448 If IS_DECLARATION is TRUE, then this type-specifier is appearing
14449 in a decl-specifier-seq.
14451 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
14452 class-specifier, enum-specifier, or elaborated-type-specifier, then
14453 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
14454 if a type is declared; 2 if it is defined. Otherwise, it is set to
14455 zero.
14457 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
14458 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
14459 is set to FALSE. */
14461 static tree
14463 cp_parser_flags flags,
14468 {
14474 /* Assume this type-specifier does not declare a new type. */
14477 /* And that it does not specify a cv-qualifier. */
14480 /* Peek at the next token. */
14483 /* If we're looking at a keyword, we can use that to guide the
14484 production we choose. */
14487 {
14492 /* Look for the enum-specifier. */
14494 /* If that worked, we're done. */
14496 {
14501 type_spec,
14502 token,
14505 }
14506 else
14509 /* Any of these indicate either a class-specifier, or an
14510 elaborated-type-specifier. */
14517 /* Parse tentatively so that we can back up if we don't find a
14518 class-specifier. */
14520 /* Look for the class-specifier. */
14523 /* If that worked, we're done. */
14525 {
14530 type_spec,
14531 token,
14534 }
14536 /* Fall through. */
14537 elaborated_type_specifier:
14538 /* We're declaring (not defining) a class or enum. */
14542 /* Fall through. */
14544 /* Look for an elaborated-type-specifier. */
14545 type_spec
14546 = (cp_parser_elaborated_type_specifier
14549 is_declaration));
14552 type_spec,
14553 token,
14576 /* The `__complex__' keyword is a GNU extension. */
14582 }
14584 /* Handle simple keywords. */
14586 {
14588 {
14591 }
14593 }
14595 /* If we do not already have a type-specifier, assume we are looking
14596 at a simple-type-specifier. */
14598 decl_specs,
14599 flags);
14601 /* If we didn't find a type-specifier, and a type-specifier was not
14602 optional in this context, issue an error message. */
14604 {
14607 }
14610 }
14612 /* Parse a simple-type-specifier.
14614 simple-type-specifier:
14615 :: [opt] nested-name-specifier [opt] type-name
14616 :: [opt] nested-name-specifier template template-id
14617 char
14618 wchar_t
14619 bool
14620 short
14621 int
14622 long
14623 signed
14624 unsigned
14625 float
14626 double
14627 void
14629 C++0x Extension:
14631 simple-type-specifier:
14632 auto
14633 decltype ( expression )
14634 char16_t
14635 char32_t
14636 __underlying_type ( type-id )
14638 GNU Extension:
14640 simple-type-specifier:
14641 __int128
14642 __typeof__ unary-expression
14643 __typeof__ ( type-id )
14644 __typeof__ ( type-id ) { initializer-list , [opt] }
14646 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
14647 appropriately updated. */
14649 static tree
14652 cp_parser_flags flags)
14653 {
14657 /* Peek at the next token. */
14660 /* If we're looking at a keyword, things are easy. */
14662 {
14722 {
14726 {
14729 "use of %<auto%> in lambda parameter declaration "
14730 "only available with "
14732 }
14735 "use of %<auto%> in parameter declaration "
14736 "only available with "
14738 else
14740 "ISO C++ forbids use of %<auto%> in parameter "
14742 }
14743 else
14748 /* Since DR 743, decltype can either be a simple-type-specifier by
14749 itself or begin a nested-name-specifier. Parsing it will replace
14750 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
14751 handling below decide what to do. */
14757 /* Consume the `typeof' token. */
14759 /* Parse the operand to `typeof'. */
14761 /* If it is not already a TYPE, take its type. */
14767 token,
14776 token,
14786 token,
14791 }
14793 /* If token is an already-parsed decltype not followed by ::,
14794 it's a simple-type-specifier. */
14797 {
14801 token,
14805 }
14807 /* If the type-specifier was for a built-in type, we're done. */
14809 {
14810 /* Record the type. */
14817 type,
14818 token,
14823 /* Consume the token. */
14826 /* There is no valid C++ program where a non-template type is
14827 followed by a "<". That usually indicates that the user thought
14828 that the type was a template. */
14833 }
14835 /* The type-specifier must be a user-defined type. */
14837 {
14841 /* Don't gobble tokens or issue error messages if this is an
14842 optional type-specifier. */
14846 /* Look for the optional `::' operator. */
14847 global_p
14851 /* Look for the nested-name specifier. */
14852 qualified_p
14860 /* If we have seen a nested-name-specifier, and the next token
14861 is `template', then we are using the template-id production. */
14864 {
14865 /* Look for the template-id. */
14869 none_type,
14871 /* If the template-id did not name a type, we are out of
14872 luck. */
14874 {
14877 }
14878 }
14879 /* Otherwise, look for a type-name. */
14880 else
14882 /* Keep track of all name-lookups performed in class scopes. */
14884 && !global_p
14885 && !qualified_p
14889 /* If it didn't work out, we don't have a TYPE. */
14895 token,
14897 }
14899 /* If we didn't get a type-name, issue an error message. */
14901 {
14904 }
14907 {
14908 /* See if TYPE is an Objective-C type, and if so, parse and
14909 accept any protocol references following it. Do this before
14910 the cp_parser_check_for_invalid_template_id() call, because
14911 Objective-C types can be followed by '<...>' which would
14912 enclose protocol names rather than template arguments, and so
14913 everything is fine. */
14916 {
14920 /* Clobber the "unqualified" type previously entered into
14921 DECL_SPECS with the new, improved protocol-qualified version. */
14926 }
14928 /* There is no valid C++ program where a non-template type is
14929 followed by a "<". That usually indicates that the user
14930 thought that the type was a template. */
14932 none_type,
14934 }
14937 }
14939 /* Parse a type-name.
14941 type-name:
14942 class-name
14943 enum-name
14944 typedef-name
14945 simple-template-id [in c++0x]
14947 enum-name:
14948 identifier
14950 typedef-name:
14951 identifier
14953 Returns a TYPE_DECL for the type. */
14955 static tree
14957 {
14958 tree type_decl;
14960 /* We can't know yet whether it is a class-name or not. */
14962 /* Try a class-name. */
14966 none_type,
14970 /* If it's not a class-name, keep looking. */
14972 {
14974 /* It must be a typedef-name or an enum-name. */
14978 /* It is either a simple-template-id representing an
14979 instantiation of an alias template... */
14983 none_type,
14985 /* Note that this must be an instantiation of an alias template
14986 because [temp.names]/6 says:
14988 A template-id that names an alias template specialization
14989 is a type-name.
14991 Whereas [temp.names]/7 says:
14993 A simple-template-id that names a class template
14994 specialization is a class-name. */
14999 else
15003 /* ... Or a typedef-name or an enum-name. */
15005 }
15008 }
15010 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
15012 enum-name:
15013 identifier
15015 typedef-name:
15016 identifier
15018 Returns a TYPE_DECL for the type. */
15020 static tree
15022 {
15023 tree type_decl;
15024 tree identifier;
15031 /* Look up the type-name. */
15038 {
15039 /* See if this is an Objective-C type. */
15044 }
15046 /* Issue an error if we did not find a type-name. */
15048 /* In Objective-C, we have the complication that class names are
15049 normally type names and start declarations (eg, the
15050 "NSObject" in "NSObject *object;"), but can be used in an
15051 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
15052 is an expression. So, a classname followed by a dot is not a
15053 valid type-name. */
15056 {
15061 }
15062 /* Remember that the name was used in the definition of the
15063 current class so that we can check later to see if the
15064 meaning would have been different after the class was
15065 entirely defined. */
15071 }
15073 /* Parse an elaborated-type-specifier. Note that the grammar given
15074 here incorporates the resolution to DR68.
15076 elaborated-type-specifier:
15077 class-key :: [opt] nested-name-specifier [opt] identifier
15078 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
15079 enum-key :: [opt] nested-name-specifier [opt] identifier
15080 typename :: [opt] nested-name-specifier identifier
15081 typename :: [opt] nested-name-specifier template [opt]
15082 template-id
15084 GNU extension:
15086 elaborated-type-specifier:
15087 class-key attributes :: [opt] nested-name-specifier [opt] identifier
15088 class-key attributes :: [opt] nested-name-specifier [opt]
15089 template [opt] template-id
15090 enum attributes :: [opt] nested-name-specifier [opt] identifier
15092 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
15093 declared `friend'. If IS_DECLARATION is TRUE, then this
15094 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
15095 something is being declared.
15097 Returns the TYPE specified. */
15099 static tree
15103 {
15105 tree identifier;
15108 tree globalscope;
15111 /* See if we're looking at the `enum' keyword. */
15113 {
15114 /* Consume the `enum' token. */
15116 /* Remember that it's an enumeration type. */
15118 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
15119 enums) is used here. */
15122 {
15126 /* Consume the `struct' or `class' and parse it anyway. */
15128 }
15129 /* Parse the attributes. */
15131 }
15132 /* Or, it might be `typename'. */
15134 RID_TYPENAME))
15135 {
15136 /* Consume the `typename' token. */
15138 /* Remember that it's a `typename' type. */
15140 }
15141 /* Otherwise it must be a class-key. */
15142 else
15143 {
15147 /* Parse the attributes. */
15149 }
15151 /* Look for the `::' operator. */
15154 /* Look for the nested-name-specifier. */
15156 {
15161 is_declaration))
15163 }
15164 else
15165 /* Even though `typename' is not present, the proposed resolution
15166 to Core Issue 180 says that in `class A<T>::B', `B' should be
15167 considered a type-name, even if `A<T>' is dependent. */
15172 is_declaration);
15173 /* For everything but enumeration types, consider a template-id.
15174 For an enumeration type, consider only a plain identifier. */
15176 {
15178 tree decl;
15180 /* Allow the `template' keyword. */
15182 /* If we didn't see `template', we don't know if there's a
15183 template-id or not. */
15186 /* Parse the template-id. */
15190 tag_type,
15191 is_declaration);
15192 /* If we didn't find a template-id, look for an ordinary
15193 identifier. */
15195 ;
15196 /* We can get here when cp_parser_template_id, called by
15197 cp_parser_class_name with tag_type == none_type, succeeds
15198 and caches a BASELINK. Then, when called again here,
15199 instead of failing and returning an error_mark_node
15200 returns it (see template/typename17.C in C++11).
15201 ??? Could we diagnose this earlier? */
15203 {
15206 }
15207 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
15208 in effect, then we must assume that, upon instantiation, the
15209 template will correspond to a class. */
15213 typename_type,
15215 /* If the `typename' keyword is in effect and DECL is not a type
15216 decl, then type is non existent. */
15218 ;
15224 }
15227 {
15232 {
15235 }
15237 /* For a `typename', we needn't call xref_tag. */
15243 /* Template parameter lists apply only if we are not within a
15244 function parameter list. */
15245 bool template_parm_lists_apply
15254 /* Look up a qualified name in the usual way. */
15256 {
15257 tree decl;
15258 tree ambiguous_decls;
15261 tag_type,
15268 /* If the lookup was ambiguous, an error will already have been
15269 issued. */
15273 /* If we are parsing friend declaration, DECL may be a
15274 TEMPLATE_DECL tree node here. However, we need to check
15275 whether this TEMPLATE_DECL results in valid code. Consider
15276 the following example:
15278 namespace N {
15279 template <class T> class C {};
15280 }
15281 class X {
15282 template <class T> friend class N::C; // #1, valid code
15283 };
15284 template <class T> class Y {
15285 friend class N::C; // #2, invalid code
15286 };
15288 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
15289 name lookup of `N::C'. We see that friend declaration must
15290 be template for the code to be valid. Note that
15291 processing_template_decl does not work here since it is
15292 always 1 for the above two cases. */
15294 decl = (cp_parser_maybe_treat_template_as_class
15299 {
15301 identifier,
15304 }
15307 {
15311 allow_template);
15315 }
15317 /* Forward declarations of nested types, such as
15319 class C1::C2;
15320 class C1::C2::C3;
15322 are invalid unless all components preceding the final '::'
15323 are complete. If all enclosing types are complete, these
15324 declarations become merely pointless.
15326 Invalid forward declarations of nested types are errors
15327 caught elsewhere in parsing. Those that are pointless arrive
15328 here. */
15335 }
15336 else
15337 {
15338 /* An elaborated-type-specifier sometimes introduces a new type and
15339 sometimes names an existing type. Normally, the rule is that it
15340 introduces a new type only if there is not an existing type of
15341 the same name already in scope. For example, given:
15343 struct S {};
15344 void f() { struct S s; }
15346 the `struct S' in the body of `f' is the same `struct S' as in
15347 the global scope; the existing definition is used. However, if
15348 there were no global declaration, this would introduce a new
15349 local class named `S'.
15351 An exception to this rule applies to the following code:
15353 namespace N { struct S; }
15355 Here, the elaborated-type-specifier names a new type
15356 unconditionally; even if there is already an `S' in the
15357 containing scope this declaration names a new type.
15358 This exception only applies if the elaborated-type-specifier
15359 forms the complete declaration:
15361 [class.name]
15363 A declaration consisting solely of `class-key identifier ;' is
15364 either a redeclaration of the name in the current scope or a
15365 forward declaration of the identifier as a class name. It
15366 introduces the name into the current scope.
15368 We are in this situation precisely when the next token is a `;'.
15370 An exception to the exception is that a `friend' declaration does
15371 *not* name a new type; i.e., given:
15373 struct S { friend struct T; };
15375 `T' is not a new type in the scope of `S'.
15377 Also, `new struct S' or `sizeof (struct S)' never results in the
15378 definition of a new type; a new type can only be declared in a
15379 declaration context. */
15381 tag_scope ts;
15385 /* Friends have special name lookup rules. */
15389 CPP_SEMICOLON))
15390 /* This is a `class-key identifier ;' */
15392 else
15395 template_p =
15396 (template_parm_lists_apply
15399 /* An unqualified name was used to reference this type, so
15400 there were no qualifying templates. */
15408 }
15409 }
15414 /* Allow attributes on forward declarations of classes. */
15416 {
15426 else
15429 }
15432 {
15433 /* Indicate whether this class was declared as a `class' or as a
15434 `struct'. */
15438 }
15440 /* A "<" cannot follow an elaborated type specifier. If that
15441 happens, the user was probably trying to form a template-id. */
15446 }
15448 /* Parse an enum-specifier.
15450 enum-specifier:
15451 enum-head { enumerator-list [opt] }
15452 enum-head { enumerator-list , } [C++0x]
15454 enum-head:
15455 enum-key identifier [opt] enum-base [opt]
15456 enum-key nested-name-specifier identifier enum-base [opt]
15458 enum-key:
15459 enum
15460 enum class [C++0x]
15461 enum struct [C++0x]
15463 enum-base: [C++0x]
15464 : type-specifier-seq
15466 opaque-enum-specifier:
15467 enum-key identifier enum-base [opt] ;
15469 GNU Extensions:
15470 enum-key attributes[opt] identifier [opt] enum-base [opt]
15471 { enumerator-list [opt] }attributes[opt]
15472 enum-key attributes[opt] identifier [opt] enum-base [opt]
15473 { enumerator-list, }attributes[opt] [C++0x]
15475 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
15476 if the token stream isn't an enum-specifier after all. */
15478 static tree
15480 {
15481 tree identifier;
15483 tree prev_scope;
15485 tree attributes;
15498 /* Parse tentatively so that we can back up if we don't find a
15499 enum-specifier. */
15502 /* Caller guarantees that the current token is 'enum', an identifier
15503 possibly follows, and the token after that is an opening brace.
15504 If we don't have an identifier, fabricate an anonymous name for
15505 the enumeration being defined. */
15508 /* Parse the "class" or "struct", which indicates a scoped
15509 enumeration type in C++0x. */
15512 {
15516 /* Consume the `struct' or `class' token. */
15520 }
15524 /* Clear the qualification. */
15529 /* Figure out in what scope the declaration is being placed. */
15535 nested_name_specifier
15543 {
15544 tree name;
15548 enum_type,
15553 input_location);
15555 {
15558 {
15559 /* Are template enums allowed in ISO? */
15563 /* ignore a typename reference, for it will be solved by name
15564 in start_enum. */
15566 }
15567 }
15570 else
15573 }
15574 else
15575 {
15578 else
15579 {
15585 }
15586 }
15589 /* Check for the `:' that denotes a specified underlying type in C++0x.
15590 Note that a ':' could also indicate a bitfield width, however. */
15592 {
15593 cp_decl_specifier_seq type_specifiers;
15595 /* Consume the `:'. */
15598 /* Parse the type-specifier-seq. */
15603 /* At this point this is surely not elaborated type specifier. */
15612 /* If that didn't work, stop. */
15614 {
15620 }
15621 }
15623 /* Look for the `{' but don't consume it yet. */
15625 {
15627 {
15630 {
15633 }
15634 }
15635 /* An opaque-enum-specifier must have a ';' here. */
15638 {
15641 {
15644 }
15645 }
15646 }
15652 {
15654 {
15658 }
15660 {
15662 }
15663 }
15665 /* Issue an error message if type-definitions are forbidden here. */
15668 else
15669 /* Create the new type. We do this before consuming the opening
15670 brace so the enum will be recorded as being on the line of its
15671 tag (or the 'enum' keyword, if there is no tag). */
15675 /* If the next token is not '{' it is an opaque-enum-specifier or an
15676 elaborated-type-specifier. */
15678 {
15682 {
15683 /* The following catches invalid code such as:
15684 enum class S<int>::E { A, B, C }; */
15692 {
15696 nested_name_specifier);
15698 }
15699 /* If that scope does not contain the scope in which the
15700 class was originally declared, the program is invalid. */
15702 nested_name_specifier))
15703 {
15706 "declaration of %qD in namespace %qD which does not "
15709 else
15711 "declaration of %qD in %qD which does not "
15715 }
15716 }
15721 /* Consume the opening brace. */
15728 {
15732 }
15733 else
15734 {
15740 }
15744 /* If the next token is not '}', then there are some enumerators. */
15746 {
15750 }
15751 else
15754 /* Consume the final '}'. */
15760 }
15761 else
15762 {
15763 /* If a ';' follows, then it is an opaque-enum-specifier
15764 and additional restrictions apply. */
15766 {
15773 }
15774 }
15776 /* Look for trailing attributes to apply to this enumeration, and
15777 apply them if appropriate. */
15779 {
15783 trailing_attr,
15785 }
15787 /* Finish up the enumeration. */
15789 {
15794 }
15797 {
15799 {
15802 }
15804 {
15806 }
15807 }
15808 out:
15811 }
15813 /* Parse an enumerator-list. The enumerators all have the indicated
15814 TYPE.
15816 enumerator-list:
15817 enumerator-definition
15818 enumerator-list , enumerator-definition */
15820 static void
15822 {
15824 {
15825 /* Parse an enumerator-definition. */
15828 /* If the next token is not a ',', we've reached the end of
15829 the list. */
15832 /* Otherwise, consume the `,' and keep going. */
15834 /* If the next token is a `}', there is a trailing comma. */
15836 {
15841 }
15842 }
15843 }
15845 /* Parse an enumerator-definition. The enumerator has the indicated
15846 TYPE.
15848 enumerator-definition:
15849 enumerator
15850 enumerator = constant-expression
15852 enumerator:
15853 identifier */
15855 static void
15857 {
15858 tree identifier;
15859 tree value;
15860 location_t loc;
15862 /* Save the input location because we are interested in the location
15863 of the identifier and not the location of the explicit value. */
15866 /* Look for the identifier. */
15871 /* If the next token is an '=', then there is an explicit value. */
15873 {
15874 /* Consume the `=' token. */
15876 /* Parse the value. */
15879 NULL);
15880 }
15881 else
15884 /* If we are processing a template, make sure the initializer of the
15885 enumerator doesn't contain any bare template parameter pack. */
15889 /* integral_constant_value will pull out this expression, so make sure
15890 it's folded as appropriate. */
15893 /* Create the enumerator. */
15895 }
15897 /* Parse a namespace-name.
15899 namespace-name:
15900 original-namespace-name
15901 namespace-alias
15903 Returns the NAMESPACE_DECL for the namespace. */
15905 static tree
15907 {
15908 tree identifier;
15909 tree namespace_decl;
15913 /* Get the name of the namespace. */
15918 /* Look up the identifier in the currently active scope. Look only
15919 for namespaces, due to:
15921 [basic.lookup.udir]
15923 When looking up a namespace-name in a using-directive or alias
15924 definition, only namespace names are considered.
15926 And:
15928 [basic.lookup.qual]
15930 During the lookup of a name preceding the :: scope resolution
15931 operator, object, function, and enumerator names are ignored.
15933 (Note that cp_parser_qualifying_entity only calls this
15934 function if the token after the name is the scope resolution
15935 operator.) */
15937 none_type,
15943 /* If it's not a namespace, issue an error. */
15946 {
15951 }
15954 }
15956 /* Parse a namespace-definition.
15958 namespace-definition:
15959 named-namespace-definition
15960 unnamed-namespace-definition
15962 named-namespace-definition:
15963 original-namespace-definition
15964 extension-namespace-definition
15966 original-namespace-definition:
15967 namespace identifier { namespace-body }
15969 extension-namespace-definition:
15970 namespace original-namespace-name { namespace-body }
15972 unnamed-namespace-definition:
15973 namespace { namespace-body } */
15975 static void
15977 {
15984 {
15988 }
15989 else
15992 /* Look for the `namespace' keyword. */
15995 /* Get the name of the namespace. We do not attempt to distinguish
15996 between an original-namespace-definition and an
15997 extension-namespace-definition at this point. The semantic
15998 analysis routines are responsible for that. */
16001 else
16004 /* Parse any specified attributes. */
16007 /* Look for the `{' to start the namespace. */
16009 /* Start the namespace. */
16012 /* "inline namespace" is equivalent to a stub namespace definition
16013 followed by a strong using directive. */
16015 {
16017 /* Set up namespace association. */
16021 /* Import the contents of the inline namespace. */
16025 }
16029 /* Parse the body of the namespace. */
16035 /* Finish the namespace. */
16037 /* Look for the final `}'. */
16039 }
16041 /* Parse a namespace-body.
16043 namespace-body:
16044 declaration-seq [opt] */
16046 static void
16048 {
16050 }
16052 /* Parse a namespace-alias-definition.
16054 namespace-alias-definition:
16055 namespace identifier = qualified-namespace-specifier ; */
16057 static void
16059 {
16060 tree identifier;
16061 tree namespace_specifier;
16065 /* Look for the `namespace' keyword. */
16067 /* Look for the identifier. */
16071 /* Look for the `=' token. */
16074 {
16076 /* Skip the definition. */
16081 }
16083 /* Look for the qualified-namespace-specifier. */
16084 namespace_specifier
16086 /* Look for the `;' token. */
16089 /* Register the alias in the symbol table. */
16091 }
16093 /* Parse a qualified-namespace-specifier.
16095 qualified-namespace-specifier:
16096 :: [opt] nested-name-specifier [opt] namespace-name
16098 Returns a NAMESPACE_DECL corresponding to the specified
16099 namespace. */
16101 static tree
16103 {
16104 /* Look for the optional `::'. */
16108 /* Look for the optional nested-name-specifier. */
16116 }
16118 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
16119 access declaration.
16121 using-declaration:
16122 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
16123 using :: unqualified-id ;
16125 access-declaration:
16126 qualified-id ;
16128 */
16130 static bool
16133 {
16137 tree decl;
16138 tree identifier;
16139 tree qscope;
16144 {
16147 }
16148 else
16149 {
16150 /* Look for the `using' keyword. */
16153 /* Peek at the next token. */
16155 /* See if it's `typename'. */
16157 {
16158 /* Remember that we've seen it. */
16160 /* Consume the `typename' token. */
16162 }
16163 }
16165 /* Look for the optional global scope qualification. */
16166 global_scope_p
16171 /* If we saw `typename', or didn't see `::', then there must be a
16172 nested-name-specifier present. */
16174 {
16180 {
16183 }
16184 }
16185 /* Otherwise, we could be in either of the two productions. In that
16186 case, treat the nested-name-specifier as optional. */
16187 else
16199 /* Something has already gone wrong; there's no need to parse
16200 further. Since an error has occurred, the return value of
16201 cp_parser_parse_definitely will be false, as required. */
16205 /* Parse the unqualified-id. */
16213 {
16218 }
16220 /* The function we call to handle a using-declaration is different
16221 depending on what scope we are in. */
16223 ;
16226 /* [namespace.udecl]
16228 A using declaration shall not name a template-id. */
16231 else
16232 {
16234 {
16235 /* Create the USING_DECL. */
16242 {
16245 }
16246 else
16247 /* Add it to the list of members in this class. */
16249 }
16250 else
16251 {
16253 identifier,
16260 {
16263 }
16266 else
16268 }
16269 }
16271 /* Look for the final `;'. */
16276 "access declarations are deprecated "
16277 "in favour of using-declarations; "
16281 }
16283 /* Parse an alias-declaration.
16285 alias-declaration:
16286 using identifier attribute-specifier-seq [opt] = type-id */
16288 static tree
16290 {
16292 location_t id_location;
16294 cp_decl_specifier_seq decl_specs;
16298 /* Look for the `using' keyword. */
16299 cp_token *using_token
16321 /* Now we are going to parse the type-id of the declaration. */
16323 /*
16324 [dcl.type]/3 says:
16326 "A type-specifier-seq shall not define a class or enumeration
16327 unless it appears in the type-id of an alias-declaration (7.1.3) that
16328 is not the declaration of a template-declaration."
16330 In other words, if we currently are in an alias template, the
16331 type-id should not define a type.
16333 So let's set parser->type_definition_forbidden_message in that
16334 case; cp_parser_check_type_definition (called by
16335 cp_parser_class_specifier) will then emit an error if a type is
16336 defined in the type-id. */
16338 {
16342 }
16346 /* Restore the error message if need be. */
16352 {
16355 }
16357 /* A typedef-name can also be introduced by an alias-declaration. The
16358 identifier following the using keyword becomes a typedef-name. It has
16359 the same semantics as if it were introduced by the typedef
16360 specifier. In particular, it does not define a new type and it shall
16361 not appear in the type-id. */
16366 {
16369 ds_attribute,
16370 attrs_token);
16371 }
16373 ds_typedef,
16374 using_token);
16376 ds_alias,
16377 using_token);
16386 else
16397 /* If decl is a template, return its TEMPLATE_DECL so that it gets
16398 added into the symbol table; otherwise, return the TYPE_DECL. */
16402 {
16406 }
16409 }
16411 /* Parse a using-directive.
16413 using-directive:
16414 using namespace :: [opt] nested-name-specifier [opt]
16415 namespace-name ; */
16417 static void
16419 {
16420 tree namespace_decl;
16421 tree attribs;
16423 /* Look for the `using' keyword. */
16425 /* And the `namespace' keyword. */
16427 /* Look for the optional `::' operator. */
16429 /* And the optional nested-name-specifier. */
16435 /* Get the namespace being used. */
16437 /* And any specified attributes. */
16439 /* Update the symbol table. */
16441 /* Look for the final `;'. */
16443 }
16445 /* Parse an asm-definition.
16447 asm-definition:
16448 asm ( string-literal ) ;
16450 GNU Extension:
16452 asm-definition:
16453 asm volatile [opt] ( string-literal ) ;
16454 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
16455 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16456 : asm-operand-list [opt] ) ;
16457 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16458 : asm-operand-list [opt]
16459 : asm-clobber-list [opt] ) ;
16460 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
16461 : asm-clobber-list [opt]
16462 : asm-goto-list ) ; */
16464 static void
16466 {
16467 tree string;
16472 tree asm_stmt;
16480 /* Look for the `asm' keyword. */
16482 /* See if the next token is `volatile'. */
16485 {
16486 /* Remember that we saw the `volatile' keyword. */
16488 /* Consume the token. */
16490 }
16494 {
16495 /* Remember that we saw the `goto' keyword. */
16497 /* Consume the token. */
16499 }
16500 /* Look for the opening `('. */
16503 /* Look for the string. */
16506 {
16510 }
16512 /* If we're allowing GNU extensions, check for the extended assembly
16513 syntax. Unfortunately, the `:' tokens need not be separated by
16514 a space in C, and so, for compatibility, we tolerate that here
16515 too. Doing that means that we have to treat the `::' operator as
16516 two `:' tokens. */
16521 {
16526 /* The extended syntax was used. */
16529 /* Look for outputs. */
16531 {
16532 /* Consume the `:'. */
16534 /* Parse the output-operands. */
16536 CPP_COLON)
16538 CPP_SCOPE)
16540 CPP_CLOSE_PAREN)
16546 }
16547 /* If the next token is `::', there are no outputs, and the
16548 next token is the beginning of the inputs. */
16550 /* The inputs are coming next. */
16553 /* Look for inputs. */
16556 {
16557 /* Consume the `:' or `::'. */
16559 /* Parse the output-operands. */
16561 CPP_COLON)
16563 CPP_SCOPE)
16565 CPP_CLOSE_PAREN))
16570 }
16572 /* The clobbers are coming next. */
16575 /* Look for clobbers. */
16578 {
16580 /* Consume the `:' or `::'. */
16582 /* Parse the clobbers. */
16584 CPP_COLON)
16586 CPP_CLOSE_PAREN))
16588 }
16591 /* The labels are coming next. */
16594 /* Look for labels. */
16597 {
16599 /* Consume the `:' or `::'. */
16601 /* Parse the labels. */
16603 }
16607 }
16611 /* Look for the closing `)'. */
16619 {
16620 /* Create the ASM_EXPR. */
16622 {
16625 /* If the extended syntax was not used, mark the ASM_EXPR. */
16627 {
16633 }
16634 }
16635 else
16637 }
16638 }
16640 /* Declarators [gram.dcl.decl] */
16642 /* Parse an init-declarator.
16644 init-declarator:
16645 declarator initializer [opt]
16647 GNU Extension:
16649 init-declarator:
16650 declarator asm-specification [opt] attributes [opt] initializer [opt]
16652 function-definition:
16653 decl-specifier-seq [opt] declarator ctor-initializer [opt]
16654 function-body
16655 decl-specifier-seq [opt] declarator function-try-block
16657 GNU Extension:
16659 function-definition:
16660 __extension__ function-definition
16662 TM Extension:
16664 function-definition:
16665 decl-specifier-seq [opt] declarator function-transaction-block
16667 The DECL_SPECIFIERS apply to this declarator. Returns a
16668 representation of the entity declared. If MEMBER_P is TRUE, then
16669 this declarator appears in a class scope. The new DECL created by
16670 this declarator is returned.
16672 The CHECKS are access checks that should be performed once we know
16673 what entity is being declared (and, therefore, what classes have
16674 befriended it).
16676 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
16677 for a function-definition here as well. If the declarator is a
16678 declarator for a function-definition, *FUNCTION_DEFINITION_P will
16679 be TRUE upon return. By that point, the function-definition will
16680 have been completely parsed.
16682 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
16683 is FALSE.
16685 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
16686 parsed declaration if it is an uninitialized single declarator not followed
16687 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
16688 if present, will not be consumed. If returned, this declarator will be
16689 created with SD_INITIALIZED but will not call cp_finish_decl. */
16691 static tree
16700 {
16704 tree prefix_attributes;
16706 tree asm_specification;
16707 tree initializer;
16709 tree scope;
16711 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
16712 initialized with "= ..", CPP_OPEN_PAREN if initialized with
16713 "(...)". */
16723 /* Gather the attributes that were provided with the
16724 decl-specifiers. */
16727 /* Assume that this is not the declarator for a function
16728 definition. */
16732 /* Default arguments are only permitted for function parameters. */
16736 /* Defer access checks while parsing the declarator; we cannot know
16737 what names are accessible until we know what is being
16738 declared. */
16741 /* Parse the declarator. */
16743 declarator
16748 /* Gather up the deferred checks. */
16753 /* If the DECLARATOR was erroneous, there's no need to go
16754 further. */
16758 /* Check that the number of template-parameter-lists is OK. */
16768 /* Figure out what scope the entity declared by the DECLARATOR is
16769 located in. `grokdeclarator' sometimes changes the scope, so
16770 we compute it now. */
16773 /* Perform any lookups in the declared type which were thought to be
16774 dependent, but are not in the scope of the declarator. */
16775 decl_specifiers->type
16778 /* If we're allowing GNU extensions, look for an
16779 asm-specification. */
16781 {
16782 /* Look for an asm-specification. */
16785 }
16786 else
16789 /* Look for attributes. */
16793 /* Peek at the next token. */
16799 {
16800 /* Check to see if the token indicates the start of a
16801 function-definition. */
16803 {
16805 {
16806 /* If a function-definition should not appear here, issue an
16807 error message. */
16811 }
16813 location_t func_brace_location
16816 /* Neither attributes nor an asm-specification are allowed
16817 on a function-definition. */
16820 "an asm-specification is not allowed "
16824 "attributes are not allowed "
16826 /* This is a function-definition. */
16829 /* Parse the function definition. */
16832 decl_specifiers,
16833 declarator,
16834 prefix_attributes);
16835 else
16836 decl =
16837 (cp_parser_function_definition_from_specifiers_and_declarator
16841 {
16842 /* This is where the prologue starts... */
16845 }
16848 }
16849 }
16851 {
16852 /* A non-template declaration involving a function parameter list
16853 containing an implicit template parameter will be made into a
16854 template. If the resulting declaration is not going to be an
16855 actual function then finish the template scope here to prevent it.
16856 An error message will be issued once we have a decl to talk about.
16858 FIXME probably we should do type deduction rather than create an
16859 implicit template, but the standard currently doesn't allow it. */
16862 }
16864 /* [dcl.dcl]
16866 Only in function declarations for constructors, destructors, and
16867 type conversions can the decl-specifier-seq be omitted.
16869 We explicitly postpone this check past the point where we handle
16870 function-definitions because we tolerate function-definitions
16871 that are missing their return types in some modes. */
16873 {
16877 }
16879 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
16883 {
16891 {
16897 }
16898 }
16899 else
16900 {
16901 /* If the init-declarator isn't initialized and isn't followed by a
16902 `,' or `;', it's not a valid init-declarator. */
16905 {
16908 else
16909 {
16912 }
16913 }
16916 }
16918 /* Because start_decl has side-effects, we should only call it if we
16919 know we're going ahead. By this point, we know that we cannot
16920 possibly be looking at any other construct. */
16923 /* Enter the newly declared entry in the symbol table. If we're
16924 processing a declaration in a class-specifier, we wait until
16925 after processing the initializer. */
16927 {
16934 /* Adjust location of decl if declarator->id_loc is more appropriate:
16935 set, and decl wasn't merged with another decl, in which case its
16936 location would be different from input_location, and more accurate. */
16941 }
16943 /* Enter the SCOPE. That way unqualified names appearing in the
16944 initializer will be looked up in SCOPE. */
16947 /* Perform deferred access control checks, now that we know in which
16948 SCOPE the declared entity resides. */
16950 {
16953 /* If the entity being declared is a function, pretend that we
16954 are in its scope. If it is a `friend', it may have access to
16955 things that would not otherwise be accessible. */
16957 {
16960 }
16962 /* Perform access checks for template parameters. */
16965 /* Perform the access control checks for the declarator and the
16966 decl-specifiers. */
16969 /* Restore the saved value. */
16972 }
16974 /* Parse the initializer. */
16979 {
16981 {
16985 else
16986 {
16987 /* If the declaration was erroneous, we don't really
16988 know what the user intended, so just silently
16989 consume the initializer. */
16997 }
16998 }
16999 else
17000 {
17001 /* We want to record the extra mangling scope for in-class
17002 initializers of class members and initializers of static data
17003 member templates. The former involves deferring
17004 parsing of the initializer until end of class as with default
17005 arguments. So right here we only handle the latter. */
17015 }
17016 }
17018 /* The old parser allows attributes to appear after a parenthesized
17019 initializer. Mark Mitchell proposed removing this functionality
17020 on the GCC mailing lists on 2002-08-13. This parser accepts the
17021 attributes -- but ignores them. */
17028 /* And now complain about a non-function implicit template. */
17033 /* For an in-class declaration, use `grokfield' to create the
17034 declaration. */
17036 {
17038 {
17041 }
17049 }
17051 /* Finish processing the declaration. But, skip member
17052 declarations. */
17054 {
17057 asm_specification,
17058 /* If the initializer is in parentheses, then this is
17059 a direct-initialization, which means that an
17060 `explicit' constructor is OK. Otherwise, an
17061 `explicit' constructor cannot be used. */
17064 }
17067 /* Core issue #226 (C++0x only): A default template-argument
17068 shall not be specified in a friend class template
17069 declaration. */
17078 {
17081 else
17083 }
17086 }
17088 /* Parse a declarator.
17090 declarator:
17091 direct-declarator
17092 ptr-operator declarator
17094 abstract-declarator:
17095 ptr-operator abstract-declarator [opt]
17096 direct-abstract-declarator
17098 GNU Extensions:
17100 declarator:
17101 attributes [opt] direct-declarator
17102 attributes [opt] ptr-operator declarator
17104 abstract-declarator:
17105 attributes [opt] ptr-operator abstract-declarator [opt]
17106 attributes [opt] direct-abstract-declarator
17108 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
17109 detect constructor, destructor or conversion operators. It is set
17110 to -1 if the declarator is a name, and +1 if it is a
17111 function. Otherwise it is set to zero. Usually you just want to
17112 test for >0, but internally the negative value is used.
17114 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
17115 a decl-specifier-seq unless it declares a constructor, destructor,
17116 or conversion. It might seem that we could check this condition in
17117 semantic analysis, rather than parsing, but that makes it difficult
17118 to handle something like `f()'. We want to notice that there are
17119 no decl-specifiers, and therefore realize that this is an
17120 expression, not a declaration.)
17122 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
17123 the declarator is a direct-declarator of the form "(...)".
17125 MEMBER_P is true iff this declarator is a member-declarator.
17127 FRIEND_P is true iff this declarator is a friend. */
17131 cp_parser_declarator_kind dcl_kind,
17135 {
17138 cp_cv_quals cv_quals;
17139 tree class_type;
17142 /* Assume this is not a constructor, destructor, or type-conversion
17143 operator. */
17150 /* Check for the ptr-operator production. */
17152 /* Parse the ptr-operator. */
17158 /* If that worked, then we have a ptr-operator. */
17160 {
17161 /* If a ptr-operator was found, then this declarator was not
17162 parenthesized. */
17165 /* The dependent declarator is optional if we are parsing an
17166 abstract-declarator. */
17170 /* Parse the dependent declarator. */
17175 friend_p);
17177 /* If we are parsing an abstract-declarator, we must handle the
17178 case where the dependent declarator is absent. */
17183 declarator = cp_parser_make_indirect_declarator
17185 }
17186 /* Everything else is a direct-declarator. */
17187 else
17188 {
17191 CPP_OPEN_PAREN);
17193 ctor_dtor_or_conv_p,
17195 }
17200 }
17202 /* Parse a direct-declarator or direct-abstract-declarator.
17204 direct-declarator:
17205 declarator-id
17206 direct-declarator ( parameter-declaration-clause )
17207 cv-qualifier-seq [opt]
17208 ref-qualifier [opt]
17209 exception-specification [opt]
17210 direct-declarator [ constant-expression [opt] ]
17211 ( declarator )
17213 direct-abstract-declarator:
17214 direct-abstract-declarator [opt]
17215 ( parameter-declaration-clause )
17216 cv-qualifier-seq [opt]
17217 ref-qualifier [opt]
17218 exception-specification [opt]
17219 direct-abstract-declarator [opt] [ constant-expression [opt] ]
17220 ( abstract-declarator )
17222 Returns a representation of the declarator. DCL_KIND is
17223 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
17224 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
17225 we are parsing a direct-declarator. It is
17226 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
17227 of ambiguity we prefer an abstract declarator, as per
17228 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P, MEMBER_P, and FRIEND_P are
17229 as for cp_parser_declarator. */
17233 cp_parser_declarator_kind dcl_kind,
17236 {
17246 {
17247 /* Peek at the next token. */
17250 {
17251 /* This is either a parameter-declaration-clause, or a
17252 parenthesized declarator. When we know we are parsing a
17253 named declarator, it must be a parenthesized declarator
17254 if FIRST is true. For instance, `(int)' is a
17255 parameter-declaration-clause, with an omitted
17256 direct-abstract-declarator. But `((*))', is a
17257 parenthesized abstract declarator. Finally, when T is a
17258 template parameter `(T)' is a
17259 parameter-declaration-clause, and not a parenthesized
17260 named declarator.
17262 We first try and parse a parameter-declaration-clause,
17263 and then try a nested declarator (if FIRST is true).
17265 It is not an error for it not to be a
17266 parameter-declaration-clause, even when FIRST is
17267 false. Consider,
17269 int i (int);
17270 int i (3);
17272 The first is the declaration of a function while the
17273 second is the definition of a variable, including its
17274 initializer.
17276 Having seen only the parenthesis, we cannot know which of
17277 these two alternatives should be selected. Even more
17278 complex are examples like:
17280 int i (int (a));
17281 int i (int (3));
17283 The former is a function-declaration; the latter is a
17284 variable initialization.
17286 Thus again, we try a parameter-declaration-clause, and if
17287 that fails, we back out and return. */
17290 {
17291 tree params;
17294 /* In a member-declarator, the only valid interpretation
17295 of a parenthesis is the start of a
17296 parameter-declaration-clause. (It is invalid to
17297 initialize a static data member with a parenthesized
17298 initializer; only the "=" form of initialization is
17299 permitted.) */
17303 /* Consume the `('. */
17306 {
17307 /* If this is going to be an abstract declarator, we're
17308 in a declarator and we can't have default args. */
17311 }
17315 /* Parse the parameter-declaration-clause. */
17318 /* Consume the `)'. */
17321 /* If all went well, parse the cv-qualifier-seq,
17322 ref-qualifier and the exception-specification. */
17324 {
17325 cp_cv_quals cv_quals;
17326 cp_virt_specifiers virt_specifiers;
17327 cp_ref_qualifier ref_qual;
17328 tree exception_specification;
17329 tree late_return;
17330 tree attrs;
17340 /* Parse the cv-qualifier-seq. */
17342 /* Parse the ref-qualifier. */
17344 /* And the exception-specification. */
17345 exception_specification
17350 /* In here, we handle cases where attribute is used after
17351 the function declaration. For example:
17352 void func (int x) __attribute__((vector(..))); */
17355 {
17359 CPP_SEMICOLON)
17361 CPP_OPEN_BRACE))
17364 ;
17365 else
17367 }
17368 late_return = (cp_parser_late_return_type_opt
17373 /* Parse the virt-specifier-seq. */
17376 /* Create the function-declarator. */
17378 params,
17379 cv_quals,
17380 virt_specifiers,
17381 ref_qual,
17382 exception_specification,
17383 late_return);
17385 /* Any subsequent parameter lists are to do with
17386 return type, so are not those of the declared
17387 function. */
17389 }
17391 /* Remove the function parms from scope. */
17395 /* Repeat the main loop. */
17397 }
17399 /* If this is the first, we can try a parenthesized
17400 declarator. */
17402 {
17408 /* Consume the `('. */
17410 /* Parse the nested declarator. */
17413 declarator
17419 /* Expect a `)'. */
17426 }
17427 /* Otherwise, we must be done. */
17428 else
17430 }
17434 {
17435 /* Parse an array-declarator. */
17444 /* Consume the `['. */
17446 /* Peek at the next token. */
17448 /* If the next token is `]', then there is no
17449 constant-expression. */
17451 {
17453 bounds
17463 {
17464 /* Normally, the array bound must be an integral constant
17465 expression. However, as an extension, we allow VLAs
17466 in function scopes as long as they aren't part of a
17467 parameter declaration. */
17471 }
17474 {
17475 /* Remember this wasn't a constant-expression. */
17478 }
17479 }
17480 else
17482 /* Look for the closing `]'. */
17484 {
17487 }
17492 }
17494 {
17495 {
17496 tree qualifying_scope;
17497 tree unqualified_name;
17498 tree attrs;
17499 special_function_kind sfk;
17504 /* Parse a declarator-id */
17507 {
17510 /* If we see an ellipsis, we should be looking at a
17511 parameter pack. */
17513 {
17514 /* Consume the `...' */
17518 }
17519 }
17522 unqualified_name
17526 {
17530 {
17531 /* Check whether an error occurred. */
17534 /* We already consumed the ellipsis to mark a
17535 parameter pack, but we have no way to report it,
17536 so abort the tentative parse. We will be exiting
17537 immediately anyway. */
17539 }
17540 else
17546 && (qualifying_scope
17548 {
17551 }
17552 }
17557 {
17562 }
17568 {
17569 /* In the declaration of a member of a template class
17570 outside of the class itself, the SCOPE will sometimes
17571 be a TYPENAME_TYPE. For example, given:
17573 template <typename T>
17574 int S<T>::R::i = 3;
17576 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
17577 this context, we must resolve S<T>::R to an ordinary
17578 type, rather than a typename type.
17580 The reason we normally avoid resolving TYPENAME_TYPEs
17581 is that a specialization of `S' might render
17582 `S<T>::R' not a type. However, if `S' is
17583 specialized, then this `i' will not be used, so there
17584 is no harm in resolving the types here. */
17585 tree type;
17587 /* Resolve the TYPENAME_TYPE. */
17590 /* If that failed, the declarator is invalid. */
17592 {
17595 "cannot define member of dependent typedef "
17597 else
17602 }
17604 }
17609 {
17610 tree class_type;
17615 else
17619 {
17622 {
17625 {
17629 "use %<%T::%D%> instead of %<%T::%D%> to "
17631 class_type,
17636 }
17637 else
17639 }
17640 else
17641 {
17642 /* We do not attempt to print the declarator
17643 here because we do not have enough
17644 information about its original syntactic
17645 form. */
17649 }
17650 }
17653 {
17659 for an anonymous type, even if the type
17660 got a name for linkage purposes. */
17662 /* Handle correctly (c++/19200):
17664 struct S {
17665 struct T{};
17666 friend void S(T);
17667 };
17669 and also:
17671 namespace N {
17672 void S();
17673 }
17675 struct S {
17676 friend void N::S();
17677 }; */
17678 && !(friend_p
17681 class_type))
17682 {
17685 }
17693 }
17694 }
17696 unqualified_name,
17697 sfk);
17704 }
17706 handle_declarator:;
17709 {
17710 /* Any names that appear after the declarator-id for a
17711 member are looked up in the containing scope. */
17713 {
17714 /* But declarations with qualified-ids can't appear in a
17715 function. */
17719 }
17721 }
17725 /* Default args are only allowed on function
17726 declarations. */
17728 else
17732 }
17733 /* We're done. */
17734 else
17736 }
17738 /* For an abstract declarator, we might wind up with nothing at this
17739 point. That's an error; the declarator is not optional. */
17743 /* If we entered a scope, we must exit it now. */
17751 }
17753 /* Parse a ptr-operator.
17755 ptr-operator:
17756 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17757 * cv-qualifier-seq [opt]
17758 &
17759 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
17760 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17762 GNU Extension:
17764 ptr-operator:
17765 & cv-qualifier-seq [opt]
17767 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
17768 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
17769 an rvalue reference. In the case of a pointer-to-member, *TYPE is
17770 filled in with the TYPE containing the member. *CV_QUALS is
17771 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
17772 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
17773 Note that the tree codes returned by this function have nothing
17774 to do with the types of trees that will be eventually be created
17775 to represent the pointer or reference type being parsed. They are
17776 just constants with suggestive names. */
17777 static enum tree_code
17782 {
17787 /* Assume that it's not a pointer-to-member. */
17789 /* And that there are no cv-qualifiers. */
17792 /* Peek at the next token. */
17795 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
17805 {
17806 /* Consume the `*', `&' or `&&'. */
17809 /* A `*' can be followed by a cv-qualifier-seq, and so can a
17810 `&', if we are allowing GNU extensions. (The only qualifier
17811 that can legally appear after `&' is `restrict', but that is
17812 enforced during semantic analysis. */
17820 }
17821 else
17822 {
17823 /* Try the pointer-to-member case. */
17825 /* Look for the optional `::' operator. */
17828 /* Look for the nested-name specifier. */
17835 /* If we found it, and the next token is a `*', then we are
17836 indeed looking at a pointer-to-member operator. */
17839 {
17840 /* Indicate that the `*' operator was used. */
17848 else
17849 {
17850 /* The type of which the member is a member is given by the
17851 current SCOPE. */
17853 /* The next name will not be qualified. */
17857 /* Look for optional c++11 attributes. */
17861 /* Look for the optional cv-qualifier-seq. */
17863 }
17864 }
17865 /* If that didn't work we don't have a ptr-operator. */
17868 }
17871 }
17873 /* Parse an (optional) cv-qualifier-seq.
17875 cv-qualifier-seq:
17876 cv-qualifier cv-qualifier-seq [opt]
17878 cv-qualifier:
17879 const
17880 volatile
17882 GNU Extension:
17884 cv-qualifier:
17885 __restrict__
17887 Returns a bitmask representing the cv-qualifiers. */
17889 static cp_cv_quals
17891 {
17895 {
17897 cp_cv_quals cv_qualifier;
17899 /* Peek at the next token. */
17901 /* See if it's a cv-qualifier. */
17903 {
17919 }
17925 {
17928 }
17929 else
17930 {
17933 }
17934 }
17937 }
17939 /* Parse an (optional) ref-qualifier
17941 ref-qualifier:
17942 &
17943 &&
17945 Returns cp_ref_qualifier representing ref-qualifier. */
17947 static cp_ref_qualifier
17949 {
17952 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
17957 {
17962 {
17974 }
17979 {
17982 }
17983 else
17984 {
17987 }
17988 }
17991 }
17993 /* Parse an (optional) virt-specifier-seq.
17995 virt-specifier-seq:
17996 virt-specifier virt-specifier-seq [opt]
17998 virt-specifier:
17999 override
18000 final
18002 Returns a bitmask representing the virt-specifiers. */
18004 static cp_virt_specifiers
18006 {
18010 {
18012 cp_virt_specifiers virt_specifier;
18014 /* Peek at the next token. */
18016 /* See if it's a virt-specifier-qualifier. */
18020 {
18023 }
18025 {
18028 }
18030 {
18032 }
18033 else
18037 {
18040 }
18041 else
18042 {
18045 }
18046 }
18048 }
18050 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
18051 is in scope even though it isn't real. */
18053 void
18055 {
18056 tree this_parm;
18059 {
18060 /* We don't clear this between NSDMIs. Is it already what we want? */
18065 }
18068 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
18070 current_class_ref
18073 }
18075 /* Return true iff our current scope is a non-static data member
18076 initializer. */
18078 bool
18080 {
18081 /* We recognize NSDMI context by the context-less 'this' pointer set up
18082 by the function above. */
18086 }
18088 /* Parse a late-specified return type, if any. This is not a separate
18089 non-terminal, but part of a function declarator, which looks like
18091 -> trailing-type-specifier-seq abstract-declarator(opt)
18093 Returns the type indicated by the type-id.
18095 In addition to this this parses any queued up omp declare simd
18096 clauses and Cilk Plus SIMD-enabled function's vector attributes.
18098 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
18099 function. */
18101 static tree
18103 cp_cv_quals quals)
18104 {
18108 && declarator
18114 /* Peek at the next token. */
18116 /* A late-specified return type is indicated by an initial '->'. */
18123 {
18124 /* DR 1207: 'this' is in scope in the trailing return type. */
18126 }
18129 {
18130 /* Consume the ->. */
18134 }
18137 declarator->std_attributes
18141 declarator->std_attributes
18146 {
18149 }
18152 }
18154 /* Parse a declarator-id.
18156 declarator-id:
18157 id-expression
18158 :: [opt] nested-name-specifier [opt] type-name
18160 In the `id-expression' case, the value returned is as for
18161 cp_parser_id_expression if the id-expression was an unqualified-id.
18162 If the id-expression was a qualified-id, then a SCOPE_REF is
18163 returned. The first operand is the scope (either a NAMESPACE_DECL
18164 or TREE_TYPE), but the second is still just a representation of an
18165 unqualified-id. */
18167 static tree
18169 {
18170 tree id;
18171 /* The expression must be an id-expression. Assume that qualified
18172 names are the names of types so that:
18174 template <class T>
18175 int S<T>::R::i = 3;
18177 will work; we must treat `S<T>::R' as the name of a type.
18178 Similarly, assume that qualified names are templates, where
18179 required, so that:
18181 template <class T>
18182 int S<T>::R<T>::i = 3;
18184 will work, too. */
18190 optional_p);
18194 }
18196 /* Parse a type-id.
18198 type-id:
18199 type-specifier-seq abstract-declarator [opt]
18201 Returns the TYPE specified. */
18203 static tree
18206 {
18207 cp_decl_specifier_seq type_specifier_seq;
18210 /* Parse the type-specifier-seq. */
18212 is_trailing_return,
18217 /* There might or might not be an abstract declarator. */
18219 /* Look for the declarator. */
18220 abstract_declarator
18225 /* Check to see if there really was a declarator. */
18230 /* None of the valid uses of 'auto' in C++14 involve the type-id
18231 nonterminal, but it is valid in a trailing-return-type. */
18234 {
18235 /* A type-id with type 'auto' is only ok if the abstract declarator
18236 is a function declarator with a late-specified return type. */
18241 else
18242 {
18245 }
18246 }
18249 is_template_arg);
18250 }
18253 {
18255 }
18258 {
18259 tree r;
18261 parser->type_definition_forbidden_message
18266 {
18269 }
18271 }
18274 {
18276 }
18278 /* Parse a type-specifier-seq.
18280 type-specifier-seq:
18281 type-specifier type-specifier-seq [opt]
18283 GNU extension:
18285 type-specifier-seq:
18286 attributes type-specifier-seq [opt]
18288 If IS_DECLARATION is true, we are at the start of a "condition" or
18289 exception-declaration, so we might be followed by a declarator-id.
18291 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
18292 i.e. we've just seen "->".
18294 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
18296 static void
18301 {
18306 /* Clear the TYPE_SPECIFIER_SEQ. */
18309 /* In the context of a trailing return type, enum E { } is an
18310 elaborated-type-specifier followed by a function-body, not an
18311 enum-specifier. */
18315 /* Parse the type-specifiers and attributes. */
18317 {
18318 tree type_specifier;
18321 /* Check for attributes first. */
18323 {
18328 }
18330 /* record the token of the beginning of the type specifier seq,
18331 for error reporting purposes*/
18335 /* Look for the type-specifier. */
18337 flags,
18338 type_specifier_seq,
18340 NULL,
18343 {
18344 /* If the first type-specifier could not be found, this is not a
18345 type-specifier-seq at all. */
18347 {
18348 /* Set in_declarator_p to avoid skipping to the semicolon. */
18360 }
18361 /* If subsequent type-specifiers could not be found, the
18362 type-specifier-seq is complete. */
18364 }
18367 /* The standard says that a condition can be:
18369 type-specifier-seq declarator = assignment-expression
18371 However, given:
18373 struct S {};
18374 if (int S = ...)
18376 we should treat the "S" as a declarator, not as a
18377 type-specifier. The standard doesn't say that explicitly for
18378 type-specifier-seq, but it does say that for
18379 decl-specifier-seq in an ordinary declaration. Perhaps it
18380 would be clearer just to allow a decl-specifier-seq here, and
18381 then add a semantic restriction that if any decl-specifiers
18382 that are not type-specifiers appear, the program is invalid. */
18385 }
18386 }
18388 /* Return whether the function currently being declared has an associated
18389 template parameter list. */
18391 static bool
18393 {
18406 }
18408 /* Parse a parameter-declaration-clause.
18410 parameter-declaration-clause:
18411 parameter-declaration-list [opt] ... [opt]
18412 parameter-declaration-list , ...
18414 Returns a representation for the parameter declarations. A return
18415 value of NULL indicates a parameter-declaration-clause consisting
18416 only of an ellipsis. */
18418 static tree
18420 {
18421 tree parameters;
18430 parser->auto_is_implicit_function_template_parm_p
18432 }
18438 && !processing_template_parmlist
18444 /* Peek at the next token. */
18446 /* Check for trivial parameter-declaration-clauses. */
18448 {
18449 /* Consume the `...' token. */
18452 }
18454 /* There are no parameters. */
18455 {
18456 #ifndef NO_IMPLICIT_EXTERN_C
18461 else
18462 #endif
18464 }
18465 /* Check for `(void)', too, which is a special case. */
18469 {
18470 /* Consume the `void' token. */
18472 /* There are no parameters. */
18474 }
18476 /* Parse the parameter-declaration-list. */
18478 /* If a parse error occurred while parsing the
18479 parameter-declaration-list, then the entire
18480 parameter-declaration-clause is erroneous. */
18484 /* Peek at the next token. */
18486 /* If it's a `,', the clause should terminate with an ellipsis. */
18488 {
18489 /* Consume the `,'. */
18491 /* Expect an ellipsis. */
18492 ellipsis_p
18494 }
18495 /* It might also be `...' if the optional trailing `,' was
18496 omitted. */
18498 {
18499 /* Consume the `...' token. */
18501 /* And remember that we saw it. */
18503 }
18504 else
18507 /* Finish the parameter list. */
18512 }
18514 /* Parse a parameter-declaration-list.
18516 parameter-declaration-list:
18517 parameter-declaration
18518 parameter-declaration-list , parameter-declaration
18520 Returns a representation of the parameter-declaration-list, as for
18521 cp_parser_parameter_declaration_clause. However, the
18522 `void_list_node' is never appended to the list. Upon return,
18523 *IS_ERROR will be true iff an error occurred. */
18525 static tree
18527 {
18533 /* Assume all will go well. */
18535 /* The special considerations that apply to a function within an
18536 unbraced linkage specifications do not apply to the parameters
18537 to the function. */
18538 saved_in_unbraced_linkage_specification_p
18542 /* Look for more parameters. */
18544 {
18552 /* Parse the parameter. */
18553 parameter
18558 /* We don't know yet if the enclosing context is deprecated, so wait
18559 and warn in grokparms if appropriate. */
18563 {
18564 /* If a function parameter pack was specified and an implicit template
18565 parameter was introduced during cp_parser_parameter_declaration,
18566 change any implicit parameters introduced into packs. */
18570 {
18578 }
18582 PARM,
18585 }
18589 /* If a parse error occurred parsing the parameter declaration,
18590 then the entire parameter-declaration-list is erroneous. */
18592 {
18596 }
18606 {
18610 }
18612 /* Add the new parameter to the list. */
18616 /* Peek at the next token. */
18619 /* These are for Objective-C++ */
18622 /* The parameter-declaration-list is complete. */
18625 {
18628 /* Peek at the next token. */
18630 /* If it's an ellipsis, then the list is complete. */
18633 /* Otherwise, there must be more parameters. Consume the
18634 `,'. */
18636 /* When parsing something like:
18638 int i(float f, double d)
18640 we can tell after seeing the declaration for "f" that we
18641 are not looking at an initialization of a variable "i",
18642 but rather at the declaration of a function "i".
18644 Due to the fact that the parsing of template arguments
18645 (as specified to a template-id) requires backtracking we
18646 cannot use this technique when inside a template argument
18647 list. */
18651 /* However, a parameter-declaration of the form
18652 "float(f)" (which is a valid declaration of a
18653 parameter "f") can also be interpreted as an
18654 expression (the conversion of "f" to "float"). */
18657 }
18658 else
18659 {
18667 }
18668 }
18670 parser->in_unbraced_linkage_specification_p
18673 /* Reset implicit_template_scope if we are about to leave the function
18674 parameter list that introduced it. Note that for out-of-line member
18675 definitions, there will be one or more class scopes before we get to
18676 the template parameter scope. */
18680 {
18684 {
18687 }
18688 }
18691 }
18693 /* Parse a parameter declaration.
18695 parameter-declaration:
18696 decl-specifier-seq ... [opt] declarator
18697 decl-specifier-seq declarator = assignment-expression
18698 decl-specifier-seq ... [opt] abstract-declarator [opt]
18699 decl-specifier-seq abstract-declarator [opt] = assignment-expression
18701 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
18702 declares a template parameter. (In that case, a non-nested `>'
18703 token encountered during the parsing of the assignment-expression
18704 is not interpreted as a greater-than operator.)
18706 Returns a representation of the parameter, or NULL if an error
18707 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
18708 true iff the declarator is of the form "(p)". */
18714 {
18716 cp_decl_specifier_seq decl_specifiers;
18718 tree default_argument;
18722 /* In a template parameter, `>' is not an operator.
18724 [temp.param]
18726 When parsing a default template-argument for a non-type
18727 template-parameter, the first non-nested `>' is taken as the end
18728 of the template parameter-list rather than a greater-than
18729 operator. */
18731 /* Type definitions may not appear in parameter types. */
18733 parser->type_definition_forbidden_message
18736 /* Parse the declaration-specifiers. */
18738 CP_PARSER_FLAGS_NONE,
18742 /* Complain about missing 'typename' or other invalid type names. */
18747 /* If an error occurred, there's no reason to attempt to parse the
18748 rest of the declaration. */
18750 {
18753 }
18755 /* Peek at the next token. */
18758 /* If the next token is a `)', `,', `=', `>', or `...', then there
18759 is no declarator. However, when variadic templates are enabled,
18760 there may be a declarator following `...'. */
18765 {
18769 }
18770 /* Otherwise, there should be a declarator. */
18771 else
18772 {
18776 /* After seeing a decl-specifier-seq, if the next token is not a
18777 "(", there is no possibility that the code is a valid
18778 expression. Therefore, if parsing tentatively, we commit at
18779 this point. */
18781 /* In an expression context, having seen:
18783 (int((char ...
18785 we cannot be sure whether we are looking at a
18786 function-type (taking a "char" as a parameter) or a cast
18787 of some object of type "char" to "int". */
18793 /* Parse the declarator. */
18796 CP_PARSER_DECLARATOR_EITHER,
18798 parenthesized_p,
18802 /* After the declarator, allow more attributes. */
18803 decl_specifiers.attributes
18806 }
18808 /* If the next token is an ellipsis, and we have not seen a
18809 declarator name, and the type of the declarator contains parameter
18810 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
18811 a parameter pack expansion expression. Otherwise, leave the
18812 ellipsis for a C-style variadic function. */
18815 {
18826 {
18827 /* Consume the `...'. */
18831 /* Build a pack expansion type */
18834 else
18836 }
18837 }
18839 /* The restriction on defining new types applies only to the type
18840 of the parameter, not to the default argument. */
18843 /* If the next token is `=', then process a default argument. */
18845 {
18847 /* If we are defining a class, then the tokens that make up the
18848 default argument must be saved and processed later. */
18853 /* Outside of a class definition, we can just parse the
18854 assignment-expression. */
18855 else
18856 default_argument
18860 {
18863 else
18864 {
18866 "default arguments are only "
18869 }
18870 }
18874 {
18875 /* Find the name of the parameter pack. */
18882 template_parm_p
18888 else
18890 template_parm_p
18897 }
18898 }
18899 else
18903 declarator,
18904 default_argument);
18905 }
18907 /* Parse a default argument and return it.
18909 TEMPLATE_PARM_P is true if this is a default argument for a
18910 non-type template parameter. */
18911 static tree
18913 {
18919 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
18920 set correctly. */
18923 /* Local variable names (and the `this' keyword) may not
18924 appear in a default argument. */
18927 /* Parse the assignment-expression. */
18932 /* The "this" pointer is not valid in a default argument. */
18934 {
18939 }
18940 default_argument
18942 /* Restore the "this" pointer. */
18944 {
18947 }
18956 }
18958 /* Parse a function-body.
18960 function-body:
18961 compound_statement */
18963 static void
18965 {
18967 }
18969 /* Parse a ctor-initializer-opt followed by a function-body. Return
18970 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
18971 is true we are parsing a function-try-block. */
18973 static bool
18976 {
18984 /* Begin the function body. */
18986 /* Parse the optional ctor-initializer. */
18989 /* If we're parsing a constexpr constructor definition, we need
18990 to check that the constructor body is indeed empty. However,
18991 before we get to cp_parser_function_body lot of junk has been
18992 generated, so we can't just check that we have an empty block.
18993 Rather we take a snapshot of the outermost block, and check whether
18994 cp_parser_function_body changed its state. */
18996 {
19000 }
19001 /* Parse the function-body. */
19005 /* Finish the function body. */
19009 }
19011 /* Parse an initializer.
19013 initializer:
19014 = initializer-clause
19015 ( expression-list )
19017 Returns an expression representing the initializer. If no
19018 initializer is present, NULL_TREE is returned.
19020 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
19021 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
19022 set to TRUE if there is no initializer present. If there is an
19023 initializer, and it is not a constant-expression, *NON_CONSTANT_P
19024 is set to true; otherwise it is set to false. */
19026 static tree
19029 {
19031 tree init;
19033 /* Peek at the next token. */
19036 /* Let our caller know whether or not this initializer was
19037 parenthesized. */
19039 /* Assume that the initializer is constant. */
19043 {
19044 /* Consume the `='. */
19046 /* Parse the initializer-clause. */
19048 }
19050 {
19055 non_constant_p);
19060 }
19062 {
19067 }
19068 else
19069 {
19070 /* Anything else is an error. */
19073 }
19076 }
19078 /* Parse an initializer-clause.
19080 initializer-clause:
19081 assignment-expression
19082 braced-init-list
19084 Returns an expression representing the initializer.
19086 If the `assignment-expression' production is used the value
19087 returned is simply a representation for the expression.
19089 Otherwise, calls cp_parser_braced_list. */
19091 static tree
19093 {
19094 tree initializer;
19096 /* Assume the expression is constant. */
19099 /* If it is not a `{', then we are looking at an
19100 assignment-expression. */
19102 {
19103 initializer
19106 non_constant_p);
19107 }
19108 else
19112 }
19114 /* Parse a brace-enclosed initializer list.
19116 braced-init-list:
19117 { initializer-list , [opt] }
19118 { }
19120 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
19121 the elements of the initializer-list (or NULL, if the last
19122 production is used). The TREE_TYPE for the CONSTRUCTOR will be
19123 NULL_TREE. There is no way to detect whether or not the optional
19124 trailing `,' was provided. NON_CONSTANT_P is as for
19125 cp_parser_initializer. */
19127 static tree
19129 {
19130 tree initializer;
19132 /* Consume the `{' token. */
19134 /* Create a CONSTRUCTOR to represent the braced-initializer. */
19136 /* If it's not a `}', then there is a non-trivial initializer. */
19138 {
19139 /* Parse the initializer list. */
19142 /* A trailing `,' token is allowed. */
19145 }
19146 else
19148 /* Now, there should be a trailing `}'. */
19152 }
19154 /* Parse an initializer-list.
19156 initializer-list:
19157 initializer-clause ... [opt]
19158 initializer-list , initializer-clause ... [opt]
19160 GNU Extension:
19162 initializer-list:
19163 designation initializer-clause ...[opt]
19164 initializer-list , designation initializer-clause ...[opt]
19166 designation:
19167 . identifier =
19168 identifier :
19169 [ constant-expression ] =
19171 Returns a vec of constructor_elt. The VALUE of each elt is an expression
19172 for the initializer. If the INDEX of the elt is non-NULL, it is the
19173 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
19174 as for cp_parser_initializer. */
19178 {
19181 /* Assume all of the expressions are constant. */
19184 /* Parse the rest of the list. */
19186 {
19188 tree designator;
19189 tree initializer;
19192 /* If the next token is an identifier and the following one is a
19193 colon, we are looking at the GNU designated-initializer
19194 syntax. */
19198 {
19199 /* Warn the user that they are using an extension. */
19202 /* Consume the identifier. */
19204 /* Consume the `:'. */
19206 }
19207 /* Also handle the C99 syntax, '. id ='. */
19212 {
19213 /* Warn the user that they are using an extension. */
19216 /* Consume the `.'. */
19218 /* Consume the identifier. */
19220 /* Consume the `='. */
19222 }
19223 /* Also handle C99 array designators, '[ const ] ='. */
19227 {
19228 /* In C++11, [ could start a lambda-introducer. */
19240 }
19241 else
19244 /* Parse the initializer. */
19247 /* If any clause is non-constant, so is the entire initializer. */
19251 /* If we have an ellipsis, this is an initializer pack
19252 expansion. */
19254 {
19255 /* Consume the `...'. */
19258 /* Turn the initializer into an initializer expansion. */
19260 }
19262 /* Add it to the vector. */
19265 /* If the next token is not a comma, we have reached the end of
19266 the list. */
19270 /* Peek at the next token. */
19272 /* If the next token is a `}', then we're still done. An
19273 initializer-clause can have a trailing `,' after the
19274 initializer-list and before the closing `}'. */
19278 /* Consume the `,' token. */
19280 }
19283 }
19285 /* Classes [gram.class] */
19287 /* Parse a class-name.
19289 class-name:
19290 identifier
19291 template-id
19293 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
19294 to indicate that names looked up in dependent types should be
19295 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
19296 keyword has been used to indicate that the name that appears next
19297 is a template. TAG_TYPE indicates the explicit tag given before
19298 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
19299 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
19300 is the class being defined in a class-head.
19302 Returns the TYPE_DECL representing the class. */
19304 static tree
19312 {
19313 tree decl;
19314 tree scope;
19319 /* All class-names start with an identifier. */
19322 {
19325 }
19327 /* PARSER->SCOPE can be cleared when parsing the template-arguments
19328 to a template-id, so we save it here. */
19333 /* Any name names a type if we're following the `typename' keyword
19334 in a qualified name where the enclosing scope is type-dependent. */
19337 /* Handle the common case (an identifier, but not a template-id)
19338 efficiently. */
19341 {
19345 /* Look for the identifier. */
19349 /* If the next token isn't an identifier, we are certainly not
19350 looking at a class-name. */
19353 /* If we know this is a type-name, there's no need to look it
19354 up. */
19357 else
19358 {
19359 tree ambiguous_decls;
19360 /* If we already know that this lookup is ambiguous, then
19361 we've already issued an error message; there's no reason
19362 to check again. */
19364 {
19367 }
19368 /* If the next token is a `::', then the name must be a type
19369 name.
19371 [basic.lookup.qual]
19373 During the lookup for a name preceding the :: scope
19374 resolution operator, object, function, and enumerator
19375 names are ignored. */
19378 /* Look up the name. */
19380 tag_type,
19383 check_dependency_p,
19387 {
19391 }
19392 }
19393 }
19394 else
19395 {
19396 /* Try a template-id. */
19398 check_dependency_p,
19399 tag_type,
19400 is_declaration);
19403 }
19407 /* If this is a typename, create a TYPENAME_TYPE. */
19409 {
19414 }
19418 /* Check to see that it is really the name of a class. */
19422 /* Situations like this:
19424 template <typename T> struct A {
19425 typename T::template X<int>::I i;
19426 };
19428 are problematic. Is `T::template X<int>' a class-name? The
19429 standard does not seem to be definitive, but there is no other
19430 valid interpretation of the following `::'. Therefore, those
19431 names are considered class-names. */
19432 {
19436 }
19440 /* In Objective-C 2.0, a classname followed by '.' starts a
19441 dot-syntax expression, and it's not a type-name. */
19453 }
19455 /* Parse a class-specifier.
19457 class-specifier:
19458 class-head { member-specification [opt] }
19460 Returns the TREE_TYPE representing the class. */
19462 static tree
19464 {
19465 tree type;
19479 /* Parse the class-head. */
19482 /* If the class-head was a semantic disaster, skip the entire body
19483 of the class. */
19485 {
19489 }
19491 /* Look for the `{'. */
19493 {
19496 }
19500 /* Issue an error message if type-definitions are forbidden here. */
19502 /* Remember that we are defining one more class. */
19504 /* Inside the class, surrounding template-parameter-lists do not
19505 apply. */
19506 saved_num_template_parameter_lists
19509 /* We are not in a function body. */
19512 /* Or in a loop. */
19515 /* Or in a switch. */
19518 /* We are not immediately inside an extern "lang" block. */
19519 saved_in_unbraced_linkage_specification_p
19523 /* Start the class. */
19525 {
19528 }
19532 /* If the type is erroneous, skip the entire body of the class. */
19534 else
19535 /* Parse the member-specification. */
19538 /* Look for the trailing `}'. */
19540 /* Look for trailing attributes to apply to this class. */
19548 /* We've finished a type definition. Check for the common syntax
19549 error of forgetting a semicolon after the definition. We need to
19550 be careful, as we can't just check for not-a-semicolon and be done
19551 with it; the user might have typed:
19553 class X { } c = ...;
19554 class X { } *p = ...;
19556 and so forth. Instead, enumerate all the possible tokens that
19557 might follow this production; if we don't see one of them, then
19558 complain and silently insert the semicolon. */
19559 {
19564 /* Don't try to parse c++11 attributes here. As per the
19565 grammar, that should be a task for
19566 cp_parser_decl_specifier_seq. */
19570 {
19581 /* While it's legal for type qualifiers and storage class
19582 specifiers to follow type definitions in the grammar, only
19583 compiler testsuites contain code like that. Assume that if
19584 we see such code, then what we're really seeing is a case
19585 like:
19587 class X { }
19588 const <type> var = ...;
19590 or
19592 class Y { }
19593 static <type> func (...) ...
19595 i.e. the qualifier or specifier applies to the next
19596 declaration. To do so, however, we need to look ahead one
19597 more token to see if *that* token is a type specifier.
19599 This code could be improved to handle:
19601 class Z { }
19602 static const <type> var = ...; */
19605 {
19608 /* Handling user-defined types here would be nice, but very
19609 tricky. */
19610 want_semicolon
19613 }
19617 }
19619 /* If we don't have a type, then something is very wrong and we
19620 shouldn't try to do anything clever. Likewise for not seeing the
19621 closing brace. */
19623 {
19624 cp_token_position prev
19635 else
19638 /* Unget one token and smash it to look as though we encountered
19639 a semicolon in the input stream. */
19644 }
19645 }
19647 /* If this class is not itself within the scope of another class,
19648 then we need to parse the bodies of all of the queued function
19649 definitions. Note that the queued functions defined in a class
19650 are not always processed immediately following the
19651 class-specifier for that class. Consider:
19653 struct A {
19654 struct B { void f() { sizeof (A); } };
19655 };
19657 If `f' were processed before the processing of `A' were
19658 completed, there would be no way to compute the size of `A'.
19659 Note that the nesting we are interested in here is lexical --
19660 not the semantic nesting given by TYPE_CONTEXT. In particular,
19661 for:
19663 struct A { struct B; };
19664 struct A::B { void f() { } };
19666 there is no need to delay the parsing of `A::B::f'. */
19668 {
19669 tree decl;
19676 /* In a first pass, parse default arguments to the functions.
19677 Then, in a second pass, parse the bodies of the functions.
19678 This two-phased approach handles cases like:
19680 struct S {
19681 void f() { g(); }
19682 void g(int i = 3);
19683 };
19685 */
19687 {
19689 /* If there are default arguments that have not yet been processed,
19690 take care of them now. */
19692 {
19697 }
19698 /* Make sure that any template parameters are in scope. */
19700 /* Parse the default argument expressions. */
19702 /* Remove any template parameters from the symbol table. */
19704 }
19706 /* Now parse any NSDMIs. */
19710 {
19712 {
19717 }
19720 }
19727 /* Now do some post-NSDMI bookkeeping. */
19733 /* Now parse the body of the functions. */
19735 {
19736 /* OpenMP UDRs need to be parsed before all other functions. */
19743 }
19744 else
19748 }
19749 else
19752 /* Put back any saved access checks. */
19755 /* Restore saved state. */
19759 parser->num_template_parameter_lists
19761 parser->in_unbraced_linkage_specification_p
19765 }
19767 static tree
19769 {
19770 tree ret;
19775 }
19777 /* Parse a class-head.
19779 class-head:
19780 class-key identifier [opt] base-clause [opt]
19781 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
19782 class-key nested-name-specifier [opt] template-id
19783 base-clause [opt]
19785 class-virt-specifier:
19786 final
19788 GNU Extensions:
19789 class-key attributes identifier [opt] base-clause [opt]
19790 class-key attributes nested-name-specifier identifier base-clause [opt]
19791 class-key attributes nested-name-specifier [opt] template-id
19792 base-clause [opt]
19794 Upon return BASES is initialized to the list of base classes (or
19795 NULL, if there are none) in the same form returned by
19796 cp_parser_base_clause.
19798 Returns the TYPE of the indicated class. Sets
19799 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
19800 involving a nested-name-specifier was used, and FALSE otherwise.
19802 Returns error_mark_node if this is not a class-head.
19804 Returns NULL_TREE if the class-head is syntactically valid, but
19805 semantically invalid in a way that means we should skip the entire
19806 body of the class. */
19808 static tree
19811 {
19812 tree nested_name_specifier;
19816 tree attributes;
19817 tree bases;
19827 /* Assume no nested-name-specifier will be present. */
19829 /* Assume no template parameter lists will be used in defining the
19830 type. */
19834 /* Look for the class-key. */
19839 /* Parse the attributes. */
19842 /* If the next token is `::', that is invalid -- but sometimes
19843 people do try to write:
19845 struct ::S {};
19847 Handle this gracefully by accepting the extra qualifier, and then
19848 issuing an error about it later if this really is a
19849 class-head. If it turns out just to be an elaborated type
19850 specifier, remain silent. */
19856 /* Determine the name of the class. Begin by looking for an
19857 optional nested-name-specifier. */
19859 nested_name_specifier
19865 /* If there was a nested-name-specifier, then there *must* be an
19866 identifier. */
19868 {
19870 /* Although the grammar says `identifier', it really means
19871 `class-name' or `template-name'. You are only allowed to
19872 define a class that has already been declared with this
19873 syntax.
19875 The proposed resolution for Core Issue 180 says that wherever
19876 you see `class T::X' you should treat `X' as a type-name.
19878 It is OK to define an inaccessible class; for example:
19880 class A { class B; };
19881 class A::B {};
19883 We do not know if we will see a class-name, or a
19884 template-name. We look for a class-name first, in case the
19885 class-name is a template-id; if we looked for the
19886 template-name first we would stop after the template-name. */
19891 class_type,
19895 /* If that didn't work, ignore the nested-name-specifier. */
19897 {
19903 }
19904 /* If we could not find a corresponding TYPE, treat this
19905 declaration like an unqualified declaration. */
19908 /* Otherwise, count the number of templates used in TYPE and its
19909 containing scopes. */
19910 else
19911 {
19912 tree scope;
19924 }
19925 }
19926 /* Otherwise, the identifier is optional. */
19927 else
19928 {
19929 /* We don't know whether what comes next is a template-id,
19930 an identifier, or nothing at all. */
19932 /* Check for a template-id. */
19937 class_key,
19939 /* If that didn't work, it could still be an identifier. */
19941 {
19943 {
19946 }
19947 else
19949 }
19950 else
19951 {
19954 }
19955 }
19960 {
19962 class_key,
19964 }
19967 /* If it's not a `:' or a `{' then we can't really be looking at a
19968 class-head, since a class-head only appears as part of a
19969 class-specifier. We have to detect this situation before calling
19970 xref_tag, since that has irreversible side-effects. */
19972 {
19976 }
19978 /* At this point, we're going ahead with the class-specifier, even
19979 if some other problem occurs. */
19982 {
19987 }
19988 /* Issue the error about the overly-qualified name now. */
19990 {
19995 }
19997 {
20002 }
20004 {
20005 tree scope;
20007 /* Reject typedef-names in class heads. */
20009 {
20012 type);
20015 }
20017 /* Figure out in what scope the declaration is being placed. */
20019 /* If that scope does not contain the scope in which the
20020 class was originally declared, the program is invalid. */
20022 {
20025 "declaration of %qD in namespace %qD which does not "
20028 else
20034 }
20035 /* [dcl.meaning]
20037 A declarator-id shall not be qualified except for the
20038 definition of a ... nested class outside of its class
20039 ... [or] the definition or explicit instantiation of a
20040 class member of a namespace outside of its namespace. */
20042 {
20047 }
20048 }
20049 /* An explicit-specialization must be preceded by "template <>". If
20050 it is not, try to recover gracefully. */
20054 {
20058 /* Take the same action that would have been taken by
20059 cp_parser_explicit_specialization. */
20062 }
20063 /* There must be no "return" statements between this point and the
20064 end of this function; set "type "to the correct return value and
20065 use "goto done;" to return. */
20066 /* Make sure that the right number of template parameters were
20067 present. */
20071 {
20072 /* If something went wrong, there is no point in even trying to
20073 process the class-definition. */
20076 }
20078 /* Look up the type. */
20080 {
20084 {
20088 }
20089 else
20090 {
20093 }
20096 }
20098 {
20099 tree class_type;
20101 /* Given:
20103 template <typename T> struct S { struct T };
20104 template <typename T> struct S<T>::T { };
20106 we will get a TYPENAME_TYPE when processing the definition of
20107 `S::T'. We need to resolve it to the actual type before we
20108 try to define it. */
20110 {
20115 else
20116 {
20119 }
20120 }
20124 {
20127 }
20130 /* Enter the scope indicated by the nested-name-specifier. */
20132 /* Get the canonical version of this type. */
20134 /* Call push_template_decl if it seems like we should be defining a
20135 template either from the template headers or the type we're
20136 defining, so that we diagnose both extra and missing headers. */
20142 {
20145 {
20148 }
20149 }
20153 }
20155 {
20156 /* If the class was unnamed, create a dummy name. */
20161 }
20163 /* Indicate whether this class was declared as a `class' or as a
20164 `struct'. */
20169 /* If this type was already complete, and we see another definition,
20170 that's an error. */
20172 {
20174 type);
20176 type);
20179 }
20184 {
20185 /* Apply attributes now, before any use of the class as a template
20186 argument in its base list. */
20189 }
20191 /* We will have entered the scope containing the class; the names of
20192 base classes should be looked up in that context. For example:
20194 struct A { struct B {}; struct C; };
20195 struct A::C : B {};
20197 is valid. */
20199 /* Get the list of base-classes, if there is one. */
20201 {
20202 /* PR59482: enter the class scope so that base-specifiers are looked
20203 up correctly. */
20207 /* PR59482: get out of the previously pushed class scope so that the
20208 subsequent pops pop the right thing. */
20211 }
20212 else
20215 /* If we're really defining a class, process the base classes.
20216 If they're invalid, fail. */
20221 done:
20222 /* Leave the scope given by the nested-name-specifier. We will
20223 enter the class scope itself while processing the members. */
20228 {
20231 }
20237 out:
20240 }
20242 /* Parse a class-key.
20244 class-key:
20245 class
20246 struct
20247 union
20249 Returns the kind of class-key specified, or none_type to indicate
20250 error. */
20252 static enum tag_types
20254 {
20258 /* Look for the class-key. */
20263 /* Check to see if the TOKEN is a class-key. */
20268 }
20270 /* Parse a type-parameter-key.
20272 type-parameter-key:
20273 class
20274 typename
20275 */
20277 static void
20279 {
20280 /* Look for the type-parameter-key. */
20284 {
20287 /* typename is not allowed in a template template parameter
20288 by the standard until C++1Z. */
20290 "ISO C++ forbids typename key in template template parameter;"
20292 }
20293 else
20297 }
20299 /* Parse an (optional) member-specification.
20301 member-specification:
20302 member-declaration member-specification [opt]
20303 access-specifier : member-specification [opt] */
20305 static void
20307 {
20309 {
20313 /* Peek at the next token. */
20315 /* If it's a `}', or EOF then we've seen all the members. */
20321 /* See if this token is a keyword. */
20324 {
20328 /* Consume the access-specifier. */
20330 /* Remember which access-specifier is active. */
20332 /* Look for the `:'. */
20337 /* Accept #pragmas at class scope. */
20339 {
20342 }
20344 /* Otherwise, the next construction must be a
20345 member-declaration. */
20347 }
20348 }
20349 }
20351 /* Parse a member-declaration.
20353 member-declaration:
20354 decl-specifier-seq [opt] member-declarator-list [opt] ;
20355 function-definition ; [opt]
20356 :: [opt] nested-name-specifier template [opt] unqualified-id ;
20357 using-declaration
20358 template-declaration
20359 alias-declaration
20361 member-declarator-list:
20362 member-declarator
20363 member-declarator-list , member-declarator
20365 member-declarator:
20366 declarator pure-specifier [opt]
20367 declarator constant-initializer [opt]
20368 identifier [opt] : constant-expression
20370 GNU Extensions:
20372 member-declaration:
20373 __extension__ member-declaration
20375 member-declarator:
20376 declarator attributes [opt] pure-specifier [opt]
20377 declarator attributes [opt] constant-initializer [opt]
20378 identifier [opt] attributes [opt] : constant-expression
20380 C++0x Extensions:
20382 member-declaration:
20383 static_assert-declaration */
20385 static void
20387 {
20388 cp_decl_specifier_seq decl_specifiers;
20389 tree prefix_attributes;
20390 tree decl;
20399 /* Check for the `__extension__' keyword. */
20401 {
20402 /* Recurse. */
20404 /* Restore the old value of the PEDANTIC flag. */
20408 }
20410 /* Check for a template-declaration. */
20412 {
20413 /* An explicit specialization here is an error condition, and we
20414 expect the specialization handler to detect and report this. */
20418 else
20422 }
20424 /* Check for a using-declaration. */
20426 {
20428 {
20429 /* Parse the using-declaration. */
20433 }
20434 else
20435 {
20436 tree decl;
20440 /* Note that if we actually see the '=' token after the
20441 identifier, cp_parser_alias_declaration commits the
20442 tentative parse. In that case, we really expects an
20443 alias-declaration. Otherwise, we expect a using
20444 declaration. */
20445 alias_decl_expected =
20451 else
20455 }
20456 }
20458 /* Check for @defs. */
20460 {
20465 {
20470 }
20472 }
20474 /* If the next token is `static_assert' we have a static assertion. */
20476 {
20479 }
20486 /* Parse the decl-specifier-seq. */
20489 CP_PARSER_FLAGS_OPTIONAL,
20492 /* Check for an invalid type-name. */
20496 /* If there is no declarator, then the decl-specifier-seq should
20497 specify a type. */
20499 {
20500 /* If there was no decl-specifier-seq, and the next token is a
20501 `;', then we have something like:
20503 struct S { ; };
20505 [class.mem]
20507 Each member-declaration shall declare at least one member
20508 name of the class. */
20510 {
20514 }
20515 else
20516 {
20517 tree type;
20519 /* See if this declaration is a friend. */
20521 /* If there were decl-specifiers, check to see if there was
20522 a class-declaration. */
20525 /* Nested classes have already been added to the class, but
20526 a `friend' needs to be explicitly registered. */
20528 {
20529 /* If the `friend' keyword was present, the friend must
20530 be introduced with a class-key. */
20533 "in C++03 a class-key must be used "
20535 /* In this case:
20537 template <typename T> struct A {
20538 friend struct A<T>::B;
20539 };
20541 A<T>::B will be represented by a TYPENAME_TYPE, and
20542 therefore not recognized by check_tag_decl. */
20544 {
20548 }
20551 "friend declaration does not name a class or "
20553 else
20556 }
20557 /* If there is no TYPE, an error message will already have
20558 been issued. */
20560 ;
20561 /* An anonymous aggregate has to be handled specially; such
20562 a declaration really declares a data member (with a
20563 particular type), as opposed to a nested class. */
20565 {
20566 /* C++11 9.5/6. */
20569 "a storage class on an anonymous aggregate "
20572 /* Remove constructors and such from TYPE, now that we
20573 know it is an anonymous aggregate. */
20575 /* And make the corresponding data member. */
20578 /* Add it to the class. */
20580 }
20581 else
20582 cp_parser_check_access_in_redeclaration
20585 }
20586 }
20587 else
20588 {
20591 /* Clear attributes from the decl_specifiers but keep them
20592 around as prefix attributes that apply them to the entity
20593 being declared. */
20597 /* See if these declarations will be friends. */
20600 /* Keep going until we hit the `;' at the end of the
20601 declaration. */
20603 {
20605 tree first_attribute;
20607 /* Peek at the next token. */
20610 /* Check for a bitfield declaration. */
20615 {
20616 tree identifier;
20617 tree width;
20619 /* Get the name of the bitfield. Note that we cannot just
20620 check TOKEN here because it may have been invalidated by
20621 the call to cp_lexer_peek_nth_token above. */
20624 else
20627 /* Consume the `:' token. */
20629 /* Get the width of the bitfield. */
20630 width
20633 NULL);
20635 /* Look for attributes that apply to the bitfield. */
20637 /* Remember which attributes are prefix attributes and
20638 which are not. */
20640 /* Combine the attributes. */
20643 /* Create the bitfield declaration. */
20646 identifier,
20647 sfk_none)
20650 width,
20651 attributes);
20652 }
20653 else
20654 {
20656 tree initializer;
20657 tree asm_specification;
20660 /* Parse the declarator. */
20661 declarator
20666 friend_p);
20668 /* If something went wrong parsing the declarator, make sure
20669 that we at least consume some tokens. */
20671 {
20672 /* Skip to the end of the statement. */
20674 /* If the next token is not a semicolon, that is
20675 probably because we just skipped over the body of
20676 a function. So, we consume a semicolon if
20677 present, but do not issue an error message if it
20678 is not present. */
20680 CPP_SEMICOLON))
20683 }
20686 cp_parser_check_for_definition_in_return_type
20690 /* Look for an asm-specification. */
20692 /* Look for attributes that apply to the declaration. */
20694 /* Remember which attributes are prefix attributes and
20695 which are not. */
20697 /* Combine the attributes. */
20700 /* If it's an `=', then we have a constant-initializer or a
20701 pure-specifier. It is not correct to parse the
20702 initializer before registering the member declaration
20703 since the member declaration should be in scope while
20704 its initializer is processed. However, the rest of the
20705 front end does not yet provide an interface that allows
20706 us to handle this correctly. */
20708 {
20709 /* In [class.mem]:
20711 A pure-specifier shall be used only in the declaration of
20712 a virtual function.
20714 A member-declarator can contain a constant-initializer
20715 only if it declares a static member of integral or
20716 enumeration type.
20718 Therefore, if the DECLARATOR is for a function, we look
20719 for a pure-specifier; otherwise, we look for a
20720 constant-initializer. When we call `grokfield', it will
20721 perform more stringent semantics checks. */
20733 {
20735 /* Don't require a constant rvalue in C++11, since we
20736 might want a reference constant. We'll enforce
20737 constancy later. */
20739 /* Parse the initializer. */
20742 }
20743 else
20744 /* Parse the initializer. */
20746 }
20749 {
20753 else
20755 }
20756 /* Otherwise, there is no initializer. */
20757 else
20760 /* See if we are probably looking at a function
20761 definition. We are certainly not looking at a
20762 member-declarator. Calling `grokfield' has
20763 side-effects, so we must not do it unless we are sure
20764 that we are looking at a member-declarator. */
20767 {
20768 /* The grammar does not allow a pure-specifier to be
20769 used when a member function is defined. (It is
20770 possible that this fact is an oversight in the
20771 standard, since a pure function may be defined
20772 outside of the class-specifier. */
20778 declarator,
20779 attributes);
20782 /* If the member was not a friend, declare it here. */
20785 /* Peek at the next token. */
20787 /* If the next token is a semicolon, consume it. */
20791 }
20792 else
20795 /* Create the declaration. */
20800 {
20803 else
20805 }
20806 }
20810 /* Reset PREFIX_ATTRIBUTES. */
20816 /* If there is any qualification still in effect, clear it
20817 now; we will be starting fresh with the next declarator. */
20821 /* If it's a `,', then there are more declarators. */
20823 {
20826 {
20830 }
20831 }
20832 /* If the next token isn't a `;', then we have a parse error. */
20834 CPP_SEMICOLON))
20835 {
20836 /* The next token might be a ways away from where the
20837 actual semicolon is missing. Find the previous token
20838 and use that for our error position. */
20843 /* Assume that the user meant to provide a semicolon. If
20844 we were to cp_parser_skip_to_end_of_statement, we might
20845 skip to a semicolon inside a member function definition
20846 and issue nonsensical error messages. */
20848 }
20851 {
20852 /* Add DECL to the list of members. */
20861 /* Add DECL to the queue of NSDMI to be parsed later. */
20863 }
20867 }
20868 }
20871 out:
20873 }
20875 /* Parse a pure-specifier.
20877 pure-specifier:
20878 = 0
20880 Returns INTEGER_ZERO_NODE if a pure specifier is found.
20881 Otherwise, ERROR_MARK_NODE is returned. */
20883 static tree
20885 {
20888 /* Look for the `=' token. */
20891 /* Look for the `0' token. */
20900 /* Accept = default or = delete in c++0x mode. */
20903 {
20906 }
20908 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
20910 {
20915 }
20917 {
20920 }
20923 }
20925 /* Parse a constant-initializer.
20927 constant-initializer:
20928 = constant-expression
20930 Returns a representation of the constant-expression. */
20932 static tree
20934 {
20935 /* Look for the `=' token. */
20939 /* It is invalid to write:
20941 struct S { static const int i = { 7 }; };
20943 */
20945 {
20948 /* Consume the opening brace. */
20950 /* Skip the initializer. */
20952 /* Look for the trailing `}'. */
20956 }
20960 NULL);
20961 }
20963 /* Derived classes [gram.class.derived] */
20965 /* Parse a base-clause.
20967 base-clause:
20968 : base-specifier-list
20970 base-specifier-list:
20971 base-specifier ... [opt]
20972 base-specifier-list , base-specifier ... [opt]
20974 Returns a TREE_LIST representing the base-classes, in the order in
20975 which they were declared. The representation of each node is as
20976 described by cp_parser_base_specifier.
20978 In the case that no bases are specified, this function will return
20979 NULL_TREE, not ERROR_MARK_NODE. */
20981 static tree
20983 {
20986 /* Look for the `:' that begins the list. */
20989 /* Scan the base-specifier-list. */
20991 {
20993 tree base;
20996 /* Look for the base-specifier. */
20998 /* Look for the (optional) ellipsis. */
21000 {
21001 /* Consume the `...'. */
21005 }
21007 /* Add BASE to the front of the list. */
21009 {
21011 /* Make this a pack expansion type. */
21015 {
21018 }
21019 }
21020 /* Peek at the next token. */
21022 /* If it's not a comma, then the list is complete. */
21025 /* Consume the `,'. */
21027 }
21029 /* PARSER->SCOPE may still be non-NULL at this point, if the last
21030 base class had a qualified name. However, the next name that
21031 appears is certainly not qualified. */
21037 }
21039 /* Parse a base-specifier.
21041 base-specifier:
21042 :: [opt] nested-name-specifier [opt] class-name
21043 virtual access-specifier [opt] :: [opt] nested-name-specifier
21044 [opt] class-name
21045 access-specifier virtual [opt] :: [opt] nested-name-specifier
21046 [opt] class-name
21048 Returns a TREE_LIST. The TREE_PURPOSE will be one of
21049 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
21050 indicate the specifiers provided. The TREE_VALUE will be a TYPE
21051 (or the ERROR_MARK_NODE) indicating the type that was specified. */
21053 static tree
21055 {
21063 tree type;
21065 /* Process the optional `virtual' and `access-specifier'. */
21067 {
21068 /* Peek at the next token. */
21070 /* Process `virtual'. */
21072 {
21074 /* If `virtual' appears more than once, issue an error. */
21076 {
21080 }
21084 /* Consume the `virtual' token. */
21092 /* If more than one access specifier appears, issue an
21093 error. */
21096 {
21100 }
21104 /* Consume the access-specifier. */
21112 }
21113 }
21114 /* It is not uncommon to see programs mechanically, erroneously, use
21115 the 'typename' keyword to denote (dependent) qualified types
21116 as base classes. */
21118 {
21123 else
21125 "keyword %<typename%> not allowed in this context "
21128 }
21130 /* Look for the optional `::' operator. */
21132 /* Look for the nested-name-specifier. The simplest way to
21133 implement:
21135 [temp.res]
21137 The keyword `typename' is not permitted in a base-specifier or
21138 mem-initializer; in these contexts a qualified name that
21139 depends on a template-parameter is implicitly assumed to be a
21140 type name.
21142 is to pretend that we have seen the `typename' keyword at this
21143 point. */
21147 typename_type,
21149 /* If the base class is given by a qualified name, assume that names
21150 we see are type names or templates, as appropriate. */
21156 /* DR 950 allows decltype as a base-specifier. */
21158 else
21159 {
21160 /* Otherwise, look for the class-name. */
21162 class_scope_p,
21163 template_p,
21164 typename_type,
21169 }
21175 }
21177 /* Exception handling [gram.exception] */
21179 /* Parse an (optional) noexcept-specification.
21181 noexcept-specification:
21182 noexcept ( constant-expression ) [opt]
21184 If no noexcept-specification is present, returns NULL_TREE.
21185 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
21186 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
21187 there are no parentheses. CONSUMED_EXPR will be set accordingly.
21188 Otherwise, returns a noexcept specification unless RETURN_COND is true,
21189 in which case a boolean condition is returned instead. */
21191 static tree
21196 {
21200 /* Peek at the next token. */
21203 /* Is it a noexcept-specification? */
21205 {
21206 tree expr;
21210 {
21214 {
21215 /* Types may not be defined in an exception-specification. */
21217 parser->type_definition_forbidden_message
21222 /* Restore the saved message. */
21224 }
21225 else
21226 {
21229 }
21232 }
21233 else
21234 {
21238 }
21240 /* We cannot build a noexcept-spec right away because this will check
21241 that expr is a constexpr. */
21244 else
21246 }
21247 else
21249 }
21251 /* Parse an (optional) exception-specification.
21253 exception-specification:
21254 throw ( type-id-list [opt] )
21256 Returns a TREE_LIST representing the exception-specification. The
21257 TREE_VALUE of each node is a type. */
21259 static tree
21261 {
21263 tree type_id_list;
21266 /* Peek at the next token. */
21269 /* Is it a noexcept-specification? */
21275 /* If it's not `throw', then there's no exception-specification. */
21279 #if 0
21280 /* Enable this once a lot of code has transitioned to noexcept? */
21284 #endif
21286 /* Consume the `throw'. */
21289 /* Look for the `('. */
21292 /* Peek at the next token. */
21294 /* If it's not a `)', then there is a type-id-list. */
21296 {
21297 /* Types may not be defined in an exception-specification. */
21299 parser->type_definition_forbidden_message
21301 /* Parse the type-id-list. */
21303 /* Restore the saved message. */
21305 }
21306 else
21309 /* Look for the `)'. */
21313 }
21315 /* Parse an (optional) type-id-list.
21317 type-id-list:
21318 type-id ... [opt]
21319 type-id-list , type-id ... [opt]
21321 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
21322 in the order that the types were presented. */
21324 static tree
21326 {
21330 {
21332 tree type;
21334 /* Get the next type-id. */
21336 /* Parse the optional ellipsis. */
21338 {
21339 /* Consume the `...'. */
21342 /* Turn the type into a pack expansion expression. */
21344 }
21345 /* Add it to the list. */
21347 /* Peek at the next token. */
21349 /* If it is not a `,', we are done. */
21352 /* Consume the `,'. */
21354 }
21357 }
21359 /* Parse a try-block.
21361 try-block:
21362 try compound-statement handler-seq */
21364 static tree
21366 {
21367 tree try_block;
21377 }
21379 /* Parse a function-try-block.
21381 function-try-block:
21382 try ctor-initializer [opt] function-body handler-seq */
21384 static bool
21386 {
21387 tree compound_stmt;
21388 tree try_block;
21391 /* Look for the `try' keyword. */
21394 /* Let the rest of the front end know where we are. */
21396 /* Parse the function-body. */
21397 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
21399 /* We're done with the `try' part. */
21401 /* Parse the handlers. */
21403 /* We're done with the handlers. */
21407 }
21409 /* Parse a handler-seq.
21411 handler-seq:
21412 handler handler-seq [opt] */
21414 static void
21416 {
21418 {
21421 /* Parse the handler. */
21423 /* Peek at the next token. */
21425 /* If it's not `catch' then there are no more handlers. */
21428 }
21429 }
21431 /* Parse a handler.
21433 handler:
21434 catch ( exception-declaration ) compound-statement */
21436 static void
21438 {
21439 tree handler;
21440 tree declaration;
21450 }
21452 /* Parse an exception-declaration.
21454 exception-declaration:
21455 type-specifier-seq declarator
21456 type-specifier-seq abstract-declarator
21457 type-specifier-seq
21458 ...
21460 Returns a VAR_DECL for the declaration, or NULL_TREE if the
21461 ellipsis variant is used. */
21463 static tree
21465 {
21466 cp_decl_specifier_seq type_specifiers;
21470 /* If it's an ellipsis, it's easy to handle. */
21472 {
21473 /* Consume the `...' token. */
21476 }
21478 /* Types may not be defined in exception-declarations. */
21480 parser->type_definition_forbidden_message
21483 /* Parse the type-specifier-seq. */
21487 /* If it's a `)', then there is no declarator. */
21490 else
21497 /* Restore the saved message. */
21504 }
21506 /* Parse a throw-expression.
21508 throw-expression:
21509 throw assignment-expression [opt]
21511 Returns a THROW_EXPR representing the throw-expression. */
21513 static tree
21515 {
21516 tree expression;
21521 /* Figure out whether or not there is an assignment-expression
21522 following the "throw" keyword. */
21530 else
21535 }
21537 /* GNU Extensions */
21539 /* Parse an (optional) asm-specification.
21541 asm-specification:
21542 asm ( string-literal )
21544 If the asm-specification is present, returns a STRING_CST
21545 corresponding to the string-literal. Otherwise, returns
21546 NULL_TREE. */
21548 static tree
21550 {
21552 tree asm_specification;
21554 /* Peek at the next token. */
21556 /* If the next token isn't the `asm' keyword, then there's no
21557 asm-specification. */
21561 /* Consume the `asm' token. */
21563 /* Look for the `('. */
21566 /* Look for the string-literal. */
21569 /* Look for the `)'. */
21573 }
21575 /* Parse an asm-operand-list.
21577 asm-operand-list:
21578 asm-operand
21579 asm-operand-list , asm-operand
21581 asm-operand:
21582 string-literal ( expression )
21583 [ string-literal ] string-literal ( expression )
21585 Returns a TREE_LIST representing the operands. The TREE_VALUE of
21586 each node is the expression. The TREE_PURPOSE is itself a
21587 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
21588 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
21589 is a STRING_CST for the string literal before the parenthesis. Returns
21590 ERROR_MARK_NODE if any of the operands are invalid. */
21592 static tree
21594 {
21599 {
21600 tree string_literal;
21601 tree expression;
21602 tree name;
21605 {
21606 /* Consume the `[' token. */
21608 /* Read the operand name. */
21613 /* Look for the closing `]'. */
21615 }
21616 else
21618 /* Look for the string-literal. */
21621 /* Look for the `('. */
21623 /* Parse the expression. */
21625 /* Look for the `)'. */
21633 /* Add this operand to the list. */
21635 expression,
21636 asm_operands);
21637 /* If the next token is not a `,', there are no more
21638 operands. */
21641 /* Consume the `,'. */
21643 }
21646 }
21648 /* Parse an asm-clobber-list.
21650 asm-clobber-list:
21651 string-literal
21652 asm-clobber-list , string-literal
21654 Returns a TREE_LIST, indicating the clobbers in the order that they
21655 appeared. The TREE_VALUE of each node is a STRING_CST. */
21657 static tree
21659 {
21663 {
21664 tree string_literal;
21666 /* Look for the string literal. */
21668 /* Add it to the list. */
21670 /* If the next token is not a `,', then the list is
21671 complete. */
21674 /* Consume the `,' token. */
21676 }
21679 }
21681 /* Parse an asm-label-list.
21683 asm-label-list:
21684 identifier
21685 asm-label-list , identifier
21687 Returns a TREE_LIST, indicating the labels in the order that they
21688 appeared. The TREE_VALUE of each node is a label. */
21690 static tree
21692 {
21696 {
21699 /* Look for the identifier. */
21702 {
21705 {
21711 }
21712 }
21713 /* If the next token is not a `,', then the list is
21714 complete. */
21717 /* Consume the `,' token. */
21719 }
21722 }
21724 /* Return TRUE iff the next tokens in the stream are possibly the
21725 beginning of a GNU extension attribute. */
21727 static bool
21729 {
21731 }
21733 /* Return TRUE iff the next tokens in the stream are possibly the
21734 beginning of a standard C++-11 attribute specifier. */
21736 static bool
21738 {
21740 }
21742 /* Return TRUE iff the next Nth tokens in the stream are possibly the
21743 beginning of a standard C++-11 attribute specifier. */
21745 static bool
21747 {
21755 }
21757 /* Return TRUE iff the next Nth tokens in the stream are possibly the
21758 beginning of a GNU extension attribute. */
21760 static bool
21762 {
21766 }
21768 /* Return true iff the next tokens can be the beginning of either a
21769 GNU attribute list, or a standard C++11 attribute sequence. */
21771 static bool
21773 {
21776 }
21778 /* Return true iff the next Nth tokens can be the beginning of either
21779 a GNU attribute list, or a standard C++11 attribute sequence. */
21781 static bool
21783 {
21786 }
21788 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
21789 of GNU attributes, or return NULL. */
21791 static tree
21793 {
21797 }
21799 #define CILK_SIMD_FN_CLAUSE_MASK \
21800 ((OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_VECTORLENGTH) \
21801 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_LINEAR) \
21802 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_UNIFORM) \
21803 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_MASK) \
21804 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_NOMASK))
21806 /* Parses the Cilk Plus SIMD-enabled function's attribute. Syntax:
21807 vector [(<clauses>)] */
21809 static void
21811 {
21815 {
21820 }
21823 {
21826 paren_scope++;
21827 }
21829 {
21832 paren_scope++;
21834 paren_scope--;
21835 /* Do not push the last ')' */
21838 }
21847 }
21849 /* Parse an (optional) series of attributes.
21851 attributes:
21852 attributes attribute
21854 attribute:
21855 __attribute__ (( attribute-list [opt] ))
21857 The return value is as for cp_parser_gnu_attribute_list. */
21859 static tree
21861 {
21865 {
21867 tree attribute_list;
21870 /* Peek at the next token. */
21872 /* If it's not `__attribute__', then we're done. */
21876 /* Consume the `__attribute__' keyword. */
21878 /* Look for the two `(' tokens. */
21882 /* Peek at the next token. */
21885 /* Parse the attribute-list. */
21887 else
21888 /* If the next token is a `)', then there is no attribute
21889 list. */
21892 /* Look for the two `)' tokens. */
21900 /* Add these new attributes to the list. */
21902 }
21905 }
21907 /* Returns true of NAME is an IDENTIFIER_NODE with identiifer "vector,"
21908 "__vector" or "__vector__." */
21912 {
21916 }
21918 /* Parse a GNU attribute-list.
21920 attribute-list:
21921 attribute
21922 attribute-list , attribute
21924 attribute:
21925 identifier
21926 identifier ( identifier )
21927 identifier ( identifier , expression-list )
21928 identifier ( expression-list )
21930 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
21931 to an attribute. The TREE_PURPOSE of each node is the identifier
21932 indicating which attribute is in use. The TREE_VALUE represents
21933 the arguments, if any. */
21935 static tree
21937 {
21943 {
21945 tree identifier;
21946 tree attribute;
21948 /* Look for the identifier. We also allow keywords here; for
21949 example `__attribute__ ((const))' is legal. */
21953 {
21956 /* Consume the token, but save it since we need it for the
21957 SIMD enabled function parsing. */
21960 /* Save away the identifier that indicates which attribute
21961 this is. */
21963 /* For keywords, use the canonical spelling, not the
21964 parsed identifier. */
21970 /* Peek at the next token. */
21972 /* If it's an `(', then parse the attribute arguments. */
21974 {
21979 {
21982 }
21983 else
21984 vec = cp_parser_parenthesized_expression_list
21990 else
21991 {
21994 }
21995 /* Save the arguments away. */
21997 }
21999 {
22002 }
22005 {
22006 /* Add this attribute to the list. */
22009 }
22012 }
22013 /* Now, look for more attributes. If the next token isn't a
22014 `,', we're done. */
22018 /* Consume the comma and keep going. */
22020 }
22023 /* We built up the list in reverse order. */
22025 }
22027 /* Parse a standard C++11 attribute.
22029 The returned representation is a TREE_LIST which TREE_PURPOSE is
22030 the scoped name of the attribute, and the TREE_VALUE is its
22031 arguments list.
22033 Note that the scoped name of the attribute is itself a TREE_LIST
22034 which TREE_PURPOSE is the namespace of the attribute, and
22035 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
22036 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
22037 and which TREE_PURPOSE is directly the attribute name.
22039 Clients of the attribute code should use get_attribute_namespace
22040 and get_attribute_name to get the actual namespace and name of
22041 attributes, regardless of their being GNU or C++11 attributes.
22043 attribute:
22044 attribute-token attribute-argument-clause [opt]
22046 attribute-token:
22047 identifier
22048 attribute-scoped-token
22050 attribute-scoped-token:
22051 attribute-namespace :: identifier
22053 attribute-namespace:
22054 identifier
22056 attribute-argument-clause:
22057 ( balanced-token-seq )
22059 balanced-token-seq:
22060 balanced-token [opt]
22061 balanced-token-seq balanced-token
22063 balanced-token:
22064 ( balanced-token-seq )
22065 [ balanced-token-seq ]
22066 { balanced-token-seq }. */
22068 static tree
22070 {
22074 /* First, parse name of the the attribute, a.k.a
22075 attribute-token. */
22092 {
22093 /* We are seeing a scoped attribute token. */
22103 else
22104 {
22108 }
22110 NULL_TREE);
22112 }
22113 else
22114 {
22116 NULL_TREE);
22117 /* C++11 noreturn attribute is equivalent to GNU's. */
22120 /* C++14 deprecated attribute is equivalent to GNU's. */
22123 }
22125 /* Now parse the optional argument clause of the attribute. */
22130 {
22136 /* A GNU attribute that takes an identifier in parameter. */
22139 vec = cp_parser_parenthesized_expression_list
22145 else
22146 {
22149 }
22153 else
22155 }
22158 }
22160 /* Parse a list of standard C++-11 attributes.
22162 attribute-list:
22163 attribute [opt]
22164 attribute-list , attribute[opt]
22165 attribute ...
22166 attribute-list , attribute ...
22167 */
22169 static tree
22171 {
22176 {
22181 {
22184 }
22189 }
22192 }
22194 /* Parse a standard C++-11 attribute specifier.
22196 attribute-specifier:
22197 [ [ attribute-list ] ]
22198 alignment-specifier
22200 alignment-specifier:
22201 alignas ( type-id ... [opt] )
22202 alignas ( alignment-expression ... [opt] ). */
22204 static tree
22206 {
22212 {
22221 else
22222 /* Warn about parsing c++11 attribute in non-c++1 mode, only
22223 when we are sure that we have actually parsed them. */
22225 }
22226 else
22227 {
22228 tree alignas_expr;
22230 /* Look for an alignment-specifier. */
22242 {
22245 }
22251 {
22255 alignas_expr =
22263 }
22266 {
22269 }
22273 /* Build the C++-11 representation of an 'aligned'
22274 attribute. */
22275 attributes =
22279 }
22282 }
22284 /* Parse a standard C++-11 attribute-specifier-seq.
22286 attribute-specifier-seq:
22287 attribute-specifier-seq [opt] attribute-specifier
22288 */
22290 static tree
22292 {
22296 {
22305 }
22309 }
22311 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
22312 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
22313 current value of the PEDANTIC flag, regardless of whether or not
22314 the `__extension__' keyword is present. The caller is responsible
22315 for restoring the value of the PEDANTIC flag. */
22317 static bool
22319 {
22320 /* Save the old value of the PEDANTIC flag. */
22324 {
22325 /* Consume the `__extension__' token. */
22327 /* We're not being pedantic while the `__extension__' keyword is
22328 in effect. */
22332 }
22335 }
22337 /* Parse a label declaration.
22339 label-declaration:
22340 __label__ label-declarator-seq ;
22342 label-declarator-seq:
22343 identifier , label-declarator-seq
22344 identifier */
22346 static void
22348 {
22349 /* Look for the `__label__' keyword. */
22353 {
22354 tree identifier;
22356 /* Look for an identifier. */
22358 /* If we failed, stop. */
22361 /* Declare it as a label. */
22363 /* If the next token is a `;', stop. */
22366 /* Look for the `,' separating the label declarations. */
22368 }
22370 /* Look for the final `;'. */
22372 }
22374 /* Support Functions */
22376 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
22377 NAME should have one of the representations used for an
22378 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
22379 is returned. If PARSER->SCOPE is a dependent type, then a
22380 SCOPE_REF is returned.
22382 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
22383 returned; the name was already resolved when the TEMPLATE_ID_EXPR
22384 was formed. Abstractly, such entities should not be passed to this
22385 function, because they do not need to be looked up, but it is
22386 simpler to check for this special case here, rather than at the
22387 call-sites.
22389 In cases not explicitly covered above, this function returns a
22390 DECL, OVERLOAD, or baselink representing the result of the lookup.
22391 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
22392 is returned.
22394 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
22395 (e.g., "struct") that was used. In that case bindings that do not
22396 refer to types are ignored.
22398 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
22399 ignored.
22401 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
22402 are ignored.
22404 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
22405 types.
22407 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
22408 TREE_LIST of candidates if name-lookup results in an ambiguity, and
22409 NULL_TREE otherwise. */
22411 static tree
22418 location_t name_location)
22419 {
22420 tree decl;
22423 /* Assume that the lookup will be unambiguous. */
22427 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
22428 no longer valid. Note that if we are parsing tentatively, and
22429 the parse fails, OBJECT_TYPE will be automatically restored. */
22435 /* A template-id has already been resolved; there is no lookup to
22436 do. */
22440 {
22444 }
22446 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
22447 it should already have been checked to make sure that the name
22448 used matches the type being destroyed. */
22450 {
22451 tree type;
22453 /* Figure out to which type this destructor applies. */
22458 else
22460 /* If that's not a class type, there is no destructor. */
22467 /* If it was a class type, return the destructor. */
22469 }
22471 /* By this point, the NAME should be an ordinary identifier. If
22472 the id-expression was a qualified name, the qualifying scope is
22473 stored in PARSER->SCOPE at this point. */
22476 /* Perform the lookup. */
22478 {
22484 /* If the SCOPE is dependent, the lookup must be deferred until
22485 the template is instantiated -- unless we are explicitly
22486 looking up names in uninstantiated templates. Even then, we
22487 cannot look up the name if the scope is not a class type; it
22488 might, for example, be a template type parameter. */
22493 /* Defer lookup. */
22495 else
22496 {
22499 /* If PARSER->SCOPE is a dependent type, then it must be a
22500 class type, and we must not be checking dependencies;
22501 otherwise, we would have processed this lookup above. So
22502 that PARSER->SCOPE is not considered a dependent base by
22503 lookup_member, we must enter the scope here. */
22507 /* If the PARSER->SCOPE is a template specialization, it
22508 may be instantiated during name lookup. In that case,
22509 errors may be issued. Even if we rollback the current
22510 tentative parse, those errors are valid. */
22515 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
22516 lookup result and the nested-name-specifier nominates a class C:
22517 * if the name specified after the nested-name-specifier, when
22518 looked up in C, is the injected-class-name of C (Clause 9), or
22519 * if the name specified after the nested-name-specifier is the
22520 same as the identifier or the simple-template-id's template-
22521 name in the last component of the nested-name-specifier,
22522 the name is instead considered to name the constructor of
22523 class C. [ Note: for example, the constructor is not an
22524 acceptable lookup result in an elaborated-type-specifier so
22525 the constructor would not be used in place of the
22526 injected-class-name. --end note ] Such a constructor name
22527 shall be used only in the declarator-id of a declaration that
22528 names a constructor or in a using-declaration. */
22536 /* If we have a single function from a using decl, pull it out. */
22543 }
22545 /* If the scope is a dependent type and either we deferred lookup or
22546 we did lookup but didn't find the name, rememeber the name. */
22549 {
22551 {
22552 tree type;
22554 /* The resolution to Core Issue 180 says that `struct
22555 A::B' should be considered a type-name, even if `A'
22556 is dependent. */
22561 }
22565 CPP_CLOSE_PAREN)))
22569 else
22572 is_template);
22573 }
22576 }
22578 {
22579 /* Look up the name in the scope of the OBJECT_TYPE, unless the
22580 OBJECT_TYPE is not a class. */
22582 /* If the OBJECT_TYPE is a template specialization, it may
22583 be instantiated during name lookup. In that case, errors
22584 may be issued. Even if we rollback the current tentative
22585 parse, those errors are valid. */
22587 name,
22590 tf_warning_or_error);
22591 else
22595 /* Look it up in the enclosing context. */
22601 }
22602 else
22603 {
22609 }
22611 /* If the lookup failed, let our caller know. */
22615 /* Pull out the template from an injected-class-name (or multiple). */
22619 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
22621 {
22624 /* The error message we have to print is too complicated for
22625 cp_parser_error, so we incorporate its actions directly. */
22627 {
22629 name);
22631 }
22633 }
22641 /* If we have resolved the name of a member declaration, check to
22642 see if the declaration is accessible. When the name resolves to
22643 set of overloaded functions, accessibility is checked when
22644 overload resolution is done.
22646 During an explicit instantiation, access is not checked at all,
22647 as per [temp.explicit]. */
22654 }
22656 /* Like cp_parser_lookup_name, but for use in the typical case where
22657 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
22658 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
22660 static tree
22662 {
22664 none_type,
22669 location);
22670 }
22672 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
22673 the current context, return the TYPE_DECL. If TAG_NAME_P is
22674 true, the DECL indicates the class being defined in a class-head,
22675 or declared in an elaborated-type-specifier.
22677 Otherwise, return DECL. */
22679 static tree
22681 {
22682 /* If the TEMPLATE_DECL is being declared as part of a class-head,
22683 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
22685 struct A {
22686 template <typename T> struct B;
22687 };
22689 template <typename T> struct A::B {};
22691 Similarly, in an elaborated-type-specifier:
22693 namespace N { struct X{}; }
22695 struct A {
22696 template <typename T> friend struct N::X;
22697 };
22699 However, if the DECL refers to a class type, and we are in
22700 the scope of the class, then the name lookup automatically
22701 finds the TYPE_DECL created by build_self_reference rather
22702 than a TEMPLATE_DECL. For example, in:
22704 template <class T> struct S {
22705 S s;
22706 };
22708 there is no need to handle such case. */
22714 }
22716 /* If too many, or too few, template-parameter lists apply to the
22717 declarator, issue an error message. Returns TRUE if all went well,
22718 and FALSE otherwise. */
22720 static bool
22723 location_t declarator_location)
22724 {
22726 {
22728 {
22736 /* If the DECLARATOR has the form `X<y>' then it uses one
22737 additional level of template parameters. */
22740 return cp_parser_check_template_parameters
22742 }
22757 }
22759 }
22761 /* NUM_TEMPLATES were used in the current declaration. If that is
22762 invalid, return FALSE and issue an error messages. Otherwise,
22763 return TRUE. If DECLARATOR is non-NULL, then we are checking a
22764 declarator and we can print more accurate diagnostics. */
22766 static bool
22769 location_t location,
22771 {
22772 /* If there are the same number of template classes and parameter
22773 lists, that's OK. */
22776 /* If there are more, but only one more, then we are referring to a
22777 member template. That's OK too. */
22780 /* If there are more template classes than parameter lists, we have
22781 something like:
22783 template <class T> void S<T>::R<T>::f (); */
22785 {
22795 else
22798 }
22799 /* Otherwise, there are too many template parameter lists. We have
22800 something like:
22802 template <class T> template <class U> void S::f(); */
22805 }
22807 /* Parse an optional `::' token indicating that the following name is
22808 from the global namespace. If so, PARSER->SCOPE is set to the
22809 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
22810 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
22811 Returns the new value of PARSER->SCOPE, if the `::' token is
22812 present, and NULL_TREE otherwise. */
22814 static tree
22816 {
22819 /* Peek at the next token. */
22821 /* If we're looking at a `::' token then we're starting from the
22822 global namespace, not our current location. */
22824 {
22825 /* Consume the `::' token. */
22827 /* Set the SCOPE so that we know where to start the lookup. */
22833 }
22835 {
22839 }
22842 }
22844 /* Returns TRUE if the upcoming token sequence is the start of a
22845 constructor declarator. If FRIEND_P is true, the declarator is
22846 preceded by the `friend' specifier. */
22848 static bool
22850 {
22853 tree nested_name_specifier;
22856 /* The common case is that this is not a constructor declarator, so
22857 try to avoid doing lots of work if at all possible. It's not
22858 valid declare a constructor at function scope. */
22861 /* And only certain tokens can begin a constructor declarator. */
22869 /* Parse tentatively; we are going to roll back all of the tokens
22870 consumed here. */
22872 /* Assume that we are looking at a constructor declarator. */
22875 /* Look for the optional `::' operator. */
22878 /* Look for the nested-name-specifier. */
22879 nested_name_specifier
22890 /* Outside of a class-specifier, there must be a
22891 nested-name-specifier. */
22897 /* If we have a class scope, this is easy; DR 147 says that S::S always
22898 names the constructor, and no other qualified name could. */
22901 {
22911 }
22912 /* If we still think that this might be a constructor-declarator,
22913 look for a class-name. */
22915 {
22916 /* If we have:
22918 template <typename T> struct S {
22919 S();
22920 };
22922 we must recognize that the nested `S' names a class. */
22923 tree type_decl;
22927 none_type,
22931 /* If there was no class-name, then this is not a constructor.
22932 Otherwise, if we are in a class-specifier and we aren't
22933 handling a friend declaration, check that its type matches
22934 current_class_type (c++/38313). Note: error_mark_node
22935 is left alone for error recovery purposes. */
22937 && (outside_class_specifier_p
22942 /* If we're still considering a constructor, we have to see a `(',
22943 to begin the parameter-declaration-clause, followed by either a
22944 `)', an `...', or a decl-specifier. We need to check for a
22945 type-specifier to avoid being fooled into thinking that:
22947 S (f) (int);
22949 is a constructor. (It is actually a function named `f' that
22950 takes one parameter (of type `int') and returns a value of type
22951 `S'. */
22959 /* A parameter declaration begins with a decl-specifier,
22960 which is either the "attribute" keyword, a storage class
22961 specifier, or (usually) a type-specifier. */
22963 {
22964 tree type;
22968 /* Names appearing in the type-specifier should be looked up
22969 in the scope of the class. */
22972 else
22973 {
22976 {
22980 {
22983 }
22984 }
22986 }
22988 /* Inside the constructor parameter list, surrounding
22989 template-parameter-lists do not apply. */
22990 saved_num_template_parameter_lists
22994 /* Look for the type-specifier. */
22996 CP_PARSER_FLAGS_NONE,
23002 parser->num_template_parameter_lists
23005 /* Leave the scope of the class. */
23010 }
23011 }
23013 /* We did not really want to consume any tokens. */
23017 }
23019 /* Parse the definition of the function given by the DECL_SPECIFIERS,
23020 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
23021 they must be performed once we are in the scope of the function.
23023 Returns the function defined. */
23025 static tree
23026 cp_parser_function_definition_from_specifiers_and_declarator
23029 tree attributes,
23031 {
23032 tree fn;
23035 /* Begin the function-definition. */
23038 /* The things we're about to see are not directly qualified by any
23039 template headers we've seen thus far. */
23042 /* If there were names looked up in the decl-specifier-seq that we
23043 did not check, check them now. We must wait until we are in the
23044 scope of the function to perform the checks, since the function
23045 might be a friend. */
23049 {
23052 }
23055 {
23056 /* Skip the entire function. */
23059 }
23061 {
23062 /* Seen already, skip it. An error message has already been output. */
23066 /* If this is a function from a class, pop the nested class. */
23069 }
23070 else
23071 {
23072 timevar_id_t tv;
23075 else
23081 }
23084 }
23086 /* Parse the part of a function-definition that follows the
23087 declarator. INLINE_P is TRUE iff this function is an inline
23088 function defined within a class-specifier.
23090 Returns the function defined. */
23092 static tree
23095 {
23096 tree fn;
23102 bool fully_implicit_function_template_p
23105 tree implicit_template_parms
23108 cp_binding_level* implicit_template_scope
23114 /* If the next token is `return', then the code may be trying to
23115 make use of the "named return value" extension that G++ used to
23116 support. */
23119 {
23120 /* Consume the `return' keyword. */
23122 /* Look for the identifier that indicates what value is to be
23123 returned. */
23125 /* Issue an error message. */
23128 /* Skip tokens until we reach the start of the function body. */
23130 {
23137 }
23138 }
23139 /* The `extern' in `extern "C" void f () { ... }' does not apply to
23140 anything declared inside `f'. */
23141 saved_in_unbraced_linkage_specification_p
23144 /* Inside the function, surrounding template-parameter-lists do not
23145 apply. */
23146 saved_num_template_parameter_lists
23152 /* If the next token is `try', `__transaction_atomic', or
23153 `__transaction_relaxed`, then we are looking at either function-try-block
23154 or function-transaction-block. Note that all of these include the
23155 function-body. */
23158 RID_TRANSACTION_ATOMIC);
23160 RID_TRANSACTION_RELAXED))
23162 RID_TRANSACTION_RELAXED);
23165 else
23166 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
23171 /* Finish the function. */
23174 /* Generate code for it, if necessary. */
23176 /* Restore the saved values. */
23177 parser->in_unbraced_linkage_specification_p
23179 parser->num_template_parameter_lists
23183 parser->fully_implicit_function_template_p
23185 parser->implicit_template_parms
23187 parser->implicit_template_scope
23194 }
23196 /* Parse a template-declaration, assuming that the `export' (and
23197 `extern') keywords, if present, has already been scanned. MEMBER_P
23198 is as for cp_parser_template_declaration. */
23200 static void
23202 {
23205 tree parameter_list;
23210 /* Look for the `template' keyword. */
23215 /* And the `<'. */
23219 {
23220 /* 14.5.2.2 [temp.mem]
23222 A local class shall not have member templates. */
23227 }
23228 /* [temp]
23230 A template ... shall not have C linkage. */
23232 {
23234 /* Give it C++ linkage to avoid confusing other parts of the
23235 front end. */
23238 }
23239 else
23242 /* We cannot perform access checks on the template parameter
23243 declarations until we know what is being declared, just as we
23244 cannot check the decl-specifier list. */
23247 /* If the next token is `>', then we have an invalid
23248 specialization. Rather than complain about an invalid template
23249 parameter, issue an error message here. */
23251 {
23255 }
23256 else
23257 {
23258 /* Parse the template parameters. */
23260 }
23262 /* Get the deferred access checks from the parameter list. These
23263 will be checked once we know what is being declared, as for a
23264 member template the checks must be performed in the scope of the
23265 class containing the member. */
23268 /* Look for the `>'. */
23270 /* We just processed one more parameter list. */
23272 /* If the next token is `template', there are more template
23273 parameters. */
23275 RID_TEMPLATE))
23280 else
23281 {
23282 /* There are no access checks when parsing a template, as we do not
23283 know if a specialization will be a friend. */
23287 checks,
23288 member_p,
23293 /* If this is a member template declaration, let the front
23294 end know. */
23296 {
23301 }
23306 }
23307 /* We are done with the current parameter list. */
23312 /* Finish up. */
23315 /* Check the template arguments for a literal operator template. */
23319 {
23323 else
23324 {
23327 {
23333 }
23335 {
23343 }
23344 else
23346 }
23348 {
23351 " Expected non-type template argument pack <char...>"
23353 decl);
23354 else
23357 decl);
23358 }
23359 }
23360 /* Register member declarations. */
23363 /* For the erroneous case of a template with C linkage, we pushed an
23364 implicit C++ linkage scope; exit that scope now. */
23367 /* If DECL is a function template, we must return to parse it later.
23368 (Even though there is no definition, there might be default
23369 arguments that need handling.) */
23373 }
23375 /* Perform the deferred access checks from a template-parameter-list.
23376 CHECKS is a TREE_LIST of access checks, as returned by
23377 get_deferred_access_checks. */
23379 static void
23380 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
23381 {
23385 }
23387 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
23388 `function-definition' sequence that follows a template header.
23389 If MEMBER_P is true, this declaration appears in a class scope.
23391 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
23392 *FRIEND_P is set to TRUE iff the declaration is a friend. */
23394 static tree
23400 {
23403 cp_decl_specifier_seq decl_specifiers;
23407 /* This function is only used when processing a template
23408 declaration. */
23412 /* Defer access checks until we know what is being declared. */
23415 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
23416 alternative. */
23419 CP_PARSER_FLAGS_OPTIONAL,
23425 /* There are no template typedefs. */
23427 {
23431 }
23433 /* Gather up the access checks that occurred the
23434 decl-specifier-seq. */
23437 /* Check for the declaration of a template class. */
23439 {
23441 {
23444 /* In this case:
23446 struct C {
23447 friend template <typename T> struct A<T>::B;
23448 };
23450 A<T>::B will be represented by a TYPENAME_TYPE, and
23451 therefore not recognized by shadow_tag. */
23453 && !decl
23460 else
23463 /* Perform access checks for template parameters. */
23465 }
23466 }
23468 /* Complain about missing 'typename' or other invalid type names. */
23471 {
23472 /* cp_parser_parse_and_diagnose_invalid_type_name calls
23473 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
23474 the rest of this declaration. */
23477 }
23479 /* If it's not a template class, try for a template function. If
23480 the next token is a `;', then this declaration does not declare
23481 anything. But, if there were errors in the decl-specifiers, then
23482 the error might well have come from an attempted class-specifier.
23483 In that case, there's no need to warn about a missing declarator. */
23487 {
23490 checks,
23492 member_p,
23493 declares_class_or_enum,
23495 NULL);
23497 /* 7.1.1-1 [dcl.stc]
23499 A storage-class-specifier shall not be specified in an explicit
23500 specialization... */
23502 && explicit_specialization_p
23504 {
23508 }
23512 }
23514 /* Look for a trailing `;' after the declaration. */
23520 out:
23523 /* Clear any current qualification; whatever comes next is the start
23524 of something new. */
23530 }
23532 /* Parse a cast-expression that is not the operand of a unary "&". */
23534 static tree
23536 {
23539 }
23541 /* Parse a functional cast to TYPE. Returns an expression
23542 representing the cast. */
23544 static tree
23546 {
23548 tree expression_list;
23549 tree cast;
23556 {
23564 tf_warning_or_error);
23565 }
23574 else
23575 {
23578 }
23581 tf_warning_or_error);
23582 /* [expr.const]/1: In an integral constant expression "only type
23583 conversions to integral or enumeration type can be used". */
23589 NIC_CONSTRUCTOR))
23592 }
23594 /* Save the tokens that make up the body of a member function defined
23595 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
23596 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
23597 specifiers applied to the declaration. Returns the FUNCTION_DECL
23598 for the member function. */
23600 static tree
23604 tree attributes)
23605 {
23608 tree fn;
23610 /* Create the FUNCTION_DECL. */
23613 /* If something went badly wrong, bail out now. */
23615 {
23616 /* If there's a function-body, skip it. */
23621 }
23623 /* Remember it, if there default args to post process. */
23626 /* Save away the tokens that make up the body of the
23627 function. */
23629 /* Handle function try blocks. */
23632 /* We can have braced-init-list mem-initializers before the fn body. */
23634 {
23637 {
23638 /* cache_group will stop after an un-nested { } pair, too. */
23642 /* variadic mem-inits have ... after the ')'. */
23645 }
23646 }
23648 /* Handle function try blocks. */
23653 /* Save away the inline definition; we will process it when the
23654 class is complete. */
23658 /* We need to know that this was defined in the class, so that
23659 friend templates are handled correctly. */
23662 /* Add FN to the queue of functions to be parsed later. */
23666 }
23668 /* Save the tokens that make up the in-class initializer for a non-static
23669 data member. Returns a DEFAULT_ARG. */
23671 static tree
23673 {
23675 }
23677 /* Parse a template-argument-list, as well as the trailing ">" (but
23678 not the opening "<"). See cp_parser_template_argument_list for the
23679 return value. */
23681 static tree
23683 {
23684 tree arguments;
23685 tree saved_scope;
23686 tree saved_qualifying_scope;
23687 tree saved_object_scope;
23692 /* [temp.names]
23694 When parsing a template-id, the first non-nested `>' is taken as
23695 the end of the template-argument-list rather than a greater-than
23696 operator. */
23697 saved_greater_than_is_operator_p
23700 /* Parsing the argument list may modify SCOPE, so we save it
23701 here. */
23705 /* We need to evaluate the template arguments, even though this
23706 template-id may be nested within a "sizeof". */
23711 /* Parse the template-argument-list itself. */
23715 else
23717 /* Look for the `>' that ends the template-argument-list. If we find
23718 a '>>' instead, it's probably just a typo. */
23720 {
23722 {
23723 /* In C++0x, a `>>' in a template argument list or cast
23724 expression is considered to be two separate `>'
23725 tokens. So, change the current token to a `>', but don't
23726 consume it: it will be consumed later when the outer
23727 template argument list (or cast expression) is parsed.
23728 Note that this replacement of `>' for `>>' is necessary
23729 even if we are parsing tentatively: in the tentative
23730 case, after calling
23731 cp_parser_enclosed_template_argument_list we will always
23732 throw away all of the template arguments and the first
23733 closing `>', either because the template argument list
23734 was erroneous or because we are replacing those tokens
23735 with a CPP_TEMPLATE_ID token. The second `>' (which will
23736 not have been thrown away) is needed either to close an
23737 outer template argument list or to complete a new-style
23738 cast. */
23741 }
23743 {
23744 /* If we're in a nested template argument list, the '>>' has
23745 to be a typo for '> >'. We emit the error message, but we
23746 continue parsing and we push a '>' as next token, so that
23747 the argument list will be parsed correctly. Note that the
23748 global source location is still on the token before the
23749 '>>', so we need to say explicitly where we want it. */
23755 }
23756 else
23757 {
23758 /* If this is not a nested template argument list, the '>>'
23759 is a typo for '>'. Emit an error message and continue.
23760 Same deal about the token location, but here we can get it
23761 right by consuming the '>>' before issuing the diagnostic. */
23764 "spurious %<>>%>, use %<>%> to terminate "
23766 }
23767 }
23768 else
23770 /* The `>' token might be a greater-than operator again now. */
23771 parser->greater_than_is_operator_p
23773 /* Restore the SAVED_SCOPE. */
23781 }
23783 /* MEMBER_FUNCTION is a member function, or a friend. If default
23784 arguments, or the body of the function have not yet been parsed,
23785 parse them now. */
23787 static void
23789 {
23791 /* If this member is a template, get the underlying
23792 FUNCTION_DECL. */
23796 /* There should not be any class definitions in progress at this
23797 point; the bodies of members are only parsed outside of all class
23798 definitions. */
23800 /* While we're parsing the member functions we might encounter more
23801 classes. We want to handle them right away, but we don't want
23802 them getting mixed up with functions that are currently in the
23803 queue. */
23806 /* Make sure that any template parameters are in scope. */
23809 /* If the body of the function has not yet been parsed, parse it
23810 now. */
23812 {
23813 tree function_scope;
23816 /* The function is no longer pending; we are processing it. */
23821 /* If this is a local class, enter the scope of the containing
23822 function. */
23827 /* Push the body of the function onto the lexer stack. */
23830 /* Let the front end know that we going to be defining this
23831 function. */
23835 /* Don't do access checking if it is a templated function. */
23839 /* #pragma omp declare reduction needs special parsing. */
23841 {
23846 }
23847 else
23848 /* Now, parse the body of the function. */
23855 /* Leave the scope of the containing function. */
23859 }
23861 /* Remove any template parameters from the symbol table. */
23864 /* Restore the queue. */
23867 }
23869 /* If DECL contains any default args, remember it on the unparsed
23870 functions queue. */
23872 static void
23874 {
23875 tree probe;
23878 probe;
23881 {
23885 }
23886 }
23888 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
23889 which is either a FIELD_DECL or PARM_DECL. Parse it and return
23890 the result. For a PARM_DECL, PARMTYPE is the corresponding type
23891 from the parameter-type-list. */
23893 static tree
23896 {
23898 tree parsed_arg;
23904 /* Push the saved tokens for the default argument onto the parser's
23905 lexer stack. */
23911 /* Parse the default argument. */
23922 {
23923 /* In a non-template class, check conversions now. In a template,
23924 we'll wait and instantiate these as needed. */
23927 tf_warning_or_error);
23928 else
23930 }
23932 /* If the token stream has not been completely used up, then
23933 there was extra junk after the end of the default
23934 argument. */
23936 {
23939 else
23941 }
23943 /* Revert to the main lexer. */
23947 }
23949 /* FIELD is a non-static data member with an initializer which we saved for
23950 later; parse it now. */
23952 static void
23954 {
23955 tree def;
23962 NULL_TREE);
23968 }
23970 /* FN is a FUNCTION_DECL which may contains a parameter with an
23971 unparsed DEFAULT_ARG. Parse the default args now. This function
23972 assumes that the current scope is the scope in which the default
23973 argument should be processed. */
23975 static void
23977 {
23981 /* While we're parsing the default args, we might (due to the
23982 statement expression extension) encounter more classes. We want
23983 to handle them right away, but we don't want them getting mixed
23984 up with default args that are currently in the queue. */
23987 /* Local variable names (and the `this' keyword) may not appear
23988 in a default argument. */
23999 {
24001 tree parsed_arg;
24003 tree copy;
24010 /* This can happen for a friend declaration for a function
24011 already declared with default arguments. */
24014 parsed_arg
24016 default_arg,
24019 {
24021 }
24025 /* Update any instantiations we've already created. */
24029 }
24033 /* Make sure no default arg is missing. */
24036 /* Restore the state of local_variables_forbidden_p. */
24039 /* Restore the queue. */
24041 }
24043 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
24045 sizeof ... ( identifier )
24047 where the 'sizeof' token has already been consumed. */
24049 static tree
24051 {
24052 /* Consume the `...'. */
24059 else
24067 /* The name is not qualified. */
24085 }
24087 /* Parse the operand of `sizeof' (or a similar operator). Returns
24088 either a TYPE or an expression, depending on the form of the
24089 input. The KEYWORD indicates which kind of expression we have
24090 encountered. */
24092 static tree
24094 {
24101 /* If it's a `...', then we are computing the length of a parameter
24102 pack. */
24107 /* Types cannot be defined in a `sizeof' expression. Save away the
24108 old message. */
24110 /* And create the new one. */
24116 /* The restrictions on constant-expressions do not apply inside
24117 sizeof expressions. */
24118 saved_integral_constant_expression_p
24120 saved_non_integral_constant_expression_p
24124 /* Do not actually evaluate the expression. */
24127 /* If it's a `(', then we might be looking at the type-id
24128 construction. */
24130 {
24133 /* We can't be sure yet whether we're looking at a type-id or an
24134 expression. */
24136 /* Note: as a GNU Extension, compound literals are considered
24137 postfix-expressions as they are in C99, so they are valid
24138 arguments to sizeof. See comment in cp_parser_cast_expression
24139 for details. */
24142 else
24143 {
24146 /* Look for the type-id. */
24148 /* Look for the closing `)'. */
24151 }
24153 /* If all went well, then we're done. */
24155 {
24156 cp_decl_specifier_seq decl_specs;
24158 /* Build a trivial decl-specifier-seq. */
24162 /* Call grokdeclarator to figure out what type this is. */
24165 TYPENAME,
24168 }
24169 }
24171 /* If the type-id production did not work out, then we must be
24172 looking at the unary-expression production. */
24177 /* Go back to evaluating expressions. */
24181 /* Free the message we created. */
24183 /* And restore the old one. */
24185 parser->integral_constant_expression_p
24187 parser->non_integral_constant_expression_p
24191 }
24193 /* If the current declaration has no declarator, return true. */
24195 static bool
24197 {
24198 /* If the next token is a `;' or a `,' then there is no
24199 declarator. */
24202 }
24204 /* Update the DECL_SPECS to reflect the storage class indicated by
24205 KEYWORD. */
24207 static void
24212 {
24213 cp_storage_class storage_class;
24216 {
24220 }
24222 {
24225 }
24230 {
24233 }
24236 {
24254 }
24258 /* A storage class specifier cannot be applied alongside a typedef
24259 specifier. If there is a typedef specifier present then set
24260 conflicting_specifiers_p which will trigger an error later
24261 on in grokdeclarator. */
24264 }
24266 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
24267 is true, the type is a class or enum definition. */
24269 static void
24271 tree type_spec,
24274 {
24277 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
24278 (with, for example, in "typedef int wchar_t;") we remember that
24279 this is what happened. In system headers, we ignore these
24280 declarations so that G++ can work with system headers that are not
24281 C++-safe. */
24283 && !type_definition_p
24293 {
24296 ds_redefined_builtin_type_spec,
24297 token);
24299 {
24303 }
24304 }
24307 else
24308 {
24313 }
24314 }
24316 /* True iff TOKEN is the GNU keyword __thread. */
24318 static bool
24320 {
24323 }
24325 /* Set the location for a declarator specifier and check if it is
24326 duplicated.
24328 DECL_SPECS is the sequence of declarator specifiers onto which to
24329 set the location.
24331 DS is the single declarator specifier to set which location is to
24332 be set onto the existing sequence of declarators.
24334 LOCATION is the location for the declarator specifier to
24335 consider. */
24337 static void
24340 {
24349 {
24353 }
24354 else
24355 {
24357 {
24361 else
24362 {
24365 OPT_Wlong_long,
24367 }
24368 }
24370 {
24375 else
24377 }
24378 else
24379 {
24395 "__complex"
24396 };
24399 }
24400 }
24401 }
24403 /* Return true iff the declarator specifier DS is present in the
24404 sequence of declarator specifiers DECL_SPECS. */
24406 bool
24408 cp_decl_spec ds)
24409 {
24416 }
24418 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
24419 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
24421 static bool
24423 {
24425 }
24427 /* Issue an error message indicating that TOKEN_DESC was expected.
24428 If KEYWORD is true, it indicated this function is called by
24429 cp_parser_require_keword and the required token can only be
24430 a indicated keyword. */
24432 static void
24434 required_token token_desc,
24436 {
24438 {
24507 }
24509 {
24511 {
24590 }
24591 }
24592 else
24594 }
24598 /* If the next token is of the indicated TYPE, consume it. Otherwise,
24599 issue an error message indicating that TOKEN_DESC was expected.
24601 Returns the token consumed, if the token had the appropriate type.
24602 Otherwise, returns NULL. */
24607 required_token token_desc)
24608 {
24611 else
24612 {
24613 /* Output the MESSAGE -- unless we're parsing tentatively. */
24617 }
24618 }
24620 /* An error message is produced if the next token is not '>'.
24621 All further tokens are skipped until the desired token is
24622 found or '{', '}', ';' or an unbalanced ')' or ']'. */
24624 static void
24626 {
24627 /* Current level of '< ... >'. */
24629 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
24632 /* Are we ready, yet? If not, issue error message. */
24636 /* Skip tokens until the desired token is found. */
24638 {
24639 /* Peek at the next token. */
24641 {
24649 /* C++0x views the `>>' operator as two `>' tokens, but
24650 C++98 does not. */
24653 {
24654 /* We've hit a `>>' where the first `>' closes the
24655 template argument list, and the second `>' is
24656 spurious. Just consume the `>>' and stop; we've
24657 already produced at least one error. */
24660 }
24661 /* Fall through for C++0x, so we handle the second `>' in
24662 the `>>'. */
24666 {
24667 /* We've reached the token we want, consume it and stop. */
24670 }
24689 /* The '>' was probably forgotten, don't look further. */
24694 }
24696 /* Consume this token. */
24698 }
24699 }
24701 /* If the next token is the indicated keyword, consume it. Otherwise,
24702 issue an error message indicating that TOKEN_DESC was expected.
24704 Returns the token consumed, if the token had the appropriate type.
24705 Otherwise, returns NULL. */
24710 required_token token_desc)
24711 {
24715 {
24718 }
24721 }
24723 /* Returns TRUE iff TOKEN is a token that can begin the body of a
24724 function-definition. */
24726 static bool
24728 {
24731 /* A ctor-initializer begins with a `:'. */
24733 /* A function-try-block begins with `try'. */
24735 /* A function-transaction-block begins with `__transaction_atomic'
24736 or `__transaction_relaxed'. */
24739 /* The named return value extension begins with `return'. */
24741 }
24743 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
24744 definition. */
24746 static bool
24748 {
24755 }
24757 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
24758 C++0x) ending a template-argument. */
24760 static bool
24762 {
24770 }
24772 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
24773 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
24775 static bool
24778 {
24784 /* Check for the sequence `<::' in the original code. It would be lexed as
24785 `[:', where `[' is a digraph, and there is no whitespace before
24786 `:'. */
24788 {
24793 }
24795 }
24797 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
24798 or none_type otherwise. */
24800 static enum tag_types
24802 {
24804 {
24814 }
24815 }
24817 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
24818 or none_type otherwise or if the token is null. */
24820 static enum tag_types
24822 {
24827 {
24835 }
24836 }
24838 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
24840 static void
24842 {
24846 {
24850 type))
24853 }
24854 }
24856 /* Issue an error message if DECL is redeclared with different
24857 access than its original declaration [class.access.spec/3].
24858 This applies to nested classes and nested class templates.
24859 [class.mem/1]. */
24861 static void
24863 {
24872 }
24874 /* Look for the `template' keyword, as a syntactic disambiguator.
24875 Return TRUE iff it is present, in which case it will be
24876 consumed. */
24878 static bool
24880 {
24882 {
24883 /* In C++98 the `template' keyword can only be used within templates;
24884 outside templates the parser can always figure out what is a
24885 template and what is not. In C++11, per the resolution of DR 468,
24886 `template' is allowed in cases where it is not strictly necessary. */
24889 {
24892 "in C++98 %<template%> (as a disambiguator) is only "
24894 /* If this part of the token stream is rescanned, the same
24895 error message would be generated. So, we purge the token
24896 from the stream. */
24899 }
24900 else
24901 {
24902 /* Consume the `template' keyword. */
24905 }
24906 }
24908 }
24910 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
24911 set PARSER->SCOPE, and perform other related actions. */
24913 static void
24915 {
24921 /* Get the stored value. */
24923 /* Perform any access checks that were deferred. */
24926 {
24931 }
24932 /* Set the scope from the stored value. */
24936 }
24938 /* Consume tokens up through a non-nested END token. Returns TRUE if we
24939 encounter the end of a block before what we were looking for. */
24941 static bool
24945 {
24947 {
24950 /* Abort a parenthesized expression if we encounter a semicolon. */
24954 /* If we've reached the end of the file, stop. */
24960 /* We've hit the end of an enclosing block, so there's been some
24961 kind of syntax error. */
24964 /* Consume the token. */
24966 /* See if it starts a new group. */
24968 {
24970 /* In theory this should probably check end == '}', but
24971 cp_parser_save_member_function_body needs it to exit
24972 after either '}' or ')' when called with ')'. */
24975 }
24977 {
24981 }
24986 }
24987 }
24989 /* Like above, for caching a default argument or NSDMI. Both of these are
24990 terminated by a non-nested comma, but it can be unclear whether or not a
24991 comma is nested in a template argument list unless we do more parsing.
24992 In order to handle this ambiguity, when we encounter a ',' after a '<'
24993 we try to parse what follows as a parameter-declaration-list (in the
24994 case of a default argument) or a member-declarator (in the case of an
24995 NSDMI). If that succeeds, then we stop caching. */
24997 static tree
24999 {
25004 tree default_argument;
25006 /* Add tokens until we have processed the entire default
25007 argument. We add the range [first_token, token). */
25010 {
25011 /* For list-initialization, this is straightforward. */
25014 }
25016 {
25019 /* Peek at the next token. */
25021 /* What we do depends on what token we have. */
25023 {
25024 /* In valid code, a default argument must be
25025 immediately followed by a `,' `)', or `...'. */
25028 {
25029 /* If we've seen a '<', we might be in a
25030 template-argument-list. Until Core issue 325 is
25031 resolved, we don't know how this situation ought
25032 to be handled, so try to DTRT. We check whether
25033 what comes after the comma is a valid parameter
25034 declaration list. If it is, then the comma ends
25035 the default argument; otherwise the default
25036 argument continues. */
25039 /* Set ITALP so cp_parser_parameter_declaration_list
25040 doesn't decide to commit to this parse. */
25048 {
25055 }
25056 else
25057 {
25061 }
25068 }
25071 /* If we run into a non-nested `;', `}', or `]',
25072 then the code is invalid -- but the default
25073 argument is certainly over. */
25078 /* Handle correctly int n = sizeof ... ( p ); */
25081 /* Update DEPTH, if necessary. */
25096 /* This might be the comparison operator, or it might
25097 start a template argument list. */
25104 /* Fall through for C++0x, which treats the `>>'
25105 operator like two `>' tokens in certain
25106 cases. */
25110 {
25111 /* This might be an operator, or it might close a
25112 template argument list. But if a previous '<'
25113 started a template argument list, this will have
25114 closed it, so we can't be in one anymore. */
25118 }
25121 /* If we run out of tokens, issue an error message. */
25130 /* In these cases, we should look for template-ids.
25131 For example, if the default argument is
25132 `X<int, double>()', we need to do name lookup to
25133 figure out whether or not `X' is a template; if
25134 so, the `,' does not end the default argument.
25136 That is not yet done. */
25141 }
25143 /* If we've reached the end, stop. */
25147 /* Add the token to the token block. */
25149 }
25151 /* Create a DEFAULT_ARG to represent the unparsed default
25152 argument. */
25159 }
25161 /* Begin parsing tentatively. We always save tokens while parsing
25162 tentatively so that if the tentative parsing fails we can restore the
25163 tokens. */
25165 static void
25167 {
25168 /* Enter a new parsing context. */
25170 /* Begin saving tokens. */
25172 /* In order to avoid repetitive access control error messages,
25173 access checks are queued up until we are no longer parsing
25174 tentatively. */
25176 }
25178 /* Commit to the currently active tentative parse. */
25180 static void
25182 {
25186 /* Mark all of the levels as committed. */
25189 {
25196 }
25197 }
25199 /* Commit to the topmost currently active tentative parse.
25201 Note that this function shouldn't be called when there are
25202 irreversible side-effects while in a tentative state. For
25203 example, we shouldn't create a permanent entry in the symbol
25204 table, or issue an error message that might not apply if the
25205 tentative parse is aborted. */
25207 static void
25209 {
25214 {
25222 }
25223 }
25225 /* Abort the currently active tentative parse. All consumed tokens
25226 will be rolled back, and no diagnostics will be issued. */
25228 static void
25230 {
25234 /* Now, pretend that we want to see if the construct was
25235 successfully parsed. */
25237 }
25239 /* Stop parsing tentatively. If a parse error has occurred, restore the
25240 token stream. Otherwise, commit to the tokens we have consumed.
25241 Returns true if no error occurred; false otherwise. */
25243 static bool
25245 {
25249 /* Remember whether or not an error occurred, since we are about to
25250 destroy that information. */
25252 /* Remove the topmost context from the stack. */
25255 /* If no parse errors occurred, commit to the tentative parse. */
25257 {
25258 /* Commit to the tokens read tentatively, unless that was
25259 already done. */
25264 }
25265 /* Otherwise, if errors occurred, roll back our state so that things
25266 are just as they were before we began the tentative parse. */
25267 else
25268 {
25271 }
25272 /* Add the context to the front of the free list. */
25277 }
25279 /* Returns true if we are parsing tentatively and are not committed to
25280 this tentative parse. */
25282 static bool
25284 {
25287 }
25289 /* Returns nonzero iff an error has occurred during the most recent
25290 tentative parse. */
25292 static bool
25294 {
25297 }
25299 /* Returns nonzero if GNU extensions are allowed. */
25301 static bool
25303 {
25305 }
25306 \f
25307 /* Objective-C++ Productions */
25310 /* Parse an Objective-C expression, which feeds into a primary-expression
25311 above.
25313 objc-expression:
25314 objc-message-expression
25315 objc-string-literal
25316 objc-encode-expression
25317 objc-protocol-expression
25318 objc-selector-expression
25320 Returns a tree representation of the expression. */
25322 static tree
25324 {
25325 /* Try to figure out what kind of declaration is present. */
25329 {
25339 {
25351 }
25357 }
25360 }
25362 /* Parse an Objective-C message expression.
25364 objc-message-expression:
25365 [ objc-message-receiver objc-message-args ]
25367 Returns a representation of an Objective-C message. */
25369 static tree
25371 {
25380 }
25382 /* Parse an objc-message-receiver.
25384 objc-message-receiver:
25385 expression
25386 simple-type-specifier
25388 Returns a representation of the type or expression. */
25390 static tree
25392 {
25393 tree rcv;
25395 /* An Objective-C message receiver may be either (1) a type
25396 or (2) an expression. */
25405 CP_PARSER_FLAGS_NONE);
25408 }
25410 /* Parse the arguments and selectors comprising an Objective-C message.
25412 objc-message-args:
25413 objc-selector
25414 objc-selector-args
25415 objc-selector-args , objc-comma-args
25417 objc-selector-args:
25418 objc-selector [opt] : assignment-expression
25419 objc-selector-args objc-selector [opt] : assignment-expression
25421 objc-comma-args:
25422 assignment-expression
25423 objc-comma-args , assignment-expression
25425 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
25426 selector arguments and TREE_VALUE containing a list of comma
25427 arguments. */
25429 static tree
25431 {
25437 {
25443 /* Detect if we have a unary selector. */
25452 sel_args
25457 }
25459 /* Handle non-selector arguments, if any. */
25461 {
25462 tree arg;
25467 addl_args
25472 }
25475 {
25478 }
25481 }
25483 /* Parse an Objective-C encode expression.
25485 objc-encode-expression:
25486 @encode objc-typename
25488 Returns an encoded representation of the type argument. */
25490 static tree
25492 {
25493 tree type;
25503 {
25507 }
25509 /* This happens if we find @encode(T) (where T is a template
25510 typename or something dependent on a template typename) when
25511 parsing a template. In that case, we can't compile it
25512 immediately, but we rather create an AT_ENCODE_EXPR which will
25513 need to be instantiated when the template is used.
25514 */
25516 {
25520 }
25523 }
25525 /* Parse an Objective-C @defs expression. */
25527 static tree
25529 {
25530 tree name;
25538 }
25540 /* Parse an Objective-C protocol expression.
25542 objc-protocol-expression:
25543 @protocol ( identifier )
25545 Returns a representation of the protocol expression. */
25547 static tree
25549 {
25550 tree proto;
25558 }
25560 /* Parse an Objective-C selector expression.
25562 objc-selector-expression:
25563 @selector ( objc-method-signature )
25565 objc-method-signature:
25566 objc-selector
25567 objc-selector-seq
25569 objc-selector-seq:
25570 objc-selector :
25571 objc-selector-seq objc-selector :
25573 Returns a representation of the method selector. */
25575 static tree
25577 {
25589 {
25598 {
25599 /* Detect if we have a unary selector. */
25601 {
25604 }
25605 else
25606 {
25608 }
25609 }
25614 {
25615 sel_seq
25618 sel_seq
25621 }
25622 else
25623 sel_seq
25628 }
25630 finish_selector:
25634 }
25636 /* Parse a list of identifiers.
25638 objc-identifier-list:
25639 identifier
25640 objc-identifier-list , identifier
25642 Returns a TREE_LIST of identifier nodes. */
25644 static tree
25646 {
25647 tree identifier;
25648 tree list;
25659 {
25666 identifier));
25668 }
25671 }
25673 /* Parse an Objective-C alias declaration.
25675 objc-alias-declaration:
25676 @compatibility_alias identifier identifier ;
25678 This function registers the alias mapping with the Objective-C front end.
25679 It returns nothing. */
25681 static void
25683 {
25691 }
25693 /* Parse an Objective-C class forward-declaration.
25695 objc-class-declaration:
25696 @class objc-identifier-list ;
25698 The function registers the forward declarations with the Objective-C
25699 front end. It returns nothing. */
25701 static void
25703 {
25706 {
25707 tree id;
25717 else
25719 }
25721 }
25723 /* Parse a list of Objective-C protocol references.
25725 objc-protocol-refs-opt:
25726 objc-protocol-refs [opt]
25728 objc-protocol-refs:
25729 < objc-identifier-list >
25731 Returns a TREE_LIST of identifiers, if any. */
25733 static tree
25735 {
25739 {
25743 }
25746 }
25748 /* Parse a Objective-C visibility specification. */
25750 static void
25752 {
25756 {
25771 }
25773 /* Eat '@private'/'@protected'/'@public'. */
25775 }
25777 /* Parse an Objective-C method type. Return 'true' if it is a class
25778 (+) method, and 'false' if it is an instance (-) method. */
25782 {
25785 else
25787 }
25789 /* Parse an Objective-C protocol qualifier. */
25791 static tree
25793 {
25806 {
25811 }
25814 }
25816 /* Parse an Objective-C typename. */
25818 static tree
25820 {
25824 {
25830 /* An ObjC type name may consist of just protocol qualifiers, in which
25831 case the type shall default to 'id'. */
25833 {
25836 /* If the type could not be parsed, an error has already
25837 been produced. For error recovery, behave as if it had
25838 not been specified, which will use the default type
25839 'id'. */
25841 {
25843 /* We need to skip to the closing parenthesis as
25844 cp_parser_type_id() does not seem to do it for
25845 us. */
25850 }
25851 }
25855 }
25858 }
25860 /* Check to see if TYPE refers to an Objective-C selector name. */
25862 static bool
25864 {
25870 }
25872 /* Parse an Objective-C selector. */
25874 static tree
25876 {
25880 {
25883 }
25885 /* C++ operator names are allowed to appear in ObjC selectors. */
25887 {
25900 }
25901 }
25903 /* Parse an Objective-C params list. */
25905 static tree
25907 {
25913 {
25923 /* Detect if we have a unary selector. */
25926 {
25929 }
25933 {
25934 /* Something went quite wrong. There should be a colon
25935 here, but there is not. Stop parsing parameters. */
25937 }
25939 /* New ObjC allows attributes on parameters too. */
25944 params
25947 type_name,
25948 identifier,
25949 parm_attr));
25952 }
25955 {
25958 }
25960 /* We allow tail attributes for the method. */
25962 {
25970 }
25973 {
25976 }
25978 }
25980 /* Parse the non-keyword Objective-C params. */
25982 static tree
25985 {
25991 {
25993 tree parm;
25999 {
26004 }
26006 /* TODO: parse attributes for tail parameters. */
26015 }
26017 /* We allow tail attributes for the method. */
26019 {
26021 {
26026 }
26027 else
26028 /* We have an error, but parse the attributes, so that we can
26029 carry on. */
26035 }
26038 }
26040 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
26042 static void
26044 {
26047 /* If the next token is `extern' and the following token is a string
26048 literal, then we have a linkage specification. */
26050 && cp_parser_is_pure_string_literal
26053 /* Handle #pragma, if any. */
26056 /* Allow stray semicolons. */
26059 /* Mark methods as optional or required, when building protocols. */
26061 {
26064 }
26066 {
26069 }
26072 /* Other stray characters must generate errors. */
26074 {
26078 }
26079 /* Finally, try to parse a block-declaration, or a function-definition. */
26080 else
26082 }
26084 /* Parse a method signature. */
26086 static tree
26088 {
26104 }
26106 static bool
26108 {
26109 tree tattr;
26114 /* If the attributes are followed by a method introducer, this is not allowed.
26115 Dump the attributes and flag the situation. */
26120 /* Otherwise, the attributes introduce some interstitial code, possibly so
26121 rewind to allow that check. */
26124 }
26126 /* Parse an Objective-C method prototype list. */
26128 static void
26130 {
26134 {
26136 {
26141 else
26145 {
26149 }
26152 }
26158 OPT_Wattributes,
26160 else
26161 /* Allow for interspersed non-ObjC++ code. */
26165 }
26169 else
26173 }
26175 /* Parse an Objective-C method definition list. */
26177 static void
26179 {
26183 {
26184 tree meth;
26187 {
26193 else
26198 {
26202 }
26204 NULL_TREE);
26206 /* For historical reasons, we accept an optional semicolon. */
26213 {
26220 }
26221 }
26222 /* The following case will be removed once @synthesize is
26223 completely implemented. */
26234 else
26235 /* Allow for interspersed non-ObjC++ code. */
26239 }
26243 else
26247 }
26249 /* Parse Objective-C ivars. */
26251 static void
26253 {
26264 {
26265 cp_decl_specifier_seq declspecs;
26267 tree prefix_attributes;
26275 CP_PARSER_FLAGS_OPTIONAL,
26279 /* auto, register, static, extern, mutable. */
26281 {
26284 }
26286 /* thread_local. */
26288 {
26291 }
26293 /* typedef. */
26295 {
26298 }
26303 /* Keep going until we hit the `;' at the end of the
26304 declaration. */
26306 {
26311 /* Check for a (possibly unnamed) bitfield declaration. */
26319 {
26320 /* Get the name of the bitfield. */
26323 sfk_none);
26325 eat_colon:
26327 /* Get the width of the bitfield. */
26328 width
26331 NULL);
26332 }
26333 else
26334 {
26335 /* Parse the declarator. */
26336 declarator
26342 }
26344 /* Look for attributes that apply to the ivar. */
26346 /* Remember which attributes are prefix attributes and
26347 which are not. */
26349 /* Combine the attributes. */
26353 /* Create the bitfield declaration. */
26355 width,
26356 attributes);
26357 else
26362 /* Add the instance variable. */
26366 /* Reset PREFIX_ATTRIBUTES. */
26375 {
26378 }
26380 }
26384 }
26389 /* Do not consume the RID_AT_END, so it will be read again as terminating
26390 the @interface of @implementation. */
26394 /* For historical reasons, we accept an optional semicolon. */
26397 }
26399 /* Parse an Objective-C protocol declaration. */
26401 static void
26403 {
26409 {
26414 }
26416 /* See if we have a forward declaration or a definition. */
26419 /* Try a forward declaration first. */
26421 {
26423 {
26424 tree id;
26434 else
26436 }
26438 }
26440 /* Ok, we got a full-fledged definition (or at least should). */
26441 else
26442 {
26447 }
26448 }
26450 /* Parse an Objective-C superclass or category. */
26452 static void
26457 {
26463 {
26466 }
26468 {
26471 /* If there is no category name, and this is an @interface, we
26472 have a class extension. */
26474 {
26477 }
26478 else
26482 }
26483 }
26485 /* Parse an Objective-C class interface. */
26487 static void
26489 {
26496 {
26497 /* It's hard to recover because even if valid @interface stuff
26498 is to follow, we can't compile it (or validate it) if we
26499 don't even know which class it refers to. Let's assume this
26500 was a stray '@interface' token in the stream and skip it.
26501 */
26503 }
26508 /* We have either a class or a category on our hands. */
26511 else
26512 {
26514 /* Handle instance variable declarations, if any. */
26517 }
26520 }
26522 /* Parse an Objective-C class implementation. */
26524 static void
26526 {
26533 {
26534 /* It's hard to recover because even if valid @implementation
26535 stuff is to follow, we can't compile it (or validate it) if
26536 we don't even know which class it refers to. Let's assume
26537 this was a stray '@implementation' token in the stream and
26538 skip it.
26539 */
26541 }
26545 /* We have either a class or a category on our hands. */
26548 else
26549 {
26551 /* Handle instance variable declarations, if any. */
26554 }
26557 }
26559 /* Consume the @end token and finish off the implementation. */
26561 static void
26563 {
26566 }
26568 /* Parse an Objective-C declaration. */
26570 static void
26572 {
26573 /* Try to figure out what kind of declaration is present. */
26578 {
26594 }
26597 {
26620 }
26621 }
26623 /* Parse an Objective-C try-catch-finally statement.
26625 objc-try-catch-finally-stmt:
26626 @try compound-statement objc-catch-clause-seq [opt]
26627 objc-finally-clause [opt]
26629 objc-catch-clause-seq:
26630 objc-catch-clause objc-catch-clause-seq [opt]
26632 objc-catch-clause:
26633 @catch ( objc-exception-declaration ) compound-statement
26635 objc-finally-clause:
26636 @finally compound-statement
26638 objc-exception-declaration:
26639 parameter-declaration
26640 '...'
26642 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
26644 Returns NULL_TREE.
26646 PS: This function is identical to c_parser_objc_try_catch_finally_statement
26647 for C. Keep them in sync. */
26649 static tree
26651 {
26652 location_t location;
26653 tree stmt;
26658 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
26659 node, lest it get absorbed into the surrounding block. */
26665 {
26674 {
26675 /* We have "@catch (...)" (where the '...' are literally
26676 what is in the code). Skip the '...'.
26677 parameter_declaration is set to NULL_TREE, and
26678 objc_being_catch_clauses() knows that that means
26679 '...'. */
26682 }
26683 else
26684 {
26685 /* We have "@catch (NSException *exception)" or something
26686 like that. Parse the parameter declaration. */
26690 else
26695 }
26698 else
26699 {
26700 /* If there was no open parenthesis, we are recovering from
26701 an error, and we are trying to figure out what mistake
26702 the user has made. */
26704 /* If there is an immediate closing parenthesis, the user
26705 probably forgot the opening one (ie, they typed "@catch
26706 NSException *e)". Parse the closing parenthesis and keep
26707 going. */
26711 /* If these is no immediate closing parenthesis, the user
26712 probably doesn't know that parenthesis are required at
26713 all (ie, they typed "@catch NSException *e"). So, just
26714 forget about the closing parenthesis and keep going. */
26715 }
26719 }
26721 {
26724 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
26725 node, lest it get absorbed into the surrounding block. */
26729 }
26732 }
26734 /* Parse an Objective-C synchronized statement.
26736 objc-synchronized-stmt:
26737 @synchronized ( expression ) compound-statement
26739 Returns NULL_TREE. */
26741 static tree
26743 {
26744 location_t location;
26755 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
26756 node, lest it get absorbed into the surrounding block. */
26761 }
26763 /* Parse an Objective-C throw statement.
26765 objc-throw-stmt:
26766 @throw assignment-expression [opt] ;
26768 Returns a constructed '@throw' statement. */
26770 static tree
26772 {
26784 }
26786 /* Parse an Objective-C statement. */
26788 static tree
26790 {
26791 /* Try to figure out what kind of declaration is present. */
26795 {
26806 }
26809 }
26811 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
26812 look ahead to see if an objc keyword follows the attributes. This
26813 is to detect the use of prefix attributes on ObjC @interface and
26814 @protocol. */
26816 static bool
26818 {
26823 {
26826 }
26829 }
26831 /* This routine is a minimal replacement for
26832 c_parser_struct_declaration () used when parsing the list of
26833 types/names or ObjC++ properties. For example, when parsing the
26834 code
26836 @property (readonly) int a, b, c;
26838 this function is responsible for parsing "int a, int b, int c" and
26839 returning the declarations as CHAIN of DECLs.
26841 TODO: Share this code with cp_parser_objc_class_ivars. It's very
26842 similar parsing. */
26843 static tree
26845 {
26847 cp_decl_specifier_seq declspecs;
26849 tree prefix_attributes;
26852 CP_PARSER_FLAGS_NONE,
26859 /* auto, register, static, extern, mutable. */
26861 {
26864 }
26866 /* thread_local. */
26868 {
26871 }
26873 /* typedef. */
26875 {
26878 }
26883 /* Keep going until we hit the `;' at the end of the declaration. */
26885 {
26890 /* Parse the declarator. */
26894 /* Look for attributes that apply to the ivar. */
26896 /* Remember which attributes are prefix attributes and
26897 which are not. */
26899 /* Combine the attributes. */
26909 /* Reset PREFIX_ATTRIBUTES. */
26920 {
26923 }
26924 else
26926 }
26928 }
26930 /* Parse an Objective-C @property declaration. The syntax is:
26932 objc-property-declaration:
26933 '@property' objc-property-attributes[opt] struct-declaration ;
26935 objc-property-attributes:
26936 '(' objc-property-attribute-list ')'
26938 objc-property-attribute-list:
26939 objc-property-attribute
26940 objc-property-attribute-list, objc-property-attribute
26942 objc-property-attribute
26943 'getter' = identifier
26944 'setter' = identifier
26945 'readonly'
26946 'readwrite'
26947 'assign'
26948 'retain'
26949 'copy'
26950 'nonatomic'
26952 For example:
26953 @property NSString *name;
26954 @property (readonly) id object;
26955 @property (retain, nonatomic, getter=getTheName) id name;
26956 @property int a, b, c;
26958 PS: This function is identical to
26959 c_parser_objc_at_property_declaration for C. Keep them in sync. */
26960 static void
26962 {
26963 /* The following variables hold the attributes of the properties as
26964 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
26965 seen. When we see an attribute, we set them to 'true' (if they
26966 are boolean properties) or to the identifier (if they have an
26967 argument, ie, for getter and setter). Note that here we only
26968 parse the list of attributes, check the syntax and accumulate the
26969 attributes that we find. objc_add_property_declaration() will
26970 then process the information. */
26980 /* 'properties' is the list of properties that we read. Usually a
26981 single one, but maybe more (eg, in "@property int a, b, c;" there
26982 are three). */
26983 tree properties;
26984 location_t loc;
26990 /* Parse the optional attribute list... */
26992 {
26993 /* Eat the '('. */
26997 {
27003 {
27006 }
27010 {
27021 {
27025 else
27030 }
27033 {
27037 }
27039 {
27041 {
27044 }
27045 else
27049 else
27051 }
27052 else
27053 {
27055 {
27058 }
27059 else
27061 }
27067 }
27074 else
27076 }
27078 /* FIXME: "@property (setter, assign);" will generate a spurious
27079 "error: expected ‘)’ before ‘,’ token". This is because
27080 cp_parser_require, unlike the C counterpart, will produce an
27081 error even if we are in error recovery. */
27083 {
27088 }
27089 }
27091 /* ... and the property declaration(s). */
27095 {
27097 /* If the next token is now a `;', consume it. */
27101 }
27105 else
27106 {
27107 /* Comma-separated properties are chained together in
27108 reverse order; add them one by one. */
27117 }
27120 }
27122 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
27124 objc-synthesize-declaration:
27125 @synthesize objc-synthesize-identifier-list ;
27127 objc-synthesize-identifier-list:
27128 objc-synthesize-identifier
27129 objc-synthesize-identifier-list, objc-synthesize-identifier
27131 objc-synthesize-identifier
27132 identifier
27133 identifier = identifier
27135 For example:
27136 @synthesize MyProperty;
27137 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
27139 PS: This function is identical to c_parser_objc_at_synthesize_declaration
27140 for C. Keep them in sync.
27141 */
27142 static void
27144 {
27146 location_t loc;
27151 {
27155 {
27158 }
27160 {
27164 {
27167 }
27168 }
27169 else
27174 else
27176 }
27179 }
27181 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
27183 objc-dynamic-declaration:
27184 @dynamic identifier-list ;
27186 For example:
27187 @dynamic MyProperty;
27188 @dynamic MyProperty, AnotherProperty;
27190 PS: This function is identical to c_parser_objc_at_dynamic_declaration
27191 for C. Keep them in sync.
27192 */
27193 static void
27195 {
27197 location_t loc;
27202 {
27203 tree property;
27206 {
27209 }
27213 else
27215 }
27218 }
27220 \f
27221 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 parsing routines. */
27223 /* Returns name of the next clause.
27224 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
27225 the token is not consumed. Otherwise appropriate pragma_omp_clause is
27226 returned and the token is consumed. */
27228 static pragma_omp_clause
27230 {
27242 {
27247 {
27350 }
27351 }
27357 }
27359 /* Validate that a clause of the given type does not already exist. */
27361 static void
27364 {
27365 tree c;
27369 {
27372 }
27373 }
27375 /* OpenMP 2.5:
27376 variable-list:
27377 identifier
27378 variable-list , identifier
27380 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
27381 colon). An opening parenthesis will have been consumed by the caller.
27383 If KIND is nonzero, create the appropriate node and install the decl
27384 in OMP_CLAUSE_DECL and add the node to the head of the list.
27386 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
27387 return the list created.
27389 COLON can be NULL if only closing parenthesis should end the list,
27390 or pointer to bool which will receive false if the list is terminated
27391 by closing parenthesis or true if the list is terminated by colon. */
27393 static tree
27396 {
27400 {
27403 }
27405 {
27422 {
27424 {
27430 {
27438 parser->colon_corrects_to_scope_p
27442 else
27443 {
27444 /* Look for `:'. */
27448 CPP_CLOSE_SQUARE))
27450 }
27451 /* Look for the closing `]'. */
27453 RT_CLOSE_SQUARE))
27456 }
27460 }
27466 }
27467 else
27470 get_comma:
27474 }
27480 {
27484 }
27487 {
27490 /* Try to resync to an unnested comma. Copied from
27491 cp_parser_parenthesized_expression_list. */
27492 skip_comma:
27501 }
27504 }
27506 /* Similarly, but expect leading and trailing parenthesis. This is a very
27507 common case for omp clauses. */
27509 static tree
27511 {
27515 }
27517 /* OpenMP 3.0:
27518 collapse ( constant-expression ) */
27520 static tree
27522 {
27524 location_t loc;
27525 HOST_WIDE_INT n;
27545 {
27548 }
27556 }
27558 /* OpenMP 2.5:
27559 default ( shared | none ) */
27561 static tree
27563 {
27565 tree c;
27570 {
27575 {
27590 }
27593 }
27594 else
27595 {
27596 invalid_kind:
27598 }
27614 }
27616 /* OpenMP 3.1:
27617 final ( expression ) */
27619 static tree
27621 {
27642 }
27644 /* OpenMP 2.5:
27645 if ( expression ) */
27647 static tree
27649 {
27670 }
27672 /* OpenMP 3.1:
27673 mergeable */
27675 static tree
27678 {
27679 tree c;
27682 location);
27687 }
27689 /* OpenMP 2.5:
27690 nowait */
27692 static tree
27695 {
27696 tree c;
27703 }
27705 /* OpenMP 2.5:
27706 num_threads ( expression ) */
27708 static tree
27710 location_t location)
27711 {
27733 }
27735 /* OpenMP 2.5:
27736 ordered */
27738 static tree
27741 {
27742 tree c;
27750 }
27752 /* OpenMP 2.5:
27753 reduction ( reduction-operator : variable-list )
27755 reduction-operator:
27756 One of: + * - & ^ | && ||
27758 OpenMP 3.1:
27760 reduction-operator:
27761 One of: + * - & ^ | && || min max
27763 OpenMP 4.0:
27765 reduction-operator:
27766 One of: + * - & ^ | && ||
27767 id-expression */
27769 static tree
27771 {
27779 {
27789 }
27793 else
27794 {
27805 {
27835 }
27836 else
27837 {
27839 resync_fail:
27844 }
27845 }
27851 NULL);
27853 {
27856 }
27859 }
27861 /* OpenMP 2.5:
27862 schedule ( schedule-kind )
27863 schedule ( schedule-kind , expression )
27865 schedule-kind:
27866 static | dynamic | guided | runtime | auto */
27868 static tree
27870 {
27879 {
27884 {
27905 }
27906 }
27911 else
27916 {
27931 else
27936 }
27944 invalid_kind:
27946 resync_fail:
27951 }
27953 /* OpenMP 3.0:
27954 untied */
27956 static tree
27959 {
27960 tree c;
27967 }
27969 /* OpenMP 4.0:
27970 inbranch
27971 notinbranch */
27973 static tree
27976 {
27981 }
27983 /* OpenMP 4.0:
27984 parallel
27985 for
27986 sections
27987 taskgroup */
27989 static tree
27993 {
27997 }
27999 /* OpenMP 4.0:
28000 num_teams ( expression ) */
28002 static tree
28004 location_t location)
28005 {
28027 }
28029 /* OpenMP 4.0:
28030 thread_limit ( expression ) */
28032 static tree
28034 location_t location)
28035 {
28057 }
28059 /* OpenMP 4.0:
28060 aligned ( variable-list )
28061 aligned ( variable-list : constant-expression ) */
28063 static tree
28065 {
28076 {
28086 }
28092 }
28094 /* OpenMP 4.0:
28095 linear ( variable-list )
28096 linear ( variable-list : expression ) */
28098 static tree
28101 {
28112 {
28116 {
28119 }
28127 }
28133 }
28135 /* OpenMP 4.0:
28136 safelen ( constant-expression ) */
28138 static tree
28140 location_t location)
28141 {
28162 }
28164 /* OpenMP 4.0:
28165 simdlen ( constant-expression ) */
28167 static tree
28169 location_t location)
28170 {
28191 }
28193 /* OpenMP 4.0:
28194 depend ( depend-kind : variable-list )
28196 depend-kind:
28197 in | out | inout */
28199 static tree
28201 {
28209 {
28219 else
28221 }
28222 else
28230 NULL);
28237 invalid_kind:
28239 resync_fail:
28244 }
28246 /* OpenMP 4.0:
28247 map ( map-kind : variable-list )
28248 map ( variable-list )
28250 map-kind:
28251 alloc | to | from | tofrom */
28253 static tree
28255 {
28264 {
28276 else
28277 {
28283 }
28286 }
28289 NULL);
28295 }
28297 /* OpenMP 4.0:
28298 device ( expression ) */
28300 static tree
28302 location_t location)
28303 {
28325 }
28327 /* OpenMP 4.0:
28328 dist_schedule ( static )
28329 dist_schedule ( static , expression ) */
28331 static tree
28333 location_t location)
28334 {
28347 {
28358 }
28363 location);
28367 invalid_kind:
28369 resync_fail:
28374 }
28376 /* OpenMP 4.0:
28377 proc_bind ( proc-bind-kind )
28379 proc-bind-kind:
28380 master | close | spread */
28382 static tree
28384 location_t location)
28385 {
28386 tree c;
28393 {
28403 else
28405 }
28406 else
28415 location);
28420 invalid_kind:
28422 resync_fail:
28427 }
28429 /* Parse all OpenMP clauses. The set clauses allowed by the directive
28430 is a bitmask in MASK. Return the list of clauses found; the result
28431 of clause default goes in *pdefault. */
28433 static tree
28437 {
28444 {
28445 pragma_omp_clause c_kind;
28456 {
28468 clauses);
28482 clauses);
28491 clauses);
28515 clauses);
28529 clauses);
28546 OMP_CLAUSE_NOTINBRANCH,
28555 {
28556 clause_not_first:
28560 }
28585 clauses);
28590 clauses);
28595 clauses);
28658 }
28663 {
28664 /* Remove the invalid clause(s) from the list to avoid
28665 confusing the rest of the compiler. */
28668 }
28669 }
28670 saw_error:
28671 /* In Cilk Plus SIMD enabled functions there is no pragma_token, so
28672 no reason to skip to the end. */
28678 }
28680 /* OpenMP 2.5:
28681 structured-block:
28682 statement
28684 In practice, we're also interested in adding the statement to an
28685 outer node. So it is convenient if we work around the fact that
28686 cp_parser_statement calls add_stmt. */
28688 static unsigned
28690 {
28693 /* Only move the values to IN_OMP_BLOCK if they weren't false.
28694 This preserves the "not within loop or switch" style error messages
28695 for nonsense cases like
28696 void foo() {
28697 #pragma omp single
28698 break;
28699 }
28700 */
28705 }
28707 static void
28709 {
28711 }
28713 static tree
28715 {
28723 }
28725 /* OpenMP 2.5:
28726 # pragma omp atomic new-line
28727 expression-stmt
28729 expression-stmt:
28730 x binop= expr | x++ | ++x | x-- | --x
28731 binop:
28732 +, *, -, /, &, ^, |, <<, >>
28734 where x is an lvalue expression with scalar type.
28736 OpenMP 3.1:
28737 # pragma omp atomic new-line
28738 update-stmt
28740 # pragma omp atomic read new-line
28741 read-stmt
28743 # pragma omp atomic write new-line
28744 write-stmt
28746 # pragma omp atomic update new-line
28747 update-stmt
28749 # pragma omp atomic capture new-line
28750 capture-stmt
28752 # pragma omp atomic capture new-line
28753 capture-block
28755 read-stmt:
28756 v = x
28757 write-stmt:
28758 x = expr
28759 update-stmt:
28760 expression-stmt | x = x binop expr
28761 capture-stmt:
28762 v = expression-stmt
28763 capture-block:
28764 { v = x; update-stmt; } | { update-stmt; v = x; }
28766 OpenMP 4.0:
28767 update-stmt:
28768 expression-stmt | x = x binop expr | x = expr binop x
28769 capture-stmt:
28770 v = update-stmt
28771 capture-block:
28772 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
28774 where x and v are lvalue expressions with scalar type. */
28776 static void
28778 {
28786 {
28791 {
28797 }
28798 }
28800 {
28812 else
28816 }
28818 {
28824 {
28829 {
28832 }
28833 }
28834 }
28838 {
28849 else
28855 {
28856 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
28857 opcode. */
28862 }
28866 {
28869 }
28870 else
28871 {
28878 }
28881 }
28883 restart:
28888 {
28895 /* FALLTHROUGH */
28905 /* FALLTHROUGH */
28920 /* Undo effects of boolean_increment for post {in,de}crement. */
28922 /* FALLTHRU */
28926 {
28927 /* Undo effects of boolean_increment. */
28929 {
28930 /* This is pre or post increment. */
28935 && !structured_block
28939 }
28940 }
28941 /* FALLTHRU */
28944 {
28979 {
28983 }
28986 {
28992 {
28997 }
28999 {
29010 {
29012 {
29017 }
29018 else
29020 }
29024 }
29027 {
29034 }
29038 }
29042 {
29045 {
29053 }
29055 {
29060 }
29095 }
29106 /* FALLTHROUGH */
29111 }
29118 }
29119 stmt_done:
29121 {
29134 }
29136 {
29139 }
29140 done:
29146 saw_error:
29149 {
29153 {
29157 }
29158 }
29159 }
29162 /* OpenMP 2.5:
29163 # pragma omp barrier new-line */
29165 static void
29167 {
29170 }
29172 /* OpenMP 2.5:
29173 # pragma omp critical [(name)] new-line
29174 structured-block */
29176 static tree
29178 {
29182 {
29194 }
29199 }
29201 /* OpenMP 2.5:
29202 # pragma omp flush flush-vars[opt] new-line
29204 flush-vars:
29205 ( variable-list ) */
29207 static void
29209 {
29215 }
29217 /* Helper function, to parse omp for increment expression. */
29219 static tree
29221 {
29226 {
29229 }
29232 {
29241 /* Fall through: OpenMP disallows NE_EXPR. */
29244 }
29246 /* If decl is an iterator, preserve LHS and RHS of the relational
29247 expr until finish_omp_for. */
29257 }
29259 /* Helper function, to parse omp for increment expression. */
29261 static tree
29263 {
29267 cp_id_kind idk;
29271 {
29279 }
29287 {
29292 }
29299 {
29303 }
29315 do
29316 {
29323 {
29325 {
29328 else
29330 tf_warning_or_error);
29331 }
29332 else
29335 }
29336 }
29340 {
29344 }
29345 else
29349 }
29351 /* Parse the initialization statement of either an OpenMP for loop or
29352 a Cilk Plus for loop.
29354 Return true if the resulting construct should have an
29355 OMP_CLAUSE_PRIVATE added to it. */
29357 static bool
29365 {
29371 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
29373 init-expr:
29374 var = lb
29375 integer-type var = lb
29376 random-access-iterator-type var = lb
29377 pointer-type var = lb
29378 */
29379 cp_decl_specifier_seq type_specifiers;
29381 /* First, try to parse as an initialized declaration. See
29382 cp_parser_condition, from whence the bulk of this is copied. */
29389 {
29390 /* If parsing a type specifier seq succeeded, then this
29391 MUST be a initialized declaration. */
29396 CP_PARSER_DECLARATOR_NAMED,
29407 else
29408 {
29418 {
29420 CPP_OPEN_PAREN))
29421 {
29425 else
29428 }
29429 else
29430 /* Trigger an error. */
29435 }
29439 {
29447 {
29450 auto_node);
29455 }
29458 asm_specification,
29459 LOOKUP_ONLYCONVERTING);
29461 {
29464 }
29465 else
29468 }
29469 else
29470 {
29471 /* Consume '='. */
29475 non_class:
29478 else
29481 asm_specification,
29482 LOOKUP_ONLYCONVERTING);
29483 }
29487 }
29488 }
29489 else
29490 {
29491 cp_id_kind idk;
29492 /* If parsing a type specifier sequence failed, then
29493 this MUST be a simple expression. */
29501 && decl
29504 {
29505 tree rhs;
29512 rhs,
29513 tf_warning_or_error));
29515 }
29516 else
29517 {
29522 {
29526 }
29527 }
29528 }
29530 }
29532 /* Parse the restricted form of the for statement allowed by OpenMP. */
29534 static tree
29537 {
29541 location_t loc_first;
29560 {
29563 location_t loc;
29567 {
29570 }
29573 {
29576 }
29585 add_private_clause
29592 {
29595 {
29601 }
29602 else
29604 }
29611 {
29616 {
29620 }
29623 {
29624 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
29625 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
29630 {
29633 }
29634 else
29635 {
29638 }
29642 }
29643 else
29644 {
29649 }
29650 }
29653 {
29654 tree c;
29656 {
29665 decl);
29669 decl);
29670 }
29672 {
29677 {
29680 }
29681 }
29682 }
29691 {
29692 /* If decl is an iterator, preserve the operator on decl
29693 until finish_omp_for. */
29695 && ((processing_template_decl
29699 else
29703 }
29718 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
29719 in between the collapsed for loops to be still considered perfectly
29720 nested. Hopefully the final version clarifies this.
29721 For now handle (multiple) {'s and empty statements. */
29723 do
29724 {
29728 {
29730 bracecount++;
29731 }
29735 else
29736 {
29743 }
29744 }
29748 {
29751 }
29752 }
29754 /* Note that we saved the original contents of this flag when we entered
29755 the structured block, and so we don't need to re-save it here. */
29758 else
29761 /* Note that the grammar doesn't call for a structured block here,
29762 though the loop as a whole is a structured block. */
29769 else
29774 {
29776 {
29778 nbraces--;
29779 }
29782 else
29783 {
29785 {
29788 }
29793 }
29794 }
29801 }
29803 /* Helper function for OpenMP parsing, split clauses and call
29804 finish_omp_clauses on each of the set of clauses afterwards. */
29806 static void
29809 {
29815 }
29817 /* OpenMP 4.0:
29818 #pragma omp simd simd-clause[optseq] new-line
29819 for-loop */
29821 #define OMP_SIMD_CLAUSE_MASK \
29822 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
29823 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
29824 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
29825 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29826 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
29827 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
29828 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
29830 static tree
29833 {
29845 {
29848 }
29859 }
29861 /* OpenMP 2.5:
29862 #pragma omp for for-clause[optseq] new-line
29863 for-loop
29865 OpenMP 4.0:
29866 #pragma omp for simd for-simd-clause[optseq] new-line
29867 for-loop */
29869 #define OMP_FOR_CLAUSE_MASK \
29870 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29871 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
29872 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
29873 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
29874 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
29875 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
29876 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
29877 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
29879 static tree
29882 {
29893 {
29898 {
29906 cclauses);
29910 cclauses);
29922 }
29923 }
29925 {
29928 }
29933 {
29936 }
29947 }
29949 /* OpenMP 2.5:
29950 # pragma omp master new-line
29951 structured-block */
29953 static tree
29955 {
29959 }
29961 /* OpenMP 2.5:
29962 # pragma omp ordered new-line
29963 structured-block */
29965 static tree
29967 {
29971 }
29973 /* OpenMP 2.5:
29975 section-scope:
29976 { section-sequence }
29978 section-sequence:
29979 section-directive[opt] structured-block
29980 section-sequence section-directive structured-block */
29982 static tree
29984 {
29995 {
29999 }
30002 {
30010 {
30014 }
30016 {
30019 }
30024 }
30035 }
30037 /* OpenMP 2.5:
30038 # pragma omp sections sections-clause[optseq] newline
30039 sections-scope */
30041 #define OMP_SECTIONS_CLAUSE_MASK \
30042 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30043 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30044 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30045 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30046 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
30048 static tree
30051 {
30063 {
30066 }
30073 }
30075 /* OpenMP 2.5:
30076 # pragma omp parallel parallel-clause[optseq] new-line
30077 structured-block
30078 # pragma omp parallel for parallel-for-clause[optseq] new-line
30079 structured-block
30080 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
30081 structured-block
30083 OpenMP 4.0:
30084 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
30085 structured-block */
30087 #define OMP_PARALLEL_CLAUSE_MASK \
30088 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
30089 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30090 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30091 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
30092 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
30093 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
30094 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30095 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
30096 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
30098 static tree
30101 {
30110 {
30123 block);
30128 }
30130 {
30134 }
30136 {
30139 }
30141 {
30145 {
30155 block);
30158 }
30159 }
30169 }
30171 /* OpenMP 2.5:
30172 # pragma omp single single-clause[optseq] new-line
30173 structured-block */
30175 #define OMP_SINGLE_CLAUSE_MASK \
30176 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30177 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30178 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
30179 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
30181 static tree
30183 {
30193 }
30195 /* OpenMP 3.0:
30196 # pragma omp task task-clause[optseq] new-line
30197 structured-block */
30199 #define OMP_TASK_CLAUSE_MASK \
30200 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
30201 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
30202 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
30203 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30204 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30205 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
30206 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
30207 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
30208 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND))
30210 static tree
30212 {
30223 }
30225 /* OpenMP 3.0:
30226 # pragma omp taskwait new-line */
30228 static void
30230 {
30233 }
30235 /* OpenMP 3.1:
30236 # pragma omp taskyield new-line */
30238 static void
30240 {
30243 }
30245 /* OpenMP 4.0:
30246 # pragma omp taskgroup new-line
30247 structured-block */
30249 static tree
30251 {
30255 }
30258 /* OpenMP 2.5:
30259 # pragma omp threadprivate (variable-list) */
30261 static void
30263 {
30264 tree vars;
30270 }
30272 /* OpenMP 4.0:
30273 # pragma omp cancel cancel-clause[optseq] new-line */
30275 #define OMP_CANCEL_CLAUSE_MASK \
30276 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
30277 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
30278 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
30279 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
30280 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30282 static void
30284 {
30288 }
30290 /* OpenMP 4.0:
30291 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
30293 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
30294 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
30295 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
30296 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
30297 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
30299 static void
30301 {
30302 tree clauses;
30306 {
30311 {
30314 }
30315 }
30317 {
30321 }
30324 OMP_CANCELLATION_POINT_CLAUSE_MASK,
30326 pragma_tok);
30328 }
30330 /* OpenMP 4.0:
30331 #pragma omp distribute distribute-clause[optseq] new-line
30332 for-loop */
30334 #define OMP_DISTRIBUTE_CLAUSE_MASK \
30335 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30336 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30337 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
30338 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30340 static tree
30343 {
30352 {
30360 else
30363 {
30369 {
30372 cclauses);
30373 else
30375 cclauses);
30376 }
30381 cclauses);
30382 else
30384 cclauses);
30396 }
30397 }
30399 {
30402 }
30407 {
30410 }
30421 }
30423 /* OpenMP 4.0:
30424 # pragma omp teams teams-clause[optseq] new-line
30425 structured-block */
30427 #define OMP_TEAMS_CLAUSE_MASK \
30428 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30429 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30430 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
30431 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30432 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
30433 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
30434 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
30436 static tree
30439 {
30448 {
30452 {
30460 cclauses);
30464 cclauses);
30475 }
30476 }
30478 {
30481 }
30486 {
30489 }
30497 }
30499 /* OpenMP 4.0:
30500 # pragma omp target data target-data-clause[optseq] new-line
30501 structured-block */
30503 #define OMP_TARGET_DATA_CLAUSE_MASK \
30504 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
30505 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
30506 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30508 static tree
30510 {
30522 }
30524 /* OpenMP 4.0:
30525 # pragma omp target update target-update-clause[optseq] new-line */
30527 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
30528 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
30529 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
30530 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
30531 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30533 static bool
30536 {
30538 {
30540 "%<#pragma omp target update%> may only be "
30544 }
30546 tree clauses
30551 {
30553 "%<#pragma omp target update must contain at least one "
30556 }
30564 }
30566 /* OpenMP 4.0:
30567 # pragma omp target target-clause[optseq] new-line
30568 structured-block */
30570 #define OMP_TARGET_CLAUSE_MASK \
30571 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
30572 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
30573 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30575 static bool
30578 {
30580 {
30584 }
30587 {
30592 {
30600 {
30602 OMP_TARGET_CLAUSE_MASK,
30603 cclauses);
30605 }
30621 }
30623 {
30626 }
30628 {
30632 }
30634 {
30637 }
30638 }
30652 }
30654 /* OpenMP 4.0:
30655 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
30657 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
30658 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
30659 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
30660 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
30661 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
30662 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
30663 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
30665 static void
30668 {
30670 cp_omp_declare_simd_data data;
30672 {
30677 }
30688 {
30692 {
30705 }
30710 "%<#pragma omp declare simd%> not immediately followed by "
30714 }
30715 }
30717 /* Handles the delayed parsing of the Cilk Plus SIMD-enabled function.
30718 This function is modelled similar to the late parsing of omp declare
30719 simd. */
30721 static tree
30723 {
30729 {
30735 }
30737 {
30741 }
30746 {
30753 NULL);
30767 }
30772 }
30774 /* Finalize #pragma omp declare simd clauses after direct declarator has
30775 been parsed, and put that into "omp declare simd" attribute. */
30777 static tree
30779 {
30785 {
30790 }
30795 {
30813 }
30817 }
30820 /* OpenMP 4.0:
30821 # pragma omp declare target new-line
30822 declarations and definitions
30823 # pragma omp end declare target new-line */
30825 static void
30827 {
30830 }
30832 static void
30834 {
30837 {
30840 }
30842 {
30846 {
30849 }
30852 else
30853 {
30857 }
30858 }
30859 else
30860 {
30864 }
30868 "%<#pragma omp end declare target%> without corresponding "
30870 else
30872 }
30874 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
30875 expression and optional initializer clause of
30876 #pragma omp declare reduction. We store the expression(s) as
30877 either 3, 6 or 7 special statements inside of the artificial function's
30878 body. The first two statements are DECL_EXPRs for the artificial
30879 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
30880 expression that uses those variables.
30881 If there was any INITIALIZER clause, this is followed by further statements,
30882 the fourth and fifth statements are DECL_EXPRs for the artificial
30883 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
30884 constructor variant (first token after open paren is not omp_priv),
30885 then the sixth statement is a statement with the function call expression
30886 that uses the OMP_PRIV and optionally OMP_ORIG variable.
30887 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
30888 to initialize the OMP_PRIV artificial variable and there is seventh
30889 statement, a DECL_EXPR of the OMP_PRIV statement again. */
30891 static bool
30893 {
30905 tree combiner;
30920 {
30923 }
30926 {
30933 {
30936 }
30952 {
30956 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
30960 == CPP_CLOSE_PAREN
30963 {
30967 }
30972 }
30973 else
30974 {
30990 {
30995 }
30997 tree arg;
31010 }
31021 }
31027 }
31029 /* OpenMP 4.0
31030 #pragma omp declare reduction (reduction-id : typename-list : expression) \
31031 initializer-clause[opt] new-line
31033 initializer-clause:
31034 initializer (omp_priv initializer)
31035 initializer (function-name (argument-list)) */
31037 static void
31040 {
31050 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
31057 {
31089 }
31101 /* Types may not be defined in declare reduction type list. */
31104 parser->type_definition_forbidden_message
31110 saved_colon_doesnt_start_class_def_p
31115 {
31119 ;
31140 else
31145 else
31147 }
31149 /* Restore the saved message. */
31152 parser->colon_doesnt_start_class_def_p
31157 {
31158 fail:
31161 }
31167 {
31168 tree fntype
31171 NULL_TREE);
31190 {
31195 }
31197 {
31199 {
31208 }
31215 }
31216 else
31217 {
31220 }
31223 else
31226 {
31229 }
31231 {
31234 else
31239 }
31244 else
31245 {
31254 }
31261 }
31265 done:
31266 /* Free any declarators allocated. */
31268 }
31270 /* OpenMP 4.0
31271 #pragma omp declare simd declare-simd-clauses[optseq] new-line
31272 #pragma omp declare reduction (reduction-id : typename-list : expression) \
31273 initializer-clause[opt] new-line
31274 #pragma omp declare target new-line */
31276 static void
31279 {
31281 {
31286 {
31289 context);
31291 }
31294 {
31297 context);
31299 }
31301 {
31304 }
31306 {
31310 }
31311 }
31315 }
31317 /* Main entry point to OpenMP statement pragmas. */
31319 static void
31321 {
31322 tree stmt;
31327 {
31375 }
31379 }
31380 \f
31381 /* Transactional Memory parsing routines. */
31383 /* Parse a transaction attribute.
31385 txn-attribute:
31386 attribute
31387 [ [ identifier ] ]
31389 ??? Simplify this when C++0x bracket attributes are
31390 implemented properly. */
31392 static tree
31394 {
31409 {
31413 /* For keywords, use the canonical spelling,
31414 not the parsed identifier. */
31418 }
31419 else
31423 error1:
31426 }
31428 /* Parse a __transaction_atomic or __transaction_relaxed statement.
31430 transaction-statement:
31431 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
31432 compound-statement
31433 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
31434 */
31436 static tree
31438 {
31453 else
31454 {
31458 }
31460 /* Parse a noexcept specification. */
31463 /* Keep track if we're in the lexical scope of an outer transaction. */
31475 }
31477 /* Parse a __transaction_atomic or __transaction_relaxed expression.
31479 transaction-expression:
31480 __transaction_atomic txn-noexcept-spec[opt] ( expression )
31481 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
31482 */
31484 static tree
31486 {
31511 /* Set this early. This might mean that we allow transaction_cancel in
31512 an expression that we find out later actually has to be a constexpr.
31513 However, we expect that cxx_constant_value will be able to deal with
31514 this; also, if the noexcept has no constexpr, then what we parse next
31515 really is a transaction's body. */
31518 /* Parse a noexcept specification. */
31524 {
31531 }
31532 else
31533 {
31534 /* The only expression that is available got parsed for the noexcept
31535 already. noexcept is true then. */
31538 }
31547 }
31549 /* Parse a function-transaction-block.
31551 function-transaction-block:
31552 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
31553 function-body
31554 __transaction_atomic txn-attribute[opt] function-try-block
31555 __transaction_relaxed ctor-initializer[opt] function-body
31556 __transaction_relaxed function-try-block
31557 */
31559 static bool
31561 {
31577 else
31578 {
31582 }
31590 else
31591 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
31599 }
31601 /* Parse a __transaction_cancel statement.
31603 cancel-statement:
31604 __transaction_cancel txn-attribute[opt] ;
31605 __transaction_cancel txn-attribute[opt] throw-expression ;
31607 ??? Cancel and throw is not yet implemented. */
31609 static tree
31611 {
31617 RT_TRANSACTION_CANCEL);
31624 /* ??? Parse cancel-and-throw here. */
31629 {
31633 }
31635 {
31639 }
31641 {
31644 {
31650 }
31651 }
31653 {
31657 }
31663 }
31664 \f
31665 /* The parser. */
31669 \f
31670 /* Special handling for the first token or line in the file. The first
31671 thing in the file might be #pragma GCC pch_preprocess, which loads a
31672 PCH file, which is a GC collection point. So we need to handle this
31673 first pragma without benefit of an existing lexer structure.
31675 Always returns one token to the caller in *FIRST_TOKEN. This is
31676 either the true first token of the file, or the first token after
31677 the initial pragma. */
31679 static void
31681 {
31690 {
31697 }
31698 else
31701 /* Skip to the end of the pragma. */
31705 /* Now actually load the PCH file. */
31709 /* Read one more token to return to our caller. We have to do this
31710 after reading the PCH file in, since its pointers have to be
31711 live. */
31713 }
31715 /* Parses the grainsize pragma for the _Cilk_for statement.
31716 Syntax:
31717 #pragma cilk grainsize = <VALUE>. */
31719 static void
31721 {
31723 {
31728 {
31731 }
31733 /* Make sure the next token is _Cilk_for, it is invalid otherwise. */
31736 else
31738 "%<#pragma cilk grainsize%> is not followed by "
31741 }
31743 }
31745 /* Normal parsing of a pragma token. Here we can (and must) use the
31746 regular lexer. */
31748 static bool
31750 {
31762 {
31770 {
31780 }
31785 {
31795 }
31800 {
31806 "%<#pragma omp taskwait%> may only be "
31811 }
31816 {
31822 "%<#pragma omp taskyield%> may only be "
31827 }
31832 {
31838 "%<#pragma omp cancel%> may only be "
31843 }
31848 {
31854 "%<#pragma omp cancellation point%> may only be "
31859 }
31897 "%<#pragma omp section%> may only be used in "
31902 {
31909 {
31912 }
31915 }
31919 {
31923 }
31929 {
31933 }
31935 /* Ignore the pragma if Cilk Plus is not enabled. */
31937 {
31940 }
31941 else
31942 {
31946 }
31953 bad_stmt:
31956 }
31960 }
31962 /* The interface the pragma parsers have to the lexer. */
31964 enum cpp_ttype
31966 {
31979 else
31980 {
31984 }
31987 }
31989 \f
31990 /* External interface. */
31992 /* Parse one entire translation unit. */
31994 void
31996 {
32008 }
32010 /* Parses the Cilk Plus #pragma simd and SIMD-enabled function attribute's
32011 vectorlength clause:
32012 Syntax:
32013 vectorlength ( constant-expression ) */
32015 static tree
32018 {
32020 tree expr;
32021 /* The vectorlength clause in #pragma simd behaves exactly like OpenMP's
32022 safelen clause. Thus, vectorlength is represented as OMP 4.0
32023 safelen. For SIMD-enabled function it is represented by OMP 4.0
32024 simdlen. */
32027 loc);
32028 else
32030 loc);
32038 /* If expr == error_mark_node, then don't emit any errors nor
32039 create a clause. if any of the above functions returns
32040 error mark node then they would have emitted an error message. */
32042 ;
32050 else
32051 {
32052 tree c;
32054 {
32059 }
32060 else
32061 {
32066 }
32067 }
32072 }
32074 /* Handles the Cilk Plus #pragma simd linear clause.
32075 Syntax:
32076 linear ( simd-linear-variable-list )
32078 simd-linear-variable-list:
32079 simd-linear-variable
32080 simd-linear-variable-list , simd-linear-variable
32082 simd-linear-variable:
32083 id-expression
32084 id-expression : simd-linear-step
32086 simd-linear-step:
32087 conditional-expression */
32089 static tree
32091 {
32097 {
32101 }
32106 {
32109 {
32113 }
32120 {
32124 }
32125 else
32126 {
32130 /* If present, parse the linear step. Otherwise, assume the default
32131 value of 1. */
32133 {
32140 {
32141 /* If an error has occurred, then the whole pragma is
32142 considered ill-formed. Thus, no reason to keep
32143 parsing. */
32146 }
32154 else
32156 "step size must be an integer constant "
32158 }
32160 /* Use the OMP_CLAUSE_LINEAR, which has the same semantics. */
32166 }
32171 else
32172 {
32177 }
32178 }
32182 }
32184 /* Returns the name of the next clause. If the clause is not
32185 recognized, then PRAGMA_CILK_CLAUSE_NONE is returned and the next
32186 token is not consumed. Otherwise, the appropriate enum from the
32187 pragma_simd_clause is returned and the token is consumed. */
32189 static pragma_omp_clause
32191 {
32192 pragma_omp_clause clause_type;
32209 else
32214 }
32216 /* Parses all the #pragma simd clauses. Returns a list of clauses found. */
32218 static tree
32220 {
32225 {
32226 pragma_omp_clause c_kind;
32233 /* Use the OpenMP 4.0 equivalent function. */
32236 /* Use the OpenMP 4.0 equivalent function. */
32238 clauses);
32240 /* Use the OMP 4.0 equivalent function. */
32242 clauses);
32244 /* Use the OMP 4.0 equivalent function. */
32246 else
32247 {
32251 }
32252 }
32258 else
32260 }
32262 /* Main entry-point for parsing Cilk Plus <#pragma simd> for loops. */
32264 static void
32266 {
32273 {
32277 }
32286 }
32288 /* Main entry-point for parsing Cilk Plus _Cilk_for
32289 loops. The return value is error_mark_node
32290 when errors happen and CILK_FOR tree on success. */
32292 static tree
32294 {
32309 else
32315 }
32317 /* Create an identifier for a generic parameter type (a synthesized
32318 template parameter implied by `auto' or a concept identifier). */
32321 static tree
32323 {
32327 }
32329 /* Predicate that behaves as is_auto_or_concept but matches the parent
32330 node of the generic type rather than the generic type itself. This
32331 allows for type transformation in add_implicit_template_parms. */
32335 {
32337 }
32339 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
32340 (creating a new template parameter list if necessary). Returns the newly
32341 created template type parm. */
32343 tree
32345 {
32348 /* We are either continuing a function template that already contains implicit
32349 template parameters, creating a new fully-implicit function template, or
32350 extending an existing explicit function template with implicit template
32351 parameters. */
32359 {
32363 }
32364 else
32365 {
32366 /* Roll back to the existing template parameter scope (in the case of
32367 extending an explicit function template) or introduce a new template
32368 parameter scope ahead of the function parameter scope (or class scope
32369 in the case of out-of-line member definitions). The function scope is
32370 added back after template parameter synthesis below. */
32375 {
32378 }
32380 {
32381 /* If not defining a class, then any class scope is a scope level in
32382 an out-of-line member definition. In this case simply wind back
32383 beyond the first such scope to inject the template parameter list.
32384 Otherwise wind back to the class being defined. The latter can
32385 occur in class member friend declarations such as:
32387 class A {
32388 void foo (auto);
32389 };
32390 class B {
32391 friend void A::foo (auto);
32392 };
32394 The template parameter list synthesized for the friend declaration
32395 must be injected in the scope of 'B'. This can also occur in
32396 erroneous cases such as:
32398 struct A {
32399 struct B {
32400 void foo (auto);
32401 };
32402 void B::foo (auto) {}
32403 };
32405 Here the attempted definition of 'B::foo' within 'A' is ill-formed
32406 but, nevertheless, the template parameter list synthesized for the
32407 declarator should be injected into the scope of 'A' as if the
32408 ill-formed template was specified explicitly. */
32411 {
32414 }
32415 }
32421 {
32422 /* Introduce a new template parameter list for implicit template
32423 parameters. */
32427 parser->implicit_template_scope
32434 }
32435 else
32436 {
32437 /* Synthesize implicit template parameters at the end of the explicit
32438 template parameter list. */
32445 parser->implicit_template_parms
32447 }
32448 }
32450 /* Synthesize a new template parameter and track the current template
32451 parameter chain with implicit_template_parms. */
32455 synth_id);
32456 tree new_parm
32458 input_location,
32465 parser->implicit_template_parms
32467 else
32472 /* If creating a fully implicit function template, start the new implicit
32473 template parameter list with this synthesized type, otherwise grow the
32474 current template parameter list. */
32477 {
32484 }
32485 else
32486 {
32491 }
32496 }
32498 /* Finish the declaration of a fully implicit function template. Such a
32499 template has no explicit template parameter list so has not been through the
32500 normal template head and tail processing. synthesize_implicit_template_parm
32501 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
32502 provided if the declaration is a class member such that its template
32503 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
32504 form is returned. Otherwise NULL_TREE is returned. */
32506 tree
32508 {
32513 {
32517 }
32527 }