| blob | a84bc59cef2273de8d045468858f3382e84fdac5 |
1 /* C++ Parser.
2 Copyright (C) 2000-2013 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/>. */
42 \f
43 /* The lexer. */
45 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
46 and c-lex.c) and the C++ parser. */
49 {
51 };
53 /* The various kinds of non integral constant we encounter. */
55 NIC_NONE,
56 /* floating-point literal */
57 NIC_FLOAT,
58 /* %<this%> */
59 NIC_THIS,
60 /* %<__FUNCTION__%> */
61 NIC_FUNC_NAME,
62 /* %<__PRETTY_FUNCTION__%> */
63 NIC_PRETTY_FUNC,
64 /* %<__func__%> */
65 NIC_C99_FUNC,
66 /* "%<va_arg%> */
67 NIC_VA_ARG,
68 /* a cast */
69 NIC_CAST,
70 /* %<typeid%> operator */
71 NIC_TYPEID,
72 /* non-constant compound literals */
73 NIC_NCC,
74 /* a function call */
75 NIC_FUNC_CALL,
76 /* an increment */
77 NIC_INC,
78 /* an decrement */
79 NIC_DEC,
80 /* an array reference */
81 NIC_ARRAY_REF,
82 /* %<->%> */
83 NIC_ARROW,
84 /* %<.%> */
85 NIC_POINT,
86 /* the address of a label */
87 NIC_ADDR_LABEL,
88 /* %<*%> */
89 NIC_STAR,
90 /* %<&%> */
91 NIC_ADDR,
92 /* %<++%> */
93 NIC_PREINCREMENT,
94 /* %<--%> */
95 NIC_PREDECREMENT,
96 /* %<new%> */
97 NIC_NEW,
98 /* %<delete%> */
99 NIC_DEL,
100 /* calls to overloaded operators */
101 NIC_OVERLOADED,
102 /* an assignment */
103 NIC_ASSIGNMENT,
104 /* a comma operator */
105 NIC_COMMA,
106 /* a call to a constructor */
107 NIC_CONSTRUCTOR,
108 /* a transaction expression */
109 NIC_TRANSACTION
112 /* The various kinds of errors about name-lookup failing. */
114 /* NULL */
115 NLE_NULL,
116 /* is not a type */
117 NLE_TYPE,
118 /* is not a class or namespace */
119 NLE_CXX98,
120 /* is not a class, namespace, or enumeration */
121 NLE_NOT_CXX98
124 /* The various kinds of required token */
126 RT_NONE,
148 /* The type is CPP_KEYWORD */
177 RT_TRANSACTION_CANCEL /* __transaction_cancel */
180 /* Prototypes. */
186 static void cp_lexer_destroy
188 static int cp_lexer_saving_tokens
192 static void cp_lexer_get_preprocessor_token
200 static bool cp_lexer_next_token_is_not
202 static bool cp_lexer_next_token_is_keyword
206 static void cp_lexer_purge_token
208 static void cp_lexer_purge_tokens_after
210 static void cp_lexer_save_tokens
212 static void cp_lexer_commit_tokens
214 static void cp_lexer_rollback_tokens
216 static void cp_lexer_print_token
220 static void cp_lexer_start_debugging
222 static void cp_lexer_stop_debugging
228 static void cp_parser_initial_pragma
231 static tree cp_literal_operator_id
234 /* Manifest constants. */
235 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
236 #define CP_SAVED_TOKEN_STACK 5
238 /* Variables. */
240 /* The stream to which debugging output should be written. */
243 /* Nonzero if we are parsing an unevaluated operand: an operand to
244 sizeof, typeof, or alignof. */
247 /* Dump up to NUM tokens in BUFFER to FILE starting with token
248 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
249 first token in BUFFER. If NUM is 0, dump all the tokens. If
250 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
251 highlighted by surrounding it in [[ ]]. */
253 static void
257 {
274 {
277 }
282 {
289 nprinted++;
299 {
309 }
310 }
313 {
316 }
319 }
322 /* Dump all tokens in BUFFER to stderr. */
324 void
326 {
328 }
331 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
332 description for T. */
334 static void
336 {
338 {
341 }
342 }
345 /* Dump parser context C to FILE. */
347 static void
349 {
354 }
357 /* Print the stack of parsing contexts to FILE starting with FIRST. */
359 static void
361 {
367 {
370 }
371 }
374 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
376 static void
378 {
381 }
384 /* Print an unparsed function entry UF to FILE. */
386 static void
388 {
391 tree fn;
396 i++)
397 {
403 }
408 {
411 }
417 {
420 }
422 }
425 /* Print the stack of unparsed member functions S to FILE. */
427 static void
430 {
436 {
439 }
440 }
443 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
444 the given PARSER. If FILE is NULL, the output is printed on stderr. */
446 static void
448 {
460 next_token);
461 }
464 /* Dump debugging information for the given PARSER. If FILE is NULL,
465 the output is printed on stderr. */
467 void
469 {
472 expanded_location eloc;
546 }
549 /* Allocate memory for a new lexer object and return it. */
553 {
558 /* Allocate the memory. */
561 /* Initially we are not debugging. */
566 /* Create the buffer. */
570 }
573 /* Create a new main C++ lexer, the lexer that gets tokens from the
574 preprocessor. */
578 {
580 cp_token token;
582 /* It's possible that parsing the first pragma will load a PCH file,
583 which is a GC collection point. So we have to do that before
584 allocating any memory. */
589 /* Put the first token in the buffer. */
592 /* Get the remaining tokens from the preprocessor. */
594 {
597 }
606 /* Subsequent preprocessor diagnostics should use compiler
607 diagnostic functions to get the compiler source location. */
612 }
614 /* Create a new lexer whose token stream is primed with the tokens in
615 CACHE. When these tokens are exhausted, no new tokens will be read. */
619 {
624 /* We do not own the buffer. */
631 /* Initially we are not debugging. */
636 }
638 /* Frees all resources associated with LEXER. */
640 static void
642 {
646 }
648 /* Returns nonzero if debugging information should be output. */
652 {
654 }
659 {
663 }
667 {
669 }
673 {
675 }
679 {
682 else
684 }
688 {
692 }
694 /* nonzero if we are presently saving tokens. */
698 {
700 }
702 /* Store the next token from the preprocessor in *TOKEN. Return true
703 if we reach EOF. If LEXER is NULL, assume we are handling an
704 initial #pragma pch_preprocess, and thus want the lexer to return
705 processed strings. */
707 static void
709 {
712 /* Get a new token from the preprocessor. */
713 token->type
720 /* On some systems, some header files are surrounded by an
721 implicit extern "C" block. Set a flag in the token if it
722 comes from such a header. */
727 /* Check to see if this token is a keyword. */
729 {
731 {
732 /* Mark this token as a keyword. */
734 /* Record which keyword. */
736 }
737 else
738 {
742 {
743 /* Warn about the C++0x keyword (but still treat it as
744 an identifier). */
749 /* Clear out the C_RID_CODE so we don't warn about this
750 particular identifier-turned-keyword again. */
752 }
756 }
757 }
759 {
760 /* This only happens in Objective-C++; it must be a keyword. */
763 {
764 /* Replace 'class' with '@class', 'private' with '@private',
765 etc. This prevents confusion with the C++ keyword
766 'class', and makes the tokens consistent with other
767 Objective-C 'AT' keywords. For example '@class' is
768 reported as RID_AT_CLASS which is consistent with
769 '@synchronized', which is reported as
770 RID_AT_SYNCHRONIZED.
771 */
780 }
781 }
783 {
784 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
788 }
789 }
791 /* Update the globals input_location and the input file stack from TOKEN. */
794 {
796 {
798 }
799 }
801 /* Return a pointer to the next token in the token stream, but do not
802 consume it. */
806 {
808 {
812 }
814 }
816 /* Return true if the next token has the indicated TYPE. */
820 {
822 }
824 /* Return true if the next token does not have the indicated TYPE. */
828 {
830 }
832 /* Return true if the next token is the indicated KEYWORD. */
836 {
838 }
840 /* Return true if the next token is not the indicated KEYWORD. */
844 {
846 }
848 /* Return true if the next token is a keyword for a decl-specifier. */
850 static bool
852 {
857 {
858 /* auto specifier: storage-class-specifier in C++,
859 simple-type-specifier in C++0x. */
861 /* Storage classes. */
867 /* Elaborated type specifiers. */
873 /* Simple type specifiers. */
888 /* GNU extensions. */
891 /* C++0x extensions. */
898 }
899 }
901 /* Returns TRUE iff the token T begins a decltype type. */
903 static bool
905 {
908 }
910 /* Returns TRUE iff the next token begins a decltype type. */
912 static bool
914 {
917 }
919 /* Return a pointer to the Nth token in the token stream. If N is 1,
920 then this is precisely equivalent to cp_lexer_peek_token (except
921 that it is not inline). One would like to disallow that case, but
922 there is one case (cp_parser_nth_token_starts_template_id) where
923 the caller passes a variable for N and it might be 1. */
927 {
930 /* N is 1-based, not zero-based. */
941 {
944 {
947 }
951 }
954 {
957 }
960 }
962 /* Return the next token, and advance the lexer's next_token pointer
963 to point to the next non-purged token. */
967 {
973 do
974 {
977 {
980 }
982 }
987 /* Provide debugging output. */
989 {
993 }
996 }
998 /* Permanently remove the next token from the token stream, and
999 advance the next_token pointer to refer to the next non-purged
1000 token. */
1002 static void
1004 {
1013 do
1014 {
1015 tok++;
1017 {
1020 }
1021 }
1024 }
1026 /* Permanently remove all tokens after TOK, up to, but not
1027 including, the token that will be returned next by
1028 cp_lexer_peek_token. */
1030 static void
1032 {
1041 {
1046 }
1047 }
1049 /* Begin saving tokens. All tokens consumed after this point will be
1050 preserved. */
1052 static void
1054 {
1055 /* Provide debugging output. */
1060 }
1062 /* Commit to the portion of the token stream most recently saved. */
1064 static void
1066 {
1067 /* Provide debugging output. */
1072 }
1074 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1075 to the token stream. Stop saving tokens. */
1077 static void
1079 {
1080 /* Provide debugging output. */
1085 }
1087 /* Print a representation of the TOKEN on the STREAM. */
1089 static void
1091 {
1092 /* We don't use cpp_type2name here because the parser defines
1093 a few tokens of its own. */
1095 /* cpplib-defined token types */
1096 #define OP(e, s) #e,
1097 #define TK(e, s) #e,
1098 TTYPE_TABLE
1099 #undef OP
1100 #undef TK
1101 /* C++ parser token types - see "Manifest constants", above. */
1105 };
1107 /* For some tokens, print the associated data. */
1109 {
1111 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1112 For example, `struct' is mapped to an INTEGER_CST. */
1115 /* else fall through */
1133 /* If we have a name for the token, print it out. Otherwise, we
1134 simply give the numeric code. */
1137 else
1140 }
1141 }
1143 /* Start emitting debugging information. */
1145 static void
1147 {
1150 }
1152 /* Stop emitting debugging information. */
1154 static void
1156 {
1159 }
1161 /* Create a new cp_token_cache, representing a range of tokens. */
1165 {
1170 }
1172 \f
1173 /* Decl-specifiers. */
1175 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1177 static void
1179 {
1181 }
1183 /* Declarators. */
1185 /* Nothing other than the parser should be creating declarators;
1186 declarators are a semi-syntactic representation of C++ entities.
1187 Other parts of the front end that need to create entities (like
1188 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1203 /* An erroneous declarator. */
1206 /* The obstack on which declarators and related data structures are
1207 allocated. */
1210 /* Alloc BYTES from the declarator memory pool. */
1214 {
1216 }
1218 /* Allocate a declarator of the indicated KIND. Clear fields that are
1219 common to all declarators. */
1223 {
1235 }
1237 /* Make a declarator for a generalized identifier. If
1238 QUALIFYING_SCOPE is non-NULL, the identifier is
1239 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1240 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1241 is, if any. */
1245 special_function_kind sfk)
1246 {
1249 /* It is valid to write:
1251 class C { void f(); };
1252 typedef C D;
1253 void D::f();
1255 The standard is not clear about whether `typedef const C D' is
1256 legal; as of 2002-09-15 the committee is considering that
1257 question. EDG 3.0 allows that syntax. Therefore, we do as
1258 well. */
1272 }
1274 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1275 of modifiers such as const or volatile to apply to the pointer
1276 type, represented as identifiers. ATTRIBUTES represent the attributes that
1277 appertain to the pointer or reference. */
1279 cp_declarator *
1281 tree attributes)
1282 {
1290 {
1294 }
1295 else
1301 }
1303 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1304 represent the attributes that appertain to the pointer or
1305 reference. */
1307 cp_declarator *
1310 {
1318 {
1322 }
1323 else
1329 }
1331 /* Like make_pointer_declarator -- but for a pointer to a non-static
1332 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1333 appertain to the pointer or reference. */
1335 cp_declarator *
1338 tree attributes)
1339 {
1348 {
1351 }
1352 else
1358 }
1360 /* Make a declarator for the function given by TARGET, with the
1361 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1362 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1363 indicates what exceptions can be thrown. */
1365 cp_declarator *
1367 tree parms,
1368 cp_cv_quals cv_qualifiers,
1369 cp_virt_specifiers virt_specifiers,
1370 cp_ref_qualifier ref_qualifier,
1371 tree exception_specification,
1372 tree late_return_type)
1373 {
1385 {
1389 }
1390 else
1394 }
1396 /* Make a declarator for an array of BOUNDS elements, each of which is
1397 defined by ELEMENT. */
1399 cp_declarator *
1401 {
1408 {
1412 }
1413 else
1417 }
1419 /* Determine whether the declarator we've seen so far can be a
1420 parameter pack, when followed by an ellipsis. */
1421 static bool
1423 {
1424 /* Search for a declarator name, or any other declarator that goes
1425 after the point where the ellipsis could appear in a parameter
1426 pack. If we find any of these, then this declarator can not be
1427 made into a parameter pack. */
1430 {
1432 {
1444 }
1445 }
1448 }
1452 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1453 DECLARATOR and DEFAULT_ARGUMENT. */
1455 cp_parameter_declarator *
1458 tree default_argument)
1459 {
1467 else
1474 }
1476 /* Returns true iff DECLARATOR is a declaration for a function. */
1478 static bool
1480 {
1482 {
1490 }
1492 }
1494 /* The parser. */
1496 /* Overview
1497 --------
1499 A cp_parser parses the token stream as specified by the C++
1500 grammar. Its job is purely parsing, not semantic analysis. For
1501 example, the parser breaks the token stream into declarators,
1502 expressions, statements, and other similar syntactic constructs.
1503 It does not check that the types of the expressions on either side
1504 of an assignment-statement are compatible, or that a function is
1505 not declared with a parameter of type `void'.
1507 The parser invokes routines elsewhere in the compiler to perform
1508 semantic analysis and to build up the abstract syntax tree for the
1509 code processed.
1511 The parser (and the template instantiation code, which is, in a
1512 way, a close relative of parsing) are the only parts of the
1513 compiler that should be calling push_scope and pop_scope, or
1514 related functions. The parser (and template instantiation code)
1515 keeps track of what scope is presently active; everything else
1516 should simply honor that. (The code that generates static
1517 initializers may also need to set the scope, in order to check
1518 access control correctly when emitting the initializers.)
1520 Methodology
1521 -----------
1523 The parser is of the standard recursive-descent variety. Upcoming
1524 tokens in the token stream are examined in order to determine which
1525 production to use when parsing a non-terminal. Some C++ constructs
1526 require arbitrary look ahead to disambiguate. For example, it is
1527 impossible, in the general case, to tell whether a statement is an
1528 expression or declaration without scanning the entire statement.
1529 Therefore, the parser is capable of "parsing tentatively." When the
1530 parser is not sure what construct comes next, it enters this mode.
1531 Then, while we attempt to parse the construct, the parser queues up
1532 error messages, rather than issuing them immediately, and saves the
1533 tokens it consumes. If the construct is parsed successfully, the
1534 parser "commits", i.e., it issues any queued error messages and
1535 the tokens that were being preserved are permanently discarded.
1536 If, however, the construct is not parsed successfully, the parser
1537 rolls back its state completely so that it can resume parsing using
1538 a different alternative.
1540 Future Improvements
1541 -------------------
1543 The performance of the parser could probably be improved substantially.
1544 We could often eliminate the need to parse tentatively by looking ahead
1545 a little bit. In some places, this approach might not entirely eliminate
1546 the need to parse tentatively, but it might still speed up the average
1547 case. */
1549 /* Flags that are passed to some parsing functions. These values can
1550 be bitwise-ored together. */
1552 enum
1553 {
1554 /* No flags. */
1556 /* The construct is optional. If it is not present, then no error
1557 should be issued. */
1559 /* When parsing a type-specifier, treat user-defined type-names
1560 as non-type identifiers. */
1562 /* When parsing a type-specifier, do not try to parse a class-specifier
1563 or enum-specifier. */
1565 /* When parsing a decl-specifier-seq, only allow type-specifier or
1566 constexpr. */
1568 };
1570 /* This type is used for parameters and variables which hold
1571 combinations of the above flags. */
1574 /* The different kinds of declarators we want to parse. */
1577 {
1578 /* We want an abstract declarator. */
1579 CP_PARSER_DECLARATOR_ABSTRACT,
1580 /* We want a named declarator. */
1581 CP_PARSER_DECLARATOR_NAMED,
1582 /* We don't mind, but the name must be an unqualified-id. */
1583 CP_PARSER_DECLARATOR_EITHER
1586 /* The precedence values used to parse binary expressions. The minimum value
1587 of PREC must be 1, because zero is reserved to quickly discriminate
1588 binary operators from other tokens. */
1590 enum cp_parser_prec
1591 {
1592 PREC_NOT_OPERATOR,
1593 PREC_LOGICAL_OR_EXPRESSION,
1594 PREC_LOGICAL_AND_EXPRESSION,
1595 PREC_INCLUSIVE_OR_EXPRESSION,
1596 PREC_EXCLUSIVE_OR_EXPRESSION,
1597 PREC_AND_EXPRESSION,
1598 PREC_EQUALITY_EXPRESSION,
1599 PREC_RELATIONAL_EXPRESSION,
1600 PREC_SHIFT_EXPRESSION,
1601 PREC_ADDITIVE_EXPRESSION,
1602 PREC_MULTIPLICATIVE_EXPRESSION,
1603 PREC_PM_EXPRESSION,
1604 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1605 };
1607 /* A mapping from a token type to a corresponding tree node type, with a
1608 precedence value. */
1611 {
1612 /* The token type. */
1614 /* The corresponding tree code. */
1616 /* The precedence of this operator. */
1621 {
1622 /* Left hand side of the binary operation we are currently
1623 parsing. */
1624 tree lhs;
1625 /* Original tree code for left hand side, if it was a binary
1626 expression itself (used for -Wparentheses). */
1628 /* Tree code for the binary operation we are parsing. */
1630 /* Precedence of the binary operation we are parsing. */
1632 /* Location of the binary operation we are parsing. */
1633 location_t loc;
1636 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1637 entries because precedence levels on the stack are monotonically
1638 increasing. */
1642 /* Prototypes. */
1644 /* Constructors and destructors. */
1649 /* Class variables. */
1653 /* The operator-precedence table used by cp_parser_binary_expression.
1654 Transformed into an associative array (binops_by_token) by
1655 cp_parser_new. */
1688 };
1690 /* The same as binops, but initialized by cp_parser_new so that
1691 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1692 for speed. */
1695 /* Constructors and destructors. */
1697 /* Construct a new context. The context below this one on the stack
1698 is given by NEXT. */
1702 {
1705 /* Allocate the storage. */
1707 {
1708 /* Pull the first entry from the free list. */
1712 }
1713 else
1716 /* No errors have occurred yet in this context. */
1718 /* If this is not the bottommost context, copy information that we
1719 need from the previous context. */
1721 {
1722 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1723 expression, then we are parsing one in this context, too. */
1725 /* Thread the stack. */
1727 }
1730 }
1732 /* Managing the unparsed function queues. */
1734 #define unparsed_funs_with_default_args \
1735 parser->unparsed_queues->last ().funs_with_default_args
1736 #define unparsed_funs_with_definitions \
1737 parser->unparsed_queues->last ().funs_with_definitions
1738 #define unparsed_nsdmis \
1739 parser->unparsed_queues->last ().nsdmis
1741 static void
1743 {
1746 }
1748 static void
1750 {
1753 }
1755 /* Prototypes. */
1757 /* Constructors and destructors. */
1762 /* Routines to parse various constructs.
1764 Those that return `tree' will return the error_mark_node (rather
1765 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1766 Sometimes, they will return an ordinary node if error-recovery was
1767 attempted, even though a parse error occurred. So, to check
1768 whether or not a parse error occurred, you should always use
1769 cp_parser_error_occurred. If the construct is optional (indicated
1770 either by an `_opt' in the name of the function that does the
1771 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1772 the construct is not present. */
1774 /* Lexical conventions [gram.lex] */
1776 static tree cp_parser_identifier
1778 static tree cp_parser_string_literal
1780 static tree cp_parser_userdef_char_literal
1782 static tree cp_parser_userdef_string_literal
1784 static tree cp_parser_userdef_numeric_literal
1787 /* Basic concepts [gram.basic] */
1789 static bool cp_parser_translation_unit
1792 /* Expressions [gram.expr] */
1794 static tree cp_parser_primary_expression
1796 static tree cp_parser_id_expression
1798 static tree cp_parser_unqualified_id
1800 static tree cp_parser_nested_name_specifier_opt
1802 static tree cp_parser_nested_name_specifier
1804 static tree cp_parser_qualifying_entity
1806 static tree cp_parser_postfix_expression
1808 static tree cp_parser_postfix_open_square_expression
1810 static tree cp_parser_postfix_dot_deref_expression
1814 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1816 static void cp_parser_pseudo_destructor_name
1818 static tree cp_parser_unary_expression
1820 static enum tree_code cp_parser_unary_operator
1822 static tree cp_parser_new_expression
1826 static tree cp_parser_new_type_id
1834 static tree cp_parser_delete_expression
1836 static tree cp_parser_cast_expression
1838 static tree cp_parser_binary_expression
1840 static tree cp_parser_question_colon_clause
1842 static tree cp_parser_assignment_expression
1844 static enum tree_code cp_parser_assignment_operator_opt
1846 static tree cp_parser_expression
1848 static tree cp_parser_expression
1850 static tree cp_parser_constant_expression
1852 static tree cp_parser_builtin_offsetof
1854 static tree cp_parser_lambda_expression
1856 static void cp_parser_lambda_introducer
1858 static bool cp_parser_lambda_declarator_opt
1860 static void cp_parser_lambda_body
1863 /* Statements [gram.stmt.stmt] */
1865 static void cp_parser_statement
1867 static void cp_parser_label_for_labeled_statement
1869 static tree cp_parser_expression_statement
1871 static tree cp_parser_compound_statement
1873 static void cp_parser_statement_seq_opt
1875 static tree cp_parser_selection_statement
1877 static tree cp_parser_condition
1879 static tree cp_parser_iteration_statement
1881 static bool cp_parser_for_init_statement
1883 static tree cp_parser_for
1885 static tree cp_parser_c_for
1887 static tree cp_parser_range_for
1889 static void do_range_for_auto_deduction
1891 static tree cp_parser_perform_range_for_lookup
1893 static tree cp_parser_range_for_member_function
1895 static tree cp_parser_jump_statement
1897 static void cp_parser_declaration_statement
1900 static tree cp_parser_implicitly_scoped_statement
1902 static void cp_parser_already_scoped_statement
1905 /* Declarations [gram.dcl.dcl] */
1907 static void cp_parser_declaration_seq_opt
1909 static void cp_parser_declaration
1911 static void cp_parser_block_declaration
1913 static void cp_parser_simple_declaration
1915 static void cp_parser_decl_specifier_seq
1917 static tree cp_parser_storage_class_specifier_opt
1919 static tree cp_parser_function_specifier_opt
1921 static tree cp_parser_type_specifier
1924 static tree cp_parser_simple_type_specifier
1926 static tree cp_parser_type_name
1928 static tree cp_parser_nonclass_name
1930 static tree cp_parser_elaborated_type_specifier
1932 static tree cp_parser_enum_specifier
1934 static void cp_parser_enumerator_list
1936 static void cp_parser_enumerator_definition
1938 static tree cp_parser_namespace_name
1940 static void cp_parser_namespace_definition
1942 static void cp_parser_namespace_body
1944 static tree cp_parser_qualified_namespace_specifier
1946 static void cp_parser_namespace_alias_definition
1948 static bool cp_parser_using_declaration
1950 static void cp_parser_using_directive
1952 static tree cp_parser_alias_declaration
1954 static void cp_parser_asm_definition
1956 static void cp_parser_linkage_specification
1958 static void cp_parser_static_assert
1960 static tree cp_parser_decltype
1963 /* Declarators [gram.dcl.decl] */
1965 static tree cp_parser_init_declarator
1966 (cp_parser *, cp_decl_specifier_seq *, vec<deferred_access_check, va_gc> *, bool, bool, int, bool *, tree *);
1971 static enum tree_code cp_parser_ptr_operator
1973 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1975 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
1977 static cp_ref_qualifier cp_parser_ref_qualifier_seq_opt
1979 static tree cp_parser_late_return_type_opt
1981 static tree cp_parser_declarator_id
1983 static tree cp_parser_type_id
1985 static tree cp_parser_template_type_arg
1988 static tree cp_parser_type_id_1
1990 static void cp_parser_type_specifier_seq
1992 static tree cp_parser_parameter_declaration_clause
1994 static tree cp_parser_parameter_declaration_list
1998 static tree cp_parser_default_argument
2000 static void cp_parser_function_body
2002 static tree cp_parser_initializer
2004 static tree cp_parser_initializer_clause
2006 static tree cp_parser_braced_list
2011 static bool cp_parser_ctor_initializer_opt_and_function_body
2014 /* Classes [gram.class] */
2016 static tree cp_parser_class_name
2018 static tree cp_parser_class_specifier
2020 static tree cp_parser_class_head
2022 static enum tag_types cp_parser_class_key
2024 static void cp_parser_member_specification_opt
2026 static void cp_parser_member_declaration
2028 static tree cp_parser_pure_specifier
2030 static tree cp_parser_constant_initializer
2033 /* Derived classes [gram.class.derived] */
2035 static tree cp_parser_base_clause
2037 static tree cp_parser_base_specifier
2040 /* Special member functions [gram.special] */
2042 static tree cp_parser_conversion_function_id
2044 static tree cp_parser_conversion_type_id
2048 static bool cp_parser_ctor_initializer_opt
2050 static void cp_parser_mem_initializer_list
2052 static tree cp_parser_mem_initializer
2054 static tree cp_parser_mem_initializer_id
2057 /* Overloading [gram.over] */
2059 static tree cp_parser_operator_function_id
2061 static tree cp_parser_operator
2064 /* Templates [gram.temp] */
2066 static void cp_parser_template_declaration
2068 static tree cp_parser_template_parameter_list
2070 static tree cp_parser_template_parameter
2072 static tree cp_parser_type_parameter
2074 static tree cp_parser_template_id
2076 static tree cp_parser_template_name
2078 static tree cp_parser_template_argument_list
2080 static tree cp_parser_template_argument
2082 static void cp_parser_explicit_instantiation
2084 static void cp_parser_explicit_specialization
2087 /* Exception handling [gram.exception] */
2089 static tree cp_parser_try_block
2091 static bool cp_parser_function_try_block
2093 static void cp_parser_handler_seq
2095 static void cp_parser_handler
2097 static tree cp_parser_exception_declaration
2099 static tree cp_parser_throw_expression
2101 static tree cp_parser_exception_specification_opt
2103 static tree cp_parser_type_id_list
2106 /* GNU Extensions */
2108 static tree cp_parser_asm_specification_opt
2110 static tree cp_parser_asm_operand_list
2112 static tree cp_parser_asm_clobber_list
2114 static tree cp_parser_asm_label_list
2116 static bool cp_next_tokens_can_be_attribute_p
2118 static bool cp_next_tokens_can_be_gnu_attribute_p
2120 static bool cp_next_tokens_can_be_std_attribute_p
2122 static bool cp_nth_tokens_can_be_std_attribute_p
2124 static bool cp_nth_tokens_can_be_gnu_attribute_p
2126 static bool cp_nth_tokens_can_be_attribute_p
2128 static tree cp_parser_attributes_opt
2130 static tree cp_parser_gnu_attributes_opt
2132 static tree cp_parser_gnu_attribute_list
2134 static tree cp_parser_std_attribute
2136 static tree cp_parser_std_attribute_spec
2138 static tree cp_parser_std_attribute_spec_seq
2140 static bool cp_parser_extension_opt
2142 static void cp_parser_label_declaration
2145 /* Transactional Memory Extensions */
2147 static tree cp_parser_transaction
2149 static tree cp_parser_transaction_expression
2151 static bool cp_parser_function_transaction
2153 static tree cp_parser_transaction_cancel
2157 static bool cp_parser_pragma
2160 /* Objective-C++ Productions */
2162 static tree cp_parser_objc_message_receiver
2164 static tree cp_parser_objc_message_args
2166 static tree cp_parser_objc_message_expression
2168 static tree cp_parser_objc_encode_expression
2170 static tree cp_parser_objc_defs_expression
2172 static tree cp_parser_objc_protocol_expression
2174 static tree cp_parser_objc_selector_expression
2176 static tree cp_parser_objc_expression
2178 static bool cp_parser_objc_selector_p
2180 static tree cp_parser_objc_selector
2182 static tree cp_parser_objc_protocol_refs_opt
2184 static void cp_parser_objc_declaration
2186 static tree cp_parser_objc_statement
2188 static bool cp_parser_objc_valid_prefix_attributes
2190 static void cp_parser_objc_at_property_declaration
2192 static void cp_parser_objc_at_synthesize_declaration
2194 static void cp_parser_objc_at_dynamic_declaration
2196 static tree cp_parser_objc_struct_declaration
2199 /* Utility Routines */
2201 static tree cp_parser_lookup_name
2203 static tree cp_parser_lookup_name_simple
2205 static tree cp_parser_maybe_treat_template_as_class
2207 static bool cp_parser_check_declarator_template_parameters
2209 static bool cp_parser_check_template_parameters
2211 static tree cp_parser_simple_cast_expression
2213 static tree cp_parser_global_scope_opt
2215 static bool cp_parser_constructor_declarator_p
2217 static tree cp_parser_function_definition_from_specifiers_and_declarator
2219 static tree cp_parser_function_definition_after_declarator
2221 static void cp_parser_template_declaration_after_export
2223 static void cp_parser_perform_template_parameter_access_checks
2225 static tree cp_parser_single_declaration
2227 static tree cp_parser_functional_cast
2229 static tree cp_parser_save_member_function_body
2231 static tree cp_parser_save_nsdmi
2233 static tree cp_parser_enclosed_template_argument_list
2235 static void cp_parser_save_default_args
2237 static void cp_parser_late_parsing_for_member
2239 static tree cp_parser_late_parse_one_default_arg
2241 static void cp_parser_late_parsing_nsdmi
2243 static void cp_parser_late_parsing_default_args
2245 static tree cp_parser_sizeof_operand
2247 static tree cp_parser_trait_expr
2249 static bool cp_parser_declares_only_class_p
2251 static void cp_parser_set_storage_class
2253 static void cp_parser_set_decl_spec_type
2255 static void set_and_check_decl_spec_loc
2258 static bool cp_parser_friend_p
2260 static void cp_parser_required_error
2266 static bool cp_parser_token_starts_function_definition_p
2268 static bool cp_parser_next_token_starts_class_definition_p
2270 static bool cp_parser_next_token_ends_template_argument_p
2272 static bool cp_parser_nth_token_starts_template_argument_list_p
2274 static enum tag_types cp_parser_token_is_class_key
2276 static void cp_parser_check_class_key
2278 static void cp_parser_check_access_in_redeclaration
2280 static bool cp_parser_optional_template_keyword
2282 static void cp_parser_pre_parsed_nested_name_specifier
2284 static bool cp_parser_cache_group
2286 static tree cp_parser_cache_defarg
2288 static void cp_parser_parse_tentatively
2290 static void cp_parser_commit_to_tentative_parse
2292 static void cp_parser_abort_tentative_parse
2294 static bool cp_parser_parse_definitely
2298 static bool cp_parser_uncommitted_to_tentative_parse_p
2300 static void cp_parser_error
2302 static void cp_parser_name_lookup_error
2304 static bool cp_parser_simulate_error
2306 static bool cp_parser_check_type_definition
2308 static void cp_parser_check_for_definition_in_return_type
2310 static void cp_parser_check_for_invalid_template_id
2312 static bool cp_parser_non_integral_constant_expression
2314 static void cp_parser_diagnose_invalid_type_name
2316 static bool cp_parser_parse_and_diagnose_invalid_type_name
2318 static int cp_parser_skip_to_closing_parenthesis
2320 static void cp_parser_skip_to_end_of_statement
2322 static void cp_parser_consume_semicolon_at_end_of_statement
2324 static void cp_parser_skip_to_end_of_block_or_statement
2326 static bool cp_parser_skip_to_closing_brace
2328 static void cp_parser_skip_to_end_of_template_parameter_list
2330 static void cp_parser_skip_to_pragma_eol
2332 static bool cp_parser_error_occurred
2334 static bool cp_parser_allow_gnu_extensions_p
2336 static bool cp_parser_is_pure_string_literal
2338 static bool cp_parser_is_string_literal
2340 static bool cp_parser_is_keyword
2342 static tree cp_parser_make_typename_type
2347 /* Returns nonzero if we are parsing tentatively. */
2351 {
2353 }
2355 /* Returns nonzero if TOKEN is a string literal. */
2357 static bool
2359 {
2365 }
2367 /* Returns nonzero if TOKEN is a string literal
2368 of a user-defined string literal. */
2370 static bool
2372 {
2379 }
2381 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2383 static bool
2385 {
2387 }
2389 /* If not parsing tentatively, issue a diagnostic of the form
2390 FILE:LINE: MESSAGE before TOKEN
2391 where TOKEN is the next token in the input stream. MESSAGE
2392 (specified by the caller) is usually of the form "expected
2393 OTHER-TOKEN". */
2395 static void
2397 {
2399 {
2401 /* This diagnostic makes more sense if it is tagged to the line
2402 of the token we just peeked at. */
2406 {
2411 }
2414 /* Because c_parser_error does not understand
2415 CPP_KEYWORD, keywords are treated like
2416 identifiers. */
2419 }
2420 }
2422 /* Issue an error about name-lookup failing. NAME is the
2423 IDENTIFIER_NODE DECL is the result of
2424 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2425 the thing that we hoped to find. */
2427 static void
2429 tree name,
2430 tree decl,
2431 name_lookup_error desired,
2432 location_t location)
2433 {
2434 /* If name lookup completely failed, tell the user that NAME was not
2435 declared. */
2437 {
2450 else
2452 }
2454 {
2456 {
2473 }
2474 }
2476 {
2478 {
2488 name);
2492 }
2493 }
2494 else
2495 {
2497 {
2510 }
2511 }
2512 }
2514 /* If we are parsing tentatively, remember that an error has occurred
2515 during this tentative parse. Returns true if the error was
2516 simulated; false if a message should be issued by the caller. */
2518 static bool
2520 {
2522 {
2525 }
2527 }
2529 /* This function is called when a type is defined. If type
2530 definitions are forbidden at this point, an error message is
2531 issued. */
2533 static bool
2535 {
2536 /* If types are forbidden here, issue a message. */
2538 {
2539 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2540 in the message need to be interpreted. */
2543 }
2545 }
2547 /* This function is called when the DECLARATOR is processed. The TYPE
2548 was a type defined in the decl-specifiers. If it is invalid to
2549 define a type in the decl-specifiers for DECLARATOR, an error is
2550 issued. TYPE_LOCATION is the location of TYPE and is used
2551 for error reporting. */
2553 static void
2556 {
2557 /* [dcl.fct] forbids type definitions in return types.
2558 Unfortunately, it's not easy to know whether or not we are
2559 processing a return type until after the fact. */
2567 {
2572 type);
2573 }
2574 }
2576 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2577 "<" in any valid C++ program. If the next token is indeed "<",
2578 issue a message warning the user about what appears to be an
2579 invalid attempt to form a template-id. LOCATION is the location
2580 of the type-specifier (TYPE) */
2582 static void
2584 tree type,
2586 location_t location)
2587 {
2591 {
2595 {
2598 else
2600 }
2601 else
2603 /* Remember the location of the invalid "<". */
2606 /* Consume the "<". */
2608 /* Parse the template arguments. */
2610 /* Permanently remove the invalid template arguments so that
2611 this error message is not issued again. */
2614 }
2615 }
2617 /* If parsing an integral constant-expression, issue an error message
2618 about the fact that THING appeared and return true. Otherwise,
2619 return false. In either case, set
2620 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2622 static bool
2624 non_integral_constant thing)
2625 {
2628 {
2630 {
2633 {
2640 "enumeration type cannot appear in a "
2731 }
2735 }
2736 }
2738 }
2740 /* Emit a diagnostic for an invalid type name. SCOPE is the
2741 qualifying scope (or NULL, if none) for ID. This function commits
2742 to the current active tentative parse, if any. (Otherwise, the
2743 problematic construct might be encountered again later, resulting
2744 in duplicate error messages.) LOCATION is the location of ID. */
2746 static void
2749 location_t location)
2750 {
2753 /* Try to lookup the identifier. */
2758 /* If the lookup found a template-name, it means that the user forgot
2759 to specify an argument list. Emit a useful error message. */
2763 decl);
2767 /* Something like 'unsigned A a;' */
2770 {
2771 /* Issue an error message. */
2773 /* If we're in a template class, it's possible that the user was
2774 referring to a type from a base class. For example:
2776 template <typename T> struct A { typedef T X; };
2777 template <typename T> struct B : public A<T> { X x; };
2779 The user should have said "typename A<T>::X". */
2785 {
2786 tree b;
2789 b;
2791 {
2795 {
2796 tree field;
2797 /* Go from a particular instantiation of the
2798 template (which will have an empty TYPE_FIELDs),
2799 to the main version. */
2802 field;
2806 {
2811 }
2814 }
2815 }
2816 }
2817 }
2818 /* Here we diagnose qualified-ids where the scope is actually correct,
2819 but the identifier does not resolve to a valid type name. */
2821 {
2827 {
2828 /* A<T>::A<T>() */
2834 }
2843 else
2845 }
2846 }
2848 /* Check for a common situation where a type-name should be present,
2849 but is not, and issue a sensible error message. Returns true if an
2850 invalid type-name was detected.
2852 The situation handled by this function are variable declarations of the
2853 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2854 Usually, `ID' should name a type, but if we got here it means that it
2855 does not. We try to emit the best possible error message depending on
2856 how exactly the id-expression looks like. */
2858 static bool
2860 {
2861 tree id;
2864 /* Avoid duplicate error about ambiguous lookup. */
2866 {
2870 }
2879 /* If the next token is a (, this is a function with no explicit return
2880 type, i.e. constructor, destructor or conversion op. */
2883 {
2886 }
2890 /* Emit a diagnostic for the invalid type. */
2893 out:
2894 /* If we aren't in the middle of a declarator (i.e. in a
2895 parameter-declaration-clause), skip to the end of the declaration;
2896 there's no point in trying to process it. */
2900 }
2902 /* Consume tokens up to, and including, the next non-nested closing `)'.
2903 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
2904 are doing error recovery. Returns -1 if OR_COMMA is true and we
2905 found an unnested comma. */
2907 static int
2912 {
2922 {
2926 {
2929 /* If we've run out of tokens, then there is no closing `)'. */
2932 /* This is good for lambda expression capture-lists. */
2942 /* This matches the processing in skip_to_end_of_statement. */
2968 {
2972 }
2977 }
2979 /* Consume the token. */
2981 }
2982 }
2984 /* Consume tokens until we reach the end of the current statement.
2985 Normally, that will be just before consuming a `;'. However, if a
2986 non-nested `}' comes first, then we stop before consuming that. */
2988 static void
2990 {
2994 {
2998 {
3001 /* If we've run out of tokens, stop. */
3005 /* If the next token is a `;', we have reached the end of the
3006 statement. */
3012 /* If this is a non-nested '}', stop before consuming it.
3013 That way, when confronted with something like:
3015 { 3 + }
3017 we stop before consuming the closing '}', even though we
3018 have not yet reached a `;'. */
3022 /* If it is the closing '}' for a block that we have
3023 scanned, stop -- but only after consuming the token.
3024 That way given:
3026 void f g () { ... }
3027 typedef int I;
3029 we will stop after the body of the erroneously declared
3030 function, but before consuming the following `typedef'
3031 declaration. */
3033 {
3036 }
3044 }
3046 /* Consume the token. */
3048 }
3049 }
3051 /* This function is called at the end of a statement or declaration.
3052 If the next token is a semicolon, it is consumed; otherwise, error
3053 recovery is attempted. */
3055 static void
3057 {
3058 /* Look for the trailing `;'. */
3060 {
3061 /* If there is additional (erroneous) input, skip to the end of
3062 the statement. */
3064 /* If the next token is now a `;', consume it. */
3067 }
3068 }
3070 /* Skip tokens until we have consumed an entire block, or until we
3071 have consumed a non-nested `;'. */
3073 static void
3075 {
3079 {
3083 {
3086 /* If we've run out of tokens, stop. */
3090 /* Stop if this is an unnested ';'. */
3096 /* Stop if this is an unnested '}', or closes the outermost
3097 nesting level. */
3098 nesting_depth--;
3106 /* Nest. */
3107 nesting_depth++;
3112 }
3114 /* Consume the token. */
3116 }
3117 }
3119 /* Skip tokens until a non-nested closing curly brace is the next
3120 token, or there are no more tokens. Return true in the first case,
3121 false otherwise. */
3123 static bool
3125 {
3129 {
3133 {
3136 /* If we've run out of tokens, stop. */
3140 /* If the next token is a non-nested `}', then we have reached
3141 the end of the current block. */
3147 /* If it the next token is a `{', then we are entering a new
3148 block. Consume the entire block. */
3154 }
3156 /* Consume the token. */
3158 }
3159 }
3161 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3162 parameter is the PRAGMA token, allowing us to purge the entire pragma
3163 sequence. */
3165 static void
3167 {
3172 do
3176 /* Ensure that the pragma is not parsed again. */
3178 }
3180 /* Require pragma end of line, resyncing with it as necessary. The
3181 arguments are as for cp_parser_skip_to_pragma_eol. */
3183 static void
3185 {
3189 }
3191 /* This is a simple wrapper around make_typename_type. When the id is
3192 an unresolved identifier node, we can provide a superior diagnostic
3193 using cp_parser_diagnose_invalid_type_name. */
3195 static tree
3198 {
3199 tree result;
3201 {
3207 }
3209 }
3211 /* This is a wrapper around the
3212 make_{pointer,ptrmem,reference}_declarator functions that decides
3213 which one to call based on the CODE and CLASS_TYPE arguments. The
3214 CODE argument should be one of the values returned by
3215 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3216 appertain to the pointer or reference. */
3220 cp_cv_quals cv_qualifiers,
3222 tree attributes)
3223 {
3230 else
3240 }
3242 /* Create a new C++ parser. */
3246 {
3251 /* cp_lexer_new_main is called before doing GC allocation because
3252 cp_lexer_new_main might load a PCH file. */
3255 /* Initialize the binops_by_token so that we can get the tree
3256 directly from the token. */
3264 /* For now, we always accept GNU extensions. */
3267 /* The `>' token is a greater-than operator, not the end of a
3268 template-id. */
3273 /* We are not parsing a constant-expression. */
3278 /* Local variable names are not forbidden. */
3281 /* We are not processing an `extern "C"' declaration. */
3284 /* We are not processing a declarator. */
3287 /* We are not processing a template-argument-list. */
3290 /* We are not in an iteration statement. */
3293 /* We are not in a switch statement. */
3296 /* We are not parsing a type-id inside an expression. */
3299 /* Declarations aren't implicitly extern "C". */
3302 /* String literals should be translated to the execution character set. */
3305 /* We are not parsing a function body. */
3308 /* We can correct until told otherwise. */
3311 /* The unparsed function queue is empty. */
3314 /* There are no classes being defined. */
3317 /* No template parameters apply. */
3321 }
3323 /* Create a cp_lexer structure which will emit the tokens in CACHE
3324 and push it onto the parser's lexer stack. This is used for delayed
3325 parsing of in-class method bodies and default arguments, and should
3326 not be confused with tentative parsing. */
3327 static void
3329 {
3334 /* Move the current source position to that of the first token in the
3335 new lexer. */
3337 }
3339 /* Pop the top lexer off the parser stack. This is never used for the
3340 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3341 static void
3343 {
3348 /* Put the current source position back where it was before this
3349 lexer was pushed. */
3351 }
3353 /* Lexical conventions [gram.lex] */
3355 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3356 identifier. */
3358 static tree
3360 {
3363 /* Look for the identifier. */
3365 /* Return the value. */
3367 }
3369 /* Parse a sequence of adjacent string constants. Returns a
3370 TREE_STRING representing the combined, nul-terminated string
3371 constant. If TRANSLATE is true, translate the string to the
3372 execution character set. If WIDE_OK is true, a wide string is
3373 invalid here.
3375 C++98 [lex.string] says that if a narrow string literal token is
3376 adjacent to a wide string literal token, the behavior is undefined.
3377 However, C99 6.4.5p4 says that this results in a wide string literal.
3378 We follow C99 here, for consistency with the C front end.
3380 This code is largely lifted from lex_string() in c-lex.c.
3382 FUTURE: ObjC++ will need to handle @-strings here. */
3383 static tree
3385 {
3386 tree value;
3393 tree string_tree;
3399 {
3402 }
3405 {
3409 }
3410 else
3411 {
3414 }
3417 /* Try to avoid the overhead of creating and destroying an obstack
3418 for the common case of just one string. */
3421 {
3429 {
3433 }
3434 else
3438 }
3439 else
3440 {
3444 do
3445 {
3447 count++;
3452 {
3455 {
3458 }
3461 {
3466 }
3468 }
3469 else
3473 {
3478 "unsupported non-standard concatenation "
3480 }
3486 {
3490 }
3491 else
3492 {
3496 }
3497 }
3501 }
3504 {
3507 }
3511 {
3516 {
3531 }
3536 {
3541 }
3542 }
3543 else
3544 /* cpp_interpret_string has issued an error. */
3551 }
3553 /* Look up a literal operator with the name and the exact arguments. */
3555 static tree
3557 {
3564 {
3571 {
3574 {
3584 }
3587 /* May be this should be sufficient_parms_p instead,
3588 depending on how exactly should user-defined literals
3589 work in presence of default arguments on the literal
3590 operator parameters. */
3593 }
3594 }
3597 }
3599 /* Parse a user-defined char constant. Returns a call to a user-defined
3600 literal operator taking the character as an argument. */
3602 static tree
3604 {
3612 /* Build up a call to the user-defined operator */
3613 /* Lookup the name we got back from the id-expression. */
3618 {
3623 }
3632 }
3634 /* A subroutine of cp_parser_userdef_numeric_literal to
3635 create a char... template parameter pack from a string node. */
3637 static tree
3639 {
3640 tree charvec;
3646 /* Fill in CHARVEC with all of the parameters. */
3651 /* Build the argument packs. */
3658 }
3660 /* Parse a user-defined numeric constant. returns a call to a user-defined
3661 literal operator. */
3663 static tree
3665 {
3676 /* Look for a literal operator taking the exact type of numeric argument
3677 as the literal value. */
3682 {
3685 {
3689 long_long_unsigned_type_node);
3690 else
3691 {
3695 long_double_type_node);
3699 }
3702 }
3703 }
3706 /* If the numeric argument didn't work, look for a raw literal
3707 operator taking a const char* argument consisting of the number
3708 in string format. */
3713 {
3716 {
3719 }
3720 }
3723 /* If the raw literal didn't work, look for a non-type template
3724 function with parameter pack char.... Call the function with
3725 template parameter characters representing the number. */
3729 {
3734 {
3737 }
3738 }
3743 }
3745 /* Parse a user-defined string constant. Returns a call to a user-defined
3746 literal operator taking a character pointer and the length of the string
3747 as arguments. */
3749 static tree
3751 {
3760 /* Build up a call to the user-defined operator */
3761 /* Lookup the name we got back from the id-expression. */
3767 {
3771 }
3780 }
3783 /* Basic concepts [gram.basic] */
3785 /* Parse a translation-unit.
3787 translation-unit:
3788 declaration-seq [opt]
3790 Returns TRUE if all went well. */
3792 static bool
3794 {
3795 /* The address of the first non-permanent object on the declarator
3796 obstack. */
3801 /* Create the declarator obstack, if necessary. */
3803 {
3805 /* Create the error declarator. */
3807 /* Create the empty parameter list. */
3809 /* Remember where the base of the declarator obstack lies. */
3811 }
3815 /* If there are no tokens left then all went well. */
3817 {
3818 /* Get rid of the token array; we don't need it any more. */
3822 /* This file might have been a context that's implicitly extern
3823 "C". If so, pop the lang context. (Only relevant for PCH.) */
3825 {
3828 }
3830 /* Finish up. */
3834 }
3835 else
3836 {
3839 }
3841 /* Make sure the declarator obstack was fully cleaned up. */
3845 /* All went well. */
3847 }
3849 /* Return the appropriate tsubst flags for parsing, possibly in N3276
3850 decltype context. */
3854 {
3859 }
3861 /* Expressions [gram.expr] */
3863 /* Parse a primary-expression.
3865 primary-expression:
3866 literal
3867 this
3868 ( expression )
3869 id-expression
3871 GNU Extensions:
3873 primary-expression:
3874 ( compound-statement )
3875 __builtin_va_arg ( assignment-expression , type-id )
3876 __builtin_offsetof ( type-id , offsetof-expression )
3878 C++ Extensions:
3879 __has_nothrow_assign ( type-id )
3880 __has_nothrow_constructor ( type-id )
3881 __has_nothrow_copy ( type-id )
3882 __has_trivial_assign ( type-id )
3883 __has_trivial_constructor ( type-id )
3884 __has_trivial_copy ( type-id )
3885 __has_trivial_destructor ( type-id )
3886 __has_virtual_destructor ( type-id )
3887 __is_abstract ( type-id )
3888 __is_base_of ( type-id , type-id )
3889 __is_class ( type-id )
3890 __is_convertible_to ( type-id , type-id )
3891 __is_empty ( type-id )
3892 __is_enum ( type-id )
3893 __is_final ( type-id )
3894 __is_literal_type ( type-id )
3895 __is_pod ( type-id )
3896 __is_polymorphic ( type-id )
3897 __is_std_layout ( type-id )
3898 __is_trivial ( type-id )
3899 __is_union ( type-id )
3901 Objective-C++ Extension:
3903 primary-expression:
3904 objc-expression
3906 literal:
3907 __null
3909 ADDRESS_P is true iff this expression was immediately preceded by
3910 "&" and therefore might denote a pointer-to-member. CAST_P is true
3911 iff this expression is the target of a cast. TEMPLATE_ARG_P is
3912 true iff this expression is a template argument.
3914 Returns a representation of the expression. Upon return, *IDK
3915 indicates what kind of id-expression (if any) was present. */
3917 static tree
3924 {
3927 /* Assume the primary expression is not an id-expression. */
3930 /* Peek at the next token. */
3933 {
3934 /* literal:
3935 integer-literal
3936 character-literal
3937 floating-literal
3938 string-literal
3939 boolean-literal
3940 pointer-literal
3941 user-defined-literal */
3951 {
3955 }
3956 /* Floating-point literals are only allowed in an integral
3957 constant expression if they are cast to an integral or
3958 enumeration type. */
3962 {
3963 /* CAST_P will be set even in invalid code like "int(2.7 +
3964 ...)". Therefore, we have to check that the next token
3965 is sure to end the cast. */
3967 {
3972 enumerator-definition. */
3974 /* The curly brace at the end of an enum-specifier. */
3976 /* The end of a statement. */
3978 /* The end of the cast-expression. */
3980 /* The end of an array bound. */
3982 /* The closing ">" in a template-argument-list. */
3985 /* C++0x only: A ">>" treated like two ">" tokens,
3986 in a template-argument-list. */
3991 }
3993 /* If we are within a cast, then the constraint that the
3994 cast is to an integral or enumeration type will be
3995 checked at that point. If we are not within a cast, then
3996 this code is invalid. */
3999 }
4018 /* ??? Should wide strings be allowed when parser->translate_strings_p
4019 is false (i.e. in attributes)? If not, we can kill the third
4020 argument to cp_parser_string_literal. */
4026 {
4027 tree expr;
4030 /* Consume the `('. */
4032 /* Within a parenthesized expression, a `>' token is always
4033 the greater-than operator. */
4034 saved_greater_than_is_operator_p
4037 /* If we see `( { ' then we are looking at the beginning of
4038 a GNU statement-expression. */
4041 {
4042 /* Statement-expressions are not allowed by the standard. */
4046 /* And they're not allowed outside of a function-body; you
4047 cannot, for example, write:
4049 int i = ({ int j = 3; j + 1; });
4051 at class or namespace scope. */
4054 {
4056 "statement-expressions are not allowed outside "
4060 }
4061 else
4062 {
4063 /* Start the statement-expression. */
4065 /* Parse the compound-statement. */
4067 /* Finish up. */
4069 }
4070 }
4071 else
4072 {
4073 /* Parse the parenthesized expression. */
4075 /* Let the front end know that this expression was
4076 enclosed in parentheses. This matters in case, for
4077 example, the expression is of the form `A::B', since
4078 `&A::B' might be a pointer-to-member, but `&(A::B)' is
4079 not. */
4081 /* DR 705: Wrapping an unqualified name in parentheses
4082 suppresses arg-dependent lookup. We want to pass back
4083 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4084 (c++/37862), but none of the others. */
4087 }
4088 /* The `>' token might be the end of a template-id or
4089 template-parameter-list now. */
4090 parser->greater_than_is_operator_p
4092 /* Consume the `)'. */
4097 }
4101 /* We have an Objective-C++ message. */
4103 {
4105 /* Don't warn about a failed tentative parse. */
4110 }
4114 /* We have an Objective-C++ string literal. */
4121 {
4122 /* These two are the boolean literals. */
4130 /* The `__null' literal. */
4135 /* The `nullptr' literal. */
4140 /* Recognize the `this' keyword. */
4144 {
4148 }
4149 /* Pointers cannot appear in constant-expressions. */
4154 /* The `operator' keyword can be the beginning of an
4155 id-expression. */
4162 {
4163 non_integral_constant name;
4165 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4166 __func__ are the names of variables -- but they are
4167 treated specially. Therefore, they are handled here,
4168 rather than relying on the generic id-expression logic
4169 below. Grammatically, these names are id-expressions.
4171 Consume the token. */
4175 {
4187 }
4192 /* Look up the name. */
4194 }
4197 {
4198 tree expression;
4199 tree type;
4200 source_location type_location;
4202 /* The `__builtin_va_arg' construct is used to handle
4203 `va_arg'. Consume the `__builtin_va_arg' token. */
4205 /* Look for the opening `('. */
4207 /* Now, parse the assignment-expression. */
4210 /* Look for the `,'. */
4213 /* Parse the type-id. */
4215 /* Look for the closing `)'. */
4217 /* Using `va_arg' in a constant-expression is not
4218 allowed. */
4220 NIC_VA_ARG))
4223 }
4251 /* Objective-C++ expressions. */
4261 {
4266 }
4270 }
4272 /* An id-expression can start with either an identifier, a
4273 `::' as the beginning of a qualified-id, or the "operator"
4274 keyword. */
4279 {
4280 tree id_expression;
4281 tree decl;
4287 id_expression:
4288 /* Parse the id-expression. */
4289 id_expression
4306 /* If we have a template-id, then no further lookup is
4307 required. If the template-id was for a template-class, we
4308 will sometimes have a TYPE_DECL at this point. */
4312 /* Look up the name. */
4313 else
4314 {
4315 tree ambiguous_decls;
4317 /* If we already know that this lookup is ambiguous, then
4318 we've already issued an error message; there's no reason
4319 to check again. */
4322 {
4325 }
4328 none_type,
4329 template_p,
4334 /* If the lookup was ambiguous, an error will already have
4335 been issued. */
4339 /* In Objective-C++, we may have an Objective-C 2.0
4340 dot-syntax for classes here. */
4345 {
4346 tree component;
4353 }
4355 /* In Objective-C++, an instance variable (ivar) may be preferred
4356 to whatever cp_parser_lookup_name() found. */
4359 /* If name lookup gives us a SCOPE_REF, then the
4360 qualifying scope was dependent. */
4362 {
4363 /* At this point, we do not know if DECL is a valid
4364 integral constant expression. We assume that it is
4365 in fact such an expression, so that code like:
4367 template <int N> struct A {
4368 int a[B<N>::i];
4369 };
4371 is accepted. At template-instantiation time, we
4372 will check that B<N>::i is actually a constant. */
4374 }
4375 /* Check to see if DECL is a local variable in a context
4376 where that is forbidden. */
4379 {
4380 /* It might be that we only found DECL because we are
4381 trying to be generous with pre-ISO scoping rules.
4382 For example, consider:
4384 int i;
4385 void g() {
4386 for (int i = 0; i < 10; ++i) {}
4387 extern void f(int j = i);
4388 }
4390 Here, name look up will originally find the out
4391 of scope `i'. We need to issue a warning message,
4392 but then use the global `i'. */
4395 {
4398 decl);
4400 }
4401 }
4402 }
4404 decl = (finish_id_expression
4406 idk,
4411 template_arg_p,
4417 }
4419 /* Anything else is an error. */
4423 }
4424 }
4432 {
4435 }
4437 /* Parse an id-expression.
4439 id-expression:
4440 unqualified-id
4441 qualified-id
4443 qualified-id:
4444 :: [opt] nested-name-specifier template [opt] unqualified-id
4445 :: identifier
4446 :: operator-function-id
4447 :: template-id
4449 Return a representation of the unqualified portion of the
4450 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
4451 a `::' or nested-name-specifier.
4453 Often, if the id-expression was a qualified-id, the caller will
4454 want to make a SCOPE_REF to represent the qualified-id. This
4455 function does not do this in order to avoid wastefully creating
4456 SCOPE_REFs when they are not required.
4458 If TEMPLATE_KEYWORD_P is true, then we have just seen the
4459 `template' keyword.
4461 If CHECK_DEPENDENCY_P is false, then names are looked up inside
4462 uninstantiated templates.
4464 If *TEMPLATE_P is non-NULL, it is set to true iff the
4465 `template' keyword is used to explicitly indicate that the entity
4466 named is a template.
4468 If DECLARATOR_P is true, the id-expression is appearing as part of
4469 a declarator, rather than as part of an expression. */
4471 static tree
4478 {
4482 /* Assume the `template' keyword was not used. */
4486 /* Look for the optional `::' operator. */
4487 global_scope_p
4490 /* Look for the optional nested-name-specifier. */
4491 nested_name_specifier_p
4494 check_dependency_p,
4496 declarator_p)
4498 /* If there is a nested-name-specifier, then we are looking at
4499 the first qualified-id production. */
4501 {
4502 tree saved_scope;
4503 tree saved_object_scope;
4504 tree saved_qualifying_scope;
4505 tree unqualified_id;
4508 /* See if the next token is the `template' keyword. */
4512 /* Name lookup we do during the processing of the
4513 unqualified-id might obliterate SCOPE. */
4517 /* Process the final unqualified-id. */
4519 check_dependency_p,
4520 declarator_p,
4522 /* Restore the SAVED_SCOPE for our caller. */
4528 }
4529 /* Otherwise, if we are in global scope, then we are looking at one
4530 of the other qualified-id productions. */
4532 {
4534 tree id;
4536 /* Peek at the next token. */
4539 /* If it's an identifier, and the next token is not a "<", then
4540 we can avoid the template-id case. This is an optimization
4541 for this common case. */
4543 && !cp_parser_nth_token_starts_template_argument_list_p
4548 /* Try a template-id. */
4552 none_type,
4553 declarator_p);
4554 /* If that worked, we're done. */
4558 /* Peek at the next token. (Changes in the token buffer may
4559 have invalidated the pointer obtained above.) */
4563 {
4570 /* Fall through. */
4575 }
4576 }
4577 else
4580 declarator_p,
4581 optional_p);
4582 }
4584 /* Parse an unqualified-id.
4586 unqualified-id:
4587 identifier
4588 operator-function-id
4589 conversion-function-id
4590 ~ class-name
4591 template-id
4593 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
4594 keyword, in a construct like `A::template ...'.
4596 Returns a representation of unqualified-id. For the `identifier'
4597 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
4598 production a BIT_NOT_EXPR is returned; the operand of the
4599 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
4600 other productions, see the documentation accompanying the
4601 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
4602 names are looked up in uninstantiated templates. If DECLARATOR_P
4603 is true, the unqualified-id is appearing as part of a declarator,
4604 rather than as part of an expression. */
4606 static tree
4612 {
4615 /* Peek at the next token. */
4619 {
4621 {
4622 tree id;
4624 /* We don't know yet whether or not this will be a
4625 template-id. */
4627 /* Try a template-id. */
4629 check_dependency_p,
4630 none_type,
4631 declarator_p);
4632 /* If it worked, we're done. */
4635 /* Otherwise, it's an ordinary identifier. */
4637 }
4641 check_dependency_p,
4642 none_type,
4643 declarator_p);
4646 {
4647 tree type_decl;
4648 tree qualifying_scope;
4649 tree object_scope;
4650 tree scope;
4653 /* Consume the `~' token. */
4655 /* Parse the class-name. The standard, as written, seems to
4656 say that:
4658 template <typename T> struct S { ~S (); };
4659 template <typename T> S<T>::~S() {}
4661 is invalid, since `~' must be followed by a class-name, but
4662 `S<T>' is dependent, and so not known to be a class.
4663 That's not right; we need to look in uninstantiated
4664 templates. A further complication arises from:
4666 template <typename T> void f(T t) {
4667 t.T::~T();
4668 }
4670 Here, it is not possible to look up `T' in the scope of `T'
4671 itself. We must look in both the current scope, and the
4672 scope of the containing complete expression.
4674 Yet another issue is:
4676 struct S {
4677 int S;
4678 ~S();
4679 };
4681 S::~S() {}
4683 The standard does not seem to say that the `S' in `~S'
4684 should refer to the type `S' and not the data member
4685 `S::S'. */
4687 /* DR 244 says that we look up the name after the "~" in the
4688 same scope as we looked up the qualifying name. That idea
4689 isn't fully worked out; it's more complicated than that. */
4694 /* Check for invalid scopes. */
4696 {
4700 }
4702 {
4706 scope);
4711 }
4714 /* If the name is of the form "X::~X" it's OK even if X is a
4715 typedef. */
4724 {
4727 }
4729 /* If there was an explicit qualification (S::~T), first look
4730 in the scope given by the qualification (i.e., S).
4732 Note: in the calls to cp_parser_class_name below we pass
4733 typename_type so that lookup finds the injected-class-name
4734 rather than the constructor. */
4738 {
4743 typename_type,
4746 declarator_p);
4749 }
4750 /* In "N::S::~S", look in "N" as well. */
4752 {
4757 type_decl
4761 typename_type,
4764 declarator_p);
4767 }
4768 /* In "p->S::~T", look in the scope given by "*p" as well. */
4770 {
4775 type_decl
4779 typename_type,
4782 declarator_p);
4785 }
4786 /* Look in the surrounding context. */
4788 {
4794 type_decl
4798 typename_type,
4801 declarator_p);
4804 {
4805 /* We couldn't find a type with this name, so just accept
4806 it and check for a match at instantiation time. */
4811 }
4812 }
4813 /* If an error occurred, assume that the name of the
4814 destructor is the same as the name of the qualifying
4815 class. That allows us to keep parsing after running
4816 into ill-formed destructor names. */
4822 /* Check that destructor name and scope match. */
4824 {
4831 }
4833 /* [class.dtor]
4835 A typedef-name that names a class shall not be used as the
4836 identifier in the declarator for a destructor declaration. */
4843 type_decl);
4846 }
4850 {
4851 tree id;
4853 /* This could be a template-id, so we try that first. */
4855 /* Try a template-id. */
4858 none_type,
4859 declarator_p);
4860 /* If that worked, we're done. */
4863 /* We still don't know whether we're looking at an
4864 operator-function-id or a conversion-function-id. */
4866 /* Try an operator-function-id. */
4868 /* If that didn't work, try a conversion-function-id. */
4872 {
4873 /* 17.6.3.3.5 */
4878 }
4881 }
4882 /* Fall through. */
4889 }
4890 }
4892 /* Parse an (optional) nested-name-specifier.
4894 nested-name-specifier: [C++98]
4895 class-or-namespace-name :: nested-name-specifier [opt]
4896 class-or-namespace-name :: template nested-name-specifier [opt]
4898 nested-name-specifier: [C++0x]
4899 type-name ::
4900 namespace-name ::
4901 nested-name-specifier identifier ::
4902 nested-name-specifier template [opt] simple-template-id ::
4904 PARSER->SCOPE should be set appropriately before this function is
4905 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
4906 effect. TYPE_P is TRUE if we non-type bindings should be ignored
4907 in name lookups.
4909 Sets PARSER->SCOPE to the class (TYPE) or namespace
4910 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
4911 it unchanged if there is no nested-name-specifier. Returns the new
4912 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
4914 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
4915 part of a declaration and/or decl-specifier. */
4917 static tree
4923 {
4928 /* Remember where the nested-name-specifier starts. */
4930 {
4933 }
4936 {
4937 tree new_scope;
4938 tree old_scope;
4939 tree saved_qualifying_scope;
4942 /* Spot cases that cannot be the beginning of a
4943 nested-name-specifier. */
4946 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
4947 the already parsed nested-name-specifier. */
4949 {
4950 /* Grab the nested-name-specifier and continue the loop. */
4952 /* If we originally encountered this nested-name-specifier
4953 with IS_DECLARATION set to false, we will not have
4954 resolved TYPENAME_TYPEs, so we must do so here. */
4957 {
4962 }
4965 }
4967 /* Spot cases that cannot be the beginning of a
4968 nested-name-specifier. On the second and subsequent times
4969 through the loop, we look for the `template' keyword. */
4971 ;
4972 /* A template-id can start a nested-name-specifier. */
4974 ;
4975 /* DR 743: decltype can be used in a nested-name-specifier. */
4977 ;
4978 else
4979 {
4980 /* If the next token is not an identifier, then it is
4981 definitely not a type-name or namespace-name. */
4984 /* If the following token is neither a `<' (to begin a
4985 template-id), nor a `::', then we are not looking at a
4986 nested-name-specifier. */
4992 {
4996 }
4999 && !cp_parser_nth_token_starts_template_argument_list_p
5002 }
5004 /* The nested-name-specifier is optional, so we parse
5005 tentatively. */
5008 /* Look for the optional `template' keyword, if this isn't the
5009 first time through the loop. */
5012 else
5015 /* Save the old scope since the name lookup we are about to do
5016 might destroy it. */
5019 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
5020 look up names in "X<T>::I" in order to determine that "Y" is
5021 a template. So, if we have a typename at this point, we make
5022 an effort to look through it. */
5024 && !typename_keyword_p
5029 /* Parse the qualifying entity. */
5030 new_scope
5032 typename_keyword_p,
5033 template_keyword_p,
5034 check_dependency_p,
5035 type_p,
5036 is_declaration);
5037 /* Look for the `::' token. */
5040 /* If we found what we wanted, we keep going; otherwise, we're
5041 done. */
5043 {
5046 /* Restore the OLD_SCOPE since it was valid before the
5047 failed attempt at finding the last
5048 class-or-namespace-name. */
5052 /* If the next token is a decltype, and the one after that is a
5053 `::', then the decltype has failed to resolve to a class or
5054 enumeration type. Give this error even when parsing
5055 tentatively since it can't possibly be valid--and we're going
5056 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
5057 won't get another chance.*/
5061 {
5068 /* As below. */
5071 }
5075 /* If the next token is an identifier, and the one after
5076 that is a `::', then any valid interpretation would have
5077 found a class-or-namespace-name. */
5083 {
5086 {
5088 {
5089 tree decl;
5090 tree ambiguous_decls;
5093 none_type,
5102 decl);
5104 {
5110 }
5111 else
5112 {
5114 cp_parser_name_lookup_error
5117 else
5118 cp_parser_name_lookup_error
5121 }
5122 }
5125 /* Treat this as a successful nested-name-specifier
5126 due to:
5128 [basic.lookup.qual]
5130 If the name found is not a class-name (clause
5131 _class_) or namespace-name (_namespace.def_), the
5132 program is ill-formed. */
5134 }
5136 }
5138 }
5139 /* We've found one valid nested-name-specifier. */
5141 /* Name lookup always gives us a DECL. */
5144 /* Uses of "template" must be followed by actual templates. */
5156 new_scope);
5157 /* If it is a class scope, try to complete it; we are about to
5158 be looking up names inside the class. */
5160 /* Since checking types for dependency can be expensive,
5161 avoid doing it if the type is already complete. */
5163 /* Do not try to complete dependent types. */
5165 {
5167 /* If it is a typedef to current class, use the current
5168 class instead, as the typedef won't have any names inside
5169 it yet. */
5173 }
5174 /* Make sure we look in the right scope the next time through
5175 the loop. */
5177 }
5179 /* If parsing tentatively, replace the sequence of tokens that makes
5180 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
5181 token. That way, should we re-parse the token stream, we will
5182 not have to repeat the effort required to do the parse, nor will
5183 we issue duplicate error messages. */
5185 {
5189 /* Reset the contents of the START token. */
5191 /* Retrieve any deferred checks. Do not pop this access checks yet
5192 so the memory will not be reclaimed during token replacing below. */
5200 /* Purge all subsequent tokens. */
5202 }
5208 }
5210 /* Parse a nested-name-specifier. See
5211 cp_parser_nested_name_specifier_opt for details. This function
5212 behaves identically, except that it will an issue an error if no
5213 nested-name-specifier is present. */
5215 static tree
5221 {
5222 tree scope;
5224 /* Look for the nested-name-specifier. */
5226 typename_keyword_p,
5227 check_dependency_p,
5228 type_p,
5229 is_declaration);
5230 /* If it was not present, issue an error message. */
5232 {
5235 }
5238 }
5240 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
5241 this is either a class-name or a namespace-name (which corresponds
5242 to the class-or-namespace-name production in the grammar). For
5243 C++0x, it can also be a type-name that refers to an enumeration
5244 type or a simple-template-id.
5246 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
5247 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
5248 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
5249 TYPE_P is TRUE iff the next name should be taken as a class-name,
5250 even the same name is declared to be another entity in the same
5251 scope.
5253 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
5254 specified by the class-or-namespace-name. If neither is found the
5255 ERROR_MARK_NODE is returned. */
5257 static tree
5264 {
5265 tree saved_scope;
5266 tree saved_qualifying_scope;
5267 tree saved_object_scope;
5268 tree scope;
5272 /* DR 743: decltype can appear in a nested-name-specifier. */
5274 {
5278 {
5281 }
5285 }
5287 /* Before we try to parse the class-name, we must save away the
5288 current PARSER->SCOPE since cp_parser_class_name will destroy
5289 it. */
5293 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
5294 there is no need to look for a namespace-name. */
5295 only_class_p = template_keyword_p
5300 typename_keyword_p,
5301 template_keyword_p,
5303 check_dependency_p,
5305 is_declaration);
5307 /* If that didn't work and we're in C++0x mode, try for a type-name. */
5311 {
5312 /* Restore the saved scope. */
5317 /* Parse tentatively. */
5320 /* Parse a type-name */
5323 /* "If the name found does not designate a namespace or a class,
5324 enumeration, or dependent type, the program is ill-formed."
5326 We cover classes and dependent types above and namespaces below,
5327 so this code is only looking for enums. */
5333 }
5334 /* If that didn't work, try for a namespace-name. */
5336 {
5337 /* Restore the saved scope. */
5341 /* If we are not looking at an identifier followed by the scope
5342 resolution operator, then this is not part of a
5343 nested-name-specifier. (Note that this function is only used
5344 to parse the components of a nested-name-specifier.) */
5349 }
5352 }
5354 /* Parse a postfix-expression.
5356 postfix-expression:
5357 primary-expression
5358 postfix-expression [ expression ]
5359 postfix-expression ( expression-list [opt] )
5360 simple-type-specifier ( expression-list [opt] )
5361 typename :: [opt] nested-name-specifier identifier
5362 ( expression-list [opt] )
5363 typename :: [opt] nested-name-specifier template [opt] template-id
5364 ( expression-list [opt] )
5365 postfix-expression . template [opt] id-expression
5366 postfix-expression -> template [opt] id-expression
5367 postfix-expression . pseudo-destructor-name
5368 postfix-expression -> pseudo-destructor-name
5369 postfix-expression ++
5370 postfix-expression --
5371 dynamic_cast < type-id > ( expression )
5372 static_cast < type-id > ( expression )
5373 reinterpret_cast < type-id > ( expression )
5374 const_cast < type-id > ( expression )
5375 typeid ( expression )
5376 typeid ( type-id )
5378 GNU Extension:
5380 postfix-expression:
5381 ( type-id ) { initializer-list , [opt] }
5383 This extension is a GNU version of the C99 compound-literal
5384 construct. (The C99 grammar uses `type-name' instead of `type-id',
5385 but they are essentially the same concept.)
5387 If ADDRESS_P is true, the postfix expression is the operand of the
5388 `&' operator. CAST_P is true if this expression is the target of a
5389 cast.
5391 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
5392 class member access expressions [expr.ref].
5394 Returns a representation of the expression. */
5396 static tree
5400 {
5407 /* Peek at the next token. */
5409 /* Some of the productions are determined by keywords. */
5412 {
5417 {
5418 tree type;
5419 tree expression;
5422 /* All of these can be handled in the same way from the point
5423 of view of parsing. Begin by consuming the token
5424 identifying the cast. */
5427 /* New types cannot be defined in the cast. */
5429 parser->type_definition_forbidden_message
5432 /* Look for the opening `<'. */
5434 /* Parse the type to which we are casting. */
5436 /* Look for the closing `>'. */
5438 /* Restore the old message. */
5441 bool saved_greater_than_is_operator_p
5445 /* And the expression which is being cast. */
5450 parser->greater_than_is_operator_p
5453 /* Only type conversions to integral or enumeration types
5454 can be used in constant-expressions. */
5460 {
5462 postfix_expression
5466 postfix_expression
5470 postfix_expression
5472 tf_warning_or_error);
5475 postfix_expression
5480 }
5481 }
5485 {
5486 tree type;
5490 /* Consume the `typeid' token. */
5492 /* Look for the `(' token. */
5494 /* Types cannot be defined in a `typeid' expression. */
5496 parser->type_definition_forbidden_message
5498 /* We can't be sure yet whether we're looking at a type-id or an
5499 expression. */
5501 /* Try a type-id first. */
5506 /* Look for the `)' token. Otherwise, we can't be sure that
5507 we're not looking at an expression: consider `typeid (int
5508 (3))', for example. */
5510 /* If all went well, simply lookup the type-id. */
5513 /* Otherwise, fall back to the expression variant. */
5514 else
5515 {
5516 tree expression;
5518 /* Look for an expression. */
5520 /* Compute its typeid. */
5522 /* Look for the `)' token. */
5524 }
5525 /* Restore the saved message. */
5527 /* `typeid' may not appear in an integral constant expression. */
5530 }
5534 {
5535 tree type;
5536 /* The syntax permitted here is the same permitted for an
5537 elaborated-type-specifier. */
5542 }
5546 {
5549 tree p;
5566 else
5567 {
5571 }
5573 }
5576 {
5577 tree type;
5579 /* If the next thing is a simple-type-specifier, we may be
5580 looking at a functional cast. We could also be looking at
5581 an id-expression. So, we try the functional cast, and if
5582 that doesn't work we fall back to the primary-expression. */
5584 /* Look for the simple-type-specifier. */
5587 CP_PARSER_FLAGS_NONE);
5588 /* Parse the cast itself. */
5590 postfix_expression
5592 /* If that worked, we're done. */
5596 /* If the functional-cast didn't work out, try a
5597 compound-literal. */
5600 {
5605 /* Consume the `('. */
5607 /* Parse the type. */
5612 /* Look for the `)'. */
5614 /* Look for the `{'. */
5616 /* If things aren't going well, there's no need to
5617 keep going. */
5619 {
5621 /* Parse the initializer-list. */
5622 initializer_list
5624 /* Allow a trailing `,'. */
5627 /* Look for the final `}'. */
5629 }
5630 /* If that worked, we're definitely looking at a
5631 compound-literal expression. */
5633 {
5634 /* Warn the user that a compound literal is not
5635 allowed in standard C++. */
5637 /* For simplicity, we disallow compound literals in
5638 constant-expressions. We could
5639 allow compound literals of integer type, whose
5640 initializer was a constant, in constant
5641 expressions. Permitting that usage, as a further
5642 extension, would not change the meaning of any
5643 currently accepted programs. (Of course, as
5644 compound literals are not part of ISO C++, the
5645 standard has nothing to say.) */
5647 NIC_NCC))
5648 {
5651 }
5652 /* Form the representation of the compound-literal. */
5653 postfix_expression
5654 = (finish_compound_literal
5656 initializer_list),
5657 tf_warning_or_error));
5659 }
5660 }
5662 /* It must be a primary-expression. */
5663 postfix_expression
5666 decltype_p,
5668 }
5670 }
5672 /* Note that we don't need to worry about calling build_cplus_new on a
5673 class-valued CALL_EXPR in decltype when it isn't the end of the
5674 postfix-expression; unary_complex_lvalue will take care of that for
5675 all these cases. */
5677 /* Keep looping until the postfix-expression is complete. */
5679 {
5683 /* It is not a Koenig lookup function call. */
5684 postfix_expression
5687 /* Peek at the next token. */
5691 {
5694 {
5696 "two consecutive %<[%> shall "
5699 }
5700 postfix_expression
5702 postfix_expression,
5704 decltype_p);
5710 /* postfix-expression ( expression-list [opt] ) */
5711 {
5721 is_builtin_constant_p
5724 {
5725 /* The whole point of __builtin_constant_p is to allow
5726 non-constant expressions to appear as arguments. */
5727 saved_integral_constant_expression_p
5729 saved_non_integral_constant_expression_p
5732 }
5733 args = (cp_parser_parenthesized_expression_list
5738 {
5739 parser->integral_constant_expression_p
5741 parser->non_integral_constant_expression_p
5743 }
5746 {
5749 }
5751 /* Function calls are not permitted in
5752 constant-expressions. */
5755 NIC_FUNC_CALL))
5756 {
5760 }
5765 {
5767 {
5769 {
5772 postfix_expression
5775 complain);
5776 }
5777 else
5778 postfix_expression
5780 }
5781 /* We do not perform argument-dependent lookup if
5782 normal lookup finds a non-function, in accordance
5783 with the expected resolution of DR 218. */
5786 {
5790 /* Do not do argument dependent lookup if regular
5791 lookup finds a member function or a block-scope
5792 function declaration. [basic.lookup.argdep]/3 */
5795 {
5798 postfix_expression
5801 complain);
5802 }
5803 }
5804 }
5807 {
5817 {
5818 postfix_expression
5822 }
5825 {
5826 postfix_expression
5827 = (build_new_method_call
5833 complain));
5834 }
5835 else
5836 postfix_expression
5840 complain);
5841 }
5845 postfix_expression = (build_offset_ref_call_from_tree
5847 complain));
5849 /* A call to a static class member, or a namespace-scope
5850 function. */
5851 postfix_expression
5854 koenig_p,
5855 complain);
5856 else
5857 /* All other function calls. */
5858 postfix_expression
5861 koenig_p,
5862 complain);
5864 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
5868 }
5873 /* postfix-expression . template [opt] id-expression
5874 postfix-expression . pseudo-destructor-name
5875 postfix-expression -> template [opt] id-expression
5876 postfix-expression -> pseudo-destructor-name */
5878 /* Consume the `.' or `->' operator. */
5881 postfix_expression
5883 postfix_expression,
5891 /* postfix-expression ++ */
5892 /* Consume the `++' token. */
5894 /* Generate a representation for the complete expression. */
5895 postfix_expression
5897 POSTINCREMENT_EXPR);
5898 /* Increments may not appear in constant-expressions. */
5906 /* postfix-expression -- */
5907 /* Consume the `--' token. */
5909 /* Generate a representation for the complete expression. */
5910 postfix_expression
5912 POSTDECREMENT_EXPR);
5913 /* Decrements may not appear in constant-expressions. */
5925 else
5927 }
5928 }
5930 /* We should never get here. */
5933 }
5935 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
5936 by cp_parser_builtin_offsetof. We're looking for
5938 postfix-expression [ expression ]
5939 postfix-expression [ braced-init-list ] (C++11)
5941 FOR_OFFSETOF is set if we're being called in that context, which
5942 changes how we deal with integer constant expressions. */
5944 static tree
5946 tree postfix_expression,
5949 {
5950 tree index;
5953 /* Consume the `[' token. */
5956 /* Parse the index expression. */
5957 /* ??? For offsetof, there is a question of what to allow here. If
5958 offsetof is not being used in an integral constant expression context,
5959 then we *could* get the right answer by computing the value at runtime.
5960 If we are in an integral constant expression context, then we might
5961 could accept any constant expression; hard to say without analysis.
5962 Rather than open the barn door too wide right away, allow only integer
5963 constant expressions here. */
5966 else
5967 {
5969 {
5973 }
5974 else
5976 }
5978 /* Look for the closing `]'. */
5981 /* Build the ARRAY_REF. */
5985 /* When not doing offsetof, array references are not permitted in
5986 constant-expressions. */
5992 }
5994 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
5995 by cp_parser_builtin_offsetof. We're looking for
5997 postfix-expression . template [opt] id-expression
5998 postfix-expression . pseudo-destructor-name
5999 postfix-expression -> template [opt] id-expression
6000 postfix-expression -> pseudo-destructor-name
6002 FOR_OFFSETOF is set if we're being called in that context. That sorta
6003 limits what of the above we'll actually accept, but nevermind.
6004 TOKEN_TYPE is the "." or "->" token, which will already have been
6005 removed from the stream. */
6007 static tree
6010 tree postfix_expression,
6012 location_t location)
6013 {
6014 tree name;
6019 /* If this is a `->' operator, dereference the pointer. */
6022 tf_warning_or_error);
6023 /* Check to see whether or not the expression is type-dependent. */
6025 /* The identifier following the `->' or `.' is not qualified. */
6031 /* Enter the scope corresponding to the type of the object
6032 given by the POSTFIX_EXPRESSION. */
6034 {
6036 /* According to the standard, no expression should ever have
6037 reference type. Unfortunately, we do not currently match
6038 the standard in this respect in that our internal representation
6039 of an expression may have reference type even when the standard
6040 says it does not. Therefore, we have to manually obtain the
6041 underlying type here. */
6043 /* The type of the POSTFIX_EXPRESSION must be complete. */
6045 {
6047 postfix_expression);
6049 }
6050 /* Unlike the object expression in other contexts, *this is not
6051 required to be of complete type for purposes of class member
6052 access (5.2.5) outside the member function body. */
6056 /* Let the name lookup machinery know that we are processing a
6057 class member access expression. */
6059 /* If something went wrong, we want to be able to discern that case,
6060 as opposed to the case where there was no SCOPE due to the type
6061 of expression being dependent. */
6064 /* If the SCOPE was erroneous, make the various semantic analysis
6065 functions exit quickly -- and without issuing additional error
6066 messages. */
6069 }
6071 /* Assume this expression is not a pseudo-destructor access. */
6074 /* If the SCOPE is a scalar type, then, if this is a valid program,
6075 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
6076 is type dependent, it can be pseudo-destructor-name or something else.
6077 Try to parse it as pseudo-destructor-name first. */
6079 {
6080 tree s;
6081 tree type;
6084 /* Parse the pseudo-destructor-name. */
6093 {
6095 postfix_expression
6098 }
6099 }
6102 {
6103 /* If the SCOPE is not a scalar type, we are looking at an
6104 ordinary class member access expression, rather than a
6105 pseudo-destructor-name. */
6108 /* Parse the id-expression. */
6109 name = (cp_parser_id_expression
6116 /* In general, build a SCOPE_REF if the member name is qualified.
6117 However, if the name was not dependent and has already been
6118 resolved; there is no need to build the SCOPE_REF. For example;
6120 struct X { void f(); };
6121 template <typename T> void f(T* t) { t->X::f(); }
6123 Even though "t" is dependent, "X::f" is not and has been resolved
6124 to a BASELINK; there is no need to include scope information. */
6126 /* But we do need to remember that there was an explicit scope for
6127 virtual function calls. */
6131 /* If the name is a template-id that names a type, we will get a
6132 TYPE_DECL here. That is invalid code. */
6134 {
6137 }
6138 else
6139 {
6141 {
6143 {
6147 }
6148 else
6151 name,
6152 template_p);
6156 }
6158 adjust_result_of_qualified_name_lookup
6160 postfix_expression
6162 template_p,
6163 tf_warning_or_error);
6164 }
6165 }
6167 /* We no longer need to look up names in the scope of the object on
6168 the left-hand side of the `.' or `->' operator. */
6171 /* Outside of offsetof, these operators may not appear in
6172 constant-expressions. */
6174 && (cp_parser_non_integral_constant_expression
6179 }
6181 /* Parse a parenthesized expression-list.
6183 expression-list:
6184 assignment-expression
6185 expression-list, assignment-expression
6187 attribute-list:
6188 expression-list
6189 identifier
6190 identifier, expression-list
6192 CAST_P is true if this expression is the target of a cast.
6194 ALLOW_EXPANSION_P is true if this expression allows expansion of an
6195 argument pack.
6197 Returns a vector of trees. Each element is a representation of an
6198 assignment-expression. NULL is returned if the ( and or ) are
6199 missing. An empty, but allocated, vector is returned on no
6200 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
6201 if we are parsing an attribute list for an attribute that wants a
6202 plain identifier argument, normal_attr for an attribute that wants
6203 an expression, or non_attr if we aren't parsing an attribute list. If
6204 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
6205 not all of the expressions in the list were constant. */
6213 {
6219 /* Assume all the expressions will be constant. */
6228 /* Within a parenthesized expression, a `>' token is always
6229 the greater-than operator. */
6230 saved_greater_than_is_operator_p
6234 /* Consume expressions until there are no more. */
6237 {
6238 tree expr;
6240 /* At the beginning of attribute lists, check to see if the
6241 next token is an identifier. */
6244 {
6247 /* Consume the identifier. */
6249 /* Save the identifier. */
6251 }
6252 else
6253 {
6256 /* Parse the next assignment-expression. */
6258 {
6259 /* A braced-init-list. */
6264 }
6266 {
6267 expr = (cp_parser_constant_expression
6272 }
6273 else
6279 /* If we have an ellipsis, then this is an expression
6280 expansion. */
6283 {
6284 /* Consume the `...'. */
6287 /* Build the argument pack. */
6289 }
6291 /* Add it to the list. We add error_mark_node
6292 expressions to the list, so that we can still tell if
6293 the correct form for a parenthesized expression-list
6294 is found. That gives better errors. */
6299 }
6301 /* After the first item, attribute lists look the same as
6302 expression lists. */
6305 get_comma:;
6306 /* If the next token isn't a `,', then we are done. */
6310 /* Otherwise, consume the `,' and keep going. */
6312 }
6315 {
6318 skip_comma:;
6319 /* We try and resync to an unnested comma, as that will give the
6320 user better diagnostics. */
6328 {
6329 parser->greater_than_is_operator_p
6332 }
6333 }
6335 parser->greater_than_is_operator_p
6342 }
6344 /* Parse a pseudo-destructor-name.
6346 pseudo-destructor-name:
6347 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
6348 :: [opt] nested-name-specifier template template-id :: ~ type-name
6349 :: [opt] nested-name-specifier [opt] ~ type-name
6351 If either of the first two productions is used, sets *SCOPE to the
6352 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
6353 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
6354 or ERROR_MARK_NODE if the parse fails. */
6356 static void
6360 {
6363 /* Assume that things will not work out. */
6366 /* Look for the optional `::' operator. */
6368 /* Look for the optional nested-name-specifier. */
6369 nested_name_specifier_p
6376 /* Now, if we saw a nested-name-specifier, we might be doing the
6377 second production. */
6380 {
6381 /* Consume the `template' keyword. */
6383 /* Parse the template-id. */
6387 class_type,
6389 /* Look for the `::' token. */
6391 }
6392 /* If the next token is not a `~', then there might be some
6393 additional qualification. */
6395 {
6396 /* At this point, we're looking for "type-name :: ~". The type-name
6397 must not be a class-name, since this is a pseudo-destructor. So,
6398 it must be either an enum-name, or a typedef-name -- both of which
6399 are just identifiers. So, we peek ahead to check that the "::"
6400 and "~" tokens are present; if they are not, then we can avoid
6401 calling type_name. */
6405 {
6408 }
6410 /* Look for the type-name. */
6415 /* Look for the `::' token. */
6417 }
6418 else
6421 /* Look for the `~'. */
6424 /* Look for the type-name again. We are not responsible for
6425 checking that it matches the first type-name. */
6427 }
6429 /* Parse a unary-expression.
6431 unary-expression:
6432 postfix-expression
6433 ++ cast-expression
6434 -- cast-expression
6435 unary-operator cast-expression
6436 sizeof unary-expression
6437 sizeof ( type-id )
6438 alignof ( type-id ) [C++0x]
6439 new-expression
6440 delete-expression
6442 GNU Extensions:
6444 unary-expression:
6445 __extension__ cast-expression
6446 __alignof__ unary-expression
6447 __alignof__ ( type-id )
6448 alignof unary-expression [C++0x]
6449 __real__ cast-expression
6450 __imag__ cast-expression
6451 && identifier
6453 ADDRESS_P is true iff the unary-expression is appearing as the
6454 operand of the `&' operator. CAST_P is true if this expression is
6455 the target of a cast.
6457 Returns a representation of the expression. */
6459 static tree
6462 {
6466 /* Peek at the next token. */
6468 /* Some keywords give away the kind of expression. */
6470 {
6474 {
6477 {
6480 location_t first_loc;
6483 /* Consume the token. */
6486 /* Parse the operand. */
6491 else
6492 {
6493 /* ISO C++ defines alignof only with types, not with
6494 expressions. So pedwarn if alignof is used with a non-
6495 type expression. However, __alignof__ is ok. */
6498 "ISO C++ does not allow %<alignof%> "
6502 }
6503 /* For SIZEOF_EXPR, just issue diagnostics, but keep
6504 SIZEOF_EXPR with the original operand. */
6506 {
6508 {
6510 {
6513 error_mark_node));
6515 }
6516 else
6520 }
6522 }
6524 }
6533 {
6534 /* The saved value of the PEDANTIC flag. */
6536 tree expr;
6538 /* Save away the PEDANTIC flag. */
6540 /* Parse the cast-expression. */
6542 /* Restore the PEDANTIC flag. */
6546 }
6550 {
6551 tree expression;
6553 /* Consume the `__real__' or `__imag__' token. */
6555 /* Parse the cast-expression. */
6557 /* Create the complete representation. */
6561 expression,
6562 tf_warning_or_error);
6563 }
6571 {
6572 tree expr;
6582 parser->type_definition_forbidden_message
6585 saved_integral_constant_expression_p
6587 saved_non_integral_constant_expression_p
6591 saved_greater_than_is_operator_p
6601 parser->greater_than_is_operator_p
6604 parser->integral_constant_expression_p
6606 parser->non_integral_constant_expression_p
6613 }
6617 }
6618 }
6620 /* Look for the `:: new' and `:: delete', which also signal the
6621 beginning of a new-expression, or delete-expression,
6622 respectively. If the next token is `::', then it might be one of
6623 these. */
6625 {
6628 /* See if the token after the `::' is one of the keywords in
6629 which we're interested. */
6631 /* If it's `new', we have a new-expression. */
6634 /* Similarly, for `delete'. */
6637 }
6639 /* Look for a unary operator. */
6641 /* The `++' and `--' operators can be handled similarly, even though
6642 they are not technically unary-operators in the grammar. */
6644 {
6649 /* Handle the GNU address-of-label extension. */
6652 {
6653 tree identifier;
6654 tree expression;
6657 /* Consume the '&&' token. */
6659 /* Look for the identifier. */
6661 /* Create an expression representing the address. */
6664 NIC_ADDR_LABEL))
6667 }
6668 }
6670 {
6671 tree cast_expression;
6677 /* Consume the operator token. */
6679 /* Parse the cast-expression. */
6680 cast_expression
6685 pidk);
6686 /* Now, build an appropriate representation. */
6688 {
6692 RO_UNARY_STAR,
6693 complain);
6698 /* Fall through. */
6701 cast_expression,
6702 complain);
6709 /* Fall through. */
6719 }
6723 non_constant_p))
6727 }
6731 decltype_p,
6732 pidk);
6733 }
6738 {
6741 }
6743 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
6744 unary-operator, the corresponding tree code is returned. */
6746 static enum tree_code
6748 {
6750 {
6771 }
6772 }
6774 /* Parse a new-expression.
6776 new-expression:
6777 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
6778 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
6780 Returns a representation of the expression. */
6782 static tree
6784 {
6787 tree type;
6790 tree ret;
6792 /* Look for the optional `::' operator. */
6793 global_scope_p
6797 /* Look for the `new' operator. */
6799 /* There's no easy way to tell a new-placement from the
6800 `( type-id )' construct. */
6802 /* Look for a new-placement. */
6804 /* If that didn't work out, there's no new-placement. */
6806 {
6810 }
6812 /* If the next token is a `(', then we have a parenthesized
6813 type-id. */
6815 {
6819 /* Consume the `('. */
6822 /* Parse the type-id. */
6823 parser->type_definition_forbidden_message
6828 /* Look for the closing `)'. */
6831 /* There should not be a direct-new-declarator in this production,
6832 but GCC used to allowed this, so we check and emit a sensible error
6833 message for this case. */
6835 {
6841 }
6842 }
6843 /* Otherwise, there must be a new-type-id. */
6844 else
6847 /* If the next token is a `(' or '{', then we have a new-initializer. */
6851 else
6854 /* A new-expression may not appear in an integral constant
6855 expression. */
6858 else
6859 {
6860 /* Create a representation of the new-expression. */
6862 tf_warning_or_error);
6863 }
6871 }
6873 /* Parse a new-placement.
6875 new-placement:
6876 ( expression-list )
6878 Returns the same representation as for an expression-list. */
6882 {
6885 /* Parse the expression-list. */
6886 expression_list = (cp_parser_parenthesized_expression_list
6892 }
6894 /* Parse a new-type-id.
6896 new-type-id:
6897 type-specifier-seq new-declarator [opt]
6899 Returns the TYPE allocated. If the new-type-id indicates an array
6900 type, *NELTS is set to the number of elements in the last array
6901 bound; the TYPE will not include the last array bound. */
6903 static tree
6905 {
6906 cp_decl_specifier_seq type_specifier_seq;
6912 /* The type-specifier sequence must not contain type definitions.
6913 (It cannot contain declarations of new types either, but if they
6914 are not definitions we will catch that because they are not
6915 complete.) */
6917 parser->type_definition_forbidden_message
6919 /* Parse the type-specifier-seq. */
6923 /* Restore the old message. */
6929 /* Parse the new-declarator. */
6932 /* Determine the number of elements in the last array dimension, if
6933 any. */
6935 /* Skip down to the last array dimension. */
6940 {
6943 }
6948 {
6951 }
6954 {
6961 else
6963 }
6966 }
6968 /* Parse an (optional) new-declarator.
6970 new-declarator:
6971 ptr-operator new-declarator [opt]
6972 direct-new-declarator
6974 Returns the declarator. */
6978 {
6981 cp_cv_quals cv_quals;
6983 /* We don't know if there's a ptr-operator next, or not. */
6985 /* Look for a ptr-operator. */
6987 /* If that worked, look for more new-declarators. */
6989 {
6992 /* Parse another optional declarator. */
6995 declarator = cp_parser_make_indirect_declarator
6999 }
7001 /* If the next token is a `[', there is a direct-new-declarator. */
7006 }
7008 /* Parse a direct-new-declarator.
7010 direct-new-declarator:
7011 [ expression ]
7012 direct-new-declarator [constant-expression]
7014 */
7018 {
7022 {
7023 tree expression;
7026 /* Look for the opening `['. */
7031 /* The standard requires that the expression have integral
7032 type. DR 74 adds enumeration types. We believe that the
7033 real intent is that these expressions be handled like the
7034 expression in a `switch' condition, which also allows
7035 classes with a single conversion to integral or
7036 enumeration type. */
7038 {
7039 expression
7041 expression,
7044 {
7046 "expression in new-declarator must have integral "
7049 }
7050 }
7052 /* Look for the closing `]'. */
7055 /* Add this bound to the declarator. */
7058 /* If the next token is not a `[', then there are no more
7059 bounds. */
7062 }
7065 }
7067 /* Parse a new-initializer.
7069 new-initializer:
7070 ( expression-list [opt] )
7071 braced-init-list
7073 Returns a representation of the expression-list. */
7077 {
7081 {
7082 tree t;
7088 }
7089 else
7090 expression_list = (cp_parser_parenthesized_expression_list
7096 }
7098 /* Parse a delete-expression.
7100 delete-expression:
7101 :: [opt] delete cast-expression
7102 :: [opt] delete [ ] cast-expression
7104 Returns a representation of the expression. */
7106 static tree
7108 {
7111 tree expression;
7113 /* Look for the optional `::' operator. */
7114 global_scope_p
7118 /* Look for the `delete' keyword. */
7120 /* See if the array syntax is in use. */
7122 {
7123 /* Consume the `[' token. */
7125 /* Look for the `]' token. */
7127 /* Remember that this is the `[]' construct. */
7129 }
7130 else
7133 /* Parse the cast-expression. */
7136 /* A delete-expression may not appear in an integral constant
7137 expression. */
7142 tf_warning_or_error);
7143 }
7145 /* Returns true if TOKEN may start a cast-expression and false
7146 otherwise. */
7148 static bool
7150 {
7153 {
7193 /* In ((type ()) () the last () isn't a valid cast-expression,
7194 so the whole must be parsed as postfix-expression. */
7198 /* '[' may start a primary-expression in obj-c++. */
7204 }
7205 }
7207 /* Parse a cast-expression.
7209 cast-expression:
7210 unary-expression
7211 ( type-id ) cast-expression
7213 ADDRESS_P is true iff the unary-expression is appearing as the
7214 operand of the `&' operator. CAST_P is true if this expression is
7215 the target of a cast.
7217 Returns a representation of the expression. */
7219 static tree
7222 {
7223 /* If it's a `(', then we might be looking at a cast. */
7225 {
7231 /* There's no way to know yet whether or not this is a cast.
7232 For example, `(int (3))' is a unary-expression, while `(int)
7233 3' is a cast. So, we resort to parsing tentatively. */
7235 /* Types may not be defined in a cast. */
7237 parser->type_definition_forbidden_message
7239 /* Consume the `('. */
7241 /* A very tricky bit is that `(struct S) { 3 }' is a
7242 compound-literal (which we permit in C++ as an extension).
7243 But, that construct is not a cast-expression -- it is a
7244 postfix-expression. (The reason is that `(struct S) { 3 }.i'
7245 is legal; if the compound-literal were a cast-expression,
7246 you'd need an extra set of parentheses.) But, if we parse
7247 the type-id, and it happens to be a class-specifier, then we
7248 will commit to the parse at that point, because we cannot
7249 undo the action that is done when creating a new class. So,
7250 then we cannot back up and do a postfix-expression.
7252 Therefore, we scan ahead to the closing `)', and check to see
7253 if the token after the `)' is a `{'. If so, we are not
7254 looking at a cast-expression.
7256 Save tokens so that we can put them back. */
7258 /* Skip tokens until the next token is a closing parenthesis.
7259 If we find the closing `)', and the next token is a `{', then
7260 we are looking at a compound-literal. */
7261 compound_literal_p
7265 /* Roll back the tokens we skipped. */
7267 /* If we were looking at a compound-literal, simulate an error
7268 so that the call to cp_parser_parse_definitely below will
7269 fail. */
7272 else
7273 {
7276 /* Look for the type-id. */
7278 /* Look for the closing `)'. */
7281 }
7283 /* Restore the saved message. */
7286 /* At this point this can only be either a cast or a
7287 parenthesized ctor such as `(T ())' that looks like a cast to
7288 function returning T. */
7291 {
7297 pidk);
7299 /* Warn about old-style casts, if so requested. */
7301 && !in_system_header
7306 /* Only type conversions to integral or enumeration types
7307 can be used in constant-expressions. */
7310 NIC_CAST))
7313 /* Perform the cast. */
7316 }
7317 else
7319 }
7321 /* If we get here, then it's not a cast, so it must be a
7322 unary-expression. */
7325 }
7327 /* Parse a binary expression of the general form:
7329 pm-expression:
7330 cast-expression
7331 pm-expression .* cast-expression
7332 pm-expression ->* cast-expression
7334 multiplicative-expression:
7335 pm-expression
7336 multiplicative-expression * pm-expression
7337 multiplicative-expression / pm-expression
7338 multiplicative-expression % pm-expression
7340 additive-expression:
7341 multiplicative-expression
7342 additive-expression + multiplicative-expression
7343 additive-expression - multiplicative-expression
7345 shift-expression:
7346 additive-expression
7347 shift-expression << additive-expression
7348 shift-expression >> additive-expression
7350 relational-expression:
7351 shift-expression
7352 relational-expression < shift-expression
7353 relational-expression > shift-expression
7354 relational-expression <= shift-expression
7355 relational-expression >= shift-expression
7357 GNU Extension:
7359 relational-expression:
7360 relational-expression <? shift-expression
7361 relational-expression >? shift-expression
7363 equality-expression:
7364 relational-expression
7365 equality-expression == relational-expression
7366 equality-expression != relational-expression
7368 and-expression:
7369 equality-expression
7370 and-expression & equality-expression
7372 exclusive-or-expression:
7373 and-expression
7374 exclusive-or-expression ^ and-expression
7376 inclusive-or-expression:
7377 exclusive-or-expression
7378 inclusive-or-expression | exclusive-or-expression
7380 logical-and-expression:
7381 inclusive-or-expression
7382 logical-and-expression && inclusive-or-expression
7384 logical-or-expression:
7385 logical-and-expression
7386 logical-or-expression || logical-and-expression
7388 All these are implemented with a single function like:
7390 binary-expression:
7391 simple-cast-expression
7392 binary-expression <token> binary-expression
7394 CAST_P is true if this expression is the target of a cast.
7396 The binops_by_token map is used to get the tree codes for each <token> type.
7397 binary-expressions are associated according to a precedence table. */
7399 #define TOKEN_PRECEDENCE(token) \
7400 (((token->type == CPP_GREATER \
7401 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
7402 && !parser->greater_than_is_operator_p) \
7403 ? PREC_NOT_OPERATOR \
7404 : binops_by_token[token->type].prec)
7406 static tree
7412 {
7413 cp_parser_expression_stack stack;
7415 cp_parser_expression_stack_entry current;
7416 tree rhs;
7420 tree overload;
7422 /* Parse the first expression. */
7432 {
7433 /* Get an operator token. */
7439 {
7441 "%<>>%> operator is treated"
7445 }
7449 /* Popping an entry off the stack means we completed a subexpression:
7450 - either we found a token which is not an operator (`>' where it is not
7451 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
7452 will happen repeatedly;
7453 - or, we found an operator which has lower priority. This is the case
7454 where the recursive descent *ascends*, as in `3 * 4 + 5' after
7455 parsing `3 * 4'. */
7457 {
7460 else
7462 }
7464 get_rhs:
7468 /* We used the operator token. */
7471 /* For "false && x" or "true || x", x will never be executed;
7472 disable warnings while evaluating it. */
7478 /* Extract another operand. It may be the RHS of this expression
7479 or the LHS of a new, higher priority expression. */
7483 /* Get another operator token. Look up its precedence to avoid
7484 building a useless (immediately popped) stack entry for common
7485 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
7489 {
7490 /* ... and prepare to parse the RHS of the new, higher priority
7491 expression. Since precedence levels on the stack are
7492 monotonically increasing, we do not have to care about
7493 stack overflows. */
7502 pop:
7504 /* If the stack is not empty, we have parsed into LHS the right side
7505 (`4' in the example above) of an expression we had suspended.
7506 We can use the information on the stack to recover the LHS (`3')
7507 from the stack together with the tree code (`MULT_EXPR'), and
7508 the precedence of the higher level subexpression
7509 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
7510 which will be used to actually build the additive expression. */
7515 }
7517 /* Undo the disabling of warnings done above. */
7524 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
7525 ERROR_MARK for everything that is not a binary expression.
7526 This makes warn_about_parentheses miss some warnings that
7527 involve unary operators. For unary expressions we should
7528 pass the correct tree_code unless the unary expression was
7529 surrounded by parentheses.
7530 */
7537 else
7546 /* If the binary operator required the use of an overloaded operator,
7547 then this expression cannot be an integral constant-expression.
7548 An overloaded operator can be used even if both operands are
7549 otherwise permissible in an integral constant-expression if at
7550 least one of the operands is of enumeration type. */
7554 NIC_OVERLOADED))
7556 }
7559 }
7561 static tree
7566 {
7569 }
7571 /* Parse the `? expression : assignment-expression' part of a
7572 conditional-expression. The LOGICAL_OR_EXPR is the
7573 logical-or-expression that started the conditional-expression.
7574 Returns a representation of the entire conditional-expression.
7576 This routine is used by cp_parser_assignment_expression.
7578 ? expression : assignment-expression
7580 GNU Extensions:
7582 ? : assignment-expression */
7584 static tree
7586 {
7587 tree expr;
7588 tree assignment_expr;
7592 /* Consume the `?' token. */
7597 {
7600 /* Implicit true clause. */
7604 }
7605 else
7606 {
7609 /* Parse the expression. */
7612 c_inhibit_evaluation_warnings +=
7616 }
7618 /* The next token should be a `:'. */
7620 /* Parse the assignment-expression. */
7624 /* Build the conditional-expression. */
7626 expr,
7627 assignment_expr,
7628 tf_warning_or_error);
7629 }
7631 /* Parse an assignment-expression.
7633 assignment-expression:
7634 conditional-expression
7635 logical-or-expression assignment-operator assignment_expression
7636 throw-expression
7638 CAST_P is true if this expression is the target of a cast.
7639 DECLTYPE_P is true if this expression is the operand of decltype.
7641 Returns a representation for the expression. */
7643 static tree
7646 {
7647 tree expr;
7649 /* If the next token is the `throw' keyword, then we're looking at
7650 a throw-expression. */
7653 /* Otherwise, it must be that we are looking at a
7654 logical-or-expression. */
7655 else
7656 {
7657 /* Parse the binary expressions (logical-or-expression). */
7659 decltype_p,
7661 /* If the next token is a `?' then we're actually looking at a
7662 conditional-expression. */
7665 else
7666 {
7669 /* If it's an assignment-operator, we're using the second
7670 production. */
7671 enum tree_code assignment_operator
7674 {
7676 location_t saved_input_location;
7678 /* Parse the right-hand side of the assignment. */
7684 /* An assignment may not appear in a
7685 constant-expression. */
7687 NIC_ASSIGNMENT))
7689 /* Build the assignment expression. Its default
7690 location is the location of the '=' token. */
7694 assignment_operator,
7695 rhs,
7698 }
7699 }
7700 }
7703 }
7705 static tree
7708 {
7711 }
7713 /* Parse an (optional) assignment-operator.
7715 assignment-operator: one of
7716 = *= /= %= += -= >>= <<= &= ^= |=
7718 GNU Extension:
7720 assignment-operator: one of
7721 <?= >?=
7723 If the next token is an assignment operator, the corresponding tree
7724 code is returned, and the token is consumed. For example, for
7725 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
7726 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
7727 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
7728 operator, ERROR_MARK is returned. */
7730 static enum tree_code
7732 {
7736 /* Peek at the next token. */
7740 {
7786 /* Nothing else is an assignment operator. */
7788 }
7790 /* If it was an assignment operator, consume it. */
7795 }
7797 /* Parse an expression.
7799 expression:
7800 assignment-expression
7801 expression , assignment-expression
7803 CAST_P is true if this expression is the target of a cast.
7804 DECLTYPE_P is true if this expression is the immediate operand of decltype,
7805 except possibly parenthesized or on the RHS of a comma (N3276).
7807 Returns a representation of the expression. */
7809 static tree
7812 {
7817 {
7818 tree assignment_expression;
7820 /* Parse the next assignment-expression. */
7821 assignment_expression
7824 /* We don't create a temporary for a call that is the immediate operand
7825 of decltype or on the RHS of a comma. But when we see a comma, we
7826 need to create a temporary for a call on the LHS. */
7831 assignment_expression
7835 /* If this is the first assignment-expression, we can just
7836 save it away. */
7839 else
7841 assignment_expression,
7843 /* If the next token is not a comma, then we are done with the
7844 expression. */
7847 /* Consume the `,'. */
7850 /* A comma operator cannot appear in a constant-expression. */
7853 }
7856 }
7860 {
7862 }
7864 /* Parse a constant-expression.
7866 constant-expression:
7867 conditional-expression
7869 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
7870 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
7871 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
7872 is false, NON_CONSTANT_P should be NULL. */
7874 static tree
7878 {
7882 tree expression;
7884 /* It might seem that we could simply parse the
7885 conditional-expression, and then check to see if it were
7886 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
7887 one that the compiler can figure out is constant, possibly after
7888 doing some simplifications or optimizations. The standard has a
7889 precise definition of constant-expression, and we must honor
7890 that, even though it is somewhat more restrictive.
7892 For example:
7894 int i[(2, 3)];
7896 is not a legal declaration, because `(2, 3)' is not a
7897 constant-expression. The `,' operator is forbidden in a
7898 constant-expression. However, GCC's constant-folding machinery
7899 will fold this operation to an INTEGER_CST for `3'. */
7901 /* Save the old settings. */
7903 saved_allow_non_integral_constant_expression_p
7906 /* We are now parsing a constant-expression. */
7908 parser->allow_non_integral_constant_expression_p
7911 /* Although the grammar says "conditional-expression", we parse an
7912 "assignment-expression", which also permits "throw-expression"
7913 and the use of assignment operators. In the case that
7914 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
7915 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
7916 actually essential that we look for an assignment-expression.
7917 For example, cp_parser_initializer_clauses uses this function to
7918 determine whether a particular assignment-expression is in fact
7919 constant. */
7921 /* Restore the old settings. */
7922 parser->integral_constant_expression_p
7924 parser->allow_non_integral_constant_expression_p
7927 {
7928 /* Require an rvalue constant expression here; that's what our
7929 callers expect. Reference constant expressions are handled
7930 separately in e.g. cp_parser_template_argument. */
7935 }
7938 parser->non_integral_constant_expression_p
7942 }
7944 /* Parse __builtin_offsetof.
7946 offsetof-expression:
7947 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
7949 offsetof-member-designator:
7950 id-expression
7951 | offsetof-member-designator "." id-expression
7952 | offsetof-member-designator "[" expression "]"
7953 | offsetof-member-designator "->" id-expression */
7955 static tree
7957 {
7960 cp_id_kind dummy;
7963 /* We're about to accept non-integral-constant things, but will
7964 definitely yield an integral constant expression. Save and
7965 restore these values around our local parsing. */
7969 /* Consume the "__builtin_offsetof" token. */
7971 /* Consume the opening `('. */
7973 /* Parse the type-id. */
7975 /* Look for the `,'. */
7979 /* Build the (type *)null that begins the traditional offsetof macro. */
7981 tf_warning_or_error);
7983 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
7987 {
7990 {
7992 /* offsetof-member-designator "[" expression "]" */
7998 /* offsetof-member-designator "->" identifier */
8001 /* FALLTHRU */
8004 /* offsetof-member-designator "." identifier */
8012 /* Consume the ")" token. */
8017 /* Error. We know the following require will fail, but
8018 that gives the proper error message. */
8023 }
8024 }
8026 success:
8027 /* If we're processing a template, we can't finish the semantics yet.
8028 Otherwise we can fold the entire expression now. */
8031 else
8034 failure:
8039 }
8041 /* Parse a trait expression.
8043 Returns a representation of the expression, the underlying type
8044 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
8046 static tree
8048 {
8049 cp_trait_kind kind;
8052 cp_decl_specifier_seq decl_specs;
8055 {
8132 }
8134 /* Consume the token. */
8144 /* Build a trivial decl-specifier-seq. */
8148 /* Call grokdeclarator to figure out what type this is. */
8153 {
8161 /* Build a trivial decl-specifier-seq. */
8165 /* Call grokdeclarator to figure out what type this is. */
8168 }
8172 /* Complete the trait expression, which may mean either processing
8173 the trait expr now or saving it for template instantiation. */
8175 {
8184 }
8185 }
8187 /* Lambdas that appear in variable initializer or default argument scope
8188 get that in their mangling, so we need to record it. We might as well
8189 use the count for function and namespace scopes as well. */
8193 {
8194 tree t;
8199 static void
8201 {
8202 tree_int ti;
8204 /* Once we're inside a function, we ignore other scopes and just push
8205 the function again so that popping works properly. */
8212 {
8213 /* Don't reset the count if we're still in the same function. */
8216 }
8217 }
8219 static void
8221 {
8224 }
8226 static void
8228 {
8231 {
8234 }
8236 }
8238 /* Parse a lambda expression.
8240 lambda-expression:
8241 lambda-introducer lambda-declarator [opt] compound-statement
8243 Returns a representation of the expression. */
8245 static tree
8247 {
8249 tree type;
8259 /* We may be in the middle of deferred access check. Disable
8260 it now. */
8271 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
8274 /* Now that we've started the type, add the capture fields for any
8275 explicit captures. */
8278 {
8279 /* Inside the class, surrounding template-parameter-lists do not apply. */
8280 unsigned int saved_num_template_parameter_lists
8289 /* By virtue of defining a local class, a lambda expression has access to
8290 the private variables of enclosing classes. */
8299 /* The capture list was built up in reverse order; fix that now. */
8300 {
8306 {
8310 }
8312 }
8322 }
8326 /* This field is only used during parsing of the lambda. */
8329 /* This lambda shouldn't have any proxies left at this point. */
8331 /* And now that we're done, push proxies for an enclosing lambda. */
8336 else
8338 }
8340 /* Parse the beginning of a lambda expression.
8342 lambda-introducer:
8343 [ lambda-capture [opt] ]
8345 LAMBDA_EXPR is the current representation of the lambda expression. */
8347 static void
8349 {
8350 /* Need commas after the first capture. */
8353 /* Eat the leading `['. */
8356 /* Record default capture mode. "[&" "[=" "[&," "[=," */
8364 {
8367 }
8370 {
8372 tree capture_id;
8373 tree capture_init_expr;
8377 enum capture_kind_type
8378 {
8379 BY_COPY,
8380 BY_REFERENCE
8381 };
8385 {
8388 }
8392 else
8395 /* Possibly capture `this'. */
8397 {
8407 explicit_init_p);
8409 }
8411 /* Remember whether we want to capture as a reference or not. */
8413 {
8416 }
8418 /* Get the identifier. */
8423 /* Would be nice to have a cp_parser_skip_to_closing_x for general
8424 delimiters, but I modified this to stop on unnested ']' as well. It
8425 was already changed to stop on unnested '}', so the
8426 "closing_parenthesis" name is no more misleading with my change. */
8427 {
8433 }
8435 /* Find the initializer for this capture. */
8437 {
8438 /* An explicit expression exists. */
8441 "ISO C++ does not allow initializers "
8447 }
8448 else
8449 {
8452 /* Turn the identifier into an id-expression. */
8453 capture_init_expr
8454 = cp_parser_lookup_name
8456 capture_id,
8457 none_type,
8465 {
8468 }
8472 {
8475 capture_init_expr);
8478 }
8481 {
8484 capture_init_expr);
8487 }
8489 capture_init_expr
8490 = finish_id_expression
8492 capture_init_expr,
8504 }
8508 {
8513 capture_id);
8517 "capture of %qD redundant with by-reference capture "
8519 }
8522 capture_id,
8523 capture_init_expr,
8525 explicit_init_p);
8526 }
8529 }
8531 /* Parse the (optional) middle of a lambda expression.
8533 lambda-declarator:
8534 ( parameter-declaration-clause [opt] )
8535 attribute-specifier [opt]
8536 mutable [opt]
8537 exception-specification [opt]
8538 lambda-return-type-clause [opt]
8540 LAMBDA_EXPR is the current representation of the lambda expression. */
8542 static bool
8544 {
8545 /* 5.1.1.4 of the standard says:
8546 If a lambda-expression does not include a lambda-declarator, it is as if
8547 the lambda-declarator were ().
8548 This means an empty parameter list, no attributes, and no exception
8549 specification. */
8553 tree t;
8555 /* The lambda-declarator is optional, but must begin with an opening
8556 parenthesis if present. */
8558 {
8563 /* Parse parameters. */
8566 /* Default arguments shall not be specified in the
8567 parameter-declaration-clause of a lambda-declarator. */
8577 /* Parse optional `mutable' keyword. */
8579 {
8582 }
8584 /* Parse optional exception specification. */
8587 /* Parse optional trailing return type. */
8589 {
8592 }
8594 /* The function parameters must be in scope all the way until after the
8595 trailing-return-type in case of decltype. */
8600 }
8602 /* Create the function call operator.
8604 Messing with declarators like this is no uglier than building up the
8605 FUNCTION_DECL by hand, and this is less likely to get out of sync with
8606 other code. */
8607 {
8608 cp_decl_specifier_seq return_type_specs;
8610 tree fco;
8617 else
8618 /* Maybe we will deduce the return type later. */
8624 sfk_none);
8629 VIRT_SPEC_UNSPECIFIED,
8630 REF_QUAL_NONE,
8631 exception_spec,
8636 declarator,
8637 attributes);
8639 {
8642 /* Give the object parameter a different name. */
8644 }
8651 }
8652 }
8654 /* Parse the body of a lambda expression, which is simply
8656 compound-statement
8658 but which requires special handling.
8659 LAMBDA_EXPR is the current representation of the lambda expression. */
8661 static void
8663 {
8668 else
8669 /* Still increment function_depth so that we don't GC in the
8670 middle of an expression. */
8672 /* Clear this in case we're in the middle of a default argument. */
8675 /* Finish the function call operator
8676 - class_specifier
8677 + late_parsing_for_member
8678 + function_definition_after_declarator
8679 + ctor_initializer_opt_and_function_body */
8680 {
8682 tree body;
8684 tree compound_stmt;
8685 tree cap;
8687 /* Let the front end know that we are going to be defining this
8688 function. */
8690 NULL_TREE,
8699 /* Push the proxies for any explicit captures. */
8706 /* 5.1.1.4 of the standard says:
8707 If a lambda-expression does not include a trailing-return-type, it
8708 is as if the trailing-return-type denotes the following type:
8709 * if the compound-statement is of the form
8710 { return attribute-specifier [opt] expression ; }
8711 the type of the returned expression after lvalue-to-rvalue
8712 conversion (_conv.lval_ 4.1), array-to-pointer conversion
8713 (_conv.array_ 4.2), and function-to-pointer conversion
8714 (_conv.func_ 4.3);
8715 * otherwise, void. */
8717 /* In a lambda that has neither a lambda-return-type-clause
8718 nor a deducible form, errors should be reported for return statements
8719 in the body. Since we used void as the placeholder return type, parsing
8720 the body as usual will give such desired behavior. */
8724 {
8728 /* Parse tentatively in case there's more after the initial return
8729 statement. */
8740 {
8744 /* Will get error here if type not deduced yet. */
8748 }
8749 }
8752 {
8757 }
8761 out:
8765 /* Finish the function and generate code for it if necessary. */
8767 }
8772 else
8774 }
8776 /* Statements [gram.stmt.stmt] */
8778 /* Parse a statement.
8780 statement:
8781 labeled-statement
8782 expression-statement
8783 compound-statement
8784 selection-statement
8785 iteration-statement
8786 jump-statement
8787 declaration-statement
8788 try-block
8790 C++11:
8792 statement:
8793 labeled-statement
8794 attribute-specifier-seq (opt) expression-statement
8795 attribute-specifier-seq (opt) compound-statement
8796 attribute-specifier-seq (opt) selection-statement
8797 attribute-specifier-seq (opt) iteration-statement
8798 attribute-specifier-seq (opt) jump-statement
8799 declaration-statement
8800 attribute-specifier-seq (opt) try-block
8802 TM Extension:
8804 statement:
8805 atomic-statement
8807 IN_COMPOUND is true when the statement is nested inside a
8808 cp_parser_compound_statement; this matters for certain pragmas.
8810 If IF_P is not NULL, *IF_P is set to indicate whether the statement
8811 is a (possibly labeled) if statement which is not enclosed in braces
8812 and has an else clause. This is used to implement -Wparentheses. */
8814 static void
8817 {
8822 restart:
8825 /* There is no statement yet. */
8831 /* In obj-c++, seing '[[' might be the either the beginning of
8832 c++11 attributes, or a nested objc-message-expression. So
8833 let's parse the c++11 attributes tentatively. */
8837 {
8840 }
8842 /* Peek at the next token. */
8844 /* Remember the location of the first token in the statement. */
8846 /* If this is a keyword, then that will often determine what kind of
8847 statement we have. */
8849 {
8853 {
8856 /* Looks like a labeled-statement with a case label.
8857 Parse the label, and then use tail recursion to parse
8858 the statement. */
8880 /* Objective-C++ exception-handling constructs. */
8894 /* This must be a namespace alias definition. */
8907 /* It might be a keyword like `int' that can start a
8908 declaration-statement. */
8910 }
8911 }
8913 {
8914 /* If the next token is a `:', then we are looking at a
8915 labeled-statement. */
8918 {
8919 /* Looks like a labeled-statement with an ordinary label.
8920 Parse the label, and then use tail recursion to parse
8921 the statement. */
8925 }
8926 }
8927 /* Anything that starts with a `{' must be a compound-statement. */
8930 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
8931 a statement all its own. */
8933 {
8934 /* Only certain OpenMP pragmas are attached to statements, and thus
8935 are considered statements themselves. All others are not. In
8936 the context of a compound, accept the pragma as a "statement" and
8937 return so that we can check for a close brace. Otherwise we
8938 require a real statement and must go back and read one. */
8944 }
8946 {
8949 }
8951 /* Everything else must be a declaration-statement or an
8952 expression-statement. Try for the declaration-statement
8953 first, unless we are looking at a `;', in which case we know that
8954 we have an expression-statement. */
8956 {
8958 {
8960 {
8961 /* Attributes should be parsed as part of the the
8962 declaration, so let's un-parse them. */
8965 }
8968 /* Try to parse the declaration-statement. */
8970 /* If that worked, we're done. */
8973 }
8974 /* Look for an expression-statement instead. */
8976 }
8978 /* Set the line number for the statement. */
8982 /* Note that for now, we don't do anything with c++11 statements
8983 parsed at this level. */
8986 OPT_Wattributes,
8988 }
8990 /* Parse the label for a labeled-statement, i.e.
8992 identifier :
8993 case constant-expression :
8994 default :
8996 GNU Extension:
8997 case constant-expression ... constant-expression : statement
8999 When a label is parsed without errors, the label is added to the
9000 parse tree by the finish_* functions, so this function doesn't
9001 have to return the label. */
9003 static void
9005 {
9010 /* The next token should be an identifier. */
9014 {
9017 }
9021 {
9023 {
9027 /* Consume the `case' token. */
9029 /* Parse the constant-expression. */
9032 NULL);
9036 {
9037 /* Consume the `...' token. */
9039 expr_hi =
9042 NULL);
9043 /* We don't need to emit warnings here, as the common code
9044 will do this for us. */
9045 }
9046 else
9051 else
9054 expr);
9055 }
9059 /* Consume the `default' token. */
9064 else
9069 /* Anything else must be an ordinary label. */
9072 }
9074 /* Require the `:' token. */
9077 /* An ordinary label may optionally be followed by attributes.
9078 However, this is only permitted if the attributes are then
9079 followed by a semicolon. This is because, for backward
9080 compatibility, when parsing
9081 lab: __attribute__ ((unused)) int i;
9082 we want the attribute to attach to "i", not "lab". */
9085 {
9086 tree attrs;
9093 ;
9094 else
9096 }
9102 }
9104 /* Parse an expression-statement.
9106 expression-statement:
9107 expression [opt] ;
9109 Returns the new EXPR_STMT -- or NULL_TREE if the expression
9110 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
9111 indicates whether this expression-statement is part of an
9112 expression statement. */
9114 static tree
9116 {
9120 /* If the next token is a ';', then there is no expression
9121 statement. */
9125 /* Give a helpful message for "A<T>::type t;" and the like. */
9128 {
9135 {
9136 /* A::A a; */
9141 }
9142 }
9144 /* Consume the final `;'. */
9149 /* This is the final expression statement of a statement
9150 expression. */
9154 else
9158 }
9160 /* Parse a compound-statement.
9162 compound-statement:
9163 { statement-seq [opt] }
9165 GNU extension:
9167 compound-statement:
9168 { label-declaration-seq [opt] statement-seq [opt] }
9170 label-declaration-seq:
9171 label-declaration
9172 label-declaration-seq label-declaration
9174 Returns a tree representing the statement. */
9176 static tree
9179 {
9180 tree compound_stmt;
9182 /* Consume the `{'. */
9189 /* Begin the compound-statement. */
9191 /* If the next keyword is `__label__' we have a label declaration. */
9194 /* Parse an (optional) statement-seq. */
9196 /* Finish the compound-statement. */
9198 /* Consume the `}'. */
9202 }
9204 /* Parse an (optional) statement-seq.
9206 statement-seq:
9207 statement
9208 statement-seq [opt] statement */
9210 static void
9212 {
9213 /* Scan statements until there aren't any more. */
9215 {
9218 /* If we are looking at a `}', then we have run out of
9219 statements; the same is true if we have reached the end
9220 of file, or have stumbled upon a stray '@end'. */
9227 /* If we are in a compound statement and find 'else' then
9228 something went wrong. */
9230 {
9233 else
9234 {
9237 }
9238 }
9240 /* Parse the statement. */
9242 }
9243 }
9245 /* Parse a selection-statement.
9247 selection-statement:
9248 if ( condition ) statement
9249 if ( condition ) statement else statement
9250 switch ( condition ) statement
9252 Returns the new IF_STMT or SWITCH_STMT.
9254 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9255 is a (possibly labeled) if statement which is not enclosed in
9256 braces and has an else clause. This is used to implement
9257 -Wparentheses. */
9259 static tree
9261 {
9268 /* Peek at the next token. */
9271 /* See what kind of keyword it is. */
9274 {
9277 {
9278 tree statement;
9279 tree condition;
9281 /* Look for the `('. */
9283 {
9286 }
9288 /* Begin the selection-statement. */
9291 else
9294 /* Parse the condition. */
9296 /* Look for the `)'. */
9302 {
9306 /* Add the condition. */
9309 /* Parse the then-clause. */
9313 {
9321 }
9322 else
9328 /* If the next token is `else', parse the else-clause. */
9330 RID_ELSE))
9331 {
9332 /* Consume the `else' keyword. */
9335 /* Parse the else-clause. */
9337 {
9338 location_t loc;
9345 }
9346 else
9351 /* If we are currently parsing a then-clause, then
9352 IF_P will not be NULL. We set it to true to
9353 indicate that this if statement has an else clause.
9354 This may trigger the Wparentheses warning below
9355 when we get back up to the parent if statement. */
9358 }
9359 else
9360 {
9361 /* This if statement does not have an else clause. If
9362 NESTED_IF is true, then the then-clause is an if
9363 statement which does have an else clause. We warn
9364 about the potential ambiguity. */
9367 "suggest explicit braces to avoid ambiguous"
9369 }
9371 /* Now we're all done with the if-statement. */
9373 }
9374 else
9375 {
9379 /* Add the condition. */
9382 /* Parse the body of the switch-statement. */
9391 /* Now we're all done with the switch-statement. */
9393 }
9396 }
9402 }
9403 }
9405 /* Parse a condition.
9407 condition:
9408 expression
9409 type-specifier-seq declarator = initializer-clause
9410 type-specifier-seq declarator braced-init-list
9412 GNU Extension:
9414 condition:
9415 type-specifier-seq declarator asm-specification [opt]
9416 attributes [opt] = assignment-expression
9418 Returns the expression that should be tested. */
9420 static tree
9422 {
9423 cp_decl_specifier_seq type_specifiers;
9427 /* Try the declaration first. */
9429 /* New types are not allowed in the type-specifier-seq for a
9430 condition. */
9432 parser->type_definition_forbidden_message
9434 /* Parse the type-specifier-seq. */
9436 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
9439 /* Restore the saved message. */
9441 /* If all is well, we might be looking at a declaration. */
9443 {
9444 tree decl;
9445 tree asm_specification;
9446 tree attributes;
9450 /* Parse the declarator. */
9455 /* Parse the attributes. */
9457 /* Parse the asm-specification. */
9459 /* If the next token is not an `=' or '{', then we might still be
9460 looking at an expression. For example:
9462 if (A(a).x)
9464 looks like a decl-specifier-seq and a declarator -- but then
9465 there is no `=', so this is an expression. */
9470 /* If we did see an `=' or '{', then we are looking at a declaration
9471 for sure. */
9473 {
9474 tree pushed_scope;
9478 /* Create the declaration. */
9484 /* Parse the initializer. */
9486 {
9490 }
9491 else
9492 {
9493 /* Consume the `='. */
9496 }
9500 /* Process the initializer. */
9503 asm_specification,
9504 flags);
9510 }
9511 }
9512 /* If we didn't even get past the declarator successfully, we are
9513 definitely not looking at a declaration. */
9514 else
9517 /* Otherwise, we are looking at an expression. */
9519 }
9521 /* Parses a for-statement or range-for-statement until the closing ')',
9522 not included. */
9524 static tree
9526 {
9530 /* Begin the for-statement. */
9533 /* Parse the initialization. */
9538 else
9540 }
9542 static tree
9544 {
9545 /* Normal for loop */
9548 tree stmt;
9551 /* The for-init-statement has already been parsed in
9552 cp_parser_for_init_statement, so no work is needed here. */
9555 /* If there's a condition, process it. */
9559 /* Look for the `;'. */
9562 /* If there's an expression, process it. */
9568 }
9570 /* Tries to parse a range-based for-statement:
9572 range-based-for:
9573 decl-specifier-seq declarator : expression
9575 The decl-specifier-seq declarator and the `:' are already parsed by
9576 cp_parser_for_init_statement. If processing_template_decl it returns a
9577 newly created RANGE_FOR_STMT; if not, it is converted to a
9578 regular FOR_STMT. */
9580 static tree
9582 {
9586 {
9589 }
9590 else
9593 /* If in template, STMT is converted to a normal for-statement
9594 at instantiation. If not, it is done just ahead. */
9596 {
9602 /* do_auto_deduction doesn't mess with template init-lists. */
9605 }
9606 else
9607 {
9610 }
9612 }
9614 /* Subroutine of cp_convert_range_for: given the initializer expression,
9615 builds up the range temporary. */
9617 static tree
9619 {
9622 /* Find out the type deduced by the declaration
9623 `auto &&__range = range_expr'. */
9628 /* Create the __range variable. */
9635 }
9637 /* Used by cp_parser_range_for in template context: we aren't going to
9638 do a full conversion yet, but we still need to resolve auto in the
9639 type of the for-range-declaration if present. This is basically
9640 a shortcut version of cp_convert_range_for. */
9642 static void
9644 {
9647 {
9650 iter_type = (cp_parser_perform_range_for_lookup
9654 tf_warning_or_error);
9657 }
9658 }
9660 /* Converts a range-based for-statement into a normal
9661 for-statement, as per the definition.
9663 for (RANGE_DECL : RANGE_EXPR)
9664 BLOCK
9666 should be equivalent to:
9668 {
9669 auto &&__range = RANGE_EXPR;
9670 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
9671 __begin != __end;
9672 ++__begin)
9673 {
9674 RANGE_DECL = *__begin;
9675 BLOCK
9676 }
9677 }
9679 If RANGE_EXPR is an array:
9680 BEGIN_EXPR = __range
9681 END_EXPR = __range + ARRAY_SIZE(__range)
9682 Else if RANGE_EXPR has a member 'begin' or 'end':
9683 BEGIN_EXPR = __range.begin()
9684 END_EXPR = __range.end()
9685 Else:
9686 BEGIN_EXPR = begin(__range)
9687 END_EXPR = end(__range);
9689 If __range has a member 'begin' but not 'end', or vice versa, we must
9690 still use the second alternative (it will surely fail, however).
9691 When calling begin()/end() in the third alternative we must use
9692 argument dependent lookup, but always considering 'std' as an associated
9693 namespace. */
9695 tree
9697 {
9703 /* If an error happened previously do nothing or else a lot of
9704 unhelpful errors would be issued. */
9706 else
9707 {
9712 LOOKUP_ONLYCONVERTING);
9717 }
9719 /* The new for initialization statement. */
9727 LOOKUP_ONLYCONVERTING);
9736 LOOKUP_ONLYCONVERTING);
9740 /* The new for condition. */
9747 /* The new increment expression. */
9750 tf_warning_or_error);
9753 /* The declaration is initialized with *__begin inside the loop body. */
9756 tf_warning_or_error),
9758 LOOKUP_ONLYCONVERTING);
9761 }
9763 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
9764 We need to solve both at the same time because the method used
9765 depends on the existence of members begin or end.
9766 Returns the type deduced for the iterator expression. */
9768 static tree
9770 {
9772 {
9775 }
9778 {
9783 }
9785 {
9786 /* If RANGE is an array, we will use pointer arithmetic. */
9789 range,
9793 }
9794 else
9795 {
9796 /* If it is not an array, we must do a bit of magic. */
9806 tf_warning_or_error);
9809 tf_warning_or_error);
9812 {
9813 /* Use the member functions. */
9816 else
9822 else
9825 }
9826 else
9827 {
9828 /* Use global functions with ADL. */
9836 tf_warning_or_error);
9838 tf_warning_or_error);
9841 tf_warning_or_error);
9843 tf_warning_or_error);
9846 }
9848 /* Last common checks. */
9850 {
9851 /* If one of the expressions is an error do no more checks. */
9854 }
9855 else
9856 {
9858 /* The unqualified type of the __begin and __end temporaries should
9859 be the same, as required by the multiple auto declaration. */
9865 }
9866 }
9867 }
9869 /* Helper function for cp_parser_perform_range_for_lookup.
9870 Builds a tree for RANGE.IDENTIFIER(). */
9872 static tree
9874 {
9887 tf_warning_or_error);
9890 }
9892 /* Parse an iteration-statement.
9894 iteration-statement:
9895 while ( condition ) statement
9896 do statement while ( expression ) ;
9897 for ( for-init-statement condition [opt] ; expression [opt] )
9898 statement
9900 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
9902 static tree
9904 {
9907 tree statement;
9910 /* Peek at the next token. */
9915 /* Remember whether or not we are already within an iteration
9916 statement. */
9919 /* See what kind of keyword it is. */
9922 {
9924 {
9925 tree condition;
9927 /* Begin the while-statement. */
9929 /* Look for the `('. */
9931 /* Parse the condition. */
9934 /* Look for the `)'. */
9936 /* Parse the dependent statement. */
9940 /* We're done with the while-statement. */
9942 }
9946 {
9947 tree expression;
9949 /* Begin the do-statement. */
9951 /* Parse the body of the do-statement. */
9956 /* Look for the `while' keyword. */
9958 /* Look for the `('. */
9960 /* Parse the expression. */
9962 /* We're done with the do-statement. */
9964 /* Look for the `)'. */
9966 /* Look for the `;'. */
9968 }
9972 {
9973 /* Look for the `('. */
9978 /* Look for the `)'. */
9981 /* Parse the body of the for-statement. */
9986 /* We're done with the for-statement. */
9988 }
9995 }
9998 }
10000 /* Parse a for-init-statement or the declarator of a range-based-for.
10001 Returns true if a range-based-for declaration is seen.
10003 for-init-statement:
10004 expression-statement
10005 simple-declaration */
10007 static bool
10009 {
10010 /* If the next token is a `;', then we have an empty
10011 expression-statement. Grammatically, this is also a
10012 simple-declaration, but an invalid one, because it does not
10013 declare anything. Therefore, if we did not handle this case
10014 specially, we would issue an error message about an invalid
10015 declaration. */
10017 {
10023 /* We're going to speculatively look for a declaration, falling back
10024 to an expression, if necessary. */
10026 /* Parse the declaration. */
10029 decl);
10032 {
10033 /* It is a range-for, consume the ':' */
10037 {
10039 "range-based %<for%> loops are not allowed "
10042 }
10043 }
10044 else
10045 /* The ';' is not consumed yet because we told
10046 cp_parser_simple_declaration not to. */
10051 /* If the tentative parse failed, then we shall need to look for an
10052 expression-statement. */
10053 }
10054 /* If we are here, it is an expression-statement. */
10057 }
10059 /* Parse a jump-statement.
10061 jump-statement:
10062 break ;
10063 continue ;
10064 return expression [opt] ;
10065 return braced-init-list ;
10066 goto identifier ;
10068 GNU extension:
10070 jump-statement:
10071 goto * expression ;
10073 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
10075 static tree
10077 {
10083 /* Peek at the next token. */
10088 /* See what kind of keyword it is. */
10091 {
10095 {
10110 }
10116 {
10129 }
10134 {
10135 tree expr;
10139 {
10142 }
10145 else
10146 /* If the next token is a `;', then there is no
10147 expression. */
10149 /* Build the return-statement. */
10151 /* Look for the final `;'. */
10153 }
10157 /* Create the goto-statement. */
10159 {
10160 /* Issue a warning about this use of a GNU extension. */
10162 /* Consume the '*' token. */
10164 /* Parse the dependent expression. */
10166 }
10167 else
10169 /* Look for the final `;'. */
10176 }
10179 }
10181 /* Parse a declaration-statement.
10183 declaration-statement:
10184 block-declaration */
10186 static void
10188 {
10191 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
10194 /* Parse the block-declaration. */
10197 /* Free any declarators allocated. */
10200 /* Finish off the statement. */
10202 }
10204 /* Some dependent statements (like `if (cond) statement'), are
10205 implicitly in their own scope. In other words, if the statement is
10206 a single statement (as opposed to a compound-statement), it is
10207 none-the-less treated as if it were enclosed in braces. Any
10208 declarations appearing in the dependent statement are out of scope
10209 after control passes that point. This function parses a statement,
10210 but ensures that is in its own scope, even if it is not a
10211 compound-statement.
10213 If IF_P is not NULL, *IF_P is set to indicate whether the statement
10214 is a (possibly labeled) if statement which is not enclosed in
10215 braces and has an else clause. This is used to implement
10216 -Wparentheses.
10218 Returns the new statement. */
10220 static tree
10222 {
10223 tree statement;
10228 /* Mark if () ; with a special NOP_EXPR. */
10230 {
10234 }
10235 /* if a compound is opened, we simply parse the statement directly. */
10238 /* If the token is not a `{', then we must take special action. */
10239 else
10240 {
10241 /* Create a compound-statement. */
10243 /* Parse the dependent-statement. */
10245 /* Finish the dummy compound-statement. */
10247 }
10249 /* Return the statement. */
10251 }
10253 /* For some dependent statements (like `while (cond) statement'), we
10254 have already created a scope. Therefore, even if the dependent
10255 statement is a compound-statement, we do not want to create another
10256 scope. */
10258 static void
10260 {
10261 /* If the token is a `{', then we must take special action. */
10264 else
10265 {
10266 /* Avoid calling cp_parser_compound_statement, so that we
10267 don't create a new scope. Do everything else by hand. */
10269 /* If the next keyword is `__label__' we have a label declaration. */
10272 /* Parse an (optional) statement-seq. */
10275 }
10276 }
10278 /* Declarations [gram.dcl.dcl] */
10280 /* Parse an optional declaration-sequence.
10282 declaration-seq:
10283 declaration
10284 declaration-seq declaration */
10286 static void
10288 {
10290 {
10301 {
10302 /* A declaration consisting of a single semicolon is
10303 invalid. Allow it unless we're being pedantic. */
10308 }
10310 /* If we're entering or exiting a region that's implicitly
10311 extern "C", modify the lang context appropriately. */
10313 {
10316 }
10318 {
10321 }
10324 {
10325 /* A top-level declaration can consist solely of a #pragma.
10326 A nested declaration cannot, so this is done here and not
10327 in cp_parser_declaration. (A #pragma at block scope is
10328 handled in cp_parser_statement.) */
10331 }
10333 /* Parse the declaration itself. */
10335 }
10336 }
10338 /* Parse a declaration.
10340 declaration:
10341 block-declaration
10342 function-definition
10343 template-declaration
10344 explicit-instantiation
10345 explicit-specialization
10346 linkage-specification
10347 namespace-definition
10349 GNU extension:
10351 declaration:
10352 __extension__ declaration */
10354 static void
10356 {
10357 cp_token token1;
10358 cp_token token2;
10363 /* Check for the `__extension__' keyword. */
10365 {
10366 /* Parse the qualified declaration. */
10368 /* Restore the PEDANTIC flag. */
10372 }
10374 /* Try to figure out what kind of declaration is present. */
10379 else
10380 {
10383 }
10385 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
10388 /* If the next token is `extern' and the following token is a string
10389 literal, then we have a linkage specification. */
10393 /* If the next token is `template', then we have either a template
10394 declaration, an explicit instantiation, or an explicit
10395 specialization. */
10397 {
10398 /* `template <>' indicates a template specialization. */
10402 /* `template <' indicates a template declaration. */
10405 /* Anything else must be an explicit instantiation. */
10406 else
10408 }
10409 /* If the next token is `export', then we have a template
10410 declaration. */
10413 /* If the next token is `extern', 'static' or 'inline' and the one
10414 after that is `template', we have a GNU extended explicit
10415 instantiation directive. */
10422 /* If the next token is `namespace', check for a named or unnamed
10423 namespace definition. */
10429 /* An unnamed namespace definition. */
10433 /* An inline (associated) namespace definition. */
10437 /* Objective-C++ declaration/definition. */
10444 /* We must have either a block declaration or a function
10445 definition. */
10446 else
10447 /* Try to parse a block-declaration, or a function-definition. */
10450 /* Free any declarators allocated. */
10452 }
10454 /* Parse a block-declaration.
10456 block-declaration:
10457 simple-declaration
10458 asm-definition
10459 namespace-alias-definition
10460 using-declaration
10461 using-directive
10463 GNU Extension:
10465 block-declaration:
10466 __extension__ block-declaration
10468 C++0x Extension:
10470 block-declaration:
10471 static_assert-declaration
10473 If STATEMENT_P is TRUE, then this block-declaration is occurring as
10474 part of a declaration-statement. */
10476 static void
10479 {
10483 /* Check for the `__extension__' keyword. */
10485 {
10486 /* Parse the qualified declaration. */
10488 /* Restore the PEDANTIC flag. */
10492 }
10494 /* Peek at the next token to figure out which kind of declaration is
10495 present. */
10498 /* If the next keyword is `asm', we have an asm-definition. */
10500 {
10504 }
10505 /* If the next keyword is `namespace', we have a
10506 namespace-alias-definition. */
10509 /* If the next keyword is `using', we have a
10510 using-declaration, a using-directive, or an alias-declaration. */
10512 {
10517 /* If the token after `using' is `namespace', then we have a
10518 using-directive. */
10522 /* If the second token after 'using' is '=', then we have an
10523 alias-declaration. */
10529 /* Otherwise, it's a using-declaration. */
10530 else
10533 }
10534 /* If the next keyword is `__label__' we have a misplaced label
10535 declaration. */
10537 {
10541 /* If the next token is now a `;', consume it. */
10544 }
10545 /* If the next token is `static_assert' we have a static assertion. */
10548 /* Anything else must be a simple-declaration. */
10549 else
10552 }
10554 /* Parse a simple-declaration.
10556 simple-declaration:
10557 decl-specifier-seq [opt] init-declarator-list [opt] ;
10559 init-declarator-list:
10560 init-declarator
10561 init-declarator-list , init-declarator
10563 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
10564 function-definition as a simple-declaration.
10566 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
10567 parsed declaration if it is an uninitialized single declarator not followed
10568 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
10569 if present, will not be consumed. */
10571 static void
10575 {
10576 cp_decl_specifier_seq decl_specifiers;
10583 /* Defer access checks until we know what is being declared; the
10584 checks for names appearing in the decl-specifier-seq should be
10585 done as if we were in the scope of the thing being declared. */
10588 /* Parse the decl-specifier-seq. We have to keep track of whether
10589 or not the decl-specifier-seq declares a named class or
10590 enumeration type, since that is the only case in which the
10591 init-declarator-list is allowed to be empty.
10593 [dcl.dcl]
10595 In a simple-declaration, the optional init-declarator-list can be
10596 omitted only when declaring a class or enumeration, that is when
10597 the decl-specifier-seq contains either a class-specifier, an
10598 elaborated-type-specifier, or an enum-specifier. */
10600 CP_PARSER_FLAGS_OPTIONAL,
10603 /* We no longer need to defer access checks. */
10606 /* In a block scope, a valid declaration must always have a
10607 decl-specifier-seq. By not trying to parse declarators, we can
10608 resolve the declaration/expression ambiguity more quickly. */
10611 {
10614 }
10616 /* If the next two tokens are both identifiers, the code is
10617 erroneous. The usual cause of this situation is code like:
10619 T t;
10621 where "T" should name a type -- but does not. */
10624 {
10625 /* If parsing tentatively, we should commit; we really are
10626 looking at a declaration. */
10628 /* Give up. */
10630 }
10632 /* If we have seen at least one decl-specifier, and the next token
10633 is not a parenthesis, then we must be looking at a declaration.
10634 (After "int (" we might be looking at a functional cast.) */
10641 /* Keep going until we hit the `;' at the end of the simple
10642 declaration. */
10645 CPP_SEMICOLON))
10646 {
10649 tree decl;
10652 {
10653 /* If we are processing next declarator, coma is expected */
10659 }
10660 else
10663 /* Parse the init-declarator. */
10666 function_definition_allowed_p,
10668 declares_class_or_enum,
10670 maybe_range_for_decl);
10671 /* If an error occurred while parsing tentatively, exit quickly.
10672 (That usually happens when in the body of a function; each
10673 statement is treated as a declaration-statement until proven
10674 otherwise.) */
10677 /* Handle function definitions specially. */
10679 {
10680 /* If the next token is a `,', then we are probably
10681 processing something like:
10683 void f() {}, *p;
10685 which is erroneous. */
10687 {
10690 "mixing"
10692 }
10693 /* Otherwise, we're done with the list of declarators. */
10694 else
10695 {
10698 }
10699 }
10702 /* The next token should be either a `,' or a `;'. */
10704 /* If it's a `,', there are more declarators to come. */
10707 /* If it's a `;', we are done. */
10710 /* Anything else is an error. */
10711 else
10712 {
10713 /* If we have already issued an error message we don't need
10714 to issue another one. */
10718 /* Skip tokens until we reach the end of the statement. */
10720 /* If the next token is now a `;', consume it. */
10724 }
10725 /* After the first time around, a function-definition is not
10726 allowed -- even if it was OK at first. For example:
10728 int i, f() {}
10730 is not valid. */
10732 }
10734 /* Issue an error message if no declarators are present, and the
10735 decl-specifier-seq does not itself declare a class or
10736 enumeration. */
10738 {
10741 /* Perform any deferred access checks. */
10743 }
10745 /* Consume the `;'. */
10749 done:
10751 }
10753 /* Parse a decl-specifier-seq.
10755 decl-specifier-seq:
10756 decl-specifier-seq [opt] decl-specifier
10757 decl-specifier attribute-specifier-seq [opt] (C++11)
10759 decl-specifier:
10760 storage-class-specifier
10761 type-specifier
10762 function-specifier
10763 friend
10764 typedef
10766 GNU Extension:
10768 decl-specifier:
10769 attributes
10771 Set *DECL_SPECS to a representation of the decl-specifier-seq.
10773 The parser flags FLAGS is used to control type-specifier parsing.
10775 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
10776 flags:
10778 1: one of the decl-specifiers is an elaborated-type-specifier
10779 (i.e., a type declaration)
10780 2: one of the decl-specifiers is an enum-specifier or a
10781 class-specifier (i.e., a type definition)
10783 */
10785 static void
10787 cp_parser_flags flags,
10790 {
10794 cp_decl_spec ds;
10796 /* Clear DECL_SPECS. */
10799 /* Assume no class or enumeration type is declared. */
10802 /* Keep reading specifiers until there are no more to read. */
10804 {
10809 /* Peek at the next token. */
10812 /* Save the first token of the decl spec list for error
10813 reporting. */
10816 /* Handle attributes. */
10818 {
10819 /* Parse the attributes. */
10822 /* In a sequence of declaration specifiers, c++11 attributes
10823 appertain to the type that precede them. In that case
10824 [dcl.spec]/1 says:
10826 The attribute-specifier-seq affects the type only for
10827 the declaration it appears in, not other declarations
10828 involving the same type.
10830 But for now let's force the user to position the
10831 attribute either at the beginning of the declaration or
10832 after the declarator-id, which would clearly mean that it
10833 applies to the declarator. */
10835 {
10837 /* The c++11 attribute is at the beginning of the
10838 declaration. It appertains to the entity being
10840 else
10841 {
10843 {
10844 /* This is an attribute following a
10845 class-specifier. */
10850 }
10851 else
10852 {
10853 decl_specs->std_attributes
10855 attrs);
10858 }
10860 }
10861 }
10863 decl_specs->attributes
10865 attrs);
10869 }
10870 /* Assume we will find a decl-specifier keyword. */
10872 /* If the next token is an appropriate keyword, we can simply
10873 add it to the list. */
10875 {
10876 /* decl-specifier:
10877 friend
10878 constexpr */
10881 {
10884 }
10885 else
10886 {
10888 /* Consume the token. */
10890 }
10898 /* function-specifier:
10899 inline
10900 virtual
10901 explicit */
10908 /* decl-specifier:
10909 typedef */
10912 /* Consume the token. */
10914 /* A constructor declarator cannot appear in a typedef. */
10916 /* The "typedef" keyword can only occur in a declaration; we
10917 may as well commit at this point. */
10924 /* storage-class-specifier:
10925 auto
10926 register
10927 static
10928 extern
10929 mutable
10931 GNU Extension:
10932 thread */
10935 {
10936 /* Consume the token. */
10939 /* Complain about `auto' as a storage specifier, if
10940 we're complaining about C++0x compatibility. */
10944 /* Set the storage class anyway. */
10946 token);
10947 }
10948 else
10949 /* C++0x auto type-specifier. */
10957 /* Consume the token. */
10960 token);
10963 /* Consume the token. */
10969 /* We did not yet find a decl-specifier yet. */
10972 }
10982 /* Constructors are a special case. The `S' in `S()' is not a
10983 decl-specifier; it is the beginning of the declarator. */
10984 constructor_p
10985 = (!found_decl_spec
10986 && constructor_possible_p
10987 && (cp_parser_constructor_declarator_p
10990 /* If we don't have a DECL_SPEC yet, then we must be looking at
10991 a type-specifier. */
10993 {
10996 tree type_spec;
10998 type_spec
11000 decl_specs,
11006 /* If this type-specifier referenced a user-defined type
11007 (a typedef, class-name, etc.), then we can't allow any
11008 more such type-specifiers henceforth.
11010 [dcl.spec]
11012 The longest sequence of decl-specifiers that could
11013 possibly be a type name is taken as the
11014 decl-specifier-seq of a declaration. The sequence shall
11015 be self-consistent as described below.
11017 [dcl.type]
11019 As a general rule, at most one type-specifier is allowed
11020 in the complete decl-specifier-seq of a declaration. The
11021 only exceptions are the following:
11023 -- const or volatile can be combined with any other
11024 type-specifier.
11026 -- signed or unsigned can be combined with char, long,
11027 short, or int.
11029 -- ..
11031 Example:
11033 typedef char* Pc;
11034 void g (const int Pc);
11036 Here, Pc is *not* part of the decl-specifier seq; it's
11037 the declarator. Therefore, once we see a type-specifier
11038 (other than a cv-qualifier), we forbid any additional
11039 user-defined types. We *do* still allow things like `int
11040 int' to be considered a decl-specifier-seq, and issue the
11041 error message later. */
11044 /* A constructor declarator cannot follow a type-specifier. */
11046 {
11051 }
11052 }
11054 /* If we still do not have a DECL_SPEC, then there are no more
11055 decl-specifiers. */
11060 /* After we see one decl-specifier, further decl-specifiers are
11061 always optional. */
11063 }
11065 /* Don't allow a friend specifier with a class definition. */
11070 }
11072 /* Parse an (optional) storage-class-specifier.
11074 storage-class-specifier:
11075 auto
11076 register
11077 static
11078 extern
11079 mutable
11081 GNU Extension:
11083 storage-class-specifier:
11084 thread
11086 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
11088 static tree
11090 {
11092 {
11096 /* Fall through for C++98. */
11103 /* Consume the token. */
11108 }
11109 }
11111 /* Parse an (optional) function-specifier.
11113 function-specifier:
11114 inline
11115 virtual
11116 explicit
11118 Returns an IDENTIFIER_NODE corresponding to the keyword used.
11119 Updates DECL_SPECS, if it is non-NULL. */
11121 static tree
11124 {
11127 {
11133 /* 14.5.2.3 [temp.mem]
11135 A member function template shall not be virtual. */
11138 else
11148 }
11150 /* Consume the token. */
11152 }
11154 /* Parse a linkage-specification.
11156 linkage-specification:
11157 extern string-literal { declaration-seq [opt] }
11158 extern string-literal declaration */
11160 static void
11162 {
11163 tree linkage;
11165 /* Look for the `extern' keyword. */
11168 /* Look for the string-literal. */
11171 /* Transform the literal into an identifier. If the literal is a
11172 wide-character string, or contains embedded NULs, then we can't
11173 handle it as the user wants. */
11176 {
11178 /* Assume C++ linkage. */
11180 }
11181 else
11184 /* We're now using the new linkage. */
11187 /* If the next token is a `{', then we're using the first
11188 production. */
11190 {
11191 /* Consume the `{' token. */
11193 /* Parse the declarations. */
11195 /* Look for the closing `}'. */
11197 }
11198 /* Otherwise, there's just one declaration. */
11199 else
11200 {
11203 saved_in_unbraced_linkage_specification_p
11207 parser->in_unbraced_linkage_specification_p
11209 }
11211 /* We're done with the linkage-specification. */
11213 }
11215 /* Parse a static_assert-declaration.
11217 static_assert-declaration:
11218 static_assert ( constant-expression , string-literal ) ;
11220 If MEMBER_P, this static_assert is a class member. */
11222 static void
11224 {
11225 tree condition;
11226 tree message;
11228 location_t saved_loc;
11231 /* Peek at the `static_assert' token so we can keep track of exactly
11232 where the static assertion started. */
11236 /* Look for the `static_assert' keyword. */
11238 RT_STATIC_ASSERT))
11241 /* We know we are in a static assertion; commit to any tentative
11242 parse. */
11246 /* Parse the `(' starting the static assertion condition. */
11249 /* Parse the constant-expression. Allow a non-constant expression
11250 here in order to give better diagnostics in finish_static_assert. */
11251 condition =
11256 /* Parse the separating `,'. */
11259 /* Parse the string-literal message. */
11264 /* A `)' completes the static assertion. */
11271 /* A semicolon terminates the declaration. */
11274 /* Complete the static assertion, which may mean either processing
11275 the static assert now or saving it for template instantiation. */
11277 }
11279 /* Parse a `decltype' type. Returns the type.
11281 simple-type-specifier:
11282 decltype ( expression ) */
11284 static tree
11286 {
11287 tree expr;
11296 {
11297 /* Already parsed. */
11300 }
11302 /* Look for the `decltype' token. */
11306 /* Types cannot be defined in a `decltype' expression. Save away the
11307 old message. */
11310 /* And create the new one. */
11311 parser->type_definition_forbidden_message
11314 /* The restrictions on constant-expressions do not apply inside
11315 decltype expressions. */
11316 saved_integral_constant_expression_p
11318 saved_non_integral_constant_expression_p
11322 /* Do not actually evaluate the expression. */
11325 /* Do not warn about problems with the expression. */
11328 /* Parse the opening `('. */
11332 /* First, try parsing an id-expression. */
11343 {
11346 cp_id_kind idk;
11350 /* Lookup the name we got back from the id-expression. */
11352 none_type,
11366 {
11367 /* Complete lookup of the id-expression. */
11368 expr = (finish_id_expression
11381 /* We found an id-expression, but it was something that we
11382 should not have found. This is an error, not something
11383 we can recover from, so note that we found an
11384 id-expression and we'll recover as gracefully as
11385 possible. */
11387 }
11392 /* We have an id-expression. */
11394 }
11397 {
11398 /* Abort the id-expression parse. */
11401 /* Parsing tentatively, again. */
11404 /* Parse a class member access. */
11412 /* We have an id-expression. */
11414 }
11417 /* We have parsed the complete id-expression or member access. */
11419 else
11420 {
11423 /* Abort our attempt to parse an id-expression or member access
11424 expression. */
11427 /* Within a parenthesized expression, a `>' token is always
11428 the greater-than operator. */
11429 saved_greater_than_is_operator_p
11433 /* Parse a full expression. */
11437 /* The `>' token might be the end of a template-id or
11438 template-parameter-list now. */
11439 parser->greater_than_is_operator_p
11441 }
11443 /* Go back to evaluating expressions. */
11447 /* Restore the old message and the integral constant expression
11448 flags. */
11450 parser->integral_constant_expression_p
11452 parser->non_integral_constant_expression_p
11455 /* Parse to the closing `)'. */
11457 {
11461 }
11464 tf_warning_or_error);
11466 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
11467 it again. */
11474 }
11476 /* Special member functions [gram.special] */
11478 /* Parse a conversion-function-id.
11480 conversion-function-id:
11481 operator conversion-type-id
11483 Returns an IDENTIFIER_NODE representing the operator. */
11485 static tree
11487 {
11488 tree type;
11489 tree saved_scope;
11490 tree saved_qualifying_scope;
11491 tree saved_object_scope;
11494 /* Look for the `operator' token. */
11497 /* When we parse the conversion-type-id, the current scope will be
11498 reset. However, we need that information in able to look up the
11499 conversion function later, so we save it here. */
11503 /* We must enter the scope of the class so that the names of
11504 entities declared within the class are available in the
11505 conversion-type-id. For example, consider:
11507 struct S {
11508 typedef int I;
11509 operator I();
11510 };
11512 S::operator I() { ... }
11514 In order to see that `I' is a type-name in the definition, we
11515 must be in the scope of `S'. */
11518 /* Parse the conversion-type-id. */
11520 /* Leave the scope of the class, if any. */
11523 /* Restore the saved scope. */
11527 /* If the TYPE is invalid, indicate failure. */
11531 }
11533 /* Parse a conversion-type-id:
11535 conversion-type-id:
11536 type-specifier-seq conversion-declarator [opt]
11538 Returns the TYPE specified. */
11540 static tree
11542 {
11543 tree attributes;
11544 cp_decl_specifier_seq type_specifiers;
11546 tree type_specified;
11548 /* Parse the attributes. */
11550 /* Parse the type-specifiers. */
11554 /* If that didn't work, stop. */
11557 /* Parse the conversion-declarator. */
11565 /* Don't give this error when parsing tentatively. This happens to
11566 work because we always parse this definitively once. */
11569 {
11571 {
11574 }
11578 }
11581 }
11583 /* Parse an (optional) conversion-declarator.
11585 conversion-declarator:
11586 ptr-operator conversion-declarator [opt]
11588 */
11592 {
11595 cp_cv_quals cv_quals;
11597 /* We don't know if there's a ptr-operator next, or not. */
11599 /* Try the ptr-operator. */
11602 /* If it worked, look for more conversion-declarators. */
11604 {
11607 /* Parse another optional declarator. */
11610 declarator = cp_parser_make_indirect_declarator
11614 }
11617 }
11619 /* Parse an (optional) ctor-initializer.
11621 ctor-initializer:
11622 : mem-initializer-list
11624 Returns TRUE iff the ctor-initializer was actually present. */
11626 static bool
11628 {
11629 /* If the next token is not a `:', then there is no
11630 ctor-initializer. */
11632 {
11633 /* Do default initialization of any bases and members. */
11638 }
11640 /* Consume the `:' token. */
11642 /* And the mem-initializer-list. */
11646 }
11648 /* Parse a mem-initializer-list.
11650 mem-initializer-list:
11651 mem-initializer ... [opt]
11652 mem-initializer ... [opt] , mem-initializer-list */
11654 static void
11656 {
11661 /* Let the semantic analysis code know that we are starting the
11662 mem-initializer-list. */
11667 /* Loop through the list. */
11669 {
11670 tree mem_initializer;
11673 /* Parse the mem-initializer. */
11675 /* If the next token is a `...', we're expanding member initializers. */
11677 {
11678 /* Consume the `...'. */
11681 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
11682 can be expanded but members cannot. */
11685 {
11690 }
11692 /* Construct the pack expansion type. */
11695 }
11698 {
11702 }
11703 /* Look for a target constructor. */
11707 {
11710 {
11714 }
11716 }
11717 /* Add it to the list, unless it was erroneous. */
11719 {
11722 }
11723 /* If the next token is not a `,', we're done. */
11726 /* Consume the `,' token. */
11728 }
11730 /* Perform semantic analysis. */
11733 }
11735 /* Parse a mem-initializer.
11737 mem-initializer:
11738 mem-initializer-id ( expression-list [opt] )
11739 mem-initializer-id braced-init-list
11741 GNU extension:
11743 mem-initializer:
11744 ( expression-list [opt] )
11746 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
11747 class) or FIELD_DECL (for a non-static data member) to initialize;
11748 the TREE_VALUE is the expression-list. An empty initialization
11749 list is represented by void_list_node. */
11751 static tree
11753 {
11754 tree mem_initializer_id;
11755 tree expression_list;
11756 tree member;
11759 /* Find out what is being initialized. */
11761 {
11765 }
11766 else
11767 {
11771 }
11777 {
11783 }
11784 else
11785 {
11795 }
11805 }
11807 /* Parse a mem-initializer-id.
11809 mem-initializer-id:
11810 :: [opt] nested-name-specifier [opt] class-name
11811 identifier
11813 Returns a TYPE indicating the class to be initializer for the first
11814 production. Returns an IDENTIFIER_NODE indicating the data member
11815 to be initialized for the second production. */
11817 static tree
11819 {
11823 tree id;
11827 /* `typename' is not allowed in this context ([temp.res]). */
11829 {
11831 "keyword %<typename%> not allowed in this context (a qualified "
11834 }
11835 /* Look for the optional `::' operator. */
11836 global_scope_p
11840 /* Look for the optional nested-name-specifier. The simplest way to
11841 implement:
11843 [temp.res]
11845 The keyword `typename' is not permitted in a base-specifier or
11846 mem-initializer; in these contexts a qualified name that
11847 depends on a template-parameter is implicitly assumed to be a
11848 type name.
11850 is to assume that we have seen the `typename' keyword at this
11851 point. */
11852 nested_name_specifier_p
11861 /* If there is a `::' operator or a nested-name-specifier, then we
11862 are definitely looking for a class-name. */
11867 typename_type,
11871 /* Otherwise, we could also be looking for an ordinary identifier. */
11873 /* Try a class-name. */
11877 none_type,
11881 /* If we found one, we're done. */
11884 /* Otherwise, look for an ordinary identifier. */
11886 }
11888 /* Overloading [gram.over] */
11890 /* Parse an operator-function-id.
11892 operator-function-id:
11893 operator operator
11895 Returns an IDENTIFIER_NODE for the operator which is a
11896 human-readable spelling of the identifier, e.g., `operator +'. */
11898 static tree
11900 {
11901 /* Look for the `operator' keyword. */
11904 /* And then the name of the operator itself. */
11906 }
11908 /* Return an identifier node for a user-defined literal operator.
11909 The suffix identifier is chained to the operator name identifier. */
11911 static tree
11913 {
11914 tree identifier;
11919 /*IDENTIFIER_UDLIT_OPNAME_P (identifier) = 1; If we get a flag someday. */
11922 }
11924 /* Parse an operator.
11926 operator:
11927 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
11928 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
11929 || ++ -- , ->* -> () []
11931 GNU Extensions:
11933 operator:
11934 <? >? <?= >?=
11936 Returns an IDENTIFIER_NODE for the operator which is a
11937 human-readable spelling of the identifier, e.g., `operator +'. */
11939 static tree
11941 {
11945 /* Peek at the next token. */
11947 /* Figure out which operator we have. */
11949 {
11951 {
11954 /* The keyword should be either `new' or `delete'. */
11959 else
11962 /* Consume the `new' or `delete' token. */
11965 /* Peek at the next token. */
11967 /* If it's a `[' token then this is the array variant of the
11968 operator. */
11970 {
11971 /* Consume the `[' token. */
11973 /* Look for the `]' token. */
11977 }
11978 /* Otherwise, we have the non-array variant. */
11979 else
11983 }
12130 /* Consume the `('. */
12132 /* Look for the matching `)'. */
12137 /* Consume the `['. */
12139 /* Look for the matching `]'. */
12147 {
12150 }
12151 /* Consume the string. */
12153 /* Look for the suffix identifier. */
12156 {
12159 {
12162 }
12163 }
12164 else
12165 {
12168 }
12175 /* Anything else is an error. */
12177 }
12179 /* If we have selected an identifier, we need to consume the
12180 operator token. */
12183 /* Otherwise, no valid operator name was present. */
12184 else
12185 {
12188 }
12191 }
12193 /* Parse a template-declaration.
12195 template-declaration:
12196 export [opt] template < template-parameter-list > declaration
12198 If MEMBER_P is TRUE, this template-declaration occurs within a
12199 class-specifier.
12201 The grammar rule given by the standard isn't correct. What
12202 is really meant is:
12204 template-declaration:
12205 export [opt] template-parameter-list-seq
12206 decl-specifier-seq [opt] init-declarator [opt] ;
12207 export [opt] template-parameter-list-seq
12208 function-definition
12210 template-parameter-list-seq:
12211 template-parameter-list-seq [opt]
12212 template < template-parameter-list > */
12214 static void
12216 {
12217 /* Check for `export'. */
12219 {
12220 /* Consume the `export' token. */
12222 /* Warn that we do not support `export'. */
12224 }
12227 }
12229 /* Parse a template-parameter-list.
12231 template-parameter-list:
12232 template-parameter
12233 template-parameter-list , template-parameter
12235 Returns a TREE_LIST. Each node represents a template parameter.
12236 The nodes are connected via their TREE_CHAINs. */
12238 static tree
12240 {
12245 /* The loop below parses the template parms. We first need to know
12246 the total number of template parms to be able to compute proper
12247 canonical types of each dependent type. So after the loop, when
12248 we know the total number of template parms,
12249 end_template_parm_list computes the proper canonical types and
12250 fixes up the dependent types accordingly. */
12252 {
12253 tree parameter;
12256 location_t parm_loc;
12258 /* Parse the template-parameter. */
12263 /* Add it to the list. */
12266 parm_loc,
12267 parameter,
12268 is_non_type,
12269 is_parameter_pack);
12270 else
12271 {
12274 }
12276 /* If the next token is not a `,', we're done. */
12279 /* Otherwise, consume the `,' token. */
12281 }
12284 }
12286 /* Parse a template-parameter.
12288 template-parameter:
12289 type-parameter
12290 parameter-declaration
12292 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
12293 the parameter. The TREE_PURPOSE is the default value, if any.
12294 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
12295 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
12296 set to true iff this parameter is a parameter pack. */
12298 static tree
12301 {
12305 tree parm;
12307 /* Assume it is a type parameter or a template parameter. */
12309 /* Assume it not a parameter pack. */
12311 /* Peek at the next token. */
12313 /* If it is `class' or `template', we have a type-parameter. */
12316 /* If it is `class' or `typename' we do not know yet whether it is a
12317 type parameter or a non-type parameter. Consider:
12319 template <typename T, typename T::X X> ...
12321 or:
12323 template <class C, class D*> ...
12325 Here, the first parameter is a type parameter, and the second is
12326 a non-type parameter. We can tell by looking at the token after
12327 the identifier -- if it is a `,', `=', or `>' then we have a type
12328 parameter. */
12330 {
12331 /* Peek at the token after `class' or `typename'. */
12333 /* If it's an ellipsis, we have a template type parameter
12334 pack. */
12337 /* If it's an identifier, skip it. */
12340 /* Now, see if the token looks like the end of a template
12341 parameter. */
12346 }
12348 /* Otherwise, it is a non-type parameter.
12350 [temp.param]
12352 When parsing a default template-argument for a non-type
12353 template-parameter, the first non-nested `>' is taken as the end
12354 of the template parameter-list rather than a greater-than
12355 operator. */
12357 parameter_declarator
12361 /* If the parameter declaration is marked as a parameter pack, set
12362 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
12363 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
12364 grokdeclarator. */
12368 {
12371 }
12375 {
12376 /* Can happen in some cases of erroneous input (c++/34892). */
12378 /* Consume the `...' for better error recovery. */
12380 }
12381 /* If the next token is an ellipsis, and we don't already have it
12382 marked as a parameter pack, then we have a parameter pack (that
12383 has no declarator). */
12386 && (declarator_can_be_parameter_pack
12388 {
12389 /* Consume the `...'. */
12394 }
12395 /* We might end up with a pack expansion as the type of the non-type
12396 template parameter, in which case this is a non-type template
12397 parameter pack. */
12401 {
12405 }
12408 {
12409 /* Parameter packs cannot have default arguments. However, a
12410 user may try to do so, so we'll parse them and give an
12411 appropriate diagnostic here. */
12415 /* Find the name of the parameter pack. */
12424 else
12428 /* Parse the default argument, but throw away the result. */
12430 }
12440 }
12442 /* Parse a type-parameter.
12444 type-parameter:
12445 class identifier [opt]
12446 class identifier [opt] = type-id
12447 typename identifier [opt]
12448 typename identifier [opt] = type-id
12449 template < template-parameter-list > class identifier [opt]
12450 template < template-parameter-list > class identifier [opt]
12451 = id-expression
12453 GNU Extension (variadic templates):
12455 type-parameter:
12456 class ... identifier [opt]
12457 typename ... identifier [opt]
12459 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
12460 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
12461 the declaration of the parameter.
12463 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
12465 static tree
12467 {
12469 tree parameter;
12471 /* Look for a keyword to tell us what kind of parameter this is. */
12477 {
12480 {
12481 tree identifier;
12482 tree default_argument;
12484 /* If the next token is an ellipsis, we have a template
12485 argument pack. */
12487 {
12488 /* Consume the `...' token. */
12493 }
12495 /* If the next token is an identifier, then it names the
12496 parameter. */
12499 else
12502 /* Create the parameter. */
12505 /* If the next token is an `=', we have a default argument. */
12507 {
12508 /* Consume the `=' token. */
12510 /* Parse the default-argument. */
12514 /* Template parameter packs cannot have default
12515 arguments. */
12517 {
12520 "template parameter pack %qD cannot have a "
12522 else
12524 "template parameter packs cannot have "
12527 }
12529 }
12530 else
12533 /* Create the combined representation of the parameter and the
12534 default argument. */
12536 }
12540 {
12541 tree identifier;
12542 tree default_argument;
12544 /* Look for the `<'. */
12546 /* Parse the template-parameter-list. */
12548 /* Look for the `>'. */
12550 /* Look for the `class' keyword. */
12552 /* If the next token is an ellipsis, we have a template
12553 argument pack. */
12555 {
12556 /* Consume the `...' token. */
12561 }
12562 /* If the next token is an `=', then there is a
12563 default-argument. If the next token is a `>', we are at
12564 the end of the parameter-list. If the next token is a `,',
12565 then we are at the end of this parameter. */
12569 {
12571 /* Treat invalid names as if the parameter were nameless. */
12574 }
12575 else
12578 /* Create the template parameter. */
12580 identifier);
12582 /* If the next token is an `=', then there is a
12583 default-argument. */
12585 {
12588 /* Consume the `='. */
12590 /* Parse the id-expression. */
12592 /* save token before parsing the id-expression, for error
12593 reporting */
12595 default_argument
12603 /* If the id-expression was a template-id that refers to
12604 a template-class, we already have the declaration here,
12605 so no further lookup is needed. */
12606 ;
12607 else
12608 /* Look up the name. */
12609 default_argument
12611 none_type,
12617 /* See if the default argument is valid. */
12618 default_argument
12621 /* Template parameter packs cannot have default
12622 arguments. */
12624 {
12627 "template parameter pack %qD cannot "
12629 identifier);
12630 else
12634 }
12636 }
12637 else
12640 /* Create the combined representation of the parameter and the
12641 default argument. */
12643 }
12649 }
12652 }
12654 /* Parse a template-id.
12656 template-id:
12657 template-name < template-argument-list [opt] >
12659 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
12660 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
12661 returned. Otherwise, if the template-name names a function, or set
12662 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
12663 names a class, returns a TYPE_DECL for the specialization.
12665 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
12666 uninstantiated templates. */
12668 static tree
12674 {
12676 tree templ;
12677 tree arguments;
12678 tree template_id;
12685 /* If the next token corresponds to a template-id, there is no need
12686 to reparse it. */
12689 {
12692 /* Get the stored value. */
12694 /* Perform any access checks that were deferred. */
12697 {
12702 tf_warning_or_error);
12703 }
12704 /* Return the stored value. */
12706 }
12708 /* Avoid performing name lookup if there is no possibility of
12709 finding a template-id. */
12712 && !cp_parser_nth_token_starts_template_argument_list_p
12714 {
12717 }
12719 /* Remember where the template-id starts. */
12725 /* Parse the template-name. */
12728 check_dependency_p,
12729 is_declaration,
12730 tag_type,
12733 {
12736 }
12738 /* If we find the sequence `[:' after a template-name, it's probably
12739 a digraph-typo for `< ::'. Substitute the tokens and check if we can
12740 parse correctly the argument list. */
12747 {
12749 /* Change `:' into `::'. */
12751 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
12752 CPP_LESS. */
12755 /* Parse the arguments. */
12758 {
12759 /* If we couldn't parse an argument list, then we revert our changes
12760 and return simply an error. Maybe this is not a template-id
12761 after all. */
12766 }
12767 /* Otherwise, emit an error about the invalid digraph, but continue
12768 parsing because we got our argument list. */
12771 {
12774 "%<<:%> is an alternate spelling for %<[%>."
12777 {
12779 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
12782 }
12783 }
12784 }
12785 else
12786 {
12787 /* Look for the `<' that starts the template-argument-list. */
12789 {
12792 }
12793 /* Parse the arguments. */
12795 }
12797 /* Build a representation of the specialization. */
12800 TEMPLATE_ID_EXPR,
12804 {
12806 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
12807 template (rather than some instantiation thereof) only if
12808 is not nested within some other construct. For example, in
12809 "template <typename T> void f(T) { A<T>::", A<T> is just an
12810 instantiation of A. */
12813 CPP_SCOPE));
12814 template_id
12816 }
12817 else
12818 {
12819 /* If it's not a class-template or a template-template, it should be
12820 a function-template. */
12826 }
12828 /* If parsing tentatively, replace the sequence of tokens that makes
12829 up the template-id with a CPP_TEMPLATE_ID token. That way,
12830 should we re-parse the token stream, we will not have to repeat
12831 the effort required to do the parse, nor will we issue duplicate
12832 error messages about problems during instantiation of the
12833 template. */
12835 /* Don't do this if we had a parse error in a declarator; re-parsing
12836 might succeed if a name changes meaning (60361). */
12840 {
12843 /* Reset the contents of the START_OF_ID token. */
12845 /* Retrieve any deferred checks. Do not pop this access checks yet
12846 so the memory will not be reclaimed during token replacing below. */
12852 /* Purge all subsequent tokens. */
12855 /* ??? Can we actually assume that, if template_id ==
12856 error_mark_node, we will have issued a diagnostic to the
12857 user, as opposed to simply marking the tentative parse as
12858 failed? */
12861 }
12865 }
12867 /* Parse a template-name.
12869 template-name:
12870 identifier
12872 The standard should actually say:
12874 template-name:
12875 identifier
12876 operator-function-id
12878 A defect report has been filed about this issue.
12880 A conversion-function-id cannot be a template name because they cannot
12881 be part of a template-id. In fact, looking at this code:
12883 a.operator K<int>()
12885 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
12886 It is impossible to call a templated conversion-function-id with an
12887 explicit argument list, since the only allowed template parameter is
12888 the type to which it is converting.
12890 If TEMPLATE_KEYWORD_P is true, then we have just seen the
12891 `template' keyword, in a construction like:
12893 T::template f<3>()
12895 In that case `f' is taken to be a template-name, even though there
12896 is no way of knowing for sure.
12898 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
12899 name refers to a set of overloaded functions, at least one of which
12900 is a template, or an IDENTIFIER_NODE with the name of the template,
12901 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
12902 names are looked up inside uninstantiated templates. */
12904 static tree
12911 {
12912 tree identifier;
12913 tree decl;
12914 tree fns;
12917 /* If the next token is `operator', then we have either an
12918 operator-function-id or a conversion-function-id. */
12920 {
12921 /* We don't know whether we're looking at an
12922 operator-function-id or a conversion-function-id. */
12924 /* Try an operator-function-id. */
12926 /* If that didn't work, try a conversion-function-id. */
12928 {
12931 }
12932 }
12933 /* Look for the identifier. */
12934 else
12937 /* If we didn't find an identifier, we don't have a template-id. */
12941 /* If the name immediately followed the `template' keyword, then it
12942 is a template-name. However, if the next token is not `<', then
12943 we do not treat it as a template-name, since it is not being used
12944 as part of a template-id. This enables us to handle constructs
12945 like:
12947 template <typename T> struct S { S(); };
12948 template <typename T> S<T>::S();
12950 correctly. We would treat `S' as a template -- if it were `S<T>'
12951 -- but we do not if there is no `<'. */
12955 {
12956 /* In a declaration, in a dependent context, we pretend that the
12957 "template" keyword was present in order to improve error
12958 recovery. For example, given:
12960 template <typename T> void f(T::X<int>);
12962 we want to treat "X<int>" as a template-id. */
12964 && !template_keyword_p
12966 && check_dependency_p
12968 /* Do not do this for dtors (or ctors), since they never
12969 need the template keyword before their name. */
12971 {
12974 /* Explain what went wrong. */
12976 identifier);
12979 /* If parsing tentatively, find the location of the "<" token. */
12982 /* Parse the template arguments so that we can issue error
12983 messages about them. */
12986 /* Skip tokens until we find a good place from which to
12987 continue parsing. */
12992 /* If parsing tentatively, permanently remove the
12993 template argument list. That will prevent duplicate
12994 error messages from being issued about the missing
12995 "template" keyword. */
13001 }
13003 /* If the "template" keyword is present, then there is generally
13004 no point in doing name-lookup, so we just return IDENTIFIER.
13005 But, if the qualifying scope is non-dependent then we can
13006 (and must) do name-lookup normally. */
13012 }
13014 /* Look up the name. */
13016 tag_type,
13019 check_dependency_p,
13023 /* If DECL is a template, then the name was a template-name. */
13025 ;
13026 else
13027 {
13030 /* The standard does not explicitly indicate whether a name that
13031 names a set of overloaded declarations, some of which are
13032 templates, is a template-name. However, such a name should
13033 be a template-name; otherwise, there is no way to form a
13034 template-id for the overloaded templates. */
13042 {
13043 /* The name does not name a template. */
13046 }
13047 }
13049 /* If DECL is dependent, and refers to a function, then just return
13050 its name; we will look it up again during template instantiation. */
13052 {
13056 }
13059 }
13061 /* Parse a template-argument-list.
13063 template-argument-list:
13064 template-argument ... [opt]
13065 template-argument-list , template-argument ... [opt]
13067 Returns a TREE_VEC containing the arguments. */
13069 static tree
13071 {
13076 tree vec;
13083 /* Even if the template-id appears in an integral
13084 constant-expression, the contents of the argument list do
13085 not. */
13091 /* Parse the arguments. */
13092 do
13093 {
13094 tree argument;
13097 /* Consume the comma. */
13100 /* Parse the template-argument. */
13103 /* If the next token is an ellipsis, we're expanding a template
13104 argument pack. */
13106 {
13108 {
13112 }
13113 /* Consume the `...' token. */
13116 /* Make the argument into a TYPE_PACK_EXPANSION or
13117 EXPR_PACK_EXPANSION. */
13119 }
13122 {
13126 {
13129 }
13130 else
13132 }
13134 }
13147 #ifdef ENABLE_CHECKING
13149 #endif
13151 }
13153 /* Parse a template-argument.
13155 template-argument:
13156 assignment-expression
13157 type-id
13158 id-expression
13160 The representation is that of an assignment-expression, type-id, or
13161 id-expression -- except that the qualified id-expression is
13162 evaluated, so that the value returned is either a DECL or an
13163 OVERLOAD.
13165 Although the standard says "assignment-expression", it forbids
13166 throw-expressions or assignments in the template argument.
13167 Therefore, we use "conditional-expression" instead. */
13169 static tree
13171 {
13172 tree argument;
13178 cp_id_kind idk;
13180 /* There's really no way to know what we're looking at, so we just
13181 try each alternative in order.
13183 [temp.arg]
13185 In a template-argument, an ambiguity between a type-id and an
13186 expression is resolved to a type-id, regardless of the form of
13187 the corresponding template-parameter.
13189 Therefore, we try a type-id first. */
13192 /* If there was no error parsing the type-id but the next token is a
13193 '>>', our behavior depends on which dialect of C++ we're
13194 parsing. In C++98, we probably found a typo for '> >'. But there
13195 are type-id which are also valid expressions. For instance:
13197 struct X { int operator >> (int); };
13198 template <int V> struct Foo {};
13199 Foo<X () >> 5> r;
13201 Here 'X()' is a valid type-id of a function type, but the user just
13202 wanted to write the expression "X() >> 5". Thus, we remember that we
13203 found a valid type-id, but we still try to parse the argument as an
13204 expression to see what happens.
13206 In C++0x, the '>>' will be considered two separate '>'
13207 tokens. */
13211 {
13214 }
13215 else
13216 {
13217 /* If the next token isn't a `,' or a `>', then this argument wasn't
13218 really finished. This means that the argument is not a valid
13219 type-id. */
13222 /* If that worked, we're done. */
13225 }
13226 /* We're still not sure what the argument will be. */
13228 /* Try a template. */
13236 /* If the next token isn't a `,' or a `>', then this argument wasn't
13237 really finished. */
13241 {
13242 /* Figure out what is being referred to. If the id-expression
13243 was for a class template specialization, then we will have a
13244 TYPE_DECL at this point. There is no need to do name lookup
13245 at this point in that case. */
13248 none_type,
13257 }
13260 /* It must be a non-type argument. There permitted cases are given
13261 in [temp.arg.nontype]:
13263 -- an integral constant-expression of integral or enumeration
13264 type; or
13266 -- the name of a non-type template-parameter; or
13268 -- the name of an object or function with external linkage...
13270 -- the address of an object or function with external linkage...
13272 -- a pointer to member... */
13273 /* Look for a non-type template parameter. */
13275 {
13287 }
13289 /* If the next token is "&", the argument must be the address of an
13290 object or function with external linkage. */
13293 {
13296 }
13297 /* See if we might have an id-expression. */
13304 {
13307 address_p,
13314 else
13315 {
13316 tree probe;
13319 {
13322 }
13324 /* If we're in a template, we represent a qualified-id referring
13325 to a static data member as a SCOPE_REF even if the scope isn't
13326 dependent so that we can check access control later. */
13331 {
13332 /* A variable without external linkage might still be a
13333 valid constant-expression, so no error is issued here
13334 if the external-linkage check fails. */
13337 }
13339 /* All overloaded functions are allowed; if the external
13340 linkage test does not pass, an error will be issued
13341 later. */
13342 ;
13346 /* A pointer-to-member. */
13347 ;
13349 ;
13350 else
13354 {
13357 tf_warning_or_error);
13359 }
13360 }
13361 }
13362 /* If the argument started with "&", there are no other valid
13363 alternatives at this point. */
13365 {
13368 }
13370 /* If the argument wasn't successfully parsed as a type-id followed
13371 by '>>', the argument can only be a constant expression now.
13372 Otherwise, we try parsing the constant-expression tentatively,
13373 because the argument could really be a type-id. */
13386 /* We did our best to parse the argument as a non type-id, but that
13387 was the only alternative that matched (albeit with a '>' after
13388 it). We can assume it's just a typo from the user, and a
13389 diagnostic will then be issued. */
13391 }
13393 /* Parse an explicit-instantiation.
13395 explicit-instantiation:
13396 template declaration
13398 Although the standard says `declaration', what it really means is:
13400 explicit-instantiation:
13401 template decl-specifier-seq [opt] declarator [opt] ;
13403 Things like `template int S<int>::i = 5, int S<double>::j;' are not
13404 supposed to be allowed. A defect report has been filed about this
13405 issue.
13407 GNU Extension:
13409 explicit-instantiation:
13410 storage-class-specifier template
13411 decl-specifier-seq [opt] declarator [opt] ;
13412 function-specifier template
13413 decl-specifier-seq [opt] declarator [opt] ; */
13415 static void
13417 {
13419 cp_decl_specifier_seq decl_specifiers;
13424 /* Look for an (optional) storage-class-specifier or
13425 function-specifier. */
13427 {
13428 extension_specifier
13431 extension_specifier
13434 }
13436 /* Look for the `template' keyword. */
13438 /* Let the front end know that we are processing an explicit
13439 instantiation. */
13441 /* [temp.explicit] says that we are supposed to ignore access
13442 control while processing explicit instantiation directives. */
13444 /* Parse a decl-specifier-seq. */
13446 CP_PARSER_FLAGS_OPTIONAL,
13449 /* If there was exactly one decl-specifier, and it declared a class,
13450 and there's no declarator, then we have an explicit type
13451 instantiation. */
13453 {
13454 tree type;
13458 /* Turn access control back on for names used during
13459 template instantiation. */
13464 }
13465 else
13466 {
13468 tree decl;
13470 /* Parse the declarator. */
13471 declarator
13481 {
13484 "explicit instantiation shall not use"
13488 "explicit instantiation shall not use"
13493 /* Turn access control back on for names used during
13494 template instantiation. */
13496 /* Do the explicit instantiation. */
13498 }
13499 else
13500 {
13502 /* Skip the body of the explicit instantiation. */
13504 }
13505 }
13506 /* We're done with the instantiation. */
13512 }
13514 /* Parse an explicit-specialization.
13516 explicit-specialization:
13517 template < > declaration
13519 Although the standard says `declaration', what it really means is:
13521 explicit-specialization:
13522 template <> decl-specifier [opt] init-declarator [opt] ;
13523 template <> function-definition
13524 template <> explicit-specialization
13525 template <> template-declaration */
13527 static void
13529 {
13533 /* Look for the `template' keyword. */
13535 /* Look for the `<'. */
13537 /* Look for the `>'. */
13539 /* We have processed another parameter list. */
13541 /* [temp]
13543 A template ... explicit specialization ... shall not have C
13544 linkage. */
13546 {
13548 /* Give it C++ linkage to avoid confusing other parts of the
13549 front end. */
13552 }
13553 else
13555 /* Let the front end know that we are beginning a specialization. */
13557 {
13560 }
13562 /* If the next keyword is `template', we need to figure out whether
13563 or not we're looking a template-declaration. */
13565 {
13570 else
13572 }
13573 else
13574 /* Parse the dependent declaration. */
13580 /* We're done with the specialization. */
13582 /* For the erroneous case of a template with C linkage, we pushed an
13583 implicit C++ linkage scope; exit that scope now. */
13586 /* We're done with this parameter list. */
13588 }
13590 /* Parse a type-specifier.
13592 type-specifier:
13593 simple-type-specifier
13594 class-specifier
13595 enum-specifier
13596 elaborated-type-specifier
13597 cv-qualifier
13599 GNU Extension:
13601 type-specifier:
13602 __complex__
13604 Returns a representation of the type-specifier. For a
13605 class-specifier, enum-specifier, or elaborated-type-specifier, a
13606 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
13608 The parser flags FLAGS is used to control type-specifier parsing.
13610 If IS_DECLARATION is TRUE, then this type-specifier is appearing
13611 in a decl-specifier-seq.
13613 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
13614 class-specifier, enum-specifier, or elaborated-type-specifier, then
13615 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
13616 if a type is declared; 2 if it is defined. Otherwise, it is set to
13617 zero.
13619 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
13620 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
13621 is set to FALSE. */
13623 static tree
13625 cp_parser_flags flags,
13630 {
13636 /* Assume this type-specifier does not declare a new type. */
13639 /* And that it does not specify a cv-qualifier. */
13642 /* Peek at the next token. */
13645 /* If we're looking at a keyword, we can use that to guide the
13646 production we choose. */
13649 {
13654 /* Look for the enum-specifier. */
13656 /* If that worked, we're done. */
13658 {
13663 type_spec,
13664 token,
13667 }
13668 else
13671 /* Any of these indicate either a class-specifier, or an
13672 elaborated-type-specifier. */
13679 /* Parse tentatively so that we can back up if we don't find a
13680 class-specifier. */
13682 /* Look for the class-specifier. */
13685 /* If that worked, we're done. */
13687 {
13692 type_spec,
13693 token,
13696 }
13698 /* Fall through. */
13699 elaborated_type_specifier:
13700 /* We're declaring (not defining) a class or enum. */
13704 /* Fall through. */
13706 /* Look for an elaborated-type-specifier. */
13707 type_spec
13708 = (cp_parser_elaborated_type_specifier
13711 is_declaration));
13714 type_spec,
13715 token,
13738 /* The `__complex__' keyword is a GNU extension. */
13744 }
13746 /* Handle simple keywords. */
13748 {
13750 {
13753 }
13755 }
13757 /* If we do not already have a type-specifier, assume we are looking
13758 at a simple-type-specifier. */
13760 decl_specs,
13761 flags);
13763 /* If we didn't find a type-specifier, and a type-specifier was not
13764 optional in this context, issue an error message. */
13766 {
13769 }
13772 }
13774 /* Parse a simple-type-specifier.
13776 simple-type-specifier:
13777 :: [opt] nested-name-specifier [opt] type-name
13778 :: [opt] nested-name-specifier template template-id
13779 char
13780 wchar_t
13781 bool
13782 short
13783 int
13784 long
13785 signed
13786 unsigned
13787 float
13788 double
13789 void
13791 C++0x Extension:
13793 simple-type-specifier:
13794 auto
13795 decltype ( expression )
13796 char16_t
13797 char32_t
13798 __underlying_type ( type-id )
13800 GNU Extension:
13802 simple-type-specifier:
13803 __int128
13804 __typeof__ unary-expression
13805 __typeof__ ( type-id )
13807 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
13808 appropriately updated. */
13810 static tree
13813 cp_parser_flags flags)
13814 {
13818 /* Peek at the next token. */
13821 /* If we're looking at a keyword, things are easy. */
13823 {
13886 /* Since DR 743, decltype can either be a simple-type-specifier by
13887 itself or begin a nested-name-specifier. Parsing it will replace
13888 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
13889 handling below decide what to do. */
13895 /* Consume the `typeof' token. */
13897 /* Parse the operand to `typeof'. */
13899 /* If it is not already a TYPE, take its type. */
13905 token,
13914 token,
13924 token,
13929 }
13931 /* If token is an already-parsed decltype not followed by ::,
13932 it's a simple-type-specifier. */
13935 {
13939 token,
13943 }
13945 /* If the type-specifier was for a built-in type, we're done. */
13947 {
13948 /* Record the type. */
13955 type,
13956 token,
13961 /* Consume the token. */
13964 /* There is no valid C++ program where a non-template type is
13965 followed by a "<". That usually indicates that the user thought
13966 that the type was a template. */
13971 }
13973 /* The type-specifier must be a user-defined type. */
13975 {
13979 /* Don't gobble tokens or issue error messages if this is an
13980 optional type-specifier. */
13984 /* Look for the optional `::' operator. */
13985 global_p
13989 /* Look for the nested-name specifier. */
13990 qualified_p
13998 /* If we have seen a nested-name-specifier, and the next token
13999 is `template', then we are using the template-id production. */
14002 {
14003 /* Look for the template-id. */
14007 none_type,
14009 /* If the template-id did not name a type, we are out of
14010 luck. */
14012 {
14015 }
14016 }
14017 /* Otherwise, look for a type-name. */
14018 else
14020 /* Keep track of all name-lookups performed in class scopes. */
14022 && !global_p
14023 && !qualified_p
14027 /* If it didn't work out, we don't have a TYPE. */
14033 token,
14035 }
14037 /* If we didn't get a type-name, issue an error message. */
14039 {
14042 }
14045 {
14046 /* See if TYPE is an Objective-C type, and if so, parse and
14047 accept any protocol references following it. Do this before
14048 the cp_parser_check_for_invalid_template_id() call, because
14049 Objective-C types can be followed by '<...>' which would
14050 enclose protocol names rather than template arguments, and so
14051 everything is fine. */
14054 {
14058 /* Clobber the "unqualified" type previously entered into
14059 DECL_SPECS with the new, improved protocol-qualified version. */
14064 }
14066 /* There is no valid C++ program where a non-template type is
14067 followed by a "<". That usually indicates that the user
14068 thought that the type was a template. */
14070 none_type,
14072 }
14075 }
14077 /* Parse a type-name.
14079 type-name:
14080 class-name
14081 enum-name
14082 typedef-name
14083 simple-template-id [in c++0x]
14085 enum-name:
14086 identifier
14088 typedef-name:
14089 identifier
14091 Returns a TYPE_DECL for the type. */
14093 static tree
14095 {
14096 tree type_decl;
14098 /* We can't know yet whether it is a class-name or not. */
14100 /* Try a class-name. */
14104 none_type,
14108 /* If it's not a class-name, keep looking. */
14110 {
14112 /* It must be a typedef-name or an enum-name. */
14116 /* It is either a simple-template-id representing an
14117 instantiation of an alias template... */
14121 none_type,
14123 /* Note that this must be an instantiation of an alias template
14124 because [temp.names]/6 says:
14126 A template-id that names an alias template specialization
14127 is a type-name.
14129 Whereas [temp.names]/7 says:
14131 A simple-template-id that names a class template
14132 specialization is a class-name. */
14137 else
14141 /* ... Or a typedef-name or an enum-name. */
14143 }
14146 }
14148 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
14150 enum-name:
14151 identifier
14153 typedef-name:
14154 identifier
14156 Returns a TYPE_DECL for the type. */
14158 static tree
14160 {
14161 tree type_decl;
14162 tree identifier;
14169 /* Look up the type-name. */
14176 {
14177 /* See if this is an Objective-C type. */
14182 }
14184 /* Issue an error if we did not find a type-name. */
14186 /* In Objective-C, we have the complication that class names are
14187 normally type names and start declarations (eg, the
14188 "NSObject" in "NSObject *object;"), but can be used in an
14189 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
14190 is an expression. So, a classname followed by a dot is not a
14191 valid type-name. */
14194 {
14199 }
14200 /* Remember that the name was used in the definition of the
14201 current class so that we can check later to see if the
14202 meaning would have been different after the class was
14203 entirely defined. */
14209 }
14211 /* Parse an elaborated-type-specifier. Note that the grammar given
14212 here incorporates the resolution to DR68.
14214 elaborated-type-specifier:
14215 class-key :: [opt] nested-name-specifier [opt] identifier
14216 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
14217 enum-key :: [opt] nested-name-specifier [opt] identifier
14218 typename :: [opt] nested-name-specifier identifier
14219 typename :: [opt] nested-name-specifier template [opt]
14220 template-id
14222 GNU extension:
14224 elaborated-type-specifier:
14225 class-key attributes :: [opt] nested-name-specifier [opt] identifier
14226 class-key attributes :: [opt] nested-name-specifier [opt]
14227 template [opt] template-id
14228 enum attributes :: [opt] nested-name-specifier [opt] identifier
14230 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
14231 declared `friend'. If IS_DECLARATION is TRUE, then this
14232 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
14233 something is being declared.
14235 Returns the TYPE specified. */
14237 static tree
14241 {
14243 tree identifier;
14246 tree globalscope;
14249 /* See if we're looking at the `enum' keyword. */
14251 {
14252 /* Consume the `enum' token. */
14254 /* Remember that it's an enumeration type. */
14256 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
14257 enums) is used here. */
14260 {
14264 /* Consume the `struct' or `class' and parse it anyway. */
14266 }
14267 /* Parse the attributes. */
14269 }
14270 /* Or, it might be `typename'. */
14272 RID_TYPENAME))
14273 {
14274 /* Consume the `typename' token. */
14276 /* Remember that it's a `typename' type. */
14278 }
14279 /* Otherwise it must be a class-key. */
14280 else
14281 {
14285 /* Parse the attributes. */
14287 }
14289 /* Look for the `::' operator. */
14292 /* Look for the nested-name-specifier. */
14294 {
14299 is_declaration))
14301 }
14302 else
14303 /* Even though `typename' is not present, the proposed resolution
14304 to Core Issue 180 says that in `class A<T>::B', `B' should be
14305 considered a type-name, even if `A<T>' is dependent. */
14310 is_declaration);
14311 /* For everything but enumeration types, consider a template-id.
14312 For an enumeration type, consider only a plain identifier. */
14314 {
14316 tree decl;
14318 /* Allow the `template' keyword. */
14320 /* If we didn't see `template', we don't know if there's a
14321 template-id or not. */
14324 /* Parse the template-id. */
14328 tag_type,
14329 is_declaration);
14330 /* If we didn't find a template-id, look for an ordinary
14331 identifier. */
14333 ;
14334 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
14335 in effect, then we must assume that, upon instantiation, the
14336 template will correspond to a class. */
14340 typename_type,
14342 /* If the `typename' keyword is in effect and DECL is not a type
14343 decl, then type is non existent. */
14345 ;
14351 }
14354 {
14359 {
14362 }
14364 /* For a `typename', we needn't call xref_tag. */
14368 identifier,
14370 /* Look up a qualified name in the usual way. */
14372 {
14373 tree decl;
14374 tree ambiguous_decls;
14377 tag_type,
14384 /* If the lookup was ambiguous, an error will already have been
14385 issued. */
14389 /* If we are parsing friend declaration, DECL may be a
14390 TEMPLATE_DECL tree node here. However, we need to check
14391 whether this TEMPLATE_DECL results in valid code. Consider
14392 the following example:
14394 namespace N {
14395 template <class T> class C {};
14396 }
14397 class X {
14398 template <class T> friend class N::C; // #1, valid code
14399 };
14400 template <class T> class Y {
14401 friend class N::C; // #2, invalid code
14402 };
14404 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
14405 name lookup of `N::C'. We see that friend declaration must
14406 be template for the code to be valid. Note that
14407 processing_template_decl does not work here since it is
14408 always 1 for the above two cases. */
14410 decl = (cp_parser_maybe_treat_template_as_class
14415 {
14418 identifier,
14421 }
14424 {
14428 allow_template);
14432 }
14434 /* Forward declarations of nested types, such as
14436 class C1::C2;
14437 class C1::C2::C3;
14439 are invalid unless all components preceding the final '::'
14440 are complete. If all enclosing types are complete, these
14441 declarations become merely pointless.
14443 Invalid forward declarations of nested types are errors
14444 caught elsewhere in parsing. Those that are pointless arrive
14445 here. */
14452 }
14453 else
14454 {
14455 /* An elaborated-type-specifier sometimes introduces a new type and
14456 sometimes names an existing type. Normally, the rule is that it
14457 introduces a new type only if there is not an existing type of
14458 the same name already in scope. For example, given:
14460 struct S {};
14461 void f() { struct S s; }
14463 the `struct S' in the body of `f' is the same `struct S' as in
14464 the global scope; the existing definition is used. However, if
14465 there were no global declaration, this would introduce a new
14466 local class named `S'.
14468 An exception to this rule applies to the following code:
14470 namespace N { struct S; }
14472 Here, the elaborated-type-specifier names a new type
14473 unconditionally; even if there is already an `S' in the
14474 containing scope this declaration names a new type.
14475 This exception only applies if the elaborated-type-specifier
14476 forms the complete declaration:
14478 [class.name]
14480 A declaration consisting solely of `class-key identifier ;' is
14481 either a redeclaration of the name in the current scope or a
14482 forward declaration of the identifier as a class name. It
14483 introduces the name into the current scope.
14485 We are in this situation precisely when the next token is a `;'.
14487 An exception to the exception is that a `friend' declaration does
14488 *not* name a new type; i.e., given:
14490 struct S { friend struct T; };
14492 `T' is not a new type in the scope of `S'.
14494 Also, `new struct S' or `sizeof (struct S)' never results in the
14495 definition of a new type; a new type can only be declared in a
14496 declaration context. */
14498 tag_scope ts;
14502 /* Friends have special name lookup rules. */
14506 CPP_SEMICOLON))
14507 /* This is a `class-key identifier ;' */
14509 else
14512 template_p =
14516 /* An unqualified name was used to reference this type, so
14517 there were no qualifying templates. */
14524 }
14525 }
14530 /* Allow attributes on forward declarations of classes. */
14532 {
14542 else
14545 }
14548 {
14549 /* Indicate whether this class was declared as a `class' or as a
14550 `struct'. */
14554 }
14556 /* A "<" cannot follow an elaborated type specifier. If that
14557 happens, the user was probably trying to form a template-id. */
14562 }
14564 /* Parse an enum-specifier.
14566 enum-specifier:
14567 enum-head { enumerator-list [opt] }
14568 enum-head { enumerator-list , } [C++0x]
14570 enum-head:
14571 enum-key identifier [opt] enum-base [opt]
14572 enum-key nested-name-specifier identifier enum-base [opt]
14574 enum-key:
14575 enum
14576 enum class [C++0x]
14577 enum struct [C++0x]
14579 enum-base: [C++0x]
14580 : type-specifier-seq
14582 opaque-enum-specifier:
14583 enum-key identifier enum-base [opt] ;
14585 GNU Extensions:
14586 enum-key attributes[opt] identifier [opt] enum-base [opt]
14587 { enumerator-list [opt] }attributes[opt]
14588 enum-key attributes[opt] identifier [opt] enum-base [opt]
14589 { enumerator-list, }attributes[opt] [C++0x]
14591 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
14592 if the token stream isn't an enum-specifier after all. */
14594 static tree
14596 {
14597 tree identifier;
14599 tree prev_scope;
14601 tree attributes;
14614 /* Parse tentatively so that we can back up if we don't find a
14615 enum-specifier. */
14618 /* Caller guarantees that the current token is 'enum', an identifier
14619 possibly follows, and the token after that is an opening brace.
14620 If we don't have an identifier, fabricate an anonymous name for
14621 the enumeration being defined. */
14624 /* Parse the "class" or "struct", which indicates a scoped
14625 enumeration type in C++0x. */
14628 {
14632 /* Consume the `struct' or `class' token. */
14636 }
14640 /* Clear the qualification. */
14645 /* Figure out in what scope the declaration is being placed. */
14651 nested_name_specifier
14659 {
14660 tree name;
14664 enum_type,
14669 input_location);
14671 {
14674 {
14675 /* Are template enums allowed in ISO? */
14679 /* ignore a typename reference, for it will be solved by name
14680 in start_enum. */
14682 }
14683 }
14684 else
14687 }
14688 else
14689 {
14692 else
14693 {
14696 }
14697 }
14700 /* Check for the `:' that denotes a specified underlying type in C++0x.
14701 Note that a ':' could also indicate a bitfield width, however. */
14703 {
14704 cp_decl_specifier_seq type_specifiers;
14706 /* Consume the `:'. */
14709 /* Parse the type-specifier-seq. */
14714 /* At this point this is surely not elaborated type specifier. */
14723 /* If that didn't work, stop. */
14725 {
14731 }
14732 }
14734 /* Look for the `{' but don't consume it yet. */
14736 {
14738 {
14741 {
14744 }
14745 }
14746 /* An opaque-enum-specifier must have a ';' here. */
14749 {
14752 {
14755 }
14756 }
14757 }
14763 {
14765 {
14769 }
14771 {
14773 }
14774 }
14776 /* Issue an error message if type-definitions are forbidden here. */
14779 else
14780 /* Create the new type. We do this before consuming the opening
14781 brace so the enum will be recorded as being on the line of its
14782 tag (or the 'enum' keyword, if there is no tag). */
14786 /* If the next token is not '{' it is an opaque-enum-specifier or an
14787 elaborated-type-specifier. */
14789 {
14792 {
14793 /* The following catches invalid code such as:
14794 enum class S<int>::E { A, B, C }; */
14801 /* If that scope does not contain the scope in which the
14802 class was originally declared, the program is invalid. */
14804 {
14807 "declaration of %qD in namespace %qD which does not "
14810 else
14815 }
14816 }
14821 /* Consume the opening brace. */
14828 {
14832 }
14833 else
14834 {
14839 }
14843 /* If the next token is not '}', then there are some enumerators. */
14847 /* Consume the final '}'. */
14853 }
14854 else
14855 {
14856 /* If a ';' follows, then it is an opaque-enum-specifier
14857 and additional restrictions apply. */
14859 {
14866 }
14867 }
14869 /* Look for trailing attributes to apply to this enumeration, and
14870 apply them if appropriate. */
14872 {
14876 trailing_attr,
14878 }
14880 /* Finish up the enumeration. */
14882 {
14887 }
14890 {
14892 {
14895 }
14897 {
14899 }
14900 }
14901 out:
14904 }
14906 /* Parse an enumerator-list. The enumerators all have the indicated
14907 TYPE.
14909 enumerator-list:
14910 enumerator-definition
14911 enumerator-list , enumerator-definition */
14913 static void
14915 {
14917 {
14918 /* Parse an enumerator-definition. */
14921 /* If the next token is not a ',', we've reached the end of
14922 the list. */
14925 /* Otherwise, consume the `,' and keep going. */
14927 /* If the next token is a `}', there is a trailing comma. */
14929 {
14934 }
14935 }
14936 }
14938 /* Parse an enumerator-definition. The enumerator has the indicated
14939 TYPE.
14941 enumerator-definition:
14942 enumerator
14943 enumerator = constant-expression
14945 enumerator:
14946 identifier */
14948 static void
14950 {
14951 tree identifier;
14952 tree value;
14953 location_t loc;
14955 /* Save the input location because we are interested in the location
14956 of the identifier and not the location of the explicit value. */
14959 /* Look for the identifier. */
14964 /* If the next token is an '=', then there is an explicit value. */
14966 {
14967 /* Consume the `=' token. */
14969 /* Parse the value. */
14972 NULL);
14973 }
14974 else
14977 /* If we are processing a template, make sure the initializer of the
14978 enumerator doesn't contain any bare template parameter pack. */
14982 /* integral_constant_value will pull out this expression, so make sure
14983 it's folded as appropriate. */
14986 /* Create the enumerator. */
14988 }
14990 /* Parse a namespace-name.
14992 namespace-name:
14993 original-namespace-name
14994 namespace-alias
14996 Returns the NAMESPACE_DECL for the namespace. */
14998 static tree
15000 {
15001 tree identifier;
15002 tree namespace_decl;
15006 /* Get the name of the namespace. */
15011 /* Look up the identifier in the currently active scope. Look only
15012 for namespaces, due to:
15014 [basic.lookup.udir]
15016 When looking up a namespace-name in a using-directive or alias
15017 definition, only namespace names are considered.
15019 And:
15021 [basic.lookup.qual]
15023 During the lookup of a name preceding the :: scope resolution
15024 operator, object, function, and enumerator names are ignored.
15026 (Note that cp_parser_qualifying_entity only calls this
15027 function if the token after the name is the scope resolution
15028 operator.) */
15030 none_type,
15036 /* If it's not a namespace, issue an error. */
15039 {
15044 }
15047 }
15049 /* Parse a namespace-definition.
15051 namespace-definition:
15052 named-namespace-definition
15053 unnamed-namespace-definition
15055 named-namespace-definition:
15056 original-namespace-definition
15057 extension-namespace-definition
15059 original-namespace-definition:
15060 namespace identifier { namespace-body }
15062 extension-namespace-definition:
15063 namespace original-namespace-name { namespace-body }
15065 unnamed-namespace-definition:
15066 namespace { namespace-body } */
15068 static void
15070 {
15076 {
15080 }
15081 else
15084 /* Look for the `namespace' keyword. */
15087 /* Get the name of the namespace. We do not attempt to distinguish
15088 between an original-namespace-definition and an
15089 extension-namespace-definition at this point. The semantic
15090 analysis routines are responsible for that. */
15093 else
15096 /* Parse any specified attributes. */
15099 /* Look for the `{' to start the namespace. */
15101 /* Start the namespace. */
15104 /* "inline namespace" is equivalent to a stub namespace definition
15105 followed by a strong using directive. */
15107 {
15109 /* Set up namespace association. */
15113 /* Import the contents of the inline namespace. */
15117 }
15121 /* Parse the body of the namespace. */
15127 /* Finish the namespace. */
15129 /* Look for the final `}'. */
15131 }
15133 /* Parse a namespace-body.
15135 namespace-body:
15136 declaration-seq [opt] */
15138 static void
15140 {
15142 }
15144 /* Parse a namespace-alias-definition.
15146 namespace-alias-definition:
15147 namespace identifier = qualified-namespace-specifier ; */
15149 static void
15151 {
15152 tree identifier;
15153 tree namespace_specifier;
15157 /* Look for the `namespace' keyword. */
15159 /* Look for the identifier. */
15163 /* Look for the `=' token. */
15166 {
15168 /* Skip the definition. */
15173 }
15175 /* Look for the qualified-namespace-specifier. */
15176 namespace_specifier
15178 /* Look for the `;' token. */
15181 /* Register the alias in the symbol table. */
15183 }
15185 /* Parse a qualified-namespace-specifier.
15187 qualified-namespace-specifier:
15188 :: [opt] nested-name-specifier [opt] namespace-name
15190 Returns a NAMESPACE_DECL corresponding to the specified
15191 namespace. */
15193 static tree
15195 {
15196 /* Look for the optional `::'. */
15200 /* Look for the optional nested-name-specifier. */
15208 }
15210 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
15211 access declaration.
15213 using-declaration:
15214 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
15215 using :: unqualified-id ;
15217 access-declaration:
15218 qualified-id ;
15220 */
15222 static bool
15225 {
15229 tree decl;
15230 tree identifier;
15231 tree qscope;
15236 {
15239 }
15240 else
15241 {
15242 /* Look for the `using' keyword. */
15245 /* Peek at the next token. */
15247 /* See if it's `typename'. */
15249 {
15250 /* Remember that we've seen it. */
15252 /* Consume the `typename' token. */
15254 }
15255 }
15257 /* Look for the optional global scope qualification. */
15258 global_scope_p
15263 /* If we saw `typename', or didn't see `::', then there must be a
15264 nested-name-specifier present. */
15270 /* Otherwise, we could be in either of the two productions. In that
15271 case, treat the nested-name-specifier as optional. */
15272 else
15282 /* Something has already gone wrong; there's no need to parse
15283 further. Since an error has occurred, the return value of
15284 cp_parser_parse_definitely will be false, as required. */
15288 /* Parse the unqualified-id. */
15296 {
15301 }
15303 /* The function we call to handle a using-declaration is different
15304 depending on what scope we are in. */
15306 ;
15309 /* [namespace.udecl]
15311 A using declaration shall not name a template-id. */
15314 else
15315 {
15317 {
15318 /* Create the USING_DECL. */
15326 else
15327 /* Add it to the list of members in this class. */
15329 }
15330 else
15331 {
15333 identifier,
15343 else
15345 }
15346 }
15348 /* Look for the final `;'. */
15353 "access declarations are deprecated "
15354 "in favour of using-declarations; "
15358 }
15360 /* Parse an alias-declaration.
15362 alias-declaration:
15363 using identifier attribute-specifier-seq [opt] = type-id */
15365 static tree
15367 {
15369 location_t id_location;
15371 cp_decl_specifier_seq decl_specs;
15375 /* Look for the `using' keyword. */
15376 cp_token *using_token
15398 /* Now we are going to parse the type-id of the declaration. */
15400 /*
15401 [dcl.type]/3 says:
15403 "A type-specifier-seq shall not define a class or enumeration
15404 unless it appears in the type-id of an alias-declaration (7.1.3) that
15405 is not the declaration of a template-declaration."
15407 In other words, if we currently are in an alias template, the
15408 type-id should not define a type.
15410 So let's set parser->type_definition_forbidden_message in that
15411 case; cp_parser_check_type_definition (called by
15412 cp_parser_class_specifier) will then emit an error if a type is
15413 defined in the type-id. */
15415 {
15419 }
15423 /* Restore the error message if need be. */
15428 {
15431 }
15436 {
15439 }
15441 /* A typedef-name can also be introduced by an alias-declaration. The
15442 identifier following the using keyword becomes a typedef-name. It has
15443 the same semantics as if it were introduced by the typedef
15444 specifier. In particular, it does not define a new type and it shall
15445 not appear in the type-id. */
15450 {
15453 ds_attribute,
15454 attrs_token);
15455 }
15457 ds_typedef,
15458 using_token);
15460 ds_alias,
15461 using_token);
15470 else
15481 /* If decl is a template, return its TEMPLATE_DECL so that it gets
15482 added into the symbol table; otherwise, return the TYPE_DECL. */
15486 {
15490 }
15493 }
15495 /* Parse a using-directive.
15497 using-directive:
15498 using namespace :: [opt] nested-name-specifier [opt]
15499 namespace-name ; */
15501 static void
15503 {
15504 tree namespace_decl;
15505 tree attribs;
15507 /* Look for the `using' keyword. */
15509 /* And the `namespace' keyword. */
15511 /* Look for the optional `::' operator. */
15513 /* And the optional nested-name-specifier. */
15519 /* Get the namespace being used. */
15521 /* And any specified attributes. */
15523 /* Update the symbol table. */
15525 /* Look for the final `;'. */
15527 }
15529 /* Parse an asm-definition.
15531 asm-definition:
15532 asm ( string-literal ) ;
15534 GNU Extension:
15536 asm-definition:
15537 asm volatile [opt] ( string-literal ) ;
15538 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
15539 asm volatile [opt] ( string-literal : asm-operand-list [opt]
15540 : asm-operand-list [opt] ) ;
15541 asm volatile [opt] ( string-literal : asm-operand-list [opt]
15542 : asm-operand-list [opt]
15543 : asm-clobber-list [opt] ) ;
15544 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
15545 : asm-clobber-list [opt]
15546 : asm-goto-list ) ; */
15548 static void
15550 {
15551 tree string;
15556 tree asm_stmt;
15564 /* Look for the `asm' keyword. */
15566 /* See if the next token is `volatile'. */
15569 {
15570 /* Remember that we saw the `volatile' keyword. */
15572 /* Consume the token. */
15574 }
15578 {
15579 /* Remember that we saw the `goto' keyword. */
15581 /* Consume the token. */
15583 }
15584 /* Look for the opening `('. */
15587 /* Look for the string. */
15590 {
15594 }
15596 /* If we're allowing GNU extensions, check for the extended assembly
15597 syntax. Unfortunately, the `:' tokens need not be separated by
15598 a space in C, and so, for compatibility, we tolerate that here
15599 too. Doing that means that we have to treat the `::' operator as
15600 two `:' tokens. */
15605 {
15610 /* The extended syntax was used. */
15613 /* Look for outputs. */
15615 {
15616 /* Consume the `:'. */
15618 /* Parse the output-operands. */
15620 CPP_COLON)
15622 CPP_SCOPE)
15624 CPP_CLOSE_PAREN)
15630 }
15631 /* If the next token is `::', there are no outputs, and the
15632 next token is the beginning of the inputs. */
15634 /* The inputs are coming next. */
15637 /* Look for inputs. */
15640 {
15641 /* Consume the `:' or `::'. */
15643 /* Parse the output-operands. */
15645 CPP_COLON)
15647 CPP_SCOPE)
15649 CPP_CLOSE_PAREN))
15654 }
15656 /* The clobbers are coming next. */
15659 /* Look for clobbers. */
15662 {
15664 /* Consume the `:' or `::'. */
15666 /* Parse the clobbers. */
15668 CPP_COLON)
15670 CPP_CLOSE_PAREN))
15672 }
15675 /* The labels are coming next. */
15678 /* Look for labels. */
15681 {
15683 /* Consume the `:' or `::'. */
15685 /* Parse the labels. */
15687 }
15691 }
15695 /* Look for the closing `)'. */
15703 {
15704 /* Create the ASM_EXPR. */
15706 {
15709 /* If the extended syntax was not used, mark the ASM_EXPR. */
15711 {
15717 }
15718 }
15719 else
15721 }
15722 }
15724 /* Declarators [gram.dcl.decl] */
15726 /* Parse an init-declarator.
15728 init-declarator:
15729 declarator initializer [opt]
15731 GNU Extension:
15733 init-declarator:
15734 declarator asm-specification [opt] attributes [opt] initializer [opt]
15736 function-definition:
15737 decl-specifier-seq [opt] declarator ctor-initializer [opt]
15738 function-body
15739 decl-specifier-seq [opt] declarator function-try-block
15741 GNU Extension:
15743 function-definition:
15744 __extension__ function-definition
15746 TM Extension:
15748 function-definition:
15749 decl-specifier-seq [opt] declarator function-transaction-block
15751 The DECL_SPECIFIERS apply to this declarator. Returns a
15752 representation of the entity declared. If MEMBER_P is TRUE, then
15753 this declarator appears in a class scope. The new DECL created by
15754 this declarator is returned.
15756 The CHECKS are access checks that should be performed once we know
15757 what entity is being declared (and, therefore, what classes have
15758 befriended it).
15760 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
15761 for a function-definition here as well. If the declarator is a
15762 declarator for a function-definition, *FUNCTION_DEFINITION_P will
15763 be TRUE upon return. By that point, the function-definition will
15764 have been completely parsed.
15766 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
15767 is FALSE.
15769 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
15770 parsed declaration if it is an uninitialized single declarator not followed
15771 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
15772 if present, will not be consumed. If returned, this declarator will be
15773 created with SD_INITIALIZED but will not call cp_finish_decl. */
15775 static tree
15784 {
15788 tree prefix_attributes;
15790 tree asm_specification;
15791 tree initializer;
15793 tree scope;
15795 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
15796 initialized with "= ..", CPP_OPEN_PAREN if initialized with
15797 "(...)". */
15806 /* Gather the attributes that were provided with the
15807 decl-specifiers. */
15810 /* Assume that this is not the declarator for a function
15811 definition. */
15815 /* Defer access checks while parsing the declarator; we cannot know
15816 what names are accessible until we know what is being
15817 declared. */
15820 /* Parse the declarator. */
15822 declarator
15826 member_p);
15827 /* Gather up the deferred checks. */
15830 /* If the DECLARATOR was erroneous, there's no need to go
15831 further. */
15835 /* Check that the number of template-parameter-lists is OK. */
15845 /* Figure out what scope the entity declared by the DECLARATOR is
15846 located in. `grokdeclarator' sometimes changes the scope, so
15847 we compute it now. */
15850 /* Perform any lookups in the declared type which were thought to be
15851 dependent, but are not in the scope of the declarator. */
15852 decl_specifiers->type
15855 /* If we're allowing GNU extensions, look for an
15856 asm-specification. */
15858 {
15859 /* Look for an asm-specification. */
15862 }
15863 else
15866 /* Look for attributes. */
15870 /* Peek at the next token. */
15872 /* Check to see if the token indicates the start of a
15873 function-definition. */
15876 {
15878 {
15879 /* If a function-definition should not appear here, issue an
15880 error message. */
15884 }
15885 else
15886 {
15887 location_t func_brace_location
15890 /* Neither attributes nor an asm-specification are allowed
15891 on a function-definition. */
15894 "an asm-specification is not allowed "
15899 /* This is a function-definition. */
15902 /* Parse the function definition. */
15905 decl_specifiers,
15906 declarator,
15907 prefix_attributes);
15908 else
15909 decl
15910 = (cp_parser_function_definition_from_specifiers_and_declarator
15914 {
15915 /* This is where the prologue starts... */
15918 }
15921 }
15922 }
15924 /* [dcl.dcl]
15926 Only in function declarations for constructors, destructors, and
15927 type conversions can the decl-specifier-seq be omitted.
15929 We explicitly postpone this check past the point where we handle
15930 function-definitions because we tolerate function-definitions
15931 that are missing their return types in some modes. */
15933 {
15937 }
15939 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
15943 {
15951 {
15957 }
15958 }
15959 else
15960 {
15961 /* If the init-declarator isn't initialized and isn't followed by a
15962 `,' or `;', it's not a valid init-declarator. */
15965 {
15968 else
15969 {
15972 }
15973 }
15976 }
15978 /* Because start_decl has side-effects, we should only call it if we
15979 know we're going ahead. By this point, we know that we cannot
15980 possibly be looking at any other construct. */
15983 /* If the decl specifiers were bad, issue an error now that we're
15984 sure this was intended to be a declarator. Then continue
15985 declaring the variable(s), as int, to try to cut down on further
15986 errors. */
15989 {
15992 }
15994 /* Check to see whether or not this declaration is a friend. */
15997 /* Enter the newly declared entry in the symbol table. If we're
15998 processing a declaration in a class-specifier, we wait until
15999 after processing the initializer. */
16001 {
16008 /* Adjust location of decl if declarator->id_loc is more appropriate:
16009 set, and decl wasn't merged with another decl, in which case its
16010 location would be different from input_location, and more accurate. */
16015 }
16017 /* Enter the SCOPE. That way unqualified names appearing in the
16018 initializer will be looked up in SCOPE. */
16021 /* Perform deferred access control checks, now that we know in which
16022 SCOPE the declared entity resides. */
16024 {
16027 /* If the entity being declared is a function, pretend that we
16028 are in its scope. If it is a `friend', it may have access to
16029 things that would not otherwise be accessible. */
16031 {
16034 }
16036 /* Perform access checks for template parameters. */
16039 /* Perform the access control checks for the declarator and the
16040 decl-specifiers. */
16043 /* Restore the saved value. */
16046 }
16048 /* Parse the initializer. */
16053 {
16055 {
16059 else
16060 {
16061 /* If the declaration was erroneous, we don't really
16062 know what the user intended, so just silently
16063 consume the initializer. */
16071 }
16072 }
16073 else
16074 {
16075 /* We want to record the extra mangling scope for in-class
16076 initializers of class members and initializers of static data
16077 member templates. The former involves deferring
16078 parsing of the initializer until end of class as with default
16079 arguments. So right here we only handle the latter. */
16089 }
16090 }
16092 /* The old parser allows attributes to appear after a parenthesized
16093 initializer. Mark Mitchell proposed removing this functionality
16094 on the GCC mailing lists on 2002-08-13. This parser accepts the
16095 attributes -- but ignores them. */
16102 /* For an in-class declaration, use `grokfield' to create the
16103 declaration. */
16105 {
16107 {
16110 }
16114 prefix_attributes);
16117 }
16119 /* Finish processing the declaration. But, skip member
16120 declarations. */
16122 {
16125 asm_specification,
16126 /* If the initializer is in parentheses, then this is
16127 a direct-initialization, which means that an
16128 `explicit' constructor is OK. Otherwise, an
16129 `explicit' constructor cannot be used. */
16132 }
16135 /* Core issue #226 (C++0x only): A default template-argument
16136 shall not be specified in a friend class template
16137 declaration. */
16145 }
16147 /* Parse a declarator.
16149 declarator:
16150 direct-declarator
16151 ptr-operator declarator
16153 abstract-declarator:
16154 ptr-operator abstract-declarator [opt]
16155 direct-abstract-declarator
16157 GNU Extensions:
16159 declarator:
16160 attributes [opt] direct-declarator
16161 attributes [opt] ptr-operator declarator
16163 abstract-declarator:
16164 attributes [opt] ptr-operator abstract-declarator [opt]
16165 attributes [opt] direct-abstract-declarator
16167 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
16168 detect constructor, destructor or conversion operators. It is set
16169 to -1 if the declarator is a name, and +1 if it is a
16170 function. Otherwise it is set to zero. Usually you just want to
16171 test for >0, but internally the negative value is used.
16173 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
16174 a decl-specifier-seq unless it declares a constructor, destructor,
16175 or conversion. It might seem that we could check this condition in
16176 semantic analysis, rather than parsing, but that makes it difficult
16177 to handle something like `f()'. We want to notice that there are
16178 no decl-specifiers, and therefore realize that this is an
16179 expression, not a declaration.)
16181 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
16182 the declarator is a direct-declarator of the form "(...)".
16184 MEMBER_P is true iff this declarator is a member-declarator. */
16188 cp_parser_declarator_kind dcl_kind,
16192 {
16195 cp_cv_quals cv_quals;
16196 tree class_type;
16199 /* Assume this is not a constructor, destructor, or type-conversion
16200 operator. */
16207 /* Check for the ptr-operator production. */
16209 /* Parse the ptr-operator. */
16215 /* If that worked, then we have a ptr-operator. */
16217 {
16218 /* If a ptr-operator was found, then this declarator was not
16219 parenthesized. */
16222 /* The dependent declarator is optional if we are parsing an
16223 abstract-declarator. */
16227 /* Parse the dependent declarator. */
16233 /* If we are parsing an abstract-declarator, we must handle the
16234 case where the dependent declarator is absent. */
16239 declarator = cp_parser_make_indirect_declarator
16241 }
16242 /* Everything else is a direct-declarator. */
16243 else
16244 {
16247 CPP_OPEN_PAREN);
16249 ctor_dtor_or_conv_p,
16250 member_p);
16251 }
16256 }
16258 /* Parse a direct-declarator or direct-abstract-declarator.
16260 direct-declarator:
16261 declarator-id
16262 direct-declarator ( parameter-declaration-clause )
16263 cv-qualifier-seq [opt]
16264 ref-qualifier [opt]
16265 exception-specification [opt]
16266 direct-declarator [ constant-expression [opt] ]
16267 ( declarator )
16269 direct-abstract-declarator:
16270 direct-abstract-declarator [opt]
16271 ( parameter-declaration-clause )
16272 cv-qualifier-seq [opt]
16273 ref-qualifier [opt]
16274 exception-specification [opt]
16275 direct-abstract-declarator [opt] [ constant-expression [opt] ]
16276 ( abstract-declarator )
16278 Returns a representation of the declarator. DCL_KIND is
16279 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
16280 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
16281 we are parsing a direct-declarator. It is
16282 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
16283 of ambiguity we prefer an abstract declarator, as per
16284 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
16285 cp_parser_declarator. */
16289 cp_parser_declarator_kind dcl_kind,
16292 {
16302 {
16303 /* Peek at the next token. */
16306 {
16307 /* This is either a parameter-declaration-clause, or a
16308 parenthesized declarator. When we know we are parsing a
16309 named declarator, it must be a parenthesized declarator
16310 if FIRST is true. For instance, `(int)' is a
16311 parameter-declaration-clause, with an omitted
16312 direct-abstract-declarator. But `((*))', is a
16313 parenthesized abstract declarator. Finally, when T is a
16314 template parameter `(T)' is a
16315 parameter-declaration-clause, and not a parenthesized
16316 named declarator.
16318 We first try and parse a parameter-declaration-clause,
16319 and then try a nested declarator (if FIRST is true).
16321 It is not an error for it not to be a
16322 parameter-declaration-clause, even when FIRST is
16323 false. Consider,
16325 int i (int);
16326 int i (3);
16328 The first is the declaration of a function while the
16329 second is the definition of a variable, including its
16330 initializer.
16332 Having seen only the parenthesis, we cannot know which of
16333 these two alternatives should be selected. Even more
16334 complex are examples like:
16336 int i (int (a));
16337 int i (int (3));
16339 The former is a function-declaration; the latter is a
16340 variable initialization.
16342 Thus again, we try a parameter-declaration-clause, and if
16343 that fails, we back out and return. */
16346 {
16347 tree params;
16350 tree t;
16352 /* In a member-declarator, the only valid interpretation
16353 of a parenthesis is the start of a
16354 parameter-declaration-clause. (It is invalid to
16355 initialize a static data member with a parenthesized
16356 initializer; only the "=" form of initialization is
16357 permitted.) */
16361 /* Consume the `('. */
16364 {
16365 /* If this is going to be an abstract declarator, we're
16366 in a declarator and we can't have default args. */
16369 }
16371 /* Inside the function parameter list, surrounding
16372 template-parameter-lists do not apply. */
16373 saved_num_template_parameter_lists
16379 /* Parse the parameter-declaration-clause. */
16382 parser->num_template_parameter_lists
16385 /* Consume the `)'. */
16388 /* If all went well, parse the cv-qualifier-seq,
16389 ref-qualifier and the exception-specification. */
16391 {
16392 cp_cv_quals cv_quals;
16393 cp_virt_specifiers virt_specifiers;
16394 cp_ref_qualifier ref_qual;
16395 tree exception_specification;
16396 tree late_return;
16397 tree attrs;
16407 /* Parse the cv-qualifier-seq. */
16409 /* Parse the ref-qualifier. */
16411 /* And the exception-specification. */
16412 exception_specification
16417 late_return = (cp_parser_late_return_type_opt
16420 /* Parse the virt-specifier-seq. */
16423 /* Create the function-declarator. */
16425 params,
16426 cv_quals,
16427 virt_specifiers,
16428 ref_qual,
16429 exception_specification,
16430 late_return);
16432 /* Any subsequent parameter lists are to do with
16433 return type, so are not those of the declared
16434 function. */
16436 }
16438 /* Remove the function parms from scope. */
16444 /* Repeat the main loop. */
16446 }
16448 /* If this is the first, we can try a parenthesized
16449 declarator. */
16451 {
16457 /* Consume the `('. */
16459 /* Parse the nested declarator. */
16462 declarator
16465 member_p);
16468 /* Expect a `)'. */
16475 }
16476 /* Otherwise, we must be done. */
16477 else
16479 }
16483 {
16484 /* Parse an array-declarator. */
16493 /* Consume the `['. */
16495 /* Peek at the next token. */
16497 /* If the next token is `]', then there is no
16498 constant-expression. */
16500 {
16503 bounds
16513 {
16514 /* Normally, the array bound must be an integral constant
16515 expression. However, as an extension, we allow VLAs
16516 in function scopes as long as they aren't part of a
16517 parameter declaration. */
16521 }
16523 {
16524 /* Remember this wasn't a constant-expression. */
16527 }
16528 }
16529 else
16531 /* Look for the closing `]'. */
16533 {
16536 }
16541 }
16543 {
16544 {
16545 tree qualifying_scope;
16546 tree unqualified_name;
16547 tree attrs;
16548 special_function_kind sfk;
16553 /* Parse a declarator-id */
16556 {
16559 /* If we see an ellipsis, we should be looking at a
16560 parameter pack. */
16562 {
16563 /* Consume the `...' */
16567 }
16568 }
16571 unqualified_name
16575 {
16579 {
16580 /* Check whether an error occurred. */
16583 /* We already consumed the ellipsis to mark a
16584 parameter pack, but we have no way to report it,
16585 so abort the tentative parse. We will be exiting
16586 immediately anyway. */
16588 }
16589 else
16595 && (qualifying_scope
16598 {
16601 }
16602 }
16607 {
16612 }
16618 {
16619 /* In the declaration of a member of a template class
16620 outside of the class itself, the SCOPE will sometimes
16621 be a TYPENAME_TYPE. For example, given:
16623 template <typename T>
16624 int S<T>::R::i = 3;
16626 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
16627 this context, we must resolve S<T>::R to an ordinary
16628 type, rather than a typename type.
16630 The reason we normally avoid resolving TYPENAME_TYPEs
16631 is that a specialization of `S' might render
16632 `S<T>::R' not a type. However, if `S' is
16633 specialized, then this `i' will not be used, so there
16634 is no harm in resolving the types here. */
16635 tree type;
16637 /* Resolve the TYPENAME_TYPE. */
16640 /* If that failed, the declarator is invalid. */
16642 {
16645 "cannot define member of dependent typedef "
16647 else
16652 }
16654 }
16659 {
16660 tree class_type;
16665 else
16669 {
16672 {
16675 {
16679 "use %<%T::%D%> instead of %<%T::%D%> to "
16681 class_type,
16686 }
16687 else
16689 }
16690 else
16691 {
16692 /* We do not attempt to print the declarator
16693 here because we do not have enough
16694 information about its original syntactic
16695 form. */
16699 }
16700 }
16703 {
16709 for an anonymous type, even if the type
16710 got a name for linkage purposes. */
16713 class_type))
16714 {
16717 }
16725 }
16726 }
16728 unqualified_name,
16729 sfk);
16736 }
16738 handle_declarator:;
16741 /* Any names that appear after the declarator-id for a
16742 member are looked up in the containing scope. */
16747 /* Default args are only allowed on function
16748 declarations. */
16750 else
16754 }
16755 /* We're done. */
16756 else
16758 }
16760 /* For an abstract declarator, we might wind up with nothing at this
16761 point. That's an error; the declarator is not optional. */
16765 /* If we entered a scope, we must exit it now. */
16773 }
16775 /* Parse a ptr-operator.
16777 ptr-operator:
16778 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
16779 * cv-qualifier-seq [opt]
16780 &
16781 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
16782 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
16784 GNU Extension:
16786 ptr-operator:
16787 & cv-qualifier-seq [opt]
16789 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
16790 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
16791 an rvalue reference. In the case of a pointer-to-member, *TYPE is
16792 filled in with the TYPE containing the member. *CV_QUALS is
16793 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
16794 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
16795 Note that the tree codes returned by this function have nothing
16796 to do with the types of trees that will be eventually be created
16797 to represent the pointer or reference type being parsed. They are
16798 just constants with suggestive names. */
16799 static enum tree_code
16804 {
16809 /* Assume that it's not a pointer-to-member. */
16811 /* And that there are no cv-qualifiers. */
16814 /* Peek at the next token. */
16817 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
16827 {
16828 /* Consume the `*', `&' or `&&'. */
16831 /* A `*' can be followed by a cv-qualifier-seq, and so can a
16832 `&', if we are allowing GNU extensions. (The only qualifier
16833 that can legally appear after `&' is `restrict', but that is
16834 enforced during semantic analysis. */
16842 }
16843 else
16844 {
16845 /* Try the pointer-to-member case. */
16847 /* Look for the optional `::' operator. */
16850 /* Look for the nested-name specifier. */
16857 /* If we found it, and the next token is a `*', then we are
16858 indeed looking at a pointer-to-member operator. */
16861 {
16862 /* Indicate that the `*' operator was used. */
16870 else
16871 {
16872 /* The type of which the member is a member is given by the
16873 current SCOPE. */
16875 /* The next name will not be qualified. */
16879 /* Look for optional c++11 attributes. */
16883 /* Look for the optional cv-qualifier-seq. */
16885 }
16886 }
16887 /* If that didn't work we don't have a ptr-operator. */
16890 }
16893 }
16895 /* Parse an (optional) cv-qualifier-seq.
16897 cv-qualifier-seq:
16898 cv-qualifier cv-qualifier-seq [opt]
16900 cv-qualifier:
16901 const
16902 volatile
16904 GNU Extension:
16906 cv-qualifier:
16907 __restrict__
16909 Returns a bitmask representing the cv-qualifiers. */
16911 static cp_cv_quals
16913 {
16917 {
16919 cp_cv_quals cv_qualifier;
16921 /* Peek at the next token. */
16923 /* See if it's a cv-qualifier. */
16925 {
16941 }
16947 {
16950 }
16951 else
16952 {
16955 }
16956 }
16959 }
16961 /* Parse an (optional) ref-qualifier
16963 ref-qualifier:
16964 &
16965 &&
16967 Returns cp_ref_qualifier representing ref-qualifier. */
16969 static cp_ref_qualifier
16971 {
16975 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
16980 {
16987 }
16990 {
16992 }
16995 }
16997 /* Parse an (optional) virt-specifier-seq.
16999 virt-specifier-seq:
17000 virt-specifier virt-specifier-seq [opt]
17002 virt-specifier:
17003 override
17004 final
17006 Returns a bitmask representing the virt-specifiers. */
17008 static cp_virt_specifiers
17010 {
17014 {
17016 cp_virt_specifiers virt_specifier;
17018 /* Peek at the next token. */
17020 /* See if it's a virt-specifier-qualifier. */
17024 {
17027 }
17029 {
17032 }
17034 {
17036 }
17037 else
17041 {
17044 }
17045 else
17046 {
17049 }
17050 }
17052 }
17054 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
17055 is in scope even though it isn't real. */
17057 static void
17059 {
17060 tree this_parm;
17063 {
17064 /* We don't clear this between NSDMIs. Is it already what we want? */
17069 }
17072 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
17074 current_class_ref
17077 }
17079 /* Parse a late-specified return type, if any. This is not a separate
17080 non-terminal, but part of a function declarator, which looks like
17082 -> trailing-type-specifier-seq abstract-declarator(opt)
17084 Returns the type indicated by the type-id.
17086 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
17087 function. */
17089 static tree
17091 {
17093 tree type;
17095 /* Peek at the next token. */
17097 /* A late-specified return type is indicated by an initial '->'. */
17101 /* Consume the ->. */
17107 {
17108 /* DR 1207: 'this' is in scope in the trailing return type. */
17110 }
17115 {
17118 }
17121 }
17123 /* Parse a declarator-id.
17125 declarator-id:
17126 id-expression
17127 :: [opt] nested-name-specifier [opt] type-name
17129 In the `id-expression' case, the value returned is as for
17130 cp_parser_id_expression if the id-expression was an unqualified-id.
17131 If the id-expression was a qualified-id, then a SCOPE_REF is
17132 returned. The first operand is the scope (either a NAMESPACE_DECL
17133 or TREE_TYPE), but the second is still just a representation of an
17134 unqualified-id. */
17136 static tree
17138 {
17139 tree id;
17140 /* The expression must be an id-expression. Assume that qualified
17141 names are the names of types so that:
17143 template <class T>
17144 int S<T>::R::i = 3;
17146 will work; we must treat `S<T>::R' as the name of a type.
17147 Similarly, assume that qualified names are templates, where
17148 required, so that:
17150 template <class T>
17151 int S<T>::R<T>::i = 3;
17153 will work, too. */
17159 optional_p);
17163 }
17165 /* Parse a type-id.
17167 type-id:
17168 type-specifier-seq abstract-declarator [opt]
17170 Returns the TYPE specified. */
17172 static tree
17175 {
17176 cp_decl_specifier_seq type_specifier_seq;
17179 /* Parse the type-specifier-seq. */
17181 is_trailing_return,
17186 /* There might or might not be an abstract declarator. */
17188 /* Look for the declarator. */
17189 abstract_declarator
17193 /* Check to see if there really was a declarator. */
17199 {
17200 /* A type-id with type 'auto' is only ok if the abstract declarator
17201 is a function declarator with a late-specified return type. */
17206 else
17207 {
17210 }
17211 }
17214 is_template_arg);
17215 }
17218 {
17220 }
17223 {
17224 tree r;
17226 parser->type_definition_forbidden_message
17231 }
17234 {
17236 }
17238 /* Parse a type-specifier-seq.
17240 type-specifier-seq:
17241 type-specifier type-specifier-seq [opt]
17243 GNU extension:
17245 type-specifier-seq:
17246 attributes type-specifier-seq [opt]
17248 If IS_DECLARATION is true, we are at the start of a "condition" or
17249 exception-declaration, so we might be followed by a declarator-id.
17251 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
17252 i.e. we've just seen "->".
17254 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
17256 static void
17261 {
17266 /* Clear the TYPE_SPECIFIER_SEQ. */
17269 /* In the context of a trailing return type, enum E { } is an
17270 elaborated-type-specifier followed by a function-body, not an
17271 enum-specifier. */
17275 /* Parse the type-specifiers and attributes. */
17277 {
17278 tree type_specifier;
17281 /* Check for attributes first. */
17283 {
17288 }
17290 /* record the token of the beginning of the type specifier seq,
17291 for error reporting purposes*/
17295 /* Look for the type-specifier. */
17297 flags,
17298 type_specifier_seq,
17300 NULL,
17303 {
17304 /* If the first type-specifier could not be found, this is not a
17305 type-specifier-seq at all. */
17307 {
17311 }
17312 /* If subsequent type-specifiers could not be found, the
17313 type-specifier-seq is complete. */
17315 }
17318 /* The standard says that a condition can be:
17320 type-specifier-seq declarator = assignment-expression
17322 However, given:
17324 struct S {};
17325 if (int S = ...)
17327 we should treat the "S" as a declarator, not as a
17328 type-specifier. The standard doesn't say that explicitly for
17329 type-specifier-seq, but it does say that for
17330 decl-specifier-seq in an ordinary declaration. Perhaps it
17331 would be clearer just to allow a decl-specifier-seq here, and
17332 then add a semantic restriction that if any decl-specifiers
17333 that are not type-specifiers appear, the program is invalid. */
17336 }
17337 }
17339 /* Parse a parameter-declaration-clause.
17341 parameter-declaration-clause:
17342 parameter-declaration-list [opt] ... [opt]
17343 parameter-declaration-list , ...
17345 Returns a representation for the parameter declarations. A return
17346 value of NULL indicates a parameter-declaration-clause consisting
17347 only of an ellipsis. */
17349 static tree
17351 {
17352 tree parameters;
17357 /* Peek at the next token. */
17359 /* Check for trivial parameter-declaration-clauses. */
17361 {
17362 /* Consume the `...' token. */
17365 }
17367 /* There are no parameters. */
17368 {
17369 #ifndef NO_IMPLICIT_EXTERN_C
17373 else
17374 #endif
17376 }
17377 /* Check for `(void)', too, which is a special case. */
17381 {
17382 /* Consume the `void' token. */
17384 /* There are no parameters. */
17386 }
17388 /* Parse the parameter-declaration-list. */
17390 /* If a parse error occurred while parsing the
17391 parameter-declaration-list, then the entire
17392 parameter-declaration-clause is erroneous. */
17396 /* Peek at the next token. */
17398 /* If it's a `,', the clause should terminate with an ellipsis. */
17400 {
17401 /* Consume the `,'. */
17403 /* Expect an ellipsis. */
17404 ellipsis_p
17406 }
17407 /* It might also be `...' if the optional trailing `,' was
17408 omitted. */
17410 {
17411 /* Consume the `...' token. */
17413 /* And remember that we saw it. */
17415 }
17416 else
17419 /* Finish the parameter list. */
17424 }
17426 /* Parse a parameter-declaration-list.
17428 parameter-declaration-list:
17429 parameter-declaration
17430 parameter-declaration-list , parameter-declaration
17432 Returns a representation of the parameter-declaration-list, as for
17433 cp_parser_parameter_declaration_clause. However, the
17434 `void_list_node' is never appended to the list. Upon return,
17435 *IS_ERROR will be true iff an error occurred. */
17437 static tree
17439 {
17445 /* Assume all will go well. */
17447 /* The special considerations that apply to a function within an
17448 unbraced linkage specifications do not apply to the parameters
17449 to the function. */
17450 saved_in_unbraced_linkage_specification_p
17454 /* Look for more parameters. */
17456 {
17460 /* Parse the parameter. */
17461 parameter
17466 /* We don't know yet if the enclosing context is deprecated, so wait
17467 and warn in grokparms if appropriate. */
17473 PARM,
17479 /* If a parse error occurred parsing the parameter declaration,
17480 then the entire parameter-declaration-list is erroneous. */
17482 {
17486 }
17496 {
17500 }
17502 /* Add the new parameter to the list. */
17506 /* Peek at the next token. */
17509 /* These are for Objective-C++ */
17512 /* The parameter-declaration-list is complete. */
17515 {
17518 /* Peek at the next token. */
17520 /* If it's an ellipsis, then the list is complete. */
17523 /* Otherwise, there must be more parameters. Consume the
17524 `,'. */
17526 /* When parsing something like:
17528 int i(float f, double d)
17530 we can tell after seeing the declaration for "f" that we
17531 are not looking at an initialization of a variable "i",
17532 but rather at the declaration of a function "i".
17534 Due to the fact that the parsing of template arguments
17535 (as specified to a template-id) requires backtracking we
17536 cannot use this technique when inside a template argument
17537 list. */
17541 /* However, a parameter-declaration of the form
17542 "foat(f)" (which is a valid declaration of a
17543 parameter "f") can also be interpreted as an
17544 expression (the conversion of "f" to "float"). */
17547 }
17548 else
17549 {
17557 }
17558 }
17560 parser->in_unbraced_linkage_specification_p
17564 }
17566 /* Parse a parameter declaration.
17568 parameter-declaration:
17569 decl-specifier-seq ... [opt] declarator
17570 decl-specifier-seq declarator = assignment-expression
17571 decl-specifier-seq ... [opt] abstract-declarator [opt]
17572 decl-specifier-seq abstract-declarator [opt] = assignment-expression
17574 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
17575 declares a template parameter. (In that case, a non-nested `>'
17576 token encountered during the parsing of the assignment-expression
17577 is not interpreted as a greater-than operator.)
17579 Returns a representation of the parameter, or NULL if an error
17580 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
17581 true iff the declarator is of the form "(p)". */
17587 {
17589 cp_decl_specifier_seq decl_specifiers;
17591 tree default_argument;
17595 /* In a template parameter, `>' is not an operator.
17597 [temp.param]
17599 When parsing a default template-argument for a non-type
17600 template-parameter, the first non-nested `>' is taken as the end
17601 of the template parameter-list rather than a greater-than
17602 operator. */
17604 /* Type definitions may not appear in parameter types. */
17606 parser->type_definition_forbidden_message
17609 /* Parse the declaration-specifiers. */
17611 CP_PARSER_FLAGS_NONE,
17615 /* Complain about missing 'typename' or other invalid type names. */
17619 /* If an error occurred, there's no reason to attempt to parse the
17620 rest of the declaration. */
17622 {
17625 }
17627 /* Peek at the next token. */
17630 /* If the next token is a `)', `,', `=', `>', or `...', then there
17631 is no declarator. However, when variadic templates are enabled,
17632 there may be a declarator following `...'. */
17637 {
17641 }
17642 /* Otherwise, there should be a declarator. */
17643 else
17644 {
17648 /* After seeing a decl-specifier-seq, if the next token is not a
17649 "(", there is no possibility that the code is a valid
17650 expression. Therefore, if parsing tentatively, we commit at
17651 this point. */
17653 /* In an expression context, having seen:
17655 (int((char ...
17657 we cannot be sure whether we are looking at a
17658 function-type (taking a "char" as a parameter) or a cast
17659 of some object of type "char" to "int". */
17665 /* Parse the declarator. */
17668 CP_PARSER_DECLARATOR_EITHER,
17670 parenthesized_p,
17673 /* After the declarator, allow more attributes. */
17674 decl_specifiers.attributes
17677 }
17679 /* If the next token is an ellipsis, and we have not seen a
17680 declarator name, and the type of the declarator contains parameter
17681 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
17682 a parameter pack expansion expression. Otherwise, leave the
17683 ellipsis for a C-style variadic function. */
17686 {
17697 {
17698 /* Consume the `...'. */
17702 /* Build a pack expansion type */
17705 else
17707 }
17708 }
17710 /* The restriction on defining new types applies only to the type
17711 of the parameter, not to the default argument. */
17714 /* If the next token is `=', then process a default argument. */
17716 {
17718 /* If we are defining a class, then the tokens that make up the
17719 default argument must be saved and processed later. */
17724 /* Outside of a class definition, we can just parse the
17725 assignment-expression. */
17726 else
17727 default_argument
17731 {
17734 else
17735 {
17737 "default arguments are only "
17740 }
17741 }
17745 {
17746 /* Find the name of the parameter pack. */
17753 template_parm_p
17759 else
17761 template_parm_p
17768 }
17769 }
17770 else
17774 declarator,
17775 default_argument);
17776 }
17778 /* Parse a default argument and return it.
17780 TEMPLATE_PARM_P is true if this is a default argument for a
17781 non-type template parameter. */
17782 static tree
17784 {
17790 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
17791 set correctly. */
17794 /* Local variable names (and the `this' keyword) may not
17795 appear in a default argument. */
17798 /* Parse the assignment-expression. */
17801 default_argument
17811 }
17813 /* Parse a function-body.
17815 function-body:
17816 compound_statement */
17818 static void
17820 {
17822 }
17824 /* Parse a ctor-initializer-opt followed by a function-body. Return
17825 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
17826 is true we are parsing a function-try-block. */
17828 static bool
17831 {
17839 /* Begin the function body. */
17841 /* Parse the optional ctor-initializer. */
17844 /* If we're parsing a constexpr constructor definition, we need
17845 to check that the constructor body is indeed empty. However,
17846 before we get to cp_parser_function_body lot of junk has been
17847 generated, so we can't just check that we have an empty block.
17848 Rather we take a snapshot of the outermost block, and check whether
17849 cp_parser_function_body changed its state. */
17851 {
17855 }
17856 /* Parse the function-body. */
17860 /* Finish the function body. */
17864 }
17866 /* Parse an initializer.
17868 initializer:
17869 = initializer-clause
17870 ( expression-list )
17872 Returns an expression representing the initializer. If no
17873 initializer is present, NULL_TREE is returned.
17875 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
17876 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
17877 set to TRUE if there is no initializer present. If there is an
17878 initializer, and it is not a constant-expression, *NON_CONSTANT_P
17879 is set to true; otherwise it is set to false. */
17881 static tree
17884 {
17886 tree init;
17888 /* Peek at the next token. */
17891 /* Let our caller know whether or not this initializer was
17892 parenthesized. */
17894 /* Assume that the initializer is constant. */
17898 {
17899 /* Consume the `='. */
17901 /* Parse the initializer-clause. */
17903 }
17905 {
17910 non_constant_p);
17915 }
17917 {
17921 }
17922 else
17923 {
17924 /* Anything else is an error. */
17927 }
17930 }
17932 /* Parse an initializer-clause.
17934 initializer-clause:
17935 assignment-expression
17936 braced-init-list
17938 Returns an expression representing the initializer.
17940 If the `assignment-expression' production is used the value
17941 returned is simply a representation for the expression.
17943 Otherwise, calls cp_parser_braced_list. */
17945 static tree
17947 {
17948 tree initializer;
17950 /* Assume the expression is constant. */
17953 /* If it is not a `{', then we are looking at an
17954 assignment-expression. */
17956 {
17957 initializer
17960 non_constant_p);
17961 }
17962 else
17966 }
17968 /* Parse a brace-enclosed initializer list.
17970 braced-init-list:
17971 { initializer-list , [opt] }
17972 { }
17974 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
17975 the elements of the initializer-list (or NULL, if the last
17976 production is used). The TREE_TYPE for the CONSTRUCTOR will be
17977 NULL_TREE. There is no way to detect whether or not the optional
17978 trailing `,' was provided. NON_CONSTANT_P is as for
17979 cp_parser_initializer. */
17981 static tree
17983 {
17984 tree initializer;
17986 /* Consume the `{' token. */
17988 /* Create a CONSTRUCTOR to represent the braced-initializer. */
17990 /* If it's not a `}', then there is a non-trivial initializer. */
17992 {
17993 /* Parse the initializer list. */
17996 /* A trailing `,' token is allowed. */
17999 }
18000 else
18002 /* Now, there should be a trailing `}'. */
18006 }
18008 /* Parse an initializer-list.
18010 initializer-list:
18011 initializer-clause ... [opt]
18012 initializer-list , initializer-clause ... [opt]
18014 GNU Extension:
18016 initializer-list:
18017 designation initializer-clause ...[opt]
18018 initializer-list , designation initializer-clause ...[opt]
18020 designation:
18021 . identifier =
18022 identifier :
18023 [ constant-expression ] =
18025 Returns a vec of constructor_elt. The VALUE of each elt is an expression
18026 for the initializer. If the INDEX of the elt is non-NULL, it is the
18027 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
18028 as for cp_parser_initializer. */
18032 {
18035 /* Assume all of the expressions are constant. */
18038 /* Parse the rest of the list. */
18040 {
18042 tree designator;
18043 tree initializer;
18046 /* If the next token is an identifier and the following one is a
18047 colon, we are looking at the GNU designated-initializer
18048 syntax. */
18052 {
18053 /* Warn the user that they are using an extension. */
18056 /* Consume the identifier. */
18058 /* Consume the `:'. */
18060 }
18061 /* Also handle the C99 syntax, '. id ='. */
18066 {
18067 /* Warn the user that they are using an extension. */
18070 /* Consume the `.'. */
18072 /* Consume the identifier. */
18074 /* Consume the `='. */
18076 }
18077 /* Also handle C99 array designators, '[ const ] ='. */
18081 {
18082 /* In C++11, [ could start a lambda-introducer. */
18094 }
18095 else
18098 /* Parse the initializer. */
18101 /* If any clause is non-constant, so is the entire initializer. */
18105 /* If we have an ellipsis, this is an initializer pack
18106 expansion. */
18108 {
18109 /* Consume the `...'. */
18112 /* Turn the initializer into an initializer expansion. */
18114 }
18116 /* Add it to the vector. */
18119 /* If the next token is not a comma, we have reached the end of
18120 the list. */
18124 /* Peek at the next token. */
18126 /* If the next token is a `}', then we're still done. An
18127 initializer-clause can have a trailing `,' after the
18128 initializer-list and before the closing `}'. */
18132 /* Consume the `,' token. */
18134 }
18137 }
18139 /* Classes [gram.class] */
18141 /* Parse a class-name.
18143 class-name:
18144 identifier
18145 template-id
18147 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
18148 to indicate that names looked up in dependent types should be
18149 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
18150 keyword has been used to indicate that the name that appears next
18151 is a template. TAG_TYPE indicates the explicit tag given before
18152 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
18153 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
18154 is the class being defined in a class-head.
18156 Returns the TYPE_DECL representing the class. */
18158 static tree
18166 {
18167 tree decl;
18168 tree scope;
18173 /* All class-names start with an identifier. */
18176 {
18179 }
18181 /* PARSER->SCOPE can be cleared when parsing the template-arguments
18182 to a template-id, so we save it here. */
18187 /* Any name names a type if we're following the `typename' keyword
18188 in a qualified name where the enclosing scope is type-dependent. */
18191 /* Handle the common case (an identifier, but not a template-id)
18192 efficiently. */
18195 {
18199 /* Look for the identifier. */
18203 /* If the next token isn't an identifier, we are certainly not
18204 looking at a class-name. */
18207 /* If we know this is a type-name, there's no need to look it
18208 up. */
18211 else
18212 {
18213 tree ambiguous_decls;
18214 /* If we already know that this lookup is ambiguous, then
18215 we've already issued an error message; there's no reason
18216 to check again. */
18218 {
18221 }
18222 /* If the next token is a `::', then the name must be a type
18223 name.
18225 [basic.lookup.qual]
18227 During the lookup for a name preceding the :: scope
18228 resolution operator, object, function, and enumerator
18229 names are ignored. */
18232 /* Look up the name. */
18234 tag_type,
18237 check_dependency_p,
18241 {
18245 }
18246 }
18247 }
18248 else
18249 {
18250 /* Try a template-id. */
18252 check_dependency_p,
18253 tag_type,
18254 is_declaration);
18257 }
18261 /* If this is a typename, create a TYPENAME_TYPE. */
18263 {
18268 }
18272 /* Check to see that it is really the name of a class. */
18276 /* Situations like this:
18278 template <typename T> struct A {
18279 typename T::template X<int>::I i;
18280 };
18282 are problematic. Is `T::template X<int>' a class-name? The
18283 standard does not seem to be definitive, but there is no other
18284 valid interpretation of the following `::'. Therefore, those
18285 names are considered class-names. */
18286 {
18290 }
18294 /* In Objective-C 2.0, a classname followed by '.' starts a
18295 dot-syntax expression, and it's not a type-name. */
18307 }
18309 /* Parse a class-specifier.
18311 class-specifier:
18312 class-head { member-specification [opt] }
18314 Returns the TREE_TYPE representing the class. */
18316 static tree
18318 {
18319 tree type;
18333 /* Parse the class-head. */
18336 /* If the class-head was a semantic disaster, skip the entire body
18337 of the class. */
18339 {
18343 }
18345 /* Look for the `{'. */
18347 {
18350 }
18352 /* Issue an error message if type-definitions are forbidden here. */
18354 /* Remember that we are defining one more class. */
18356 /* Inside the class, surrounding template-parameter-lists do not
18357 apply. */
18358 saved_num_template_parameter_lists
18361 /* We are not in a function body. */
18364 /* Or in a loop. */
18367 /* Or in a switch. */
18370 /* We are not immediately inside an extern "lang" block. */
18371 saved_in_unbraced_linkage_specification_p
18375 /* Start the class. */
18377 {
18380 }
18384 /* If the type is erroneous, skip the entire body of the class. */
18386 else
18387 /* Parse the member-specification. */
18390 /* Look for the trailing `}'. */
18392 /* Look for trailing attributes to apply to this class. */
18400 /* We've finished a type definition. Check for the common syntax
18401 error of forgetting a semicolon after the definition. We need to
18402 be careful, as we can't just check for not-a-semicolon and be done
18403 with it; the user might have typed:
18405 class X { } c = ...;
18406 class X { } *p = ...;
18408 and so forth. Instead, enumerate all the possible tokens that
18409 might follow this production; if we don't see one of them, then
18410 complain and silently insert the semicolon. */
18411 {
18416 /* Don't try to parse c++11 attributes here. As per the
18417 grammar, that should be a task for
18418 cp_parser_decl_specifier_seq. */
18422 {
18433 /* While it's legal for type qualifiers and storage class
18434 specifiers to follow type definitions in the grammar, only
18435 compiler testsuites contain code like that. Assume that if
18436 we see such code, then what we're really seeing is a case
18437 like:
18439 class X { }
18440 const <type> var = ...;
18442 or
18444 class Y { }
18445 static <type> func (...) ...
18447 i.e. the qualifier or specifier applies to the next
18448 declaration. To do so, however, we need to look ahead one
18449 more token to see if *that* token is a type specifier.
18451 This code could be improved to handle:
18453 class Z { }
18454 static const <type> var = ...; */
18457 {
18460 /* Handling user-defined types here would be nice, but very
18461 tricky. */
18462 want_semicolon
18465 }
18469 }
18471 /* If we don't have a type, then something is very wrong and we
18472 shouldn't try to do anything clever. Likewise for not seeing the
18473 closing brace. */
18475 {
18476 cp_token_position prev
18487 else
18490 /* Unget one token and smash it to look as though we encountered
18491 a semicolon in the input stream. */
18496 }
18497 }
18499 /* If this class is not itself within the scope of another class,
18500 then we need to parse the bodies of all of the queued function
18501 definitions. Note that the queued functions defined in a class
18502 are not always processed immediately following the
18503 class-specifier for that class. Consider:
18505 struct A {
18506 struct B { void f() { sizeof (A); } };
18507 };
18509 If `f' were processed before the processing of `A' were
18510 completed, there would be no way to compute the size of `A'.
18511 Note that the nesting we are interested in here is lexical --
18512 not the semantic nesting given by TYPE_CONTEXT. In particular,
18513 for:
18515 struct A { struct B; };
18516 struct A::B { void f() { } };
18518 there is no need to delay the parsing of `A::B::f'. */
18520 {
18521 tree decl;
18528 /* In a first pass, parse default arguments to the functions.
18529 Then, in a second pass, parse the bodies of the functions.
18530 This two-phased approach handles cases like:
18532 struct S {
18533 void f() { g(); }
18534 void g(int i = 3);
18535 };
18537 */
18539 {
18541 /* If there are default arguments that have not yet been processed,
18542 take care of them now. */
18544 {
18549 }
18550 /* Make sure that any template parameters are in scope. */
18552 /* Parse the default argument expressions. */
18554 /* Remove any template parameters from the symbol table. */
18556 }
18558 /* Now parse any NSDMIs. */
18562 {
18564 {
18569 }
18572 }
18578 /* Now parse the body of the functions. */
18582 }
18584 /* Put back any saved access checks. */
18587 /* Restore saved state. */
18591 parser->num_template_parameter_lists
18593 parser->in_unbraced_linkage_specification_p
18597 }
18599 static tree
18601 {
18602 tree ret;
18607 }
18609 /* Parse a class-head.
18611 class-head:
18612 class-key identifier [opt] base-clause [opt]
18613 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
18614 class-key nested-name-specifier [opt] template-id
18615 base-clause [opt]
18617 class-virt-specifier:
18618 final
18620 GNU Extensions:
18621 class-key attributes identifier [opt] base-clause [opt]
18622 class-key attributes nested-name-specifier identifier base-clause [opt]
18623 class-key attributes nested-name-specifier [opt] template-id
18624 base-clause [opt]
18626 Upon return BASES is initialized to the list of base classes (or
18627 NULL, if there are none) in the same form returned by
18628 cp_parser_base_clause.
18630 Returns the TYPE of the indicated class. Sets
18631 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
18632 involving a nested-name-specifier was used, and FALSE otherwise.
18634 Returns error_mark_node if this is not a class-head.
18636 Returns NULL_TREE if the class-head is syntactically valid, but
18637 semantically invalid in a way that means we should skip the entire
18638 body of the class. */
18640 static tree
18643 {
18644 tree nested_name_specifier;
18648 tree attributes;
18649 tree bases;
18659 /* Assume no nested-name-specifier will be present. */
18661 /* Assume no template parameter lists will be used in defining the
18662 type. */
18666 /* Look for the class-key. */
18671 /* Parse the attributes. */
18674 /* If the next token is `::', that is invalid -- but sometimes
18675 people do try to write:
18677 struct ::S {};
18679 Handle this gracefully by accepting the extra qualifier, and then
18680 issuing an error about it later if this really is a
18681 class-head. If it turns out just to be an elaborated type
18682 specifier, remain silent. */
18688 /* Determine the name of the class. Begin by looking for an
18689 optional nested-name-specifier. */
18691 nested_name_specifier
18697 /* If there was a nested-name-specifier, then there *must* be an
18698 identifier. */
18700 {
18702 /* Although the grammar says `identifier', it really means
18703 `class-name' or `template-name'. You are only allowed to
18704 define a class that has already been declared with this
18705 syntax.
18707 The proposed resolution for Core Issue 180 says that wherever
18708 you see `class T::X' you should treat `X' as a type-name.
18710 It is OK to define an inaccessible class; for example:
18712 class A { class B; };
18713 class A::B {};
18715 We do not know if we will see a class-name, or a
18716 template-name. We look for a class-name first, in case the
18717 class-name is a template-id; if we looked for the
18718 template-name first we would stop after the template-name. */
18723 class_type,
18727 /* If that didn't work, ignore the nested-name-specifier. */
18729 {
18735 }
18736 /* If we could not find a corresponding TYPE, treat this
18737 declaration like an unqualified declaration. */
18740 /* Otherwise, count the number of templates used in TYPE and its
18741 containing scopes. */
18742 else
18743 {
18744 tree scope;
18758 }
18759 }
18760 /* Otherwise, the identifier is optional. */
18761 else
18762 {
18763 /* We don't know whether what comes next is a template-id,
18764 an identifier, or nothing at all. */
18766 /* Check for a template-id. */
18771 class_key,
18773 /* If that didn't work, it could still be an identifier. */
18775 {
18777 {
18780 }
18781 else
18783 }
18784 else
18785 {
18788 }
18789 }
18794 {
18796 class_key,
18798 }
18801 /* If it's not a `:' or a `{' then we can't really be looking at a
18802 class-head, since a class-head only appears as part of a
18803 class-specifier. We have to detect this situation before calling
18804 xref_tag, since that has irreversible side-effects. */
18806 {
18810 }
18812 /* At this point, we're going ahead with the class-specifier, even
18813 if some other problem occurs. */
18816 {
18821 }
18822 /* Issue the error about the overly-qualified name now. */
18824 {
18829 }
18831 {
18836 }
18838 {
18839 tree scope;
18841 /* Reject typedef-names in class heads. */
18843 {
18846 type);
18849 }
18851 /* Figure out in what scope the declaration is being placed. */
18853 /* If that scope does not contain the scope in which the
18854 class was originally declared, the program is invalid. */
18856 {
18859 "declaration of %qD in namespace %qD which does not "
18862 else
18868 }
18869 /* [dcl.meaning]
18871 A declarator-id shall not be qualified except for the
18872 definition of a ... nested class outside of its class
18873 ... [or] the definition or explicit instantiation of a
18874 class member of a namespace outside of its namespace. */
18876 {
18881 }
18882 }
18883 /* An explicit-specialization must be preceded by "template <>". If
18884 it is not, try to recover gracefully. */
18888 {
18892 /* Take the same action that would have been taken by
18893 cp_parser_explicit_specialization. */
18896 }
18897 /* There must be no "return" statements between this point and the
18898 end of this function; set "type "to the correct return value and
18899 use "goto done;" to return. */
18900 /* Make sure that the right number of template parameters were
18901 present. */
18905 {
18906 /* If something went wrong, there is no point in even trying to
18907 process the class-definition. */
18910 }
18912 /* Look up the type. */
18914 {
18918 {
18922 }
18923 else
18924 {
18927 }
18930 }
18932 {
18933 tree class_type;
18935 /* Given:
18937 template <typename T> struct S { struct T };
18938 template <typename T> struct S<T>::T { };
18940 we will get a TYPENAME_TYPE when processing the definition of
18941 `S::T'. We need to resolve it to the actual type before we
18942 try to define it. */
18944 {
18949 else
18950 {
18953 }
18954 }
18958 {
18961 }
18964 /* Enter the scope indicated by the nested-name-specifier. */
18966 /* Get the canonical version of this type. */
18970 {
18973 {
18976 }
18977 }
18981 }
18983 {
18984 /* If the class was unnamed, create a dummy name. */
18989 }
18991 /* Indicate whether this class was declared as a `class' or as a
18992 `struct'. */
18997 /* If this type was already complete, and we see another definition,
18998 that's an error. */
19000 {
19002 type);
19004 type);
19007 }
19012 {
19013 /* Apply attributes now, before any use of the class as a template
19014 argument in its base list. */
19017 }
19019 /* We will have entered the scope containing the class; the names of
19020 base classes should be looked up in that context. For example:
19022 struct A { struct B {}; struct C; };
19023 struct A::C : B {};
19025 is valid. */
19027 /* Get the list of base-classes, if there is one. */
19030 else
19033 /* If we're really defining a class, process the base classes.
19034 If they're invalid, fail. */
19039 done:
19040 /* Leave the scope given by the nested-name-specifier. We will
19041 enter the class scope itself while processing the members. */
19046 {
19049 }
19055 out:
19058 }
19060 /* Parse a class-key.
19062 class-key:
19063 class
19064 struct
19065 union
19067 Returns the kind of class-key specified, or none_type to indicate
19068 error. */
19070 static enum tag_types
19072 {
19076 /* Look for the class-key. */
19081 /* Check to see if the TOKEN is a class-key. */
19086 }
19088 /* Parse an (optional) member-specification.
19090 member-specification:
19091 member-declaration member-specification [opt]
19092 access-specifier : member-specification [opt] */
19094 static void
19096 {
19098 {
19102 /* Peek at the next token. */
19104 /* If it's a `}', or EOF then we've seen all the members. */
19110 /* See if this token is a keyword. */
19113 {
19117 /* Consume the access-specifier. */
19119 /* Remember which access-specifier is active. */
19121 /* Look for the `:'. */
19126 /* Accept #pragmas at class scope. */
19128 {
19131 }
19133 /* Otherwise, the next construction must be a
19134 member-declaration. */
19136 }
19137 }
19138 }
19140 /* Parse a member-declaration.
19142 member-declaration:
19143 decl-specifier-seq [opt] member-declarator-list [opt] ;
19144 function-definition ; [opt]
19145 :: [opt] nested-name-specifier template [opt] unqualified-id ;
19146 using-declaration
19147 template-declaration
19148 alias-declaration
19150 member-declarator-list:
19151 member-declarator
19152 member-declarator-list , member-declarator
19154 member-declarator:
19155 declarator pure-specifier [opt]
19156 declarator constant-initializer [opt]
19157 identifier [opt] : constant-expression
19159 GNU Extensions:
19161 member-declaration:
19162 __extension__ member-declaration
19164 member-declarator:
19165 declarator attributes [opt] pure-specifier [opt]
19166 declarator attributes [opt] constant-initializer [opt]
19167 identifier [opt] attributes [opt] : constant-expression
19169 C++0x Extensions:
19171 member-declaration:
19172 static_assert-declaration */
19174 static void
19176 {
19177 cp_decl_specifier_seq decl_specifiers;
19178 tree prefix_attributes;
19179 tree decl;
19188 /* Check for the `__extension__' keyword. */
19190 {
19191 /* Recurse. */
19193 /* Restore the old value of the PEDANTIC flag. */
19197 }
19199 /* Check for a template-declaration. */
19201 {
19202 /* An explicit specialization here is an error condition, and we
19203 expect the specialization handler to detect and report this. */
19207 else
19211 }
19213 /* Check for a using-declaration. */
19215 {
19217 {
19218 /* Parse the using-declaration. */
19222 }
19223 else
19224 {
19225 tree decl;
19229 /* Note that if we actually see the '=' token after the
19230 identifier, cp_parser_alias_declaration commits the
19231 tentative parse. In that case, we really expects an
19232 alias-declaration. Otherwise, we expect a using
19233 declaration. */
19234 alias_decl_expected =
19240 else
19244 }
19245 }
19247 /* Check for @defs. */
19249 {
19254 {
19259 }
19261 }
19263 /* If the next token is `static_assert' we have a static assertion. */
19265 {
19268 }
19275 /* Parse the decl-specifier-seq. */
19278 CP_PARSER_FLAGS_OPTIONAL,
19281 /* Check for an invalid type-name. */
19285 /* If there is no declarator, then the decl-specifier-seq should
19286 specify a type. */
19288 {
19289 /* If there was no decl-specifier-seq, and the next token is a
19290 `;', then we have something like:
19292 struct S { ; };
19294 [class.mem]
19296 Each member-declaration shall declare at least one member
19297 name of the class. */
19299 {
19303 }
19304 else
19305 {
19306 tree type;
19308 /* See if this declaration is a friend. */
19310 /* If there were decl-specifiers, check to see if there was
19311 a class-declaration. */
19314 /* Nested classes have already been added to the class, but
19315 a `friend' needs to be explicitly registered. */
19317 {
19318 /* If the `friend' keyword was present, the friend must
19319 be introduced with a class-key. */
19322 "in C++03 a class-key must be used "
19324 /* In this case:
19326 template <typename T> struct A {
19327 friend struct A<T>::B;
19328 };
19330 A<T>::B will be represented by a TYPENAME_TYPE, and
19331 therefore not recognized by check_tag_decl. */
19333 {
19337 }
19340 "friend declaration does not name a class or "
19342 else
19345 }
19346 /* If there is no TYPE, an error message will already have
19347 been issued. */
19349 ;
19350 /* An anonymous aggregate has to be handled specially; such
19351 a declaration really declares a data member (with a
19352 particular type), as opposed to a nested class. */
19354 {
19355 /* C++11 9.5/6. */
19358 "a storage class on an anonymous aggregate "
19361 /* Remove constructors and such from TYPE, now that we
19362 know it is an anonymous aggregate. */
19364 /* And make the corresponding data member. */
19367 /* Add it to the class. */
19369 }
19370 else
19371 cp_parser_check_access_in_redeclaration
19374 }
19375 }
19376 else
19377 {
19380 /* Clear attributes from the decl_specifiers but keep them
19381 around as prefix attributes that apply them to the entity
19382 being declared. */
19386 /* See if these declarations will be friends. */
19389 /* Keep going until we hit the `;' at the end of the
19390 declaration. */
19392 {
19394 tree first_attribute;
19396 /* Peek at the next token. */
19399 /* Check for a bitfield declaration. */
19404 {
19405 tree identifier;
19406 tree width;
19408 /* Get the name of the bitfield. Note that we cannot just
19409 check TOKEN here because it may have been invalidated by
19410 the call to cp_lexer_peek_nth_token above. */
19413 else
19416 /* Consume the `:' token. */
19418 /* Get the width of the bitfield. */
19419 width
19422 NULL);
19424 /* Look for attributes that apply to the bitfield. */
19426 /* Remember which attributes are prefix attributes and
19427 which are not. */
19429 /* Combine the attributes. */
19432 /* Create the bitfield declaration. */
19435 identifier,
19436 sfk_none)
19439 width,
19440 attributes);
19441 }
19442 else
19443 {
19445 tree initializer;
19446 tree asm_specification;
19449 /* Parse the declarator. */
19450 declarator
19456 /* If something went wrong parsing the declarator, make sure
19457 that we at least consume some tokens. */
19459 {
19460 /* Skip to the end of the statement. */
19462 /* If the next token is not a semicolon, that is
19463 probably because we just skipped over the body of
19464 a function. So, we consume a semicolon if
19465 present, but do not issue an error message if it
19466 is not present. */
19468 CPP_SEMICOLON))
19471 }
19474 cp_parser_check_for_definition_in_return_type
19478 /* Look for an asm-specification. */
19480 /* Look for attributes that apply to the declaration. */
19482 /* Remember which attributes are prefix attributes and
19483 which are not. */
19485 /* Combine the attributes. */
19488 /* If it's an `=', then we have a constant-initializer or a
19489 pure-specifier. It is not correct to parse the
19490 initializer before registering the member declaration
19491 since the member declaration should be in scope while
19492 its initializer is processed. However, the rest of the
19493 front end does not yet provide an interface that allows
19494 us to handle this correctly. */
19496 {
19497 /* In [class.mem]:
19499 A pure-specifier shall be used only in the declaration of
19500 a virtual function.
19502 A member-declarator can contain a constant-initializer
19503 only if it declares a static member of integral or
19504 enumeration type.
19506 Therefore, if the DECLARATOR is for a function, we look
19507 for a pure-specifier; otherwise, we look for a
19508 constant-initializer. When we call `grokfield', it will
19509 perform more stringent semantics checks. */
19521 {
19523 /* Don't require a constant rvalue in C++11, since we
19524 might want a reference constant. We'll enforce
19525 constancy later. */
19527 /* Parse the initializer. */
19530 }
19531 else
19532 /* Parse the initializer. */
19534 }
19537 {
19541 else
19543 }
19544 /* Otherwise, there is no initializer. */
19545 else
19548 /* See if we are probably looking at a function
19549 definition. We are certainly not looking at a
19550 member-declarator. Calling `grokfield' has
19551 side-effects, so we must not do it unless we are sure
19552 that we are looking at a member-declarator. */
19555 {
19556 /* The grammar does not allow a pure-specifier to be
19557 used when a member function is defined. (It is
19558 possible that this fact is an oversight in the
19559 standard, since a pure function may be defined
19560 outside of the class-specifier. */
19566 declarator,
19567 attributes);
19568 /* If the member was not a friend, declare it here. */
19571 /* Peek at the next token. */
19573 /* If the next token is a semicolon, consume it. */
19577 }
19578 else
19581 /* Create the declaration. */
19584 asm_specification,
19585 attributes);
19586 }
19588 /* Reset PREFIX_ATTRIBUTES. */
19594 /* If there is any qualification still in effect, clear it
19595 now; we will be starting fresh with the next declarator. */
19599 /* If it's a `,', then there are more declarators. */
19601 {
19604 {
19608 }
19609 }
19610 /* If the next token isn't a `;', then we have a parse error. */
19612 CPP_SEMICOLON))
19613 {
19614 /* The next token might be a ways away from where the
19615 actual semicolon is missing. Find the previous token
19616 and use that for our error position. */
19621 /* Assume that the user meant to provide a semicolon. If
19622 we were to cp_parser_skip_to_end_of_statement, we might
19623 skip to a semicolon inside a member function definition
19624 and issue nonsensical error messages. */
19626 }
19629 {
19630 /* Add DECL to the list of members. */
19639 /* Add DECL to the queue of NSDMI to be parsed later. */
19641 }
19645 }
19646 }
19649 out:
19651 }
19653 /* Parse a pure-specifier.
19655 pure-specifier:
19656 = 0
19658 Returns INTEGER_ZERO_NODE if a pure specifier is found.
19659 Otherwise, ERROR_MARK_NODE is returned. */
19661 static tree
19663 {
19666 /* Look for the `=' token. */
19669 /* Look for the `0' token. */
19678 /* Accept = default or = delete in c++0x mode. */
19681 {
19684 }
19686 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
19688 {
19693 }
19695 {
19698 }
19701 }
19703 /* Parse a constant-initializer.
19705 constant-initializer:
19706 = constant-expression
19708 Returns a representation of the constant-expression. */
19710 static tree
19712 {
19713 /* Look for the `=' token. */
19717 /* It is invalid to write:
19719 struct S { static const int i = { 7 }; };
19721 */
19723 {
19726 /* Consume the opening brace. */
19728 /* Skip the initializer. */
19730 /* Look for the trailing `}'. */
19734 }
19738 NULL);
19739 }
19741 /* Derived classes [gram.class.derived] */
19743 /* Parse a base-clause.
19745 base-clause:
19746 : base-specifier-list
19748 base-specifier-list:
19749 base-specifier ... [opt]
19750 base-specifier-list , base-specifier ... [opt]
19752 Returns a TREE_LIST representing the base-classes, in the order in
19753 which they were declared. The representation of each node is as
19754 described by cp_parser_base_specifier.
19756 In the case that no bases are specified, this function will return
19757 NULL_TREE, not ERROR_MARK_NODE. */
19759 static tree
19761 {
19764 /* Look for the `:' that begins the list. */
19767 /* Scan the base-specifier-list. */
19769 {
19771 tree base;
19774 /* Look for the base-specifier. */
19776 /* Look for the (optional) ellipsis. */
19778 {
19779 /* Consume the `...'. */
19783 }
19785 /* Add BASE to the front of the list. */
19787 {
19789 /* Make this a pack expansion type. */
19793 {
19796 }
19797 }
19798 /* Peek at the next token. */
19800 /* If it's not a comma, then the list is complete. */
19803 /* Consume the `,'. */
19805 }
19807 /* PARSER->SCOPE may still be non-NULL at this point, if the last
19808 base class had a qualified name. However, the next name that
19809 appears is certainly not qualified. */
19815 }
19817 /* Parse a base-specifier.
19819 base-specifier:
19820 :: [opt] nested-name-specifier [opt] class-name
19821 virtual access-specifier [opt] :: [opt] nested-name-specifier
19822 [opt] class-name
19823 access-specifier virtual [opt] :: [opt] nested-name-specifier
19824 [opt] class-name
19826 Returns a TREE_LIST. The TREE_PURPOSE will be one of
19827 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
19828 indicate the specifiers provided. The TREE_VALUE will be a TYPE
19829 (or the ERROR_MARK_NODE) indicating the type that was specified. */
19831 static tree
19833 {
19841 tree type;
19843 /* Process the optional `virtual' and `access-specifier'. */
19845 {
19846 /* Peek at the next token. */
19848 /* Process `virtual'. */
19850 {
19852 /* If `virtual' appears more than once, issue an error. */
19854 {
19858 }
19862 /* Consume the `virtual' token. */
19870 /* If more than one access specifier appears, issue an
19871 error. */
19874 {
19878 }
19882 /* Consume the access-specifier. */
19890 }
19891 }
19892 /* It is not uncommon to see programs mechanically, erroneously, use
19893 the 'typename' keyword to denote (dependent) qualified types
19894 as base classes. */
19896 {
19901 else
19903 "keyword %<typename%> not allowed in this context "
19906 }
19908 /* Look for the optional `::' operator. */
19910 /* Look for the nested-name-specifier. The simplest way to
19911 implement:
19913 [temp.res]
19915 The keyword `typename' is not permitted in a base-specifier or
19916 mem-initializer; in these contexts a qualified name that
19917 depends on a template-parameter is implicitly assumed to be a
19918 type name.
19920 is to pretend that we have seen the `typename' keyword at this
19921 point. */
19925 typename_type,
19927 /* If the base class is given by a qualified name, assume that names
19928 we see are type names or templates, as appropriate. */
19934 /* DR 950 allows decltype as a base-specifier. */
19936 else
19937 {
19938 /* Otherwise, look for the class-name. */
19940 class_scope_p,
19941 template_p,
19942 typename_type,
19947 }
19953 }
19955 /* Exception handling [gram.exception] */
19957 /* Parse an (optional) noexcept-specification.
19959 noexcept-specification:
19960 noexcept ( constant-expression ) [opt]
19962 If no noexcept-specification is present, returns NULL_TREE.
19963 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
19964 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
19965 there are no parentheses. CONSUMED_EXPR will be set accordingly.
19966 Otherwise, returns a noexcept specification unless RETURN_COND is true,
19967 in which case a boolean condition is returned instead. */
19969 static tree
19974 {
19978 /* Peek at the next token. */
19981 /* Is it a noexcept-specification? */
19983 {
19984 tree expr;
19988 {
19992 {
19993 /* Types may not be defined in an exception-specification. */
19995 parser->type_definition_forbidden_message
20000 /* Restore the saved message. */
20002 }
20003 else
20004 {
20007 }
20010 }
20011 else
20012 {
20016 }
20018 /* We cannot build a noexcept-spec right away because this will check
20019 that expr is a constexpr. */
20022 else
20024 }
20025 else
20027 }
20029 /* Parse an (optional) exception-specification.
20031 exception-specification:
20032 throw ( type-id-list [opt] )
20034 Returns a TREE_LIST representing the exception-specification. The
20035 TREE_VALUE of each node is a type. */
20037 static tree
20039 {
20041 tree type_id_list;
20044 /* Peek at the next token. */
20047 /* Is it a noexcept-specification? */
20053 /* If it's not `throw', then there's no exception-specification. */
20057 #if 0
20058 /* Enable this once a lot of code has transitioned to noexcept? */
20062 #endif
20064 /* Consume the `throw'. */
20067 /* Look for the `('. */
20070 /* Peek at the next token. */
20072 /* If it's not a `)', then there is a type-id-list. */
20074 {
20075 /* Types may not be defined in an exception-specification. */
20077 parser->type_definition_forbidden_message
20079 /* Parse the type-id-list. */
20081 /* Restore the saved message. */
20083 }
20084 else
20087 /* Look for the `)'. */
20091 }
20093 /* Parse an (optional) type-id-list.
20095 type-id-list:
20096 type-id ... [opt]
20097 type-id-list , type-id ... [opt]
20099 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
20100 in the order that the types were presented. */
20102 static tree
20104 {
20108 {
20110 tree type;
20112 /* Get the next type-id. */
20114 /* Parse the optional ellipsis. */
20116 {
20117 /* Consume the `...'. */
20120 /* Turn the type into a pack expansion expression. */
20122 }
20123 /* Add it to the list. */
20125 /* Peek at the next token. */
20127 /* If it is not a `,', we are done. */
20130 /* Consume the `,'. */
20132 }
20135 }
20137 /* Parse a try-block.
20139 try-block:
20140 try compound-statement handler-seq */
20142 static tree
20144 {
20145 tree try_block;
20155 }
20157 /* Parse a function-try-block.
20159 function-try-block:
20160 try ctor-initializer [opt] function-body handler-seq */
20162 static bool
20164 {
20165 tree compound_stmt;
20166 tree try_block;
20169 /* Look for the `try' keyword. */
20172 /* Let the rest of the front end know where we are. */
20174 /* Parse the function-body. */
20175 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
20177 /* We're done with the `try' part. */
20179 /* Parse the handlers. */
20181 /* We're done with the handlers. */
20185 }
20187 /* Parse a handler-seq.
20189 handler-seq:
20190 handler handler-seq [opt] */
20192 static void
20194 {
20196 {
20199 /* Parse the handler. */
20201 /* Peek at the next token. */
20203 /* If it's not `catch' then there are no more handlers. */
20206 }
20207 }
20209 /* Parse a handler.
20211 handler:
20212 catch ( exception-declaration ) compound-statement */
20214 static void
20216 {
20217 tree handler;
20218 tree declaration;
20228 }
20230 /* Parse an exception-declaration.
20232 exception-declaration:
20233 type-specifier-seq declarator
20234 type-specifier-seq abstract-declarator
20235 type-specifier-seq
20236 ...
20238 Returns a VAR_DECL for the declaration, or NULL_TREE if the
20239 ellipsis variant is used. */
20241 static tree
20243 {
20244 cp_decl_specifier_seq type_specifiers;
20248 /* If it's an ellipsis, it's easy to handle. */
20250 {
20251 /* Consume the `...' token. */
20254 }
20256 /* Types may not be defined in exception-declarations. */
20258 parser->type_definition_forbidden_message
20261 /* Parse the type-specifier-seq. */
20265 /* If it's a `)', then there is no declarator. */
20268 else
20274 /* Restore the saved message. */
20281 }
20283 /* Parse a throw-expression.
20285 throw-expression:
20286 throw assignment-expression [opt]
20288 Returns a THROW_EXPR representing the throw-expression. */
20290 static tree
20292 {
20293 tree expression;
20298 /* Figure out whether or not there is an assignment-expression
20299 following the "throw" keyword. */
20307 else
20312 }
20314 /* GNU Extensions */
20316 /* Parse an (optional) asm-specification.
20318 asm-specification:
20319 asm ( string-literal )
20321 If the asm-specification is present, returns a STRING_CST
20322 corresponding to the string-literal. Otherwise, returns
20323 NULL_TREE. */
20325 static tree
20327 {
20329 tree asm_specification;
20331 /* Peek at the next token. */
20333 /* If the next token isn't the `asm' keyword, then there's no
20334 asm-specification. */
20338 /* Consume the `asm' token. */
20340 /* Look for the `('. */
20343 /* Look for the string-literal. */
20346 /* Look for the `)'. */
20350 }
20352 /* Parse an asm-operand-list.
20354 asm-operand-list:
20355 asm-operand
20356 asm-operand-list , asm-operand
20358 asm-operand:
20359 string-literal ( expression )
20360 [ string-literal ] string-literal ( expression )
20362 Returns a TREE_LIST representing the operands. The TREE_VALUE of
20363 each node is the expression. The TREE_PURPOSE is itself a
20364 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
20365 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
20366 is a STRING_CST for the string literal before the parenthesis. Returns
20367 ERROR_MARK_NODE if any of the operands are invalid. */
20369 static tree
20371 {
20376 {
20377 tree string_literal;
20378 tree expression;
20379 tree name;
20382 {
20383 /* Consume the `[' token. */
20385 /* Read the operand name. */
20390 /* Look for the closing `]'. */
20392 }
20393 else
20395 /* Look for the string-literal. */
20398 /* Look for the `('. */
20400 /* Parse the expression. */
20402 /* Look for the `)'. */
20410 /* Add this operand to the list. */
20412 expression,
20413 asm_operands);
20414 /* If the next token is not a `,', there are no more
20415 operands. */
20418 /* Consume the `,'. */
20420 }
20423 }
20425 /* Parse an asm-clobber-list.
20427 asm-clobber-list:
20428 string-literal
20429 asm-clobber-list , string-literal
20431 Returns a TREE_LIST, indicating the clobbers in the order that they
20432 appeared. The TREE_VALUE of each node is a STRING_CST. */
20434 static tree
20436 {
20440 {
20441 tree string_literal;
20443 /* Look for the string literal. */
20445 /* Add it to the list. */
20447 /* If the next token is not a `,', then the list is
20448 complete. */
20451 /* Consume the `,' token. */
20453 }
20456 }
20458 /* Parse an asm-label-list.
20460 asm-label-list:
20461 identifier
20462 asm-label-list , identifier
20464 Returns a TREE_LIST, indicating the labels in the order that they
20465 appeared. The TREE_VALUE of each node is a label. */
20467 static tree
20469 {
20473 {
20476 /* Look for the identifier. */
20479 {
20482 {
20488 }
20489 }
20490 /* If the next token is not a `,', then the list is
20491 complete. */
20494 /* Consume the `,' token. */
20496 }
20499 }
20501 /* Return TRUE iff the next tokens in the stream are possibly the
20502 beginning of a GNU extension attribute. */
20504 static bool
20506 {
20508 }
20510 /* Return TRUE iff the next tokens in the stream are possibly the
20511 beginning of a standard C++-11 attribute specifier. */
20513 static bool
20515 {
20517 }
20519 /* Return TRUE iff the next Nth tokens in the stream are possibly the
20520 beginning of a standard C++-11 attribute specifier. */
20522 static bool
20524 {
20532 }
20534 /* Return TRUE iff the next Nth tokens in the stream are possibly the
20535 beginning of a GNU extension attribute. */
20537 static bool
20539 {
20543 }
20545 /* Return true iff the next tokens can be the beginning of either a
20546 GNU attribute list, or a standard C++11 attribute sequence. */
20548 static bool
20550 {
20553 }
20555 /* Return true iff the next Nth tokens can be the beginning of either
20556 a GNU attribute list, or a standard C++11 attribute sequence. */
20558 static bool
20560 {
20563 }
20565 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
20566 of GNU attributes, or return NULL. */
20568 static tree
20570 {
20574 }
20576 /* Parse an (optional) series of attributes.
20578 attributes:
20579 attributes attribute
20581 attribute:
20582 __attribute__ (( attribute-list [opt] ))
20584 The return value is as for cp_parser_gnu_attribute_list. */
20586 static tree
20588 {
20592 {
20594 tree attribute_list;
20597 /* Peek at the next token. */
20599 /* If it's not `__attribute__', then we're done. */
20603 /* Consume the `__attribute__' keyword. */
20605 /* Look for the two `(' tokens. */
20609 /* Peek at the next token. */
20612 /* Parse the attribute-list. */
20614 else
20615 /* If the next token is a `)', then there is no attribute
20616 list. */
20619 /* Look for the two `)' tokens. */
20627 /* Add these new attributes to the list. */
20629 }
20632 }
20634 /* Parse a GNU attribute-list.
20636 attribute-list:
20637 attribute
20638 attribute-list , attribute
20640 attribute:
20641 identifier
20642 identifier ( identifier )
20643 identifier ( identifier , expression-list )
20644 identifier ( expression-list )
20646 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
20647 to an attribute. The TREE_PURPOSE of each node is the identifier
20648 indicating which attribute is in use. The TREE_VALUE represents
20649 the arguments, if any. */
20651 static tree
20653 {
20659 {
20661 tree identifier;
20662 tree attribute;
20664 /* Look for the identifier. We also allow keywords here; for
20665 example `__attribute__ ((const))' is legal. */
20669 {
20672 /* Consume the token. */
20675 /* Save away the identifier that indicates which attribute
20676 this is. */
20678 /* For keywords, use the canonical spelling, not the
20679 parsed identifier. */
20685 /* Peek at the next token. */
20687 /* If it's an `(', then parse the attribute arguments. */
20689 {
20693 vec = cp_parser_parenthesized_expression_list
20699 else
20700 {
20703 }
20704 /* Save the arguments away. */
20706 }
20709 {
20710 /* Add this attribute to the list. */
20713 }
20716 }
20717 /* Now, look for more attributes. If the next token isn't a
20718 `,', we're done. */
20722 /* Consume the comma and keep going. */
20724 }
20727 /* We built up the list in reverse order. */
20729 }
20731 /* Parse a standard C++11 attribute.
20733 The returned representation is a TREE_LIST which TREE_PURPOSE is
20734 the scoped name of the attribute, and the TREE_VALUE is its
20735 arguments list.
20737 Note that the scoped name of the attribute is itself a TREE_LIST
20738 which TREE_PURPOSE is the namespace of the attribute, and
20739 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
20740 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
20741 and which TREE_PURPOSE is directly the attribute name.
20743 Clients of the attribute code should use get_attribute_namespace
20744 and get_attribute_name to get the actual namespace and name of
20745 attributes, regardless of their being GNU or C++11 attributes.
20747 attribute:
20748 attribute-token attribute-argument-clause [opt]
20750 attribute-token:
20751 identifier
20752 attribute-scoped-token
20754 attribute-scoped-token:
20755 attribute-namespace :: identifier
20757 attribute-namespace:
20758 identifier
20760 attribute-argument-clause:
20761 ( balanced-token-seq )
20763 balanced-token-seq:
20764 balanced-token [opt]
20765 balanced-token-seq balanced-token
20767 balanced-token:
20768 ( balanced-token-seq )
20769 [ balanced-token-seq ]
20770 { balanced-token-seq }. */
20772 static tree
20774 {
20778 /* First, parse name of the the attribute, a.k.a
20779 attribute-token. */
20796 {
20797 /* We are seeing a scoped attribute token. */
20807 else
20808 {
20812 }
20814 NULL_TREE);
20816 }
20817 else
20818 {
20820 NULL_TREE);
20821 /* C++11 noreturn attribute is equivalent to GNU's. */
20824 }
20826 /* Now parse the optional argument clause of the attribute. */
20831 {
20837 /* A GNU attribute that takes an identifier in parameter. */
20840 vec = cp_parser_parenthesized_expression_list
20846 else
20847 {
20850 }
20854 else
20856 }
20859 }
20861 /* Parse a list of standard C++-11 attributes.
20863 attribute-list:
20864 attribute [opt]
20865 attribute-list , attribute[opt]
20866 attribute ...
20867 attribute-list , attribute ...
20868 */
20870 static tree
20872 {
20877 {
20882 {
20885 }
20890 }
20893 }
20895 /* Parse a standard C++-11 attribute specifier.
20897 attribute-specifier:
20898 [ [ attribute-list ] ]
20899 alignment-specifier
20901 alignment-specifier:
20902 alignas ( type-id ... [opt] )
20903 alignas ( alignment-expression ... [opt] ). */
20905 static tree
20907 {
20913 {
20922 else
20923 /* Warn about parsing c++11 attribute in non-c++1 mode, only
20924 when we are sure that we have actually parsed them. */
20926 }
20927 else
20928 {
20929 tree alignas_expr;
20931 /* Look for an alignment-specifier. */
20943 {
20946 }
20952 {
20956 alignas_expr =
20962 }
20965 {
20968 }
20972 /* Build the C++-11 representation of an 'aligned'
20973 attribute. */
20974 attributes =
20978 }
20981 }
20983 /* Parse a standard C++-11 attribute-specifier-seq.
20985 attribute-specifier-seq:
20986 attribute-specifier-seq [opt] attribute-specifier
20987 */
20989 static tree
20991 {
20995 {
21004 }
21008 }
21010 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
21011 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
21012 current value of the PEDANTIC flag, regardless of whether or not
21013 the `__extension__' keyword is present. The caller is responsible
21014 for restoring the value of the PEDANTIC flag. */
21016 static bool
21018 {
21019 /* Save the old value of the PEDANTIC flag. */
21023 {
21024 /* Consume the `__extension__' token. */
21026 /* We're not being pedantic while the `__extension__' keyword is
21027 in effect. */
21031 }
21034 }
21036 /* Parse a label declaration.
21038 label-declaration:
21039 __label__ label-declarator-seq ;
21041 label-declarator-seq:
21042 identifier , label-declarator-seq
21043 identifier */
21045 static void
21047 {
21048 /* Look for the `__label__' keyword. */
21052 {
21053 tree identifier;
21055 /* Look for an identifier. */
21057 /* If we failed, stop. */
21060 /* Declare it as a label. */
21062 /* If the next token is a `;', stop. */
21065 /* Look for the `,' separating the label declarations. */
21067 }
21069 /* Look for the final `;'. */
21071 }
21073 /* Support Functions */
21075 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
21076 NAME should have one of the representations used for an
21077 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
21078 is returned. If PARSER->SCOPE is a dependent type, then a
21079 SCOPE_REF is returned.
21081 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
21082 returned; the name was already resolved when the TEMPLATE_ID_EXPR
21083 was formed. Abstractly, such entities should not be passed to this
21084 function, because they do not need to be looked up, but it is
21085 simpler to check for this special case here, rather than at the
21086 call-sites.
21088 In cases not explicitly covered above, this function returns a
21089 DECL, OVERLOAD, or baselink representing the result of the lookup.
21090 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
21091 is returned.
21093 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
21094 (e.g., "struct") that was used. In that case bindings that do not
21095 refer to types are ignored.
21097 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
21098 ignored.
21100 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
21101 are ignored.
21103 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
21104 types.
21106 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
21107 TREE_LIST of candidates if name-lookup results in an ambiguity, and
21108 NULL_TREE otherwise. */
21110 static tree
21117 location_t name_location)
21118 {
21119 tree decl;
21122 /* Assume that the lookup will be unambiguous. */
21126 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
21127 no longer valid. Note that if we are parsing tentatively, and
21128 the parse fails, OBJECT_TYPE will be automatically restored. */
21134 /* A template-id has already been resolved; there is no lookup to
21135 do. */
21139 {
21143 }
21145 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
21146 it should already have been checked to make sure that the name
21147 used matches the type being destroyed. */
21149 {
21150 tree type;
21152 /* Figure out to which type this destructor applies. */
21157 else
21159 /* If that's not a class type, there is no destructor. */
21166 /* If it was a class type, return the destructor. */
21168 }
21170 /* By this point, the NAME should be an ordinary identifier. If
21171 the id-expression was a qualified name, the qualifying scope is
21172 stored in PARSER->SCOPE at this point. */
21175 /* Perform the lookup. */
21177 {
21183 /* If the SCOPE is dependent, the lookup must be deferred until
21184 the template is instantiated -- unless we are explicitly
21185 looking up names in uninstantiated templates. Even then, we
21186 cannot look up the name if the scope is not a class type; it
21187 might, for example, be a template type parameter. */
21192 /* Defer lookup. */
21194 else
21195 {
21198 /* If PARSER->SCOPE is a dependent type, then it must be a
21199 class type, and we must not be checking dependencies;
21200 otherwise, we would have processed this lookup above. So
21201 that PARSER->SCOPE is not considered a dependent base by
21202 lookup_member, we must enter the scope here. */
21206 /* If the PARSER->SCOPE is a template specialization, it
21207 may be instantiated during name lookup. In that case,
21208 errors may be issued. Even if we rollback the current
21209 tentative parse, those errors are valid. */
21214 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
21215 lookup result and the nested-name-specifier nominates a class C:
21216 * if the name specified after the nested-name-specifier, when
21217 looked up in C, is the injected-class-name of C (Clause 9), or
21218 * if the name specified after the nested-name-specifier is the
21219 same as the identifier or the simple-template-id's template-
21220 name in the last component of the nested-name-specifier,
21221 the name is instead considered to name the constructor of
21222 class C. [ Note: for example, the constructor is not an
21223 acceptable lookup result in an elaborated-type-specifier so
21224 the constructor would not be used in place of the
21225 injected-class-name. --end note ] Such a constructor name
21226 shall be used only in the declarator-id of a declaration that
21227 names a constructor or in a using-declaration. */
21235 /* If we have a single function from a using decl, pull it out. */
21242 }
21244 /* If the scope is a dependent type and either we deferred lookup or
21245 we did lookup but didn't find the name, rememeber the name. */
21248 {
21250 {
21251 tree type;
21253 /* The resolution to Core Issue 180 says that `struct
21254 A::B' should be considered a type-name, even if `A'
21255 is dependent. */
21259 }
21263 CPP_CLOSE_PAREN)))
21267 else
21270 is_template);
21271 }
21274 }
21276 {
21278 /* Look up the name in the scope of the OBJECT_TYPE, unless the
21279 OBJECT_TYPE is not a class. */
21281 /* If the OBJECT_TYPE is a template specialization, it may
21282 be instantiated during name lookup. In that case, errors
21283 may be issued. Even if we rollback the current tentative
21284 parse, those errors are valid. */
21286 name,
21289 tf_warning_or_error);
21290 /* Look it up in the enclosing context, too. */
21298 }
21299 else
21300 {
21306 }
21308 /* If the lookup failed, let our caller know. */
21312 /* Pull out the template from an injected-class-name (or multiple). */
21316 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
21318 {
21321 /* The error message we have to print is too complicated for
21322 cp_parser_error, so we incorporate its actions directly. */
21324 {
21326 name);
21328 }
21330 }
21338 /* If we have resolved the name of a member declaration, check to
21339 see if the declaration is accessible. When the name resolves to
21340 set of overloaded functions, accessibility is checked when
21341 overload resolution is done.
21343 During an explicit instantiation, access is not checked at all,
21344 as per [temp.explicit]. */
21351 }
21353 /* Like cp_parser_lookup_name, but for use in the typical case where
21354 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
21355 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
21357 static tree
21359 {
21361 none_type,
21366 location);
21367 }
21369 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
21370 the current context, return the TYPE_DECL. If TAG_NAME_P is
21371 true, the DECL indicates the class being defined in a class-head,
21372 or declared in an elaborated-type-specifier.
21374 Otherwise, return DECL. */
21376 static tree
21378 {
21379 /* If the TEMPLATE_DECL is being declared as part of a class-head,
21380 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
21382 struct A {
21383 template <typename T> struct B;
21384 };
21386 template <typename T> struct A::B {};
21388 Similarly, in an elaborated-type-specifier:
21390 namespace N { struct X{}; }
21392 struct A {
21393 template <typename T> friend struct N::X;
21394 };
21396 However, if the DECL refers to a class type, and we are in
21397 the scope of the class, then the name lookup automatically
21398 finds the TYPE_DECL created by build_self_reference rather
21399 than a TEMPLATE_DECL. For example, in:
21401 template <class T> struct S {
21402 S s;
21403 };
21405 there is no need to handle such case. */
21411 }
21413 /* If too many, or too few, template-parameter lists apply to the
21414 declarator, issue an error message. Returns TRUE if all went well,
21415 and FALSE otherwise. */
21417 static bool
21420 location_t declarator_location)
21421 {
21423 {
21425 {
21433 /* If the DECLARATOR has the form `X<y>' then it uses one
21434 additional level of template parameters. */
21437 return cp_parser_check_template_parameters
21439 }
21454 }
21456 }
21458 /* NUM_TEMPLATES were used in the current declaration. If that is
21459 invalid, return FALSE and issue an error messages. Otherwise,
21460 return TRUE. If DECLARATOR is non-NULL, then we are checking a
21461 declarator and we can print more accurate diagnostics. */
21463 static bool
21466 location_t location,
21468 {
21469 /* If there are the same number of template classes and parameter
21470 lists, that's OK. */
21473 /* If there are more, but only one more, then we are referring to a
21474 member template. That's OK too. */
21477 /* If there are more template classes than parameter lists, we have
21478 something like:
21480 template <class T> void S<T>::R<T>::f (); */
21482 {
21492 else
21495 }
21496 /* Otherwise, there are too many template parameter lists. We have
21497 something like:
21499 template <class T> template <class U> void S::f(); */
21502 }
21504 /* Parse an optional `::' token indicating that the following name is
21505 from the global namespace. If so, PARSER->SCOPE is set to the
21506 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
21507 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
21508 Returns the new value of PARSER->SCOPE, if the `::' token is
21509 present, and NULL_TREE otherwise. */
21511 static tree
21513 {
21516 /* Peek at the next token. */
21518 /* If we're looking at a `::' token then we're starting from the
21519 global namespace, not our current location. */
21521 {
21522 /* Consume the `::' token. */
21524 /* Set the SCOPE so that we know where to start the lookup. */
21530 }
21532 {
21536 }
21539 }
21541 /* Returns TRUE if the upcoming token sequence is the start of a
21542 constructor declarator. If FRIEND_P is true, the declarator is
21543 preceded by the `friend' specifier. */
21545 static bool
21547 {
21549 tree nested_name_specifier;
21552 /* The common case is that this is not a constructor declarator, so
21553 try to avoid doing lots of work if at all possible. It's not
21554 valid declare a constructor at function scope. */
21557 /* And only certain tokens can begin a constructor declarator. */
21565 /* Parse tentatively; we are going to roll back all of the tokens
21566 consumed here. */
21568 /* Assume that we are looking at a constructor declarator. */
21571 /* Look for the optional `::' operator. */
21574 /* Look for the nested-name-specifier. */
21575 nested_name_specifier
21581 /* Outside of a class-specifier, there must be a
21582 nested-name-specifier. */
21590 /* If we have a class scope, this is easy; DR 147 says that S::S always
21591 names the constructor, and no other qualified name could. */
21594 {
21604 }
21605 /* If we still think that this might be a constructor-declarator,
21606 look for a class-name. */
21608 {
21609 /* If we have:
21611 template <typename T> struct S {
21612 S();
21613 };
21615 we must recognize that the nested `S' names a class. */
21616 tree type_decl;
21620 none_type,
21624 /* If there was no class-name, then this is not a constructor. */
21627 /* If we're still considering a constructor, we have to see a `(',
21628 to begin the parameter-declaration-clause, followed by either a
21629 `)', an `...', or a decl-specifier. We need to check for a
21630 type-specifier to avoid being fooled into thinking that:
21632 S (f) (int);
21634 is a constructor. (It is actually a function named `f' that
21635 takes one parameter (of type `int') and returns a value of type
21636 `S'. */
21644 /* A parameter declaration begins with a decl-specifier,
21645 which is either the "attribute" keyword, a storage class
21646 specifier, or (usually) a type-specifier. */
21648 {
21649 tree type;
21653 /* Names appearing in the type-specifier should be looked up
21654 in the scope of the class. */
21657 else
21658 {
21661 {
21665 {
21668 }
21669 }
21671 }
21673 /* Inside the constructor parameter list, surrounding
21674 template-parameter-lists do not apply. */
21675 saved_num_template_parameter_lists
21679 /* Look for the type-specifier. */
21681 CP_PARSER_FLAGS_NONE,
21687 parser->num_template_parameter_lists
21690 /* Leave the scope of the class. */
21695 }
21696 }
21698 /* We did not really want to consume any tokens. */
21702 }
21704 /* Parse the definition of the function given by the DECL_SPECIFIERS,
21705 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
21706 they must be performed once we are in the scope of the function.
21708 Returns the function defined. */
21710 static tree
21711 cp_parser_function_definition_from_specifiers_and_declarator
21714 tree attributes,
21716 {
21717 tree fn;
21720 /* Begin the function-definition. */
21723 /* The things we're about to see are not directly qualified by any
21724 template headers we've seen thus far. */
21727 /* If there were names looked up in the decl-specifier-seq that we
21728 did not check, check them now. We must wait until we are in the
21729 scope of the function to perform the checks, since the function
21730 might be a friend. */
21734 {
21735 /* Skip the entire function. */
21738 }
21740 {
21741 /* Seen already, skip it. An error message has already been output. */
21745 /* If this is a function from a class, pop the nested class. */
21748 }
21749 else
21750 {
21751 timevar_id_t tv;
21754 else
21760 }
21763 }
21765 /* Parse the part of a function-definition that follows the
21766 declarator. INLINE_P is TRUE iff this function is an inline
21767 function defined within a class-specifier.
21769 Returns the function defined. */
21771 static tree
21774 {
21775 tree fn;
21784 /* If the next token is `return', then the code may be trying to
21785 make use of the "named return value" extension that G++ used to
21786 support. */
21789 {
21790 /* Consume the `return' keyword. */
21792 /* Look for the identifier that indicates what value is to be
21793 returned. */
21795 /* Issue an error message. */
21798 /* Skip tokens until we reach the start of the function body. */
21800 {
21807 }
21808 }
21809 /* The `extern' in `extern "C" void f () { ... }' does not apply to
21810 anything declared inside `f'. */
21811 saved_in_unbraced_linkage_specification_p
21814 /* Inside the function, surrounding template-parameter-lists do not
21815 apply. */
21816 saved_num_template_parameter_lists
21822 /* If the next token is `try', `__transaction_atomic', or
21823 `__transaction_relaxed`, then we are looking at either function-try-block
21824 or function-transaction-block. Note that all of these include the
21825 function-body. */
21828 RID_TRANSACTION_ATOMIC);
21830 RID_TRANSACTION_RELAXED))
21832 RID_TRANSACTION_RELAXED);
21835 else
21836 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
21841 /* Finish the function. */
21844 /* Generate code for it, if necessary. */
21846 /* Restore the saved values. */
21847 parser->in_unbraced_linkage_specification_p
21849 parser->num_template_parameter_lists
21854 }
21856 /* Parse a template-declaration, assuming that the `export' (and
21857 `extern') keywords, if present, has already been scanned. MEMBER_P
21858 is as for cp_parser_template_declaration. */
21860 static void
21862 {
21865 tree parameter_list;
21870 /* Look for the `template' keyword. */
21875 /* And the `<'. */
21879 {
21880 /* 14.5.2.2 [temp.mem]
21882 A local class shall not have member templates. */
21887 }
21888 /* [temp]
21890 A template ... shall not have C linkage. */
21892 {
21894 /* Give it C++ linkage to avoid confusing other parts of the
21895 front end. */
21898 }
21899 else
21902 /* We cannot perform access checks on the template parameter
21903 declarations until we know what is being declared, just as we
21904 cannot check the decl-specifier list. */
21907 /* If the next token is `>', then we have an invalid
21908 specialization. Rather than complain about an invalid template
21909 parameter, issue an error message here. */
21911 {
21915 }
21916 else
21917 {
21918 /* Parse the template parameters. */
21920 }
21922 /* Get the deferred access checks from the parameter list. These
21923 will be checked once we know what is being declared, as for a
21924 member template the checks must be performed in the scope of the
21925 class containing the member. */
21928 /* Look for the `>'. */
21930 /* We just processed one more parameter list. */
21932 /* If the next token is `template', there are more template
21933 parameters. */
21935 RID_TEMPLATE))
21940 else
21941 {
21942 /* There are no access checks when parsing a template, as we do not
21943 know if a specialization will be a friend. */
21947 checks,
21948 member_p,
21953 /* If this is a member template declaration, let the front
21954 end know. */
21956 {
21961 }
21967 }
21968 /* We are done with the current parameter list. */
21973 /* Finish up. */
21976 /* Check the template arguments for a literal operator template. */
21980 {
21984 else
21985 {
21989 else
21990 {
21996 }
21997 }
22001 decl);
22002 }
22003 /* Register member declarations. */
22006 /* For the erroneous case of a template with C linkage, we pushed an
22007 implicit C++ linkage scope; exit that scope now. */
22010 /* If DECL is a function template, we must return to parse it later.
22011 (Even though there is no definition, there might be default
22012 arguments that need handling.) */
22017 }
22019 /* Perform the deferred access checks from a template-parameter-list.
22020 CHECKS is a TREE_LIST of access checks, as returned by
22021 get_deferred_access_checks. */
22023 static void
22024 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
22025 {
22029 }
22031 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
22032 `function-definition' sequence that follows a template header.
22033 If MEMBER_P is true, this declaration appears in a class scope.
22035 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
22036 *FRIEND_P is set to TRUE iff the declaration is a friend. */
22038 static tree
22044 {
22047 cp_decl_specifier_seq decl_specifiers;
22051 /* This function is only used when processing a template
22052 declaration. */
22056 /* Defer access checks until we know what is being declared. */
22059 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
22060 alternative. */
22063 CP_PARSER_FLAGS_OPTIONAL,
22069 /* There are no template typedefs. */
22071 {
22075 }
22077 /* Gather up the access checks that occurred the
22078 decl-specifier-seq. */
22081 /* Check for the declaration of a template class. */
22083 {
22085 {
22088 /* In this case:
22090 struct C {
22091 friend template <typename T> struct A<T>::B;
22092 };
22094 A<T>::B will be represented by a TYPENAME_TYPE, and
22095 therefore not recognized by shadow_tag. */
22097 && !decl
22104 else
22107 /* Perform access checks for template parameters. */
22109 }
22110 }
22112 /* Complain about missing 'typename' or other invalid type names. */
22115 {
22116 /* cp_parser_parse_and_diagnose_invalid_type_name calls
22117 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
22118 the rest of this declaration. */
22121 }
22123 /* If it's not a template class, try for a template function. If
22124 the next token is a `;', then this declaration does not declare
22125 anything. But, if there were errors in the decl-specifiers, then
22126 the error might well have come from an attempted class-specifier.
22127 In that case, there's no need to warn about a missing declarator. */
22131 {
22134 checks,
22136 member_p,
22137 declares_class_or_enum,
22139 NULL);
22141 /* 7.1.1-1 [dcl.stc]
22143 A storage-class-specifier shall not be specified in an explicit
22144 specialization... */
22146 && explicit_specialization_p
22148 {
22152 }
22156 }
22158 /* Look for a trailing `;' after the declaration. */
22164 out:
22167 /* Clear any current qualification; whatever comes next is the start
22168 of something new. */
22174 }
22176 /* Parse a cast-expression that is not the operand of a unary "&". */
22178 static tree
22180 {
22183 }
22185 /* Parse a functional cast to TYPE. Returns an expression
22186 representing the cast. */
22188 static tree
22190 {
22192 tree expression_list;
22193 tree cast;
22200 {
22207 tf_warning_or_error);
22208 }
22217 else
22218 {
22221 }
22224 tf_warning_or_error);
22225 /* [expr.const]/1: In an integral constant expression "only type
22226 conversions to integral or enumeration type can be used". */
22232 NIC_CONSTRUCTOR))
22235 }
22237 /* Save the tokens that make up the body of a member function defined
22238 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
22239 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
22240 specifiers applied to the declaration. Returns the FUNCTION_DECL
22241 for the member function. */
22243 static tree
22247 tree attributes)
22248 {
22251 tree fn;
22253 /* Create the FUNCTION_DECL. */
22255 /* If something went badly wrong, bail out now. */
22257 {
22258 /* If there's a function-body, skip it. */
22263 }
22265 /* Remember it, if there default args to post process. */
22268 /* Save away the tokens that make up the body of the
22269 function. */
22271 /* We can have braced-init-list mem-initializers before the fn body. */
22273 {
22277 {
22278 /* cache_group will stop after an un-nested { } pair, too. */
22282 /* variadic mem-inits have ... after the ')'. */
22285 }
22286 }
22288 /* Handle function try blocks. */
22293 /* Save away the inline definition; we will process it when the
22294 class is complete. */
22298 /* We need to know that this was defined in the class, so that
22299 friend templates are handled correctly. */
22302 /* Add FN to the queue of functions to be parsed later. */
22306 }
22308 /* Save the tokens that make up the in-class initializer for a non-static
22309 data member. Returns a DEFAULT_ARG. */
22311 static tree
22313 {
22315 }
22317 /* Parse a template-argument-list, as well as the trailing ">" (but
22318 not the opening "<"). See cp_parser_template_argument_list for the
22319 return value. */
22321 static tree
22323 {
22324 tree arguments;
22325 tree saved_scope;
22326 tree saved_qualifying_scope;
22327 tree saved_object_scope;
22332 /* [temp.names]
22334 When parsing a template-id, the first non-nested `>' is taken as
22335 the end of the template-argument-list rather than a greater-than
22336 operator. */
22337 saved_greater_than_is_operator_p
22340 /* Parsing the argument list may modify SCOPE, so we save it
22341 here. */
22345 /* We need to evaluate the template arguments, even though this
22346 template-id may be nested within a "sizeof". */
22351 /* Parse the template-argument-list itself. */
22355 else
22357 /* Look for the `>' that ends the template-argument-list. If we find
22358 a '>>' instead, it's probably just a typo. */
22360 {
22362 {
22363 /* In C++0x, a `>>' in a template argument list or cast
22364 expression is considered to be two separate `>'
22365 tokens. So, change the current token to a `>', but don't
22366 consume it: it will be consumed later when the outer
22367 template argument list (or cast expression) is parsed.
22368 Note that this replacement of `>' for `>>' is necessary
22369 even if we are parsing tentatively: in the tentative
22370 case, after calling
22371 cp_parser_enclosed_template_argument_list we will always
22372 throw away all of the template arguments and the first
22373 closing `>', either because the template argument list
22374 was erroneous or because we are replacing those tokens
22375 with a CPP_TEMPLATE_ID token. The second `>' (which will
22376 not have been thrown away) is needed either to close an
22377 outer template argument list or to complete a new-style
22378 cast. */
22381 }
22383 {
22384 /* If we're in a nested template argument list, the '>>' has
22385 to be a typo for '> >'. We emit the error message, but we
22386 continue parsing and we push a '>' as next token, so that
22387 the argument list will be parsed correctly. Note that the
22388 global source location is still on the token before the
22389 '>>', so we need to say explicitly where we want it. */
22395 }
22396 else
22397 {
22398 /* If this is not a nested template argument list, the '>>'
22399 is a typo for '>'. Emit an error message and continue.
22400 Same deal about the token location, but here we can get it
22401 right by consuming the '>>' before issuing the diagnostic. */
22404 "spurious %<>>%>, use %<>%> to terminate "
22406 }
22407 }
22408 else
22410 /* The `>' token might be a greater-than operator again now. */
22411 parser->greater_than_is_operator_p
22413 /* Restore the SAVED_SCOPE. */
22421 }
22423 /* MEMBER_FUNCTION is a member function, or a friend. If default
22424 arguments, or the body of the function have not yet been parsed,
22425 parse them now. */
22427 static void
22429 {
22431 /* If this member is a template, get the underlying
22432 FUNCTION_DECL. */
22436 /* There should not be any class definitions in progress at this
22437 point; the bodies of members are only parsed outside of all class
22438 definitions. */
22440 /* While we're parsing the member functions we might encounter more
22441 classes. We want to handle them right away, but we don't want
22442 them getting mixed up with functions that are currently in the
22443 queue. */
22446 /* Make sure that any template parameters are in scope. */
22449 /* If the body of the function has not yet been parsed, parse it
22450 now. */
22452 {
22453 tree function_scope;
22456 /* The function is no longer pending; we are processing it. */
22461 /* If this is a local class, enter the scope of the containing
22462 function. */
22467 /* Push the body of the function onto the lexer stack. */
22470 /* Let the front end know that we going to be defining this
22471 function. */
22475 /* Don't do access checking if it is a templated function. */
22479 /* Now, parse the body of the function. */
22486 /* Leave the scope of the containing function. */
22490 }
22492 /* Remove any template parameters from the symbol table. */
22495 /* Restore the queue. */
22498 }
22500 /* If DECL contains any default args, remember it on the unparsed
22501 functions queue. */
22503 static void
22505 {
22506 tree probe;
22509 probe;
22512 {
22516 }
22517 }
22519 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
22520 which is either a FIELD_DECL or PARM_DECL. Parse it and return
22521 the result. For a PARM_DECL, PARMTYPE is the corresponding type
22522 from the parameter-type-list. */
22524 static tree
22527 {
22529 tree parsed_arg;
22535 /* Push the saved tokens for the default argument onto the parser's
22536 lexer stack. */
22542 /* Parse the default argument. */
22553 {
22554 /* In a non-template class, check conversions now. In a template,
22555 we'll wait and instantiate these as needed. */
22558 tf_warning_or_error);
22559 else
22560 {
22567 /* This represents the whole initialization. */
22569 }
22570 }
22572 /* If the token stream has not been completely used up, then
22573 there was extra junk after the end of the default
22574 argument. */
22576 {
22579 else
22581 }
22583 /* Revert to the main lexer. */
22587 }
22589 /* FIELD is a non-static data member with an initializer which we saved for
22590 later; parse it now. */
22592 static void
22594 {
22595 tree def;
22600 NULL_TREE);
22604 }
22606 /* FN is a FUNCTION_DECL which may contains a parameter with an
22607 unparsed DEFAULT_ARG. Parse the default args now. This function
22608 assumes that the current scope is the scope in which the default
22609 argument should be processed. */
22611 static void
22613 {
22617 /* While we're parsing the default args, we might (due to the
22618 statement expression extension) encounter more classes. We want
22619 to handle them right away, but we don't want them getting mixed
22620 up with default args that are currently in the queue. */
22623 /* Local variable names (and the `this' keyword) may not appear
22624 in a default argument. */
22635 {
22637 tree parsed_arg;
22639 tree copy;
22646 /* This can happen for a friend declaration for a function
22647 already declared with default arguments. */
22650 parsed_arg
22652 default_arg,
22655 {
22657 }
22661 /* Update any instantiations we've already created. */
22665 }
22669 /* Make sure no default arg is missing. */
22672 /* Restore the state of local_variables_forbidden_p. */
22675 /* Restore the queue. */
22677 }
22679 /* Parse the operand of `sizeof' (or a similar operator). Returns
22680 either a TYPE or an expression, depending on the form of the
22681 input. The KEYWORD indicates which kind of expression we have
22682 encountered. */
22684 static tree
22686 {
22694 /* Types cannot be defined in a `sizeof' expression. Save away the
22695 old message. */
22697 /* And create the new one. */
22703 /* The restrictions on constant-expressions do not apply inside
22704 sizeof expressions. */
22705 saved_integral_constant_expression_p
22707 saved_non_integral_constant_expression_p
22711 /* If it's a `...', then we are computing the length of a parameter
22712 pack. */
22715 {
22716 /* Consume the `...'. */
22720 /* Note that this is an expansion. */
22722 }
22724 /* Do not actually evaluate the expression. */
22727 /* If it's a `(', then we might be looking at the type-id
22728 construction. */
22730 {
22731 tree type;
22734 /* We can't be sure yet whether we're looking at a type-id or an
22735 expression. */
22737 /* Consume the `('. */
22739 /* Parse the type-id. */
22744 /* Now, look for the trailing `)'. */
22746 /* If all went well, then we're done. */
22748 {
22749 cp_decl_specifier_seq decl_specs;
22751 /* Build a trivial decl-specifier-seq. */
22755 /* Call grokdeclarator to figure out what type this is. */
22758 TYPENAME,
22761 }
22762 }
22767 /* If the type-id production did not work out, then we must be
22768 looking at the unary-expression production. */
22774 /* Build a pack expansion. */
22777 /* Go back to evaluating expressions. */
22781 /* Free the message we created. */
22783 /* And restore the old one. */
22785 parser->integral_constant_expression_p
22787 parser->non_integral_constant_expression_p
22791 }
22793 /* If the current declaration has no declarator, return true. */
22795 static bool
22797 {
22798 /* If the next token is a `;' or a `,' then there is no
22799 declarator. */
22802 }
22804 /* Update the DECL_SPECS to reflect the storage class indicated by
22805 KEYWORD. */
22807 static void
22812 {
22813 cp_storage_class storage_class;
22816 {
22820 }
22822 {
22825 }
22830 {
22833 }
22836 {
22854 }
22858 /* A storage class specifier cannot be applied alongside a typedef
22859 specifier. If there is a typedef specifier present then set
22860 conflicting_specifiers_p which will trigger an error later
22861 on in grokdeclarator. */
22864 }
22866 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
22867 is true, the type is a class or enum definition. */
22869 static void
22871 tree type_spec,
22874 {
22877 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
22878 (with, for example, in "typedef int wchar_t;") we remember that
22879 this is what happened. In system headers, we ignore these
22880 declarations so that G++ can work with system headers that are not
22881 C++-safe. */
22883 && !type_definition_p
22893 {
22896 ds_redefined_builtin_type_spec,
22897 token);
22899 {
22903 }
22904 }
22907 else
22908 {
22913 }
22914 }
22916 /* True iff TOKEN is the GNU keyword __thread. */
22918 static bool
22920 {
22923 }
22925 /* Set the location for a declarator specifier and check if it is
22926 duplicated.
22928 DECL_SPECS is the sequence of declarator specifiers onto which to
22929 set the location.
22931 DS is the single declarator specifier to set which location is to
22932 be set onto the existing sequence of declarators.
22934 LOCATION is the location for the declarator specifier to
22935 consider. */
22937 static void
22940 {
22949 {
22953 }
22954 else
22955 {
22957 {
22961 else
22962 {
22965 OPT_Wlong_long,
22967 }
22968 }
22970 {
22975 else
22977 }
22978 else
22979 {
22995 "__complex"
22996 };
22999 }
23000 }
23001 }
23003 /* Return true iff the declarator specifier DS is present in the
23004 sequence of declarator specifiers DECL_SPECS. */
23006 bool
23008 cp_decl_spec ds)
23009 {
23016 }
23018 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
23019 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
23021 static bool
23023 {
23025 }
23027 /* Issue an error message indicating that TOKEN_DESC was expected.
23028 If KEYWORD is true, it indicated this function is called by
23029 cp_parser_require_keword and the required token can only be
23030 a indicated keyword. */
23032 static void
23034 required_token token_desc,
23036 {
23038 {
23107 }
23109 {
23111 {
23190 }
23191 }
23192 else
23194 }
23198 /* If the next token is of the indicated TYPE, consume it. Otherwise,
23199 issue an error message indicating that TOKEN_DESC was expected.
23201 Returns the token consumed, if the token had the appropriate type.
23202 Otherwise, returns NULL. */
23207 required_token token_desc)
23208 {
23211 else
23212 {
23213 /* Output the MESSAGE -- unless we're parsing tentatively. */
23217 }
23218 }
23220 /* An error message is produced if the next token is not '>'.
23221 All further tokens are skipped until the desired token is
23222 found or '{', '}', ';' or an unbalanced ')' or ']'. */
23224 static void
23226 {
23227 /* Current level of '< ... >'. */
23229 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
23232 /* Are we ready, yet? If not, issue error message. */
23236 /* Skip tokens until the desired token is found. */
23238 {
23239 /* Peek at the next token. */
23241 {
23249 /* C++0x views the `>>' operator as two `>' tokens, but
23250 C++98 does not. */
23253 {
23254 /* We've hit a `>>' where the first `>' closes the
23255 template argument list, and the second `>' is
23256 spurious. Just consume the `>>' and stop; we've
23257 already produced at least one error. */
23260 }
23261 /* Fall through for C++0x, so we handle the second `>' in
23262 the `>>'. */
23266 {
23267 /* We've reached the token we want, consume it and stop. */
23270 }
23289 /* The '>' was probably forgotten, don't look further. */
23294 }
23296 /* Consume this token. */
23298 }
23299 }
23301 /* If the next token is the indicated keyword, consume it. Otherwise,
23302 issue an error message indicating that TOKEN_DESC was expected.
23304 Returns the token consumed, if the token had the appropriate type.
23305 Otherwise, returns NULL. */
23310 required_token token_desc)
23311 {
23315 {
23318 }
23321 }
23323 /* Returns TRUE iff TOKEN is a token that can begin the body of a
23324 function-definition. */
23326 static bool
23328 {
23331 /* A ctor-initializer begins with a `:'. */
23333 /* A function-try-block begins with `try'. */
23335 /* A function-transaction-block begins with `__transaction_atomic'
23336 or `__transaction_relaxed'. */
23339 /* The named return value extension begins with `return'. */
23341 }
23343 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
23344 definition. */
23346 static bool
23348 {
23353 }
23355 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
23356 C++0x) ending a template-argument. */
23358 static bool
23360 {
23368 }
23370 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
23371 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
23373 static bool
23376 {
23382 /* Check for the sequence `<::' in the original code. It would be lexed as
23383 `[:', where `[' is a digraph, and there is no whitespace before
23384 `:'. */
23386 {
23391 }
23393 }
23395 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
23396 or none_type otherwise. */
23398 static enum tag_types
23400 {
23402 {
23412 }
23413 }
23415 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
23417 static void
23419 {
23423 {
23427 type);
23430 }
23431 }
23433 /* Issue an error message if DECL is redeclared with different
23434 access than its original declaration [class.access.spec/3].
23435 This applies to nested classes and nested class templates.
23436 [class.mem/1]. */
23438 static void
23440 {
23449 }
23451 /* Look for the `template' keyword, as a syntactic disambiguator.
23452 Return TRUE iff it is present, in which case it will be
23453 consumed. */
23455 static bool
23457 {
23459 {
23460 /* In C++98 the `template' keyword can only be used within templates;
23461 outside templates the parser can always figure out what is a
23462 template and what is not. In C++11, per the resolution of DR 468,
23463 `template' is allowed in cases where it is not strictly necessary. */
23466 {
23469 "in C++98 %<template%> (as a disambiguator) is only "
23471 /* If this part of the token stream is rescanned, the same
23472 error message would be generated. So, we purge the token
23473 from the stream. */
23476 }
23477 else
23478 {
23479 /* Consume the `template' keyword. */
23482 }
23483 }
23485 }
23487 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
23488 set PARSER->SCOPE, and perform other related actions. */
23490 static void
23492 {
23498 /* Get the stored value. */
23500 /* Perform any access checks that were deferred. */
23503 {
23508 }
23509 /* Set the scope from the stored value. */
23513 }
23515 /* Consume tokens up through a non-nested END token. Returns TRUE if we
23516 encounter the end of a block before what we were looking for. */
23518 static bool
23522 {
23524 {
23527 /* Abort a parenthesized expression if we encounter a semicolon. */
23531 /* If we've reached the end of the file, stop. */
23537 /* We've hit the end of an enclosing block, so there's been some
23538 kind of syntax error. */
23541 /* Consume the token. */
23543 /* See if it starts a new group. */
23545 {
23547 /* In theory this should probably check end == '}', but
23548 cp_parser_save_member_function_body needs it to exit
23549 after either '}' or ')' when called with ')'. */
23552 }
23554 {
23558 }
23563 }
23564 }
23566 /* Like above, for caching a default argument or NSDMI. Both of these are
23567 terminated by a non-nested comma, but it can be unclear whether or not a
23568 comma is nested in a template argument list unless we do more parsing.
23569 In order to handle this ambiguity, when we encounter a ',' after a '<'
23570 we try to parse what follows as a parameter-declaration-list (in the
23571 case of a default argument) or a member-declarator (in the case of an
23572 NSDMI). If that succeeds, then we stop caching. */
23574 static tree
23576 {
23581 tree default_argument;
23583 /* Add tokens until we have processed the entire default
23584 argument. We add the range [first_token, token). */
23587 {
23588 /* For list-initialization, this is straightforward. */
23591 }
23593 {
23596 /* Peek at the next token. */
23598 /* What we do depends on what token we have. */
23600 {
23601 /* In valid code, a default argument must be
23602 immediately followed by a `,' `)', or `...'. */
23605 {
23606 /* If we've seen a '<', we might be in a
23607 template-argument-list. Until Core issue 325 is
23608 resolved, we don't know how this situation ought
23609 to be handled, so try to DTRT. We check whether
23610 what comes after the comma is a valid parameter
23611 declaration list. If it is, then the comma ends
23612 the default argument; otherwise the default
23613 argument continues. */
23615 tree t;
23617 /* Set ITALP so cp_parser_parameter_declaration_list
23618 doesn't decide to commit to this parse. */
23626 {
23632 }
23633 else
23634 {
23640 }
23647 }
23650 /* If we run into a non-nested `;', `}', or `]',
23651 then the code is invalid -- but the default
23652 argument is certainly over. */
23658 /* Update DEPTH, if necessary. */
23673 /* This might be the comparison operator, or it might
23674 start a template argument list. */
23681 /* Fall through for C++0x, which treats the `>>'
23682 operator like two `>' tokens in certain
23683 cases. */
23687 {
23688 /* This might be an operator, or it might close a
23689 template argument list. But if a previous '<'
23690 started a template argument list, this will have
23691 closed it, so we can't be in one anymore. */
23695 }
23698 /* If we run out of tokens, issue an error message. */
23707 /* In these cases, we should look for template-ids.
23708 For example, if the default argument is
23709 `X<int, double>()', we need to do name lookup to
23710 figure out whether or not `X' is a template; if
23711 so, the `,' does not end the default argument.
23713 That is not yet done. */
23718 }
23720 /* If we've reached the end, stop. */
23724 /* Add the token to the token block. */
23726 }
23728 /* Create a DEFAULT_ARG to represent the unparsed default
23729 argument. */
23736 }
23738 /* Begin parsing tentatively. We always save tokens while parsing
23739 tentatively so that if the tentative parsing fails we can restore the
23740 tokens. */
23742 static void
23744 {
23745 /* Enter a new parsing context. */
23747 /* Begin saving tokens. */
23749 /* In order to avoid repetitive access control error messages,
23750 access checks are queued up until we are no longer parsing
23751 tentatively. */
23753 }
23755 /* Commit to the currently active tentative parse. */
23757 static void
23759 {
23763 /* Mark all of the levels as committed. */
23766 {
23773 }
23774 }
23776 /* Abort the currently active tentative parse. All consumed tokens
23777 will be rolled back, and no diagnostics will be issued. */
23779 static void
23781 {
23783 /* Now, pretend that we want to see if the construct was
23784 successfully parsed. */
23786 }
23788 /* Stop parsing tentatively. If a parse error has occurred, restore the
23789 token stream. Otherwise, commit to the tokens we have consumed.
23790 Returns true if no error occurred; false otherwise. */
23792 static bool
23794 {
23798 /* Remember whether or not an error occurred, since we are about to
23799 destroy that information. */
23801 /* Remove the topmost context from the stack. */
23804 /* If no parse errors occurred, commit to the tentative parse. */
23806 {
23807 /* Commit to the tokens read tentatively, unless that was
23808 already done. */
23813 }
23814 /* Otherwise, if errors occurred, roll back our state so that things
23815 are just as they were before we began the tentative parse. */
23816 else
23817 {
23820 }
23821 /* Add the context to the front of the free list. */
23826 }
23828 /* Returns true if we are parsing tentatively and are not committed to
23829 this tentative parse. */
23831 static bool
23833 {
23836 }
23838 /* Returns nonzero iff an error has occurred during the most recent
23839 tentative parse. */
23841 static bool
23843 {
23846 }
23848 /* Returns nonzero if GNU extensions are allowed. */
23850 static bool
23852 {
23854 }
23855 \f
23856 /* Objective-C++ Productions */
23859 /* Parse an Objective-C expression, which feeds into a primary-expression
23860 above.
23862 objc-expression:
23863 objc-message-expression
23864 objc-string-literal
23865 objc-encode-expression
23866 objc-protocol-expression
23867 objc-selector-expression
23869 Returns a tree representation of the expression. */
23871 static tree
23873 {
23874 /* Try to figure out what kind of declaration is present. */
23878 {
23888 {
23900 }
23906 }
23909 }
23911 /* Parse an Objective-C message expression.
23913 objc-message-expression:
23914 [ objc-message-receiver objc-message-args ]
23916 Returns a representation of an Objective-C message. */
23918 static tree
23920 {
23929 }
23931 /* Parse an objc-message-receiver.
23933 objc-message-receiver:
23934 expression
23935 simple-type-specifier
23937 Returns a representation of the type or expression. */
23939 static tree
23941 {
23942 tree rcv;
23944 /* An Objective-C message receiver may be either (1) a type
23945 or (2) an expression. */
23954 CP_PARSER_FLAGS_NONE);
23957 }
23959 /* Parse the arguments and selectors comprising an Objective-C message.
23961 objc-message-args:
23962 objc-selector
23963 objc-selector-args
23964 objc-selector-args , objc-comma-args
23966 objc-selector-args:
23967 objc-selector [opt] : assignment-expression
23968 objc-selector-args objc-selector [opt] : assignment-expression
23970 objc-comma-args:
23971 assignment-expression
23972 objc-comma-args , assignment-expression
23974 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
23975 selector arguments and TREE_VALUE containing a list of comma
23976 arguments. */
23978 static tree
23980 {
23986 {
23992 /* Detect if we have a unary selector. */
24001 sel_args
24006 }
24008 /* Handle non-selector arguments, if any. */
24010 {
24011 tree arg;
24016 addl_args
24021 }
24024 {
24027 }
24030 }
24032 /* Parse an Objective-C encode expression.
24034 objc-encode-expression:
24035 @encode objc-typename
24037 Returns an encoded representation of the type argument. */
24039 static tree
24041 {
24042 tree type;
24052 {
24056 }
24058 /* This happens if we find @encode(T) (where T is a template
24059 typename or something dependent on a template typename) when
24060 parsing a template. In that case, we can't compile it
24061 immediately, but we rather create an AT_ENCODE_EXPR which will
24062 need to be instantiated when the template is used.
24063 */
24065 {
24069 }
24072 }
24074 /* Parse an Objective-C @defs expression. */
24076 static tree
24078 {
24079 tree name;
24087 }
24089 /* Parse an Objective-C protocol expression.
24091 objc-protocol-expression:
24092 @protocol ( identifier )
24094 Returns a representation of the protocol expression. */
24096 static tree
24098 {
24099 tree proto;
24107 }
24109 /* Parse an Objective-C selector expression.
24111 objc-selector-expression:
24112 @selector ( objc-method-signature )
24114 objc-method-signature:
24115 objc-selector
24116 objc-selector-seq
24118 objc-selector-seq:
24119 objc-selector :
24120 objc-selector-seq objc-selector :
24122 Returns a representation of the method selector. */
24124 static tree
24126 {
24138 {
24147 {
24148 /* Detect if we have a unary selector. */
24150 {
24153 }
24154 else
24155 {
24157 }
24158 }
24163 {
24164 sel_seq
24167 sel_seq
24170 }
24171 else
24172 sel_seq
24177 }
24179 finish_selector:
24183 }
24185 /* Parse a list of identifiers.
24187 objc-identifier-list:
24188 identifier
24189 objc-identifier-list , identifier
24191 Returns a TREE_LIST of identifier nodes. */
24193 static tree
24195 {
24196 tree identifier;
24197 tree list;
24208 {
24215 identifier));
24217 }
24220 }
24222 /* Parse an Objective-C alias declaration.
24224 objc-alias-declaration:
24225 @compatibility_alias identifier identifier ;
24227 This function registers the alias mapping with the Objective-C front end.
24228 It returns nothing. */
24230 static void
24232 {
24240 }
24242 /* Parse an Objective-C class forward-declaration.
24244 objc-class-declaration:
24245 @class objc-identifier-list ;
24247 The function registers the forward declarations with the Objective-C
24248 front end. It returns nothing. */
24250 static void
24252 {
24255 {
24256 tree id;
24266 else
24268 }
24270 }
24272 /* Parse a list of Objective-C protocol references.
24274 objc-protocol-refs-opt:
24275 objc-protocol-refs [opt]
24277 objc-protocol-refs:
24278 < objc-identifier-list >
24280 Returns a TREE_LIST of identifiers, if any. */
24282 static tree
24284 {
24288 {
24292 }
24295 }
24297 /* Parse a Objective-C visibility specification. */
24299 static void
24301 {
24305 {
24320 }
24322 /* Eat '@private'/'@protected'/'@public'. */
24324 }
24326 /* Parse an Objective-C method type. Return 'true' if it is a class
24327 (+) method, and 'false' if it is an instance (-) method. */
24331 {
24334 else
24336 }
24338 /* Parse an Objective-C protocol qualifier. */
24340 static tree
24342 {
24355 {
24360 }
24363 }
24365 /* Parse an Objective-C typename. */
24367 static tree
24369 {
24373 {
24379 /* An ObjC type name may consist of just protocol qualifiers, in which
24380 case the type shall default to 'id'. */
24382 {
24385 /* If the type could not be parsed, an error has already
24386 been produced. For error recovery, behave as if it had
24387 not been specified, which will use the default type
24388 'id'. */
24390 {
24392 /* We need to skip to the closing parenthesis as
24393 cp_parser_type_id() does not seem to do it for
24394 us. */
24399 }
24400 }
24404 }
24407 }
24409 /* Check to see if TYPE refers to an Objective-C selector name. */
24411 static bool
24413 {
24419 }
24421 /* Parse an Objective-C selector. */
24423 static tree
24425 {
24429 {
24432 }
24434 /* C++ operator names are allowed to appear in ObjC selectors. */
24436 {
24449 }
24450 }
24452 /* Parse an Objective-C params list. */
24454 static tree
24456 {
24462 {
24472 /* Detect if we have a unary selector. */
24475 {
24478 }
24482 {
24483 /* Something went quite wrong. There should be a colon
24484 here, but there is not. Stop parsing parameters. */
24486 }
24488 /* New ObjC allows attributes on parameters too. */
24493 params
24496 type_name,
24497 identifier,
24498 parm_attr));
24501 }
24504 {
24507 }
24509 /* We allow tail attributes for the method. */
24511 {
24519 }
24522 {
24525 }
24527 }
24529 /* Parse the non-keyword Objective-C params. */
24531 static tree
24534 {
24540 {
24542 tree parm;
24548 {
24553 }
24555 /* TODO: parse attributes for tail parameters. */
24564 }
24566 /* We allow tail attributes for the method. */
24568 {
24570 {
24575 }
24576 else
24577 /* We have an error, but parse the attributes, so that we can
24578 carry on. */
24584 }
24587 }
24589 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
24591 static void
24593 {
24596 /* If the next token is `extern' and the following token is a string
24597 literal, then we have a linkage specification. */
24599 && cp_parser_is_pure_string_literal
24602 /* Handle #pragma, if any. */
24605 /* Allow stray semicolons. */
24608 /* Mark methods as optional or required, when building protocols. */
24610 {
24613 }
24615 {
24618 }
24621 /* Other stray characters must generate errors. */
24623 {
24627 }
24628 /* Finally, try to parse a block-declaration, or a function-definition. */
24629 else
24631 }
24633 /* Parse a method signature. */
24635 static tree
24637 {
24653 }
24655 static bool
24657 {
24658 tree tattr;
24663 /* If the attributes are followed by a method introducer, this is not allowed.
24664 Dump the attributes and flag the situation. */
24669 /* Otherwise, the attributes introduce some interstitial code, possibly so
24670 rewind to allow that check. */
24673 }
24675 /* Parse an Objective-C method prototype list. */
24677 static void
24679 {
24683 {
24685 {
24690 else
24694 {
24698 }
24701 }
24707 OPT_Wattributes,
24709 else
24710 /* Allow for interspersed non-ObjC++ code. */
24714 }
24718 else
24722 }
24724 /* Parse an Objective-C method definition list. */
24726 static void
24728 {
24732 {
24733 tree meth;
24736 {
24742 else
24747 {
24751 }
24753 NULL_TREE);
24755 /* For historical reasons, we accept an optional semicolon. */
24762 {
24769 }
24770 }
24771 /* The following case will be removed once @synthesize is
24772 completely implemented. */
24783 else
24784 /* Allow for interspersed non-ObjC++ code. */
24788 }
24792 else
24796 }
24798 /* Parse Objective-C ivars. */
24800 static void
24802 {
24813 {
24814 cp_decl_specifier_seq declspecs;
24816 tree prefix_attributes;
24824 CP_PARSER_FLAGS_OPTIONAL,
24828 /* auto, register, static, extern, mutable. */
24830 {
24833 }
24835 /* thread_local. */
24837 {
24840 }
24842 /* typedef. */
24844 {
24847 }
24852 /* Keep going until we hit the `;' at the end of the
24853 declaration. */
24855 {
24860 /* Check for a (possibly unnamed) bitfield declaration. */
24868 {
24869 /* Get the name of the bitfield. */
24872 sfk_none);
24874 eat_colon:
24876 /* Get the width of the bitfield. */
24877 width
24880 NULL);
24881 }
24882 else
24883 {
24884 /* Parse the declarator. */
24885 declarator
24890 }
24892 /* Look for attributes that apply to the ivar. */
24894 /* Remember which attributes are prefix attributes and
24895 which are not. */
24897 /* Combine the attributes. */
24901 /* Create the bitfield declaration. */
24903 width,
24904 attributes);
24905 else
24910 /* Add the instance variable. */
24914 /* Reset PREFIX_ATTRIBUTES. */
24923 {
24926 }
24928 }
24932 }
24937 /* Do not consume the RID_AT_END, so it will be read again as terminating
24938 the @interface of @implementation. */
24942 /* For historical reasons, we accept an optional semicolon. */
24945 }
24947 /* Parse an Objective-C protocol declaration. */
24949 static void
24951 {
24957 {
24962 }
24964 /* See if we have a forward declaration or a definition. */
24967 /* Try a forward declaration first. */
24969 {
24971 {
24972 tree id;
24982 else
24984 }
24986 }
24988 /* Ok, we got a full-fledged definition (or at least should). */
24989 else
24990 {
24995 }
24996 }
24998 /* Parse an Objective-C superclass or category. */
25000 static void
25005 {
25011 {
25014 }
25016 {
25019 /* If there is no category name, and this is an @interface, we
25020 have a class extension. */
25022 {
25025 }
25026 else
25030 }
25031 }
25033 /* Parse an Objective-C class interface. */
25035 static void
25037 {
25044 {
25045 /* It's hard to recover because even if valid @interface stuff
25046 is to follow, we can't compile it (or validate it) if we
25047 don't even know which class it refers to. Let's assume this
25048 was a stray '@interface' token in the stream and skip it.
25049 */
25051 }
25056 /* We have either a class or a category on our hands. */
25059 else
25060 {
25062 /* Handle instance variable declarations, if any. */
25065 }
25068 }
25070 /* Parse an Objective-C class implementation. */
25072 static void
25074 {
25081 {
25082 /* It's hard to recover because even if valid @implementation
25083 stuff is to follow, we can't compile it (or validate it) if
25084 we don't even know which class it refers to. Let's assume
25085 this was a stray '@implementation' token in the stream and
25086 skip it.
25087 */
25089 }
25093 /* We have either a class or a category on our hands. */
25096 else
25097 {
25099 /* Handle instance variable declarations, if any. */
25102 }
25105 }
25107 /* Consume the @end token and finish off the implementation. */
25109 static void
25111 {
25114 }
25116 /* Parse an Objective-C declaration. */
25118 static void
25120 {
25121 /* Try to figure out what kind of declaration is present. */
25126 {
25142 }
25145 {
25168 }
25169 }
25171 /* Parse an Objective-C try-catch-finally statement.
25173 objc-try-catch-finally-stmt:
25174 @try compound-statement objc-catch-clause-seq [opt]
25175 objc-finally-clause [opt]
25177 objc-catch-clause-seq:
25178 objc-catch-clause objc-catch-clause-seq [opt]
25180 objc-catch-clause:
25181 @catch ( objc-exception-declaration ) compound-statement
25183 objc-finally-clause:
25184 @finally compound-statement
25186 objc-exception-declaration:
25187 parameter-declaration
25188 '...'
25190 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
25192 Returns NULL_TREE.
25194 PS: This function is identical to c_parser_objc_try_catch_finally_statement
25195 for C. Keep them in sync. */
25197 static tree
25199 {
25200 location_t location;
25201 tree stmt;
25206 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
25207 node, lest it get absorbed into the surrounding block. */
25213 {
25222 {
25223 /* We have "@catch (...)" (where the '...' are literally
25224 what is in the code). Skip the '...'.
25225 parameter_declaration is set to NULL_TREE, and
25226 objc_being_catch_clauses() knows that that means
25227 '...'. */
25230 }
25231 else
25232 {
25233 /* We have "@catch (NSException *exception)" or something
25234 like that. Parse the parameter declaration. */
25238 else
25243 }
25246 else
25247 {
25248 /* If there was no open parenthesis, we are recovering from
25249 an error, and we are trying to figure out what mistake
25250 the user has made. */
25252 /* If there is an immediate closing parenthesis, the user
25253 probably forgot the opening one (ie, they typed "@catch
25254 NSException *e)". Parse the closing parenthesis and keep
25255 going. */
25259 /* If these is no immediate closing parenthesis, the user
25260 probably doesn't know that parenthesis are required at
25261 all (ie, they typed "@catch NSException *e"). So, just
25262 forget about the closing parenthesis and keep going. */
25263 }
25267 }
25269 {
25272 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
25273 node, lest it get absorbed into the surrounding block. */
25277 }
25280 }
25282 /* Parse an Objective-C synchronized statement.
25284 objc-synchronized-stmt:
25285 @synchronized ( expression ) compound-statement
25287 Returns NULL_TREE. */
25289 static tree
25291 {
25292 location_t location;
25303 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
25304 node, lest it get absorbed into the surrounding block. */
25309 }
25311 /* Parse an Objective-C throw statement.
25313 objc-throw-stmt:
25314 @throw assignment-expression [opt] ;
25316 Returns a constructed '@throw' statement. */
25318 static tree
25320 {
25332 }
25334 /* Parse an Objective-C statement. */
25336 static tree
25338 {
25339 /* Try to figure out what kind of declaration is present. */
25343 {
25354 }
25357 }
25359 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
25360 look ahead to see if an objc keyword follows the attributes. This
25361 is to detect the use of prefix attributes on ObjC @interface and
25362 @protocol. */
25364 static bool
25366 {
25371 {
25374 }
25377 }
25379 /* This routine is a minimal replacement for
25380 c_parser_struct_declaration () used when parsing the list of
25381 types/names or ObjC++ properties. For example, when parsing the
25382 code
25384 @property (readonly) int a, b, c;
25386 this function is responsible for parsing "int a, int b, int c" and
25387 returning the declarations as CHAIN of DECLs.
25389 TODO: Share this code with cp_parser_objc_class_ivars. It's very
25390 similar parsing. */
25391 static tree
25393 {
25395 cp_decl_specifier_seq declspecs;
25397 tree prefix_attributes;
25400 CP_PARSER_FLAGS_NONE,
25407 /* auto, register, static, extern, mutable. */
25409 {
25412 }
25414 /* thread_local. */
25416 {
25419 }
25421 /* typedef. */
25423 {
25426 }
25431 /* Keep going until we hit the `;' at the end of the declaration. */
25433 {
25438 /* Parse the declarator. */
25442 /* Look for attributes that apply to the ivar. */
25444 /* Remember which attributes are prefix attributes and
25445 which are not. */
25447 /* Combine the attributes. */
25457 /* Reset PREFIX_ATTRIBUTES. */
25468 {
25471 }
25472 else
25474 }
25476 }
25478 /* Parse an Objective-C @property declaration. The syntax is:
25480 objc-property-declaration:
25481 '@property' objc-property-attributes[opt] struct-declaration ;
25483 objc-property-attributes:
25484 '(' objc-property-attribute-list ')'
25486 objc-property-attribute-list:
25487 objc-property-attribute
25488 objc-property-attribute-list, objc-property-attribute
25490 objc-property-attribute
25491 'getter' = identifier
25492 'setter' = identifier
25493 'readonly'
25494 'readwrite'
25495 'assign'
25496 'retain'
25497 'copy'
25498 'nonatomic'
25500 For example:
25501 @property NSString *name;
25502 @property (readonly) id object;
25503 @property (retain, nonatomic, getter=getTheName) id name;
25504 @property int a, b, c;
25506 PS: This function is identical to
25507 c_parser_objc_at_property_declaration for C. Keep them in sync. */
25508 static void
25510 {
25511 /* The following variables hold the attributes of the properties as
25512 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
25513 seen. When we see an attribute, we set them to 'true' (if they
25514 are boolean properties) or to the identifier (if they have an
25515 argument, ie, for getter and setter). Note that here we only
25516 parse the list of attributes, check the syntax and accumulate the
25517 attributes that we find. objc_add_property_declaration() will
25518 then process the information. */
25528 /* 'properties' is the list of properties that we read. Usually a
25529 single one, but maybe more (eg, in "@property int a, b, c;" there
25530 are three). */
25531 tree properties;
25532 location_t loc;
25538 /* Parse the optional attribute list... */
25540 {
25541 /* Eat the '('. */
25545 {
25551 {
25554 }
25558 {
25569 {
25573 else
25578 }
25581 {
25585 }
25587 {
25589 {
25592 }
25593 else
25597 else
25599 }
25600 else
25601 {
25603 {
25606 }
25607 else
25609 }
25615 }
25622 else
25624 }
25626 /* FIXME: "@property (setter, assign);" will generate a spurious
25627 "error: expected ‘)’ before ‘,’ token". This is because
25628 cp_parser_require, unlike the C counterpart, will produce an
25629 error even if we are in error recovery. */
25631 {
25636 }
25637 }
25639 /* ... and the property declaration(s). */
25643 {
25645 /* If the next token is now a `;', consume it. */
25649 }
25653 else
25654 {
25655 /* Comma-separated properties are chained together in
25656 reverse order; add them one by one. */
25665 }
25668 }
25670 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
25672 objc-synthesize-declaration:
25673 @synthesize objc-synthesize-identifier-list ;
25675 objc-synthesize-identifier-list:
25676 objc-synthesize-identifier
25677 objc-synthesize-identifier-list, objc-synthesize-identifier
25679 objc-synthesize-identifier
25680 identifier
25681 identifier = identifier
25683 For example:
25684 @synthesize MyProperty;
25685 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
25687 PS: This function is identical to c_parser_objc_at_synthesize_declaration
25688 for C. Keep them in sync.
25689 */
25690 static void
25692 {
25694 location_t loc;
25699 {
25703 {
25706 }
25708 {
25712 {
25715 }
25716 }
25717 else
25722 else
25724 }
25727 }
25729 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
25731 objc-dynamic-declaration:
25732 @dynamic identifier-list ;
25734 For example:
25735 @dynamic MyProperty;
25736 @dynamic MyProperty, AnotherProperty;
25738 PS: This function is identical to c_parser_objc_at_dynamic_declaration
25739 for C. Keep them in sync.
25740 */
25741 static void
25743 {
25745 location_t loc;
25750 {
25751 tree property;
25754 {
25757 }
25761 else
25763 }
25766 }
25768 \f
25769 /* OpenMP 2.5 parsing routines. */
25771 /* Returns name of the next clause.
25772 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
25773 the token is not consumed. Otherwise appropriate pragma_omp_clause is
25774 returned and the token is consumed. */
25776 static pragma_omp_clause
25778 {
25788 {
25793 {
25840 }
25841 }
25847 }
25849 /* Validate that a clause of the given type does not already exist. */
25851 static void
25854 {
25855 tree c;
25859 {
25862 }
25863 }
25865 /* OpenMP 2.5:
25866 variable-list:
25867 identifier
25868 variable-list , identifier
25870 In addition, we match a closing parenthesis. An opening parenthesis
25871 will have been consumed by the caller.
25873 If KIND is nonzero, create the appropriate node and install the decl
25874 in OMP_CLAUSE_DECL and add the node to the head of the list.
25876 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
25877 return the list created. */
25879 static tree
25881 tree list)
25882 {
25885 {
25902 {
25907 }
25908 else
25911 get_comma:
25915 }
25918 {
25921 /* Try to resync to an unnested comma. Copied from
25922 cp_parser_parenthesized_expression_list. */
25923 skip_comma:
25930 }
25933 }
25935 /* Similarly, but expect leading and trailing parenthesis. This is a very
25936 common case for omp clauses. */
25938 static tree
25940 {
25944 }
25946 /* OpenMP 3.0:
25947 collapse ( constant-expression ) */
25949 static tree
25951 {
25953 location_t loc;
25954 HOST_WIDE_INT n;
25974 {
25977 }
25985 }
25987 /* OpenMP 2.5:
25988 default ( shared | none ) */
25990 static tree
25992 {
25994 tree c;
25999 {
26004 {
26019 }
26022 }
26023 else
26024 {
26025 invalid_kind:
26027 }
26043 }
26045 /* OpenMP 3.1:
26046 final ( expression ) */
26048 static tree
26050 {
26071 }
26073 /* OpenMP 2.5:
26074 if ( expression ) */
26076 static tree
26078 {
26099 }
26101 /* OpenMP 3.1:
26102 mergeable */
26104 static tree
26107 {
26108 tree c;
26111 location);
26116 }
26118 /* OpenMP 2.5:
26119 nowait */
26121 static tree
26124 {
26125 tree c;
26132 }
26134 /* OpenMP 2.5:
26135 num_threads ( expression ) */
26137 static tree
26139 location_t location)
26140 {
26162 }
26164 /* OpenMP 2.5:
26165 ordered */
26167 static tree
26170 {
26171 tree c;
26179 }
26181 /* OpenMP 2.5:
26182 reduction ( reduction-operator : variable-list )
26184 reduction-operator:
26185 One of: + * - & ^ | && ||
26187 OpenMP 3.1:
26189 reduction-operator:
26190 One of: + * - & ^ | && || min max */
26192 static tree
26194 {
26202 {
26228 {
26233 {
26236 }
26238 {
26241 }
26242 }
26243 /* FALLTHROUGH */
26247 resync_fail:
26252 }
26263 }
26265 /* OpenMP 2.5:
26266 schedule ( schedule-kind )
26267 schedule ( schedule-kind , expression )
26269 schedule-kind:
26270 static | dynamic | guided | runtime | auto */
26272 static tree
26274 {
26283 {
26288 {
26309 }
26310 }
26315 else
26320 {
26335 else
26340 }
26348 invalid_kind:
26350 resync_fail:
26355 }
26357 /* OpenMP 3.0:
26358 untied */
26360 static tree
26363 {
26364 tree c;
26371 }
26373 /* Parse all OpenMP clauses. The set clauses allowed by the directive
26374 is a bitmask in MASK. Return the list of clauses found; the result
26375 of clause default goes in *pdefault. */
26377 static tree
26380 {
26386 {
26387 pragma_omp_clause c_kind;
26399 {
26411 clauses);
26425 clauses);
26434 clauses);
26458 clauses);
26472 clauses);
26483 }
26486 {
26487 /* Remove the invalid clause(s) from the list to avoid
26488 confusing the rest of the compiler. */
26491 }
26492 }
26493 saw_error:
26496 }
26498 /* OpenMP 2.5:
26499 structured-block:
26500 statement
26502 In practice, we're also interested in adding the statement to an
26503 outer node. So it is convenient if we work around the fact that
26504 cp_parser_statement calls add_stmt. */
26506 static unsigned
26508 {
26511 /* Only move the values to IN_OMP_BLOCK if they weren't false.
26512 This preserves the "not within loop or switch" style error messages
26513 for nonsense cases like
26514 void foo() {
26515 #pragma omp single
26516 break;
26517 }
26518 */
26523 }
26525 static void
26527 {
26529 }
26531 static tree
26533 {
26541 }
26543 /* OpenMP 2.5:
26544 # pragma omp atomic new-line
26545 expression-stmt
26547 expression-stmt:
26548 x binop= expr | x++ | ++x | x-- | --x
26549 binop:
26550 +, *, -, /, &, ^, |, <<, >>
26552 where x is an lvalue expression with scalar type.
26554 OpenMP 3.1:
26555 # pragma omp atomic new-line
26556 update-stmt
26558 # pragma omp atomic read new-line
26559 read-stmt
26561 # pragma omp atomic write new-line
26562 write-stmt
26564 # pragma omp atomic update new-line
26565 update-stmt
26567 # pragma omp atomic capture new-line
26568 capture-stmt
26570 # pragma omp atomic capture new-line
26571 capture-block
26573 read-stmt:
26574 v = x
26575 write-stmt:
26576 x = expr
26577 update-stmt:
26578 expression-stmt | x = x binop expr
26579 capture-stmt:
26580 v = x binop= expr | v = x++ | v = ++x | v = x-- | v = --x
26581 capture-block:
26582 { v = x; update-stmt; } | { update-stmt; v = x; }
26584 where x and v are lvalue expressions with scalar type. */
26586 static void
26588 {
26595 {
26607 else
26611 }
26615 {
26626 else
26632 {
26633 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
26634 opcode. */
26639 }
26643 {
26646 }
26647 else
26648 {
26655 }
26658 }
26660 restart:
26665 {
26672 /* FALLTHROUGH */
26682 /* FALLTHROUGH */
26697 /* Undo effects of boolean_increment for post {in,de}crement. */
26699 /* FALLTHRU */
26703 {
26704 /* Undo effects of boolean_increment. */
26706 {
26707 /* This is pre or post increment. */
26712 && !structured_block
26716 }
26717 }
26718 /* FALLTHRU */
26721 {
26751 {
26761 {
26764 {
26772 }
26807 }
26818 }
26819 /* FALLTHROUGH */
26824 }
26831 }
26832 stmt_done:
26834 {
26847 }
26849 {
26852 }
26853 done:
26859 saw_error:
26862 {
26866 {
26870 }
26871 }
26872 }
26875 /* OpenMP 2.5:
26876 # pragma omp barrier new-line */
26878 static void
26880 {
26883 }
26885 /* OpenMP 2.5:
26886 # pragma omp critical [(name)] new-line
26887 structured-block */
26889 static tree
26891 {
26895 {
26907 }
26912 }
26914 /* OpenMP 2.5:
26915 # pragma omp flush flush-vars[opt] new-line
26917 flush-vars:
26918 ( variable-list ) */
26920 static void
26922 {
26928 }
26930 /* Helper function, to parse omp for increment expression. */
26932 static tree
26934 {
26939 {
26942 }
26945 {
26953 }
26955 /* If decl is an iterator, preserve LHS and RHS of the relational
26956 expr until finish_omp_for. */
26966 }
26968 /* Helper function, to parse omp for increment expression. */
26970 static tree
26972 {
26976 cp_id_kind idk;
26980 {
26988 }
26996 {
27001 }
27008 {
27012 }
27024 do
27025 {
27032 {
27034 {
27037 else
27039 tf_warning_or_error);
27040 }
27041 else
27044 }
27045 }
27049 {
27053 }
27054 else
27058 }
27060 /* Parse the restricted form of the for statement allowed by OpenMP. */
27062 static tree
27064 {
27068 location_t loc_first;
27087 {
27090 location_t loc;
27093 {
27096 }
27105 {
27106 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
27108 init-expr:
27109 var = lb
27110 integer-type var = lb
27111 random-access-iterator-type var = lb
27112 pointer-type var = lb
27113 */
27114 cp_decl_specifier_seq type_specifiers;
27116 /* First, try to parse as an initialized declaration. See
27117 cp_parser_condition, from whence the bulk of this is copied. */
27124 {
27125 /* If parsing a type specifier seq succeeded, then this
27126 MUST be a initialized declaration. */
27131 CP_PARSER_DECLARATOR_NAMED,
27141 else
27142 {
27152 {
27154 CPP_OPEN_PAREN))
27157 else
27158 /* Trigger an error. */
27163 }
27167 {
27175 {
27178 auto_node);
27183 }
27186 asm_specification,
27187 LOOKUP_ONLYCONVERTING);
27189 {
27192 }
27193 else
27196 }
27197 else
27198 {
27199 /* Consume '='. */
27203 non_class:
27206 else
27209 asm_specification,
27210 LOOKUP_ONLYCONVERTING);
27211 }
27215 }
27216 }
27217 else
27218 {
27219 cp_id_kind idk;
27220 /* If parsing a type specifier sequence failed, then
27221 this MUST be a simple expression. */
27226 && decl
27229 {
27230 tree rhs;
27237 rhs,
27238 tf_warning_or_error));
27240 }
27241 else
27242 {
27247 {
27251 }
27252 }
27253 }
27254 }
27257 {
27260 {
27266 }
27267 else
27269 }
27274 {
27279 {
27283 }
27286 {
27287 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
27288 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
27297 }
27298 else
27299 {
27304 }
27305 }
27308 {
27309 tree c;
27311 {
27320 decl);
27324 decl);
27325 }
27327 {
27332 {
27335 }
27336 }
27337 }
27346 {
27347 /* If decl is an iterator, preserve the operator on decl
27348 until finish_omp_for. */
27350 && ((processing_template_decl
27354 else
27358 }
27373 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
27374 in between the collapsed for loops to be still considered perfectly
27375 nested. Hopefully the final version clarifies this.
27376 For now handle (multiple) {'s and empty statements. */
27378 do
27379 {
27383 {
27385 bracecount++;
27386 }
27390 else
27391 {
27398 }
27399 }
27403 {
27406 }
27407 }
27409 /* Note that we saved the original contents of this flag when we entered
27410 the structured block, and so we don't need to re-save it here. */
27413 /* Note that the grammar doesn't call for a structured block here,
27414 though the loop as a whole is a structured block. */
27421 else
27426 {
27428 {
27430 nbraces--;
27431 }
27434 else
27435 {
27437 {
27440 }
27445 }
27446 }
27453 }
27455 /* OpenMP 2.5:
27456 #pragma omp for for-clause[optseq] new-line
27457 for-loop */
27459 #define OMP_FOR_CLAUSE_MASK \
27460 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
27461 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
27462 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
27463 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
27464 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
27465 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
27466 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT) \
27467 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE))
27469 static tree
27471 {
27487 }
27489 /* OpenMP 2.5:
27490 # pragma omp master new-line
27491 structured-block */
27493 static tree
27495 {
27499 }
27501 /* OpenMP 2.5:
27502 # pragma omp ordered new-line
27503 structured-block */
27505 static tree
27507 {
27511 }
27513 /* OpenMP 2.5:
27515 section-scope:
27516 { section-sequence }
27518 section-sequence:
27519 section-directive[opt] structured-block
27520 section-sequence section-directive structured-block */
27522 static tree
27524 {
27535 {
27542 {
27552 }
27558 }
27561 {
27569 {
27573 }
27575 {
27578 }
27583 }
27594 }
27596 /* OpenMP 2.5:
27597 # pragma omp sections sections-clause[optseq] newline
27598 sections-scope */
27600 #define OMP_SECTIONS_CLAUSE_MASK \
27601 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
27602 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
27603 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
27604 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
27605 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
27607 static tree
27609 {
27620 }
27622 /* OpenMP 2.5:
27623 # pragma parallel parallel-clause new-line
27624 # pragma parallel for parallel-for-clause new-line
27625 # pragma parallel sections parallel-sections-clause new-line */
27627 #define OMP_PARALLEL_CLAUSE_MASK \
27628 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
27629 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
27630 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
27631 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
27632 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
27633 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
27634 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
27635 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
27637 static tree
27639 {
27648 {
27654 }
27656 {
27660 {
27666 }
27667 }
27674 {
27694 }
27701 }
27703 /* OpenMP 2.5:
27704 # pragma omp single single-clause[optseq] new-line
27705 structured-block */
27707 #define OMP_SINGLE_CLAUSE_MASK \
27708 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
27709 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
27710 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
27711 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
27713 static tree
27715 {
27725 }
27727 /* OpenMP 3.0:
27728 # pragma omp task task-clause[optseq] new-line
27729 structured-block */
27731 #define OMP_TASK_CLAUSE_MASK \
27732 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
27733 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
27734 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
27735 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
27736 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
27737 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
27738 | (1u << PRAGMA_OMP_CLAUSE_FINAL) \
27739 | (1u << PRAGMA_OMP_CLAUSE_MERGEABLE))
27741 static tree
27743 {
27754 }
27756 /* OpenMP 3.0:
27757 # pragma omp taskwait new-line */
27759 static void
27761 {
27764 }
27766 /* OpenMP 3.1:
27767 # pragma omp taskyield new-line */
27769 static void
27771 {
27774 }
27776 /* OpenMP 2.5:
27777 # pragma omp threadprivate (variable-list) */
27779 static void
27781 {
27782 tree vars;
27788 }
27790 /* Main entry point to OpenMP statement pragmas. */
27792 static void
27794 {
27795 tree stmt;
27798 {
27828 }
27832 }
27833 \f
27834 /* Transactional Memory parsing routines. */
27836 /* Parse a transaction attribute.
27838 txn-attribute:
27839 attribute
27840 [ [ identifier ] ]
27842 ??? Simplify this when C++0x bracket attributes are
27843 implemented properly. */
27845 static tree
27847 {
27862 {
27866 /* For keywords, use the canonical spelling,
27867 not the parsed identifier. */
27871 }
27872 else
27876 error1:
27879 }
27881 /* Parse a __transaction_atomic or __transaction_relaxed statement.
27883 transaction-statement:
27884 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
27885 compound-statement
27886 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
27887 */
27889 static tree
27891 {
27906 else
27907 {
27911 }
27913 /* Parse a noexcept specification. */
27916 /* Keep track if we're in the lexical scope of an outer transaction. */
27928 }
27930 /* Parse a __transaction_atomic or __transaction_relaxed expression.
27932 transaction-expression:
27933 __transaction_atomic txn-noexcept-spec[opt] ( expression )
27934 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
27935 */
27937 static tree
27939 {
27964 /* Set this early. This might mean that we allow transaction_cancel in
27965 an expression that we find out later actually has to be a constexpr.
27966 However, we expect that cxx_constant_value will be able to deal with
27967 this; also, if the noexcept has no constexpr, then what we parse next
27968 really is a transaction's body. */
27971 /* Parse a noexcept specification. */
27977 {
27984 }
27985 else
27986 {
27987 /* The only expression that is available got parsed for the noexcept
27988 already. noexcept is true then. */
27991 }
28000 }
28002 /* Parse a function-transaction-block.
28004 function-transaction-block:
28005 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
28006 function-body
28007 __transaction_atomic txn-attribute[opt] function-try-block
28008 __transaction_relaxed ctor-initializer[opt] function-body
28009 __transaction_relaxed function-try-block
28010 */
28012 static bool
28014 {
28030 else
28031 {
28035 }
28043 else
28044 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
28052 }
28054 /* Parse a __transaction_cancel statement.
28056 cancel-statement:
28057 __transaction_cancel txn-attribute[opt] ;
28058 __transaction_cancel txn-attribute[opt] throw-expression ;
28060 ??? Cancel and throw is not yet implemented. */
28062 static tree
28064 {
28070 RT_TRANSACTION_CANCEL);
28077 /* ??? Parse cancel-and-throw here. */
28082 {
28086 }
28088 {
28092 }
28094 {
28097 {
28103 }
28104 }
28106 {
28110 }
28117 }
28118 \f
28119 /* The parser. */
28123 \f
28124 /* Special handling for the first token or line in the file. The first
28125 thing in the file might be #pragma GCC pch_preprocess, which loads a
28126 PCH file, which is a GC collection point. So we need to handle this
28127 first pragma without benefit of an existing lexer structure.
28129 Always returns one token to the caller in *FIRST_TOKEN. This is
28130 either the true first token of the file, or the first token after
28131 the initial pragma. */
28133 static void
28135 {
28144 {
28151 }
28152 else
28155 /* Skip to the end of the pragma. */
28159 /* Now actually load the PCH file. */
28163 /* Read one more token to return to our caller. We have to do this
28164 after reading the PCH file in, since its pointers have to be
28165 live. */
28167 }
28169 /* Normal parsing of a pragma token. Here we can (and must) use the
28170 regular lexer. */
28172 static bool
28174 {
28184 {
28192 {
28202 }
28207 {
28217 }
28222 {
28228 "%<#pragma omp taskwait%> may only be "
28233 }
28238 {
28244 "%<#pragma omp taskyield%> may only be "
28249 }
28272 "%<#pragma omp section%> may only be used in "
28281 bad_stmt:
28284 }
28288 }
28290 /* The interface the pragma parsers have to the lexer. */
28292 enum cpp_ttype
28294 {
28307 else
28308 {
28312 }
28315 }
28317 \f
28318 /* External interface. */
28320 /* Parse one entire translation unit. */
28322 void
28324 {
28328 {
28331 }
28339 }