| blob | 224fea184bde14758f6099101bc942831096755c |
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 static void cp_parser_cilk_simd_construct
236 static tree cp_parser_cilk_for
239 /* Manifest constants. */
240 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
241 #define CP_SAVED_TOKEN_STACK 5
243 /* Variables. */
245 /* The stream to which debugging output should be written. */
248 /* Nonzero if we are parsing an unevaluated operand: an operand to
249 sizeof, typeof, or alignof. */
252 /* Dump up to NUM tokens in BUFFER to FILE starting with token
253 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
254 first token in BUFFER. If NUM is 0, dump all the tokens. If
255 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
256 highlighted by surrounding it in [[ ]]. */
258 static void
262 {
279 {
282 }
287 {
294 nprinted++;
304 {
314 }
315 }
318 {
321 }
324 }
327 /* Dump all tokens in BUFFER to stderr. */
329 void
331 {
333 }
335 DEBUG_FUNCTION void
337 {
339 }
341 DEBUG_FUNCTION void
343 {
346 else
348 }
351 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
352 description for T. */
354 static void
356 {
358 {
361 }
362 }
365 /* Dump parser context C to FILE. */
367 static void
369 {
374 }
377 /* Print the stack of parsing contexts to FILE starting with FIRST. */
379 static void
381 {
387 {
390 }
391 }
394 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
396 static void
398 {
401 }
404 /* Print an unparsed function entry UF to FILE. */
406 static void
408 {
411 tree fn;
416 i++)
417 {
423 }
428 {
431 }
437 {
440 }
442 }
445 /* Print the stack of unparsed member functions S to FILE. */
447 static void
450 {
456 {
459 }
460 }
463 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
464 the given PARSER. If FILE is NULL, the output is printed on stderr. */
466 static void
468 {
480 next_token);
481 }
484 /* Dump debugging information for the given PARSER. If FILE is NULL,
485 the output is printed on stderr. */
487 void
489 {
492 expanded_location eloc;
566 }
568 DEBUG_FUNCTION void
570 {
572 }
574 DEBUG_FUNCTION void
576 {
579 else
581 }
583 /* Allocate memory for a new lexer object and return it. */
587 {
592 /* Allocate the memory. */
595 /* Initially we are not debugging. */
600 /* Create the buffer. */
604 }
607 /* Create a new main C++ lexer, the lexer that gets tokens from the
608 preprocessor. */
612 {
614 cp_token token;
616 /* It's possible that parsing the first pragma will load a PCH file,
617 which is a GC collection point. So we have to do that before
618 allocating any memory. */
623 /* Put the first token in the buffer. */
626 /* Get the remaining tokens from the preprocessor. */
628 {
631 }
640 /* Subsequent preprocessor diagnostics should use compiler
641 diagnostic functions to get the compiler source location. */
646 }
648 /* Create a new lexer whose token stream is primed with the tokens in
649 CACHE. When these tokens are exhausted, no new tokens will be read. */
653 {
658 /* We do not own the buffer. */
665 /* Initially we are not debugging. */
670 }
672 /* Frees all resources associated with LEXER. */
674 static void
676 {
680 }
682 /* Returns nonzero if debugging information should be output. */
686 {
688 }
693 {
697 }
701 {
703 }
707 {
709 }
713 {
716 else
718 }
722 {
726 }
728 /* nonzero if we are presently saving tokens. */
732 {
734 }
736 /* Store the next token from the preprocessor in *TOKEN. Return true
737 if we reach EOF. If LEXER is NULL, assume we are handling an
738 initial #pragma pch_preprocess, and thus want the lexer to return
739 processed strings. */
741 static void
743 {
746 /* Get a new token from the preprocessor. */
747 token->type
754 /* On some systems, some header files are surrounded by an
755 implicit extern "C" block. Set a flag in the token if it
756 comes from such a header. */
761 /* Check to see if this token is a keyword. */
763 {
765 {
766 /* Mark this token as a keyword. */
768 /* Record which keyword. */
770 }
771 else
772 {
776 {
777 /* Warn about the C++0x keyword (but still treat it as
778 an identifier). */
783 /* Clear out the C_RID_CODE so we don't warn about this
784 particular identifier-turned-keyword again. */
786 }
790 }
791 }
793 {
794 /* This only happens in Objective-C++; it must be a keyword. */
797 {
798 /* Replace 'class' with '@class', 'private' with '@private',
799 etc. This prevents confusion with the C++ keyword
800 'class', and makes the tokens consistent with other
801 Objective-C 'AT' keywords. For example '@class' is
802 reported as RID_AT_CLASS which is consistent with
803 '@synchronized', which is reported as
804 RID_AT_SYNCHRONIZED.
805 */
814 }
815 }
817 {
818 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
822 }
823 }
825 /* Update the globals input_location and the input file stack from TOKEN. */
828 {
830 {
832 }
833 }
835 /* Return a pointer to the next token in the token stream, but do not
836 consume it. */
840 {
842 {
846 }
848 }
850 /* Return true if the next token has the indicated TYPE. */
854 {
856 }
858 /* Return true if the next token does not have the indicated TYPE. */
862 {
864 }
866 /* Return true if the next token is the indicated KEYWORD. */
870 {
872 }
876 {
878 }
880 /* Return true if the next token is not the indicated KEYWORD. */
884 {
886 }
888 /* Return true if the next token is a keyword for a decl-specifier. */
890 static bool
892 {
897 {
898 /* auto specifier: storage-class-specifier in C++,
899 simple-type-specifier in C++0x. */
901 /* Storage classes. */
907 /* Elaborated type specifiers. */
913 /* Simple type specifiers. */
928 /* GNU extensions. */
931 /* C++0x extensions. */
938 }
939 }
941 /* Returns TRUE iff the token T begins a decltype type. */
943 static bool
945 {
948 }
950 /* Returns TRUE iff the next token begins a decltype type. */
952 static bool
954 {
957 }
959 /* Return a pointer to the Nth token in the token stream. If N is 1,
960 then this is precisely equivalent to cp_lexer_peek_token (except
961 that it is not inline). One would like to disallow that case, but
962 there is one case (cp_parser_nth_token_starts_template_id) where
963 the caller passes a variable for N and it might be 1. */
967 {
970 /* N is 1-based, not zero-based. */
981 {
984 {
987 }
991 }
994 {
997 }
1000 }
1002 /* Return the next token, and advance the lexer's next_token pointer
1003 to point to the next non-purged token. */
1007 {
1013 do
1014 {
1017 {
1020 }
1022 }
1027 /* Provide debugging output. */
1029 {
1033 }
1036 }
1038 /* Permanently remove the next token from the token stream, and
1039 advance the next_token pointer to refer to the next non-purged
1040 token. */
1042 static void
1044 {
1053 do
1054 {
1055 tok++;
1057 {
1060 }
1061 }
1064 }
1066 /* Permanently remove all tokens after TOK, up to, but not
1067 including, the token that will be returned next by
1068 cp_lexer_peek_token. */
1070 static void
1072 {
1081 {
1086 }
1087 }
1089 /* Begin saving tokens. All tokens consumed after this point will be
1090 preserved. */
1092 static void
1094 {
1095 /* Provide debugging output. */
1100 }
1102 /* Commit to the portion of the token stream most recently saved. */
1104 static void
1106 {
1107 /* Provide debugging output. */
1112 }
1114 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1115 to the token stream. Stop saving tokens. */
1117 static void
1119 {
1120 /* Provide debugging output. */
1125 }
1127 /* Print a representation of the TOKEN on the STREAM. */
1129 static void
1131 {
1132 /* We don't use cpp_type2name here because the parser defines
1133 a few tokens of its own. */
1135 /* cpplib-defined token types */
1136 #define OP(e, s) #e,
1137 #define TK(e, s) #e,
1138 TTYPE_TABLE
1139 #undef OP
1140 #undef TK
1141 /* C++ parser token types - see "Manifest constants", above. */
1145 };
1147 /* For some tokens, print the associated data. */
1149 {
1151 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1152 For example, `struct' is mapped to an INTEGER_CST. */
1155 /* else fall through */
1173 /* If we have a name for the token, print it out. Otherwise, we
1174 simply give the numeric code. */
1177 else
1180 }
1181 }
1183 DEBUG_FUNCTION void
1185 {
1188 }
1190 DEBUG_FUNCTION void
1192 {
1195 else
1197 }
1200 /* Start emitting debugging information. */
1202 static void
1204 {
1207 }
1209 /* Stop emitting debugging information. */
1211 static void
1213 {
1216 }
1218 /* Create a new cp_token_cache, representing a range of tokens. */
1222 {
1227 }
1229 \f
1230 /* Decl-specifiers. */
1232 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1234 static void
1236 {
1238 }
1240 /* Declarators. */
1242 /* Nothing other than the parser should be creating declarators;
1243 declarators are a semi-syntactic representation of C++ entities.
1244 Other parts of the front end that need to create entities (like
1245 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1260 /* An erroneous declarator. */
1263 /* The obstack on which declarators and related data structures are
1264 allocated. */
1267 /* Alloc BYTES from the declarator memory pool. */
1271 {
1273 }
1275 /* Allocate a declarator of the indicated KIND. Clear fields that are
1276 common to all declarators. */
1280 {
1292 }
1294 /* Make a declarator for a generalized identifier. If
1295 QUALIFYING_SCOPE is non-NULL, the identifier is
1296 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1297 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1298 is, if any. */
1302 special_function_kind sfk)
1303 {
1306 /* It is valid to write:
1308 class C { void f(); };
1309 typedef C D;
1310 void D::f();
1312 The standard is not clear about whether `typedef const C D' is
1313 legal; as of 2002-09-15 the committee is considering that
1314 question. EDG 3.0 allows that syntax. Therefore, we do as
1315 well. */
1329 }
1331 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1332 of modifiers such as const or volatile to apply to the pointer
1333 type, represented as identifiers. ATTRIBUTES represent the attributes that
1334 appertain to the pointer or reference. */
1336 cp_declarator *
1338 tree attributes)
1339 {
1347 {
1351 }
1352 else
1358 }
1360 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1361 represent the attributes that appertain to the pointer or
1362 reference. */
1364 cp_declarator *
1367 {
1375 {
1379 }
1380 else
1386 }
1388 /* Like make_pointer_declarator -- but for a pointer to a non-static
1389 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1390 appertain to the pointer or reference. */
1392 cp_declarator *
1395 tree attributes)
1396 {
1405 {
1408 }
1409 else
1415 }
1417 /* Make a declarator for the function given by TARGET, with the
1418 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1419 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1420 indicates what exceptions can be thrown. */
1422 cp_declarator *
1424 tree parms,
1425 cp_cv_quals cv_qualifiers,
1426 cp_virt_specifiers virt_specifiers,
1427 cp_ref_qualifier ref_qualifier,
1428 tree exception_specification,
1429 tree late_return_type)
1430 {
1442 {
1446 }
1447 else
1451 }
1453 /* Make a declarator for an array of BOUNDS elements, each of which is
1454 defined by ELEMENT. */
1456 cp_declarator *
1458 {
1465 {
1469 }
1470 else
1474 }
1476 /* Determine whether the declarator we've seen so far can be a
1477 parameter pack, when followed by an ellipsis. */
1478 static bool
1480 {
1481 /* Search for a declarator name, or any other declarator that goes
1482 after the point where the ellipsis could appear in a parameter
1483 pack. If we find any of these, then this declarator can not be
1484 made into a parameter pack. */
1487 {
1489 {
1501 }
1502 }
1505 }
1509 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1510 DECLARATOR and DEFAULT_ARGUMENT. */
1512 cp_parameter_declarator *
1515 tree default_argument)
1516 {
1524 else
1531 }
1533 /* Returns true iff DECLARATOR is a declaration for a function. */
1535 static bool
1537 {
1539 {
1547 }
1549 }
1551 /* The parser. */
1553 /* Overview
1554 --------
1556 A cp_parser parses the token stream as specified by the C++
1557 grammar. Its job is purely parsing, not semantic analysis. For
1558 example, the parser breaks the token stream into declarators,
1559 expressions, statements, and other similar syntactic constructs.
1560 It does not check that the types of the expressions on either side
1561 of an assignment-statement are compatible, or that a function is
1562 not declared with a parameter of type `void'.
1564 The parser invokes routines elsewhere in the compiler to perform
1565 semantic analysis and to build up the abstract syntax tree for the
1566 code processed.
1568 The parser (and the template instantiation code, which is, in a
1569 way, a close relative of parsing) are the only parts of the
1570 compiler that should be calling push_scope and pop_scope, or
1571 related functions. The parser (and template instantiation code)
1572 keeps track of what scope is presently active; everything else
1573 should simply honor that. (The code that generates static
1574 initializers may also need to set the scope, in order to check
1575 access control correctly when emitting the initializers.)
1577 Methodology
1578 -----------
1580 The parser is of the standard recursive-descent variety. Upcoming
1581 tokens in the token stream are examined in order to determine which
1582 production to use when parsing a non-terminal. Some C++ constructs
1583 require arbitrary look ahead to disambiguate. For example, it is
1584 impossible, in the general case, to tell whether a statement is an
1585 expression or declaration without scanning the entire statement.
1586 Therefore, the parser is capable of "parsing tentatively." When the
1587 parser is not sure what construct comes next, it enters this mode.
1588 Then, while we attempt to parse the construct, the parser queues up
1589 error messages, rather than issuing them immediately, and saves the
1590 tokens it consumes. If the construct is parsed successfully, the
1591 parser "commits", i.e., it issues any queued error messages and
1592 the tokens that were being preserved are permanently discarded.
1593 If, however, the construct is not parsed successfully, the parser
1594 rolls back its state completely so that it can resume parsing using
1595 a different alternative.
1597 Future Improvements
1598 -------------------
1600 The performance of the parser could probably be improved substantially.
1601 We could often eliminate the need to parse tentatively by looking ahead
1602 a little bit. In some places, this approach might not entirely eliminate
1603 the need to parse tentatively, but it might still speed up the average
1604 case. */
1606 /* Flags that are passed to some parsing functions. These values can
1607 be bitwise-ored together. */
1609 enum
1610 {
1611 /* No flags. */
1613 /* The construct is optional. If it is not present, then no error
1614 should be issued. */
1616 /* When parsing a type-specifier, treat user-defined type-names
1617 as non-type identifiers. */
1619 /* When parsing a type-specifier, do not try to parse a class-specifier
1620 or enum-specifier. */
1622 /* When parsing a decl-specifier-seq, only allow type-specifier or
1623 constexpr. */
1625 };
1627 /* This type is used for parameters and variables which hold
1628 combinations of the above flags. */
1631 /* The different kinds of declarators we want to parse. */
1634 {
1635 /* We want an abstract declarator. */
1636 CP_PARSER_DECLARATOR_ABSTRACT,
1637 /* We want a named declarator. */
1638 CP_PARSER_DECLARATOR_NAMED,
1639 /* We don't mind, but the name must be an unqualified-id. */
1640 CP_PARSER_DECLARATOR_EITHER
1643 /* The precedence values used to parse binary expressions. The minimum value
1644 of PREC must be 1, because zero is reserved to quickly discriminate
1645 binary operators from other tokens. */
1647 enum cp_parser_prec
1648 {
1649 PREC_NOT_OPERATOR,
1650 PREC_LOGICAL_OR_EXPRESSION,
1651 PREC_LOGICAL_AND_EXPRESSION,
1652 PREC_INCLUSIVE_OR_EXPRESSION,
1653 PREC_EXCLUSIVE_OR_EXPRESSION,
1654 PREC_AND_EXPRESSION,
1655 PREC_EQUALITY_EXPRESSION,
1656 PREC_RELATIONAL_EXPRESSION,
1657 PREC_SHIFT_EXPRESSION,
1658 PREC_ADDITIVE_EXPRESSION,
1659 PREC_MULTIPLICATIVE_EXPRESSION,
1660 PREC_PM_EXPRESSION,
1661 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1662 };
1664 /* A mapping from a token type to a corresponding tree node type, with a
1665 precedence value. */
1668 {
1669 /* The token type. */
1671 /* The corresponding tree code. */
1673 /* The precedence of this operator. */
1678 {
1679 /* Left hand side of the binary operation we are currently
1680 parsing. */
1681 tree lhs;
1682 /* Original tree code for left hand side, if it was a binary
1683 expression itself (used for -Wparentheses). */
1685 /* Tree code for the binary operation we are parsing. */
1687 /* Precedence of the binary operation we are parsing. */
1689 /* Location of the binary operation we are parsing. */
1690 location_t loc;
1693 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1694 entries because precedence levels on the stack are monotonically
1695 increasing. */
1699 /* Prototypes. */
1701 /* Constructors and destructors. */
1706 /* Class variables. */
1710 /* The operator-precedence table used by cp_parser_binary_expression.
1711 Transformed into an associative array (binops_by_token) by
1712 cp_parser_new. */
1745 };
1747 /* The same as binops, but initialized by cp_parser_new so that
1748 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1749 for speed. */
1752 /* Constructors and destructors. */
1754 /* Construct a new context. The context below this one on the stack
1755 is given by NEXT. */
1759 {
1762 /* Allocate the storage. */
1764 {
1765 /* Pull the first entry from the free list. */
1769 }
1770 else
1773 /* No errors have occurred yet in this context. */
1775 /* If this is not the bottommost context, copy information that we
1776 need from the previous context. */
1778 {
1779 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1780 expression, then we are parsing one in this context, too. */
1782 /* Thread the stack. */
1784 }
1787 }
1789 /* Managing the unparsed function queues. */
1791 #define unparsed_funs_with_default_args \
1792 parser->unparsed_queues->last ().funs_with_default_args
1793 #define unparsed_funs_with_definitions \
1794 parser->unparsed_queues->last ().funs_with_definitions
1795 #define unparsed_nsdmis \
1796 parser->unparsed_queues->last ().nsdmis
1798 static void
1800 {
1803 }
1805 static void
1807 {
1810 }
1812 /* Prototypes. */
1814 /* Constructors and destructors. */
1819 /* Routines to parse various constructs.
1821 Those that return `tree' will return the error_mark_node (rather
1822 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1823 Sometimes, they will return an ordinary node if error-recovery was
1824 attempted, even though a parse error occurred. So, to check
1825 whether or not a parse error occurred, you should always use
1826 cp_parser_error_occurred. If the construct is optional (indicated
1827 either by an `_opt' in the name of the function that does the
1828 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1829 the construct is not present. */
1831 /* Lexical conventions [gram.lex] */
1833 static tree cp_parser_identifier
1835 static tree cp_parser_string_literal
1837 static tree cp_parser_userdef_char_literal
1839 static tree cp_parser_userdef_string_literal
1841 static tree cp_parser_userdef_numeric_literal
1844 /* Basic concepts [gram.basic] */
1846 static bool cp_parser_translation_unit
1849 /* Expressions [gram.expr] */
1851 static tree cp_parser_primary_expression
1853 static tree cp_parser_id_expression
1855 static tree cp_parser_unqualified_id
1857 static tree cp_parser_nested_name_specifier_opt
1859 static tree cp_parser_nested_name_specifier
1861 static tree cp_parser_qualifying_entity
1863 static tree cp_parser_postfix_expression
1865 static tree cp_parser_postfix_open_square_expression
1867 static tree cp_parser_postfix_dot_deref_expression
1871 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1873 static void cp_parser_pseudo_destructor_name
1875 static tree cp_parser_unary_expression
1877 static enum tree_code cp_parser_unary_operator
1879 static tree cp_parser_new_expression
1883 static tree cp_parser_new_type_id
1891 static tree cp_parser_delete_expression
1893 static tree cp_parser_cast_expression
1895 static tree cp_parser_binary_expression
1897 static tree cp_parser_question_colon_clause
1899 static tree cp_parser_assignment_expression
1901 static enum tree_code cp_parser_assignment_operator_opt
1903 static tree cp_parser_expression
1905 static tree cp_parser_expression
1907 static tree cp_parser_constant_expression
1909 static tree cp_parser_builtin_offsetof
1911 static tree cp_parser_lambda_expression
1913 static void cp_parser_lambda_introducer
1915 static bool cp_parser_lambda_declarator_opt
1917 static void cp_parser_lambda_body
1920 /* Statements [gram.stmt.stmt] */
1922 static void cp_parser_statement
1924 static void cp_parser_label_for_labeled_statement
1926 static tree cp_parser_expression_statement
1928 static tree cp_parser_compound_statement
1930 static void cp_parser_statement_seq_opt
1932 static tree cp_parser_selection_statement
1934 static tree cp_parser_condition
1936 static tree cp_parser_iteration_statement
1938 static bool cp_parser_for_init_statement
1940 static tree cp_parser_for
1942 static tree cp_parser_c_for
1944 static tree cp_parser_range_for
1946 static void do_range_for_auto_deduction
1948 static tree cp_parser_perform_range_for_lookup
1950 static tree cp_parser_range_for_member_function
1952 static tree cp_parser_jump_statement
1954 static void cp_parser_declaration_statement
1957 static tree cp_parser_implicitly_scoped_statement
1959 static void cp_parser_already_scoped_statement
1962 /* Declarations [gram.dcl.dcl] */
1964 static void cp_parser_declaration_seq_opt
1966 static void cp_parser_declaration
1968 static void cp_parser_block_declaration
1970 static void cp_parser_simple_declaration
1972 static void cp_parser_decl_specifier_seq
1974 static tree cp_parser_storage_class_specifier_opt
1976 static tree cp_parser_function_specifier_opt
1978 static tree cp_parser_type_specifier
1981 static tree cp_parser_simple_type_specifier
1983 static tree cp_parser_type_name
1985 static tree cp_parser_nonclass_name
1987 static tree cp_parser_elaborated_type_specifier
1989 static tree cp_parser_enum_specifier
1991 static void cp_parser_enumerator_list
1993 static void cp_parser_enumerator_definition
1995 static tree cp_parser_namespace_name
1997 static void cp_parser_namespace_definition
1999 static void cp_parser_namespace_body
2001 static tree cp_parser_qualified_namespace_specifier
2003 static void cp_parser_namespace_alias_definition
2005 static bool cp_parser_using_declaration
2007 static void cp_parser_using_directive
2009 static tree cp_parser_alias_declaration
2011 static void cp_parser_asm_definition
2013 static void cp_parser_linkage_specification
2015 static void cp_parser_static_assert
2017 static tree cp_parser_decltype
2020 /* Declarators [gram.dcl.decl] */
2022 static tree cp_parser_init_declarator
2023 (cp_parser *, cp_decl_specifier_seq *, vec<deferred_access_check, va_gc> *, bool, bool, int, bool *, tree *);
2028 static enum tree_code cp_parser_ptr_operator
2030 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2032 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2034 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2036 static tree cp_parser_late_return_type_opt
2038 static tree cp_parser_declarator_id
2040 static tree cp_parser_type_id
2042 static tree cp_parser_template_type_arg
2045 static tree cp_parser_type_id_1
2047 static void cp_parser_type_specifier_seq
2049 static tree cp_parser_parameter_declaration_clause
2051 static tree cp_parser_parameter_declaration_list
2055 static tree cp_parser_default_argument
2057 static void cp_parser_function_body
2059 static tree cp_parser_initializer
2061 static tree cp_parser_initializer_clause
2063 static tree cp_parser_braced_list
2068 static bool cp_parser_ctor_initializer_opt_and_function_body
2071 /* Classes [gram.class] */
2073 static tree cp_parser_class_name
2075 static tree cp_parser_class_specifier
2077 static tree cp_parser_class_head
2079 static enum tag_types cp_parser_class_key
2081 static void cp_parser_member_specification_opt
2083 static void cp_parser_member_declaration
2085 static tree cp_parser_pure_specifier
2087 static tree cp_parser_constant_initializer
2090 /* Derived classes [gram.class.derived] */
2092 static tree cp_parser_base_clause
2094 static tree cp_parser_base_specifier
2097 /* Special member functions [gram.special] */
2099 static tree cp_parser_conversion_function_id
2101 static tree cp_parser_conversion_type_id
2105 static bool cp_parser_ctor_initializer_opt
2107 static void cp_parser_mem_initializer_list
2109 static tree cp_parser_mem_initializer
2111 static tree cp_parser_mem_initializer_id
2114 /* Overloading [gram.over] */
2116 static tree cp_parser_operator_function_id
2118 static tree cp_parser_operator
2121 /* Templates [gram.temp] */
2123 static void cp_parser_template_declaration
2125 static tree cp_parser_template_parameter_list
2127 static tree cp_parser_template_parameter
2129 static tree cp_parser_type_parameter
2131 static tree cp_parser_template_id
2133 static tree cp_parser_template_name
2135 static tree cp_parser_template_argument_list
2137 static tree cp_parser_template_argument
2139 static void cp_parser_explicit_instantiation
2141 static void cp_parser_explicit_specialization
2144 /* Exception handling [gram.exception] */
2146 static tree cp_parser_try_block
2148 static bool cp_parser_function_try_block
2150 static void cp_parser_handler_seq
2152 static void cp_parser_handler
2154 static tree cp_parser_exception_declaration
2156 static tree cp_parser_throw_expression
2158 static tree cp_parser_exception_specification_opt
2160 static tree cp_parser_type_id_list
2163 /* GNU Extensions */
2165 static tree cp_parser_asm_specification_opt
2167 static tree cp_parser_asm_operand_list
2169 static tree cp_parser_asm_clobber_list
2171 static tree cp_parser_asm_label_list
2173 static bool cp_next_tokens_can_be_attribute_p
2175 static bool cp_next_tokens_can_be_gnu_attribute_p
2177 static bool cp_next_tokens_can_be_std_attribute_p
2179 static bool cp_nth_tokens_can_be_std_attribute_p
2181 static bool cp_nth_tokens_can_be_gnu_attribute_p
2183 static bool cp_nth_tokens_can_be_attribute_p
2185 static tree cp_parser_attributes_opt
2187 static tree cp_parser_gnu_attributes_opt
2189 static tree cp_parser_gnu_attribute_list
2191 static tree cp_parser_std_attribute
2193 static tree cp_parser_std_attribute_spec
2195 static tree cp_parser_std_attribute_spec_seq
2197 static bool cp_parser_extension_opt
2199 static void cp_parser_label_declaration
2202 /* Transactional Memory Extensions */
2204 static tree cp_parser_transaction
2206 static tree cp_parser_transaction_expression
2208 static bool cp_parser_function_transaction
2210 static tree cp_parser_transaction_cancel
2214 static bool cp_parser_pragma
2217 /* Objective-C++ Productions */
2219 static tree cp_parser_objc_message_receiver
2221 static tree cp_parser_objc_message_args
2223 static tree cp_parser_objc_message_expression
2225 static tree cp_parser_objc_encode_expression
2227 static tree cp_parser_objc_defs_expression
2229 static tree cp_parser_objc_protocol_expression
2231 static tree cp_parser_objc_selector_expression
2233 static tree cp_parser_objc_expression
2235 static bool cp_parser_objc_selector_p
2237 static tree cp_parser_objc_selector
2239 static tree cp_parser_objc_protocol_refs_opt
2241 static void cp_parser_objc_declaration
2243 static tree cp_parser_objc_statement
2245 static bool cp_parser_objc_valid_prefix_attributes
2247 static void cp_parser_objc_at_property_declaration
2249 static void cp_parser_objc_at_synthesize_declaration
2251 static void cp_parser_objc_at_dynamic_declaration
2253 static tree cp_parser_objc_struct_declaration
2256 /* Utility Routines */
2258 static tree cp_parser_lookup_name
2260 static tree cp_parser_lookup_name_simple
2262 static tree cp_parser_maybe_treat_template_as_class
2264 static bool cp_parser_check_declarator_template_parameters
2266 static bool cp_parser_check_template_parameters
2268 static tree cp_parser_simple_cast_expression
2270 static tree cp_parser_global_scope_opt
2272 static bool cp_parser_constructor_declarator_p
2274 static tree cp_parser_function_definition_from_specifiers_and_declarator
2276 static tree cp_parser_function_definition_after_declarator
2278 static void cp_parser_template_declaration_after_export
2280 static void cp_parser_perform_template_parameter_access_checks
2282 static tree cp_parser_single_declaration
2284 static tree cp_parser_functional_cast
2286 static tree cp_parser_save_member_function_body
2288 static tree cp_parser_save_nsdmi
2290 static tree cp_parser_enclosed_template_argument_list
2292 static void cp_parser_save_default_args
2294 static void cp_parser_late_parsing_for_member
2296 static tree cp_parser_late_parse_one_default_arg
2298 static void cp_parser_late_parsing_nsdmi
2300 static void cp_parser_late_parsing_default_args
2302 static tree cp_parser_sizeof_operand
2304 static tree cp_parser_trait_expr
2306 static bool cp_parser_declares_only_class_p
2308 static void cp_parser_set_storage_class
2310 static void cp_parser_set_decl_spec_type
2312 static void set_and_check_decl_spec_loc
2315 static bool cp_parser_friend_p
2317 static void cp_parser_required_error
2323 static bool cp_parser_token_starts_function_definition_p
2325 static bool cp_parser_next_token_starts_class_definition_p
2327 static bool cp_parser_next_token_ends_template_argument_p
2329 static bool cp_parser_nth_token_starts_template_argument_list_p
2331 static enum tag_types cp_parser_token_is_class_key
2333 static void cp_parser_check_class_key
2335 static void cp_parser_check_access_in_redeclaration
2337 static bool cp_parser_optional_template_keyword
2339 static void cp_parser_pre_parsed_nested_name_specifier
2341 static bool cp_parser_cache_group
2343 static tree cp_parser_cache_defarg
2345 static void cp_parser_parse_tentatively
2347 static void cp_parser_commit_to_tentative_parse
2349 static void cp_parser_abort_tentative_parse
2351 static bool cp_parser_parse_definitely
2355 static bool cp_parser_uncommitted_to_tentative_parse_p
2357 static void cp_parser_error
2359 static void cp_parser_name_lookup_error
2361 static bool cp_parser_simulate_error
2363 static bool cp_parser_check_type_definition
2365 static void cp_parser_check_for_definition_in_return_type
2367 static void cp_parser_check_for_invalid_template_id
2369 static bool cp_parser_non_integral_constant_expression
2371 static void cp_parser_diagnose_invalid_type_name
2373 static bool cp_parser_parse_and_diagnose_invalid_type_name
2375 static int cp_parser_skip_to_closing_parenthesis
2377 static void cp_parser_skip_to_end_of_statement
2379 static void cp_parser_consume_semicolon_at_end_of_statement
2381 static void cp_parser_skip_to_end_of_block_or_statement
2383 static bool cp_parser_skip_to_closing_brace
2385 static void cp_parser_skip_to_end_of_template_parameter_list
2387 static void cp_parser_skip_to_pragma_eol
2389 static bool cp_parser_error_occurred
2391 static bool cp_parser_allow_gnu_extensions_p
2393 static bool cp_parser_is_pure_string_literal
2395 static bool cp_parser_is_string_literal
2397 static bool cp_parser_is_keyword
2399 static tree cp_parser_make_typename_type
2404 /* Returns nonzero if we are parsing tentatively. */
2408 {
2410 }
2412 /* Returns nonzero if TOKEN is a string literal. */
2414 static bool
2416 {
2422 }
2424 /* Returns nonzero if TOKEN is a string literal
2425 of a user-defined string literal. */
2427 static bool
2429 {
2436 }
2438 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2440 static bool
2442 {
2444 }
2446 /* If not parsing tentatively, issue a diagnostic of the form
2447 FILE:LINE: MESSAGE before TOKEN
2448 where TOKEN is the next token in the input stream. MESSAGE
2449 (specified by the caller) is usually of the form "expected
2450 OTHER-TOKEN". */
2452 static void
2454 {
2456 {
2458 /* This diagnostic makes more sense if it is tagged to the line
2459 of the token we just peeked at. */
2463 {
2468 }
2471 /* Because c_parser_error does not understand
2472 CPP_KEYWORD, keywords are treated like
2473 identifiers. */
2476 }
2477 }
2479 /* Issue an error about name-lookup failing. NAME is the
2480 IDENTIFIER_NODE DECL is the result of
2481 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2482 the thing that we hoped to find. */
2484 static void
2486 tree name,
2487 tree decl,
2488 name_lookup_error desired,
2489 location_t location)
2490 {
2491 /* If name lookup completely failed, tell the user that NAME was not
2492 declared. */
2494 {
2507 else
2509 }
2511 {
2513 {
2530 }
2531 }
2533 {
2535 {
2545 name);
2549 }
2550 }
2551 else
2552 {
2554 {
2567 }
2568 }
2569 }
2571 /* If we are parsing tentatively, remember that an error has occurred
2572 during this tentative parse. Returns true if the error was
2573 simulated; false if a message should be issued by the caller. */
2575 static bool
2577 {
2579 {
2582 }
2584 }
2586 /* This function is called when a type is defined. If type
2587 definitions are forbidden at this point, an error message is
2588 issued. */
2590 static bool
2592 {
2593 /* If types are forbidden here, issue a message. */
2595 {
2596 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2597 in the message need to be interpreted. */
2600 }
2602 }
2604 /* This function is called when the DECLARATOR is processed. The TYPE
2605 was a type defined in the decl-specifiers. If it is invalid to
2606 define a type in the decl-specifiers for DECLARATOR, an error is
2607 issued. TYPE_LOCATION is the location of TYPE and is used
2608 for error reporting. */
2610 static void
2613 {
2614 /* [dcl.fct] forbids type definitions in return types.
2615 Unfortunately, it's not easy to know whether or not we are
2616 processing a return type until after the fact. */
2624 {
2629 type);
2630 }
2631 }
2633 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2634 "<" in any valid C++ program. If the next token is indeed "<",
2635 issue a message warning the user about what appears to be an
2636 invalid attempt to form a template-id. LOCATION is the location
2637 of the type-specifier (TYPE) */
2639 static void
2641 tree type,
2643 location_t location)
2644 {
2648 {
2652 {
2655 else
2657 }
2658 else
2660 /* Remember the location of the invalid "<". */
2663 /* Consume the "<". */
2665 /* Parse the template arguments. */
2667 /* Permanently remove the invalid template arguments so that
2668 this error message is not issued again. */
2671 }
2672 }
2674 /* If parsing an integral constant-expression, issue an error message
2675 about the fact that THING appeared and return true. Otherwise,
2676 return false. In either case, set
2677 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2679 static bool
2681 non_integral_constant thing)
2682 {
2685 {
2687 {
2690 {
2697 "enumeration type cannot appear in a "
2788 }
2792 }
2793 }
2795 }
2797 /* Emit a diagnostic for an invalid type name. SCOPE is the
2798 qualifying scope (or NULL, if none) for ID. This function commits
2799 to the current active tentative parse, if any. (Otherwise, the
2800 problematic construct might be encountered again later, resulting
2801 in duplicate error messages.) LOCATION is the location of ID. */
2803 static void
2806 location_t location)
2807 {
2810 /* Try to lookup the identifier. */
2815 /* If the lookup found a template-name, it means that the user forgot
2816 to specify an argument list. Emit a useful error message. */
2820 decl);
2824 /* Something like 'unsigned A a;' */
2827 {
2828 /* Issue an error message. */
2830 /* If we're in a template class, it's possible that the user was
2831 referring to a type from a base class. For example:
2833 template <typename T> struct A { typedef T X; };
2834 template <typename T> struct B : public A<T> { X x; };
2836 The user should have said "typename A<T>::X". */
2842 {
2843 tree b;
2846 b;
2848 {
2852 {
2853 tree field;
2854 /* Go from a particular instantiation of the
2855 template (which will have an empty TYPE_FIELDs),
2856 to the main version. */
2859 field;
2863 {
2868 }
2871 }
2872 }
2873 }
2874 }
2875 /* Here we diagnose qualified-ids where the scope is actually correct,
2876 but the identifier does not resolve to a valid type name. */
2878 {
2880 {
2885 else
2889 }
2892 {
2893 /* A<T>::A<T>() */
2899 }
2906 {
2911 else
2915 }
2916 else
2918 }
2919 }
2921 /* Check for a common situation where a type-name should be present,
2922 but is not, and issue a sensible error message. Returns true if an
2923 invalid type-name was detected.
2925 The situation handled by this function are variable declarations of the
2926 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2927 Usually, `ID' should name a type, but if we got here it means that it
2928 does not. We try to emit the best possible error message depending on
2929 how exactly the id-expression looks like. */
2931 static bool
2933 {
2934 tree id;
2937 /* Avoid duplicate error about ambiguous lookup. */
2939 {
2943 }
2952 /* If the next token is a (, this is a function with no explicit return
2953 type, i.e. constructor, destructor or conversion op. */
2956 {
2959 }
2963 /* Emit a diagnostic for the invalid type. */
2966 out:
2967 /* If we aren't in the middle of a declarator (i.e. in a
2968 parameter-declaration-clause), skip to the end of the declaration;
2969 there's no point in trying to process it. */
2973 }
2975 /* Consume tokens up to, and including, the next non-nested closing `)'.
2976 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
2977 are doing error recovery. Returns -1 if OR_COMMA is true and we
2978 found an unnested comma. */
2980 static int
2985 {
2995 {
2999 {
3002 /* If we've run out of tokens, then there is no closing `)'. */
3005 /* This is good for lambda expression capture-lists. */
3015 /* This matches the processing in skip_to_end_of_statement. */
3041 {
3045 }
3050 }
3052 /* Consume the token. */
3054 }
3055 }
3057 /* Consume tokens until we reach the end of the current statement.
3058 Normally, that will be just before consuming a `;'. However, if a
3059 non-nested `}' comes first, then we stop before consuming that. */
3061 static void
3063 {
3067 {
3071 {
3074 /* If we've run out of tokens, stop. */
3078 /* If the next token is a `;', we have reached the end of the
3079 statement. */
3085 /* If this is a non-nested '}', stop before consuming it.
3086 That way, when confronted with something like:
3088 { 3 + }
3090 we stop before consuming the closing '}', even though we
3091 have not yet reached a `;'. */
3095 /* If it is the closing '}' for a block that we have
3096 scanned, stop -- but only after consuming the token.
3097 That way given:
3099 void f g () { ... }
3100 typedef int I;
3102 we will stop after the body of the erroneously declared
3103 function, but before consuming the following `typedef'
3104 declaration. */
3106 {
3109 }
3117 }
3119 /* Consume the token. */
3121 }
3122 }
3124 /* This function is called at the end of a statement or declaration.
3125 If the next token is a semicolon, it is consumed; otherwise, error
3126 recovery is attempted. */
3128 static void
3130 {
3131 /* Look for the trailing `;'. */
3133 {
3134 /* If there is additional (erroneous) input, skip to the end of
3135 the statement. */
3137 /* If the next token is now a `;', consume it. */
3140 }
3141 }
3143 /* Skip tokens until we have consumed an entire block, or until we
3144 have consumed a non-nested `;'. */
3146 static void
3148 {
3152 {
3156 {
3159 /* If we've run out of tokens, stop. */
3163 /* Stop if this is an unnested ';'. */
3169 /* Stop if this is an unnested '}', or closes the outermost
3170 nesting level. */
3171 nesting_depth--;
3179 /* Nest. */
3180 nesting_depth++;
3185 }
3187 /* Consume the token. */
3189 }
3190 }
3192 /* Skip tokens until a non-nested closing curly brace is the next
3193 token, or there are no more tokens. Return true in the first case,
3194 false otherwise. */
3196 static bool
3198 {
3202 {
3206 {
3209 /* If we've run out of tokens, stop. */
3213 /* If the next token is a non-nested `}', then we have reached
3214 the end of the current block. */
3220 /* If it the next token is a `{', then we are entering a new
3221 block. Consume the entire block. */
3227 }
3229 /* Consume the token. */
3231 }
3232 }
3234 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3235 parameter is the PRAGMA token, allowing us to purge the entire pragma
3236 sequence. */
3238 static void
3240 {
3245 do
3249 /* Ensure that the pragma is not parsed again. */
3251 }
3253 /* Require pragma end of line, resyncing with it as necessary. The
3254 arguments are as for cp_parser_skip_to_pragma_eol. */
3256 static void
3258 {
3262 }
3264 /* This is a simple wrapper around make_typename_type. When the id is
3265 an unresolved identifier node, we can provide a superior diagnostic
3266 using cp_parser_diagnose_invalid_type_name. */
3268 static tree
3271 {
3272 tree result;
3274 {
3280 }
3282 }
3284 /* This is a wrapper around the
3285 make_{pointer,ptrmem,reference}_declarator functions that decides
3286 which one to call based on the CODE and CLASS_TYPE arguments. The
3287 CODE argument should be one of the values returned by
3288 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3289 appertain to the pointer or reference. */
3293 cp_cv_quals cv_qualifiers,
3295 tree attributes)
3296 {
3303 else
3313 }
3315 /* Create a new C++ parser. */
3319 {
3324 /* cp_lexer_new_main is called before doing GC allocation because
3325 cp_lexer_new_main might load a PCH file. */
3328 /* Initialize the binops_by_token so that we can get the tree
3329 directly from the token. */
3337 /* For now, we always accept GNU extensions. */
3340 /* The `>' token is a greater-than operator, not the end of a
3341 template-id. */
3346 /* We are not parsing a constant-expression. */
3351 /* Local variable names are not forbidden. */
3354 /* We are not processing an `extern "C"' declaration. */
3357 /* We are not processing a declarator. */
3360 /* We are not processing a template-argument-list. */
3363 /* We are not in an iteration statement. */
3366 /* We are not in a switch statement. */
3369 /* We are not parsing a type-id inside an expression. */
3372 /* Declarations aren't implicitly extern "C". */
3375 /* String literals should be translated to the execution character set. */
3378 /* We are not parsing a function body. */
3381 /* We can correct until told otherwise. */
3384 /* The unparsed function queue is empty. */
3387 /* There are no classes being defined. */
3390 /* No template parameters apply. */
3394 }
3396 /* Create a cp_lexer structure which will emit the tokens in CACHE
3397 and push it onto the parser's lexer stack. This is used for delayed
3398 parsing of in-class method bodies and default arguments, and should
3399 not be confused with tentative parsing. */
3400 static void
3402 {
3407 /* Move the current source position to that of the first token in the
3408 new lexer. */
3410 }
3412 /* Pop the top lexer off the parser stack. This is never used for the
3413 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3414 static void
3416 {
3421 /* Put the current source position back where it was before this
3422 lexer was pushed. */
3424 }
3426 /* Lexical conventions [gram.lex] */
3428 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3429 identifier. */
3431 static tree
3433 {
3436 /* Look for the identifier. */
3438 /* Return the value. */
3440 }
3442 /* Parse a sequence of adjacent string constants. Returns a
3443 TREE_STRING representing the combined, nul-terminated string
3444 constant. If TRANSLATE is true, translate the string to the
3445 execution character set. If WIDE_OK is true, a wide string is
3446 invalid here.
3448 C++98 [lex.string] says that if a narrow string literal token is
3449 adjacent to a wide string literal token, the behavior is undefined.
3450 However, C99 6.4.5p4 says that this results in a wide string literal.
3451 We follow C99 here, for consistency with the C front end.
3453 This code is largely lifted from lex_string() in c-lex.c.
3455 FUTURE: ObjC++ will need to handle @-strings here. */
3456 static tree
3458 {
3459 tree value;
3466 tree string_tree;
3472 {
3475 }
3478 {
3482 }
3483 else
3484 {
3487 }
3490 /* Try to avoid the overhead of creating and destroying an obstack
3491 for the common case of just one string. */
3494 {
3502 {
3506 }
3507 else
3511 }
3512 else
3513 {
3517 do
3518 {
3520 count++;
3525 {
3528 {
3531 }
3534 {
3539 }
3541 }
3542 else
3546 {
3551 "unsupported non-standard concatenation "
3553 }
3559 {
3563 }
3564 else
3565 {
3569 }
3570 }
3574 }
3577 {
3580 }
3584 {
3589 {
3604 }
3609 {
3614 }
3615 }
3616 else
3617 /* cpp_interpret_string has issued an error. */
3624 }
3626 /* Look up a literal operator with the name and the exact arguments. */
3628 static tree
3630 {
3637 {
3643 {
3646 {
3656 }
3659 /* May be this should be sufficient_parms_p instead,
3660 depending on how exactly should user-defined literals
3661 work in presence of default arguments on the literal
3662 operator parameters. */
3665 }
3666 }
3669 }
3671 /* Parse a user-defined char constant. Returns a call to a user-defined
3672 literal operator taking the character as an argument. */
3674 static tree
3676 {
3684 /* Build up a call to the user-defined operator */
3685 /* Lookup the name we got back from the id-expression. */
3690 {
3695 }
3704 }
3706 /* A subroutine of cp_parser_userdef_numeric_literal to
3707 create a char... template parameter pack from a string node. */
3709 static tree
3711 {
3712 tree charvec;
3718 /* Fill in CHARVEC with all of the parameters. */
3723 /* Build the argument packs. */
3730 }
3732 /* A subroutine of cp_parser_userdef_numeric_literal to
3733 create a char... template parameter pack from a string node. */
3735 static tree
3737 {
3738 tree charvec;
3746 /* First template parm is character type. */
3749 /* Fill in CHARVEC with all of the parameters. */
3754 /* Build the argument packs. */
3761 }
3763 /* Parse a user-defined numeric constant. returns a call to a user-defined
3764 literal operator. */
3766 static tree
3768 {
3779 /* Look for a literal operator taking the exact type of numeric argument
3780 as the literal value. */
3785 {
3788 {
3792 long_long_unsigned_type_node);
3793 else
3794 {
3798 long_double_type_node);
3802 }
3805 }
3806 }
3809 /* If the numeric argument didn't work, look for a raw literal
3810 operator taking a const char* argument consisting of the number
3811 in string format. */
3816 {
3819 {
3822 }
3823 }
3826 /* If the raw literal didn't work, look for a non-type template
3827 function with parameter pack char.... Call the function with
3828 template parameter characters representing the number. */
3832 {
3837 {
3840 }
3841 }
3846 }
3848 /* Parse a user-defined string constant. Returns a call to a user-defined
3849 literal operator taking a character pointer and the length of the string
3850 as arguments. */
3852 static tree
3854 {
3864 /* Look for a template function with typename parameter CharT
3865 and parameter pack CharT... Call the function with
3866 template parameter characters representing the string. */
3870 {
3875 {
3878 }
3879 }
3882 /* Build up a call to the user-defined operator */
3883 /* Lookup the name we got back from the id-expression. */
3889 {
3893 }
3902 }
3905 /* Basic concepts [gram.basic] */
3907 /* Parse a translation-unit.
3909 translation-unit:
3910 declaration-seq [opt]
3912 Returns TRUE if all went well. */
3914 static bool
3916 {
3917 /* The address of the first non-permanent object on the declarator
3918 obstack. */
3923 /* Create the declarator obstack, if necessary. */
3925 {
3927 /* Create the error declarator. */
3929 /* Create the empty parameter list. */
3931 /* Remember where the base of the declarator obstack lies. */
3933 }
3937 /* If there are no tokens left then all went well. */
3939 {
3940 /* Get rid of the token array; we don't need it any more. */
3944 /* This file might have been a context that's implicitly extern
3945 "C". If so, pop the lang context. (Only relevant for PCH.) */
3947 {
3950 }
3952 /* Finish up. */
3956 }
3957 else
3958 {
3961 }
3963 /* Make sure the declarator obstack was fully cleaned up. */
3967 /* All went well. */
3969 }
3971 /* Return the appropriate tsubst flags for parsing, possibly in N3276
3972 decltype context. */
3976 {
3981 }
3983 /* Expressions [gram.expr] */
3985 /* Parse a primary-expression.
3987 primary-expression:
3988 literal
3989 this
3990 ( expression )
3991 id-expression
3993 GNU Extensions:
3995 primary-expression:
3996 ( compound-statement )
3997 __builtin_va_arg ( assignment-expression , type-id )
3998 __builtin_offsetof ( type-id , offsetof-expression )
4000 C++ Extensions:
4001 __has_nothrow_assign ( type-id )
4002 __has_nothrow_constructor ( type-id )
4003 __has_nothrow_copy ( type-id )
4004 __has_trivial_assign ( type-id )
4005 __has_trivial_constructor ( type-id )
4006 __has_trivial_copy ( type-id )
4007 __has_trivial_destructor ( type-id )
4008 __has_virtual_destructor ( type-id )
4009 __is_abstract ( type-id )
4010 __is_base_of ( type-id , type-id )
4011 __is_class ( type-id )
4012 __is_convertible_to ( type-id , type-id )
4013 __is_empty ( type-id )
4014 __is_enum ( type-id )
4015 __is_final ( type-id )
4016 __is_literal_type ( type-id )
4017 __is_pod ( type-id )
4018 __is_polymorphic ( type-id )
4019 __is_std_layout ( type-id )
4020 __is_trivial ( type-id )
4021 __is_union ( type-id )
4023 Objective-C++ Extension:
4025 primary-expression:
4026 objc-expression
4028 literal:
4029 __null
4031 ADDRESS_P is true iff this expression was immediately preceded by
4032 "&" and therefore might denote a pointer-to-member. CAST_P is true
4033 iff this expression is the target of a cast. TEMPLATE_ARG_P is
4034 true iff this expression is a template argument.
4036 Returns a representation of the expression. Upon return, *IDK
4037 indicates what kind of id-expression (if any) was present. */
4039 static tree
4046 {
4049 /* Assume the primary expression is not an id-expression. */
4052 /* Peek at the next token. */
4055 {
4056 /* literal:
4057 integer-literal
4058 character-literal
4059 floating-literal
4060 string-literal
4061 boolean-literal
4062 pointer-literal
4063 user-defined-literal */
4073 {
4077 }
4078 /* Floating-point literals are only allowed in an integral
4079 constant expression if they are cast to an integral or
4080 enumeration type. */
4084 {
4085 /* CAST_P will be set even in invalid code like "int(2.7 +
4086 ...)". Therefore, we have to check that the next token
4087 is sure to end the cast. */
4089 {
4094 enumerator-definition. */
4096 /* The curly brace at the end of an enum-specifier. */
4098 /* The end of a statement. */
4100 /* The end of the cast-expression. */
4102 /* The end of an array bound. */
4104 /* The closing ">" in a template-argument-list. */
4107 /* C++0x only: A ">>" treated like two ">" tokens,
4108 in a template-argument-list. */
4113 }
4115 /* If we are within a cast, then the constraint that the
4116 cast is to an integral or enumeration type will be
4117 checked at that point. If we are not within a cast, then
4118 this code is invalid. */
4121 }
4140 /* ??? Should wide strings be allowed when parser->translate_strings_p
4141 is false (i.e. in attributes)? If not, we can kill the third
4142 argument to cp_parser_string_literal. */
4148 {
4149 tree expr;
4152 /* Consume the `('. */
4154 /* Within a parenthesized expression, a `>' token is always
4155 the greater-than operator. */
4156 saved_greater_than_is_operator_p
4159 /* If we see `( { ' then we are looking at the beginning of
4160 a GNU statement-expression. */
4163 {
4164 /* Statement-expressions are not allowed by the standard. */
4168 /* And they're not allowed outside of a function-body; you
4169 cannot, for example, write:
4171 int i = ({ int j = 3; j + 1; });
4173 at class or namespace scope. */
4176 {
4178 "statement-expressions are not allowed outside "
4182 }
4183 else
4184 {
4185 /* Start the statement-expression. */
4187 /* Parse the compound-statement. */
4189 /* Finish up. */
4191 }
4192 }
4193 else
4194 {
4195 /* Parse the parenthesized expression. */
4197 /* Let the front end know that this expression was
4198 enclosed in parentheses. This matters in case, for
4199 example, the expression is of the form `A::B', since
4200 `&A::B' might be a pointer-to-member, but `&(A::B)' is
4201 not. */
4203 /* DR 705: Wrapping an unqualified name in parentheses
4204 suppresses arg-dependent lookup. We want to pass back
4205 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4206 (c++/37862), but none of the others. */
4209 }
4210 /* The `>' token might be the end of a template-id or
4211 template-parameter-list now. */
4212 parser->greater_than_is_operator_p
4214 /* Consume the `)'. */
4219 }
4223 /* We have an Objective-C++ message. */
4225 {
4227 /* Don't warn about a failed tentative parse. */
4232 }
4236 /* We have an Objective-C++ string literal. */
4243 {
4244 /* These two are the boolean literals. */
4252 /* The `__null' literal. */
4257 /* The `nullptr' literal. */
4262 /* Recognize the `this' keyword. */
4266 {
4270 }
4271 /* Pointers cannot appear in constant-expressions. */
4276 /* The `operator' keyword can be the beginning of an
4277 id-expression. */
4284 {
4285 non_integral_constant name;
4287 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4288 __func__ are the names of variables -- but they are
4289 treated specially. Therefore, they are handled here,
4290 rather than relying on the generic id-expression logic
4291 below. Grammatically, these names are id-expressions.
4293 Consume the token. */
4297 {
4309 }
4314 /* Look up the name. */
4316 }
4319 {
4320 tree expression;
4321 tree type;
4322 source_location type_location;
4324 /* The `__builtin_va_arg' construct is used to handle
4325 `va_arg'. Consume the `__builtin_va_arg' token. */
4327 /* Look for the opening `('. */
4329 /* Now, parse the assignment-expression. */
4332 /* Look for the `,'. */
4335 /* Parse the type-id. */
4337 /* Look for the closing `)'. */
4339 /* Using `va_arg' in a constant-expression is not
4340 allowed. */
4342 NIC_VA_ARG))
4345 }
4373 /* Objective-C++ expressions. */
4383 {
4388 }
4392 }
4394 /* An id-expression can start with either an identifier, a
4395 `::' as the beginning of a qualified-id, or the "operator"
4396 keyword. */
4401 {
4402 tree id_expression;
4403 tree decl;
4409 id_expression:
4410 /* Parse the id-expression. */
4411 id_expression
4428 /* If we have a template-id, then no further lookup is
4429 required. If the template-id was for a template-class, we
4430 will sometimes have a TYPE_DECL at this point. */
4434 /* Look up the name. */
4435 else
4436 {
4437 tree ambiguous_decls;
4439 /* If we already know that this lookup is ambiguous, then
4440 we've already issued an error message; there's no reason
4441 to check again. */
4444 {
4447 }
4450 none_type,
4451 template_p,
4456 /* If the lookup was ambiguous, an error will already have
4457 been issued. */
4461 /* In Objective-C++, we may have an Objective-C 2.0
4462 dot-syntax for classes here. */
4467 {
4468 tree component;
4475 }
4477 /* In Objective-C++, an instance variable (ivar) may be preferred
4478 to whatever cp_parser_lookup_name() found. */
4481 /* If name lookup gives us a SCOPE_REF, then the
4482 qualifying scope was dependent. */
4484 {
4485 /* At this point, we do not know if DECL is a valid
4486 integral constant expression. We assume that it is
4487 in fact such an expression, so that code like:
4489 template <int N> struct A {
4490 int a[B<N>::i];
4491 };
4493 is accepted. At template-instantiation time, we
4494 will check that B<N>::i is actually a constant. */
4496 }
4497 /* Check to see if DECL is a local variable in a context
4498 where that is forbidden. */
4501 {
4502 /* It might be that we only found DECL because we are
4503 trying to be generous with pre-ISO scoping rules.
4504 For example, consider:
4506 int i;
4507 void g() {
4508 for (int i = 0; i < 10; ++i) {}
4509 extern void f(int j = i);
4510 }
4512 Here, name look up will originally find the out
4513 of scope `i'. We need to issue a warning message,
4514 but then use the global `i'. */
4517 {
4520 decl);
4522 }
4523 }
4524 }
4526 decl = (finish_id_expression
4528 idk,
4533 template_arg_p,
4539 }
4541 /* Anything else is an error. */
4545 }
4546 }
4554 {
4557 }
4559 /* Parse an id-expression.
4561 id-expression:
4562 unqualified-id
4563 qualified-id
4565 qualified-id:
4566 :: [opt] nested-name-specifier template [opt] unqualified-id
4567 :: identifier
4568 :: operator-function-id
4569 :: template-id
4571 Return a representation of the unqualified portion of the
4572 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
4573 a `::' or nested-name-specifier.
4575 Often, if the id-expression was a qualified-id, the caller will
4576 want to make a SCOPE_REF to represent the qualified-id. This
4577 function does not do this in order to avoid wastefully creating
4578 SCOPE_REFs when they are not required.
4580 If TEMPLATE_KEYWORD_P is true, then we have just seen the
4581 `template' keyword.
4583 If CHECK_DEPENDENCY_P is false, then names are looked up inside
4584 uninstantiated templates.
4586 If *TEMPLATE_P is non-NULL, it is set to true iff the
4587 `template' keyword is used to explicitly indicate that the entity
4588 named is a template.
4590 If DECLARATOR_P is true, the id-expression is appearing as part of
4591 a declarator, rather than as part of an expression. */
4593 static tree
4600 {
4604 /* Assume the `template' keyword was not used. */
4608 /* Look for the optional `::' operator. */
4609 global_scope_p
4612 /* Look for the optional nested-name-specifier. */
4613 nested_name_specifier_p
4616 check_dependency_p,
4618 declarator_p)
4620 /* If there is a nested-name-specifier, then we are looking at
4621 the first qualified-id production. */
4623 {
4624 tree saved_scope;
4625 tree saved_object_scope;
4626 tree saved_qualifying_scope;
4627 tree unqualified_id;
4630 /* See if the next token is the `template' keyword. */
4634 /* Name lookup we do during the processing of the
4635 unqualified-id might obliterate SCOPE. */
4639 /* Process the final unqualified-id. */
4641 check_dependency_p,
4642 declarator_p,
4644 /* Restore the SAVED_SCOPE for our caller. */
4650 }
4651 /* Otherwise, if we are in global scope, then we are looking at one
4652 of the other qualified-id productions. */
4654 {
4656 tree id;
4658 /* Peek at the next token. */
4661 /* If it's an identifier, and the next token is not a "<", then
4662 we can avoid the template-id case. This is an optimization
4663 for this common case. */
4665 && !cp_parser_nth_token_starts_template_argument_list_p
4670 /* Try a template-id. */
4674 none_type,
4675 declarator_p);
4676 /* If that worked, we're done. */
4680 /* Peek at the next token. (Changes in the token buffer may
4681 have invalidated the pointer obtained above.) */
4685 {
4692 /* Fall through. */
4697 }
4698 }
4699 else
4702 declarator_p,
4703 optional_p);
4704 }
4706 /* Parse an unqualified-id.
4708 unqualified-id:
4709 identifier
4710 operator-function-id
4711 conversion-function-id
4712 ~ class-name
4713 template-id
4715 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
4716 keyword, in a construct like `A::template ...'.
4718 Returns a representation of unqualified-id. For the `identifier'
4719 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
4720 production a BIT_NOT_EXPR is returned; the operand of the
4721 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
4722 other productions, see the documentation accompanying the
4723 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
4724 names are looked up in uninstantiated templates. If DECLARATOR_P
4725 is true, the unqualified-id is appearing as part of a declarator,
4726 rather than as part of an expression. */
4728 static tree
4734 {
4737 /* Peek at the next token. */
4741 {
4743 {
4744 tree id;
4746 /* We don't know yet whether or not this will be a
4747 template-id. */
4749 /* Try a template-id. */
4751 check_dependency_p,
4752 none_type,
4753 declarator_p);
4754 /* If it worked, we're done. */
4757 /* Otherwise, it's an ordinary identifier. */
4759 }
4763 check_dependency_p,
4764 none_type,
4765 declarator_p);
4768 {
4769 tree type_decl;
4770 tree qualifying_scope;
4771 tree object_scope;
4772 tree scope;
4775 /* Consume the `~' token. */
4777 /* Parse the class-name. The standard, as written, seems to
4778 say that:
4780 template <typename T> struct S { ~S (); };
4781 template <typename T> S<T>::~S() {}
4783 is invalid, since `~' must be followed by a class-name, but
4784 `S<T>' is dependent, and so not known to be a class.
4785 That's not right; we need to look in uninstantiated
4786 templates. A further complication arises from:
4788 template <typename T> void f(T t) {
4789 t.T::~T();
4790 }
4792 Here, it is not possible to look up `T' in the scope of `T'
4793 itself. We must look in both the current scope, and the
4794 scope of the containing complete expression.
4796 Yet another issue is:
4798 struct S {
4799 int S;
4800 ~S();
4801 };
4803 S::~S() {}
4805 The standard does not seem to say that the `S' in `~S'
4806 should refer to the type `S' and not the data member
4807 `S::S'. */
4809 /* DR 244 says that we look up the name after the "~" in the
4810 same scope as we looked up the qualifying name. That idea
4811 isn't fully worked out; it's more complicated than that. */
4816 /* Check for invalid scopes. */
4818 {
4822 }
4824 {
4828 scope);
4833 }
4836 /* If the name is of the form "X::~X" it's OK even if X is a
4837 typedef. */
4846 {
4849 }
4851 /* ~auto means the destructor of whatever the object is. */
4853 {
4856 "%<~auto%> only available with "
4860 }
4862 /* If there was an explicit qualification (S::~T), first look
4863 in the scope given by the qualification (i.e., S).
4865 Note: in the calls to cp_parser_class_name below we pass
4866 typename_type so that lookup finds the injected-class-name
4867 rather than the constructor. */
4871 {
4876 typename_type,
4879 declarator_p);
4882 }
4883 /* In "N::S::~S", look in "N" as well. */
4885 {
4890 type_decl
4894 typename_type,
4897 declarator_p);
4900 }
4901 /* In "p->S::~T", look in the scope given by "*p" as well. */
4903 {
4908 type_decl
4912 typename_type,
4915 declarator_p);
4918 }
4919 /* Look in the surrounding context. */
4921 {
4927 type_decl
4931 typename_type,
4934 declarator_p);
4937 {
4938 /* We couldn't find a type with this name, so just accept
4939 it and check for a match at instantiation time. */
4944 }
4945 }
4946 /* If an error occurred, assume that the name of the
4947 destructor is the same as the name of the qualifying
4948 class. That allows us to keep parsing after running
4949 into ill-formed destructor names. */
4955 /* Check that destructor name and scope match. */
4957 {
4964 }
4966 /* [class.dtor]
4968 A typedef-name that names a class shall not be used as the
4969 identifier in the declarator for a destructor declaration. */
4976 type_decl);
4979 }
4983 {
4984 tree id;
4986 /* This could be a template-id, so we try that first. */
4988 /* Try a template-id. */
4991 none_type,
4992 declarator_p);
4993 /* If that worked, we're done. */
4996 /* We still don't know whether we're looking at an
4997 operator-function-id or a conversion-function-id. */
4999 /* Try an operator-function-id. */
5001 /* If that didn't work, try a conversion-function-id. */
5005 {
5006 /* 17.6.3.3.5 */
5011 }
5014 }
5015 /* Fall through. */
5022 }
5023 }
5025 /* Parse an (optional) nested-name-specifier.
5027 nested-name-specifier: [C++98]
5028 class-or-namespace-name :: nested-name-specifier [opt]
5029 class-or-namespace-name :: template nested-name-specifier [opt]
5031 nested-name-specifier: [C++0x]
5032 type-name ::
5033 namespace-name ::
5034 nested-name-specifier identifier ::
5035 nested-name-specifier template [opt] simple-template-id ::
5037 PARSER->SCOPE should be set appropriately before this function is
5038 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
5039 effect. TYPE_P is TRUE if we non-type bindings should be ignored
5040 in name lookups.
5042 Sets PARSER->SCOPE to the class (TYPE) or namespace
5043 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
5044 it unchanged if there is no nested-name-specifier. Returns the new
5045 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
5047 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
5048 part of a declaration and/or decl-specifier. */
5050 static tree
5056 {
5061 /* Remember where the nested-name-specifier starts. */
5063 {
5066 }
5069 {
5070 tree new_scope;
5071 tree old_scope;
5072 tree saved_qualifying_scope;
5075 /* Spot cases that cannot be the beginning of a
5076 nested-name-specifier. */
5079 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
5080 the already parsed nested-name-specifier. */
5082 {
5083 /* Grab the nested-name-specifier and continue the loop. */
5085 /* If we originally encountered this nested-name-specifier
5086 with IS_DECLARATION set to false, we will not have
5087 resolved TYPENAME_TYPEs, so we must do so here. */
5090 {
5095 }
5098 }
5100 /* Spot cases that cannot be the beginning of a
5101 nested-name-specifier. On the second and subsequent times
5102 through the loop, we look for the `template' keyword. */
5104 ;
5105 /* A template-id can start a nested-name-specifier. */
5107 ;
5108 /* DR 743: decltype can be used in a nested-name-specifier. */
5110 ;
5111 else
5112 {
5113 /* If the next token is not an identifier, then it is
5114 definitely not a type-name or namespace-name. */
5117 /* If the following token is neither a `<' (to begin a
5118 template-id), nor a `::', then we are not looking at a
5119 nested-name-specifier. */
5125 {
5129 }
5132 && !cp_parser_nth_token_starts_template_argument_list_p
5135 }
5137 /* The nested-name-specifier is optional, so we parse
5138 tentatively. */
5141 /* Look for the optional `template' keyword, if this isn't the
5142 first time through the loop. */
5145 else
5148 /* Save the old scope since the name lookup we are about to do
5149 might destroy it. */
5152 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
5153 look up names in "X<T>::I" in order to determine that "Y" is
5154 a template. So, if we have a typename at this point, we make
5155 an effort to look through it. */
5157 && !typename_keyword_p
5162 /* Parse the qualifying entity. */
5163 new_scope
5165 typename_keyword_p,
5166 template_keyword_p,
5167 check_dependency_p,
5168 type_p,
5169 is_declaration);
5170 /* Look for the `::' token. */
5173 /* If we found what we wanted, we keep going; otherwise, we're
5174 done. */
5176 {
5179 /* Restore the OLD_SCOPE since it was valid before the
5180 failed attempt at finding the last
5181 class-or-namespace-name. */
5185 /* If the next token is a decltype, and the one after that is a
5186 `::', then the decltype has failed to resolve to a class or
5187 enumeration type. Give this error even when parsing
5188 tentatively since it can't possibly be valid--and we're going
5189 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
5190 won't get another chance.*/
5194 {
5201 /* As below. */
5204 }
5208 /* If the next token is an identifier, and the one after
5209 that is a `::', then any valid interpretation would have
5210 found a class-or-namespace-name. */
5216 {
5219 {
5221 {
5222 tree decl;
5223 tree ambiguous_decls;
5226 none_type,
5235 decl);
5237 {
5238 // cp_parser_lookup_name has the same diagnostic,
5239 // thus make sure to emit it at most once.
5242 {
5247 }
5249 }
5250 else
5251 {
5253 cp_parser_name_lookup_error
5256 else
5257 cp_parser_name_lookup_error
5260 }
5261 }
5264 /* Treat this as a successful nested-name-specifier
5265 due to:
5267 [basic.lookup.qual]
5269 If the name found is not a class-name (clause
5270 _class_) or namespace-name (_namespace.def_), the
5271 program is ill-formed. */
5273 }
5275 }
5277 }
5278 /* We've found one valid nested-name-specifier. */
5280 /* Name lookup always gives us a DECL. */
5283 /* Uses of "template" must be followed by actual templates. */
5295 new_scope);
5296 /* If it is a class scope, try to complete it; we are about to
5297 be looking up names inside the class. */
5299 /* Since checking types for dependency can be expensive,
5300 avoid doing it if the type is already complete. */
5302 /* Do not try to complete dependent types. */
5304 {
5306 /* If it is a typedef to current class, use the current
5307 class instead, as the typedef won't have any names inside
5308 it yet. */
5312 }
5313 /* Make sure we look in the right scope the next time through
5314 the loop. */
5316 }
5318 /* If parsing tentatively, replace the sequence of tokens that makes
5319 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
5320 token. That way, should we re-parse the token stream, we will
5321 not have to repeat the effort required to do the parse, nor will
5322 we issue duplicate error messages. */
5324 {
5328 /* Reset the contents of the START token. */
5330 /* Retrieve any deferred checks. Do not pop this access checks yet
5331 so the memory will not be reclaimed during token replacing below. */
5339 /* Purge all subsequent tokens. */
5341 }
5347 }
5349 /* Parse a nested-name-specifier. See
5350 cp_parser_nested_name_specifier_opt for details. This function
5351 behaves identically, except that it will an issue an error if no
5352 nested-name-specifier is present. */
5354 static tree
5360 {
5361 tree scope;
5363 /* Look for the nested-name-specifier. */
5365 typename_keyword_p,
5366 check_dependency_p,
5367 type_p,
5368 is_declaration);
5369 /* If it was not present, issue an error message. */
5371 {
5374 }
5377 }
5379 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
5380 this is either a class-name or a namespace-name (which corresponds
5381 to the class-or-namespace-name production in the grammar). For
5382 C++0x, it can also be a type-name that refers to an enumeration
5383 type or a simple-template-id.
5385 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
5386 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
5387 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
5388 TYPE_P is TRUE iff the next name should be taken as a class-name,
5389 even the same name is declared to be another entity in the same
5390 scope.
5392 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
5393 specified by the class-or-namespace-name. If neither is found the
5394 ERROR_MARK_NODE is returned. */
5396 static tree
5403 {
5404 tree saved_scope;
5405 tree saved_qualifying_scope;
5406 tree saved_object_scope;
5407 tree scope;
5411 /* DR 743: decltype can appear in a nested-name-specifier. */
5413 {
5417 {
5420 }
5424 }
5426 /* Before we try to parse the class-name, we must save away the
5427 current PARSER->SCOPE since cp_parser_class_name will destroy
5428 it. */
5432 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
5433 there is no need to look for a namespace-name. */
5434 only_class_p = template_keyword_p
5439 typename_keyword_p,
5440 template_keyword_p,
5442 check_dependency_p,
5444 is_declaration);
5446 /* If that didn't work and we're in C++0x mode, try for a type-name. */
5450 {
5451 /* Restore the saved scope. */
5456 /* Parse tentatively. */
5459 /* Parse a type-name */
5462 /* "If the name found does not designate a namespace or a class,
5463 enumeration, or dependent type, the program is ill-formed."
5465 We cover classes and dependent types above and namespaces below,
5466 so this code is only looking for enums. */
5472 }
5473 /* If that didn't work, try for a namespace-name. */
5475 {
5476 /* Restore the saved scope. */
5480 /* If we are not looking at an identifier followed by the scope
5481 resolution operator, then this is not part of a
5482 nested-name-specifier. (Note that this function is only used
5483 to parse the components of a nested-name-specifier.) */
5488 }
5491 }
5493 /* Parse a postfix-expression.
5495 postfix-expression:
5496 primary-expression
5497 postfix-expression [ expression ]
5498 postfix-expression ( expression-list [opt] )
5499 simple-type-specifier ( expression-list [opt] )
5500 typename :: [opt] nested-name-specifier identifier
5501 ( expression-list [opt] )
5502 typename :: [opt] nested-name-specifier template [opt] template-id
5503 ( expression-list [opt] )
5504 postfix-expression . template [opt] id-expression
5505 postfix-expression -> template [opt] id-expression
5506 postfix-expression . pseudo-destructor-name
5507 postfix-expression -> pseudo-destructor-name
5508 postfix-expression ++
5509 postfix-expression --
5510 dynamic_cast < type-id > ( expression )
5511 static_cast < type-id > ( expression )
5512 reinterpret_cast < type-id > ( expression )
5513 const_cast < type-id > ( expression )
5514 typeid ( expression )
5515 typeid ( type-id )
5517 GNU Extension:
5519 postfix-expression:
5520 ( type-id ) { initializer-list , [opt] }
5522 This extension is a GNU version of the C99 compound-literal
5523 construct. (The C99 grammar uses `type-name' instead of `type-id',
5524 but they are essentially the same concept.)
5526 If ADDRESS_P is true, the postfix expression is the operand of the
5527 `&' operator. CAST_P is true if this expression is the target of a
5528 cast.
5530 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
5531 class member access expressions [expr.ref].
5533 Returns a representation of the expression. */
5535 static tree
5539 {
5546 /* Peek at the next token. */
5548 /* Some of the productions are determined by keywords. */
5551 {
5556 {
5557 tree type;
5558 tree expression;
5562 /* All of these can be handled in the same way from the point
5563 of view of parsing. Begin by consuming the token
5564 identifying the cast. */
5567 /* New types cannot be defined in the cast. */
5569 parser->type_definition_forbidden_message
5572 /* Look for the opening `<'. */
5574 /* Parse the type to which we are casting. */
5579 /* Look for the closing `>'. */
5581 /* Restore the old message. */
5584 /* And the expression which is being cast. */
5589 /* Only type conversions to integral or enumeration types
5590 can be used in constant-expressions. */
5596 {
5598 postfix_expression
5602 postfix_expression
5606 postfix_expression
5608 tf_warning_or_error);
5611 postfix_expression
5616 }
5617 }
5621 {
5622 tree type;
5626 /* Consume the `typeid' token. */
5628 /* Look for the `(' token. */
5630 /* Types cannot be defined in a `typeid' expression. */
5632 parser->type_definition_forbidden_message
5634 /* We can't be sure yet whether we're looking at a type-id or an
5635 expression. */
5637 /* Try a type-id first. */
5642 /* Look for the `)' token. Otherwise, we can't be sure that
5643 we're not looking at an expression: consider `typeid (int
5644 (3))', for example. */
5646 /* If all went well, simply lookup the type-id. */
5649 /* Otherwise, fall back to the expression variant. */
5650 else
5651 {
5652 tree expression;
5654 /* Look for an expression. */
5656 /* Compute its typeid. */
5658 /* Look for the `)' token. */
5660 }
5661 /* Restore the saved message. */
5663 /* `typeid' may not appear in an integral constant expression. */
5666 }
5670 {
5671 tree type;
5672 /* The syntax permitted here is the same permitted for an
5673 elaborated-type-specifier. */
5678 }
5682 {
5685 tree p;
5700 tf_warning_or_error);
5703 tf_warning_or_error);
5704 else
5705 {
5709 }
5711 }
5714 {
5715 tree type;
5717 /* If the next thing is a simple-type-specifier, we may be
5718 looking at a functional cast. We could also be looking at
5719 an id-expression. So, we try the functional cast, and if
5720 that doesn't work we fall back to the primary-expression. */
5722 /* Look for the simple-type-specifier. */
5725 CP_PARSER_FLAGS_NONE);
5726 /* Parse the cast itself. */
5728 postfix_expression
5730 /* If that worked, we're done. */
5734 /* If the functional-cast didn't work out, try a
5735 compound-literal. */
5738 {
5743 /* Consume the `('. */
5745 /* Parse the type. */
5750 /* Look for the `)'. */
5752 /* If things aren't going well, there's no need to
5753 keep going. */
5755 {
5757 {
5759 /* Parse the brace-enclosed initializer list. */
5762 }
5763 else
5765 }
5766 /* If that worked, we're definitely looking at a
5767 compound-literal expression. */
5769 {
5770 /* Warn the user that a compound literal is not
5771 allowed in standard C++. */
5774 /* For simplicity, we disallow compound literals in
5775 constant-expressions. We could
5776 allow compound literals of integer type, whose
5777 initializer was a constant, in constant
5778 expressions. Permitting that usage, as a further
5779 extension, would not change the meaning of any
5780 currently accepted programs. (Of course, as
5781 compound literals are not part of ISO C++, the
5782 standard has nothing to say.) */
5784 NIC_NCC))
5785 {
5788 }
5789 /* Form the representation of the compound-literal. */
5790 postfix_expression
5792 tf_warning_or_error);
5794 }
5795 }
5797 /* It must be a primary-expression. */
5798 postfix_expression
5801 decltype_p,
5803 }
5805 }
5807 /* Note that we don't need to worry about calling build_cplus_new on a
5808 class-valued CALL_EXPR in decltype when it isn't the end of the
5809 postfix-expression; unary_complex_lvalue will take care of that for
5810 all these cases. */
5812 /* Keep looping until the postfix-expression is complete. */
5814 {
5818 /* It is not a Koenig lookup function call. */
5819 postfix_expression
5822 /* Peek at the next token. */
5826 {
5829 {
5831 "two consecutive %<[%> shall "
5834 }
5835 postfix_expression
5837 postfix_expression,
5839 decltype_p);
5845 /* postfix-expression ( expression-list [opt] ) */
5846 {
5856 is_builtin_constant_p
5859 {
5860 /* The whole point of __builtin_constant_p is to allow
5861 non-constant expressions to appear as arguments. */
5862 saved_integral_constant_expression_p
5864 saved_non_integral_constant_expression_p
5867 }
5868 args = (cp_parser_parenthesized_expression_list
5873 {
5874 parser->integral_constant_expression_p
5876 parser->non_integral_constant_expression_p
5878 }
5881 {
5884 }
5886 /* Function calls are not permitted in
5887 constant-expressions. */
5890 NIC_FUNC_CALL))
5891 {
5895 }
5900 {
5902 {
5904 {
5907 postfix_expression
5910 complain);
5911 }
5912 else
5913 postfix_expression
5915 }
5916 /* We do not perform argument-dependent lookup if
5917 normal lookup finds a non-function, in accordance
5918 with the expected resolution of DR 218. */
5921 {
5925 /* Do not do argument dependent lookup if regular
5926 lookup finds a member function or a block-scope
5927 function declaration. [basic.lookup.argdep]/3 */
5930 {
5933 postfix_expression
5936 complain);
5937 }
5938 }
5939 }
5942 {
5952 {
5953 postfix_expression
5957 }
5960 {
5961 postfix_expression
5962 = (build_new_method_call
5968 complain));
5969 }
5970 else
5971 postfix_expression
5975 complain);
5976 }
5980 postfix_expression = (build_offset_ref_call_from_tree
5982 complain));
5984 /* A call to a static class member, or a namespace-scope
5985 function. */
5986 postfix_expression
5989 koenig_p,
5990 complain);
5991 else
5992 /* All other function calls. */
5993 postfix_expression
5996 koenig_p,
5997 complain);
5999 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
6003 }
6008 /* postfix-expression . template [opt] id-expression
6009 postfix-expression . pseudo-destructor-name
6010 postfix-expression -> template [opt] id-expression
6011 postfix-expression -> pseudo-destructor-name */
6013 /* Consume the `.' or `->' operator. */
6016 postfix_expression
6018 postfix_expression,
6026 /* postfix-expression ++ */
6027 /* Consume the `++' token. */
6029 /* Generate a representation for the complete expression. */
6030 postfix_expression
6032 POSTINCREMENT_EXPR);
6033 /* Increments may not appear in constant-expressions. */
6041 /* postfix-expression -- */
6042 /* Consume the `--' token. */
6044 /* Generate a representation for the complete expression. */
6045 postfix_expression
6047 POSTDECREMENT_EXPR);
6048 /* Decrements may not appear in constant-expressions. */
6060 else
6062 }
6063 }
6065 /* We should never get here. */
6068 }
6070 /* This function parses Cilk Plus array notations. If a normal array expr. is
6071 parsed then the array index is passed back to the caller through *INIT_INDEX
6072 and the function returns a NULL_TREE. If array notation expr. is parsed,
6073 then *INIT_INDEX is ignored by the caller and the function returns
6074 a tree of type ARRAY_NOTATION_REF. If some error occurred it returns
6075 error_mark_node. */
6077 static tree
6079 tree array_value)
6080 {
6084 {
6087 }
6096 {
6099 }
6101 {
6102 /* Consume the ':'. */
6105 /* If we are here, then we have a case like this A[:]. */
6107 {
6111 }
6115 }
6116 else
6117 {
6118 /* If we are here, then there are three valid possibilities:
6119 1. ARRAY [ EXP ]
6120 2. ARRAY [ EXP : EXP ]
6121 3. ARRAY [ EXP : EXP : EXP ] */
6125 {
6126 /* This indicates that we have a normal array expression. */
6129 }
6131 /* Consume the ':'. */
6135 {
6138 }
6139 }
6144 {
6148 }
6154 }
6156 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6157 by cp_parser_builtin_offsetof. We're looking for
6159 postfix-expression [ expression ]
6160 postfix-expression [ braced-init-list ] (C++11)
6162 FOR_OFFSETOF is set if we're being called in that context, which
6163 changes how we deal with integer constant expressions. */
6165 static tree
6167 tree postfix_expression,
6170 {
6174 /* Consume the `[' token. */
6177 /* Parse the index expression. */
6178 /* ??? For offsetof, there is a question of what to allow here. If
6179 offsetof is not being used in an integral constant expression context,
6180 then we *could* get the right answer by computing the value at runtime.
6181 If we are in an integral constant expression context, then we might
6182 could accept any constant expression; hard to say without analysis.
6183 Rather than open the barn door too wide right away, allow only integer
6184 constant expressions here. */
6187 else
6188 {
6190 {
6196 {
6198 "braced list index is not allowed with array "
6202 }
6203 }
6205 {
6206 /* Here are have these two options:
6207 ARRAY[EXP : EXP] - Array notation expr with default
6208 stride of 1.
6209 ARRAY[EXP : EXP : EXP] - Array Notation with user-defined
6210 stride. */
6212 postfix_expression);
6215 }
6216 else
6218 }
6220 /* Look for the closing `]'. */
6223 /* Build the ARRAY_REF. */
6227 /* When not doing offsetof, array references are not permitted in
6228 constant-expressions. */
6234 }
6236 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6237 by cp_parser_builtin_offsetof. We're looking for
6239 postfix-expression . template [opt] id-expression
6240 postfix-expression . pseudo-destructor-name
6241 postfix-expression -> template [opt] id-expression
6242 postfix-expression -> pseudo-destructor-name
6244 FOR_OFFSETOF is set if we're being called in that context. That sorta
6245 limits what of the above we'll actually accept, but nevermind.
6246 TOKEN_TYPE is the "." or "->" token, which will already have been
6247 removed from the stream. */
6249 static tree
6252 tree postfix_expression,
6254 location_t location)
6255 {
6256 tree name;
6261 /* If this is a `->' operator, dereference the pointer. */
6264 tf_warning_or_error);
6265 /* Check to see whether or not the expression is type-dependent. */
6267 /* The identifier following the `->' or `.' is not qualified. */
6273 /* Enter the scope corresponding to the type of the object
6274 given by the POSTFIX_EXPRESSION. */
6276 {
6278 /* According to the standard, no expression should ever have
6279 reference type. Unfortunately, we do not currently match
6280 the standard in this respect in that our internal representation
6281 of an expression may have reference type even when the standard
6282 says it does not. Therefore, we have to manually obtain the
6283 underlying type here. */
6285 /* The type of the POSTFIX_EXPRESSION must be complete. */
6287 {
6289 postfix_expression);
6291 }
6292 /* Unlike the object expression in other contexts, *this is not
6293 required to be of complete type for purposes of class member
6294 access (5.2.5) outside the member function body. */
6298 /* Let the name lookup machinery know that we are processing a
6299 class member access expression. */
6301 /* If something went wrong, we want to be able to discern that case,
6302 as opposed to the case where there was no SCOPE due to the type
6303 of expression being dependent. */
6306 /* If the SCOPE was erroneous, make the various semantic analysis
6307 functions exit quickly -- and without issuing additional error
6308 messages. */
6311 }
6313 /* Assume this expression is not a pseudo-destructor access. */
6316 /* If the SCOPE is a scalar type, then, if this is a valid program,
6317 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
6318 is type dependent, it can be pseudo-destructor-name or something else.
6319 Try to parse it as pseudo-destructor-name first. */
6321 {
6322 tree s;
6323 tree type;
6326 /* Parse the pseudo-destructor-name. */
6335 {
6337 postfix_expression
6340 }
6341 }
6344 {
6345 /* If the SCOPE is not a scalar type, we are looking at an
6346 ordinary class member access expression, rather than a
6347 pseudo-destructor-name. */
6350 /* Parse the id-expression. */
6351 name = (cp_parser_id_expression
6358 /* In general, build a SCOPE_REF if the member name is qualified.
6359 However, if the name was not dependent and has already been
6360 resolved; there is no need to build the SCOPE_REF. For example;
6362 struct X { void f(); };
6363 template <typename T> void f(T* t) { t->X::f(); }
6365 Even though "t" is dependent, "X::f" is not and has been resolved
6366 to a BASELINK; there is no need to include scope information. */
6368 /* But we do need to remember that there was an explicit scope for
6369 virtual function calls. */
6373 /* If the name is a template-id that names a type, we will get a
6374 TYPE_DECL here. That is invalid code. */
6376 {
6379 }
6380 else
6381 {
6383 {
6385 {
6389 }
6390 else
6393 name,
6394 template_p);
6398 }
6400 adjust_result_of_qualified_name_lookup
6402 postfix_expression
6404 template_p,
6405 tf_warning_or_error);
6406 }
6407 }
6409 /* We no longer need to look up names in the scope of the object on
6410 the left-hand side of the `.' or `->' operator. */
6413 /* Outside of offsetof, these operators may not appear in
6414 constant-expressions. */
6416 && (cp_parser_non_integral_constant_expression
6421 }
6423 /* Parse a parenthesized expression-list.
6425 expression-list:
6426 assignment-expression
6427 expression-list, assignment-expression
6429 attribute-list:
6430 expression-list
6431 identifier
6432 identifier, expression-list
6434 CAST_P is true if this expression is the target of a cast.
6436 ALLOW_EXPANSION_P is true if this expression allows expansion of an
6437 argument pack.
6439 Returns a vector of trees. Each element is a representation of an
6440 assignment-expression. NULL is returned if the ( and or ) are
6441 missing. An empty, but allocated, vector is returned on no
6442 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
6443 if we are parsing an attribute list for an attribute that wants a
6444 plain identifier argument, normal_attr for an attribute that wants
6445 an expression, or non_attr if we aren't parsing an attribute list. If
6446 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
6447 not all of the expressions in the list were constant. */
6455 {
6461 /* Assume all the expressions will be constant. */
6470 /* Within a parenthesized expression, a `>' token is always
6471 the greater-than operator. */
6472 saved_greater_than_is_operator_p
6476 /* Consume expressions until there are no more. */
6479 {
6480 tree expr;
6482 /* At the beginning of attribute lists, check to see if the
6483 next token is an identifier. */
6486 {
6489 /* Consume the identifier. */
6491 /* Save the identifier. */
6493 }
6494 else
6495 {
6498 /* Parse the next assignment-expression. */
6500 {
6501 /* A braced-init-list. */
6506 }
6508 {
6509 expr = (cp_parser_constant_expression
6514 }
6515 else
6521 /* If we have an ellipsis, then this is an expression
6522 expansion. */
6525 {
6526 /* Consume the `...'. */
6529 /* Build the argument pack. */
6531 }
6533 /* Add it to the list. We add error_mark_node
6534 expressions to the list, so that we can still tell if
6535 the correct form for a parenthesized expression-list
6536 is found. That gives better errors. */
6541 }
6543 /* After the first item, attribute lists look the same as
6544 expression lists. */
6547 get_comma:;
6548 /* If the next token isn't a `,', then we are done. */
6552 /* Otherwise, consume the `,' and keep going. */
6554 }
6557 {
6560 skip_comma:;
6561 /* We try and resync to an unnested comma, as that will give the
6562 user better diagnostics. */
6570 {
6571 parser->greater_than_is_operator_p
6574 }
6575 }
6577 parser->greater_than_is_operator_p
6584 }
6586 /* Parse a pseudo-destructor-name.
6588 pseudo-destructor-name:
6589 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
6590 :: [opt] nested-name-specifier template template-id :: ~ type-name
6591 :: [opt] nested-name-specifier [opt] ~ type-name
6593 If either of the first two productions is used, sets *SCOPE to the
6594 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
6595 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
6596 or ERROR_MARK_NODE if the parse fails. */
6598 static void
6600 tree object,
6603 {
6606 /* Handle ~auto. */
6610 {
6613 "%<~auto%> only available with "
6620 }
6622 /* Assume that things will not work out. */
6625 /* Look for the optional `::' operator. */
6627 /* Look for the optional nested-name-specifier. */
6628 nested_name_specifier_p
6635 /* Now, if we saw a nested-name-specifier, we might be doing the
6636 second production. */
6639 {
6640 /* Consume the `template' keyword. */
6642 /* Parse the template-id. */
6646 class_type,
6648 /* Look for the `::' token. */
6650 }
6651 /* If the next token is not a `~', then there might be some
6652 additional qualification. */
6654 {
6655 /* At this point, we're looking for "type-name :: ~". The type-name
6656 must not be a class-name, since this is a pseudo-destructor. So,
6657 it must be either an enum-name, or a typedef-name -- both of which
6658 are just identifiers. So, we peek ahead to check that the "::"
6659 and "~" tokens are present; if they are not, then we can avoid
6660 calling type_name. */
6664 {
6667 }
6669 /* Look for the type-name. */
6674 /* Look for the `::' token. */
6676 }
6677 else
6680 /* Look for the `~'. */
6683 /* Once we see the ~, this has to be a pseudo-destructor. */
6687 /* Look for the type-name again. We are not responsible for
6688 checking that it matches the first type-name. */
6690 }
6692 /* Parse a unary-expression.
6694 unary-expression:
6695 postfix-expression
6696 ++ cast-expression
6697 -- cast-expression
6698 unary-operator cast-expression
6699 sizeof unary-expression
6700 sizeof ( type-id )
6701 alignof ( type-id ) [C++0x]
6702 new-expression
6703 delete-expression
6705 GNU Extensions:
6707 unary-expression:
6708 __extension__ cast-expression
6709 __alignof__ unary-expression
6710 __alignof__ ( type-id )
6711 alignof unary-expression [C++0x]
6712 __real__ cast-expression
6713 __imag__ cast-expression
6714 && identifier
6715 sizeof ( type-id ) { initializer-list , [opt] }
6716 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
6717 __alignof__ ( type-id ) { initializer-list , [opt] }
6719 ADDRESS_P is true iff the unary-expression is appearing as the
6720 operand of the `&' operator. CAST_P is true if this expression is
6721 the target of a cast.
6723 Returns a representation of the expression. */
6725 static tree
6728 {
6732 /* Peek at the next token. */
6734 /* Some keywords give away the kind of expression. */
6736 {
6740 {
6743 {
6746 location_t first_loc;
6749 /* Consume the token. */
6752 /* Parse the operand. */
6757 else
6758 {
6759 /* ISO C++ defines alignof only with types, not with
6760 expressions. So pedwarn if alignof is used with a non-
6761 type expression. However, __alignof__ is ok. */
6764 "ISO C++ does not allow %<alignof%> "
6768 }
6769 /* For SIZEOF_EXPR, just issue diagnostics, but keep
6770 SIZEOF_EXPR with the original operand. */
6772 {
6774 {
6776 {
6779 error_mark_node));
6781 }
6782 else
6786 }
6788 }
6790 }
6799 {
6800 /* The saved value of the PEDANTIC flag. */
6802 tree expr;
6804 /* Save away the PEDANTIC flag. */
6806 /* Parse the cast-expression. */
6808 /* Restore the PEDANTIC flag. */
6812 }
6816 {
6817 tree expression;
6819 /* Consume the `__real__' or `__imag__' token. */
6821 /* Parse the cast-expression. */
6823 /* Create the complete representation. */
6827 expression,
6828 tf_warning_or_error);
6829 }
6837 {
6838 tree expr;
6848 parser->type_definition_forbidden_message
6851 saved_integral_constant_expression_p
6853 saved_non_integral_constant_expression_p
6857 saved_greater_than_is_operator_p
6867 parser->greater_than_is_operator_p
6870 parser->integral_constant_expression_p
6872 parser->non_integral_constant_expression_p
6879 }
6883 }
6884 }
6886 /* Look for the `:: new' and `:: delete', which also signal the
6887 beginning of a new-expression, or delete-expression,
6888 respectively. If the next token is `::', then it might be one of
6889 these. */
6891 {
6894 /* See if the token after the `::' is one of the keywords in
6895 which we're interested. */
6897 /* If it's `new', we have a new-expression. */
6900 /* Similarly, for `delete'. */
6903 }
6905 /* Look for a unary operator. */
6907 /* The `++' and `--' operators can be handled similarly, even though
6908 they are not technically unary-operators in the grammar. */
6910 {
6915 /* Handle the GNU address-of-label extension. */
6918 {
6919 tree identifier;
6920 tree expression;
6923 /* Consume the '&&' token. */
6925 /* Look for the identifier. */
6927 /* Create an expression representing the address. */
6930 NIC_ADDR_LABEL))
6933 }
6934 }
6936 {
6937 tree cast_expression;
6943 /* Consume the operator token. */
6945 /* Parse the cast-expression. */
6946 cast_expression
6951 pidk);
6952 /* Now, build an appropriate representation. */
6954 {
6958 RO_UNARY_STAR,
6959 complain);
6964 /* Fall through. */
6967 cast_expression,
6968 complain);
6975 /* Fall through. */
6985 }
6989 non_constant_p))
6993 }
6997 decltype_p,
6998 pidk);
6999 }
7004 {
7007 }
7009 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
7010 unary-operator, the corresponding tree code is returned. */
7012 static enum tree_code
7014 {
7016 {
7037 }
7038 }
7040 /* Parse a new-expression.
7042 new-expression:
7043 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
7044 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
7046 Returns a representation of the expression. */
7048 static tree
7050 {
7053 tree type;
7056 tree ret;
7058 /* Look for the optional `::' operator. */
7059 global_scope_p
7063 /* Look for the `new' operator. */
7065 /* There's no easy way to tell a new-placement from the
7066 `( type-id )' construct. */
7068 /* Look for a new-placement. */
7070 /* If that didn't work out, there's no new-placement. */
7072 {
7076 }
7078 /* If the next token is a `(', then we have a parenthesized
7079 type-id. */
7081 {
7085 /* Consume the `('. */
7088 /* Parse the type-id. */
7089 parser->type_definition_forbidden_message
7094 /* Look for the closing `)'. */
7097 /* There should not be a direct-new-declarator in this production,
7098 but GCC used to allowed this, so we check and emit a sensible error
7099 message for this case. */
7101 {
7107 }
7108 }
7109 /* Otherwise, there must be a new-type-id. */
7110 else
7113 /* If the next token is a `(' or '{', then we have a new-initializer. */
7117 else
7120 /* A new-expression may not appear in an integral constant
7121 expression. */
7124 else
7125 {
7126 /* Create a representation of the new-expression. */
7128 tf_warning_or_error);
7129 }
7137 }
7139 /* Parse a new-placement.
7141 new-placement:
7142 ( expression-list )
7144 Returns the same representation as for an expression-list. */
7148 {
7151 /* Parse the expression-list. */
7152 expression_list = (cp_parser_parenthesized_expression_list
7158 }
7160 /* Parse a new-type-id.
7162 new-type-id:
7163 type-specifier-seq new-declarator [opt]
7165 Returns the TYPE allocated. If the new-type-id indicates an array
7166 type, *NELTS is set to the number of elements in the last array
7167 bound; the TYPE will not include the last array bound. */
7169 static tree
7171 {
7172 cp_decl_specifier_seq type_specifier_seq;
7178 /* The type-specifier sequence must not contain type definitions.
7179 (It cannot contain declarations of new types either, but if they
7180 are not definitions we will catch that because they are not
7181 complete.) */
7183 parser->type_definition_forbidden_message
7185 /* Parse the type-specifier-seq. */
7189 /* Restore the old message. */
7195 /* Parse the new-declarator. */
7198 /* Determine the number of elements in the last array dimension, if
7199 any. */
7201 /* Skip down to the last array dimension. */
7206 {
7209 }
7214 {
7217 }
7220 {
7227 else
7229 }
7232 }
7234 /* Parse an (optional) new-declarator.
7236 new-declarator:
7237 ptr-operator new-declarator [opt]
7238 direct-new-declarator
7240 Returns the declarator. */
7244 {
7247 cp_cv_quals cv_quals;
7249 /* We don't know if there's a ptr-operator next, or not. */
7251 /* Look for a ptr-operator. */
7253 /* If that worked, look for more new-declarators. */
7255 {
7258 /* Parse another optional declarator. */
7261 declarator = cp_parser_make_indirect_declarator
7265 }
7267 /* If the next token is a `[', there is a direct-new-declarator. */
7272 }
7274 /* Parse a direct-new-declarator.
7276 direct-new-declarator:
7277 [ expression ]
7278 direct-new-declarator [constant-expression]
7280 */
7284 {
7288 {
7289 tree expression;
7292 /* Look for the opening `['. */
7297 /* The standard requires that the expression have integral
7298 type. DR 74 adds enumeration types. We believe that the
7299 real intent is that these expressions be handled like the
7300 expression in a `switch' condition, which also allows
7301 classes with a single conversion to integral or
7302 enumeration type. */
7304 {
7305 expression
7307 expression,
7310 {
7312 "expression in new-declarator must have integral "
7315 }
7316 }
7318 /* Look for the closing `]'. */
7321 /* Add this bound to the declarator. */
7324 /* If the next token is not a `[', then there are no more
7325 bounds. */
7328 }
7331 }
7333 /* Parse a new-initializer.
7335 new-initializer:
7336 ( expression-list [opt] )
7337 braced-init-list
7339 Returns a representation of the expression-list. */
7343 {
7347 {
7348 tree t;
7354 }
7355 else
7356 expression_list = (cp_parser_parenthesized_expression_list
7362 }
7364 /* Parse a delete-expression.
7366 delete-expression:
7367 :: [opt] delete cast-expression
7368 :: [opt] delete [ ] cast-expression
7370 Returns a representation of the expression. */
7372 static tree
7374 {
7377 tree expression;
7379 /* Look for the optional `::' operator. */
7380 global_scope_p
7384 /* Look for the `delete' keyword. */
7386 /* See if the array syntax is in use. */
7388 {
7389 /* Consume the `[' token. */
7391 /* Look for the `]' token. */
7393 /* Remember that this is the `[]' construct. */
7395 }
7396 else
7399 /* Parse the cast-expression. */
7402 /* A delete-expression may not appear in an integral constant
7403 expression. */
7408 tf_warning_or_error);
7409 }
7411 /* Returns true if TOKEN may start a cast-expression and false
7412 otherwise. */
7414 static bool
7416 {
7419 {
7459 /* In ((type ()) () the last () isn't a valid cast-expression,
7460 so the whole must be parsed as postfix-expression. */
7464 /* '[' may start a primary-expression in obj-c++. */
7470 }
7471 }
7473 /* Parse a cast-expression.
7475 cast-expression:
7476 unary-expression
7477 ( type-id ) cast-expression
7479 ADDRESS_P is true iff the unary-expression is appearing as the
7480 operand of the `&' operator. CAST_P is true if this expression is
7481 the target of a cast.
7483 Returns a representation of the expression. */
7485 static tree
7488 {
7489 /* If it's a `(', then we might be looking at a cast. */
7491 {
7497 /* There's no way to know yet whether or not this is a cast.
7498 For example, `(int (3))' is a unary-expression, while `(int)
7499 3' is a cast. So, we resort to parsing tentatively. */
7501 /* Types may not be defined in a cast. */
7503 parser->type_definition_forbidden_message
7505 /* Consume the `('. */
7507 /* A very tricky bit is that `(struct S) { 3 }' is a
7508 compound-literal (which we permit in C++ as an extension).
7509 But, that construct is not a cast-expression -- it is a
7510 postfix-expression. (The reason is that `(struct S) { 3 }.i'
7511 is legal; if the compound-literal were a cast-expression,
7512 you'd need an extra set of parentheses.) But, if we parse
7513 the type-id, and it happens to be a class-specifier, then we
7514 will commit to the parse at that point, because we cannot
7515 undo the action that is done when creating a new class. So,
7516 then we cannot back up and do a postfix-expression.
7518 Therefore, we scan ahead to the closing `)', and check to see
7519 if the token after the `)' is a `{'. If so, we are not
7520 looking at a cast-expression.
7522 Save tokens so that we can put them back. */
7524 /* Skip tokens until the next token is a closing parenthesis.
7525 If we find the closing `)', and the next token is a `{', then
7526 we are looking at a compound-literal. */
7527 compound_literal_p
7531 /* Roll back the tokens we skipped. */
7533 /* If we were looking at a compound-literal, simulate an error
7534 so that the call to cp_parser_parse_definitely below will
7535 fail. */
7538 else
7539 {
7542 /* Look for the type-id. */
7544 /* Look for the closing `)'. */
7547 }
7549 /* Restore the saved message. */
7552 /* At this point this can only be either a cast or a
7553 parenthesized ctor such as `(T ())' that looks like a cast to
7554 function returning T. */
7557 {
7563 pidk);
7565 /* Warn about old-style casts, if so requested. */
7567 && !in_system_header
7572 /* Only type conversions to integral or enumeration types
7573 can be used in constant-expressions. */
7576 NIC_CAST))
7579 /* Perform the cast. */
7582 }
7583 else
7585 }
7587 /* If we get here, then it's not a cast, so it must be a
7588 unary-expression. */
7591 }
7593 /* Parse a binary expression of the general form:
7595 pm-expression:
7596 cast-expression
7597 pm-expression .* cast-expression
7598 pm-expression ->* cast-expression
7600 multiplicative-expression:
7601 pm-expression
7602 multiplicative-expression * pm-expression
7603 multiplicative-expression / pm-expression
7604 multiplicative-expression % pm-expression
7606 additive-expression:
7607 multiplicative-expression
7608 additive-expression + multiplicative-expression
7609 additive-expression - multiplicative-expression
7611 shift-expression:
7612 additive-expression
7613 shift-expression << additive-expression
7614 shift-expression >> additive-expression
7616 relational-expression:
7617 shift-expression
7618 relational-expression < shift-expression
7619 relational-expression > shift-expression
7620 relational-expression <= shift-expression
7621 relational-expression >= shift-expression
7623 GNU Extension:
7625 relational-expression:
7626 relational-expression <? shift-expression
7627 relational-expression >? shift-expression
7629 equality-expression:
7630 relational-expression
7631 equality-expression == relational-expression
7632 equality-expression != relational-expression
7634 and-expression:
7635 equality-expression
7636 and-expression & equality-expression
7638 exclusive-or-expression:
7639 and-expression
7640 exclusive-or-expression ^ and-expression
7642 inclusive-or-expression:
7643 exclusive-or-expression
7644 inclusive-or-expression | exclusive-or-expression
7646 logical-and-expression:
7647 inclusive-or-expression
7648 logical-and-expression && inclusive-or-expression
7650 logical-or-expression:
7651 logical-and-expression
7652 logical-or-expression || logical-and-expression
7654 All these are implemented with a single function like:
7656 binary-expression:
7657 simple-cast-expression
7658 binary-expression <token> binary-expression
7660 CAST_P is true if this expression is the target of a cast.
7662 The binops_by_token map is used to get the tree codes for each <token> type.
7663 binary-expressions are associated according to a precedence table. */
7665 #define TOKEN_PRECEDENCE(token) \
7666 (((token->type == CPP_GREATER \
7667 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
7668 && !parser->greater_than_is_operator_p) \
7669 ? PREC_NOT_OPERATOR \
7670 : binops_by_token[token->type].prec)
7672 static tree
7678 {
7679 cp_parser_expression_stack stack;
7681 cp_parser_expression_stack_entry current;
7682 tree rhs;
7686 tree overload;
7688 /* Parse the first expression. */
7698 {
7699 /* Get an operator token. */
7705 {
7707 "%<>>%> operator is treated"
7711 }
7715 /* Popping an entry off the stack means we completed a subexpression:
7716 - either we found a token which is not an operator (`>' where it is not
7717 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
7718 will happen repeatedly;
7719 - or, we found an operator which has lower priority. This is the case
7720 where the recursive descent *ascends*, as in `3 * 4 + 5' after
7721 parsing `3 * 4'. */
7723 {
7726 else
7728 }
7730 get_rhs:
7734 /* We used the operator token. */
7737 /* For "false && x" or "true || x", x will never be executed;
7738 disable warnings while evaluating it. */
7744 /* Extract another operand. It may be the RHS of this expression
7745 or the LHS of a new, higher priority expression. */
7749 /* Get another operator token. Look up its precedence to avoid
7750 building a useless (immediately popped) stack entry for common
7751 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
7755 {
7756 /* ... and prepare to parse the RHS of the new, higher priority
7757 expression. Since precedence levels on the stack are
7758 monotonically increasing, we do not have to care about
7759 stack overflows. */
7768 pop:
7770 /* If the stack is not empty, we have parsed into LHS the right side
7771 (`4' in the example above) of an expression we had suspended.
7772 We can use the information on the stack to recover the LHS (`3')
7773 from the stack together with the tree code (`MULT_EXPR'), and
7774 the precedence of the higher level subexpression
7775 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
7776 which will be used to actually build the additive expression. */
7781 }
7783 /* Undo the disabling of warnings done above. */
7790 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
7791 ERROR_MARK for everything that is not a binary expression.
7792 This makes warn_about_parentheses miss some warnings that
7793 involve unary operators. For unary expressions we should
7794 pass the correct tree_code unless the unary expression was
7795 surrounded by parentheses.
7796 */
7803 else
7812 /* If the binary operator required the use of an overloaded operator,
7813 then this expression cannot be an integral constant-expression.
7814 An overloaded operator can be used even if both operands are
7815 otherwise permissible in an integral constant-expression if at
7816 least one of the operands is of enumeration type. */
7820 NIC_OVERLOADED))
7822 }
7825 }
7827 static tree
7832 {
7835 }
7837 /* Parse the `? expression : assignment-expression' part of a
7838 conditional-expression. The LOGICAL_OR_EXPR is the
7839 logical-or-expression that started the conditional-expression.
7840 Returns a representation of the entire conditional-expression.
7842 This routine is used by cp_parser_assignment_expression.
7844 ? expression : assignment-expression
7846 GNU Extensions:
7848 ? : assignment-expression */
7850 static tree
7852 {
7853 tree expr;
7854 tree assignment_expr;
7858 /* Consume the `?' token. */
7863 {
7866 /* Implicit true clause. */
7870 }
7871 else
7872 {
7875 /* Parse the expression. */
7878 c_inhibit_evaluation_warnings +=
7882 }
7884 /* The next token should be a `:'. */
7886 /* Parse the assignment-expression. */
7890 /* Build the conditional-expression. */
7892 expr,
7893 assignment_expr,
7894 tf_warning_or_error);
7895 }
7897 /* Parse an assignment-expression.
7899 assignment-expression:
7900 conditional-expression
7901 logical-or-expression assignment-operator assignment_expression
7902 throw-expression
7904 CAST_P is true if this expression is the target of a cast.
7905 DECLTYPE_P is true if this expression is the operand of decltype.
7907 Returns a representation for the expression. */
7909 static tree
7912 {
7913 tree expr;
7915 /* If the next token is the `throw' keyword, then we're looking at
7916 a throw-expression. */
7919 /* Otherwise, it must be that we are looking at a
7920 logical-or-expression. */
7921 else
7922 {
7923 /* Parse the binary expressions (logical-or-expression). */
7925 decltype_p,
7927 /* If the next token is a `?' then we're actually looking at a
7928 conditional-expression. */
7931 else
7932 {
7935 /* If it's an assignment-operator, we're using the second
7936 production. */
7937 enum tree_code assignment_operator
7940 {
7942 location_t saved_input_location;
7944 /* Parse the right-hand side of the assignment. */
7950 /* An assignment may not appear in a
7951 constant-expression. */
7953 NIC_ASSIGNMENT))
7955 /* Build the assignment expression. Its default
7956 location is the location of the '=' token. */
7960 assignment_operator,
7961 rhs,
7964 }
7965 }
7966 }
7969 }
7971 static tree
7974 {
7977 }
7979 /* Parse an (optional) assignment-operator.
7981 assignment-operator: one of
7982 = *= /= %= += -= >>= <<= &= ^= |=
7984 GNU Extension:
7986 assignment-operator: one of
7987 <?= >?=
7989 If the next token is an assignment operator, the corresponding tree
7990 code is returned, and the token is consumed. For example, for
7991 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
7992 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
7993 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
7994 operator, ERROR_MARK is returned. */
7996 static enum tree_code
7998 {
8002 /* Peek at the next token. */
8006 {
8052 /* Nothing else is an assignment operator. */
8054 }
8056 /* If it was an assignment operator, consume it. */
8061 }
8063 /* Parse an expression.
8065 expression:
8066 assignment-expression
8067 expression , assignment-expression
8069 CAST_P is true if this expression is the target of a cast.
8070 DECLTYPE_P is true if this expression is the immediate operand of decltype,
8071 except possibly parenthesized or on the RHS of a comma (N3276).
8073 Returns a representation of the expression. */
8075 static tree
8078 {
8083 {
8084 tree assignment_expression;
8086 /* Parse the next assignment-expression. */
8087 assignment_expression
8090 /* We don't create a temporary for a call that is the immediate operand
8091 of decltype or on the RHS of a comma. But when we see a comma, we
8092 need to create a temporary for a call on the LHS. */
8097 assignment_expression
8101 /* If this is the first assignment-expression, we can just
8102 save it away. */
8105 else
8107 assignment_expression,
8109 /* If the next token is not a comma, then we are done with the
8110 expression. */
8113 /* Consume the `,'. */
8116 /* A comma operator cannot appear in a constant-expression. */
8119 }
8122 }
8126 {
8128 }
8130 /* Parse a constant-expression.
8132 constant-expression:
8133 conditional-expression
8135 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
8136 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
8137 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
8138 is false, NON_CONSTANT_P should be NULL. */
8140 static tree
8144 {
8148 tree expression;
8150 /* It might seem that we could simply parse the
8151 conditional-expression, and then check to see if it were
8152 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
8153 one that the compiler can figure out is constant, possibly after
8154 doing some simplifications or optimizations. The standard has a
8155 precise definition of constant-expression, and we must honor
8156 that, even though it is somewhat more restrictive.
8158 For example:
8160 int i[(2, 3)];
8162 is not a legal declaration, because `(2, 3)' is not a
8163 constant-expression. The `,' operator is forbidden in a
8164 constant-expression. However, GCC's constant-folding machinery
8165 will fold this operation to an INTEGER_CST for `3'. */
8167 /* Save the old settings. */
8169 saved_allow_non_integral_constant_expression_p
8172 /* We are now parsing a constant-expression. */
8174 parser->allow_non_integral_constant_expression_p
8177 /* Although the grammar says "conditional-expression", we parse an
8178 "assignment-expression", which also permits "throw-expression"
8179 and the use of assignment operators. In the case that
8180 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
8181 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
8182 actually essential that we look for an assignment-expression.
8183 For example, cp_parser_initializer_clauses uses this function to
8184 determine whether a particular assignment-expression is in fact
8185 constant. */
8187 /* Restore the old settings. */
8188 parser->integral_constant_expression_p
8190 parser->allow_non_integral_constant_expression_p
8193 {
8194 /* Require an rvalue constant expression here; that's what our
8195 callers expect. Reference constant expressions are handled
8196 separately in e.g. cp_parser_template_argument. */
8201 }
8204 parser->non_integral_constant_expression_p
8208 }
8210 /* Parse __builtin_offsetof.
8212 offsetof-expression:
8213 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
8215 offsetof-member-designator:
8216 id-expression
8217 | offsetof-member-designator "." id-expression
8218 | offsetof-member-designator "[" expression "]"
8219 | offsetof-member-designator "->" id-expression */
8221 static tree
8223 {
8226 cp_id_kind dummy;
8229 /* We're about to accept non-integral-constant things, but will
8230 definitely yield an integral constant expression. Save and
8231 restore these values around our local parsing. */
8235 /* Consume the "__builtin_offsetof" token. */
8237 /* Consume the opening `('. */
8239 /* Parse the type-id. */
8241 /* Look for the `,'. */
8245 /* Build the (type *)null that begins the traditional offsetof macro. */
8247 tf_warning_or_error);
8249 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
8253 {
8256 {
8258 /* offsetof-member-designator "[" expression "]" */
8264 /* offsetof-member-designator "->" identifier */
8267 /* FALLTHRU */
8270 /* offsetof-member-designator "." identifier */
8278 /* Consume the ")" token. */
8283 /* Error. We know the following require will fail, but
8284 that gives the proper error message. */
8289 }
8290 }
8292 success:
8293 /* If we're processing a template, we can't finish the semantics yet.
8294 Otherwise we can fold the entire expression now. */
8297 else
8300 failure:
8305 }
8307 /* Parse a trait expression.
8309 Returns a representation of the expression, the underlying type
8310 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
8312 static tree
8314 {
8315 cp_trait_kind kind;
8318 cp_decl_specifier_seq decl_specs;
8321 {
8398 }
8400 /* Consume the token. */
8410 /* Build a trivial decl-specifier-seq. */
8414 /* Call grokdeclarator to figure out what type this is. */
8419 {
8427 /* Build a trivial decl-specifier-seq. */
8431 /* Call grokdeclarator to figure out what type this is. */
8434 }
8438 /* Complete the trait expression, which may mean either processing
8439 the trait expr now or saving it for template instantiation. */
8441 {
8450 }
8451 }
8453 /* Lambdas that appear in variable initializer or default argument scope
8454 get that in their mangling, so we need to record it. We might as well
8455 use the count for function and namespace scopes as well. */
8459 {
8460 tree t;
8465 static void
8467 {
8468 tree_int ti;
8470 /* Once we're inside a function, we ignore other scopes and just push
8471 the function again so that popping works properly. */
8478 {
8479 /* Don't reset the count if we're still in the same function. */
8482 }
8483 }
8485 static void
8487 {
8490 }
8492 static void
8494 {
8497 {
8500 }
8502 }
8504 /* Parse a lambda expression.
8506 lambda-expression:
8507 lambda-introducer lambda-declarator [opt] compound-statement
8509 Returns a representation of the expression. */
8511 static tree
8513 {
8515 tree type;
8525 /* We may be in the middle of deferred access check. Disable
8526 it now. */
8537 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
8540 /* Now that we've started the type, add the capture fields for any
8541 explicit captures. */
8544 {
8545 /* Inside the class, surrounding template-parameter-lists do not apply. */
8546 unsigned int saved_num_template_parameter_lists
8555 /* By virtue of defining a local class, a lambda expression has access to
8556 the private variables of enclosing classes. */
8565 /* The capture list was built up in reverse order; fix that now. */
8577 }
8581 /* This field is only used during parsing of the lambda. */
8584 /* This lambda shouldn't have any proxies left at this point. */
8586 /* And now that we're done, push proxies for an enclosing lambda. */
8591 else
8593 }
8595 /* Parse the beginning of a lambda expression.
8597 lambda-introducer:
8598 [ lambda-capture [opt] ]
8600 LAMBDA_EXPR is the current representation of the lambda expression. */
8602 static void
8604 {
8605 /* Need commas after the first capture. */
8608 /* Eat the leading `['. */
8611 /* Record default capture mode. "[&" "[=" "[&," "[=," */
8619 {
8622 }
8625 {
8627 tree capture_id;
8628 tree capture_init_expr;
8632 enum capture_kind_type
8633 {
8634 BY_COPY,
8635 BY_REFERENCE
8636 };
8640 {
8643 }
8647 else
8650 /* Possibly capture `this'. */
8652 {
8662 explicit_init_p);
8664 }
8666 /* Remember whether we want to capture as a reference or not. */
8668 {
8671 }
8673 /* Get the identifier. */
8678 /* Would be nice to have a cp_parser_skip_to_closing_x for general
8679 delimiters, but I modified this to stop on unnested ']' as well. It
8680 was already changed to stop on unnested '}', so the
8681 "closing_parenthesis" name is no more misleading with my change. */
8682 {
8688 }
8690 /* Find the initializer for this capture. */
8694 {
8696 /* An explicit initializer exists. */
8699 "lambda capture initializers "
8704 }
8705 else
8706 {
8709 /* Turn the identifier into an id-expression. */
8710 capture_init_expr
8711 = cp_parser_lookup_name
8713 capture_id,
8714 none_type,
8722 {
8725 }
8729 {
8732 capture_init_expr);
8735 }
8738 {
8741 capture_init_expr);
8744 }
8746 capture_init_expr
8747 = finish_id_expression
8749 capture_init_expr,
8761 }
8765 {
8770 capture_id);
8774 "capture of %qD redundant with by-reference capture "
8776 }
8779 capture_id,
8780 capture_init_expr,
8782 explicit_init_p);
8783 }
8786 }
8788 /* Parse the (optional) middle of a lambda expression.
8790 lambda-declarator:
8791 ( parameter-declaration-clause [opt] )
8792 attribute-specifier [opt]
8793 mutable [opt]
8794 exception-specification [opt]
8795 lambda-return-type-clause [opt]
8797 LAMBDA_EXPR is the current representation of the lambda expression. */
8799 static bool
8801 {
8802 /* 5.1.1.4 of the standard says:
8803 If a lambda-expression does not include a lambda-declarator, it is as if
8804 the lambda-declarator were ().
8805 This means an empty parameter list, no attributes, and no exception
8806 specification. */
8810 tree t;
8812 /* The lambda-declarator is optional, but must begin with an opening
8813 parenthesis if present. */
8815 {
8820 /* Parse parameters. */
8823 /* Default arguments shall not be specified in the
8824 parameter-declaration-clause of a lambda-declarator. */
8834 /* Parse optional `mutable' keyword. */
8836 {
8839 }
8841 /* Parse optional exception specification. */
8844 /* Parse optional trailing return type. */
8846 {
8850 }
8852 /* The function parameters must be in scope all the way until after the
8853 trailing-return-type in case of decltype. */
8858 }
8860 /* Create the function call operator.
8862 Messing with declarators like this is no uglier than building up the
8863 FUNCTION_DECL by hand, and this is less likely to get out of sync with
8864 other code. */
8865 {
8866 cp_decl_specifier_seq return_type_specs;
8868 tree fco;
8875 else
8876 /* Maybe we will deduce the return type later. */
8882 sfk_none);
8887 VIRT_SPEC_UNSPECIFIED,
8888 REF_QUAL_NONE,
8889 exception_spec,
8894 declarator,
8895 attributes);
8897 {
8900 /* Give the object parameter a different name. */
8902 }
8909 }
8910 }
8912 /* Parse the body of a lambda expression, which is simply
8914 compound-statement
8916 but which requires special handling.
8917 LAMBDA_EXPR is the current representation of the lambda expression. */
8919 static void
8921 {
8926 else
8927 /* Still increment function_depth so that we don't GC in the
8928 middle of an expression. */
8930 /* Clear this in case we're in the middle of a default argument. */
8933 /* Finish the function call operator
8934 - class_specifier
8935 + late_parsing_for_member
8936 + function_definition_after_declarator
8937 + ctor_initializer_opt_and_function_body */
8938 {
8940 tree body;
8942 tree compound_stmt;
8943 tree cap;
8945 /* Let the front end know that we are going to be defining this
8946 function. */
8948 NULL_TREE,
8957 /* Push the proxies for any explicit captures. */
8964 /* 5.1.1.4 of the standard says:
8965 If a lambda-expression does not include a trailing-return-type, it
8966 is as if the trailing-return-type denotes the following type:
8967 * if the compound-statement is of the form
8968 { return attribute-specifier [opt] expression ; }
8969 the type of the returned expression after lvalue-to-rvalue
8970 conversion (_conv.lval_ 4.1), array-to-pointer conversion
8971 (_conv.array_ 4.2), and function-to-pointer conversion
8972 (_conv.func_ 4.3);
8973 * otherwise, void. */
8975 /* In a lambda that has neither a lambda-return-type-clause
8976 nor a deducible form, errors should be reported for return statements
8977 in the body. Since we used void as the placeholder return type, parsing
8978 the body as usual will give such desired behavior. */
8982 {
8986 /* Parse tentatively in case there's more after the initial return
8987 statement. */
8998 {
9002 /* Will get error here if type not deduced yet. */
9006 }
9007 }
9010 {
9015 }
9019 out:
9023 /* Finish the function and generate code for it if necessary. */
9025 }
9030 else
9032 }
9034 /* Statements [gram.stmt.stmt] */
9036 /* Parse a statement.
9038 statement:
9039 labeled-statement
9040 expression-statement
9041 compound-statement
9042 selection-statement
9043 iteration-statement
9044 jump-statement
9045 declaration-statement
9046 try-block
9048 C++11:
9050 statement:
9051 labeled-statement
9052 attribute-specifier-seq (opt) expression-statement
9053 attribute-specifier-seq (opt) compound-statement
9054 attribute-specifier-seq (opt) selection-statement
9055 attribute-specifier-seq (opt) iteration-statement
9056 attribute-specifier-seq (opt) jump-statement
9057 declaration-statement
9058 attribute-specifier-seq (opt) try-block
9060 TM Extension:
9062 statement:
9063 atomic-statement
9065 IN_COMPOUND is true when the statement is nested inside a
9066 cp_parser_compound_statement; this matters for certain pragmas.
9068 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9069 is a (possibly labeled) if statement which is not enclosed in braces
9070 and has an else clause. This is used to implement -Wparentheses. */
9072 static void
9075 {
9080 restart:
9083 /* There is no statement yet. */
9089 /* In obj-c++, seing '[[' might be the either the beginning of
9090 c++11 attributes, or a nested objc-message-expression. So
9091 let's parse the c++11 attributes tentatively. */
9095 {
9098 }
9100 /* Peek at the next token. */
9102 /* Remember the location of the first token in the statement. */
9104 /* If this is a keyword, then that will often determine what kind of
9105 statement we have. */
9107 {
9111 {
9114 /* Looks like a labeled-statement with a case label.
9115 Parse the label, and then use tail recursion to parse
9116 the statement. */
9138 /* Objective-C++ exception-handling constructs. */
9152 /* This must be a namespace alias definition. */
9165 /* It might be a keyword like `int' that can start a
9166 declaration-statement. */
9168 }
9169 }
9171 {
9172 /* If the next token is a `:', then we are looking at a
9173 labeled-statement. */
9176 {
9177 /* Looks like a labeled-statement with an ordinary label.
9178 Parse the label, and then use tail recursion to parse
9179 the statement. */
9183 }
9184 }
9185 /* Anything that starts with a `{' must be a compound-statement. */
9188 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
9189 a statement all its own. */
9191 {
9192 /* Only certain OpenMP pragmas are attached to statements, and thus
9193 are considered statements themselves. All others are not. In
9194 the context of a compound, accept the pragma as a "statement" and
9195 return so that we can check for a close brace. Otherwise we
9196 require a real statement and must go back and read one. */
9202 }
9204 {
9207 }
9209 /* Everything else must be a declaration-statement or an
9210 expression-statement. Try for the declaration-statement
9211 first, unless we are looking at a `;', in which case we know that
9212 we have an expression-statement. */
9214 {
9216 {
9218 {
9219 /* Attributes should be parsed as part of the the
9220 declaration, so let's un-parse them. */
9223 }
9226 /* Try to parse the declaration-statement. */
9228 /* If that worked, we're done. */
9231 }
9232 /* Look for an expression-statement instead. */
9234 }
9236 /* Set the line number for the statement. */
9240 /* Note that for now, we don't do anything with c++11 statements
9241 parsed at this level. */
9244 OPT_Wattributes,
9246 }
9248 /* Parse the label for a labeled-statement, i.e.
9250 identifier :
9251 case constant-expression :
9252 default :
9254 GNU Extension:
9255 case constant-expression ... constant-expression : statement
9257 When a label is parsed without errors, the label is added to the
9258 parse tree by the finish_* functions, so this function doesn't
9259 have to return the label. */
9261 static void
9263 {
9268 /* The next token should be an identifier. */
9272 {
9275 }
9279 {
9281 {
9285 /* Consume the `case' token. */
9287 /* Parse the constant-expression. */
9290 NULL);
9294 {
9295 /* Consume the `...' token. */
9297 expr_hi =
9300 NULL);
9301 /* We don't need to emit warnings here, as the common code
9302 will do this for us. */
9303 }
9304 else
9309 else
9312 expr);
9313 }
9317 /* Consume the `default' token. */
9322 else
9327 /* Anything else must be an ordinary label. */
9330 }
9332 /* Require the `:' token. */
9335 /* An ordinary label may optionally be followed by attributes.
9336 However, this is only permitted if the attributes are then
9337 followed by a semicolon. This is because, for backward
9338 compatibility, when parsing
9339 lab: __attribute__ ((unused)) int i;
9340 we want the attribute to attach to "i", not "lab". */
9343 {
9344 tree attrs;
9351 ;
9352 else
9354 }
9360 }
9362 /* Parse an expression-statement.
9364 expression-statement:
9365 expression [opt] ;
9367 Returns the new EXPR_STMT -- or NULL_TREE if the expression
9368 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
9369 indicates whether this expression-statement is part of an
9370 expression statement. */
9372 static tree
9374 {
9378 /* If the next token is a ';', then there is no expression
9379 statement. */
9381 {
9385 {
9388 }
9389 }
9391 /* Give a helpful message for "A<T>::type t;" and the like. */
9394 {
9401 {
9402 /* A::A a; */
9407 }
9408 }
9410 /* Consume the final `;'. */
9415 /* This is the final expression statement of a statement
9416 expression. */
9420 else
9424 }
9426 /* Parse a compound-statement.
9428 compound-statement:
9429 { statement-seq [opt] }
9431 GNU extension:
9433 compound-statement:
9434 { label-declaration-seq [opt] statement-seq [opt] }
9436 label-declaration-seq:
9437 label-declaration
9438 label-declaration-seq label-declaration
9440 Returns a tree representing the statement. */
9442 static tree
9445 {
9446 tree compound_stmt;
9448 /* Consume the `{'. */
9455 /* Begin the compound-statement. */
9457 /* If the next keyword is `__label__' we have a label declaration. */
9460 /* Parse an (optional) statement-seq. */
9462 /* Finish the compound-statement. */
9464 /* Consume the `}'. */
9468 }
9470 /* Parse an (optional) statement-seq.
9472 statement-seq:
9473 statement
9474 statement-seq [opt] statement */
9476 static void
9478 {
9479 /* Scan statements until there aren't any more. */
9481 {
9484 /* If we are looking at a `}', then we have run out of
9485 statements; the same is true if we have reached the end
9486 of file, or have stumbled upon a stray '@end'. */
9493 /* If we are in a compound statement and find 'else' then
9494 something went wrong. */
9496 {
9499 else
9500 {
9503 }
9504 }
9506 /* Parse the statement. */
9508 }
9509 }
9511 /* Parse a selection-statement.
9513 selection-statement:
9514 if ( condition ) statement
9515 if ( condition ) statement else statement
9516 switch ( condition ) statement
9518 Returns the new IF_STMT or SWITCH_STMT.
9520 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9521 is a (possibly labeled) if statement which is not enclosed in
9522 braces and has an else clause. This is used to implement
9523 -Wparentheses. */
9525 static tree
9527 {
9534 /* Peek at the next token. */
9537 /* See what kind of keyword it is. */
9540 {
9543 {
9544 tree statement;
9545 tree condition;
9547 /* Look for the `('. */
9549 {
9552 }
9554 /* Begin the selection-statement. */
9557 else
9560 /* Parse the condition. */
9562 /* Look for the `)'. */
9568 {
9572 /* Add the condition. */
9575 /* Parse the then-clause. */
9579 {
9587 }
9588 else
9594 /* If the next token is `else', parse the else-clause. */
9596 RID_ELSE))
9597 {
9598 /* Consume the `else' keyword. */
9601 /* Parse the else-clause. */
9603 {
9604 location_t loc;
9611 }
9612 else
9617 /* If we are currently parsing a then-clause, then
9618 IF_P will not be NULL. We set it to true to
9619 indicate that this if statement has an else clause.
9620 This may trigger the Wparentheses warning below
9621 when we get back up to the parent if statement. */
9624 }
9625 else
9626 {
9627 /* This if statement does not have an else clause. If
9628 NESTED_IF is true, then the then-clause is an if
9629 statement which does have an else clause. We warn
9630 about the potential ambiguity. */
9633 "suggest explicit braces to avoid ambiguous"
9635 }
9637 /* Now we're all done with the if-statement. */
9639 }
9640 else
9641 {
9645 /* Add the condition. */
9648 /* Parse the body of the switch-statement. */
9657 /* Now we're all done with the switch-statement. */
9659 }
9662 }
9668 }
9669 }
9671 /* Parse a condition.
9673 condition:
9674 expression
9675 type-specifier-seq declarator = initializer-clause
9676 type-specifier-seq declarator braced-init-list
9678 GNU Extension:
9680 condition:
9681 type-specifier-seq declarator asm-specification [opt]
9682 attributes [opt] = assignment-expression
9684 Returns the expression that should be tested. */
9686 static tree
9688 {
9689 cp_decl_specifier_seq type_specifiers;
9693 /* Try the declaration first. */
9695 /* New types are not allowed in the type-specifier-seq for a
9696 condition. */
9698 parser->type_definition_forbidden_message
9700 /* Parse the type-specifier-seq. */
9702 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
9705 /* Restore the saved message. */
9707 /* If all is well, we might be looking at a declaration. */
9709 {
9710 tree decl;
9711 tree asm_specification;
9712 tree attributes;
9716 /* Parse the declarator. */
9721 /* Parse the attributes. */
9723 /* Parse the asm-specification. */
9725 /* If the next token is not an `=' or '{', then we might still be
9726 looking at an expression. For example:
9728 if (A(a).x)
9730 looks like a decl-specifier-seq and a declarator -- but then
9731 there is no `=', so this is an expression. */
9736 /* If we did see an `=' or '{', then we are looking at a declaration
9737 for sure. */
9739 {
9740 tree pushed_scope;
9744 /* Create the declaration. */
9750 /* Parse the initializer. */
9752 {
9756 }
9757 else
9758 {
9759 /* Consume the `='. */
9762 }
9766 /* Process the initializer. */
9769 asm_specification,
9770 flags);
9776 }
9777 }
9778 /* If we didn't even get past the declarator successfully, we are
9779 definitely not looking at a declaration. */
9780 else
9783 /* Otherwise, we are looking at an expression. */
9785 }
9787 /* Parses a for-statement or range-for-statement until the closing ')',
9788 not included. */
9790 static tree
9792 {
9796 /* Begin the for-statement. */
9799 /* Parse the initialization. */
9804 else
9806 }
9808 static tree
9810 {
9811 /* Normal for loop */
9814 tree stmt;
9817 /* The for-init-statement has already been parsed in
9818 cp_parser_for_init_statement, so no work is needed here. */
9821 /* If there's a condition, process it. */
9825 /* Look for the `;'. */
9828 /* If there's an expression, process it. */
9834 }
9836 /* Tries to parse a range-based for-statement:
9838 range-based-for:
9839 decl-specifier-seq declarator : expression
9841 The decl-specifier-seq declarator and the `:' are already parsed by
9842 cp_parser_for_init_statement. If processing_template_decl it returns a
9843 newly created RANGE_FOR_STMT; if not, it is converted to a
9844 regular FOR_STMT. */
9846 static tree
9848 {
9852 {
9855 }
9856 else
9859 /* If in template, STMT is converted to a normal for-statement
9860 at instantiation. If not, it is done just ahead. */
9862 {
9868 /* do_auto_deduction doesn't mess with template init-lists. */
9871 }
9872 else
9873 {
9876 }
9878 }
9880 /* Subroutine of cp_convert_range_for: given the initializer expression,
9881 builds up the range temporary. */
9883 static tree
9885 {
9888 /* Find out the type deduced by the declaration
9889 `auto &&__range = range_expr'. */
9894 /* Create the __range variable. */
9901 }
9903 /* Used by cp_parser_range_for in template context: we aren't going to
9904 do a full conversion yet, but we still need to resolve auto in the
9905 type of the for-range-declaration if present. This is basically
9906 a shortcut version of cp_convert_range_for. */
9908 static void
9910 {
9913 {
9916 iter_type = (cp_parser_perform_range_for_lookup
9920 tf_warning_or_error);
9923 }
9924 }
9926 /* Converts a range-based for-statement into a normal
9927 for-statement, as per the definition.
9929 for (RANGE_DECL : RANGE_EXPR)
9930 BLOCK
9932 should be equivalent to:
9934 {
9935 auto &&__range = RANGE_EXPR;
9936 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
9937 __begin != __end;
9938 ++__begin)
9939 {
9940 RANGE_DECL = *__begin;
9941 BLOCK
9942 }
9943 }
9945 If RANGE_EXPR is an array:
9946 BEGIN_EXPR = __range
9947 END_EXPR = __range + ARRAY_SIZE(__range)
9948 Else if RANGE_EXPR has a member 'begin' or 'end':
9949 BEGIN_EXPR = __range.begin()
9950 END_EXPR = __range.end()
9951 Else:
9952 BEGIN_EXPR = begin(__range)
9953 END_EXPR = end(__range);
9955 If __range has a member 'begin' but not 'end', or vice versa, we must
9956 still use the second alternative (it will surely fail, however).
9957 When calling begin()/end() in the third alternative we must use
9958 argument dependent lookup, but always considering 'std' as an associated
9959 namespace. */
9961 tree
9963 {
9969 /* If an error happened previously do nothing or else a lot of
9970 unhelpful errors would be issued. */
9972 else
9973 {
9974 tree range_temp;
9978 /* Can't bind a reference to an array of runtime bound. */
9980 else
9981 {
9986 LOOKUP_ONLYCONVERTING);
9988 }
9991 }
9993 /* The new for initialization statement. */
10001 LOOKUP_ONLYCONVERTING);
10010 LOOKUP_ONLYCONVERTING);
10014 /* The new for condition. */
10021 /* The new increment expression. */
10024 tf_warning_or_error);
10027 /* The declaration is initialized with *__begin inside the loop body. */
10030 tf_warning_or_error),
10032 LOOKUP_ONLYCONVERTING);
10035 }
10037 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
10038 We need to solve both at the same time because the method used
10039 depends on the existence of members begin or end.
10040 Returns the type deduced for the iterator expression. */
10042 static tree
10044 {
10046 {
10049 }
10052 {
10057 }
10059 {
10060 /* If RANGE is an array, we will use pointer arithmetic. */
10063 range,
10067 }
10068 else
10069 {
10070 /* If it is not an array, we must do a bit of magic. */
10080 tf_warning_or_error);
10083 tf_warning_or_error);
10086 {
10087 /* Use the member functions. */
10090 else
10096 else
10099 }
10100 else
10101 {
10102 /* Use global functions with ADL. */
10110 tf_warning_or_error);
10112 tf_warning_or_error);
10115 tf_warning_or_error);
10117 tf_warning_or_error);
10120 }
10122 /* Last common checks. */
10124 {
10125 /* If one of the expressions is an error do no more checks. */
10128 }
10129 else
10130 {
10132 /* The unqualified type of the __begin and __end temporaries should
10133 be the same, as required by the multiple auto declaration. */
10139 }
10140 }
10141 }
10143 /* Helper function for cp_parser_perform_range_for_lookup.
10144 Builds a tree for RANGE.IDENTIFIER(). */
10146 static tree
10148 {
10161 tf_warning_or_error);
10164 }
10166 /* Parse an iteration-statement.
10168 iteration-statement:
10169 while ( condition ) statement
10170 do statement while ( expression ) ;
10171 for ( for-init-statement condition [opt] ; expression [opt] )
10172 statement
10174 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
10176 static tree
10178 {
10181 tree statement;
10184 /* Peek at the next token. */
10189 /* Remember whether or not we are already within an iteration
10190 statement. */
10193 /* See what kind of keyword it is. */
10196 {
10198 {
10199 tree condition;
10201 /* Begin the while-statement. */
10203 /* Look for the `('. */
10205 /* Parse the condition. */
10208 /* Look for the `)'. */
10210 /* Parse the dependent statement. */
10214 /* We're done with the while-statement. */
10216 }
10220 {
10221 tree expression;
10223 /* Begin the do-statement. */
10225 /* Parse the body of the do-statement. */
10230 /* Look for the `while' keyword. */
10232 /* Look for the `('. */
10234 /* Parse the expression. */
10236 /* We're done with the do-statement. */
10238 /* Look for the `)'. */
10240 /* Look for the `;'. */
10242 }
10246 {
10247 /* Look for the `('. */
10252 /* Look for the `)'. */
10255 /* Parse the body of the for-statement. */
10260 /* We're done with the for-statement. */
10262 }
10269 }
10272 }
10274 /* Parse a for-init-statement or the declarator of a range-based-for.
10275 Returns true if a range-based-for declaration is seen.
10277 for-init-statement:
10278 expression-statement
10279 simple-declaration */
10281 static bool
10283 {
10284 /* If the next token is a `;', then we have an empty
10285 expression-statement. Grammatically, this is also a
10286 simple-declaration, but an invalid one, because it does not
10287 declare anything. Therefore, if we did not handle this case
10288 specially, we would issue an error message about an invalid
10289 declaration. */
10291 {
10297 /* We're going to speculatively look for a declaration, falling back
10298 to an expression, if necessary. */
10300 /* Parse the declaration. */
10303 decl);
10306 {
10307 /* It is a range-for, consume the ':' */
10311 {
10313 "range-based %<for%> loops are not allowed "
10316 }
10317 }
10318 else
10319 /* The ';' is not consumed yet because we told
10320 cp_parser_simple_declaration not to. */
10325 /* If the tentative parse failed, then we shall need to look for an
10326 expression-statement. */
10327 }
10328 /* If we are here, it is an expression-statement. */
10331 }
10333 /* Parse a jump-statement.
10335 jump-statement:
10336 break ;
10337 continue ;
10338 return expression [opt] ;
10339 return braced-init-list ;
10340 goto identifier ;
10342 GNU extension:
10344 jump-statement:
10345 goto * expression ;
10347 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
10349 static tree
10351 {
10357 /* Peek at the next token. */
10362 /* See what kind of keyword it is. */
10365 {
10369 {
10388 }
10394 {
10411 }
10416 {
10417 tree expr;
10421 {
10424 }
10427 else
10428 /* If the next token is a `;', then there is no
10429 expression. */
10431 /* Build the return-statement. */
10433 /* Look for the final `;'. */
10435 }
10439 /* Create the goto-statement. */
10441 {
10442 /* Issue a warning about this use of a GNU extension. */
10444 /* Consume the '*' token. */
10446 /* Parse the dependent expression. */
10448 }
10449 else
10451 /* Look for the final `;'. */
10458 }
10461 }
10463 /* Parse a declaration-statement.
10465 declaration-statement:
10466 block-declaration */
10468 static void
10470 {
10473 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
10476 /* Parse the block-declaration. */
10479 /* Free any declarators allocated. */
10482 /* Finish off the statement. */
10484 }
10486 /* Some dependent statements (like `if (cond) statement'), are
10487 implicitly in their own scope. In other words, if the statement is
10488 a single statement (as opposed to a compound-statement), it is
10489 none-the-less treated as if it were enclosed in braces. Any
10490 declarations appearing in the dependent statement are out of scope
10491 after control passes that point. This function parses a statement,
10492 but ensures that is in its own scope, even if it is not a
10493 compound-statement.
10495 If IF_P is not NULL, *IF_P is set to indicate whether the statement
10496 is a (possibly labeled) if statement which is not enclosed in
10497 braces and has an else clause. This is used to implement
10498 -Wparentheses.
10500 Returns the new statement. */
10502 static tree
10504 {
10505 tree statement;
10510 /* Mark if () ; with a special NOP_EXPR. */
10512 {
10516 }
10517 /* if a compound is opened, we simply parse the statement directly. */
10520 /* If the token is not a `{', then we must take special action. */
10521 else
10522 {
10523 /* Create a compound-statement. */
10525 /* Parse the dependent-statement. */
10527 /* Finish the dummy compound-statement. */
10529 }
10531 /* Return the statement. */
10533 }
10535 /* For some dependent statements (like `while (cond) statement'), we
10536 have already created a scope. Therefore, even if the dependent
10537 statement is a compound-statement, we do not want to create another
10538 scope. */
10540 static void
10542 {
10543 /* If the token is a `{', then we must take special action. */
10546 else
10547 {
10548 /* Avoid calling cp_parser_compound_statement, so that we
10549 don't create a new scope. Do everything else by hand. */
10551 /* If the next keyword is `__label__' we have a label declaration. */
10554 /* Parse an (optional) statement-seq. */
10557 }
10558 }
10560 /* Declarations [gram.dcl.dcl] */
10562 /* Parse an optional declaration-sequence.
10564 declaration-seq:
10565 declaration
10566 declaration-seq declaration */
10568 static void
10570 {
10572 {
10583 {
10584 /* A declaration consisting of a single semicolon is
10585 invalid. Allow it unless we're being pedantic. */
10590 }
10592 /* If we're entering or exiting a region that's implicitly
10593 extern "C", modify the lang context appropriately. */
10595 {
10598 }
10600 {
10603 }
10606 {
10607 /* A top-level declaration can consist solely of a #pragma.
10608 A nested declaration cannot, so this is done here and not
10609 in cp_parser_declaration. (A #pragma at block scope is
10610 handled in cp_parser_statement.) */
10613 }
10615 /* Parse the declaration itself. */
10617 }
10618 }
10620 /* Parse a declaration.
10622 declaration:
10623 block-declaration
10624 function-definition
10625 template-declaration
10626 explicit-instantiation
10627 explicit-specialization
10628 linkage-specification
10629 namespace-definition
10631 GNU extension:
10633 declaration:
10634 __extension__ declaration */
10636 static void
10638 {
10639 cp_token token1;
10640 cp_token token2;
10645 /* Check for the `__extension__' keyword. */
10647 {
10648 /* Parse the qualified declaration. */
10650 /* Restore the PEDANTIC flag. */
10654 }
10656 /* Try to figure out what kind of declaration is present. */
10661 else
10662 {
10665 }
10667 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
10670 /* If the next token is `extern' and the following token is a string
10671 literal, then we have a linkage specification. */
10675 /* If the next token is `template', then we have either a template
10676 declaration, an explicit instantiation, or an explicit
10677 specialization. */
10679 {
10680 /* `template <>' indicates a template specialization. */
10684 /* `template <' indicates a template declaration. */
10687 /* Anything else must be an explicit instantiation. */
10688 else
10690 }
10691 /* If the next token is `export', then we have a template
10692 declaration. */
10695 /* If the next token is `extern', 'static' or 'inline' and the one
10696 after that is `template', we have a GNU extended explicit
10697 instantiation directive. */
10704 /* If the next token is `namespace', check for a named or unnamed
10705 namespace definition. */
10711 /* An unnamed namespace definition. */
10715 /* An inline (associated) namespace definition. */
10719 /* Objective-C++ declaration/definition. */
10726 /* We must have either a block declaration or a function
10727 definition. */
10728 else
10729 /* Try to parse a block-declaration, or a function-definition. */
10732 /* Free any declarators allocated. */
10734 }
10736 /* Parse a block-declaration.
10738 block-declaration:
10739 simple-declaration
10740 asm-definition
10741 namespace-alias-definition
10742 using-declaration
10743 using-directive
10745 GNU Extension:
10747 block-declaration:
10748 __extension__ block-declaration
10750 C++0x Extension:
10752 block-declaration:
10753 static_assert-declaration
10755 If STATEMENT_P is TRUE, then this block-declaration is occurring as
10756 part of a declaration-statement. */
10758 static void
10761 {
10765 /* Check for the `__extension__' keyword. */
10767 {
10768 /* Parse the qualified declaration. */
10770 /* Restore the PEDANTIC flag. */
10774 }
10776 /* Peek at the next token to figure out which kind of declaration is
10777 present. */
10780 /* If the next keyword is `asm', we have an asm-definition. */
10782 {
10786 }
10787 /* If the next keyword is `namespace', we have a
10788 namespace-alias-definition. */
10791 /* If the next keyword is `using', we have a
10792 using-declaration, a using-directive, or an alias-declaration. */
10794 {
10799 /* If the token after `using' is `namespace', then we have a
10800 using-directive. */
10804 /* If the second token after 'using' is '=', then we have an
10805 alias-declaration. */
10811 /* Otherwise, it's a using-declaration. */
10812 else
10815 }
10816 /* If the next keyword is `__label__' we have a misplaced label
10817 declaration. */
10819 {
10823 /* If the next token is now a `;', consume it. */
10826 }
10827 /* If the next token is `static_assert' we have a static assertion. */
10830 /* Anything else must be a simple-declaration. */
10831 else
10834 }
10836 /* Parse a simple-declaration.
10838 simple-declaration:
10839 decl-specifier-seq [opt] init-declarator-list [opt] ;
10841 init-declarator-list:
10842 init-declarator
10843 init-declarator-list , init-declarator
10845 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
10846 function-definition as a simple-declaration.
10848 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
10849 parsed declaration if it is an uninitialized single declarator not followed
10850 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
10851 if present, will not be consumed. */
10853 static void
10857 {
10858 cp_decl_specifier_seq decl_specifiers;
10865 /* Defer access checks until we know what is being declared; the
10866 checks for names appearing in the decl-specifier-seq should be
10867 done as if we were in the scope of the thing being declared. */
10870 /* Parse the decl-specifier-seq. We have to keep track of whether
10871 or not the decl-specifier-seq declares a named class or
10872 enumeration type, since that is the only case in which the
10873 init-declarator-list is allowed to be empty.
10875 [dcl.dcl]
10877 In a simple-declaration, the optional init-declarator-list can be
10878 omitted only when declaring a class or enumeration, that is when
10879 the decl-specifier-seq contains either a class-specifier, an
10880 elaborated-type-specifier, or an enum-specifier. */
10882 CP_PARSER_FLAGS_OPTIONAL,
10885 /* We no longer need to defer access checks. */
10888 /* In a block scope, a valid declaration must always have a
10889 decl-specifier-seq. By not trying to parse declarators, we can
10890 resolve the declaration/expression ambiguity more quickly. */
10893 {
10896 }
10898 /* If the next two tokens are both identifiers, the code is
10899 erroneous. The usual cause of this situation is code like:
10901 T t;
10903 where "T" should name a type -- but does not. */
10906 {
10907 /* If parsing tentatively, we should commit; we really are
10908 looking at a declaration. */
10910 /* Give up. */
10912 }
10914 /* If we have seen at least one decl-specifier, and the next token
10915 is not a parenthesis, then we must be looking at a declaration.
10916 (After "int (" we might be looking at a functional cast.) */
10923 /* Keep going until we hit the `;' at the end of the simple
10924 declaration. */
10927 CPP_SEMICOLON))
10928 {
10931 tree decl;
10934 {
10935 /* If we are processing next declarator, coma is expected */
10941 }
10942 else
10945 /* Parse the init-declarator. */
10948 function_definition_allowed_p,
10950 declares_class_or_enum,
10952 maybe_range_for_decl);
10953 /* If an error occurred while parsing tentatively, exit quickly.
10954 (That usually happens when in the body of a function; each
10955 statement is treated as a declaration-statement until proven
10956 otherwise.) */
10959 /* Handle function definitions specially. */
10961 {
10962 /* If the next token is a `,', then we are probably
10963 processing something like:
10965 void f() {}, *p;
10967 which is erroneous. */
10969 {
10972 "mixing"
10974 }
10975 /* Otherwise, we're done with the list of declarators. */
10976 else
10977 {
10980 }
10981 }
10984 /* The next token should be either a `,' or a `;'. */
10986 /* If it's a `,', there are more declarators to come. */
10989 /* If it's a `;', we are done. */
10992 /* Anything else is an error. */
10993 else
10994 {
10995 /* If we have already issued an error message we don't need
10996 to issue another one. */
11000 /* Skip tokens until we reach the end of the statement. */
11002 /* If the next token is now a `;', consume it. */
11006 }
11007 /* After the first time around, a function-definition is not
11008 allowed -- even if it was OK at first. For example:
11010 int i, f() {}
11012 is not valid. */
11014 }
11016 /* Issue an error message if no declarators are present, and the
11017 decl-specifier-seq does not itself declare a class or
11018 enumeration. */
11020 {
11023 /* Perform any deferred access checks. */
11025 }
11027 /* Consume the `;'. */
11031 done:
11033 }
11035 /* Parse a decl-specifier-seq.
11037 decl-specifier-seq:
11038 decl-specifier-seq [opt] decl-specifier
11039 decl-specifier attribute-specifier-seq [opt] (C++11)
11041 decl-specifier:
11042 storage-class-specifier
11043 type-specifier
11044 function-specifier
11045 friend
11046 typedef
11048 GNU Extension:
11050 decl-specifier:
11051 attributes
11053 Set *DECL_SPECS to a representation of the decl-specifier-seq.
11055 The parser flags FLAGS is used to control type-specifier parsing.
11057 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
11058 flags:
11060 1: one of the decl-specifiers is an elaborated-type-specifier
11061 (i.e., a type declaration)
11062 2: one of the decl-specifiers is an enum-specifier or a
11063 class-specifier (i.e., a type definition)
11065 */
11067 static void
11069 cp_parser_flags flags,
11072 {
11076 cp_decl_spec ds;
11078 /* Clear DECL_SPECS. */
11081 /* Assume no class or enumeration type is declared. */
11084 /* Keep reading specifiers until there are no more to read. */
11086 {
11091 /* Peek at the next token. */
11094 /* Save the first token of the decl spec list for error
11095 reporting. */
11098 /* Handle attributes. */
11100 {
11101 /* Parse the attributes. */
11104 /* In a sequence of declaration specifiers, c++11 attributes
11105 appertain to the type that precede them. In that case
11106 [dcl.spec]/1 says:
11108 The attribute-specifier-seq affects the type only for
11109 the declaration it appears in, not other declarations
11110 involving the same type.
11112 But for now let's force the user to position the
11113 attribute either at the beginning of the declaration or
11114 after the declarator-id, which would clearly mean that it
11115 applies to the declarator. */
11117 {
11119 /* The c++11 attribute is at the beginning of the
11120 declaration. It appertains to the entity being
11122 else
11123 {
11125 {
11126 /* This is an attribute following a
11127 class-specifier. */
11132 }
11133 else
11134 {
11135 decl_specs->std_attributes
11137 attrs);
11140 }
11142 }
11143 }
11145 decl_specs->attributes
11147 attrs);
11151 }
11152 /* Assume we will find a decl-specifier keyword. */
11154 /* If the next token is an appropriate keyword, we can simply
11155 add it to the list. */
11157 {
11158 /* decl-specifier:
11159 friend
11160 constexpr */
11163 {
11166 }
11167 else
11168 {
11170 /* Consume the token. */
11172 }
11180 /* function-specifier:
11181 inline
11182 virtual
11183 explicit */
11190 /* decl-specifier:
11191 typedef */
11194 /* Consume the token. */
11196 /* A constructor declarator cannot appear in a typedef. */
11198 /* The "typedef" keyword can only occur in a declaration; we
11199 may as well commit at this point. */
11206 /* storage-class-specifier:
11207 auto
11208 register
11209 static
11210 extern
11211 mutable
11213 GNU Extension:
11214 thread */
11217 {
11218 /* Consume the token. */
11221 /* Complain about `auto' as a storage specifier, if
11222 we're complaining about C++0x compatibility. */
11226 /* Set the storage class anyway. */
11228 token);
11229 }
11230 else
11231 /* C++0x auto type-specifier. */
11239 /* Consume the token. */
11242 token);
11245 /* Consume the token. */
11251 /* We did not yet find a decl-specifier yet. */
11254 }
11264 /* Constructors are a special case. The `S' in `S()' is not a
11265 decl-specifier; it is the beginning of the declarator. */
11266 constructor_p
11267 = (!found_decl_spec
11268 && constructor_possible_p
11269 && (cp_parser_constructor_declarator_p
11272 /* If we don't have a DECL_SPEC yet, then we must be looking at
11273 a type-specifier. */
11275 {
11278 tree type_spec;
11280 type_spec
11282 decl_specs,
11288 /* If this type-specifier referenced a user-defined type
11289 (a typedef, class-name, etc.), then we can't allow any
11290 more such type-specifiers henceforth.
11292 [dcl.spec]
11294 The longest sequence of decl-specifiers that could
11295 possibly be a type name is taken as the
11296 decl-specifier-seq of a declaration. The sequence shall
11297 be self-consistent as described below.
11299 [dcl.type]
11301 As a general rule, at most one type-specifier is allowed
11302 in the complete decl-specifier-seq of a declaration. The
11303 only exceptions are the following:
11305 -- const or volatile can be combined with any other
11306 type-specifier.
11308 -- signed or unsigned can be combined with char, long,
11309 short, or int.
11311 -- ..
11313 Example:
11315 typedef char* Pc;
11316 void g (const int Pc);
11318 Here, Pc is *not* part of the decl-specifier seq; it's
11319 the declarator. Therefore, once we see a type-specifier
11320 (other than a cv-qualifier), we forbid any additional
11321 user-defined types. We *do* still allow things like `int
11322 int' to be considered a decl-specifier-seq, and issue the
11323 error message later. */
11326 /* A constructor declarator cannot follow a type-specifier. */
11328 {
11333 }
11334 }
11336 /* If we still do not have a DECL_SPEC, then there are no more
11337 decl-specifiers. */
11342 /* After we see one decl-specifier, further decl-specifiers are
11343 always optional. */
11345 }
11347 /* Don't allow a friend specifier with a class definition. */
11352 }
11354 /* Parse an (optional) storage-class-specifier.
11356 storage-class-specifier:
11357 auto
11358 register
11359 static
11360 extern
11361 mutable
11363 GNU Extension:
11365 storage-class-specifier:
11366 thread
11368 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
11370 static tree
11372 {
11374 {
11378 /* Fall through for C++98. */
11385 /* Consume the token. */
11390 }
11391 }
11393 /* Parse an (optional) function-specifier.
11395 function-specifier:
11396 inline
11397 virtual
11398 explicit
11400 Returns an IDENTIFIER_NODE corresponding to the keyword used.
11401 Updates DECL_SPECS, if it is non-NULL. */
11403 static tree
11406 {
11409 {
11415 /* 14.5.2.3 [temp.mem]
11417 A member function template shall not be virtual. */
11429 }
11431 /* Consume the token. */
11433 }
11435 /* Parse a linkage-specification.
11437 linkage-specification:
11438 extern string-literal { declaration-seq [opt] }
11439 extern string-literal declaration */
11441 static void
11443 {
11444 tree linkage;
11446 /* Look for the `extern' keyword. */
11449 /* Look for the string-literal. */
11452 /* Transform the literal into an identifier. If the literal is a
11453 wide-character string, or contains embedded NULs, then we can't
11454 handle it as the user wants. */
11457 {
11459 /* Assume C++ linkage. */
11461 }
11462 else
11465 /* We're now using the new linkage. */
11468 /* If the next token is a `{', then we're using the first
11469 production. */
11471 {
11472 /* Consume the `{' token. */
11474 /* Parse the declarations. */
11476 /* Look for the closing `}'. */
11478 }
11479 /* Otherwise, there's just one declaration. */
11480 else
11481 {
11484 saved_in_unbraced_linkage_specification_p
11488 parser->in_unbraced_linkage_specification_p
11490 }
11492 /* We're done with the linkage-specification. */
11494 }
11496 /* Parse a static_assert-declaration.
11498 static_assert-declaration:
11499 static_assert ( constant-expression , string-literal ) ;
11501 If MEMBER_P, this static_assert is a class member. */
11503 static void
11505 {
11506 tree condition;
11507 tree message;
11509 location_t saved_loc;
11512 /* Peek at the `static_assert' token so we can keep track of exactly
11513 where the static assertion started. */
11517 /* Look for the `static_assert' keyword. */
11519 RT_STATIC_ASSERT))
11522 /* We know we are in a static assertion; commit to any tentative
11523 parse. */
11527 /* Parse the `(' starting the static assertion condition. */
11530 /* Parse the constant-expression. Allow a non-constant expression
11531 here in order to give better diagnostics in finish_static_assert. */
11532 condition =
11537 /* Parse the separating `,'. */
11540 /* Parse the string-literal message. */
11545 /* A `)' completes the static assertion. */
11552 /* A semicolon terminates the declaration. */
11555 /* Complete the static assertion, which may mean either processing
11556 the static assert now or saving it for template instantiation. */
11558 }
11560 /* Parse the expression in decltype ( expression ). */
11562 static tree
11565 {
11567 tree expr;
11569 /* First, try parsing an id-expression. */
11580 {
11583 cp_id_kind idk;
11587 /* Lookup the name we got back from the id-expression. */
11589 none_type,
11603 {
11604 /* Complete lookup of the id-expression. */
11605 expr = (finish_id_expression
11618 /* We found an id-expression, but it was something that we
11619 should not have found. This is an error, not something
11620 we can recover from, so note that we found an
11621 id-expression and we'll recover as gracefully as
11622 possible. */
11624 }
11629 /* We have an id-expression. */
11631 }
11634 {
11635 /* Abort the id-expression parse. */
11638 /* Parsing tentatively, again. */
11641 /* Parse a class member access. */
11649 /* We have an id-expression. */
11651 }
11654 /* We have parsed the complete id-expression or member access. */
11656 else
11657 {
11658 /* Abort our attempt to parse an id-expression or member access
11659 expression. */
11662 /* Parse a full expression. */
11665 }
11668 }
11670 /* Parse a `decltype' type. Returns the type.
11672 simple-type-specifier:
11673 decltype ( expression )
11674 C++14 proposal:
11675 decltype ( auto ) */
11677 static tree
11679 {
11680 tree expr;
11689 {
11690 /* Already parsed. */
11693 }
11695 /* Look for the `decltype' token. */
11699 /* Parse the opening `('. */
11703 /* decltype (auto) */
11706 {
11713 }
11715 /* Types cannot be defined in a `decltype' expression. Save away the
11716 old message. */
11719 /* And create the new one. */
11720 parser->type_definition_forbidden_message
11723 /* The restrictions on constant-expressions do not apply inside
11724 decltype expressions. */
11725 saved_integral_constant_expression_p
11727 saved_non_integral_constant_expression_p
11731 /* Within a parenthesized expression, a `>' token is always
11732 the greater-than operator. */
11733 saved_greater_than_is_operator_p
11737 /* Do not actually evaluate the expression. */
11740 /* Do not warn about problems with the expression. */
11745 /* Go back to evaluating expressions. */
11749 /* The `>' token might be the end of a template-id or
11750 template-parameter-list now. */
11751 parser->greater_than_is_operator_p
11754 /* Restore the old message and the integral constant expression
11755 flags. */
11757 parser->integral_constant_expression_p
11759 parser->non_integral_constant_expression_p
11762 /* Parse to the closing `)'. */
11764 {
11768 }
11771 tf_warning_or_error);
11773 rewrite:
11774 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
11775 it again. */
11782 }
11784 /* Special member functions [gram.special] */
11786 /* Parse a conversion-function-id.
11788 conversion-function-id:
11789 operator conversion-type-id
11791 Returns an IDENTIFIER_NODE representing the operator. */
11793 static tree
11795 {
11796 tree type;
11797 tree saved_scope;
11798 tree saved_qualifying_scope;
11799 tree saved_object_scope;
11802 /* Look for the `operator' token. */
11805 /* When we parse the conversion-type-id, the current scope will be
11806 reset. However, we need that information in able to look up the
11807 conversion function later, so we save it here. */
11811 /* We must enter the scope of the class so that the names of
11812 entities declared within the class are available in the
11813 conversion-type-id. For example, consider:
11815 struct S {
11816 typedef int I;
11817 operator I();
11818 };
11820 S::operator I() { ... }
11822 In order to see that `I' is a type-name in the definition, we
11823 must be in the scope of `S'. */
11826 /* Parse the conversion-type-id. */
11828 /* Leave the scope of the class, if any. */
11831 /* Restore the saved scope. */
11835 /* If the TYPE is invalid, indicate failure. */
11839 }
11841 /* Parse a conversion-type-id:
11843 conversion-type-id:
11844 type-specifier-seq conversion-declarator [opt]
11846 Returns the TYPE specified. */
11848 static tree
11850 {
11851 tree attributes;
11852 cp_decl_specifier_seq type_specifiers;
11854 tree type_specified;
11857 /* Parse the attributes. */
11861 parser->type_definition_forbidden_message
11864 /* Parse the type-specifiers. */
11871 /* If that didn't work, stop. */
11874 /* Parse the conversion-declarator. */
11882 /* Don't give this error when parsing tentatively. This happens to
11883 work because we always parse this definitively once. */
11886 {
11888 {
11891 }
11895 }
11898 }
11900 /* Parse an (optional) conversion-declarator.
11902 conversion-declarator:
11903 ptr-operator conversion-declarator [opt]
11905 */
11909 {
11912 cp_cv_quals cv_quals;
11914 /* We don't know if there's a ptr-operator next, or not. */
11916 /* Try the ptr-operator. */
11919 /* If it worked, look for more conversion-declarators. */
11921 {
11924 /* Parse another optional declarator. */
11927 declarator = cp_parser_make_indirect_declarator
11931 }
11934 }
11936 /* Parse an (optional) ctor-initializer.
11938 ctor-initializer:
11939 : mem-initializer-list
11941 Returns TRUE iff the ctor-initializer was actually present. */
11943 static bool
11945 {
11946 /* If the next token is not a `:', then there is no
11947 ctor-initializer. */
11949 {
11950 /* Do default initialization of any bases and members. */
11955 }
11957 /* Consume the `:' token. */
11959 /* And the mem-initializer-list. */
11963 }
11965 /* Parse a mem-initializer-list.
11967 mem-initializer-list:
11968 mem-initializer ... [opt]
11969 mem-initializer ... [opt] , mem-initializer-list */
11971 static void
11973 {
11978 /* Let the semantic analysis code know that we are starting the
11979 mem-initializer-list. */
11984 /* Loop through the list. */
11986 {
11987 tree mem_initializer;
11990 /* Parse the mem-initializer. */
11992 /* If the next token is a `...', we're expanding member initializers. */
11994 {
11995 /* Consume the `...'. */
11998 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
11999 can be expanded but members cannot. */
12002 {
12007 }
12009 /* Construct the pack expansion type. */
12012 }
12015 {
12019 }
12020 /* Look for a target constructor. */
12024 {
12027 {
12031 }
12033 }
12034 /* Add it to the list, unless it was erroneous. */
12036 {
12039 }
12040 /* If the next token is not a `,', we're done. */
12043 /* Consume the `,' token. */
12045 }
12047 /* Perform semantic analysis. */
12050 }
12052 /* Parse a mem-initializer.
12054 mem-initializer:
12055 mem-initializer-id ( expression-list [opt] )
12056 mem-initializer-id braced-init-list
12058 GNU extension:
12060 mem-initializer:
12061 ( expression-list [opt] )
12063 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
12064 class) or FIELD_DECL (for a non-static data member) to initialize;
12065 the TREE_VALUE is the expression-list. An empty initialization
12066 list is represented by void_list_node. */
12068 static tree
12070 {
12071 tree mem_initializer_id;
12072 tree expression_list;
12073 tree member;
12076 /* Find out what is being initialized. */
12078 {
12082 }
12083 else
12084 {
12088 }
12094 {
12100 }
12101 else
12102 {
12112 }
12122 }
12124 /* Parse a mem-initializer-id.
12126 mem-initializer-id:
12127 :: [opt] nested-name-specifier [opt] class-name
12128 identifier
12130 Returns a TYPE indicating the class to be initializer for the first
12131 production. Returns an IDENTIFIER_NODE indicating the data member
12132 to be initialized for the second production. */
12134 static tree
12136 {
12140 tree id;
12144 /* `typename' is not allowed in this context ([temp.res]). */
12146 {
12148 "keyword %<typename%> not allowed in this context (a qualified "
12151 }
12152 /* Look for the optional `::' operator. */
12153 global_scope_p
12157 /* Look for the optional nested-name-specifier. The simplest way to
12158 implement:
12160 [temp.res]
12162 The keyword `typename' is not permitted in a base-specifier or
12163 mem-initializer; in these contexts a qualified name that
12164 depends on a template-parameter is implicitly assumed to be a
12165 type name.
12167 is to assume that we have seen the `typename' keyword at this
12168 point. */
12169 nested_name_specifier_p
12178 /* If there is a `::' operator or a nested-name-specifier, then we
12179 are definitely looking for a class-name. */
12184 typename_type,
12188 /* Otherwise, we could also be looking for an ordinary identifier. */
12190 /* Try a class-name. */
12194 none_type,
12198 /* If we found one, we're done. */
12201 /* Otherwise, look for an ordinary identifier. */
12203 }
12205 /* Overloading [gram.over] */
12207 /* Parse an operator-function-id.
12209 operator-function-id:
12210 operator operator
12212 Returns an IDENTIFIER_NODE for the operator which is a
12213 human-readable spelling of the identifier, e.g., `operator +'. */
12215 static tree
12217 {
12218 /* Look for the `operator' keyword. */
12221 /* And then the name of the operator itself. */
12223 }
12225 /* Return an identifier node for a user-defined literal operator.
12226 The suffix identifier is chained to the operator name identifier. */
12228 static tree
12230 {
12231 tree identifier;
12238 }
12240 /* Parse an operator.
12242 operator:
12243 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
12244 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
12245 || ++ -- , ->* -> () []
12247 GNU Extensions:
12249 operator:
12250 <? >? <?= >?=
12252 Returns an IDENTIFIER_NODE for the operator which is a
12253 human-readable spelling of the identifier, e.g., `operator +'. */
12255 static tree
12257 {
12263 /* Peek at the next token. */
12265 /* Figure out which operator we have. */
12267 {
12269 {
12272 /* The keyword should be either `new' or `delete'. */
12277 else
12280 /* Consume the `new' or `delete' token. */
12283 /* Peek at the next token. */
12285 /* If it's a `[' token then this is the array variant of the
12286 operator. */
12288 {
12289 /* Consume the `[' token. */
12291 /* Look for the `]' token. */
12295 }
12296 /* Otherwise, we have the non-array variant. */
12297 else
12301 }
12448 /* Consume the `('. */
12450 /* Look for the matching `)'. */
12455 /* Consume the `['. */
12457 /* Look for the matching `]'. */
12475 {
12478 }
12479 /* Consume the string. */
12481 /* Look for the suffix identifier. */
12484 {
12487 {
12490 }
12491 }
12493 {
12497 }
12498 else
12499 {
12502 }
12517 {
12520 {
12523 }
12525 /* Consume the user-defined string literal. */
12528 {
12531 }
12532 else
12534 }
12537 /* Anything else is an error. */
12539 }
12541 /* If we have selected an identifier, we need to consume the
12542 operator token. */
12545 /* Otherwise, no valid operator name was present. */
12546 else
12547 {
12550 }
12553 }
12555 /* Parse a template-declaration.
12557 template-declaration:
12558 export [opt] template < template-parameter-list > declaration
12560 If MEMBER_P is TRUE, this template-declaration occurs within a
12561 class-specifier.
12563 The grammar rule given by the standard isn't correct. What
12564 is really meant is:
12566 template-declaration:
12567 export [opt] template-parameter-list-seq
12568 decl-specifier-seq [opt] init-declarator [opt] ;
12569 export [opt] template-parameter-list-seq
12570 function-definition
12572 template-parameter-list-seq:
12573 template-parameter-list-seq [opt]
12574 template < template-parameter-list > */
12576 static void
12578 {
12579 /* Check for `export'. */
12581 {
12582 /* Consume the `export' token. */
12584 /* Warn that we do not support `export'. */
12586 }
12589 }
12591 /* Parse a template-parameter-list.
12593 template-parameter-list:
12594 template-parameter
12595 template-parameter-list , template-parameter
12597 Returns a TREE_LIST. Each node represents a template parameter.
12598 The nodes are connected via their TREE_CHAINs. */
12600 static tree
12602 {
12607 /* The loop below parses the template parms. We first need to know
12608 the total number of template parms to be able to compute proper
12609 canonical types of each dependent type. So after the loop, when
12610 we know the total number of template parms,
12611 end_template_parm_list computes the proper canonical types and
12612 fixes up the dependent types accordingly. */
12614 {
12615 tree parameter;
12618 location_t parm_loc;
12620 /* Parse the template-parameter. */
12625 /* Add it to the list. */
12628 parm_loc,
12629 parameter,
12630 is_non_type,
12631 is_parameter_pack);
12632 else
12633 {
12636 }
12638 /* If the next token is not a `,', we're done. */
12641 /* Otherwise, consume the `,' token. */
12643 }
12646 }
12648 /* Parse a template-parameter.
12650 template-parameter:
12651 type-parameter
12652 parameter-declaration
12654 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
12655 the parameter. The TREE_PURPOSE is the default value, if any.
12656 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
12657 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
12658 set to true iff this parameter is a parameter pack. */
12660 static tree
12663 {
12667 tree parm;
12669 /* Assume it is a type parameter or a template parameter. */
12671 /* Assume it not a parameter pack. */
12673 /* Peek at the next token. */
12675 /* If it is `class' or `template', we have a type-parameter. */
12678 /* If it is `class' or `typename' we do not know yet whether it is a
12679 type parameter or a non-type parameter. Consider:
12681 template <typename T, typename T::X X> ...
12683 or:
12685 template <class C, class D*> ...
12687 Here, the first parameter is a type parameter, and the second is
12688 a non-type parameter. We can tell by looking at the token after
12689 the identifier -- if it is a `,', `=', or `>' then we have a type
12690 parameter. */
12692 {
12693 /* Peek at the token after `class' or `typename'. */
12695 /* If it's an ellipsis, we have a template type parameter
12696 pack. */
12699 /* If it's an identifier, skip it. */
12702 /* Now, see if the token looks like the end of a template
12703 parameter. */
12708 }
12710 /* Otherwise, it is a non-type parameter.
12712 [temp.param]
12714 When parsing a default template-argument for a non-type
12715 template-parameter, the first non-nested `>' is taken as the end
12716 of the template parameter-list rather than a greater-than
12717 operator. */
12719 parameter_declarator
12723 /* If the parameter declaration is marked as a parameter pack, set
12724 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
12725 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
12726 grokdeclarator. */
12730 {
12733 }
12737 {
12738 /* Can happen in some cases of erroneous input (c++/34892). */
12740 /* Consume the `...' for better error recovery. */
12742 }
12743 /* If the next token is an ellipsis, and we don't already have it
12744 marked as a parameter pack, then we have a parameter pack (that
12745 has no declarator). */
12748 && (declarator_can_be_parameter_pack
12750 {
12751 /* Consume the `...'. */
12756 }
12757 /* We might end up with a pack expansion as the type of the non-type
12758 template parameter, in which case this is a non-type template
12759 parameter pack. */
12763 {
12767 }
12770 {
12771 /* Parameter packs cannot have default arguments. However, a
12772 user may try to do so, so we'll parse them and give an
12773 appropriate diagnostic here. */
12777 /* Find the name of the parameter pack. */
12786 else
12790 /* Parse the default argument, but throw away the result. */
12792 }
12802 }
12804 /* Parse a type-parameter.
12806 type-parameter:
12807 class identifier [opt]
12808 class identifier [opt] = type-id
12809 typename identifier [opt]
12810 typename identifier [opt] = type-id
12811 template < template-parameter-list > class identifier [opt]
12812 template < template-parameter-list > class identifier [opt]
12813 = id-expression
12815 GNU Extension (variadic templates):
12817 type-parameter:
12818 class ... identifier [opt]
12819 typename ... identifier [opt]
12821 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
12822 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
12823 the declaration of the parameter.
12825 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
12827 static tree
12829 {
12831 tree parameter;
12833 /* Look for a keyword to tell us what kind of parameter this is. */
12839 {
12842 {
12843 tree identifier;
12844 tree default_argument;
12846 /* If the next token is an ellipsis, we have a template
12847 argument pack. */
12849 {
12850 /* Consume the `...' token. */
12855 }
12857 /* If the next token is an identifier, then it names the
12858 parameter. */
12861 else
12864 /* Create the parameter. */
12867 /* If the next token is an `=', we have a default argument. */
12869 {
12870 /* Consume the `=' token. */
12872 /* Parse the default-argument. */
12876 /* Template parameter packs cannot have default
12877 arguments. */
12879 {
12882 "template parameter pack %qD cannot have a "
12884 else
12886 "template parameter packs cannot have "
12889 }
12891 }
12892 else
12895 /* Create the combined representation of the parameter and the
12896 default argument. */
12898 }
12902 {
12903 tree identifier;
12904 tree default_argument;
12906 /* Look for the `<'. */
12908 /* Parse the template-parameter-list. */
12910 /* Look for the `>'. */
12912 /* Look for the `class' keyword. */
12914 /* If the next token is an ellipsis, we have a template
12915 argument pack. */
12917 {
12918 /* Consume the `...' token. */
12923 }
12924 /* If the next token is an `=', then there is a
12925 default-argument. If the next token is a `>', we are at
12926 the end of the parameter-list. If the next token is a `,',
12927 then we are at the end of this parameter. */
12931 {
12933 /* Treat invalid names as if the parameter were nameless. */
12936 }
12937 else
12940 /* Create the template parameter. */
12942 identifier);
12944 /* If the next token is an `=', then there is a
12945 default-argument. */
12947 {
12950 /* Consume the `='. */
12952 /* Parse the id-expression. */
12954 /* save token before parsing the id-expression, for error
12955 reporting */
12957 default_argument
12965 /* If the id-expression was a template-id that refers to
12966 a template-class, we already have the declaration here,
12967 so no further lookup is needed. */
12968 ;
12969 else
12970 /* Look up the name. */
12971 default_argument
12973 none_type,
12979 /* See if the default argument is valid. */
12980 default_argument
12983 /* Template parameter packs cannot have default
12984 arguments. */
12986 {
12989 "template parameter pack %qD cannot "
12991 identifier);
12992 else
12996 }
12998 }
12999 else
13002 /* Create the combined representation of the parameter and the
13003 default argument. */
13005 }
13011 }
13014 }
13016 /* Parse a template-id.
13018 template-id:
13019 template-name < template-argument-list [opt] >
13021 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
13022 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
13023 returned. Otherwise, if the template-name names a function, or set
13024 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
13025 names a class, returns a TYPE_DECL for the specialization.
13027 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
13028 uninstantiated templates. */
13030 static tree
13036 {
13038 tree templ;
13039 tree arguments;
13040 tree template_id;
13047 /* If the next token corresponds to a template-id, there is no need
13048 to reparse it. */
13051 {
13054 /* Get the stored value. */
13056 /* Perform any access checks that were deferred. */
13059 {
13064 tf_warning_or_error);
13065 }
13066 /* Return the stored value. */
13068 }
13070 /* Avoid performing name lookup if there is no possibility of
13071 finding a template-id. */
13074 && !cp_parser_nth_token_starts_template_argument_list_p
13076 {
13079 }
13081 /* Remember where the template-id starts. */
13087 /* Parse the template-name. */
13090 check_dependency_p,
13091 is_declaration,
13092 tag_type,
13095 {
13098 }
13100 /* If we find the sequence `[:' after a template-name, it's probably
13101 a digraph-typo for `< ::'. Substitute the tokens and check if we can
13102 parse correctly the argument list. */
13109 {
13111 /* Change `:' into `::'. */
13113 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
13114 CPP_LESS. */
13117 /* Parse the arguments. */
13120 {
13121 /* If we couldn't parse an argument list, then we revert our changes
13122 and return simply an error. Maybe this is not a template-id
13123 after all. */
13128 }
13129 /* Otherwise, emit an error about the invalid digraph, but continue
13130 parsing because we got our argument list. */
13133 {
13136 "%<<:%> is an alternate spelling for %<[%>."
13139 {
13141 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
13144 }
13145 }
13146 }
13147 else
13148 {
13149 /* Look for the `<' that starts the template-argument-list. */
13151 {
13154 }
13155 /* Parse the arguments. */
13157 }
13159 /* Build a representation of the specialization. */
13162 TEMPLATE_ID_EXPR,
13166 {
13168 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
13169 template (rather than some instantiation thereof) only if
13170 is not nested within some other construct. For example, in
13171 "template <typename T> void f(T) { A<T>::", A<T> is just an
13172 instantiation of A. */
13175 CPP_SCOPE));
13176 template_id
13178 }
13179 else
13180 {
13181 /* If it's not a class-template or a template-template, it should be
13182 a function-template. */
13188 }
13190 /* If parsing tentatively, replace the sequence of tokens that makes
13191 up the template-id with a CPP_TEMPLATE_ID token. That way,
13192 should we re-parse the token stream, we will not have to repeat
13193 the effort required to do the parse, nor will we issue duplicate
13194 error messages about problems during instantiation of the
13195 template. */
13197 {
13200 /* Reset the contents of the START_OF_ID token. */
13202 /* Retrieve any deferred checks. Do not pop this access checks yet
13203 so the memory will not be reclaimed during token replacing below. */
13209 /* Purge all subsequent tokens. */
13212 /* ??? Can we actually assume that, if template_id ==
13213 error_mark_node, we will have issued a diagnostic to the
13214 user, as opposed to simply marking the tentative parse as
13215 failed? */
13218 }
13222 }
13224 /* Parse a template-name.
13226 template-name:
13227 identifier
13229 The standard should actually say:
13231 template-name:
13232 identifier
13233 operator-function-id
13235 A defect report has been filed about this issue.
13237 A conversion-function-id cannot be a template name because they cannot
13238 be part of a template-id. In fact, looking at this code:
13240 a.operator K<int>()
13242 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
13243 It is impossible to call a templated conversion-function-id with an
13244 explicit argument list, since the only allowed template parameter is
13245 the type to which it is converting.
13247 If TEMPLATE_KEYWORD_P is true, then we have just seen the
13248 `template' keyword, in a construction like:
13250 T::template f<3>()
13252 In that case `f' is taken to be a template-name, even though there
13253 is no way of knowing for sure.
13255 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
13256 name refers to a set of overloaded functions, at least one of which
13257 is a template, or an IDENTIFIER_NODE with the name of the template,
13258 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
13259 names are looked up inside uninstantiated templates. */
13261 static tree
13268 {
13269 tree identifier;
13270 tree decl;
13271 tree fns;
13274 /* If the next token is `operator', then we have either an
13275 operator-function-id or a conversion-function-id. */
13277 {
13278 /* We don't know whether we're looking at an
13279 operator-function-id or a conversion-function-id. */
13281 /* Try an operator-function-id. */
13283 /* If that didn't work, try a conversion-function-id. */
13285 {
13288 }
13289 }
13290 /* Look for the identifier. */
13291 else
13294 /* If we didn't find an identifier, we don't have a template-id. */
13298 /* If the name immediately followed the `template' keyword, then it
13299 is a template-name. However, if the next token is not `<', then
13300 we do not treat it as a template-name, since it is not being used
13301 as part of a template-id. This enables us to handle constructs
13302 like:
13304 template <typename T> struct S { S(); };
13305 template <typename T> S<T>::S();
13307 correctly. We would treat `S' as a template -- if it were `S<T>'
13308 -- but we do not if there is no `<'. */
13312 {
13313 /* In a declaration, in a dependent context, we pretend that the
13314 "template" keyword was present in order to improve error
13315 recovery. For example, given:
13317 template <typename T> void f(T::X<int>);
13319 we want to treat "X<int>" as a template-id. */
13321 && !template_keyword_p
13323 && check_dependency_p
13325 /* Do not do this for dtors (or ctors), since they never
13326 need the template keyword before their name. */
13328 {
13331 /* Explain what went wrong. */
13333 identifier);
13336 /* If parsing tentatively, find the location of the "<" token. */
13339 /* Parse the template arguments so that we can issue error
13340 messages about them. */
13343 /* Skip tokens until we find a good place from which to
13344 continue parsing. */
13349 /* If parsing tentatively, permanently remove the
13350 template argument list. That will prevent duplicate
13351 error messages from being issued about the missing
13352 "template" keyword. */
13358 }
13360 /* If the "template" keyword is present, then there is generally
13361 no point in doing name-lookup, so we just return IDENTIFIER.
13362 But, if the qualifying scope is non-dependent then we can
13363 (and must) do name-lookup normally. */
13369 }
13371 /* Look up the name. */
13373 tag_type,
13376 check_dependency_p,
13380 /* If DECL is a template, then the name was a template-name. */
13382 ;
13383 else
13384 {
13387 /* The standard does not explicitly indicate whether a name that
13388 names a set of overloaded declarations, some of which are
13389 templates, is a template-name. However, such a name should
13390 be a template-name; otherwise, there is no way to form a
13391 template-id for the overloaded templates. */
13399 {
13400 /* The name does not name a template. */
13403 }
13404 }
13406 /* If DECL is dependent, and refers to a function, then just return
13407 its name; we will look it up again during template instantiation. */
13409 {
13413 }
13416 }
13418 /* Parse a template-argument-list.
13420 template-argument-list:
13421 template-argument ... [opt]
13422 template-argument-list , template-argument ... [opt]
13424 Returns a TREE_VEC containing the arguments. */
13426 static tree
13428 {
13433 tree vec;
13440 /* Even if the template-id appears in an integral
13441 constant-expression, the contents of the argument list do
13442 not. */
13448 /* Parse the arguments. */
13449 do
13450 {
13451 tree argument;
13454 /* Consume the comma. */
13457 /* Parse the template-argument. */
13460 /* If the next token is an ellipsis, we're expanding a template
13461 argument pack. */
13463 {
13465 {
13469 }
13470 /* Consume the `...' token. */
13473 /* Make the argument into a TYPE_PACK_EXPANSION or
13474 EXPR_PACK_EXPANSION. */
13476 }
13479 {
13483 {
13486 }
13487 else
13489 }
13491 }
13504 #ifdef ENABLE_CHECKING
13506 #endif
13508 }
13510 /* Parse a template-argument.
13512 template-argument:
13513 assignment-expression
13514 type-id
13515 id-expression
13517 The representation is that of an assignment-expression, type-id, or
13518 id-expression -- except that the qualified id-expression is
13519 evaluated, so that the value returned is either a DECL or an
13520 OVERLOAD.
13522 Although the standard says "assignment-expression", it forbids
13523 throw-expressions or assignments in the template argument.
13524 Therefore, we use "conditional-expression" instead. */
13526 static tree
13528 {
13529 tree argument;
13535 cp_id_kind idk;
13537 /* There's really no way to know what we're looking at, so we just
13538 try each alternative in order.
13540 [temp.arg]
13542 In a template-argument, an ambiguity between a type-id and an
13543 expression is resolved to a type-id, regardless of the form of
13544 the corresponding template-parameter.
13546 Therefore, we try a type-id first. */
13549 /* If there was no error parsing the type-id but the next token is a
13550 '>>', our behavior depends on which dialect of C++ we're
13551 parsing. In C++98, we probably found a typo for '> >'. But there
13552 are type-id which are also valid expressions. For instance:
13554 struct X { int operator >> (int); };
13555 template <int V> struct Foo {};
13556 Foo<X () >> 5> r;
13558 Here 'X()' is a valid type-id of a function type, but the user just
13559 wanted to write the expression "X() >> 5". Thus, we remember that we
13560 found a valid type-id, but we still try to parse the argument as an
13561 expression to see what happens.
13563 In C++0x, the '>>' will be considered two separate '>'
13564 tokens. */
13568 {
13571 }
13572 else
13573 {
13574 /* If the next token isn't a `,' or a `>', then this argument wasn't
13575 really finished. This means that the argument is not a valid
13576 type-id. */
13579 /* If that worked, we're done. */
13582 }
13583 /* We're still not sure what the argument will be. */
13585 /* Try a template. */
13593 /* If the next token isn't a `,' or a `>', then this argument wasn't
13594 really finished. */
13598 {
13599 /* Figure out what is being referred to. If the id-expression
13600 was for a class template specialization, then we will have a
13601 TYPE_DECL at this point. There is no need to do name lookup
13602 at this point in that case. */
13605 none_type,
13614 }
13617 /* It must be a non-type argument. There permitted cases are given
13618 in [temp.arg.nontype]:
13620 -- an integral constant-expression of integral or enumeration
13621 type; or
13623 -- the name of a non-type template-parameter; or
13625 -- the name of an object or function with external linkage...
13627 -- the address of an object or function with external linkage...
13629 -- a pointer to member... */
13630 /* Look for a non-type template parameter. */
13632 {
13644 }
13646 /* If the next token is "&", the argument must be the address of an
13647 object or function with external linkage. */
13650 {
13653 }
13654 /* See if we might have an id-expression. */
13661 {
13664 address_p,
13671 else
13672 {
13673 tree probe;
13676 {
13679 }
13681 /* If we're in a template, we represent a qualified-id referring
13682 to a static data member as a SCOPE_REF even if the scope isn't
13683 dependent so that we can check access control later. */
13688 {
13689 /* A variable without external linkage might still be a
13690 valid constant-expression, so no error is issued here
13691 if the external-linkage check fails. */
13694 }
13696 /* All overloaded functions are allowed; if the external
13697 linkage test does not pass, an error will be issued
13698 later. */
13699 ;
13703 /* A pointer-to-member. */
13704 ;
13706 ;
13707 else
13711 {
13714 tf_warning_or_error);
13716 }
13717 }
13718 }
13719 /* If the argument started with "&", there are no other valid
13720 alternatives at this point. */
13722 {
13725 }
13727 /* If the argument wasn't successfully parsed as a type-id followed
13728 by '>>', the argument can only be a constant expression now.
13729 Otherwise, we try parsing the constant-expression tentatively,
13730 because the argument could really be a type-id. */
13742 /* We did our best to parse the argument as a non type-id, but that
13743 was the only alternative that matched (albeit with a '>' after
13744 it). We can assume it's just a typo from the user, and a
13745 diagnostic will then be issued. */
13747 }
13749 /* Parse an explicit-instantiation.
13751 explicit-instantiation:
13752 template declaration
13754 Although the standard says `declaration', what it really means is:
13756 explicit-instantiation:
13757 template decl-specifier-seq [opt] declarator [opt] ;
13759 Things like `template int S<int>::i = 5, int S<double>::j;' are not
13760 supposed to be allowed. A defect report has been filed about this
13761 issue.
13763 GNU Extension:
13765 explicit-instantiation:
13766 storage-class-specifier template
13767 decl-specifier-seq [opt] declarator [opt] ;
13768 function-specifier template
13769 decl-specifier-seq [opt] declarator [opt] ; */
13771 static void
13773 {
13775 cp_decl_specifier_seq decl_specifiers;
13780 /* Look for an (optional) storage-class-specifier or
13781 function-specifier. */
13783 {
13784 extension_specifier
13787 extension_specifier
13790 }
13792 /* Look for the `template' keyword. */
13794 /* Let the front end know that we are processing an explicit
13795 instantiation. */
13797 /* [temp.explicit] says that we are supposed to ignore access
13798 control while processing explicit instantiation directives. */
13800 /* Parse a decl-specifier-seq. */
13802 CP_PARSER_FLAGS_OPTIONAL,
13805 /* If there was exactly one decl-specifier, and it declared a class,
13806 and there's no declarator, then we have an explicit type
13807 instantiation. */
13809 {
13810 tree type;
13814 /* Turn access control back on for names used during
13815 template instantiation. */
13820 }
13821 else
13822 {
13824 tree decl;
13826 /* Parse the declarator. */
13827 declarator
13837 {
13840 "explicit instantiation shall not use"
13844 "explicit instantiation shall not use"
13849 /* Turn access control back on for names used during
13850 template instantiation. */
13852 /* Do the explicit instantiation. */
13854 }
13855 else
13856 {
13858 /* Skip the body of the explicit instantiation. */
13860 }
13861 }
13862 /* We're done with the instantiation. */
13868 }
13870 /* Parse an explicit-specialization.
13872 explicit-specialization:
13873 template < > declaration
13875 Although the standard says `declaration', what it really means is:
13877 explicit-specialization:
13878 template <> decl-specifier [opt] init-declarator [opt] ;
13879 template <> function-definition
13880 template <> explicit-specialization
13881 template <> template-declaration */
13883 static void
13885 {
13889 /* Look for the `template' keyword. */
13891 /* Look for the `<'. */
13893 /* Look for the `>'. */
13895 /* We have processed another parameter list. */
13897 /* [temp]
13899 A template ... explicit specialization ... shall not have C
13900 linkage. */
13902 {
13904 /* Give it C++ linkage to avoid confusing other parts of the
13905 front end. */
13908 }
13909 else
13911 /* Let the front end know that we are beginning a specialization. */
13913 {
13916 }
13918 /* If the next keyword is `template', we need to figure out whether
13919 or not we're looking a template-declaration. */
13921 {
13926 else
13928 }
13929 else
13930 /* Parse the dependent declaration. */
13936 /* We're done with the specialization. */
13938 /* For the erroneous case of a template with C linkage, we pushed an
13939 implicit C++ linkage scope; exit that scope now. */
13942 /* We're done with this parameter list. */
13944 }
13946 /* Parse a type-specifier.
13948 type-specifier:
13949 simple-type-specifier
13950 class-specifier
13951 enum-specifier
13952 elaborated-type-specifier
13953 cv-qualifier
13955 GNU Extension:
13957 type-specifier:
13958 __complex__
13960 Returns a representation of the type-specifier. For a
13961 class-specifier, enum-specifier, or elaborated-type-specifier, a
13962 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
13964 The parser flags FLAGS is used to control type-specifier parsing.
13966 If IS_DECLARATION is TRUE, then this type-specifier is appearing
13967 in a decl-specifier-seq.
13969 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
13970 class-specifier, enum-specifier, or elaborated-type-specifier, then
13971 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
13972 if a type is declared; 2 if it is defined. Otherwise, it is set to
13973 zero.
13975 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
13976 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
13977 is set to FALSE. */
13979 static tree
13981 cp_parser_flags flags,
13986 {
13992 /* Assume this type-specifier does not declare a new type. */
13995 /* And that it does not specify a cv-qualifier. */
13998 /* Peek at the next token. */
14001 /* If we're looking at a keyword, we can use that to guide the
14002 production we choose. */
14005 {
14010 /* Look for the enum-specifier. */
14012 /* If that worked, we're done. */
14014 {
14019 type_spec,
14020 token,
14023 }
14024 else
14027 /* Any of these indicate either a class-specifier, or an
14028 elaborated-type-specifier. */
14035 /* Parse tentatively so that we can back up if we don't find a
14036 class-specifier. */
14038 /* Look for the class-specifier. */
14041 /* If that worked, we're done. */
14043 {
14048 type_spec,
14049 token,
14052 }
14054 /* Fall through. */
14055 elaborated_type_specifier:
14056 /* We're declaring (not defining) a class or enum. */
14060 /* Fall through. */
14062 /* Look for an elaborated-type-specifier. */
14063 type_spec
14064 = (cp_parser_elaborated_type_specifier
14067 is_declaration));
14070 type_spec,
14071 token,
14094 /* The `__complex__' keyword is a GNU extension. */
14100 }
14102 /* Handle simple keywords. */
14104 {
14106 {
14109 }
14111 }
14113 /* If we do not already have a type-specifier, assume we are looking
14114 at a simple-type-specifier. */
14116 decl_specs,
14117 flags);
14119 /* If we didn't find a type-specifier, and a type-specifier was not
14120 optional in this context, issue an error message. */
14122 {
14125 }
14128 }
14130 /* Parse a simple-type-specifier.
14132 simple-type-specifier:
14133 :: [opt] nested-name-specifier [opt] type-name
14134 :: [opt] nested-name-specifier template template-id
14135 char
14136 wchar_t
14137 bool
14138 short
14139 int
14140 long
14141 signed
14142 unsigned
14143 float
14144 double
14145 void
14147 C++0x Extension:
14149 simple-type-specifier:
14150 auto
14151 decltype ( expression )
14152 char16_t
14153 char32_t
14154 __underlying_type ( type-id )
14156 GNU Extension:
14158 simple-type-specifier:
14159 __int128
14160 __typeof__ unary-expression
14161 __typeof__ ( type-id )
14162 __typeof__ ( type-id ) { initializer-list , [opt] }
14164 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
14165 appropriately updated. */
14167 static tree
14170 cp_parser_flags flags)
14171 {
14175 /* Peek at the next token. */
14178 /* If we're looking at a keyword, things are easy. */
14180 {
14243 /* Since DR 743, decltype can either be a simple-type-specifier by
14244 itself or begin a nested-name-specifier. Parsing it will replace
14245 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
14246 handling below decide what to do. */
14252 /* Consume the `typeof' token. */
14254 /* Parse the operand to `typeof'. */
14256 /* If it is not already a TYPE, take its type. */
14262 token,
14271 token,
14281 token,
14286 }
14288 /* If token is an already-parsed decltype not followed by ::,
14289 it's a simple-type-specifier. */
14292 {
14296 token,
14300 }
14302 /* If the type-specifier was for a built-in type, we're done. */
14304 {
14305 /* Record the type. */
14312 type,
14313 token,
14318 /* Consume the token. */
14321 /* There is no valid C++ program where a non-template type is
14322 followed by a "<". That usually indicates that the user thought
14323 that the type was a template. */
14328 }
14330 /* The type-specifier must be a user-defined type. */
14332 {
14336 /* Don't gobble tokens or issue error messages if this is an
14337 optional type-specifier. */
14341 /* Look for the optional `::' operator. */
14342 global_p
14346 /* Look for the nested-name specifier. */
14347 qualified_p
14355 /* If we have seen a nested-name-specifier, and the next token
14356 is `template', then we are using the template-id production. */
14359 {
14360 /* Look for the template-id. */
14364 none_type,
14366 /* If the template-id did not name a type, we are out of
14367 luck. */
14369 {
14372 }
14373 }
14374 /* Otherwise, look for a type-name. */
14375 else
14377 /* Keep track of all name-lookups performed in class scopes. */
14379 && !global_p
14380 && !qualified_p
14384 /* If it didn't work out, we don't have a TYPE. */
14390 token,
14392 }
14394 /* If we didn't get a type-name, issue an error message. */
14396 {
14399 }
14402 {
14403 /* See if TYPE is an Objective-C type, and if so, parse and
14404 accept any protocol references following it. Do this before
14405 the cp_parser_check_for_invalid_template_id() call, because
14406 Objective-C types can be followed by '<...>' which would
14407 enclose protocol names rather than template arguments, and so
14408 everything is fine. */
14411 {
14415 /* Clobber the "unqualified" type previously entered into
14416 DECL_SPECS with the new, improved protocol-qualified version. */
14421 }
14423 /* There is no valid C++ program where a non-template type is
14424 followed by a "<". That usually indicates that the user
14425 thought that the type was a template. */
14427 none_type,
14429 }
14432 }
14434 /* Parse a type-name.
14436 type-name:
14437 class-name
14438 enum-name
14439 typedef-name
14440 simple-template-id [in c++0x]
14442 enum-name:
14443 identifier
14445 typedef-name:
14446 identifier
14448 Returns a TYPE_DECL for the type. */
14450 static tree
14452 {
14453 tree type_decl;
14455 /* We can't know yet whether it is a class-name or not. */
14457 /* Try a class-name. */
14461 none_type,
14465 /* If it's not a class-name, keep looking. */
14467 {
14469 /* It must be a typedef-name or an enum-name. */
14473 /* It is either a simple-template-id representing an
14474 instantiation of an alias template... */
14478 none_type,
14480 /* Note that this must be an instantiation of an alias template
14481 because [temp.names]/6 says:
14483 A template-id that names an alias template specialization
14484 is a type-name.
14486 Whereas [temp.names]/7 says:
14488 A simple-template-id that names a class template
14489 specialization is a class-name. */
14494 else
14498 /* ... Or a typedef-name or an enum-name. */
14500 }
14503 }
14505 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
14507 enum-name:
14508 identifier
14510 typedef-name:
14511 identifier
14513 Returns a TYPE_DECL for the type. */
14515 static tree
14517 {
14518 tree type_decl;
14519 tree identifier;
14526 /* Look up the type-name. */
14530 {
14534 {
14535 /* We have found a type introduced by a using
14536 declaration at class scope that refers to a dependent
14537 type.
14539 using typename :: [opt] nested-name-specifier unqualified-id ;
14540 */
14546 }
14547 }
14551 {
14552 /* See if this is an Objective-C type. */
14557 }
14559 /* Issue an error if we did not find a type-name. */
14561 /* In Objective-C, we have the complication that class names are
14562 normally type names and start declarations (eg, the
14563 "NSObject" in "NSObject *object;"), but can be used in an
14564 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
14565 is an expression. So, a classname followed by a dot is not a
14566 valid type-name. */
14569 {
14574 }
14575 /* Remember that the name was used in the definition of the
14576 current class so that we can check later to see if the
14577 meaning would have been different after the class was
14578 entirely defined. */
14584 }
14586 /* Parse an elaborated-type-specifier. Note that the grammar given
14587 here incorporates the resolution to DR68.
14589 elaborated-type-specifier:
14590 class-key :: [opt] nested-name-specifier [opt] identifier
14591 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
14592 enum-key :: [opt] nested-name-specifier [opt] identifier
14593 typename :: [opt] nested-name-specifier identifier
14594 typename :: [opt] nested-name-specifier template [opt]
14595 template-id
14597 GNU extension:
14599 elaborated-type-specifier:
14600 class-key attributes :: [opt] nested-name-specifier [opt] identifier
14601 class-key attributes :: [opt] nested-name-specifier [opt]
14602 template [opt] template-id
14603 enum attributes :: [opt] nested-name-specifier [opt] identifier
14605 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
14606 declared `friend'. If IS_DECLARATION is TRUE, then this
14607 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
14608 something is being declared.
14610 Returns the TYPE specified. */
14612 static tree
14616 {
14618 tree identifier;
14621 tree globalscope;
14624 /* See if we're looking at the `enum' keyword. */
14626 {
14627 /* Consume the `enum' token. */
14629 /* Remember that it's an enumeration type. */
14631 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
14632 enums) is used here. */
14635 {
14639 /* Consume the `struct' or `class' and parse it anyway. */
14641 }
14642 /* Parse the attributes. */
14644 }
14645 /* Or, it might be `typename'. */
14647 RID_TYPENAME))
14648 {
14649 /* Consume the `typename' token. */
14651 /* Remember that it's a `typename' type. */
14653 }
14654 /* Otherwise it must be a class-key. */
14655 else
14656 {
14660 /* Parse the attributes. */
14662 }
14664 /* Look for the `::' operator. */
14667 /* Look for the nested-name-specifier. */
14669 {
14674 is_declaration))
14676 }
14677 else
14678 /* Even though `typename' is not present, the proposed resolution
14679 to Core Issue 180 says that in `class A<T>::B', `B' should be
14680 considered a type-name, even if `A<T>' is dependent. */
14685 is_declaration);
14686 /* For everything but enumeration types, consider a template-id.
14687 For an enumeration type, consider only a plain identifier. */
14689 {
14691 tree decl;
14693 /* Allow the `template' keyword. */
14695 /* If we didn't see `template', we don't know if there's a
14696 template-id or not. */
14699 /* Parse the template-id. */
14703 tag_type,
14704 is_declaration);
14705 /* If we didn't find a template-id, look for an ordinary
14706 identifier. */
14708 ;
14709 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
14710 in effect, then we must assume that, upon instantiation, the
14711 template will correspond to a class. */
14715 typename_type,
14717 /* If the `typename' keyword is in effect and DECL is not a type
14718 decl, then type is non existent. */
14720 ;
14726 }
14729 {
14734 {
14737 }
14739 /* For a `typename', we needn't call xref_tag. */
14743 identifier,
14745 /* Look up a qualified name in the usual way. */
14747 {
14748 tree decl;
14749 tree ambiguous_decls;
14752 tag_type,
14759 /* If the lookup was ambiguous, an error will already have been
14760 issued. */
14764 /* If we are parsing friend declaration, DECL may be a
14765 TEMPLATE_DECL tree node here. However, we need to check
14766 whether this TEMPLATE_DECL results in valid code. Consider
14767 the following example:
14769 namespace N {
14770 template <class T> class C {};
14771 }
14772 class X {
14773 template <class T> friend class N::C; // #1, valid code
14774 };
14775 template <class T> class Y {
14776 friend class N::C; // #2, invalid code
14777 };
14779 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
14780 name lookup of `N::C'. We see that friend declaration must
14781 be template for the code to be valid. Note that
14782 processing_template_decl does not work here since it is
14783 always 1 for the above two cases. */
14785 decl = (cp_parser_maybe_treat_template_as_class
14790 {
14793 identifier,
14796 }
14799 {
14803 allow_template);
14807 }
14809 /* Forward declarations of nested types, such as
14811 class C1::C2;
14812 class C1::C2::C3;
14814 are invalid unless all components preceding the final '::'
14815 are complete. If all enclosing types are complete, these
14816 declarations become merely pointless.
14818 Invalid forward declarations of nested types are errors
14819 caught elsewhere in parsing. Those that are pointless arrive
14820 here. */
14827 }
14828 else
14829 {
14830 /* An elaborated-type-specifier sometimes introduces a new type and
14831 sometimes names an existing type. Normally, the rule is that it
14832 introduces a new type only if there is not an existing type of
14833 the same name already in scope. For example, given:
14835 struct S {};
14836 void f() { struct S s; }
14838 the `struct S' in the body of `f' is the same `struct S' as in
14839 the global scope; the existing definition is used. However, if
14840 there were no global declaration, this would introduce a new
14841 local class named `S'.
14843 An exception to this rule applies to the following code:
14845 namespace N { struct S; }
14847 Here, the elaborated-type-specifier names a new type
14848 unconditionally; even if there is already an `S' in the
14849 containing scope this declaration names a new type.
14850 This exception only applies if the elaborated-type-specifier
14851 forms the complete declaration:
14853 [class.name]
14855 A declaration consisting solely of `class-key identifier ;' is
14856 either a redeclaration of the name in the current scope or a
14857 forward declaration of the identifier as a class name. It
14858 introduces the name into the current scope.
14860 We are in this situation precisely when the next token is a `;'.
14862 An exception to the exception is that a `friend' declaration does
14863 *not* name a new type; i.e., given:
14865 struct S { friend struct T; };
14867 `T' is not a new type in the scope of `S'.
14869 Also, `new struct S' or `sizeof (struct S)' never results in the
14870 definition of a new type; a new type can only be declared in a
14871 declaration context. */
14873 tag_scope ts;
14877 /* Friends have special name lookup rules. */
14881 CPP_SEMICOLON))
14882 /* This is a `class-key identifier ;' */
14884 else
14887 template_p =
14891 /* An unqualified name was used to reference this type, so
14892 there were no qualifying templates. */
14899 }
14900 }
14905 /* Allow attributes on forward declarations of classes. */
14907 {
14917 else
14920 }
14923 {
14924 /* Indicate whether this class was declared as a `class' or as a
14925 `struct'. */
14929 }
14931 /* A "<" cannot follow an elaborated type specifier. If that
14932 happens, the user was probably trying to form a template-id. */
14937 }
14939 /* Parse an enum-specifier.
14941 enum-specifier:
14942 enum-head { enumerator-list [opt] }
14943 enum-head { enumerator-list , } [C++0x]
14945 enum-head:
14946 enum-key identifier [opt] enum-base [opt]
14947 enum-key nested-name-specifier identifier enum-base [opt]
14949 enum-key:
14950 enum
14951 enum class [C++0x]
14952 enum struct [C++0x]
14954 enum-base: [C++0x]
14955 : type-specifier-seq
14957 opaque-enum-specifier:
14958 enum-key identifier enum-base [opt] ;
14960 GNU Extensions:
14961 enum-key attributes[opt] identifier [opt] enum-base [opt]
14962 { enumerator-list [opt] }attributes[opt]
14963 enum-key attributes[opt] identifier [opt] enum-base [opt]
14964 { enumerator-list, }attributes[opt] [C++0x]
14966 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
14967 if the token stream isn't an enum-specifier after all. */
14969 static tree
14971 {
14972 tree identifier;
14974 tree prev_scope;
14976 tree attributes;
14989 /* Parse tentatively so that we can back up if we don't find a
14990 enum-specifier. */
14993 /* Caller guarantees that the current token is 'enum', an identifier
14994 possibly follows, and the token after that is an opening brace.
14995 If we don't have an identifier, fabricate an anonymous name for
14996 the enumeration being defined. */
14999 /* Parse the "class" or "struct", which indicates a scoped
15000 enumeration type in C++0x. */
15003 {
15007 /* Consume the `struct' or `class' token. */
15011 }
15015 /* Clear the qualification. */
15020 /* Figure out in what scope the declaration is being placed. */
15026 nested_name_specifier
15034 {
15035 tree name;
15039 enum_type,
15044 input_location);
15046 {
15049 {
15050 /* Are template enums allowed in ISO? */
15054 /* ignore a typename reference, for it will be solved by name
15055 in start_enum. */
15057 }
15058 }
15061 else
15064 }
15065 else
15066 {
15069 else
15070 {
15076 }
15077 }
15080 /* Check for the `:' that denotes a specified underlying type in C++0x.
15081 Note that a ':' could also indicate a bitfield width, however. */
15083 {
15084 cp_decl_specifier_seq type_specifiers;
15086 /* Consume the `:'. */
15089 /* Parse the type-specifier-seq. */
15094 /* At this point this is surely not elaborated type specifier. */
15103 /* If that didn't work, stop. */
15105 {
15110 }
15111 }
15113 /* Look for the `{' but don't consume it yet. */
15115 {
15117 {
15120 {
15123 }
15124 }
15125 /* An opaque-enum-specifier must have a ';' here. */
15128 {
15131 {
15134 }
15135 }
15136 }
15142 {
15144 {
15148 }
15150 {
15152 }
15153 }
15155 /* Issue an error message if type-definitions are forbidden here. */
15158 else
15159 /* Create the new type. We do this before consuming the opening
15160 brace so the enum will be recorded as being on the line of its
15161 tag (or the 'enum' keyword, if there is no tag). */
15165 /* If the next token is not '{' it is an opaque-enum-specifier or an
15166 elaborated-type-specifier. */
15168 {
15172 {
15173 /* The following catches invalid code such as:
15174 enum class S<int>::E { A, B, C }; */
15181 /* If that scope does not contain the scope in which the
15182 class was originally declared, the program is invalid. */
15184 {
15187 "declaration of %qD in namespace %qD which does not "
15190 else
15195 }
15196 }
15201 /* Consume the opening brace. */
15208 {
15212 }
15213 else
15214 {
15219 }
15223 /* If the next token is not '}', then there are some enumerators. */
15225 {
15229 }
15230 else
15233 /* Consume the final '}'. */
15239 }
15240 else
15241 {
15242 /* If a ';' follows, then it is an opaque-enum-specifier
15243 and additional restrictions apply. */
15245 {
15252 }
15253 }
15255 /* Look for trailing attributes to apply to this enumeration, and
15256 apply them if appropriate. */
15258 {
15262 trailing_attr,
15264 }
15266 /* Finish up the enumeration. */
15268 {
15273 }
15276 {
15278 {
15281 }
15283 {
15285 }
15286 }
15287 out:
15290 }
15292 /* Parse an enumerator-list. The enumerators all have the indicated
15293 TYPE.
15295 enumerator-list:
15296 enumerator-definition
15297 enumerator-list , enumerator-definition */
15299 static void
15301 {
15303 {
15304 /* Parse an enumerator-definition. */
15307 /* If the next token is not a ',', we've reached the end of
15308 the list. */
15311 /* Otherwise, consume the `,' and keep going. */
15313 /* If the next token is a `}', there is a trailing comma. */
15315 {
15320 }
15321 }
15322 }
15324 /* Parse an enumerator-definition. The enumerator has the indicated
15325 TYPE.
15327 enumerator-definition:
15328 enumerator
15329 enumerator = constant-expression
15331 enumerator:
15332 identifier */
15334 static void
15336 {
15337 tree identifier;
15338 tree value;
15339 location_t loc;
15341 /* Save the input location because we are interested in the location
15342 of the identifier and not the location of the explicit value. */
15345 /* Look for the identifier. */
15350 /* If the next token is an '=', then there is an explicit value. */
15352 {
15353 /* Consume the `=' token. */
15355 /* Parse the value. */
15358 NULL);
15359 }
15360 else
15363 /* If we are processing a template, make sure the initializer of the
15364 enumerator doesn't contain any bare template parameter pack. */
15368 /* integral_constant_value will pull out this expression, so make sure
15369 it's folded as appropriate. */
15372 /* Create the enumerator. */
15374 }
15376 /* Parse a namespace-name.
15378 namespace-name:
15379 original-namespace-name
15380 namespace-alias
15382 Returns the NAMESPACE_DECL for the namespace. */
15384 static tree
15386 {
15387 tree identifier;
15388 tree namespace_decl;
15392 /* Get the name of the namespace. */
15397 /* Look up the identifier in the currently active scope. Look only
15398 for namespaces, due to:
15400 [basic.lookup.udir]
15402 When looking up a namespace-name in a using-directive or alias
15403 definition, only namespace names are considered.
15405 And:
15407 [basic.lookup.qual]
15409 During the lookup of a name preceding the :: scope resolution
15410 operator, object, function, and enumerator names are ignored.
15412 (Note that cp_parser_qualifying_entity only calls this
15413 function if the token after the name is the scope resolution
15414 operator.) */
15416 none_type,
15422 /* If it's not a namespace, issue an error. */
15425 {
15430 }
15433 }
15435 /* Parse a namespace-definition.
15437 namespace-definition:
15438 named-namespace-definition
15439 unnamed-namespace-definition
15441 named-namespace-definition:
15442 original-namespace-definition
15443 extension-namespace-definition
15445 original-namespace-definition:
15446 namespace identifier { namespace-body }
15448 extension-namespace-definition:
15449 namespace original-namespace-name { namespace-body }
15451 unnamed-namespace-definition:
15452 namespace { namespace-body } */
15454 static void
15456 {
15462 {
15466 }
15467 else
15470 /* Look for the `namespace' keyword. */
15473 /* Get the name of the namespace. We do not attempt to distinguish
15474 between an original-namespace-definition and an
15475 extension-namespace-definition at this point. The semantic
15476 analysis routines are responsible for that. */
15479 else
15482 /* Parse any specified attributes. */
15485 /* Look for the `{' to start the namespace. */
15487 /* Start the namespace. */
15490 /* "inline namespace" is equivalent to a stub namespace definition
15491 followed by a strong using directive. */
15493 {
15495 /* Set up namespace association. */
15499 /* Import the contents of the inline namespace. */
15503 }
15507 /* Parse the body of the namespace. */
15513 /* Finish the namespace. */
15515 /* Look for the final `}'. */
15517 }
15519 /* Parse a namespace-body.
15521 namespace-body:
15522 declaration-seq [opt] */
15524 static void
15526 {
15528 }
15530 /* Parse a namespace-alias-definition.
15532 namespace-alias-definition:
15533 namespace identifier = qualified-namespace-specifier ; */
15535 static void
15537 {
15538 tree identifier;
15539 tree namespace_specifier;
15543 /* Look for the `namespace' keyword. */
15545 /* Look for the identifier. */
15549 /* Look for the `=' token. */
15552 {
15554 /* Skip the definition. */
15559 }
15561 /* Look for the qualified-namespace-specifier. */
15562 namespace_specifier
15564 /* Look for the `;' token. */
15567 /* Register the alias in the symbol table. */
15569 }
15571 /* Parse a qualified-namespace-specifier.
15573 qualified-namespace-specifier:
15574 :: [opt] nested-name-specifier [opt] namespace-name
15576 Returns a NAMESPACE_DECL corresponding to the specified
15577 namespace. */
15579 static tree
15581 {
15582 /* Look for the optional `::'. */
15586 /* Look for the optional nested-name-specifier. */
15594 }
15596 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
15597 access declaration.
15599 using-declaration:
15600 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
15601 using :: unqualified-id ;
15603 access-declaration:
15604 qualified-id ;
15606 */
15608 static bool
15611 {
15615 tree decl;
15616 tree identifier;
15617 tree qscope;
15622 {
15625 }
15626 else
15627 {
15628 /* Look for the `using' keyword. */
15631 /* Peek at the next token. */
15633 /* See if it's `typename'. */
15635 {
15636 /* Remember that we've seen it. */
15638 /* Consume the `typename' token. */
15640 }
15641 }
15643 /* Look for the optional global scope qualification. */
15644 global_scope_p
15649 /* If we saw `typename', or didn't see `::', then there must be a
15650 nested-name-specifier present. */
15656 /* Otherwise, we could be in either of the two productions. In that
15657 case, treat the nested-name-specifier as optional. */
15658 else
15668 /* Something has already gone wrong; there's no need to parse
15669 further. Since an error has occurred, the return value of
15670 cp_parser_parse_definitely will be false, as required. */
15674 /* Parse the unqualified-id. */
15682 {
15687 }
15689 /* The function we call to handle a using-declaration is different
15690 depending on what scope we are in. */
15692 ;
15695 /* [namespace.udecl]
15697 A using declaration shall not name a template-id. */
15700 else
15701 {
15703 {
15704 /* Create the USING_DECL. */
15712 else
15713 /* Add it to the list of members in this class. */
15715 }
15716 else
15717 {
15719 identifier,
15729 else
15731 }
15732 }
15734 /* Look for the final `;'. */
15739 "access declarations are deprecated "
15740 "in favour of using-declarations; "
15744 }
15746 /* Parse an alias-declaration.
15748 alias-declaration:
15749 using identifier attribute-specifier-seq [opt] = type-id */
15751 static tree
15753 {
15755 location_t id_location;
15757 cp_decl_specifier_seq decl_specs;
15761 /* Look for the `using' keyword. */
15762 cp_token *using_token
15784 /* Now we are going to parse the type-id of the declaration. */
15786 /*
15787 [dcl.type]/3 says:
15789 "A type-specifier-seq shall not define a class or enumeration
15790 unless it appears in the type-id of an alias-declaration (7.1.3) that
15791 is not the declaration of a template-declaration."
15793 In other words, if we currently are in an alias template, the
15794 type-id should not define a type.
15796 So let's set parser->type_definition_forbidden_message in that
15797 case; cp_parser_check_type_definition (called by
15798 cp_parser_class_specifier) will then emit an error if a type is
15799 defined in the type-id. */
15801 {
15805 }
15809 /* Restore the error message if need be. */
15814 {
15817 }
15822 {
15825 }
15827 /* A typedef-name can also be introduced by an alias-declaration. The
15828 identifier following the using keyword becomes a typedef-name. It has
15829 the same semantics as if it were introduced by the typedef
15830 specifier. In particular, it does not define a new type and it shall
15831 not appear in the type-id. */
15836 {
15839 ds_attribute,
15840 attrs_token);
15841 }
15843 ds_typedef,
15844 using_token);
15846 ds_alias,
15847 using_token);
15856 else
15867 /* If decl is a template, return its TEMPLATE_DECL so that it gets
15868 added into the symbol table; otherwise, return the TYPE_DECL. */
15872 {
15876 }
15879 }
15881 /* Parse a using-directive.
15883 using-directive:
15884 using namespace :: [opt] nested-name-specifier [opt]
15885 namespace-name ; */
15887 static void
15889 {
15890 tree namespace_decl;
15891 tree attribs;
15893 /* Look for the `using' keyword. */
15895 /* And the `namespace' keyword. */
15897 /* Look for the optional `::' operator. */
15899 /* And the optional nested-name-specifier. */
15905 /* Get the namespace being used. */
15907 /* And any specified attributes. */
15909 /* Update the symbol table. */
15911 /* Look for the final `;'. */
15913 }
15915 /* Parse an asm-definition.
15917 asm-definition:
15918 asm ( string-literal ) ;
15920 GNU Extension:
15922 asm-definition:
15923 asm volatile [opt] ( string-literal ) ;
15924 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
15925 asm volatile [opt] ( string-literal : asm-operand-list [opt]
15926 : asm-operand-list [opt] ) ;
15927 asm volatile [opt] ( string-literal : asm-operand-list [opt]
15928 : asm-operand-list [opt]
15929 : asm-clobber-list [opt] ) ;
15930 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
15931 : asm-clobber-list [opt]
15932 : asm-goto-list ) ; */
15934 static void
15936 {
15937 tree string;
15942 tree asm_stmt;
15950 /* Look for the `asm' keyword. */
15952 /* See if the next token is `volatile'. */
15955 {
15956 /* Remember that we saw the `volatile' keyword. */
15958 /* Consume the token. */
15960 }
15964 {
15965 /* Remember that we saw the `goto' keyword. */
15967 /* Consume the token. */
15969 }
15970 /* Look for the opening `('. */
15973 /* Look for the string. */
15976 {
15980 }
15982 /* If we're allowing GNU extensions, check for the extended assembly
15983 syntax. Unfortunately, the `:' tokens need not be separated by
15984 a space in C, and so, for compatibility, we tolerate that here
15985 too. Doing that means that we have to treat the `::' operator as
15986 two `:' tokens. */
15991 {
15996 /* The extended syntax was used. */
15999 /* Look for outputs. */
16001 {
16002 /* Consume the `:'. */
16004 /* Parse the output-operands. */
16006 CPP_COLON)
16008 CPP_SCOPE)
16010 CPP_CLOSE_PAREN)
16016 }
16017 /* If the next token is `::', there are no outputs, and the
16018 next token is the beginning of the inputs. */
16020 /* The inputs are coming next. */
16023 /* Look for inputs. */
16026 {
16027 /* Consume the `:' or `::'. */
16029 /* Parse the output-operands. */
16031 CPP_COLON)
16033 CPP_SCOPE)
16035 CPP_CLOSE_PAREN))
16040 }
16042 /* The clobbers are coming next. */
16045 /* Look for clobbers. */
16048 {
16050 /* Consume the `:' or `::'. */
16052 /* Parse the clobbers. */
16054 CPP_COLON)
16056 CPP_CLOSE_PAREN))
16058 }
16061 /* The labels are coming next. */
16064 /* Look for labels. */
16067 {
16069 /* Consume the `:' or `::'. */
16071 /* Parse the labels. */
16073 }
16077 }
16081 /* Look for the closing `)'. */
16089 {
16090 /* Create the ASM_EXPR. */
16092 {
16095 /* If the extended syntax was not used, mark the ASM_EXPR. */
16097 {
16103 }
16104 }
16105 else
16107 }
16108 }
16110 /* Declarators [gram.dcl.decl] */
16112 /* Parse an init-declarator.
16114 init-declarator:
16115 declarator initializer [opt]
16117 GNU Extension:
16119 init-declarator:
16120 declarator asm-specification [opt] attributes [opt] initializer [opt]
16122 function-definition:
16123 decl-specifier-seq [opt] declarator ctor-initializer [opt]
16124 function-body
16125 decl-specifier-seq [opt] declarator function-try-block
16127 GNU Extension:
16129 function-definition:
16130 __extension__ function-definition
16132 TM Extension:
16134 function-definition:
16135 decl-specifier-seq [opt] declarator function-transaction-block
16137 The DECL_SPECIFIERS apply to this declarator. Returns a
16138 representation of the entity declared. If MEMBER_P is TRUE, then
16139 this declarator appears in a class scope. The new DECL created by
16140 this declarator is returned.
16142 The CHECKS are access checks that should be performed once we know
16143 what entity is being declared (and, therefore, what classes have
16144 befriended it).
16146 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
16147 for a function-definition here as well. If the declarator is a
16148 declarator for a function-definition, *FUNCTION_DEFINITION_P will
16149 be TRUE upon return. By that point, the function-definition will
16150 have been completely parsed.
16152 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
16153 is FALSE.
16155 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
16156 parsed declaration if it is an uninitialized single declarator not followed
16157 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
16158 if present, will not be consumed. If returned, this declarator will be
16159 created with SD_INITIALIZED but will not call cp_finish_decl. */
16161 static tree
16170 {
16174 tree prefix_attributes;
16176 tree asm_specification;
16177 tree initializer;
16179 tree scope;
16181 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
16182 initialized with "= ..", CPP_OPEN_PAREN if initialized with
16183 "(...)". */
16192 /* Gather the attributes that were provided with the
16193 decl-specifiers. */
16196 /* Assume that this is not the declarator for a function
16197 definition. */
16201 /* Defer access checks while parsing the declarator; we cannot know
16202 what names are accessible until we know what is being
16203 declared. */
16206 /* Parse the declarator. */
16208 declarator
16212 member_p);
16213 /* Gather up the deferred checks. */
16216 /* If the DECLARATOR was erroneous, there's no need to go
16217 further. */
16221 /* Check that the number of template-parameter-lists is OK. */
16231 /* Figure out what scope the entity declared by the DECLARATOR is
16232 located in. `grokdeclarator' sometimes changes the scope, so
16233 we compute it now. */
16236 /* Perform any lookups in the declared type which were thought to be
16237 dependent, but are not in the scope of the declarator. */
16238 decl_specifiers->type
16241 /* If we're allowing GNU extensions, look for an
16242 asm-specification. */
16244 {
16245 /* Look for an asm-specification. */
16248 }
16249 else
16252 /* Look for attributes. */
16256 /* Peek at the next token. */
16258 /* Check to see if the token indicates the start of a
16259 function-definition. */
16262 {
16264 {
16265 /* If a function-definition should not appear here, issue an
16266 error message. */
16270 }
16271 else
16272 {
16273 location_t func_brace_location
16276 /* Neither attributes nor an asm-specification are allowed
16277 on a function-definition. */
16280 "an asm-specification is not allowed "
16285 /* This is a function-definition. */
16288 /* Parse the function definition. */
16291 decl_specifiers,
16292 declarator,
16293 prefix_attributes);
16294 else
16295 decl
16296 = (cp_parser_function_definition_from_specifiers_and_declarator
16300 {
16301 /* This is where the prologue starts... */
16304 }
16307 }
16308 }
16310 /* [dcl.dcl]
16312 Only in function declarations for constructors, destructors, and
16313 type conversions can the decl-specifier-seq be omitted.
16315 We explicitly postpone this check past the point where we handle
16316 function-definitions because we tolerate function-definitions
16317 that are missing their return types in some modes. */
16319 {
16323 }
16325 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
16329 {
16337 {
16343 }
16344 }
16345 else
16346 {
16347 /* If the init-declarator isn't initialized and isn't followed by a
16348 `,' or `;', it's not a valid init-declarator. */
16351 {
16354 else
16355 {
16358 }
16359 }
16362 }
16364 /* Because start_decl has side-effects, we should only call it if we
16365 know we're going ahead. By this point, we know that we cannot
16366 possibly be looking at any other construct. */
16369 /* If the decl specifiers were bad, issue an error now that we're
16370 sure this was intended to be a declarator. Then continue
16371 declaring the variable(s), as int, to try to cut down on further
16372 errors. */
16375 {
16378 }
16380 /* Check to see whether or not this declaration is a friend. */
16383 /* Enter the newly declared entry in the symbol table. If we're
16384 processing a declaration in a class-specifier, we wait until
16385 after processing the initializer. */
16387 {
16394 /* Adjust location of decl if declarator->id_loc is more appropriate:
16395 set, and decl wasn't merged with another decl, in which case its
16396 location would be different from input_location, and more accurate. */
16401 }
16403 /* Enter the SCOPE. That way unqualified names appearing in the
16404 initializer will be looked up in SCOPE. */
16407 /* Perform deferred access control checks, now that we know in which
16408 SCOPE the declared entity resides. */
16410 {
16413 /* If the entity being declared is a function, pretend that we
16414 are in its scope. If it is a `friend', it may have access to
16415 things that would not otherwise be accessible. */
16417 {
16420 }
16422 /* Perform access checks for template parameters. */
16425 /* Perform the access control checks for the declarator and the
16426 decl-specifiers. */
16429 /* Restore the saved value. */
16432 }
16434 /* Parse the initializer. */
16439 {
16441 {
16445 else
16446 {
16447 /* If the declaration was erroneous, we don't really
16448 know what the user intended, so just silently
16449 consume the initializer. */
16457 }
16458 }
16459 else
16460 {
16461 /* We want to record the extra mangling scope for in-class
16462 initializers of class members and initializers of static data
16463 member templates. The former involves deferring
16464 parsing of the initializer until end of class as with default
16465 arguments. So right here we only handle the latter. */
16475 }
16476 }
16478 /* The old parser allows attributes to appear after a parenthesized
16479 initializer. Mark Mitchell proposed removing this functionality
16480 on the GCC mailing lists on 2002-08-13. This parser accepts the
16481 attributes -- but ignores them. */
16488 /* For an in-class declaration, use `grokfield' to create the
16489 declaration. */
16491 {
16493 {
16496 }
16500 prefix_attributes);
16503 }
16505 /* Finish processing the declaration. But, skip member
16506 declarations. */
16508 {
16511 asm_specification,
16512 /* If the initializer is in parentheses, then this is
16513 a direct-initialization, which means that an
16514 `explicit' constructor is OK. Otherwise, an
16515 `explicit' constructor cannot be used. */
16518 }
16521 /* Core issue #226 (C++0x only): A default template-argument
16522 shall not be specified in a friend class template
16523 declaration. */
16531 }
16533 /* Parse a declarator.
16535 declarator:
16536 direct-declarator
16537 ptr-operator declarator
16539 abstract-declarator:
16540 ptr-operator abstract-declarator [opt]
16541 direct-abstract-declarator
16543 GNU Extensions:
16545 declarator:
16546 attributes [opt] direct-declarator
16547 attributes [opt] ptr-operator declarator
16549 abstract-declarator:
16550 attributes [opt] ptr-operator abstract-declarator [opt]
16551 attributes [opt] direct-abstract-declarator
16553 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
16554 detect constructor, destructor or conversion operators. It is set
16555 to -1 if the declarator is a name, and +1 if it is a
16556 function. Otherwise it is set to zero. Usually you just want to
16557 test for >0, but internally the negative value is used.
16559 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
16560 a decl-specifier-seq unless it declares a constructor, destructor,
16561 or conversion. It might seem that we could check this condition in
16562 semantic analysis, rather than parsing, but that makes it difficult
16563 to handle something like `f()'. We want to notice that there are
16564 no decl-specifiers, and therefore realize that this is an
16565 expression, not a declaration.)
16567 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
16568 the declarator is a direct-declarator of the form "(...)".
16570 MEMBER_P is true iff this declarator is a member-declarator. */
16574 cp_parser_declarator_kind dcl_kind,
16578 {
16581 cp_cv_quals cv_quals;
16582 tree class_type;
16585 /* Assume this is not a constructor, destructor, or type-conversion
16586 operator. */
16593 /* Check for the ptr-operator production. */
16595 /* Parse the ptr-operator. */
16601 /* If that worked, then we have a ptr-operator. */
16603 {
16604 /* If a ptr-operator was found, then this declarator was not
16605 parenthesized. */
16608 /* The dependent declarator is optional if we are parsing an
16609 abstract-declarator. */
16613 /* Parse the dependent declarator. */
16619 /* If we are parsing an abstract-declarator, we must handle the
16620 case where the dependent declarator is absent. */
16625 declarator = cp_parser_make_indirect_declarator
16627 }
16628 /* Everything else is a direct-declarator. */
16629 else
16630 {
16633 CPP_OPEN_PAREN);
16635 ctor_dtor_or_conv_p,
16636 member_p);
16637 }
16642 }
16644 /* Parse a direct-declarator or direct-abstract-declarator.
16646 direct-declarator:
16647 declarator-id
16648 direct-declarator ( parameter-declaration-clause )
16649 cv-qualifier-seq [opt]
16650 ref-qualifier [opt]
16651 exception-specification [opt]
16652 direct-declarator [ constant-expression [opt] ]
16653 ( declarator )
16655 direct-abstract-declarator:
16656 direct-abstract-declarator [opt]
16657 ( parameter-declaration-clause )
16658 cv-qualifier-seq [opt]
16659 ref-qualifier [opt]
16660 exception-specification [opt]
16661 direct-abstract-declarator [opt] [ constant-expression [opt] ]
16662 ( abstract-declarator )
16664 Returns a representation of the declarator. DCL_KIND is
16665 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
16666 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
16667 we are parsing a direct-declarator. It is
16668 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
16669 of ambiguity we prefer an abstract declarator, as per
16670 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
16671 cp_parser_declarator. */
16675 cp_parser_declarator_kind dcl_kind,
16678 {
16688 {
16689 /* Peek at the next token. */
16692 {
16693 /* This is either a parameter-declaration-clause, or a
16694 parenthesized declarator. When we know we are parsing a
16695 named declarator, it must be a parenthesized declarator
16696 if FIRST is true. For instance, `(int)' is a
16697 parameter-declaration-clause, with an omitted
16698 direct-abstract-declarator. But `((*))', is a
16699 parenthesized abstract declarator. Finally, when T is a
16700 template parameter `(T)' is a
16701 parameter-declaration-clause, and not a parenthesized
16702 named declarator.
16704 We first try and parse a parameter-declaration-clause,
16705 and then try a nested declarator (if FIRST is true).
16707 It is not an error for it not to be a
16708 parameter-declaration-clause, even when FIRST is
16709 false. Consider,
16711 int i (int);
16712 int i (3);
16714 The first is the declaration of a function while the
16715 second is the definition of a variable, including its
16716 initializer.
16718 Having seen only the parenthesis, we cannot know which of
16719 these two alternatives should be selected. Even more
16720 complex are examples like:
16722 int i (int (a));
16723 int i (int (3));
16725 The former is a function-declaration; the latter is a
16726 variable initialization.
16728 Thus again, we try a parameter-declaration-clause, and if
16729 that fails, we back out and return. */
16732 {
16733 tree params;
16736 tree t;
16738 /* In a member-declarator, the only valid interpretation
16739 of a parenthesis is the start of a
16740 parameter-declaration-clause. (It is invalid to
16741 initialize a static data member with a parenthesized
16742 initializer; only the "=" form of initialization is
16743 permitted.) */
16747 /* Consume the `('. */
16750 {
16751 /* If this is going to be an abstract declarator, we're
16752 in a declarator and we can't have default args. */
16755 }
16757 /* Inside the function parameter list, surrounding
16758 template-parameter-lists do not apply. */
16759 saved_num_template_parameter_lists
16765 /* Parse the parameter-declaration-clause. */
16768 parser->num_template_parameter_lists
16771 /* Consume the `)'. */
16774 /* If all went well, parse the cv-qualifier-seq,
16775 ref-qualifier and the exception-specification. */
16777 {
16778 cp_cv_quals cv_quals;
16779 cp_virt_specifiers virt_specifiers;
16780 cp_ref_qualifier ref_qual;
16781 tree exception_specification;
16782 tree late_return;
16783 tree attrs;
16793 /* Parse the cv-qualifier-seq. */
16795 /* Parse the ref-qualifier. */
16797 /* And the exception-specification. */
16798 exception_specification
16803 late_return = (cp_parser_late_return_type_opt
16806 /* Parse the virt-specifier-seq. */
16809 /* Create the function-declarator. */
16811 params,
16812 cv_quals,
16813 virt_specifiers,
16814 ref_qual,
16815 exception_specification,
16816 late_return);
16818 /* Any subsequent parameter lists are to do with
16819 return type, so are not those of the declared
16820 function. */
16822 }
16824 /* Remove the function parms from scope. */
16830 /* Repeat the main loop. */
16832 }
16834 /* If this is the first, we can try a parenthesized
16835 declarator. */
16837 {
16843 /* Consume the `('. */
16845 /* Parse the nested declarator. */
16848 declarator
16851 member_p);
16854 /* Expect a `)'. */
16861 }
16862 /* Otherwise, we must be done. */
16863 else
16865 }
16869 {
16870 /* Parse an array-declarator. */
16879 /* Consume the `['. */
16881 /* Peek at the next token. */
16883 /* If the next token is `]', then there is no
16884 constant-expression. */
16886 {
16888 bounds
16898 {
16899 /* Normally, the array bound must be an integral constant
16900 expression. However, as an extension, we allow VLAs
16901 in function scopes as long as they aren't part of a
16902 parameter declaration. */
16906 }
16908 {
16909 /* Remember this wasn't a constant-expression. */
16912 }
16913 }
16914 else
16916 /* Look for the closing `]'. */
16918 {
16921 }
16926 }
16928 {
16929 {
16930 tree qualifying_scope;
16931 tree unqualified_name;
16932 tree attrs;
16933 special_function_kind sfk;
16938 /* Parse a declarator-id */
16941 {
16944 /* If we see an ellipsis, we should be looking at a
16945 parameter pack. */
16947 {
16948 /* Consume the `...' */
16952 }
16953 }
16956 unqualified_name
16960 {
16964 {
16965 /* Check whether an error occurred. */
16968 /* We already consumed the ellipsis to mark a
16969 parameter pack, but we have no way to report it,
16970 so abort the tentative parse. We will be exiting
16971 immediately anyway. */
16973 }
16974 else
16980 && (qualifying_scope
16982 {
16985 }
16986 }
16991 {
16996 }
17002 {
17003 /* In the declaration of a member of a template class
17004 outside of the class itself, the SCOPE will sometimes
17005 be a TYPENAME_TYPE. For example, given:
17007 template <typename T>
17008 int S<T>::R::i = 3;
17010 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
17011 this context, we must resolve S<T>::R to an ordinary
17012 type, rather than a typename type.
17014 The reason we normally avoid resolving TYPENAME_TYPEs
17015 is that a specialization of `S' might render
17016 `S<T>::R' not a type. However, if `S' is
17017 specialized, then this `i' will not be used, so there
17018 is no harm in resolving the types here. */
17019 tree type;
17021 /* Resolve the TYPENAME_TYPE. */
17024 /* If that failed, the declarator is invalid. */
17026 {
17029 "cannot define member of dependent typedef "
17031 else
17036 }
17038 }
17043 {
17044 tree class_type;
17049 else
17053 {
17056 {
17059 {
17063 "use %<%T::%D%> instead of %<%T::%D%> to "
17065 class_type,
17070 }
17071 else
17073 }
17074 else
17075 {
17076 /* We do not attempt to print the declarator
17077 here because we do not have enough
17078 information about its original syntactic
17079 form. */
17083 }
17084 }
17087 {
17093 for an anonymous type, even if the type
17094 got a name for linkage purposes. */
17097 class_type))
17098 {
17101 }
17109 }
17110 }
17112 unqualified_name,
17113 sfk);
17120 }
17122 handle_declarator:;
17125 {
17126 /* Any names that appear after the declarator-id for a
17127 member are looked up in the containing scope. */
17129 {
17130 /* But declarations with qualified-ids can't appear in a
17131 function. */
17134 }
17136 }
17140 /* Default args are only allowed on function
17141 declarations. */
17143 else
17147 }
17148 /* We're done. */
17149 else
17151 }
17153 /* For an abstract declarator, we might wind up with nothing at this
17154 point. That's an error; the declarator is not optional. */
17158 /* If we entered a scope, we must exit it now. */
17166 }
17168 /* Parse a ptr-operator.
17170 ptr-operator:
17171 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17172 * cv-qualifier-seq [opt]
17173 &
17174 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
17175 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17177 GNU Extension:
17179 ptr-operator:
17180 & cv-qualifier-seq [opt]
17182 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
17183 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
17184 an rvalue reference. In the case of a pointer-to-member, *TYPE is
17185 filled in with the TYPE containing the member. *CV_QUALS is
17186 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
17187 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
17188 Note that the tree codes returned by this function have nothing
17189 to do with the types of trees that will be eventually be created
17190 to represent the pointer or reference type being parsed. They are
17191 just constants with suggestive names. */
17192 static enum tree_code
17197 {
17202 /* Assume that it's not a pointer-to-member. */
17204 /* And that there are no cv-qualifiers. */
17207 /* Peek at the next token. */
17210 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
17220 {
17221 /* Consume the `*', `&' or `&&'. */
17224 /* A `*' can be followed by a cv-qualifier-seq, and so can a
17225 `&', if we are allowing GNU extensions. (The only qualifier
17226 that can legally appear after `&' is `restrict', but that is
17227 enforced during semantic analysis. */
17235 }
17236 else
17237 {
17238 /* Try the pointer-to-member case. */
17240 /* Look for the optional `::' operator. */
17243 /* Look for the nested-name specifier. */
17250 /* If we found it, and the next token is a `*', then we are
17251 indeed looking at a pointer-to-member operator. */
17254 {
17255 /* Indicate that the `*' operator was used. */
17263 else
17264 {
17265 /* The type of which the member is a member is given by the
17266 current SCOPE. */
17268 /* The next name will not be qualified. */
17272 /* Look for optional c++11 attributes. */
17276 /* Look for the optional cv-qualifier-seq. */
17278 }
17279 }
17280 /* If that didn't work we don't have a ptr-operator. */
17283 }
17286 }
17288 /* Parse an (optional) cv-qualifier-seq.
17290 cv-qualifier-seq:
17291 cv-qualifier cv-qualifier-seq [opt]
17293 cv-qualifier:
17294 const
17295 volatile
17297 GNU Extension:
17299 cv-qualifier:
17300 __restrict__
17302 Returns a bitmask representing the cv-qualifiers. */
17304 static cp_cv_quals
17306 {
17310 {
17312 cp_cv_quals cv_qualifier;
17314 /* Peek at the next token. */
17316 /* See if it's a cv-qualifier. */
17318 {
17334 }
17340 {
17343 }
17344 else
17345 {
17348 }
17349 }
17352 }
17354 /* Parse an (optional) ref-qualifier
17356 ref-qualifier:
17357 &
17358 &&
17360 Returns cp_ref_qualifier representing ref-qualifier. */
17362 static cp_ref_qualifier
17364 {
17368 {
17373 {
17385 }
17390 {
17393 }
17394 else
17395 {
17398 }
17399 }
17402 }
17404 /* Parse an (optional) virt-specifier-seq.
17406 virt-specifier-seq:
17407 virt-specifier virt-specifier-seq [opt]
17409 virt-specifier:
17410 override
17411 final
17413 Returns a bitmask representing the virt-specifiers. */
17415 static cp_virt_specifiers
17417 {
17421 {
17423 cp_virt_specifiers virt_specifier;
17425 /* Peek at the next token. */
17427 /* See if it's a virt-specifier-qualifier. */
17431 {
17434 }
17436 {
17439 }
17441 {
17443 }
17444 else
17448 {
17451 }
17452 else
17453 {
17456 }
17457 }
17459 }
17461 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
17462 is in scope even though it isn't real. */
17464 static void
17466 {
17467 tree this_parm;
17470 {
17471 /* We don't clear this between NSDMIs. Is it already what we want? */
17476 }
17479 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
17481 current_class_ref
17484 }
17486 /* Return true iff our current scope is a non-static data member
17487 initializer. */
17489 bool
17491 {
17492 /* We recognize NSDMI context by the context-less 'this' pointer set up
17493 by the function above. */
17497 }
17499 /* Parse a late-specified return type, if any. This is not a separate
17500 non-terminal, but part of a function declarator, which looks like
17502 -> trailing-type-specifier-seq abstract-declarator(opt)
17504 Returns the type indicated by the type-id.
17506 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
17507 function. */
17509 static tree
17511 {
17513 tree type;
17515 /* Peek at the next token. */
17517 /* A late-specified return type is indicated by an initial '->'. */
17521 /* Consume the ->. */
17527 {
17528 /* DR 1207: 'this' is in scope in the trailing return type. */
17530 }
17535 {
17538 }
17541 }
17543 /* Parse a declarator-id.
17545 declarator-id:
17546 id-expression
17547 :: [opt] nested-name-specifier [opt] type-name
17549 In the `id-expression' case, the value returned is as for
17550 cp_parser_id_expression if the id-expression was an unqualified-id.
17551 If the id-expression was a qualified-id, then a SCOPE_REF is
17552 returned. The first operand is the scope (either a NAMESPACE_DECL
17553 or TREE_TYPE), but the second is still just a representation of an
17554 unqualified-id. */
17556 static tree
17558 {
17559 tree id;
17560 /* The expression must be an id-expression. Assume that qualified
17561 names are the names of types so that:
17563 template <class T>
17564 int S<T>::R::i = 3;
17566 will work; we must treat `S<T>::R' as the name of a type.
17567 Similarly, assume that qualified names are templates, where
17568 required, so that:
17570 template <class T>
17571 int S<T>::R<T>::i = 3;
17573 will work, too. */
17579 optional_p);
17583 }
17585 /* Parse a type-id.
17587 type-id:
17588 type-specifier-seq abstract-declarator [opt]
17590 Returns the TYPE specified. */
17592 static tree
17595 {
17596 cp_decl_specifier_seq type_specifier_seq;
17599 /* Parse the type-specifier-seq. */
17601 is_trailing_return,
17606 /* There might or might not be an abstract declarator. */
17608 /* Look for the declarator. */
17609 abstract_declarator
17613 /* Check to see if there really was a declarator. */
17620 {
17621 /* A type-id with type 'auto' is only ok if the abstract declarator
17622 is a function declarator with a late-specified return type. */
17627 else
17628 {
17631 }
17632 }
17635 is_template_arg);
17636 }
17639 {
17641 }
17644 {
17645 tree r;
17647 parser->type_definition_forbidden_message
17652 }
17655 {
17657 }
17659 /* Parse a type-specifier-seq.
17661 type-specifier-seq:
17662 type-specifier type-specifier-seq [opt]
17664 GNU extension:
17666 type-specifier-seq:
17667 attributes type-specifier-seq [opt]
17669 If IS_DECLARATION is true, we are at the start of a "condition" or
17670 exception-declaration, so we might be followed by a declarator-id.
17672 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
17673 i.e. we've just seen "->".
17675 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
17677 static void
17682 {
17687 /* Clear the TYPE_SPECIFIER_SEQ. */
17690 /* In the context of a trailing return type, enum E { } is an
17691 elaborated-type-specifier followed by a function-body, not an
17692 enum-specifier. */
17696 /* Parse the type-specifiers and attributes. */
17698 {
17699 tree type_specifier;
17702 /* Check for attributes first. */
17704 {
17709 }
17711 /* record the token of the beginning of the type specifier seq,
17712 for error reporting purposes*/
17716 /* Look for the type-specifier. */
17718 flags,
17719 type_specifier_seq,
17721 NULL,
17724 {
17725 /* If the first type-specifier could not be found, this is not a
17726 type-specifier-seq at all. */
17728 {
17732 }
17733 /* If subsequent type-specifiers could not be found, the
17734 type-specifier-seq is complete. */
17736 }
17739 /* The standard says that a condition can be:
17741 type-specifier-seq declarator = assignment-expression
17743 However, given:
17745 struct S {};
17746 if (int S = ...)
17748 we should treat the "S" as a declarator, not as a
17749 type-specifier. The standard doesn't say that explicitly for
17750 type-specifier-seq, but it does say that for
17751 decl-specifier-seq in an ordinary declaration. Perhaps it
17752 would be clearer just to allow a decl-specifier-seq here, and
17753 then add a semantic restriction that if any decl-specifiers
17754 that are not type-specifiers appear, the program is invalid. */
17757 }
17758 }
17760 /* Parse a parameter-declaration-clause.
17762 parameter-declaration-clause:
17763 parameter-declaration-list [opt] ... [opt]
17764 parameter-declaration-list , ...
17766 Returns a representation for the parameter declarations. A return
17767 value of NULL indicates a parameter-declaration-clause consisting
17768 only of an ellipsis. */
17770 static tree
17772 {
17773 tree parameters;
17778 /* Peek at the next token. */
17780 /* Check for trivial parameter-declaration-clauses. */
17782 {
17783 /* Consume the `...' token. */
17786 }
17788 /* There are no parameters. */
17789 {
17790 #ifndef NO_IMPLICIT_EXTERN_C
17794 else
17795 #endif
17797 }
17798 /* Check for `(void)', too, which is a special case. */
17802 {
17803 /* Consume the `void' token. */
17805 /* There are no parameters. */
17807 }
17809 /* Parse the parameter-declaration-list. */
17811 /* If a parse error occurred while parsing the
17812 parameter-declaration-list, then the entire
17813 parameter-declaration-clause is erroneous. */
17817 /* Peek at the next token. */
17819 /* If it's a `,', the clause should terminate with an ellipsis. */
17821 {
17822 /* Consume the `,'. */
17824 /* Expect an ellipsis. */
17825 ellipsis_p
17827 }
17828 /* It might also be `...' if the optional trailing `,' was
17829 omitted. */
17831 {
17832 /* Consume the `...' token. */
17834 /* And remember that we saw it. */
17836 }
17837 else
17840 /* Finish the parameter list. */
17845 }
17847 /* Parse a parameter-declaration-list.
17849 parameter-declaration-list:
17850 parameter-declaration
17851 parameter-declaration-list , parameter-declaration
17853 Returns a representation of the parameter-declaration-list, as for
17854 cp_parser_parameter_declaration_clause. However, the
17855 `void_list_node' is never appended to the list. Upon return,
17856 *IS_ERROR will be true iff an error occurred. */
17858 static tree
17860 {
17866 /* Assume all will go well. */
17868 /* The special considerations that apply to a function within an
17869 unbraced linkage specifications do not apply to the parameters
17870 to the function. */
17871 saved_in_unbraced_linkage_specification_p
17875 /* Look for more parameters. */
17877 {
17881 /* Parse the parameter. */
17882 parameter
17887 /* We don't know yet if the enclosing context is deprecated, so wait
17888 and warn in grokparms if appropriate. */
17894 PARM,
17900 /* If a parse error occurred parsing the parameter declaration,
17901 then the entire parameter-declaration-list is erroneous. */
17903 {
17907 }
17917 {
17921 }
17923 /* Add the new parameter to the list. */
17927 /* Peek at the next token. */
17930 /* These are for Objective-C++ */
17933 /* The parameter-declaration-list is complete. */
17936 {
17939 /* Peek at the next token. */
17941 /* If it's an ellipsis, then the list is complete. */
17944 /* Otherwise, there must be more parameters. Consume the
17945 `,'. */
17947 /* When parsing something like:
17949 int i(float f, double d)
17951 we can tell after seeing the declaration for "f" that we
17952 are not looking at an initialization of a variable "i",
17953 but rather at the declaration of a function "i".
17955 Due to the fact that the parsing of template arguments
17956 (as specified to a template-id) requires backtracking we
17957 cannot use this technique when inside a template argument
17958 list. */
17962 /* However, a parameter-declaration of the form
17963 "float(f)" (which is a valid declaration of a
17964 parameter "f") can also be interpreted as an
17965 expression (the conversion of "f" to "float"). */
17968 }
17969 else
17970 {
17978 }
17979 }
17981 parser->in_unbraced_linkage_specification_p
17985 }
17987 /* Parse a parameter declaration.
17989 parameter-declaration:
17990 decl-specifier-seq ... [opt] declarator
17991 decl-specifier-seq declarator = assignment-expression
17992 decl-specifier-seq ... [opt] abstract-declarator [opt]
17993 decl-specifier-seq abstract-declarator [opt] = assignment-expression
17995 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
17996 declares a template parameter. (In that case, a non-nested `>'
17997 token encountered during the parsing of the assignment-expression
17998 is not interpreted as a greater-than operator.)
18000 Returns a representation of the parameter, or NULL if an error
18001 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
18002 true iff the declarator is of the form "(p)". */
18008 {
18010 cp_decl_specifier_seq decl_specifiers;
18012 tree default_argument;
18016 /* In a template parameter, `>' is not an operator.
18018 [temp.param]
18020 When parsing a default template-argument for a non-type
18021 template-parameter, the first non-nested `>' is taken as the end
18022 of the template parameter-list rather than a greater-than
18023 operator. */
18025 /* Type definitions may not appear in parameter types. */
18027 parser->type_definition_forbidden_message
18030 /* Parse the declaration-specifiers. */
18032 CP_PARSER_FLAGS_NONE,
18036 /* Complain about missing 'typename' or other invalid type names. */
18041 /* If an error occurred, there's no reason to attempt to parse the
18042 rest of the declaration. */
18044 {
18047 }
18049 /* Peek at the next token. */
18052 /* If the next token is a `)', `,', `=', `>', or `...', then there
18053 is no declarator. However, when variadic templates are enabled,
18054 there may be a declarator following `...'. */
18059 {
18063 }
18064 /* Otherwise, there should be a declarator. */
18065 else
18066 {
18070 /* After seeing a decl-specifier-seq, if the next token is not a
18071 "(", there is no possibility that the code is a valid
18072 expression. Therefore, if parsing tentatively, we commit at
18073 this point. */
18075 /* In an expression context, having seen:
18077 (int((char ...
18079 we cannot be sure whether we are looking at a
18080 function-type (taking a "char" as a parameter) or a cast
18081 of some object of type "char" to "int". */
18087 /* Parse the declarator. */
18090 CP_PARSER_DECLARATOR_EITHER,
18092 parenthesized_p,
18095 /* After the declarator, allow more attributes. */
18096 decl_specifiers.attributes
18099 }
18101 /* If the next token is an ellipsis, and we have not seen a
18102 declarator name, and the type of the declarator contains parameter
18103 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
18104 a parameter pack expansion expression. Otherwise, leave the
18105 ellipsis for a C-style variadic function. */
18108 {
18119 {
18120 /* Consume the `...'. */
18124 /* Build a pack expansion type */
18127 else
18129 }
18130 }
18132 /* The restriction on defining new types applies only to the type
18133 of the parameter, not to the default argument. */
18136 /* If the next token is `=', then process a default argument. */
18138 {
18140 /* If we are defining a class, then the tokens that make up the
18141 default argument must be saved and processed later. */
18146 /* Outside of a class definition, we can just parse the
18147 assignment-expression. */
18148 else
18149 default_argument
18153 {
18156 else
18157 {
18159 "default arguments are only "
18162 }
18163 }
18167 {
18168 /* Find the name of the parameter pack. */
18175 template_parm_p
18181 else
18183 template_parm_p
18190 }
18191 }
18192 else
18196 declarator,
18197 default_argument);
18198 }
18200 /* Parse a default argument and return it.
18202 TEMPLATE_PARM_P is true if this is a default argument for a
18203 non-type template parameter. */
18204 static tree
18206 {
18212 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
18213 set correctly. */
18216 /* Local variable names (and the `this' keyword) may not
18217 appear in a default argument. */
18220 /* Parse the assignment-expression. */
18223 default_argument
18233 }
18235 /* Parse a function-body.
18237 function-body:
18238 compound_statement */
18240 static void
18242 {
18244 }
18246 /* Parse a ctor-initializer-opt followed by a function-body. Return
18247 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
18248 is true we are parsing a function-try-block. */
18250 static bool
18253 {
18261 /* Begin the function body. */
18263 /* Parse the optional ctor-initializer. */
18266 /* If we're parsing a constexpr constructor definition, we need
18267 to check that the constructor body is indeed empty. However,
18268 before we get to cp_parser_function_body lot of junk has been
18269 generated, so we can't just check that we have an empty block.
18270 Rather we take a snapshot of the outermost block, and check whether
18271 cp_parser_function_body changed its state. */
18273 {
18277 }
18278 /* Parse the function-body. */
18282 /* Finish the function body. */
18286 }
18288 /* Parse an initializer.
18290 initializer:
18291 = initializer-clause
18292 ( expression-list )
18294 Returns an expression representing the initializer. If no
18295 initializer is present, NULL_TREE is returned.
18297 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
18298 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
18299 set to TRUE if there is no initializer present. If there is an
18300 initializer, and it is not a constant-expression, *NON_CONSTANT_P
18301 is set to true; otherwise it is set to false. */
18303 static tree
18306 {
18308 tree init;
18310 /* Peek at the next token. */
18313 /* Let our caller know whether or not this initializer was
18314 parenthesized. */
18316 /* Assume that the initializer is constant. */
18320 {
18321 /* Consume the `='. */
18323 /* Parse the initializer-clause. */
18325 }
18327 {
18332 non_constant_p);
18337 }
18339 {
18343 }
18344 else
18345 {
18346 /* Anything else is an error. */
18349 }
18352 }
18354 /* Parse an initializer-clause.
18356 initializer-clause:
18357 assignment-expression
18358 braced-init-list
18360 Returns an expression representing the initializer.
18362 If the `assignment-expression' production is used the value
18363 returned is simply a representation for the expression.
18365 Otherwise, calls cp_parser_braced_list. */
18367 static tree
18369 {
18370 tree initializer;
18372 /* Assume the expression is constant. */
18375 /* If it is not a `{', then we are looking at an
18376 assignment-expression. */
18378 {
18379 initializer
18382 non_constant_p);
18383 }
18384 else
18388 }
18390 /* Parse a brace-enclosed initializer list.
18392 braced-init-list:
18393 { initializer-list , [opt] }
18394 { }
18396 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
18397 the elements of the initializer-list (or NULL, if the last
18398 production is used). The TREE_TYPE for the CONSTRUCTOR will be
18399 NULL_TREE. There is no way to detect whether or not the optional
18400 trailing `,' was provided. NON_CONSTANT_P is as for
18401 cp_parser_initializer. */
18403 static tree
18405 {
18406 tree initializer;
18408 /* Consume the `{' token. */
18410 /* Create a CONSTRUCTOR to represent the braced-initializer. */
18412 /* If it's not a `}', then there is a non-trivial initializer. */
18414 {
18415 /* Parse the initializer list. */
18418 /* A trailing `,' token is allowed. */
18421 }
18422 else
18424 /* Now, there should be a trailing `}'. */
18428 }
18430 /* Parse an initializer-list.
18432 initializer-list:
18433 initializer-clause ... [opt]
18434 initializer-list , initializer-clause ... [opt]
18436 GNU Extension:
18438 initializer-list:
18439 designation initializer-clause ...[opt]
18440 initializer-list , designation initializer-clause ...[opt]
18442 designation:
18443 . identifier =
18444 identifier :
18445 [ constant-expression ] =
18447 Returns a vec of constructor_elt. The VALUE of each elt is an expression
18448 for the initializer. If the INDEX of the elt is non-NULL, it is the
18449 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
18450 as for cp_parser_initializer. */
18454 {
18457 /* Assume all of the expressions are constant. */
18460 /* Parse the rest of the list. */
18462 {
18464 tree designator;
18465 tree initializer;
18468 /* If the next token is an identifier and the following one is a
18469 colon, we are looking at the GNU designated-initializer
18470 syntax. */
18474 {
18475 /* Warn the user that they are using an extension. */
18478 /* Consume the identifier. */
18480 /* Consume the `:'. */
18482 }
18483 /* Also handle the C99 syntax, '. id ='. */
18488 {
18489 /* Warn the user that they are using an extension. */
18492 /* Consume the `.'. */
18494 /* Consume the identifier. */
18496 /* Consume the `='. */
18498 }
18499 /* Also handle C99 array designators, '[ const ] ='. */
18503 {
18504 /* In C++11, [ could start a lambda-introducer. */
18516 }
18517 else
18520 /* Parse the initializer. */
18523 /* If any clause is non-constant, so is the entire initializer. */
18527 /* If we have an ellipsis, this is an initializer pack
18528 expansion. */
18530 {
18531 /* Consume the `...'. */
18534 /* Turn the initializer into an initializer expansion. */
18536 }
18538 /* Add it to the vector. */
18541 /* If the next token is not a comma, we have reached the end of
18542 the list. */
18546 /* Peek at the next token. */
18548 /* If the next token is a `}', then we're still done. An
18549 initializer-clause can have a trailing `,' after the
18550 initializer-list and before the closing `}'. */
18554 /* Consume the `,' token. */
18556 }
18559 }
18561 /* Classes [gram.class] */
18563 /* Parse a class-name.
18565 class-name:
18566 identifier
18567 template-id
18569 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
18570 to indicate that names looked up in dependent types should be
18571 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
18572 keyword has been used to indicate that the name that appears next
18573 is a template. TAG_TYPE indicates the explicit tag given before
18574 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
18575 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
18576 is the class being defined in a class-head.
18578 Returns the TYPE_DECL representing the class. */
18580 static tree
18588 {
18589 tree decl;
18590 tree scope;
18595 /* All class-names start with an identifier. */
18598 {
18601 }
18603 /* PARSER->SCOPE can be cleared when parsing the template-arguments
18604 to a template-id, so we save it here. */
18609 /* Any name names a type if we're following the `typename' keyword
18610 in a qualified name where the enclosing scope is type-dependent. */
18613 /* Handle the common case (an identifier, but not a template-id)
18614 efficiently. */
18617 {
18621 /* Look for the identifier. */
18625 /* If the next token isn't an identifier, we are certainly not
18626 looking at a class-name. */
18629 /* If we know this is a type-name, there's no need to look it
18630 up. */
18633 else
18634 {
18635 tree ambiguous_decls;
18636 /* If we already know that this lookup is ambiguous, then
18637 we've already issued an error message; there's no reason
18638 to check again. */
18640 {
18643 }
18644 /* If the next token is a `::', then the name must be a type
18645 name.
18647 [basic.lookup.qual]
18649 During the lookup for a name preceding the :: scope
18650 resolution operator, object, function, and enumerator
18651 names are ignored. */
18654 /* Look up the name. */
18656 tag_type,
18659 check_dependency_p,
18663 {
18667 }
18668 }
18669 }
18670 else
18671 {
18672 /* Try a template-id. */
18674 check_dependency_p,
18675 tag_type,
18676 is_declaration);
18679 }
18683 /* If this is a typename, create a TYPENAME_TYPE. */
18685 {
18690 }
18694 /* Check to see that it is really the name of a class. */
18698 /* Situations like this:
18700 template <typename T> struct A {
18701 typename T::template X<int>::I i;
18702 };
18704 are problematic. Is `T::template X<int>' a class-name? The
18705 standard does not seem to be definitive, but there is no other
18706 valid interpretation of the following `::'. Therefore, those
18707 names are considered class-names. */
18708 {
18712 }
18716 /* In Objective-C 2.0, a classname followed by '.' starts a
18717 dot-syntax expression, and it's not a type-name. */
18729 }
18731 /* Parse a class-specifier.
18733 class-specifier:
18734 class-head { member-specification [opt] }
18736 Returns the TREE_TYPE representing the class. */
18738 static tree
18740 {
18741 tree type;
18755 /* Parse the class-head. */
18758 /* If the class-head was a semantic disaster, skip the entire body
18759 of the class. */
18761 {
18765 }
18767 /* Look for the `{'. */
18769 {
18772 }
18774 /* Issue an error message if type-definitions are forbidden here. */
18776 /* Remember that we are defining one more class. */
18778 /* Inside the class, surrounding template-parameter-lists do not
18779 apply. */
18780 saved_num_template_parameter_lists
18783 /* We are not in a function body. */
18786 /* Or in a loop. */
18789 /* Or in a switch. */
18792 /* We are not immediately inside an extern "lang" block. */
18793 saved_in_unbraced_linkage_specification_p
18797 /* Start the class. */
18799 {
18802 }
18806 /* If the type is erroneous, skip the entire body of the class. */
18808 else
18809 /* Parse the member-specification. */
18812 /* Look for the trailing `}'. */
18814 /* Look for trailing attributes to apply to this class. */
18822 /* We've finished a type definition. Check for the common syntax
18823 error of forgetting a semicolon after the definition. We need to
18824 be careful, as we can't just check for not-a-semicolon and be done
18825 with it; the user might have typed:
18827 class X { } c = ...;
18828 class X { } *p = ...;
18830 and so forth. Instead, enumerate all the possible tokens that
18831 might follow this production; if we don't see one of them, then
18832 complain and silently insert the semicolon. */
18833 {
18838 /* Don't try to parse c++11 attributes here. As per the
18839 grammar, that should be a task for
18840 cp_parser_decl_specifier_seq. */
18844 {
18855 /* While it's legal for type qualifiers and storage class
18856 specifiers to follow type definitions in the grammar, only
18857 compiler testsuites contain code like that. Assume that if
18858 we see such code, then what we're really seeing is a case
18859 like:
18861 class X { }
18862 const <type> var = ...;
18864 or
18866 class Y { }
18867 static <type> func (...) ...
18869 i.e. the qualifier or specifier applies to the next
18870 declaration. To do so, however, we need to look ahead one
18871 more token to see if *that* token is a type specifier.
18873 This code could be improved to handle:
18875 class Z { }
18876 static const <type> var = ...; */
18879 {
18882 /* Handling user-defined types here would be nice, but very
18883 tricky. */
18884 want_semicolon
18887 }
18891 }
18893 /* If we don't have a type, then something is very wrong and we
18894 shouldn't try to do anything clever. Likewise for not seeing the
18895 closing brace. */
18897 {
18898 cp_token_position prev
18909 else
18912 /* Unget one token and smash it to look as though we encountered
18913 a semicolon in the input stream. */
18918 }
18919 }
18921 /* If this class is not itself within the scope of another class,
18922 then we need to parse the bodies of all of the queued function
18923 definitions. Note that the queued functions defined in a class
18924 are not always processed immediately following the
18925 class-specifier for that class. Consider:
18927 struct A {
18928 struct B { void f() { sizeof (A); } };
18929 };
18931 If `f' were processed before the processing of `A' were
18932 completed, there would be no way to compute the size of `A'.
18933 Note that the nesting we are interested in here is lexical --
18934 not the semantic nesting given by TYPE_CONTEXT. In particular,
18935 for:
18937 struct A { struct B; };
18938 struct A::B { void f() { } };
18940 there is no need to delay the parsing of `A::B::f'. */
18942 {
18943 tree decl;
18950 /* In a first pass, parse default arguments to the functions.
18951 Then, in a second pass, parse the bodies of the functions.
18952 This two-phased approach handles cases like:
18954 struct S {
18955 void f() { g(); }
18956 void g(int i = 3);
18957 };
18959 */
18961 {
18963 /* If there are default arguments that have not yet been processed,
18964 take care of them now. */
18966 {
18971 }
18972 /* Make sure that any template parameters are in scope. */
18974 /* Parse the default argument expressions. */
18976 /* Remove any template parameters from the symbol table. */
18978 }
18980 /* Now parse any NSDMIs. */
18984 {
18986 {
18991 }
18994 }
19000 /* Now parse the body of the functions. */
19004 }
19006 /* Put back any saved access checks. */
19009 /* Restore saved state. */
19013 parser->num_template_parameter_lists
19015 parser->in_unbraced_linkage_specification_p
19019 }
19021 static tree
19023 {
19024 tree ret;
19029 }
19031 /* Parse a class-head.
19033 class-head:
19034 class-key identifier [opt] base-clause [opt]
19035 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
19036 class-key nested-name-specifier [opt] template-id
19037 base-clause [opt]
19039 class-virt-specifier:
19040 final
19042 GNU Extensions:
19043 class-key attributes identifier [opt] base-clause [opt]
19044 class-key attributes nested-name-specifier identifier base-clause [opt]
19045 class-key attributes nested-name-specifier [opt] template-id
19046 base-clause [opt]
19048 Upon return BASES is initialized to the list of base classes (or
19049 NULL, if there are none) in the same form returned by
19050 cp_parser_base_clause.
19052 Returns the TYPE of the indicated class. Sets
19053 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
19054 involving a nested-name-specifier was used, and FALSE otherwise.
19056 Returns error_mark_node if this is not a class-head.
19058 Returns NULL_TREE if the class-head is syntactically valid, but
19059 semantically invalid in a way that means we should skip the entire
19060 body of the class. */
19062 static tree
19065 {
19066 tree nested_name_specifier;
19070 tree attributes;
19071 tree bases;
19081 /* Assume no nested-name-specifier will be present. */
19083 /* Assume no template parameter lists will be used in defining the
19084 type. */
19088 /* Look for the class-key. */
19093 /* Parse the attributes. */
19096 /* If the next token is `::', that is invalid -- but sometimes
19097 people do try to write:
19099 struct ::S {};
19101 Handle this gracefully by accepting the extra qualifier, and then
19102 issuing an error about it later if this really is a
19103 class-head. If it turns out just to be an elaborated type
19104 specifier, remain silent. */
19110 /* Determine the name of the class. Begin by looking for an
19111 optional nested-name-specifier. */
19113 nested_name_specifier
19119 /* If there was a nested-name-specifier, then there *must* be an
19120 identifier. */
19122 {
19124 /* Although the grammar says `identifier', it really means
19125 `class-name' or `template-name'. You are only allowed to
19126 define a class that has already been declared with this
19127 syntax.
19129 The proposed resolution for Core Issue 180 says that wherever
19130 you see `class T::X' you should treat `X' as a type-name.
19132 It is OK to define an inaccessible class; for example:
19134 class A { class B; };
19135 class A::B {};
19137 We do not know if we will see a class-name, or a
19138 template-name. We look for a class-name first, in case the
19139 class-name is a template-id; if we looked for the
19140 template-name first we would stop after the template-name. */
19145 class_type,
19149 /* If that didn't work, ignore the nested-name-specifier. */
19151 {
19157 }
19158 /* If we could not find a corresponding TYPE, treat this
19159 declaration like an unqualified declaration. */
19162 /* Otherwise, count the number of templates used in TYPE and its
19163 containing scopes. */
19164 else
19165 {
19166 tree scope;
19178 }
19179 }
19180 /* Otherwise, the identifier is optional. */
19181 else
19182 {
19183 /* We don't know whether what comes next is a template-id,
19184 an identifier, or nothing at all. */
19186 /* Check for a template-id. */
19191 class_key,
19193 /* If that didn't work, it could still be an identifier. */
19195 {
19197 {
19200 }
19201 else
19203 }
19204 else
19205 {
19208 }
19209 }
19214 {
19216 class_key,
19218 }
19221 /* If it's not a `:' or a `{' then we can't really be looking at a
19222 class-head, since a class-head only appears as part of a
19223 class-specifier. We have to detect this situation before calling
19224 xref_tag, since that has irreversible side-effects. */
19226 {
19230 }
19232 /* At this point, we're going ahead with the class-specifier, even
19233 if some other problem occurs. */
19236 {
19241 }
19242 /* Issue the error about the overly-qualified name now. */
19244 {
19249 }
19251 {
19256 }
19258 {
19259 tree scope;
19261 /* Reject typedef-names in class heads. */
19263 {
19266 type);
19269 }
19271 /* Figure out in what scope the declaration is being placed. */
19273 /* If that scope does not contain the scope in which the
19274 class was originally declared, the program is invalid. */
19276 {
19279 "declaration of %qD in namespace %qD which does not "
19282 else
19288 }
19289 /* [dcl.meaning]
19291 A declarator-id shall not be qualified except for the
19292 definition of a ... nested class outside of its class
19293 ... [or] the definition or explicit instantiation of a
19294 class member of a namespace outside of its namespace. */
19296 {
19301 }
19302 }
19303 /* An explicit-specialization must be preceded by "template <>". If
19304 it is not, try to recover gracefully. */
19308 {
19312 /* Take the same action that would have been taken by
19313 cp_parser_explicit_specialization. */
19316 }
19317 /* There must be no "return" statements between this point and the
19318 end of this function; set "type "to the correct return value and
19319 use "goto done;" to return. */
19320 /* Make sure that the right number of template parameters were
19321 present. */
19325 {
19326 /* If something went wrong, there is no point in even trying to
19327 process the class-definition. */
19330 }
19332 /* Look up the type. */
19334 {
19338 {
19342 }
19343 else
19344 {
19347 }
19350 }
19352 {
19353 tree class_type;
19355 /* Given:
19357 template <typename T> struct S { struct T };
19358 template <typename T> struct S<T>::T { };
19360 we will get a TYPENAME_TYPE when processing the definition of
19361 `S::T'. We need to resolve it to the actual type before we
19362 try to define it. */
19364 {
19369 else
19370 {
19373 }
19374 }
19378 {
19381 }
19384 /* Enter the scope indicated by the nested-name-specifier. */
19386 /* Get the canonical version of this type. */
19390 {
19393 {
19396 }
19397 }
19401 }
19403 {
19404 /* If the class was unnamed, create a dummy name. */
19409 }
19411 /* Indicate whether this class was declared as a `class' or as a
19412 `struct'. */
19417 /* If this type was already complete, and we see another definition,
19418 that's an error. */
19420 {
19422 type);
19424 type);
19427 }
19432 {
19433 /* Apply attributes now, before any use of the class as a template
19434 argument in its base list. */
19437 }
19439 /* We will have entered the scope containing the class; the names of
19440 base classes should be looked up in that context. For example:
19442 struct A { struct B {}; struct C; };
19443 struct A::C : B {};
19445 is valid. */
19447 /* Get the list of base-classes, if there is one. */
19450 else
19453 /* If we're really defining a class, process the base classes.
19454 If they're invalid, fail. */
19459 done:
19460 /* Leave the scope given by the nested-name-specifier. We will
19461 enter the class scope itself while processing the members. */
19466 {
19469 }
19475 out:
19478 }
19480 /* Parse a class-key.
19482 class-key:
19483 class
19484 struct
19485 union
19487 Returns the kind of class-key specified, or none_type to indicate
19488 error. */
19490 static enum tag_types
19492 {
19496 /* Look for the class-key. */
19501 /* Check to see if the TOKEN is a class-key. */
19506 }
19508 /* Parse an (optional) member-specification.
19510 member-specification:
19511 member-declaration member-specification [opt]
19512 access-specifier : member-specification [opt] */
19514 static void
19516 {
19518 {
19522 /* Peek at the next token. */
19524 /* If it's a `}', or EOF then we've seen all the members. */
19530 /* See if this token is a keyword. */
19533 {
19537 /* Consume the access-specifier. */
19539 /* Remember which access-specifier is active. */
19541 /* Look for the `:'. */
19546 /* Accept #pragmas at class scope. */
19548 {
19551 }
19553 /* Otherwise, the next construction must be a
19554 member-declaration. */
19556 }
19557 }
19558 }
19560 /* Parse a member-declaration.
19562 member-declaration:
19563 decl-specifier-seq [opt] member-declarator-list [opt] ;
19564 function-definition ; [opt]
19565 :: [opt] nested-name-specifier template [opt] unqualified-id ;
19566 using-declaration
19567 template-declaration
19568 alias-declaration
19570 member-declarator-list:
19571 member-declarator
19572 member-declarator-list , member-declarator
19574 member-declarator:
19575 declarator pure-specifier [opt]
19576 declarator constant-initializer [opt]
19577 identifier [opt] : constant-expression
19579 GNU Extensions:
19581 member-declaration:
19582 __extension__ member-declaration
19584 member-declarator:
19585 declarator attributes [opt] pure-specifier [opt]
19586 declarator attributes [opt] constant-initializer [opt]
19587 identifier [opt] attributes [opt] : constant-expression
19589 C++0x Extensions:
19591 member-declaration:
19592 static_assert-declaration */
19594 static void
19596 {
19597 cp_decl_specifier_seq decl_specifiers;
19598 tree prefix_attributes;
19599 tree decl;
19608 /* Check for the `__extension__' keyword. */
19610 {
19611 /* Recurse. */
19613 /* Restore the old value of the PEDANTIC flag. */
19617 }
19619 /* Check for a template-declaration. */
19621 {
19622 /* An explicit specialization here is an error condition, and we
19623 expect the specialization handler to detect and report this. */
19627 else
19631 }
19633 /* Check for a using-declaration. */
19635 {
19637 {
19638 /* Parse the using-declaration. */
19642 }
19643 else
19644 {
19645 tree decl;
19649 /* Note that if we actually see the '=' token after the
19650 identifier, cp_parser_alias_declaration commits the
19651 tentative parse. In that case, we really expects an
19652 alias-declaration. Otherwise, we expect a using
19653 declaration. */
19654 alias_decl_expected =
19660 else
19664 }
19665 }
19667 /* Check for @defs. */
19669 {
19674 {
19679 }
19681 }
19683 /* If the next token is `static_assert' we have a static assertion. */
19685 {
19688 }
19695 /* Parse the decl-specifier-seq. */
19698 CP_PARSER_FLAGS_OPTIONAL,
19701 /* Check for an invalid type-name. */
19705 /* If there is no declarator, then the decl-specifier-seq should
19706 specify a type. */
19708 {
19709 /* If there was no decl-specifier-seq, and the next token is a
19710 `;', then we have something like:
19712 struct S { ; };
19714 [class.mem]
19716 Each member-declaration shall declare at least one member
19717 name of the class. */
19719 {
19723 }
19724 else
19725 {
19726 tree type;
19728 /* See if this declaration is a friend. */
19730 /* If there were decl-specifiers, check to see if there was
19731 a class-declaration. */
19734 /* Nested classes have already been added to the class, but
19735 a `friend' needs to be explicitly registered. */
19737 {
19738 /* If the `friend' keyword was present, the friend must
19739 be introduced with a class-key. */
19742 "in C++03 a class-key must be used "
19744 /* In this case:
19746 template <typename T> struct A {
19747 friend struct A<T>::B;
19748 };
19750 A<T>::B will be represented by a TYPENAME_TYPE, and
19751 therefore not recognized by check_tag_decl. */
19753 {
19757 }
19760 "friend declaration does not name a class or "
19762 else
19765 }
19766 /* If there is no TYPE, an error message will already have
19767 been issued. */
19769 ;
19770 /* An anonymous aggregate has to be handled specially; such
19771 a declaration really declares a data member (with a
19772 particular type), as opposed to a nested class. */
19774 {
19775 /* C++11 9.5/6. */
19778 "a storage class on an anonymous aggregate "
19781 /* Remove constructors and such from TYPE, now that we
19782 know it is an anonymous aggregate. */
19784 /* And make the corresponding data member. */
19787 /* Add it to the class. */
19789 }
19790 else
19791 cp_parser_check_access_in_redeclaration
19794 }
19795 }
19796 else
19797 {
19800 /* Clear attributes from the decl_specifiers but keep them
19801 around as prefix attributes that apply them to the entity
19802 being declared. */
19806 /* See if these declarations will be friends. */
19809 /* Keep going until we hit the `;' at the end of the
19810 declaration. */
19812 {
19814 tree first_attribute;
19816 /* Peek at the next token. */
19819 /* Check for a bitfield declaration. */
19824 {
19825 tree identifier;
19826 tree width;
19828 /* Get the name of the bitfield. Note that we cannot just
19829 check TOKEN here because it may have been invalidated by
19830 the call to cp_lexer_peek_nth_token above. */
19833 else
19836 /* Consume the `:' token. */
19838 /* Get the width of the bitfield. */
19839 width
19842 NULL);
19844 /* Look for attributes that apply to the bitfield. */
19846 /* Remember which attributes are prefix attributes and
19847 which are not. */
19849 /* Combine the attributes. */
19852 /* Create the bitfield declaration. */
19855 identifier,
19856 sfk_none)
19859 width,
19860 attributes);
19861 }
19862 else
19863 {
19865 tree initializer;
19866 tree asm_specification;
19869 /* Parse the declarator. */
19870 declarator
19876 /* If something went wrong parsing the declarator, make sure
19877 that we at least consume some tokens. */
19879 {
19880 /* Skip to the end of the statement. */
19882 /* If the next token is not a semicolon, that is
19883 probably because we just skipped over the body of
19884 a function. So, we consume a semicolon if
19885 present, but do not issue an error message if it
19886 is not present. */
19888 CPP_SEMICOLON))
19891 }
19894 cp_parser_check_for_definition_in_return_type
19898 /* Look for an asm-specification. */
19900 /* Look for attributes that apply to the declaration. */
19902 /* Remember which attributes are prefix attributes and
19903 which are not. */
19905 /* Combine the attributes. */
19908 /* If it's an `=', then we have a constant-initializer or a
19909 pure-specifier. It is not correct to parse the
19910 initializer before registering the member declaration
19911 since the member declaration should be in scope while
19912 its initializer is processed. However, the rest of the
19913 front end does not yet provide an interface that allows
19914 us to handle this correctly. */
19916 {
19917 /* In [class.mem]:
19919 A pure-specifier shall be used only in the declaration of
19920 a virtual function.
19922 A member-declarator can contain a constant-initializer
19923 only if it declares a static member of integral or
19924 enumeration type.
19926 Therefore, if the DECLARATOR is for a function, we look
19927 for a pure-specifier; otherwise, we look for a
19928 constant-initializer. When we call `grokfield', it will
19929 perform more stringent semantics checks. */
19941 {
19943 /* Don't require a constant rvalue in C++11, since we
19944 might want a reference constant. We'll enforce
19945 constancy later. */
19947 /* Parse the initializer. */
19950 }
19951 else
19952 /* Parse the initializer. */
19954 }
19957 {
19961 else
19963 }
19964 /* Otherwise, there is no initializer. */
19965 else
19968 /* See if we are probably looking at a function
19969 definition. We are certainly not looking at a
19970 member-declarator. Calling `grokfield' has
19971 side-effects, so we must not do it unless we are sure
19972 that we are looking at a member-declarator. */
19975 {
19976 /* The grammar does not allow a pure-specifier to be
19977 used when a member function is defined. (It is
19978 possible that this fact is an oversight in the
19979 standard, since a pure function may be defined
19980 outside of the class-specifier. */
19986 declarator,
19987 attributes);
19988 /* If the member was not a friend, declare it here. */
19991 /* Peek at the next token. */
19993 /* If the next token is a semicolon, consume it. */
19997 }
19998 else
20001 /* Create the declaration. */
20004 asm_specification,
20005 attributes);
20006 }
20008 /* Reset PREFIX_ATTRIBUTES. */
20014 /* If there is any qualification still in effect, clear it
20015 now; we will be starting fresh with the next declarator. */
20019 /* If it's a `,', then there are more declarators. */
20021 {
20024 {
20028 }
20029 }
20030 /* If the next token isn't a `;', then we have a parse error. */
20032 CPP_SEMICOLON))
20033 {
20034 /* The next token might be a ways away from where the
20035 actual semicolon is missing. Find the previous token
20036 and use that for our error position. */
20041 /* Assume that the user meant to provide a semicolon. If
20042 we were to cp_parser_skip_to_end_of_statement, we might
20043 skip to a semicolon inside a member function definition
20044 and issue nonsensical error messages. */
20046 }
20049 {
20050 /* Add DECL to the list of members. */
20059 /* Add DECL to the queue of NSDMI to be parsed later. */
20061 }
20065 }
20066 }
20069 out:
20071 }
20073 /* Parse a pure-specifier.
20075 pure-specifier:
20076 = 0
20078 Returns INTEGER_ZERO_NODE if a pure specifier is found.
20079 Otherwise, ERROR_MARK_NODE is returned. */
20081 static tree
20083 {
20086 /* Look for the `=' token. */
20089 /* Look for the `0' token. */
20098 /* Accept = default or = delete in c++0x mode. */
20101 {
20104 }
20106 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
20108 {
20113 }
20115 {
20118 }
20121 }
20123 /* Parse a constant-initializer.
20125 constant-initializer:
20126 = constant-expression
20128 Returns a representation of the constant-expression. */
20130 static tree
20132 {
20133 /* Look for the `=' token. */
20137 /* It is invalid to write:
20139 struct S { static const int i = { 7 }; };
20141 */
20143 {
20146 /* Consume the opening brace. */
20148 /* Skip the initializer. */
20150 /* Look for the trailing `}'. */
20154 }
20158 NULL);
20159 }
20161 /* Derived classes [gram.class.derived] */
20163 /* Parse a base-clause.
20165 base-clause:
20166 : base-specifier-list
20168 base-specifier-list:
20169 base-specifier ... [opt]
20170 base-specifier-list , base-specifier ... [opt]
20172 Returns a TREE_LIST representing the base-classes, in the order in
20173 which they were declared. The representation of each node is as
20174 described by cp_parser_base_specifier.
20176 In the case that no bases are specified, this function will return
20177 NULL_TREE, not ERROR_MARK_NODE. */
20179 static tree
20181 {
20184 /* Look for the `:' that begins the list. */
20187 /* Scan the base-specifier-list. */
20189 {
20191 tree base;
20194 /* Look for the base-specifier. */
20196 /* Look for the (optional) ellipsis. */
20198 {
20199 /* Consume the `...'. */
20203 }
20205 /* Add BASE to the front of the list. */
20207 {
20209 /* Make this a pack expansion type. */
20213 {
20216 }
20217 }
20218 /* Peek at the next token. */
20220 /* If it's not a comma, then the list is complete. */
20223 /* Consume the `,'. */
20225 }
20227 /* PARSER->SCOPE may still be non-NULL at this point, if the last
20228 base class had a qualified name. However, the next name that
20229 appears is certainly not qualified. */
20235 }
20237 /* Parse a base-specifier.
20239 base-specifier:
20240 :: [opt] nested-name-specifier [opt] class-name
20241 virtual access-specifier [opt] :: [opt] nested-name-specifier
20242 [opt] class-name
20243 access-specifier virtual [opt] :: [opt] nested-name-specifier
20244 [opt] class-name
20246 Returns a TREE_LIST. The TREE_PURPOSE will be one of
20247 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
20248 indicate the specifiers provided. The TREE_VALUE will be a TYPE
20249 (or the ERROR_MARK_NODE) indicating the type that was specified. */
20251 static tree
20253 {
20261 tree type;
20263 /* Process the optional `virtual' and `access-specifier'. */
20265 {
20266 /* Peek at the next token. */
20268 /* Process `virtual'. */
20270 {
20272 /* If `virtual' appears more than once, issue an error. */
20274 {
20278 }
20282 /* Consume the `virtual' token. */
20290 /* If more than one access specifier appears, issue an
20291 error. */
20294 {
20298 }
20302 /* Consume the access-specifier. */
20310 }
20311 }
20312 /* It is not uncommon to see programs mechanically, erroneously, use
20313 the 'typename' keyword to denote (dependent) qualified types
20314 as base classes. */
20316 {
20321 else
20323 "keyword %<typename%> not allowed in this context "
20326 }
20328 /* Look for the optional `::' operator. */
20330 /* Look for the nested-name-specifier. The simplest way to
20331 implement:
20333 [temp.res]
20335 The keyword `typename' is not permitted in a base-specifier or
20336 mem-initializer; in these contexts a qualified name that
20337 depends on a template-parameter is implicitly assumed to be a
20338 type name.
20340 is to pretend that we have seen the `typename' keyword at this
20341 point. */
20345 typename_type,
20347 /* If the base class is given by a qualified name, assume that names
20348 we see are type names or templates, as appropriate. */
20354 /* DR 950 allows decltype as a base-specifier. */
20356 else
20357 {
20358 /* Otherwise, look for the class-name. */
20360 class_scope_p,
20361 template_p,
20362 typename_type,
20367 }
20373 }
20375 /* Exception handling [gram.exception] */
20377 /* Parse an (optional) noexcept-specification.
20379 noexcept-specification:
20380 noexcept ( constant-expression ) [opt]
20382 If no noexcept-specification is present, returns NULL_TREE.
20383 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
20384 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
20385 there are no parentheses. CONSUMED_EXPR will be set accordingly.
20386 Otherwise, returns a noexcept specification unless RETURN_COND is true,
20387 in which case a boolean condition is returned instead. */
20389 static tree
20394 {
20398 /* Peek at the next token. */
20401 /* Is it a noexcept-specification? */
20403 {
20404 tree expr;
20408 {
20412 {
20413 /* Types may not be defined in an exception-specification. */
20415 parser->type_definition_forbidden_message
20420 /* Restore the saved message. */
20422 }
20423 else
20424 {
20427 }
20430 }
20431 else
20432 {
20436 }
20438 /* We cannot build a noexcept-spec right away because this will check
20439 that expr is a constexpr. */
20442 else
20444 }
20445 else
20447 }
20449 /* Parse an (optional) exception-specification.
20451 exception-specification:
20452 throw ( type-id-list [opt] )
20454 Returns a TREE_LIST representing the exception-specification. The
20455 TREE_VALUE of each node is a type. */
20457 static tree
20459 {
20461 tree type_id_list;
20464 /* Peek at the next token. */
20467 /* Is it a noexcept-specification? */
20473 /* If it's not `throw', then there's no exception-specification. */
20477 #if 0
20478 /* Enable this once a lot of code has transitioned to noexcept? */
20482 #endif
20484 /* Consume the `throw'. */
20487 /* Look for the `('. */
20490 /* Peek at the next token. */
20492 /* If it's not a `)', then there is a type-id-list. */
20494 {
20495 /* Types may not be defined in an exception-specification. */
20497 parser->type_definition_forbidden_message
20499 /* Parse the type-id-list. */
20501 /* Restore the saved message. */
20503 }
20504 else
20507 /* Look for the `)'. */
20511 }
20513 /* Parse an (optional) type-id-list.
20515 type-id-list:
20516 type-id ... [opt]
20517 type-id-list , type-id ... [opt]
20519 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
20520 in the order that the types were presented. */
20522 static tree
20524 {
20528 {
20530 tree type;
20532 /* Get the next type-id. */
20534 /* Parse the optional ellipsis. */
20536 {
20537 /* Consume the `...'. */
20540 /* Turn the type into a pack expansion expression. */
20542 }
20543 /* Add it to the list. */
20545 /* Peek at the next token. */
20547 /* If it is not a `,', we are done. */
20550 /* Consume the `,'. */
20552 }
20555 }
20557 /* Parse a try-block.
20559 try-block:
20560 try compound-statement handler-seq */
20562 static tree
20564 {
20565 tree try_block;
20575 }
20577 /* Parse a function-try-block.
20579 function-try-block:
20580 try ctor-initializer [opt] function-body handler-seq */
20582 static bool
20584 {
20585 tree compound_stmt;
20586 tree try_block;
20589 /* Look for the `try' keyword. */
20592 /* Let the rest of the front end know where we are. */
20594 /* Parse the function-body. */
20595 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
20597 /* We're done with the `try' part. */
20599 /* Parse the handlers. */
20601 /* We're done with the handlers. */
20605 }
20607 /* Parse a handler-seq.
20609 handler-seq:
20610 handler handler-seq [opt] */
20612 static void
20614 {
20616 {
20619 /* Parse the handler. */
20621 /* Peek at the next token. */
20623 /* If it's not `catch' then there are no more handlers. */
20626 }
20627 }
20629 /* Parse a handler.
20631 handler:
20632 catch ( exception-declaration ) compound-statement */
20634 static void
20636 {
20637 tree handler;
20638 tree declaration;
20648 }
20650 /* Parse an exception-declaration.
20652 exception-declaration:
20653 type-specifier-seq declarator
20654 type-specifier-seq abstract-declarator
20655 type-specifier-seq
20656 ...
20658 Returns a VAR_DECL for the declaration, or NULL_TREE if the
20659 ellipsis variant is used. */
20661 static tree
20663 {
20664 cp_decl_specifier_seq type_specifiers;
20668 /* If it's an ellipsis, it's easy to handle. */
20670 {
20671 /* Consume the `...' token. */
20674 }
20676 /* Types may not be defined in exception-declarations. */
20678 parser->type_definition_forbidden_message
20681 /* Parse the type-specifier-seq. */
20685 /* If it's a `)', then there is no declarator. */
20688 else
20694 /* Restore the saved message. */
20701 }
20703 /* Parse a throw-expression.
20705 throw-expression:
20706 throw assignment-expression [opt]
20708 Returns a THROW_EXPR representing the throw-expression. */
20710 static tree
20712 {
20713 tree expression;
20718 /* Figure out whether or not there is an assignment-expression
20719 following the "throw" keyword. */
20727 else
20732 }
20734 /* GNU Extensions */
20736 /* Parse an (optional) asm-specification.
20738 asm-specification:
20739 asm ( string-literal )
20741 If the asm-specification is present, returns a STRING_CST
20742 corresponding to the string-literal. Otherwise, returns
20743 NULL_TREE. */
20745 static tree
20747 {
20749 tree asm_specification;
20751 /* Peek at the next token. */
20753 /* If the next token isn't the `asm' keyword, then there's no
20754 asm-specification. */
20758 /* Consume the `asm' token. */
20760 /* Look for the `('. */
20763 /* Look for the string-literal. */
20766 /* Look for the `)'. */
20770 }
20772 /* Parse an asm-operand-list.
20774 asm-operand-list:
20775 asm-operand
20776 asm-operand-list , asm-operand
20778 asm-operand:
20779 string-literal ( expression )
20780 [ string-literal ] string-literal ( expression )
20782 Returns a TREE_LIST representing the operands. The TREE_VALUE of
20783 each node is the expression. The TREE_PURPOSE is itself a
20784 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
20785 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
20786 is a STRING_CST for the string literal before the parenthesis. Returns
20787 ERROR_MARK_NODE if any of the operands are invalid. */
20789 static tree
20791 {
20796 {
20797 tree string_literal;
20798 tree expression;
20799 tree name;
20802 {
20803 /* Consume the `[' token. */
20805 /* Read the operand name. */
20810 /* Look for the closing `]'. */
20812 }
20813 else
20815 /* Look for the string-literal. */
20818 /* Look for the `('. */
20820 /* Parse the expression. */
20822 /* Look for the `)'. */
20830 /* Add this operand to the list. */
20832 expression,
20833 asm_operands);
20834 /* If the next token is not a `,', there are no more
20835 operands. */
20838 /* Consume the `,'. */
20840 }
20843 }
20845 /* Parse an asm-clobber-list.
20847 asm-clobber-list:
20848 string-literal
20849 asm-clobber-list , string-literal
20851 Returns a TREE_LIST, indicating the clobbers in the order that they
20852 appeared. The TREE_VALUE of each node is a STRING_CST. */
20854 static tree
20856 {
20860 {
20861 tree string_literal;
20863 /* Look for the string literal. */
20865 /* Add it to the list. */
20867 /* If the next token is not a `,', then the list is
20868 complete. */
20871 /* Consume the `,' token. */
20873 }
20876 }
20878 /* Parse an asm-label-list.
20880 asm-label-list:
20881 identifier
20882 asm-label-list , identifier
20884 Returns a TREE_LIST, indicating the labels in the order that they
20885 appeared. The TREE_VALUE of each node is a label. */
20887 static tree
20889 {
20893 {
20896 /* Look for the identifier. */
20899 {
20902 {
20908 }
20909 }
20910 /* If the next token is not a `,', then the list is
20911 complete. */
20914 /* Consume the `,' token. */
20916 }
20919 }
20921 /* Return TRUE iff the next tokens in the stream are possibly the
20922 beginning of a GNU extension attribute. */
20924 static bool
20926 {
20928 }
20930 /* Return TRUE iff the next tokens in the stream are possibly the
20931 beginning of a standard C++-11 attribute specifier. */
20933 static bool
20935 {
20937 }
20939 /* Return TRUE iff the next Nth tokens in the stream are possibly the
20940 beginning of a standard C++-11 attribute specifier. */
20942 static bool
20944 {
20952 }
20954 /* Return TRUE iff the next Nth tokens in the stream are possibly the
20955 beginning of a GNU extension attribute. */
20957 static bool
20959 {
20963 }
20965 /* Return true iff the next tokens can be the beginning of either a
20966 GNU attribute list, or a standard C++11 attribute sequence. */
20968 static bool
20970 {
20973 }
20975 /* Return true iff the next Nth tokens can be the beginning of either
20976 a GNU attribute list, or a standard C++11 attribute sequence. */
20978 static bool
20980 {
20983 }
20985 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
20986 of GNU attributes, or return NULL. */
20988 static tree
20990 {
20994 }
20996 /* Parse an (optional) series of attributes.
20998 attributes:
20999 attributes attribute
21001 attribute:
21002 __attribute__ (( attribute-list [opt] ))
21004 The return value is as for cp_parser_gnu_attribute_list. */
21006 static tree
21008 {
21012 {
21014 tree attribute_list;
21017 /* Peek at the next token. */
21019 /* If it's not `__attribute__', then we're done. */
21023 /* Consume the `__attribute__' keyword. */
21025 /* Look for the two `(' tokens. */
21029 /* Peek at the next token. */
21032 /* Parse the attribute-list. */
21034 else
21035 /* If the next token is a `)', then there is no attribute
21036 list. */
21039 /* Look for the two `)' tokens. */
21047 /* Add these new attributes to the list. */
21049 }
21052 }
21054 /* Parse a GNU attribute-list.
21056 attribute-list:
21057 attribute
21058 attribute-list , attribute
21060 attribute:
21061 identifier
21062 identifier ( identifier )
21063 identifier ( identifier , expression-list )
21064 identifier ( expression-list )
21066 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
21067 to an attribute. The TREE_PURPOSE of each node is the identifier
21068 indicating which attribute is in use. The TREE_VALUE represents
21069 the arguments, if any. */
21071 static tree
21073 {
21079 {
21081 tree identifier;
21082 tree attribute;
21084 /* Look for the identifier. We also allow keywords here; for
21085 example `__attribute__ ((const))' is legal. */
21089 {
21092 /* Consume the token. */
21095 /* Save away the identifier that indicates which attribute
21096 this is. */
21098 /* For keywords, use the canonical spelling, not the
21099 parsed identifier. */
21105 /* Peek at the next token. */
21107 /* If it's an `(', then parse the attribute arguments. */
21109 {
21113 vec = cp_parser_parenthesized_expression_list
21119 else
21120 {
21123 }
21124 /* Save the arguments away. */
21126 }
21129 {
21130 /* Add this attribute to the list. */
21133 }
21136 }
21137 /* Now, look for more attributes. If the next token isn't a
21138 `,', we're done. */
21142 /* Consume the comma and keep going. */
21144 }
21147 /* We built up the list in reverse order. */
21149 }
21151 /* Parse a standard C++11 attribute.
21153 The returned representation is a TREE_LIST which TREE_PURPOSE is
21154 the scoped name of the attribute, and the TREE_VALUE is its
21155 arguments list.
21157 Note that the scoped name of the attribute is itself a TREE_LIST
21158 which TREE_PURPOSE is the namespace of the attribute, and
21159 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
21160 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
21161 and which TREE_PURPOSE is directly the attribute name.
21163 Clients of the attribute code should use get_attribute_namespace
21164 and get_attribute_name to get the actual namespace and name of
21165 attributes, regardless of their being GNU or C++11 attributes.
21167 attribute:
21168 attribute-token attribute-argument-clause [opt]
21170 attribute-token:
21171 identifier
21172 attribute-scoped-token
21174 attribute-scoped-token:
21175 attribute-namespace :: identifier
21177 attribute-namespace:
21178 identifier
21180 attribute-argument-clause:
21181 ( balanced-token-seq )
21183 balanced-token-seq:
21184 balanced-token [opt]
21185 balanced-token-seq balanced-token
21187 balanced-token:
21188 ( balanced-token-seq )
21189 [ balanced-token-seq ]
21190 { balanced-token-seq }. */
21192 static tree
21194 {
21198 /* First, parse name of the the attribute, a.k.a
21199 attribute-token. */
21216 {
21217 /* We are seeing a scoped attribute token. */
21227 else
21228 {
21232 }
21234 NULL_TREE);
21236 }
21237 else
21238 {
21240 NULL_TREE);
21241 /* C++11 noreturn attribute is equivalent to GNU's. */
21244 }
21246 /* Now parse the optional argument clause of the attribute. */
21251 {
21257 /* A GNU attribute that takes an identifier in parameter. */
21260 vec = cp_parser_parenthesized_expression_list
21266 else
21267 {
21270 }
21274 else
21276 }
21279 }
21281 /* Parse a list of standard C++-11 attributes.
21283 attribute-list:
21284 attribute [opt]
21285 attribute-list , attribute[opt]
21286 attribute ...
21287 attribute-list , attribute ...
21288 */
21290 static tree
21292 {
21297 {
21302 {
21305 }
21310 }
21313 }
21315 /* Parse a standard C++-11 attribute specifier.
21317 attribute-specifier:
21318 [ [ attribute-list ] ]
21319 alignment-specifier
21321 alignment-specifier:
21322 alignas ( type-id ... [opt] )
21323 alignas ( alignment-expression ... [opt] ). */
21325 static tree
21327 {
21333 {
21342 else
21343 /* Warn about parsing c++11 attribute in non-c++1 mode, only
21344 when we are sure that we have actually parsed them. */
21346 }
21347 else
21348 {
21349 tree alignas_expr;
21351 /* Look for an alignment-specifier. */
21363 {
21366 }
21372 {
21376 alignas_expr =
21382 }
21385 {
21388 }
21392 /* Build the C++-11 representation of an 'aligned'
21393 attribute. */
21394 attributes =
21398 }
21401 }
21403 /* Parse a standard C++-11 attribute-specifier-seq.
21405 attribute-specifier-seq:
21406 attribute-specifier-seq [opt] attribute-specifier
21407 */
21409 static tree
21411 {
21415 {
21424 }
21428 }
21430 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
21431 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
21432 current value of the PEDANTIC flag, regardless of whether or not
21433 the `__extension__' keyword is present. The caller is responsible
21434 for restoring the value of the PEDANTIC flag. */
21436 static bool
21438 {
21439 /* Save the old value of the PEDANTIC flag. */
21443 {
21444 /* Consume the `__extension__' token. */
21446 /* We're not being pedantic while the `__extension__' keyword is
21447 in effect. */
21451 }
21454 }
21456 /* Parse a label declaration.
21458 label-declaration:
21459 __label__ label-declarator-seq ;
21461 label-declarator-seq:
21462 identifier , label-declarator-seq
21463 identifier */
21465 static void
21467 {
21468 /* Look for the `__label__' keyword. */
21472 {
21473 tree identifier;
21475 /* Look for an identifier. */
21477 /* If we failed, stop. */
21480 /* Declare it as a label. */
21482 /* If the next token is a `;', stop. */
21485 /* Look for the `,' separating the label declarations. */
21487 }
21489 /* Look for the final `;'. */
21491 }
21493 /* Support Functions */
21495 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
21496 NAME should have one of the representations used for an
21497 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
21498 is returned. If PARSER->SCOPE is a dependent type, then a
21499 SCOPE_REF is returned.
21501 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
21502 returned; the name was already resolved when the TEMPLATE_ID_EXPR
21503 was formed. Abstractly, such entities should not be passed to this
21504 function, because they do not need to be looked up, but it is
21505 simpler to check for this special case here, rather than at the
21506 call-sites.
21508 In cases not explicitly covered above, this function returns a
21509 DECL, OVERLOAD, or baselink representing the result of the lookup.
21510 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
21511 is returned.
21513 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
21514 (e.g., "struct") that was used. In that case bindings that do not
21515 refer to types are ignored.
21517 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
21518 ignored.
21520 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
21521 are ignored.
21523 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
21524 types.
21526 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
21527 TREE_LIST of candidates if name-lookup results in an ambiguity, and
21528 NULL_TREE otherwise. */
21530 static tree
21537 location_t name_location)
21538 {
21539 tree decl;
21542 /* Assume that the lookup will be unambiguous. */
21546 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
21547 no longer valid. Note that if we are parsing tentatively, and
21548 the parse fails, OBJECT_TYPE will be automatically restored. */
21554 /* A template-id has already been resolved; there is no lookup to
21555 do. */
21559 {
21563 }
21565 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
21566 it should already have been checked to make sure that the name
21567 used matches the type being destroyed. */
21569 {
21570 tree type;
21572 /* Figure out to which type this destructor applies. */
21577 else
21579 /* If that's not a class type, there is no destructor. */
21586 /* If it was a class type, return the destructor. */
21588 }
21590 /* By this point, the NAME should be an ordinary identifier. If
21591 the id-expression was a qualified name, the qualifying scope is
21592 stored in PARSER->SCOPE at this point. */
21595 /* Perform the lookup. */
21597 {
21603 /* If the SCOPE is dependent, the lookup must be deferred until
21604 the template is instantiated -- unless we are explicitly
21605 looking up names in uninstantiated templates. Even then, we
21606 cannot look up the name if the scope is not a class type; it
21607 might, for example, be a template type parameter. */
21612 /* Defer lookup. */
21614 else
21615 {
21618 /* If PARSER->SCOPE is a dependent type, then it must be a
21619 class type, and we must not be checking dependencies;
21620 otherwise, we would have processed this lookup above. So
21621 that PARSER->SCOPE is not considered a dependent base by
21622 lookup_member, we must enter the scope here. */
21626 /* If the PARSER->SCOPE is a template specialization, it
21627 may be instantiated during name lookup. In that case,
21628 errors may be issued. Even if we rollback the current
21629 tentative parse, those errors are valid. */
21634 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
21635 lookup result and the nested-name-specifier nominates a class C:
21636 * if the name specified after the nested-name-specifier, when
21637 looked up in C, is the injected-class-name of C (Clause 9), or
21638 * if the name specified after the nested-name-specifier is the
21639 same as the identifier or the simple-template-id's template-
21640 name in the last component of the nested-name-specifier,
21641 the name is instead considered to name the constructor of
21642 class C. [ Note: for example, the constructor is not an
21643 acceptable lookup result in an elaborated-type-specifier so
21644 the constructor would not be used in place of the
21645 injected-class-name. --end note ] Such a constructor name
21646 shall be used only in the declarator-id of a declaration that
21647 names a constructor or in a using-declaration. */
21655 /* If we have a single function from a using decl, pull it out. */
21662 }
21664 /* If the scope is a dependent type and either we deferred lookup or
21665 we did lookup but didn't find the name, rememeber the name. */
21668 {
21670 {
21671 tree type;
21673 /* The resolution to Core Issue 180 says that `struct
21674 A::B' should be considered a type-name, even if `A'
21675 is dependent. */
21679 }
21683 CPP_CLOSE_PAREN)))
21687 else
21690 is_template);
21691 }
21694 }
21696 {
21698 /* Look up the name in the scope of the OBJECT_TYPE, unless the
21699 OBJECT_TYPE is not a class. */
21701 /* If the OBJECT_TYPE is a template specialization, it may
21702 be instantiated during name lookup. In that case, errors
21703 may be issued. Even if we rollback the current tentative
21704 parse, those errors are valid. */
21706 name,
21709 tf_warning_or_error);
21710 /* Look it up in the enclosing context, too. */
21718 }
21719 else
21720 {
21726 }
21728 /* If the lookup failed, let our caller know. */
21732 /* Pull out the template from an injected-class-name (or multiple). */
21736 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
21738 {
21741 /* The error message we have to print is too complicated for
21742 cp_parser_error, so we incorporate its actions directly. */
21744 {
21746 name);
21748 }
21750 }
21758 /* If we have resolved the name of a member declaration, check to
21759 see if the declaration is accessible. When the name resolves to
21760 set of overloaded functions, accessibility is checked when
21761 overload resolution is done.
21763 During an explicit instantiation, access is not checked at all,
21764 as per [temp.explicit]. */
21771 }
21773 /* Like cp_parser_lookup_name, but for use in the typical case where
21774 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
21775 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
21777 static tree
21779 {
21781 none_type,
21786 location);
21787 }
21789 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
21790 the current context, return the TYPE_DECL. If TAG_NAME_P is
21791 true, the DECL indicates the class being defined in a class-head,
21792 or declared in an elaborated-type-specifier.
21794 Otherwise, return DECL. */
21796 static tree
21798 {
21799 /* If the TEMPLATE_DECL is being declared as part of a class-head,
21800 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
21802 struct A {
21803 template <typename T> struct B;
21804 };
21806 template <typename T> struct A::B {};
21808 Similarly, in an elaborated-type-specifier:
21810 namespace N { struct X{}; }
21812 struct A {
21813 template <typename T> friend struct N::X;
21814 };
21816 However, if the DECL refers to a class type, and we are in
21817 the scope of the class, then the name lookup automatically
21818 finds the TYPE_DECL created by build_self_reference rather
21819 than a TEMPLATE_DECL. For example, in:
21821 template <class T> struct S {
21822 S s;
21823 };
21825 there is no need to handle such case. */
21831 }
21833 /* If too many, or too few, template-parameter lists apply to the
21834 declarator, issue an error message. Returns TRUE if all went well,
21835 and FALSE otherwise. */
21837 static bool
21840 location_t declarator_location)
21841 {
21843 {
21845 {
21853 /* If the DECLARATOR has the form `X<y>' then it uses one
21854 additional level of template parameters. */
21857 return cp_parser_check_template_parameters
21859 }
21874 }
21876 }
21878 /* NUM_TEMPLATES were used in the current declaration. If that is
21879 invalid, return FALSE and issue an error messages. Otherwise,
21880 return TRUE. If DECLARATOR is non-NULL, then we are checking a
21881 declarator and we can print more accurate diagnostics. */
21883 static bool
21886 location_t location,
21888 {
21889 /* If there are the same number of template classes and parameter
21890 lists, that's OK. */
21893 /* If there are more, but only one more, then we are referring to a
21894 member template. That's OK too. */
21897 /* If there are more template classes than parameter lists, we have
21898 something like:
21900 template <class T> void S<T>::R<T>::f (); */
21902 {
21912 else
21915 }
21916 /* Otherwise, there are too many template parameter lists. We have
21917 something like:
21919 template <class T> template <class U> void S::f(); */
21922 }
21924 /* Parse an optional `::' token indicating that the following name is
21925 from the global namespace. If so, PARSER->SCOPE is set to the
21926 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
21927 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
21928 Returns the new value of PARSER->SCOPE, if the `::' token is
21929 present, and NULL_TREE otherwise. */
21931 static tree
21933 {
21936 /* Peek at the next token. */
21938 /* If we're looking at a `::' token then we're starting from the
21939 global namespace, not our current location. */
21941 {
21942 /* Consume the `::' token. */
21944 /* Set the SCOPE so that we know where to start the lookup. */
21950 }
21952 {
21956 }
21959 }
21961 /* Returns TRUE if the upcoming token sequence is the start of a
21962 constructor declarator. If FRIEND_P is true, the declarator is
21963 preceded by the `friend' specifier. */
21965 static bool
21967 {
21969 tree nested_name_specifier;
21972 /* The common case is that this is not a constructor declarator, so
21973 try to avoid doing lots of work if at all possible. It's not
21974 valid declare a constructor at function scope. */
21977 /* And only certain tokens can begin a constructor declarator. */
21985 /* Parse tentatively; we are going to roll back all of the tokens
21986 consumed here. */
21988 /* Assume that we are looking at a constructor declarator. */
21991 /* Look for the optional `::' operator. */
21994 /* Look for the nested-name-specifier. */
21995 nested_name_specifier
22001 /* Outside of a class-specifier, there must be a
22002 nested-name-specifier. */
22010 /* If we have a class scope, this is easy; DR 147 says that S::S always
22011 names the constructor, and no other qualified name could. */
22014 {
22024 }
22025 /* If we still think that this might be a constructor-declarator,
22026 look for a class-name. */
22028 {
22029 /* If we have:
22031 template <typename T> struct S {
22032 S();
22033 };
22035 we must recognize that the nested `S' names a class. */
22036 tree type_decl;
22040 none_type,
22044 /* If there was no class-name, then this is not a constructor. */
22047 /* If we're still considering a constructor, we have to see a `(',
22048 to begin the parameter-declaration-clause, followed by either a
22049 `)', an `...', or a decl-specifier. We need to check for a
22050 type-specifier to avoid being fooled into thinking that:
22052 S (f) (int);
22054 is a constructor. (It is actually a function named `f' that
22055 takes one parameter (of type `int') and returns a value of type
22056 `S'. */
22064 /* A parameter declaration begins with a decl-specifier,
22065 which is either the "attribute" keyword, a storage class
22066 specifier, or (usually) a type-specifier. */
22068 {
22069 tree type;
22073 /* Names appearing in the type-specifier should be looked up
22074 in the scope of the class. */
22077 else
22078 {
22081 {
22085 {
22088 }
22089 }
22091 }
22093 /* Inside the constructor parameter list, surrounding
22094 template-parameter-lists do not apply. */
22095 saved_num_template_parameter_lists
22099 /* Look for the type-specifier. */
22101 CP_PARSER_FLAGS_NONE,
22107 parser->num_template_parameter_lists
22110 /* Leave the scope of the class. */
22115 }
22116 }
22118 /* We did not really want to consume any tokens. */
22122 }
22124 /* Parse the definition of the function given by the DECL_SPECIFIERS,
22125 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
22126 they must be performed once we are in the scope of the function.
22128 Returns the function defined. */
22130 static tree
22131 cp_parser_function_definition_from_specifiers_and_declarator
22134 tree attributes,
22136 {
22137 tree fn;
22140 /* Begin the function-definition. */
22143 /* The things we're about to see are not directly qualified by any
22144 template headers we've seen thus far. */
22147 /* If there were names looked up in the decl-specifier-seq that we
22148 did not check, check them now. We must wait until we are in the
22149 scope of the function to perform the checks, since the function
22150 might be a friend. */
22154 {
22155 /* Skip the entire function. */
22158 }
22160 {
22161 /* Seen already, skip it. An error message has already been output. */
22165 /* If this is a function from a class, pop the nested class. */
22168 }
22169 else
22170 {
22171 timevar_id_t tv;
22174 else
22180 }
22183 }
22185 /* Parse the part of a function-definition that follows the
22186 declarator. INLINE_P is TRUE iff this function is an inline
22187 function defined within a class-specifier.
22189 Returns the function defined. */
22191 static tree
22194 {
22195 tree fn;
22204 /* If the next token is `return', then the code may be trying to
22205 make use of the "named return value" extension that G++ used to
22206 support. */
22209 {
22210 /* Consume the `return' keyword. */
22212 /* Look for the identifier that indicates what value is to be
22213 returned. */
22215 /* Issue an error message. */
22218 /* Skip tokens until we reach the start of the function body. */
22220 {
22227 }
22228 }
22229 /* The `extern' in `extern "C" void f () { ... }' does not apply to
22230 anything declared inside `f'. */
22231 saved_in_unbraced_linkage_specification_p
22234 /* Inside the function, surrounding template-parameter-lists do not
22235 apply. */
22236 saved_num_template_parameter_lists
22242 /* If the next token is `try', `__transaction_atomic', or
22243 `__transaction_relaxed`, then we are looking at either function-try-block
22244 or function-transaction-block. Note that all of these include the
22245 function-body. */
22248 RID_TRANSACTION_ATOMIC);
22250 RID_TRANSACTION_RELAXED))
22252 RID_TRANSACTION_RELAXED);
22255 else
22256 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
22261 /* Finish the function. */
22264 /* Generate code for it, if necessary. */
22266 /* Restore the saved values. */
22267 parser->in_unbraced_linkage_specification_p
22269 parser->num_template_parameter_lists
22274 }
22276 /* Parse a template-declaration, assuming that the `export' (and
22277 `extern') keywords, if present, has already been scanned. MEMBER_P
22278 is as for cp_parser_template_declaration. */
22280 static void
22282 {
22285 tree parameter_list;
22290 /* Look for the `template' keyword. */
22295 /* And the `<'. */
22299 {
22300 /* 14.5.2.2 [temp.mem]
22302 A local class shall not have member templates. */
22307 }
22308 /* [temp]
22310 A template ... shall not have C linkage. */
22312 {
22314 /* Give it C++ linkage to avoid confusing other parts of the
22315 front end. */
22318 }
22319 else
22322 /* We cannot perform access checks on the template parameter
22323 declarations until we know what is being declared, just as we
22324 cannot check the decl-specifier list. */
22327 /* If the next token is `>', then we have an invalid
22328 specialization. Rather than complain about an invalid template
22329 parameter, issue an error message here. */
22331 {
22335 }
22336 else
22337 {
22338 /* Parse the template parameters. */
22340 }
22342 /* Get the deferred access checks from the parameter list. These
22343 will be checked once we know what is being declared, as for a
22344 member template the checks must be performed in the scope of the
22345 class containing the member. */
22348 /* Look for the `>'. */
22350 /* We just processed one more parameter list. */
22352 /* If the next token is `template', there are more template
22353 parameters. */
22355 RID_TEMPLATE))
22360 else
22361 {
22362 /* There are no access checks when parsing a template, as we do not
22363 know if a specialization will be a friend. */
22367 checks,
22368 member_p,
22373 /* If this is a member template declaration, let the front
22374 end know. */
22376 {
22381 }
22386 }
22387 /* We are done with the current parameter list. */
22392 /* Finish up. */
22395 /* Check the template arguments for a literal operator template. */
22399 {
22403 else
22404 {
22407 {
22413 }
22415 {
22423 }
22424 else
22426 }
22429 " Expected non-type template argument pack <char...>"
22431 decl);
22432 }
22433 /* Register member declarations. */
22436 /* For the erroneous case of a template with C linkage, we pushed an
22437 implicit C++ linkage scope; exit that scope now. */
22440 /* If DECL is a function template, we must return to parse it later.
22441 (Even though there is no definition, there might be default
22442 arguments that need handling.) */
22446 }
22448 /* Perform the deferred access checks from a template-parameter-list.
22449 CHECKS is a TREE_LIST of access checks, as returned by
22450 get_deferred_access_checks. */
22452 static void
22453 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
22454 {
22458 }
22460 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
22461 `function-definition' sequence that follows a template header.
22462 If MEMBER_P is true, this declaration appears in a class scope.
22464 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
22465 *FRIEND_P is set to TRUE iff the declaration is a friend. */
22467 static tree
22473 {
22476 cp_decl_specifier_seq decl_specifiers;
22480 /* This function is only used when processing a template
22481 declaration. */
22485 /* Defer access checks until we know what is being declared. */
22488 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
22489 alternative. */
22492 CP_PARSER_FLAGS_OPTIONAL,
22498 /* There are no template typedefs. */
22500 {
22504 }
22506 /* Gather up the access checks that occurred the
22507 decl-specifier-seq. */
22510 /* Check for the declaration of a template class. */
22512 {
22514 {
22517 /* In this case:
22519 struct C {
22520 friend template <typename T> struct A<T>::B;
22521 };
22523 A<T>::B will be represented by a TYPENAME_TYPE, and
22524 therefore not recognized by shadow_tag. */
22526 && !decl
22533 else
22536 /* Perform access checks for template parameters. */
22538 }
22539 }
22541 /* Complain about missing 'typename' or other invalid type names. */
22544 {
22545 /* cp_parser_parse_and_diagnose_invalid_type_name calls
22546 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
22547 the rest of this declaration. */
22550 }
22552 /* If it's not a template class, try for a template function. If
22553 the next token is a `;', then this declaration does not declare
22554 anything. But, if there were errors in the decl-specifiers, then
22555 the error might well have come from an attempted class-specifier.
22556 In that case, there's no need to warn about a missing declarator. */
22560 {
22563 checks,
22565 member_p,
22566 declares_class_or_enum,
22568 NULL);
22570 /* 7.1.1-1 [dcl.stc]
22572 A storage-class-specifier shall not be specified in an explicit
22573 specialization... */
22575 && explicit_specialization_p
22577 {
22581 }
22585 }
22587 /* Look for a trailing `;' after the declaration. */
22593 out:
22596 /* Clear any current qualification; whatever comes next is the start
22597 of something new. */
22603 }
22605 /* Parse a cast-expression that is not the operand of a unary "&". */
22607 static tree
22609 {
22612 }
22614 /* Parse a functional cast to TYPE. Returns an expression
22615 representing the cast. */
22617 static tree
22619 {
22621 tree expression_list;
22622 tree cast;
22626 {
22633 tf_warning_or_error);
22634 }
22643 else
22644 {
22647 }
22650 tf_warning_or_error);
22651 /* [expr.const]/1: In an integral constant expression "only type
22652 conversions to integral or enumeration type can be used". */
22658 NIC_CONSTRUCTOR))
22661 }
22663 /* Save the tokens that make up the body of a member function defined
22664 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
22665 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
22666 specifiers applied to the declaration. Returns the FUNCTION_DECL
22667 for the member function. */
22669 static tree
22673 tree attributes)
22674 {
22677 tree fn;
22679 /* Create the FUNCTION_DECL. */
22681 /* If something went badly wrong, bail out now. */
22683 {
22684 /* If there's a function-body, skip it. */
22689 }
22691 /* Remember it, if there default args to post process. */
22694 /* Save away the tokens that make up the body of the
22695 function. */
22697 /* Handle function try blocks. */
22700 /* We can have braced-init-list mem-initializers before the fn body. */
22702 {
22705 {
22706 /* cache_group will stop after an un-nested { } pair, too. */
22710 /* variadic mem-inits have ... after the ')'. */
22713 }
22714 }
22716 /* Handle function try blocks. */
22721 /* Save away the inline definition; we will process it when the
22722 class is complete. */
22726 /* We need to know that this was defined in the class, so that
22727 friend templates are handled correctly. */
22730 /* Add FN to the queue of functions to be parsed later. */
22734 }
22736 /* Save the tokens that make up the in-class initializer for a non-static
22737 data member. Returns a DEFAULT_ARG. */
22739 static tree
22741 {
22743 }
22745 /* Parse a template-argument-list, as well as the trailing ">" (but
22746 not the opening "<"). See cp_parser_template_argument_list for the
22747 return value. */
22749 static tree
22751 {
22752 tree arguments;
22753 tree saved_scope;
22754 tree saved_qualifying_scope;
22755 tree saved_object_scope;
22760 /* [temp.names]
22762 When parsing a template-id, the first non-nested `>' is taken as
22763 the end of the template-argument-list rather than a greater-than
22764 operator. */
22765 saved_greater_than_is_operator_p
22768 /* Parsing the argument list may modify SCOPE, so we save it
22769 here. */
22773 /* We need to evaluate the template arguments, even though this
22774 template-id may be nested within a "sizeof". */
22779 /* Parse the template-argument-list itself. */
22783 else
22785 /* Look for the `>' that ends the template-argument-list. If we find
22786 a '>>' instead, it's probably just a typo. */
22788 {
22790 {
22791 /* In C++0x, a `>>' in a template argument list or cast
22792 expression is considered to be two separate `>'
22793 tokens. So, change the current token to a `>', but don't
22794 consume it: it will be consumed later when the outer
22795 template argument list (or cast expression) is parsed.
22796 Note that this replacement of `>' for `>>' is necessary
22797 even if we are parsing tentatively: in the tentative
22798 case, after calling
22799 cp_parser_enclosed_template_argument_list we will always
22800 throw away all of the template arguments and the first
22801 closing `>', either because the template argument list
22802 was erroneous or because we are replacing those tokens
22803 with a CPP_TEMPLATE_ID token. The second `>' (which will
22804 not have been thrown away) is needed either to close an
22805 outer template argument list or to complete a new-style
22806 cast. */
22809 }
22811 {
22812 /* If we're in a nested template argument list, the '>>' has
22813 to be a typo for '> >'. We emit the error message, but we
22814 continue parsing and we push a '>' as next token, so that
22815 the argument list will be parsed correctly. Note that the
22816 global source location is still on the token before the
22817 '>>', so we need to say explicitly where we want it. */
22823 }
22824 else
22825 {
22826 /* If this is not a nested template argument list, the '>>'
22827 is a typo for '>'. Emit an error message and continue.
22828 Same deal about the token location, but here we can get it
22829 right by consuming the '>>' before issuing the diagnostic. */
22832 "spurious %<>>%>, use %<>%> to terminate "
22834 }
22835 }
22836 else
22838 /* The `>' token might be a greater-than operator again now. */
22839 parser->greater_than_is_operator_p
22841 /* Restore the SAVED_SCOPE. */
22849 }
22851 /* MEMBER_FUNCTION is a member function, or a friend. If default
22852 arguments, or the body of the function have not yet been parsed,
22853 parse them now. */
22855 static void
22857 {
22859 /* If this member is a template, get the underlying
22860 FUNCTION_DECL. */
22864 /* There should not be any class definitions in progress at this
22865 point; the bodies of members are only parsed outside of all class
22866 definitions. */
22868 /* While we're parsing the member functions we might encounter more
22869 classes. We want to handle them right away, but we don't want
22870 them getting mixed up with functions that are currently in the
22871 queue. */
22874 /* Make sure that any template parameters are in scope. */
22877 /* If the body of the function has not yet been parsed, parse it
22878 now. */
22880 {
22881 tree function_scope;
22884 /* The function is no longer pending; we are processing it. */
22889 /* If this is a local class, enter the scope of the containing
22890 function. */
22895 /* Push the body of the function onto the lexer stack. */
22898 /* Let the front end know that we going to be defining this
22899 function. */
22903 /* Don't do access checking if it is a templated function. */
22907 /* Now, parse the body of the function. */
22914 /* Leave the scope of the containing function. */
22918 }
22920 /* Remove any template parameters from the symbol table. */
22923 /* Restore the queue. */
22926 }
22928 /* If DECL contains any default args, remember it on the unparsed
22929 functions queue. */
22931 static void
22933 {
22934 tree probe;
22937 probe;
22940 {
22944 }
22945 }
22947 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
22948 which is either a FIELD_DECL or PARM_DECL. Parse it and return
22949 the result. For a PARM_DECL, PARMTYPE is the corresponding type
22950 from the parameter-type-list. */
22952 static tree
22955 {
22957 tree parsed_arg;
22963 /* Push the saved tokens for the default argument onto the parser's
22964 lexer stack. */
22970 /* Parse the default argument. */
22981 {
22982 /* In a non-template class, check conversions now. In a template,
22983 we'll wait and instantiate these as needed. */
22986 else
22987 {
22993 }
22994 }
22996 /* If the token stream has not been completely used up, then
22997 there was extra junk after the end of the default
22998 argument. */
23000 {
23003 else
23005 }
23007 /* Revert to the main lexer. */
23011 }
23013 /* FIELD is a non-static data member with an initializer which we saved for
23014 later; parse it now. */
23016 static void
23018 {
23019 tree def;
23024 NULL_TREE);
23028 }
23030 /* FN is a FUNCTION_DECL which may contains a parameter with an
23031 unparsed DEFAULT_ARG. Parse the default args now. This function
23032 assumes that the current scope is the scope in which the default
23033 argument should be processed. */
23035 static void
23037 {
23041 /* While we're parsing the default args, we might (due to the
23042 statement expression extension) encounter more classes. We want
23043 to handle them right away, but we don't want them getting mixed
23044 up with default args that are currently in the queue. */
23047 /* Local variable names (and the `this' keyword) may not appear
23048 in a default argument. */
23059 {
23061 tree parsed_arg;
23063 tree copy;
23070 /* This can happen for a friend declaration for a function
23071 already declared with default arguments. */
23074 parsed_arg
23076 default_arg,
23079 {
23081 }
23085 /* Update any instantiations we've already created. */
23089 }
23093 /* Make sure no default arg is missing. */
23096 /* Restore the state of local_variables_forbidden_p. */
23099 /* Restore the queue. */
23101 }
23103 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
23105 sizeof ... ( identifier )
23107 where the 'sizeof' token has already been consumed. */
23109 static tree
23111 {
23112 /* Consume the `...'. */
23119 else
23139 }
23141 /* Parse the operand of `sizeof' (or a similar operator). Returns
23142 either a TYPE or an expression, depending on the form of the
23143 input. The KEYWORD indicates which kind of expression we have
23144 encountered. */
23146 static tree
23148 {
23155 /* If it's a `...', then we are computing the length of a parameter
23156 pack. */
23161 /* Types cannot be defined in a `sizeof' expression. Save away the
23162 old message. */
23164 /* And create the new one. */
23170 /* The restrictions on constant-expressions do not apply inside
23171 sizeof expressions. */
23172 saved_integral_constant_expression_p
23174 saved_non_integral_constant_expression_p
23178 /* Do not actually evaluate the expression. */
23181 /* If it's a `(', then we might be looking at the type-id
23182 construction. */
23184 {
23188 /* We can't be sure yet whether we're looking at a type-id or an
23189 expression. */
23191 /* Consume the `('. */
23193 /* Note: as a GNU Extension, compound literals are considered
23194 postfix-expressions as they are in C99, so they are valid
23195 arguments to sizeof. See comment in cp_parser_cast_expression
23196 for details. */
23198 /* Skip tokens until the next token is a closing parenthesis.
23199 If we find the closing `)', and the next token is a `{', then
23200 we are looking at a compound-literal. */
23201 compound_literal_p
23205 /* Roll back the tokens we skipped. */
23207 /* If we were looking at a compound-literal, simulate an error
23208 so that the call to cp_parser_parse_definitely below will
23209 fail. */
23212 else
23213 {
23216 /* Look for the type-id. */
23218 /* Look for the closing `)'. */
23221 }
23223 /* If all went well, then we're done. */
23225 {
23226 cp_decl_specifier_seq decl_specs;
23228 /* Build a trivial decl-specifier-seq. */
23232 /* Call grokdeclarator to figure out what type this is. */
23235 TYPENAME,
23238 }
23239 }
23241 /* If the type-id production did not work out, then we must be
23242 looking at the unary-expression production. */
23247 /* Go back to evaluating expressions. */
23251 /* Free the message we created. */
23253 /* And restore the old one. */
23255 parser->integral_constant_expression_p
23257 parser->non_integral_constant_expression_p
23261 }
23263 /* If the current declaration has no declarator, return true. */
23265 static bool
23267 {
23268 /* If the next token is a `;' or a `,' then there is no
23269 declarator. */
23272 }
23274 /* Update the DECL_SPECS to reflect the storage class indicated by
23275 KEYWORD. */
23277 static void
23282 {
23283 cp_storage_class storage_class;
23286 {
23290 }
23292 {
23295 }
23300 {
23303 }
23306 {
23324 }
23328 /* A storage class specifier cannot be applied alongside a typedef
23329 specifier. If there is a typedef specifier present then set
23330 conflicting_specifiers_p which will trigger an error later
23331 on in grokdeclarator. */
23334 }
23336 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
23337 is true, the type is a class or enum definition. */
23339 static void
23341 tree type_spec,
23344 {
23347 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
23348 (with, for example, in "typedef int wchar_t;") we remember that
23349 this is what happened. In system headers, we ignore these
23350 declarations so that G++ can work with system headers that are not
23351 C++-safe. */
23353 && !type_definition_p
23363 {
23366 ds_redefined_builtin_type_spec,
23367 token);
23369 {
23373 }
23374 }
23377 else
23378 {
23383 }
23384 }
23386 /* True iff TOKEN is the GNU keyword __thread. */
23388 static bool
23390 {
23393 }
23395 /* Set the location for a declarator specifier and check if it is
23396 duplicated.
23398 DECL_SPECS is the sequence of declarator specifiers onto which to
23399 set the location.
23401 DS is the single declarator specifier to set which location is to
23402 be set onto the existing sequence of declarators.
23404 LOCATION is the location for the declarator specifier to
23405 consider. */
23407 static void
23410 {
23419 {
23423 }
23424 else
23425 {
23427 {
23431 else
23432 {
23435 OPT_Wlong_long,
23437 }
23438 }
23440 {
23445 else
23447 }
23448 else
23449 {
23465 "__complex"
23466 };
23469 }
23470 }
23471 }
23473 /* Return true iff the declarator specifier DS is present in the
23474 sequence of declarator specifiers DECL_SPECS. */
23476 bool
23478 cp_decl_spec ds)
23479 {
23486 }
23488 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
23489 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
23491 static bool
23493 {
23495 }
23497 /* Issue an error message indicating that TOKEN_DESC was expected.
23498 If KEYWORD is true, it indicated this function is called by
23499 cp_parser_require_keword and the required token can only be
23500 a indicated keyword. */
23502 static void
23504 required_token token_desc,
23506 {
23508 {
23577 }
23579 {
23581 {
23660 }
23661 }
23662 else
23664 }
23668 /* If the next token is of the indicated TYPE, consume it. Otherwise,
23669 issue an error message indicating that TOKEN_DESC was expected.
23671 Returns the token consumed, if the token had the appropriate type.
23672 Otherwise, returns NULL. */
23677 required_token token_desc)
23678 {
23681 else
23682 {
23683 /* Output the MESSAGE -- unless we're parsing tentatively. */
23687 }
23688 }
23690 /* An error message is produced if the next token is not '>'.
23691 All further tokens are skipped until the desired token is
23692 found or '{', '}', ';' or an unbalanced ')' or ']'. */
23694 static void
23696 {
23697 /* Current level of '< ... >'. */
23699 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
23702 /* Are we ready, yet? If not, issue error message. */
23706 /* Skip tokens until the desired token is found. */
23708 {
23709 /* Peek at the next token. */
23711 {
23719 /* C++0x views the `>>' operator as two `>' tokens, but
23720 C++98 does not. */
23723 {
23724 /* We've hit a `>>' where the first `>' closes the
23725 template argument list, and the second `>' is
23726 spurious. Just consume the `>>' and stop; we've
23727 already produced at least one error. */
23730 }
23731 /* Fall through for C++0x, so we handle the second `>' in
23732 the `>>'. */
23736 {
23737 /* We've reached the token we want, consume it and stop. */
23740 }
23759 /* The '>' was probably forgotten, don't look further. */
23764 }
23766 /* Consume this token. */
23768 }
23769 }
23771 /* If the next token is the indicated keyword, consume it. Otherwise,
23772 issue an error message indicating that TOKEN_DESC was expected.
23774 Returns the token consumed, if the token had the appropriate type.
23775 Otherwise, returns NULL. */
23780 required_token token_desc)
23781 {
23785 {
23788 }
23791 }
23793 /* Returns TRUE iff TOKEN is a token that can begin the body of a
23794 function-definition. */
23796 static bool
23798 {
23801 /* A ctor-initializer begins with a `:'. */
23803 /* A function-try-block begins with `try'. */
23805 /* A function-transaction-block begins with `__transaction_atomic'
23806 or `__transaction_relaxed'. */
23809 /* The named return value extension begins with `return'. */
23811 }
23813 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
23814 definition. */
23816 static bool
23818 {
23823 }
23825 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
23826 C++0x) ending a template-argument. */
23828 static bool
23830 {
23838 }
23840 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
23841 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
23843 static bool
23846 {
23852 /* Check for the sequence `<::' in the original code. It would be lexed as
23853 `[:', where `[' is a digraph, and there is no whitespace before
23854 `:'. */
23856 {
23861 }
23863 }
23865 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
23866 or none_type otherwise. */
23868 static enum tag_types
23870 {
23872 {
23882 }
23883 }
23885 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
23887 static void
23889 {
23893 {
23897 type))
23900 }
23901 }
23903 /* Issue an error message if DECL is redeclared with different
23904 access than its original declaration [class.access.spec/3].
23905 This applies to nested classes and nested class templates.
23906 [class.mem/1]. */
23908 static void
23910 {
23919 }
23921 /* Look for the `template' keyword, as a syntactic disambiguator.
23922 Return TRUE iff it is present, in which case it will be
23923 consumed. */
23925 static bool
23927 {
23929 {
23930 /* In C++98 the `template' keyword can only be used within templates;
23931 outside templates the parser can always figure out what is a
23932 template and what is not. In C++11, per the resolution of DR 468,
23933 `template' is allowed in cases where it is not strictly necessary. */
23936 {
23939 "in C++98 %<template%> (as a disambiguator) is only "
23941 /* If this part of the token stream is rescanned, the same
23942 error message would be generated. So, we purge the token
23943 from the stream. */
23946 }
23947 else
23948 {
23949 /* Consume the `template' keyword. */
23952 }
23953 }
23955 }
23957 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
23958 set PARSER->SCOPE, and perform other related actions. */
23960 static void
23962 {
23968 /* Get the stored value. */
23970 /* Perform any access checks that were deferred. */
23973 {
23978 }
23979 /* Set the scope from the stored value. */
23983 }
23985 /* Consume tokens up through a non-nested END token. Returns TRUE if we
23986 encounter the end of a block before what we were looking for. */
23988 static bool
23992 {
23994 {
23997 /* Abort a parenthesized expression if we encounter a semicolon. */
24001 /* If we've reached the end of the file, stop. */
24007 /* We've hit the end of an enclosing block, so there's been some
24008 kind of syntax error. */
24011 /* Consume the token. */
24013 /* See if it starts a new group. */
24015 {
24017 /* In theory this should probably check end == '}', but
24018 cp_parser_save_member_function_body needs it to exit
24019 after either '}' or ')' when called with ')'. */
24022 }
24024 {
24028 }
24033 }
24034 }
24036 /* Like above, for caching a default argument or NSDMI. Both of these are
24037 terminated by a non-nested comma, but it can be unclear whether or not a
24038 comma is nested in a template argument list unless we do more parsing.
24039 In order to handle this ambiguity, when we encounter a ',' after a '<'
24040 we try to parse what follows as a parameter-declaration-list (in the
24041 case of a default argument) or a member-declarator (in the case of an
24042 NSDMI). If that succeeds, then we stop caching. */
24044 static tree
24046 {
24051 tree default_argument;
24053 /* Add tokens until we have processed the entire default
24054 argument. We add the range [first_token, token). */
24057 {
24058 /* For list-initialization, this is straightforward. */
24061 }
24063 {
24066 /* Peek at the next token. */
24068 /* What we do depends on what token we have. */
24070 {
24071 /* In valid code, a default argument must be
24072 immediately followed by a `,' `)', or `...'. */
24075 {
24076 /* If we've seen a '<', we might be in a
24077 template-argument-list. Until Core issue 325 is
24078 resolved, we don't know how this situation ought
24079 to be handled, so try to DTRT. We check whether
24080 what comes after the comma is a valid parameter
24081 declaration list. If it is, then the comma ends
24082 the default argument; otherwise the default
24083 argument continues. */
24085 tree t;
24087 /* Set ITALP so cp_parser_parameter_declaration_list
24088 doesn't decide to commit to this parse. */
24096 {
24102 }
24103 else
24104 {
24110 }
24117 }
24120 /* If we run into a non-nested `;', `}', or `]',
24121 then the code is invalid -- but the default
24122 argument is certainly over. */
24128 /* Update DEPTH, if necessary. */
24143 /* This might be the comparison operator, or it might
24144 start a template argument list. */
24151 /* Fall through for C++0x, which treats the `>>'
24152 operator like two `>' tokens in certain
24153 cases. */
24157 {
24158 /* This might be an operator, or it might close a
24159 template argument list. But if a previous '<'
24160 started a template argument list, this will have
24161 closed it, so we can't be in one anymore. */
24165 }
24168 /* If we run out of tokens, issue an error message. */
24177 /* In these cases, we should look for template-ids.
24178 For example, if the default argument is
24179 `X<int, double>()', we need to do name lookup to
24180 figure out whether or not `X' is a template; if
24181 so, the `,' does not end the default argument.
24183 That is not yet done. */
24188 }
24190 /* If we've reached the end, stop. */
24194 /* Add the token to the token block. */
24196 }
24198 /* Create a DEFAULT_ARG to represent the unparsed default
24199 argument. */
24206 }
24208 /* Begin parsing tentatively. We always save tokens while parsing
24209 tentatively so that if the tentative parsing fails we can restore the
24210 tokens. */
24212 static void
24214 {
24215 /* Enter a new parsing context. */
24217 /* Begin saving tokens. */
24219 /* In order to avoid repetitive access control error messages,
24220 access checks are queued up until we are no longer parsing
24221 tentatively. */
24223 }
24225 /* Commit to the currently active tentative parse. */
24227 static void
24229 {
24233 /* Mark all of the levels as committed. */
24236 {
24243 }
24244 }
24246 /* Abort the currently active tentative parse. All consumed tokens
24247 will be rolled back, and no diagnostics will be issued. */
24249 static void
24251 {
24255 /* Now, pretend that we want to see if the construct was
24256 successfully parsed. */
24258 }
24260 /* Stop parsing tentatively. If a parse error has occurred, restore the
24261 token stream. Otherwise, commit to the tokens we have consumed.
24262 Returns true if no error occurred; false otherwise. */
24264 static bool
24266 {
24270 /* Remember whether or not an error occurred, since we are about to
24271 destroy that information. */
24273 /* Remove the topmost context from the stack. */
24276 /* If no parse errors occurred, commit to the tentative parse. */
24278 {
24279 /* Commit to the tokens read tentatively, unless that was
24280 already done. */
24285 }
24286 /* Otherwise, if errors occurred, roll back our state so that things
24287 are just as they were before we began the tentative parse. */
24288 else
24289 {
24292 }
24293 /* Add the context to the front of the free list. */
24298 }
24300 /* Returns true if we are parsing tentatively and are not committed to
24301 this tentative parse. */
24303 static bool
24305 {
24308 }
24310 /* Returns nonzero iff an error has occurred during the most recent
24311 tentative parse. */
24313 static bool
24315 {
24318 }
24320 /* Returns nonzero if GNU extensions are allowed. */
24322 static bool
24324 {
24326 }
24327 \f
24328 /* Objective-C++ Productions */
24331 /* Parse an Objective-C expression, which feeds into a primary-expression
24332 above.
24334 objc-expression:
24335 objc-message-expression
24336 objc-string-literal
24337 objc-encode-expression
24338 objc-protocol-expression
24339 objc-selector-expression
24341 Returns a tree representation of the expression. */
24343 static tree
24345 {
24346 /* Try to figure out what kind of declaration is present. */
24350 {
24360 {
24372 }
24378 }
24381 }
24383 /* Parse an Objective-C message expression.
24385 objc-message-expression:
24386 [ objc-message-receiver objc-message-args ]
24388 Returns a representation of an Objective-C message. */
24390 static tree
24392 {
24401 }
24403 /* Parse an objc-message-receiver.
24405 objc-message-receiver:
24406 expression
24407 simple-type-specifier
24409 Returns a representation of the type or expression. */
24411 static tree
24413 {
24414 tree rcv;
24416 /* An Objective-C message receiver may be either (1) a type
24417 or (2) an expression. */
24426 CP_PARSER_FLAGS_NONE);
24429 }
24431 /* Parse the arguments and selectors comprising an Objective-C message.
24433 objc-message-args:
24434 objc-selector
24435 objc-selector-args
24436 objc-selector-args , objc-comma-args
24438 objc-selector-args:
24439 objc-selector [opt] : assignment-expression
24440 objc-selector-args objc-selector [opt] : assignment-expression
24442 objc-comma-args:
24443 assignment-expression
24444 objc-comma-args , assignment-expression
24446 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
24447 selector arguments and TREE_VALUE containing a list of comma
24448 arguments. */
24450 static tree
24452 {
24458 {
24464 /* Detect if we have a unary selector. */
24473 sel_args
24478 }
24480 /* Handle non-selector arguments, if any. */
24482 {
24483 tree arg;
24488 addl_args
24493 }
24496 {
24499 }
24502 }
24504 /* Parse an Objective-C encode expression.
24506 objc-encode-expression:
24507 @encode objc-typename
24509 Returns an encoded representation of the type argument. */
24511 static tree
24513 {
24514 tree type;
24524 {
24528 }
24530 /* This happens if we find @encode(T) (where T is a template
24531 typename or something dependent on a template typename) when
24532 parsing a template. In that case, we can't compile it
24533 immediately, but we rather create an AT_ENCODE_EXPR which will
24534 need to be instantiated when the template is used.
24535 */
24537 {
24541 }
24544 }
24546 /* Parse an Objective-C @defs expression. */
24548 static tree
24550 {
24551 tree name;
24559 }
24561 /* Parse an Objective-C protocol expression.
24563 objc-protocol-expression:
24564 @protocol ( identifier )
24566 Returns a representation of the protocol expression. */
24568 static tree
24570 {
24571 tree proto;
24579 }
24581 /* Parse an Objective-C selector expression.
24583 objc-selector-expression:
24584 @selector ( objc-method-signature )
24586 objc-method-signature:
24587 objc-selector
24588 objc-selector-seq
24590 objc-selector-seq:
24591 objc-selector :
24592 objc-selector-seq objc-selector :
24594 Returns a representation of the method selector. */
24596 static tree
24598 {
24610 {
24619 {
24620 /* Detect if we have a unary selector. */
24622 {
24625 }
24626 else
24627 {
24629 }
24630 }
24635 {
24636 sel_seq
24639 sel_seq
24642 }
24643 else
24644 sel_seq
24649 }
24651 finish_selector:
24655 }
24657 /* Parse a list of identifiers.
24659 objc-identifier-list:
24660 identifier
24661 objc-identifier-list , identifier
24663 Returns a TREE_LIST of identifier nodes. */
24665 static tree
24667 {
24668 tree identifier;
24669 tree list;
24680 {
24687 identifier));
24689 }
24692 }
24694 /* Parse an Objective-C alias declaration.
24696 objc-alias-declaration:
24697 @compatibility_alias identifier identifier ;
24699 This function registers the alias mapping with the Objective-C front end.
24700 It returns nothing. */
24702 static void
24704 {
24712 }
24714 /* Parse an Objective-C class forward-declaration.
24716 objc-class-declaration:
24717 @class objc-identifier-list ;
24719 The function registers the forward declarations with the Objective-C
24720 front end. It returns nothing. */
24722 static void
24724 {
24727 {
24728 tree id;
24738 else
24740 }
24742 }
24744 /* Parse a list of Objective-C protocol references.
24746 objc-protocol-refs-opt:
24747 objc-protocol-refs [opt]
24749 objc-protocol-refs:
24750 < objc-identifier-list >
24752 Returns a TREE_LIST of identifiers, if any. */
24754 static tree
24756 {
24760 {
24764 }
24767 }
24769 /* Parse a Objective-C visibility specification. */
24771 static void
24773 {
24777 {
24792 }
24794 /* Eat '@private'/'@protected'/'@public'. */
24796 }
24798 /* Parse an Objective-C method type. Return 'true' if it is a class
24799 (+) method, and 'false' if it is an instance (-) method. */
24803 {
24806 else
24808 }
24810 /* Parse an Objective-C protocol qualifier. */
24812 static tree
24814 {
24827 {
24832 }
24835 }
24837 /* Parse an Objective-C typename. */
24839 static tree
24841 {
24845 {
24851 /* An ObjC type name may consist of just protocol qualifiers, in which
24852 case the type shall default to 'id'. */
24854 {
24857 /* If the type could not be parsed, an error has already
24858 been produced. For error recovery, behave as if it had
24859 not been specified, which will use the default type
24860 'id'. */
24862 {
24864 /* We need to skip to the closing parenthesis as
24865 cp_parser_type_id() does not seem to do it for
24866 us. */
24871 }
24872 }
24876 }
24879 }
24881 /* Check to see if TYPE refers to an Objective-C selector name. */
24883 static bool
24885 {
24891 }
24893 /* Parse an Objective-C selector. */
24895 static tree
24897 {
24901 {
24904 }
24906 /* C++ operator names are allowed to appear in ObjC selectors. */
24908 {
24921 }
24922 }
24924 /* Parse an Objective-C params list. */
24926 static tree
24928 {
24934 {
24944 /* Detect if we have a unary selector. */
24947 {
24950 }
24954 {
24955 /* Something went quite wrong. There should be a colon
24956 here, but there is not. Stop parsing parameters. */
24958 }
24960 /* New ObjC allows attributes on parameters too. */
24965 params
24968 type_name,
24969 identifier,
24970 parm_attr));
24973 }
24976 {
24979 }
24981 /* We allow tail attributes for the method. */
24983 {
24991 }
24994 {
24997 }
24999 }
25001 /* Parse the non-keyword Objective-C params. */
25003 static tree
25006 {
25012 {
25014 tree parm;
25020 {
25025 }
25027 /* TODO: parse attributes for tail parameters. */
25036 }
25038 /* We allow tail attributes for the method. */
25040 {
25042 {
25047 }
25048 else
25049 /* We have an error, but parse the attributes, so that we can
25050 carry on. */
25056 }
25059 }
25061 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
25063 static void
25065 {
25068 /* If the next token is `extern' and the following token is a string
25069 literal, then we have a linkage specification. */
25071 && cp_parser_is_pure_string_literal
25074 /* Handle #pragma, if any. */
25077 /* Allow stray semicolons. */
25080 /* Mark methods as optional or required, when building protocols. */
25082 {
25085 }
25087 {
25090 }
25093 /* Other stray characters must generate errors. */
25095 {
25099 }
25100 /* Finally, try to parse a block-declaration, or a function-definition. */
25101 else
25103 }
25105 /* Parse a method signature. */
25107 static tree
25109 {
25125 }
25127 static bool
25129 {
25130 tree tattr;
25135 /* If the attributes are followed by a method introducer, this is not allowed.
25136 Dump the attributes and flag the situation. */
25141 /* Otherwise, the attributes introduce some interstitial code, possibly so
25142 rewind to allow that check. */
25145 }
25147 /* Parse an Objective-C method prototype list. */
25149 static void
25151 {
25155 {
25157 {
25162 else
25166 {
25170 }
25173 }
25179 OPT_Wattributes,
25181 else
25182 /* Allow for interspersed non-ObjC++ code. */
25186 }
25190 else
25194 }
25196 /* Parse an Objective-C method definition list. */
25198 static void
25200 {
25204 {
25205 tree meth;
25208 {
25214 else
25219 {
25223 }
25225 NULL_TREE);
25227 /* For historical reasons, we accept an optional semicolon. */
25234 {
25241 }
25242 }
25243 /* The following case will be removed once @synthesize is
25244 completely implemented. */
25255 else
25256 /* Allow for interspersed non-ObjC++ code. */
25260 }
25264 else
25268 }
25270 /* Parse Objective-C ivars. */
25272 static void
25274 {
25285 {
25286 cp_decl_specifier_seq declspecs;
25288 tree prefix_attributes;
25296 CP_PARSER_FLAGS_OPTIONAL,
25300 /* auto, register, static, extern, mutable. */
25302 {
25305 }
25307 /* thread_local. */
25309 {
25312 }
25314 /* typedef. */
25316 {
25319 }
25324 /* Keep going until we hit the `;' at the end of the
25325 declaration. */
25327 {
25332 /* Check for a (possibly unnamed) bitfield declaration. */
25340 {
25341 /* Get the name of the bitfield. */
25344 sfk_none);
25346 eat_colon:
25348 /* Get the width of the bitfield. */
25349 width
25352 NULL);
25353 }
25354 else
25355 {
25356 /* Parse the declarator. */
25357 declarator
25362 }
25364 /* Look for attributes that apply to the ivar. */
25366 /* Remember which attributes are prefix attributes and
25367 which are not. */
25369 /* Combine the attributes. */
25373 /* Create the bitfield declaration. */
25375 width,
25376 attributes);
25377 else
25382 /* Add the instance variable. */
25386 /* Reset PREFIX_ATTRIBUTES. */
25395 {
25398 }
25400 }
25404 }
25409 /* Do not consume the RID_AT_END, so it will be read again as terminating
25410 the @interface of @implementation. */
25414 /* For historical reasons, we accept an optional semicolon. */
25417 }
25419 /* Parse an Objective-C protocol declaration. */
25421 static void
25423 {
25429 {
25434 }
25436 /* See if we have a forward declaration or a definition. */
25439 /* Try a forward declaration first. */
25441 {
25443 {
25444 tree id;
25454 else
25456 }
25458 }
25460 /* Ok, we got a full-fledged definition (or at least should). */
25461 else
25462 {
25467 }
25468 }
25470 /* Parse an Objective-C superclass or category. */
25472 static void
25477 {
25483 {
25486 }
25488 {
25491 /* If there is no category name, and this is an @interface, we
25492 have a class extension. */
25494 {
25497 }
25498 else
25502 }
25503 }
25505 /* Parse an Objective-C class interface. */
25507 static void
25509 {
25516 {
25517 /* It's hard to recover because even if valid @interface stuff
25518 is to follow, we can't compile it (or validate it) if we
25519 don't even know which class it refers to. Let's assume this
25520 was a stray '@interface' token in the stream and skip it.
25521 */
25523 }
25528 /* We have either a class or a category on our hands. */
25531 else
25532 {
25534 /* Handle instance variable declarations, if any. */
25537 }
25540 }
25542 /* Parse an Objective-C class implementation. */
25544 static void
25546 {
25553 {
25554 /* It's hard to recover because even if valid @implementation
25555 stuff is to follow, we can't compile it (or validate it) if
25556 we don't even know which class it refers to. Let's assume
25557 this was a stray '@implementation' token in the stream and
25558 skip it.
25559 */
25561 }
25565 /* We have either a class or a category on our hands. */
25568 else
25569 {
25571 /* Handle instance variable declarations, if any. */
25574 }
25577 }
25579 /* Consume the @end token and finish off the implementation. */
25581 static void
25583 {
25586 }
25588 /* Parse an Objective-C declaration. */
25590 static void
25592 {
25593 /* Try to figure out what kind of declaration is present. */
25598 {
25614 }
25617 {
25640 }
25641 }
25643 /* Parse an Objective-C try-catch-finally statement.
25645 objc-try-catch-finally-stmt:
25646 @try compound-statement objc-catch-clause-seq [opt]
25647 objc-finally-clause [opt]
25649 objc-catch-clause-seq:
25650 objc-catch-clause objc-catch-clause-seq [opt]
25652 objc-catch-clause:
25653 @catch ( objc-exception-declaration ) compound-statement
25655 objc-finally-clause:
25656 @finally compound-statement
25658 objc-exception-declaration:
25659 parameter-declaration
25660 '...'
25662 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
25664 Returns NULL_TREE.
25666 PS: This function is identical to c_parser_objc_try_catch_finally_statement
25667 for C. Keep them in sync. */
25669 static tree
25671 {
25672 location_t location;
25673 tree stmt;
25678 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
25679 node, lest it get absorbed into the surrounding block. */
25685 {
25694 {
25695 /* We have "@catch (...)" (where the '...' are literally
25696 what is in the code). Skip the '...'.
25697 parameter_declaration is set to NULL_TREE, and
25698 objc_being_catch_clauses() knows that that means
25699 '...'. */
25702 }
25703 else
25704 {
25705 /* We have "@catch (NSException *exception)" or something
25706 like that. Parse the parameter declaration. */
25710 else
25715 }
25718 else
25719 {
25720 /* If there was no open parenthesis, we are recovering from
25721 an error, and we are trying to figure out what mistake
25722 the user has made. */
25724 /* If there is an immediate closing parenthesis, the user
25725 probably forgot the opening one (ie, they typed "@catch
25726 NSException *e)". Parse the closing parenthesis and keep
25727 going. */
25731 /* If these is no immediate closing parenthesis, the user
25732 probably doesn't know that parenthesis are required at
25733 all (ie, they typed "@catch NSException *e"). So, just
25734 forget about the closing parenthesis and keep going. */
25735 }
25739 }
25741 {
25744 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
25745 node, lest it get absorbed into the surrounding block. */
25749 }
25752 }
25754 /* Parse an Objective-C synchronized statement.
25756 objc-synchronized-stmt:
25757 @synchronized ( expression ) compound-statement
25759 Returns NULL_TREE. */
25761 static tree
25763 {
25764 location_t location;
25775 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
25776 node, lest it get absorbed into the surrounding block. */
25781 }
25783 /* Parse an Objective-C throw statement.
25785 objc-throw-stmt:
25786 @throw assignment-expression [opt] ;
25788 Returns a constructed '@throw' statement. */
25790 static tree
25792 {
25804 }
25806 /* Parse an Objective-C statement. */
25808 static tree
25810 {
25811 /* Try to figure out what kind of declaration is present. */
25815 {
25826 }
25829 }
25831 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
25832 look ahead to see if an objc keyword follows the attributes. This
25833 is to detect the use of prefix attributes on ObjC @interface and
25834 @protocol. */
25836 static bool
25838 {
25843 {
25846 }
25849 }
25851 /* This routine is a minimal replacement for
25852 c_parser_struct_declaration () used when parsing the list of
25853 types/names or ObjC++ properties. For example, when parsing the
25854 code
25856 @property (readonly) int a, b, c;
25858 this function is responsible for parsing "int a, int b, int c" and
25859 returning the declarations as CHAIN of DECLs.
25861 TODO: Share this code with cp_parser_objc_class_ivars. It's very
25862 similar parsing. */
25863 static tree
25865 {
25867 cp_decl_specifier_seq declspecs;
25869 tree prefix_attributes;
25872 CP_PARSER_FLAGS_NONE,
25879 /* auto, register, static, extern, mutable. */
25881 {
25884 }
25886 /* thread_local. */
25888 {
25891 }
25893 /* typedef. */
25895 {
25898 }
25903 /* Keep going until we hit the `;' at the end of the declaration. */
25905 {
25910 /* Parse the declarator. */
25914 /* Look for attributes that apply to the ivar. */
25916 /* Remember which attributes are prefix attributes and
25917 which are not. */
25919 /* Combine the attributes. */
25929 /* Reset PREFIX_ATTRIBUTES. */
25940 {
25943 }
25944 else
25946 }
25948 }
25950 /* Parse an Objective-C @property declaration. The syntax is:
25952 objc-property-declaration:
25953 '@property' objc-property-attributes[opt] struct-declaration ;
25955 objc-property-attributes:
25956 '(' objc-property-attribute-list ')'
25958 objc-property-attribute-list:
25959 objc-property-attribute
25960 objc-property-attribute-list, objc-property-attribute
25962 objc-property-attribute
25963 'getter' = identifier
25964 'setter' = identifier
25965 'readonly'
25966 'readwrite'
25967 'assign'
25968 'retain'
25969 'copy'
25970 'nonatomic'
25972 For example:
25973 @property NSString *name;
25974 @property (readonly) id object;
25975 @property (retain, nonatomic, getter=getTheName) id name;
25976 @property int a, b, c;
25978 PS: This function is identical to
25979 c_parser_objc_at_property_declaration for C. Keep them in sync. */
25980 static void
25982 {
25983 /* The following variables hold the attributes of the properties as
25984 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
25985 seen. When we see an attribute, we set them to 'true' (if they
25986 are boolean properties) or to the identifier (if they have an
25987 argument, ie, for getter and setter). Note that here we only
25988 parse the list of attributes, check the syntax and accumulate the
25989 attributes that we find. objc_add_property_declaration() will
25990 then process the information. */
26000 /* 'properties' is the list of properties that we read. Usually a
26001 single one, but maybe more (eg, in "@property int a, b, c;" there
26002 are three). */
26003 tree properties;
26004 location_t loc;
26010 /* Parse the optional attribute list... */
26012 {
26013 /* Eat the '('. */
26017 {
26023 {
26026 }
26030 {
26041 {
26045 else
26050 }
26053 {
26057 }
26059 {
26061 {
26064 }
26065 else
26069 else
26071 }
26072 else
26073 {
26075 {
26078 }
26079 else
26081 }
26087 }
26094 else
26096 }
26098 /* FIXME: "@property (setter, assign);" will generate a spurious
26099 "error: expected ‘)’ before ‘,’ token". This is because
26100 cp_parser_require, unlike the C counterpart, will produce an
26101 error even if we are in error recovery. */
26103 {
26108 }
26109 }
26111 /* ... and the property declaration(s). */
26115 {
26117 /* If the next token is now a `;', consume it. */
26121 }
26125 else
26126 {
26127 /* Comma-separated properties are chained together in
26128 reverse order; add them one by one. */
26137 }
26140 }
26142 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
26144 objc-synthesize-declaration:
26145 @synthesize objc-synthesize-identifier-list ;
26147 objc-synthesize-identifier-list:
26148 objc-synthesize-identifier
26149 objc-synthesize-identifier-list, objc-synthesize-identifier
26151 objc-synthesize-identifier
26152 identifier
26153 identifier = identifier
26155 For example:
26156 @synthesize MyProperty;
26157 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
26159 PS: This function is identical to c_parser_objc_at_synthesize_declaration
26160 for C. Keep them in sync.
26161 */
26162 static void
26164 {
26166 location_t loc;
26171 {
26175 {
26178 }
26180 {
26184 {
26187 }
26188 }
26189 else
26194 else
26196 }
26199 }
26201 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
26203 objc-dynamic-declaration:
26204 @dynamic identifier-list ;
26206 For example:
26207 @dynamic MyProperty;
26208 @dynamic MyProperty, AnotherProperty;
26210 PS: This function is identical to c_parser_objc_at_dynamic_declaration
26211 for C. Keep them in sync.
26212 */
26213 static void
26215 {
26217 location_t loc;
26222 {
26223 tree property;
26226 {
26229 }
26233 else
26235 }
26238 }
26240 \f
26241 /* OpenMP 2.5 parsing routines. */
26243 /* Returns name of the next clause.
26244 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
26245 the token is not consumed. Otherwise appropriate pragma_omp_clause is
26246 returned and the token is consumed. */
26248 static pragma_omp_clause
26250 {
26260 {
26265 {
26312 }
26313 }
26319 }
26321 /* Validate that a clause of the given type does not already exist. */
26323 static void
26326 {
26327 tree c;
26331 {
26334 }
26335 }
26337 /* OpenMP 2.5:
26338 variable-list:
26339 identifier
26340 variable-list , identifier
26342 In addition, we match a closing parenthesis. An opening parenthesis
26343 will have been consumed by the caller.
26345 If KIND is nonzero, create the appropriate node and install the decl
26346 in OMP_CLAUSE_DECL and add the node to the head of the list.
26348 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
26349 return the list created. */
26351 static tree
26353 tree list)
26354 {
26357 {
26374 {
26379 }
26380 else
26383 get_comma:
26387 }
26390 {
26393 /* Try to resync to an unnested comma. Copied from
26394 cp_parser_parenthesized_expression_list. */
26395 skip_comma:
26402 }
26405 }
26407 /* Similarly, but expect leading and trailing parenthesis. This is a very
26408 common case for omp clauses. */
26410 static tree
26412 {
26416 }
26418 /* OpenMP 3.0:
26419 collapse ( constant-expression ) */
26421 static tree
26423 {
26425 location_t loc;
26426 HOST_WIDE_INT n;
26446 {
26449 }
26457 }
26459 /* OpenMP 2.5:
26460 default ( shared | none ) */
26462 static tree
26464 {
26466 tree c;
26471 {
26476 {
26491 }
26494 }
26495 else
26496 {
26497 invalid_kind:
26499 }
26515 }
26517 /* OpenMP 3.1:
26518 final ( expression ) */
26520 static tree
26522 {
26543 }
26545 /* OpenMP 2.5:
26546 if ( expression ) */
26548 static tree
26550 {
26571 }
26573 /* OpenMP 3.1:
26574 mergeable */
26576 static tree
26579 {
26580 tree c;
26583 location);
26588 }
26590 /* OpenMP 2.5:
26591 nowait */
26593 static tree
26596 {
26597 tree c;
26604 }
26606 /* OpenMP 2.5:
26607 num_threads ( expression ) */
26609 static tree
26611 location_t location)
26612 {
26634 }
26636 /* OpenMP 2.5:
26637 ordered */
26639 static tree
26642 {
26643 tree c;
26651 }
26653 /* OpenMP 2.5:
26654 reduction ( reduction-operator : variable-list )
26656 reduction-operator:
26657 One of: + * - & ^ | && ||
26659 OpenMP 3.1:
26661 reduction-operator:
26662 One of: + * - & ^ | && || min max */
26664 static tree
26666 {
26674 {
26700 {
26705 {
26708 }
26710 {
26713 }
26714 }
26715 /* FALLTHROUGH */
26719 resync_fail:
26724 }
26735 }
26737 /* OpenMP 2.5:
26738 schedule ( schedule-kind )
26739 schedule ( schedule-kind , expression )
26741 schedule-kind:
26742 static | dynamic | guided | runtime | auto */
26744 static tree
26746 {
26755 {
26760 {
26781 }
26782 }
26787 else
26792 {
26807 else
26812 }
26820 invalid_kind:
26822 resync_fail:
26827 }
26829 /* OpenMP 3.0:
26830 untied */
26832 static tree
26835 {
26836 tree c;
26843 }
26845 /* Parse all OpenMP clauses. The set clauses allowed by the directive
26846 is a bitmask in MASK. Return the list of clauses found; the result
26847 of clause default goes in *pdefault. */
26849 static tree
26852 {
26858 {
26859 pragma_omp_clause c_kind;
26871 {
26883 clauses);
26897 clauses);
26906 clauses);
26930 clauses);
26944 clauses);
26955 }
26958 {
26959 /* Remove the invalid clause(s) from the list to avoid
26960 confusing the rest of the compiler. */
26963 }
26964 }
26965 saw_error:
26968 }
26970 /* OpenMP 2.5:
26971 structured-block:
26972 statement
26974 In practice, we're also interested in adding the statement to an
26975 outer node. So it is convenient if we work around the fact that
26976 cp_parser_statement calls add_stmt. */
26978 static unsigned
26980 {
26983 /* Only move the values to IN_OMP_BLOCK if they weren't false.
26984 This preserves the "not within loop or switch" style error messages
26985 for nonsense cases like
26986 void foo() {
26987 #pragma omp single
26988 break;
26989 }
26990 */
26995 }
26997 static void
26999 {
27001 }
27003 static tree
27005 {
27013 }
27015 /* OpenMP 2.5:
27016 # pragma omp atomic new-line
27017 expression-stmt
27019 expression-stmt:
27020 x binop= expr | x++ | ++x | x-- | --x
27021 binop:
27022 +, *, -, /, &, ^, |, <<, >>
27024 where x is an lvalue expression with scalar type.
27026 OpenMP 3.1:
27027 # pragma omp atomic new-line
27028 update-stmt
27030 # pragma omp atomic read new-line
27031 read-stmt
27033 # pragma omp atomic write new-line
27034 write-stmt
27036 # pragma omp atomic update new-line
27037 update-stmt
27039 # pragma omp atomic capture new-line
27040 capture-stmt
27042 # pragma omp atomic capture new-line
27043 capture-block
27045 read-stmt:
27046 v = x
27047 write-stmt:
27048 x = expr
27049 update-stmt:
27050 expression-stmt | x = x binop expr
27051 capture-stmt:
27052 v = x binop= expr | v = x++ | v = ++x | v = x-- | v = --x
27053 capture-block:
27054 { v = x; update-stmt; } | { update-stmt; v = x; }
27056 where x and v are lvalue expressions with scalar type. */
27058 static void
27060 {
27067 {
27079 else
27083 }
27087 {
27098 else
27104 {
27105 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
27106 opcode. */
27111 }
27115 {
27118 }
27119 else
27120 {
27127 }
27130 }
27132 restart:
27137 {
27144 /* FALLTHROUGH */
27154 /* FALLTHROUGH */
27169 /* Undo effects of boolean_increment for post {in,de}crement. */
27171 /* FALLTHRU */
27175 {
27176 /* Undo effects of boolean_increment. */
27178 {
27179 /* This is pre or post increment. */
27184 && !structured_block
27188 }
27189 }
27190 /* FALLTHRU */
27193 {
27223 {
27233 {
27236 {
27244 }
27279 }
27290 }
27291 /* FALLTHROUGH */
27296 }
27303 }
27304 stmt_done:
27306 {
27319 }
27321 {
27324 }
27325 done:
27331 saw_error:
27334 {
27338 {
27342 }
27343 }
27344 }
27347 /* OpenMP 2.5:
27348 # pragma omp barrier new-line */
27350 static void
27352 {
27355 }
27357 /* OpenMP 2.5:
27358 # pragma omp critical [(name)] new-line
27359 structured-block */
27361 static tree
27363 {
27367 {
27379 }
27384 }
27386 /* OpenMP 2.5:
27387 # pragma omp flush flush-vars[opt] new-line
27389 flush-vars:
27390 ( variable-list ) */
27392 static void
27394 {
27400 }
27402 /* Helper function, to parse omp for increment expression. */
27404 static tree
27406 {
27411 {
27414 }
27417 {
27425 }
27427 /* If decl is an iterator, preserve LHS and RHS of the relational
27428 expr until finish_omp_for. */
27438 }
27440 /* Helper function, to parse omp for increment expression. */
27442 static tree
27444 {
27448 cp_id_kind idk;
27452 {
27460 }
27468 {
27473 }
27480 {
27484 }
27496 do
27497 {
27504 {
27506 {
27509 else
27511 tf_warning_or_error);
27512 }
27513 else
27516 }
27517 }
27521 {
27525 }
27526 else
27530 }
27532 /* Parse the restricted form of the for statement allowed by OpenMP. */
27534 static tree
27536 {
27540 location_t loc_first;
27559 {
27562 location_t loc;
27565 {
27568 }
27577 {
27578 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
27580 init-expr:
27581 var = lb
27582 integer-type var = lb
27583 random-access-iterator-type var = lb
27584 pointer-type var = lb
27585 */
27586 cp_decl_specifier_seq type_specifiers;
27588 /* First, try to parse as an initialized declaration. See
27589 cp_parser_condition, from whence the bulk of this is copied. */
27596 {
27597 /* If parsing a type specifier seq succeeded, then this
27598 MUST be a initialized declaration. */
27603 CP_PARSER_DECLARATOR_NAMED,
27613 else
27614 {
27624 {
27626 CPP_OPEN_PAREN))
27629 else
27630 /* Trigger an error. */
27635 }
27639 {
27647 {
27650 auto_node);
27655 }
27658 asm_specification,
27659 LOOKUP_ONLYCONVERTING);
27661 {
27664 }
27665 else
27668 }
27669 else
27670 {
27671 /* Consume '='. */
27675 non_class:
27678 else
27681 asm_specification,
27682 LOOKUP_ONLYCONVERTING);
27683 }
27687 }
27688 }
27689 else
27690 {
27691 cp_id_kind idk;
27692 /* If parsing a type specifier sequence failed, then
27693 this MUST be a simple expression. */
27698 && decl
27701 {
27702 tree rhs;
27709 rhs,
27710 tf_warning_or_error));
27712 }
27713 else
27714 {
27719 {
27723 }
27724 }
27725 }
27726 }
27729 {
27732 {
27738 }
27739 else
27741 }
27746 {
27751 {
27755 }
27758 {
27759 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
27760 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
27769 }
27770 else
27771 {
27776 }
27777 }
27780 {
27781 tree c;
27783 {
27792 decl);
27796 decl);
27797 }
27799 {
27804 {
27807 }
27808 }
27809 }
27818 {
27819 /* If decl is an iterator, preserve the operator on decl
27820 until finish_omp_for. */
27822 && ((processing_template_decl
27826 else
27830 }
27845 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
27846 in between the collapsed for loops to be still considered perfectly
27847 nested. Hopefully the final version clarifies this.
27848 For now handle (multiple) {'s and empty statements. */
27850 do
27851 {
27855 {
27857 bracecount++;
27858 }
27862 else
27863 {
27870 }
27871 }
27875 {
27878 }
27879 }
27881 /* Note that we saved the original contents of this flag when we entered
27882 the structured block, and so we don't need to re-save it here. */
27885 /* Note that the grammar doesn't call for a structured block here,
27886 though the loop as a whole is a structured block. */
27893 else
27898 {
27900 {
27902 nbraces--;
27903 }
27906 else
27907 {
27909 {
27912 }
27917 }
27918 }
27925 }
27927 /* OpenMP 2.5:
27928 #pragma omp for for-clause[optseq] new-line
27929 for-loop */
27931 #define OMP_FOR_CLAUSE_MASK \
27932 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
27933 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
27934 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
27935 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
27936 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
27937 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
27938 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT) \
27939 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE))
27941 static tree
27943 {
27959 }
27961 /* OpenMP 2.5:
27962 # pragma omp master new-line
27963 structured-block */
27965 static tree
27967 {
27971 }
27973 /* OpenMP 2.5:
27974 # pragma omp ordered new-line
27975 structured-block */
27977 static tree
27979 {
27983 }
27985 /* OpenMP 2.5:
27987 section-scope:
27988 { section-sequence }
27990 section-sequence:
27991 section-directive[opt] structured-block
27992 section-sequence section-directive structured-block */
27994 static tree
27996 {
28007 {
28014 {
28024 }
28030 }
28033 {
28041 {
28045 }
28047 {
28050 }
28055 }
28066 }
28068 /* OpenMP 2.5:
28069 # pragma omp sections sections-clause[optseq] newline
28070 sections-scope */
28072 #define OMP_SECTIONS_CLAUSE_MASK \
28073 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
28074 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
28075 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
28076 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
28077 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
28079 static tree
28081 {
28092 }
28094 /* OpenMP 2.5:
28095 # pragma parallel parallel-clause new-line
28096 # pragma parallel for parallel-for-clause new-line
28097 # pragma parallel sections parallel-sections-clause new-line */
28099 #define OMP_PARALLEL_CLAUSE_MASK \
28100 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
28101 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
28102 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
28103 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
28104 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
28105 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
28106 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
28107 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
28109 static tree
28111 {
28120 {
28126 }
28128 {
28132 {
28138 }
28139 }
28146 {
28166 }
28173 }
28175 /* OpenMP 2.5:
28176 # pragma omp single single-clause[optseq] new-line
28177 structured-block */
28179 #define OMP_SINGLE_CLAUSE_MASK \
28180 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
28181 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
28182 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
28183 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
28185 static tree
28187 {
28197 }
28199 /* OpenMP 3.0:
28200 # pragma omp task task-clause[optseq] new-line
28201 structured-block */
28203 #define OMP_TASK_CLAUSE_MASK \
28204 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
28205 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
28206 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
28207 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
28208 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
28209 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
28210 | (1u << PRAGMA_OMP_CLAUSE_FINAL) \
28211 | (1u << PRAGMA_OMP_CLAUSE_MERGEABLE))
28213 static tree
28215 {
28226 }
28228 /* OpenMP 3.0:
28229 # pragma omp taskwait new-line */
28231 static void
28233 {
28236 }
28238 /* OpenMP 3.1:
28239 # pragma omp taskyield new-line */
28241 static void
28243 {
28246 }
28248 /* OpenMP 2.5:
28249 # pragma omp threadprivate (variable-list) */
28251 static void
28253 {
28254 tree vars;
28260 }
28262 /* Main entry point to OpenMP statement pragmas. */
28264 static void
28266 {
28267 tree stmt;
28270 {
28300 }
28304 }
28305 \f
28306 /* Transactional Memory parsing routines. */
28308 /* Parse a transaction attribute.
28310 txn-attribute:
28311 attribute
28312 [ [ identifier ] ]
28314 ??? Simplify this when C++0x bracket attributes are
28315 implemented properly. */
28317 static tree
28319 {
28334 {
28338 /* For keywords, use the canonical spelling,
28339 not the parsed identifier. */
28343 }
28344 else
28348 error1:
28351 }
28353 /* Parse a __transaction_atomic or __transaction_relaxed statement.
28355 transaction-statement:
28356 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
28357 compound-statement
28358 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
28359 */
28361 static tree
28363 {
28378 else
28379 {
28383 }
28385 /* Parse a noexcept specification. */
28388 /* Keep track if we're in the lexical scope of an outer transaction. */
28400 }
28402 /* Parse a __transaction_atomic or __transaction_relaxed expression.
28404 transaction-expression:
28405 __transaction_atomic txn-noexcept-spec[opt] ( expression )
28406 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
28407 */
28409 static tree
28411 {
28436 /* Set this early. This might mean that we allow transaction_cancel in
28437 an expression that we find out later actually has to be a constexpr.
28438 However, we expect that cxx_constant_value will be able to deal with
28439 this; also, if the noexcept has no constexpr, then what we parse next
28440 really is a transaction's body. */
28443 /* Parse a noexcept specification. */
28449 {
28456 }
28457 else
28458 {
28459 /* The only expression that is available got parsed for the noexcept
28460 already. noexcept is true then. */
28463 }
28472 }
28474 /* Parse a function-transaction-block.
28476 function-transaction-block:
28477 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
28478 function-body
28479 __transaction_atomic txn-attribute[opt] function-try-block
28480 __transaction_relaxed ctor-initializer[opt] function-body
28481 __transaction_relaxed function-try-block
28482 */
28484 static bool
28486 {
28502 else
28503 {
28507 }
28515 else
28516 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
28524 }
28526 /* Parse a __transaction_cancel statement.
28528 cancel-statement:
28529 __transaction_cancel txn-attribute[opt] ;
28530 __transaction_cancel txn-attribute[opt] throw-expression ;
28532 ??? Cancel and throw is not yet implemented. */
28534 static tree
28536 {
28542 RT_TRANSACTION_CANCEL);
28549 /* ??? Parse cancel-and-throw here. */
28554 {
28558 }
28560 {
28564 }
28566 {
28569 {
28575 }
28576 }
28578 {
28582 }
28589 }
28590 \f
28591 /* The parser. */
28595 \f
28596 /* Special handling for the first token or line in the file. The first
28597 thing in the file might be #pragma GCC pch_preprocess, which loads a
28598 PCH file, which is a GC collection point. So we need to handle this
28599 first pragma without benefit of an existing lexer structure.
28601 Always returns one token to the caller in *FIRST_TOKEN. This is
28602 either the true first token of the file, or the first token after
28603 the initial pragma. */
28605 static void
28607 {
28616 {
28623 }
28624 else
28627 /* Skip to the end of the pragma. */
28631 /* Now actually load the PCH file. */
28635 /* Read one more token to return to our caller. We have to do this
28636 after reading the PCH file in, since its pointers have to be
28637 live. */
28639 }
28641 /* Normal parsing of a pragma token. Here we can (and must) use the
28642 regular lexer. */
28644 static bool
28646 {
28656 {
28664 {
28674 }
28679 {
28689 }
28694 {
28700 "%<#pragma omp taskwait%> may only be "
28705 }
28710 {
28716 "%<#pragma omp taskyield%> may only be "
28721 }
28744 "%<#pragma omp section%> may only be used in "
28750 {
28754 }
28763 bad_stmt:
28766 }
28770 }
28772 /* The interface the pragma parsers have to the lexer. */
28774 enum cpp_ttype
28776 {
28789 else
28790 {
28794 }
28797 }
28799 \f
28800 /* External interface. */
28802 /* Parse one entire translation unit. */
28804 void
28806 {
28810 {
28813 }
28821 }
28824 /* Parses the Cilk Plus #pragma simd vectorlength clause:
28825 Syntax:
28826 vectorlength ( constant-expression ) */
28828 static tree
28830 {
28832 tree expr;
28833 /* The vectorlength clause behaves exactly like OpenMP's safelen
28834 clause. Thus, vectorlength is represented as OMP 4.0
28835 safelen. */
28848 {
28853 }
28858 }
28860 /* Handles the Cilk Plus #pragma simd linear clause.
28861 Syntax:
28862 linear ( simd-linear-variable-list )
28864 simd-linear-variable-list:
28865 simd-linear-variable
28866 simd-linear-variable-list , simd-linear-variable
28868 simd-linear-variable:
28869 id-expression
28870 id-expression : simd-linear-step
28872 simd-linear-step:
28873 conditional-expression */
28875 static tree
28877 {
28883 {
28887 }
28890 {
28893 {
28897 }
28904 {
28908 }
28909 else
28910 {
28914 /* If present, parse the linear step. Otherwise, assume the default
28915 value of 1. */
28917 {
28924 {
28925 /* If an error has occurred, then the whole pragma is
28926 considered ill-formed. Thus, no reason to keep
28927 parsing. */
28930 }
28935 else
28937 }
28939 /* Use the OMP_CLAUSE_LINEAR, which has the same semantics. */
28945 }
28950 else
28951 {
28956 }
28957 }
28960 }
28962 /* Returns the name of the next clause. If the clause is not
28963 recognized, then PRAGMA_CILK_CLAUSE_NONE is returned and the next
28964 token is not consumed. Otherwise, the appropriate enum from the
28965 pragma_simd_clause is returned and the token is consumed. */
28967 static pragma_cilk_clause
28969 {
28970 pragma_cilk_clause clause_type;
28987 else
28992 }
28994 /* Parses all the #pragma simd clauses. Returns a list of clauses found. */
28996 static tree
28998 {
29003 {
29004 pragma_cilk_clause c_kind;
29011 /* Use the OpenMP 4.0 equivalent function. */
29014 /* Use the OpenMP 4.0 equivalent function. */
29016 clauses);
29018 /* Use the OMP 4.0 equivalent function. */
29020 clauses);
29022 /* Use the OMP 4.0 equivalent function. */
29024 else
29025 {
29029 }
29030 }
29036 else
29038 }
29040 /* Main entry-point for parsing Cilk Plus <#pragma simd> for loops. */
29042 static void
29044 {
29051 {
29055 }
29063 }
29065 /* Parses the initializer of a for/_Cilk_for statement. The initial
29066 value is stored in *INIT, and the inital value's declaration is
29067 stored as DECL_EXPR in *PRE_BODY. */
29069 static tree
29072 {
29076 cp_decl_specifier_seq type_specifiers;
29079 {
29082 }
29089 {
29092 }
29097 {
29106 else
29107 {
29113 {
29117 else
29118 {
29121 }
29125 }
29128 {
29133 {
29139 }
29141 LOOKUP_ONLYCONVERTING);
29144 else
29147 }
29148 else
29149 {
29150 /* Consume the '='. */
29153 non_class:
29156 else
29158 LOOKUP_ONLYCONVERTING);
29162 }
29165 }
29166 }
29167 else
29168 {
29169 cp_id_kind idk;
29175 {
29177 // ?? FIXME: I don't see any definition for *init in this
29178 // code path. ??
29185 tf_warning_or_error);
29187 }
29188 else
29189 {
29194 }
29195 }
29202 }
29204 /* Top-level function to parse _Cilk_for and the for statement
29205 following <#pragma simd>. */
29207 static tree
29209 {
29219 {
29222 else
29225 }
29229 {
29232 }
29234 /* Parse initialization. */
29242 {
29247 }
29252 {
29257 }
29259 {
29264 }
29267 {
29268 /* Skip to the semicolon ending the init. */
29270 }
29272 /* Parse condition. */
29276 {
29279 }
29280 else
29281 {
29284 }
29290 /* Parse increment. */
29292 {
29295 }
29296 else
29300 {
29303 }
29306 {
29309 }
29312 {
29315 }
29318 {
29324 /* Check if the body satisfies all the requirement of a #pragma
29325 simd for body. If it is invalid, then do not make the OpenMP
29326 nodes, just return an error mark node. */
29333 }
29334 else
29335 {
29336 /* Handle _Cilk_for here when implemented. */
29339 }
29340 }