| blob | 60e6cda98a42a5d341db28683380831dd7e9bd2e |
1 /* C++ Parser.
2 Copyright (C) 2000-2014 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
48 \f
49 /* The lexer. */
51 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
52 and c-lex.c) and the C++ parser. */
55 {
57 };
59 /* The various kinds of non integral constant we encounter. */
61 NIC_NONE,
62 /* floating-point literal */
63 NIC_FLOAT,
64 /* %<this%> */
65 NIC_THIS,
66 /* %<__FUNCTION__%> */
67 NIC_FUNC_NAME,
68 /* %<__PRETTY_FUNCTION__%> */
69 NIC_PRETTY_FUNC,
70 /* %<__func__%> */
71 NIC_C99_FUNC,
72 /* "%<va_arg%> */
73 NIC_VA_ARG,
74 /* a cast */
75 NIC_CAST,
76 /* %<typeid%> operator */
77 NIC_TYPEID,
78 /* non-constant compound literals */
79 NIC_NCC,
80 /* a function call */
81 NIC_FUNC_CALL,
82 /* an increment */
83 NIC_INC,
84 /* an decrement */
85 NIC_DEC,
86 /* an array reference */
87 NIC_ARRAY_REF,
88 /* %<->%> */
89 NIC_ARROW,
90 /* %<.%> */
91 NIC_POINT,
92 /* the address of a label */
93 NIC_ADDR_LABEL,
94 /* %<*%> */
95 NIC_STAR,
96 /* %<&%> */
97 NIC_ADDR,
98 /* %<++%> */
99 NIC_PREINCREMENT,
100 /* %<--%> */
101 NIC_PREDECREMENT,
102 /* %<new%> */
103 NIC_NEW,
104 /* %<delete%> */
105 NIC_DEL,
106 /* calls to overloaded operators */
107 NIC_OVERLOADED,
108 /* an assignment */
109 NIC_ASSIGNMENT,
110 /* a comma operator */
111 NIC_COMMA,
112 /* a call to a constructor */
113 NIC_CONSTRUCTOR,
114 /* a transaction expression */
115 NIC_TRANSACTION
118 /* The various kinds of errors about name-lookup failing. */
120 /* NULL */
121 NLE_NULL,
122 /* is not a type */
123 NLE_TYPE,
124 /* is not a class or namespace */
125 NLE_CXX98,
126 /* is not a class, namespace, or enumeration */
127 NLE_NOT_CXX98
130 /* The various kinds of required token */
132 RT_NONE,
154 /* The type is CPP_KEYWORD */
183 RT_TRANSACTION_CANCEL /* __transaction_cancel */
186 /* Prototypes. */
192 static void cp_lexer_destroy
194 static int cp_lexer_saving_tokens
198 static void cp_lexer_get_preprocessor_token
206 static bool cp_lexer_next_token_is_not
208 static bool cp_lexer_next_token_is_keyword
212 static void cp_lexer_purge_token
214 static void cp_lexer_purge_tokens_after
216 static void cp_lexer_save_tokens
218 static void cp_lexer_commit_tokens
220 static void cp_lexer_rollback_tokens
222 static void cp_lexer_print_token
226 static void cp_lexer_start_debugging
228 static void cp_lexer_stop_debugging
234 static void cp_parser_initial_pragma
237 static tree cp_literal_operator_id
240 static void cp_parser_cilk_simd
242 static bool cp_parser_omp_declare_reduction_exprs
244 static tree cp_parser_cilk_simd_vectorlength
247 /* Manifest constants. */
248 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
249 #define CP_SAVED_TOKEN_STACK 5
251 /* Variables. */
253 /* The stream to which debugging output should be written. */
256 /* Nonzero if we are parsing an unevaluated operand: an operand to
257 sizeof, typeof, or alignof. */
260 /* Dump up to NUM tokens in BUFFER to FILE starting with token
261 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
262 first token in BUFFER. If NUM is 0, dump all the tokens. If
263 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
264 highlighted by surrounding it in [[ ]]. */
266 static void
270 {
287 {
290 }
295 {
302 nprinted++;
312 {
322 }
323 }
326 {
329 }
332 }
335 /* Dump all tokens in BUFFER to stderr. */
337 void
339 {
341 }
343 DEBUG_FUNCTION void
345 {
347 }
349 DEBUG_FUNCTION void
351 {
354 else
356 }
359 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
360 description for T. */
362 static void
364 {
366 {
369 }
370 }
373 /* Dump parser context C to FILE. */
375 static void
377 {
382 }
385 /* Print the stack of parsing contexts to FILE starting with FIRST. */
387 static void
389 {
395 {
398 }
399 }
402 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
404 static void
406 {
409 }
412 /* Print an unparsed function entry UF to FILE. */
414 static void
416 {
419 tree fn;
424 i++)
425 {
431 }
436 {
439 }
445 {
448 }
450 }
453 /* Print the stack of unparsed member functions S to FILE. */
455 static void
458 {
464 {
467 }
468 }
471 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
472 the given PARSER. If FILE is NULL, the output is printed on stderr. */
474 static void
476 {
488 next_token);
489 }
492 /* Dump debugging information for the given PARSER. If FILE is NULL,
493 the output is printed on stderr. */
495 void
497 {
500 expanded_location eloc;
578 }
580 DEBUG_FUNCTION void
582 {
584 }
586 DEBUG_FUNCTION void
588 {
591 else
593 }
595 /* Allocate memory for a new lexer object and return it. */
599 {
604 /* Allocate the memory. */
607 /* Initially we are not debugging. */
612 /* Create the buffer. */
616 }
619 /* Create a new main C++ lexer, the lexer that gets tokens from the
620 preprocessor. */
624 {
626 cp_token token;
628 /* It's possible that parsing the first pragma will load a PCH file,
629 which is a GC collection point. So we have to do that before
630 allocating any memory. */
635 /* Put the first token in the buffer. */
638 /* Get the remaining tokens from the preprocessor. */
640 {
643 }
652 /* Subsequent preprocessor diagnostics should use compiler
653 diagnostic functions to get the compiler source location. */
658 }
660 /* Create a new lexer whose token stream is primed with the tokens in
661 CACHE. When these tokens are exhausted, no new tokens will be read. */
665 {
670 /* We do not own the buffer. */
677 /* Initially we are not debugging. */
682 }
684 /* Frees all resources associated with LEXER. */
686 static void
688 {
692 }
694 /* Returns nonzero if debugging information should be output. */
698 {
700 }
705 {
709 }
713 {
715 }
719 {
721 }
725 {
728 else
730 }
734 {
738 }
740 /* nonzero if we are presently saving tokens. */
744 {
746 }
748 /* Store the next token from the preprocessor in *TOKEN. Return true
749 if we reach EOF. If LEXER is NULL, assume we are handling an
750 initial #pragma pch_preprocess, and thus want the lexer to return
751 processed strings. */
753 static void
755 {
758 /* Get a new token from the preprocessor. */
759 token->type
767 /* On some systems, some header files are surrounded by an
768 implicit extern "C" block. Set a flag in the token if it
769 comes from such a header. */
774 /* Check to see if this token is a keyword. */
776 {
778 {
779 /* Mark this token as a keyword. */
781 /* Record which keyword. */
783 }
784 else
785 {
789 {
790 /* Warn about the C++0x keyword (but still treat it as
791 an identifier). */
796 /* Clear out the C_RID_CODE so we don't warn about this
797 particular identifier-turned-keyword again. */
799 }
802 }
803 }
805 {
806 /* This only happens in Objective-C++; it must be a keyword. */
809 {
810 /* Replace 'class' with '@class', 'private' with '@private',
811 etc. This prevents confusion with the C++ keyword
812 'class', and makes the tokens consistent with other
813 Objective-C 'AT' keywords. For example '@class' is
814 reported as RID_AT_CLASS which is consistent with
815 '@synchronized', which is reported as
816 RID_AT_SYNCHRONIZED.
817 */
826 }
827 }
829 {
830 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
834 }
835 }
837 /* Update the globals input_location and the input file stack from TOKEN. */
840 {
842 {
844 }
845 }
847 /* Update the globals input_location and the input file stack from LEXER. */
850 {
853 }
855 /* Return a pointer to the next token in the token stream, but do not
856 consume it. */
860 {
862 {
866 }
868 }
870 /* Return true if the next token has the indicated TYPE. */
874 {
876 }
878 /* Return true if the next token does not have the indicated TYPE. */
882 {
884 }
886 /* Return true if the next token is the indicated KEYWORD. */
890 {
892 }
896 {
898 }
900 /* Return true if the next token is not the indicated KEYWORD. */
904 {
906 }
908 /* Return true if the next token is a keyword for a decl-specifier. */
910 static bool
912 {
917 {
918 /* auto specifier: storage-class-specifier in C++,
919 simple-type-specifier in C++0x. */
921 /* Storage classes. */
927 /* Elaborated type specifiers. */
933 /* Simple type specifiers. */
948 /* GNU extensions. */
951 /* C++0x extensions. */
958 }
959 }
961 /* Returns TRUE iff the token T begins a decltype type. */
963 static bool
965 {
968 }
970 /* Returns TRUE iff the next token begins a decltype type. */
972 static bool
974 {
977 }
979 /* Return a pointer to the Nth token in the token stream. If N is 1,
980 then this is precisely equivalent to cp_lexer_peek_token (except
981 that it is not inline). One would like to disallow that case, but
982 there is one case (cp_parser_nth_token_starts_template_id) where
983 the caller passes a variable for N and it might be 1. */
987 {
990 /* N is 1-based, not zero-based. */
1001 {
1004 {
1007 }
1011 }
1014 {
1017 }
1020 }
1022 /* Return the next token, and advance the lexer's next_token pointer
1023 to point to the next non-purged token. */
1027 {
1033 do
1034 {
1037 {
1040 }
1042 }
1047 /* Provide debugging output. */
1049 {
1053 }
1056 }
1058 /* Permanently remove the next token from the token stream, and
1059 advance the next_token pointer to refer to the next non-purged
1060 token. */
1062 static void
1064 {
1073 do
1074 {
1075 tok++;
1077 {
1080 }
1081 }
1084 }
1086 /* Permanently remove all tokens after TOK, up to, but not
1087 including, the token that will be returned next by
1088 cp_lexer_peek_token. */
1090 static void
1092 {
1101 {
1106 }
1107 }
1109 /* Begin saving tokens. All tokens consumed after this point will be
1110 preserved. */
1112 static void
1114 {
1115 /* Provide debugging output. */
1120 }
1122 /* Commit to the portion of the token stream most recently saved. */
1124 static void
1126 {
1127 /* Provide debugging output. */
1132 }
1134 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1135 to the token stream. Stop saving tokens. */
1137 static void
1139 {
1140 /* Provide debugging output. */
1145 }
1147 /* Print a representation of the TOKEN on the STREAM. */
1149 static void
1151 {
1152 /* We don't use cpp_type2name here because the parser defines
1153 a few tokens of its own. */
1155 /* cpplib-defined token types */
1156 #define OP(e, s) #e,
1157 #define TK(e, s) #e,
1158 TTYPE_TABLE
1159 #undef OP
1160 #undef TK
1161 /* C++ parser token types - see "Manifest constants", above. */
1165 };
1167 /* For some tokens, print the associated data. */
1169 {
1171 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1172 For example, `struct' is mapped to an INTEGER_CST. */
1175 /* else fall through */
1193 /* If we have a name for the token, print it out. Otherwise, we
1194 simply give the numeric code. */
1197 else
1200 }
1201 }
1203 DEBUG_FUNCTION void
1205 {
1208 }
1210 DEBUG_FUNCTION void
1212 {
1215 else
1217 }
1220 /* Start emitting debugging information. */
1222 static void
1224 {
1227 }
1229 /* Stop emitting debugging information. */
1231 static void
1233 {
1236 }
1238 /* Create a new cp_token_cache, representing a range of tokens. */
1242 {
1247 }
1249 /* Diagnose if #pragma omp declare simd isn't followed immediately
1250 by function declaration or definition. */
1254 {
1256 {
1260 }
1261 }
1263 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1264 and put that into "omp declare simd" attribute. */
1268 {
1270 {
1272 {
1275 }
1277 {
1280 }
1281 }
1282 }
1283 \f
1284 /* Decl-specifiers. */
1286 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1288 static void
1290 {
1292 }
1294 /* Declarators. */
1296 /* Nothing other than the parser should be creating declarators;
1297 declarators are a semi-syntactic representation of C++ entities.
1298 Other parts of the front end that need to create entities (like
1299 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1314 /* An erroneous declarator. */
1317 /* The obstack on which declarators and related data structures are
1318 allocated. */
1321 /* Alloc BYTES from the declarator memory pool. */
1325 {
1327 }
1329 /* Allocate a declarator of the indicated KIND. Clear fields that are
1330 common to all declarators. */
1334 {
1346 }
1348 /* Make a declarator for a generalized identifier. If
1349 QUALIFYING_SCOPE is non-NULL, the identifier is
1350 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1351 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1352 is, if any. */
1356 special_function_kind sfk)
1357 {
1360 /* It is valid to write:
1362 class C { void f(); };
1363 typedef C D;
1364 void D::f();
1366 The standard is not clear about whether `typedef const C D' is
1367 legal; as of 2002-09-15 the committee is considering that
1368 question. EDG 3.0 allows that syntax. Therefore, we do as
1369 well. */
1383 }
1385 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1386 of modifiers such as const or volatile to apply to the pointer
1387 type, represented as identifiers. ATTRIBUTES represent the attributes that
1388 appertain to the pointer or reference. */
1390 cp_declarator *
1392 tree attributes)
1393 {
1401 {
1405 }
1406 else
1412 }
1414 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1415 represent the attributes that appertain to the pointer or
1416 reference. */
1418 cp_declarator *
1421 {
1429 {
1433 }
1434 else
1440 }
1442 /* Like make_pointer_declarator -- but for a pointer to a non-static
1443 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1444 appertain to the pointer or reference. */
1446 cp_declarator *
1449 tree attributes)
1450 {
1459 {
1462 }
1463 else
1469 }
1471 /* Make a declarator for the function given by TARGET, with the
1472 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1473 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1474 indicates what exceptions can be thrown. */
1476 cp_declarator *
1478 tree parms,
1479 cp_cv_quals cv_qualifiers,
1480 cp_virt_specifiers virt_specifiers,
1481 cp_ref_qualifier ref_qualifier,
1482 tree exception_specification,
1483 tree late_return_type)
1484 {
1496 {
1500 }
1501 else
1505 }
1507 /* Make a declarator for an array of BOUNDS elements, each of which is
1508 defined by ELEMENT. */
1510 cp_declarator *
1512 {
1519 {
1523 }
1524 else
1528 }
1530 /* Determine whether the declarator we've seen so far can be a
1531 parameter pack, when followed by an ellipsis. */
1532 static bool
1534 {
1535 /* Search for a declarator name, or any other declarator that goes
1536 after the point where the ellipsis could appear in a parameter
1537 pack. If we find any of these, then this declarator can not be
1538 made into a parameter pack. */
1541 {
1543 {
1555 }
1556 }
1559 }
1563 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1564 DECLARATOR and DEFAULT_ARGUMENT. */
1566 cp_parameter_declarator *
1569 tree default_argument)
1570 {
1578 else
1585 }
1587 /* Returns true iff DECLARATOR is a declaration for a function. */
1589 static bool
1591 {
1593 {
1601 }
1603 }
1605 /* The parser. */
1607 /* Overview
1608 --------
1610 A cp_parser parses the token stream as specified by the C++
1611 grammar. Its job is purely parsing, not semantic analysis. For
1612 example, the parser breaks the token stream into declarators,
1613 expressions, statements, and other similar syntactic constructs.
1614 It does not check that the types of the expressions on either side
1615 of an assignment-statement are compatible, or that a function is
1616 not declared with a parameter of type `void'.
1618 The parser invokes routines elsewhere in the compiler to perform
1619 semantic analysis and to build up the abstract syntax tree for the
1620 code processed.
1622 The parser (and the template instantiation code, which is, in a
1623 way, a close relative of parsing) are the only parts of the
1624 compiler that should be calling push_scope and pop_scope, or
1625 related functions. The parser (and template instantiation code)
1626 keeps track of what scope is presently active; everything else
1627 should simply honor that. (The code that generates static
1628 initializers may also need to set the scope, in order to check
1629 access control correctly when emitting the initializers.)
1631 Methodology
1632 -----------
1634 The parser is of the standard recursive-descent variety. Upcoming
1635 tokens in the token stream are examined in order to determine which
1636 production to use when parsing a non-terminal. Some C++ constructs
1637 require arbitrary look ahead to disambiguate. For example, it is
1638 impossible, in the general case, to tell whether a statement is an
1639 expression or declaration without scanning the entire statement.
1640 Therefore, the parser is capable of "parsing tentatively." When the
1641 parser is not sure what construct comes next, it enters this mode.
1642 Then, while we attempt to parse the construct, the parser queues up
1643 error messages, rather than issuing them immediately, and saves the
1644 tokens it consumes. If the construct is parsed successfully, the
1645 parser "commits", i.e., it issues any queued error messages and
1646 the tokens that were being preserved are permanently discarded.
1647 If, however, the construct is not parsed successfully, the parser
1648 rolls back its state completely so that it can resume parsing using
1649 a different alternative.
1651 Future Improvements
1652 -------------------
1654 The performance of the parser could probably be improved substantially.
1655 We could often eliminate the need to parse tentatively by looking ahead
1656 a little bit. In some places, this approach might not entirely eliminate
1657 the need to parse tentatively, but it might still speed up the average
1658 case. */
1660 /* Flags that are passed to some parsing functions. These values can
1661 be bitwise-ored together. */
1663 enum
1664 {
1665 /* No flags. */
1667 /* The construct is optional. If it is not present, then no error
1668 should be issued. */
1670 /* When parsing a type-specifier, treat user-defined type-names
1671 as non-type identifiers. */
1673 /* When parsing a type-specifier, do not try to parse a class-specifier
1674 or enum-specifier. */
1676 /* When parsing a decl-specifier-seq, only allow type-specifier or
1677 constexpr. */
1679 };
1681 /* This type is used for parameters and variables which hold
1682 combinations of the above flags. */
1685 /* The different kinds of declarators we want to parse. */
1688 {
1689 /* We want an abstract declarator. */
1690 CP_PARSER_DECLARATOR_ABSTRACT,
1691 /* We want a named declarator. */
1692 CP_PARSER_DECLARATOR_NAMED,
1693 /* We don't mind, but the name must be an unqualified-id. */
1694 CP_PARSER_DECLARATOR_EITHER
1697 /* The precedence values used to parse binary expressions. The minimum value
1698 of PREC must be 1, because zero is reserved to quickly discriminate
1699 binary operators from other tokens. */
1701 enum cp_parser_prec
1702 {
1703 PREC_NOT_OPERATOR,
1704 PREC_LOGICAL_OR_EXPRESSION,
1705 PREC_LOGICAL_AND_EXPRESSION,
1706 PREC_INCLUSIVE_OR_EXPRESSION,
1707 PREC_EXCLUSIVE_OR_EXPRESSION,
1708 PREC_AND_EXPRESSION,
1709 PREC_EQUALITY_EXPRESSION,
1710 PREC_RELATIONAL_EXPRESSION,
1711 PREC_SHIFT_EXPRESSION,
1712 PREC_ADDITIVE_EXPRESSION,
1713 PREC_MULTIPLICATIVE_EXPRESSION,
1714 PREC_PM_EXPRESSION,
1715 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1716 };
1718 /* A mapping from a token type to a corresponding tree node type, with a
1719 precedence value. */
1722 {
1723 /* The token type. */
1725 /* The corresponding tree code. */
1727 /* The precedence of this operator. */
1732 {
1733 /* Left hand side of the binary operation we are currently
1734 parsing. */
1735 tree lhs;
1736 /* Original tree code for left hand side, if it was a binary
1737 expression itself (used for -Wparentheses). */
1739 /* Tree code for the binary operation we are parsing. */
1741 /* Precedence of the binary operation we are parsing. */
1743 /* Location of the binary operation we are parsing. */
1744 location_t loc;
1747 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1748 entries because precedence levels on the stack are monotonically
1749 increasing. */
1753 /* Prototypes. */
1755 /* Constructors and destructors. */
1760 /* Class variables. */
1764 /* The operator-precedence table used by cp_parser_binary_expression.
1765 Transformed into an associative array (binops_by_token) by
1766 cp_parser_new. */
1799 };
1801 /* The same as binops, but initialized by cp_parser_new so that
1802 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1803 for speed. */
1806 /* Constructors and destructors. */
1808 /* Construct a new context. The context below this one on the stack
1809 is given by NEXT. */
1813 {
1816 /* Allocate the storage. */
1818 {
1819 /* Pull the first entry from the free list. */
1823 }
1824 else
1827 /* No errors have occurred yet in this context. */
1829 /* If this is not the bottommost context, copy information that we
1830 need from the previous context. */
1832 {
1833 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1834 expression, then we are parsing one in this context, too. */
1836 /* Thread the stack. */
1838 }
1841 }
1843 /* Managing the unparsed function queues. */
1845 #define unparsed_funs_with_default_args \
1846 parser->unparsed_queues->last ().funs_with_default_args
1847 #define unparsed_funs_with_definitions \
1848 parser->unparsed_queues->last ().funs_with_definitions
1849 #define unparsed_nsdmis \
1850 parser->unparsed_queues->last ().nsdmis
1851 #define unparsed_classes \
1852 parser->unparsed_queues->last ().classes
1854 static void
1856 {
1859 }
1861 static void
1863 {
1866 }
1868 /* Prototypes. */
1870 /* Constructors and destructors. */
1875 /* Routines to parse various constructs.
1877 Those that return `tree' will return the error_mark_node (rather
1878 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1879 Sometimes, they will return an ordinary node if error-recovery was
1880 attempted, even though a parse error occurred. So, to check
1881 whether or not a parse error occurred, you should always use
1882 cp_parser_error_occurred. If the construct is optional (indicated
1883 either by an `_opt' in the name of the function that does the
1884 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1885 the construct is not present. */
1887 /* Lexical conventions [gram.lex] */
1889 static tree cp_parser_identifier
1891 static tree cp_parser_string_literal
1893 static tree cp_parser_userdef_char_literal
1895 static tree cp_parser_userdef_string_literal
1897 static tree cp_parser_userdef_numeric_literal
1900 /* Basic concepts [gram.basic] */
1902 static bool cp_parser_translation_unit
1905 /* Expressions [gram.expr] */
1907 static tree cp_parser_primary_expression
1909 static tree cp_parser_id_expression
1911 static tree cp_parser_unqualified_id
1913 static tree cp_parser_nested_name_specifier_opt
1915 static tree cp_parser_nested_name_specifier
1917 static tree cp_parser_qualifying_entity
1919 static tree cp_parser_postfix_expression
1921 static tree cp_parser_postfix_open_square_expression
1923 static tree cp_parser_postfix_dot_deref_expression
1927 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1929 static void cp_parser_pseudo_destructor_name
1931 static tree cp_parser_unary_expression
1933 static enum tree_code cp_parser_unary_operator
1935 static tree cp_parser_new_expression
1939 static tree cp_parser_new_type_id
1947 static tree cp_parser_delete_expression
1949 static tree cp_parser_cast_expression
1951 static tree cp_parser_binary_expression
1953 static tree cp_parser_question_colon_clause
1955 static tree cp_parser_assignment_expression
1957 static enum tree_code cp_parser_assignment_operator_opt
1959 static tree cp_parser_expression
1961 static tree cp_parser_expression
1963 static tree cp_parser_constant_expression
1965 static tree cp_parser_builtin_offsetof
1967 static tree cp_parser_lambda_expression
1969 static void cp_parser_lambda_introducer
1971 static bool cp_parser_lambda_declarator_opt
1973 static void cp_parser_lambda_body
1976 /* Statements [gram.stmt.stmt] */
1978 static void cp_parser_statement
1980 static void cp_parser_label_for_labeled_statement
1982 static tree cp_parser_expression_statement
1984 static tree cp_parser_compound_statement
1986 static void cp_parser_statement_seq_opt
1988 static tree cp_parser_selection_statement
1990 static tree cp_parser_condition
1992 static tree cp_parser_iteration_statement
1994 static bool cp_parser_for_init_statement
1996 static tree cp_parser_for
1998 static tree cp_parser_c_for
2000 static tree cp_parser_range_for
2002 static void do_range_for_auto_deduction
2004 static tree cp_parser_perform_range_for_lookup
2006 static tree cp_parser_range_for_member_function
2008 static tree cp_parser_jump_statement
2010 static void cp_parser_declaration_statement
2013 static tree cp_parser_implicitly_scoped_statement
2015 static void cp_parser_already_scoped_statement
2018 /* Declarations [gram.dcl.dcl] */
2020 static void cp_parser_declaration_seq_opt
2022 static void cp_parser_declaration
2024 static void cp_parser_block_declaration
2026 static void cp_parser_simple_declaration
2028 static void cp_parser_decl_specifier_seq
2030 static tree cp_parser_storage_class_specifier_opt
2032 static tree cp_parser_function_specifier_opt
2034 static tree cp_parser_type_specifier
2037 static tree cp_parser_simple_type_specifier
2039 static tree cp_parser_type_name
2041 static tree cp_parser_nonclass_name
2043 static tree cp_parser_elaborated_type_specifier
2045 static tree cp_parser_enum_specifier
2047 static void cp_parser_enumerator_list
2049 static void cp_parser_enumerator_definition
2051 static tree cp_parser_namespace_name
2053 static void cp_parser_namespace_definition
2055 static void cp_parser_namespace_body
2057 static tree cp_parser_qualified_namespace_specifier
2059 static void cp_parser_namespace_alias_definition
2061 static bool cp_parser_using_declaration
2063 static void cp_parser_using_directive
2065 static tree cp_parser_alias_declaration
2067 static void cp_parser_asm_definition
2069 static void cp_parser_linkage_specification
2071 static void cp_parser_static_assert
2073 static tree cp_parser_decltype
2076 /* Declarators [gram.dcl.decl] */
2078 static tree cp_parser_init_declarator
2079 (cp_parser *, cp_decl_specifier_seq *, vec<deferred_access_check, va_gc> *, bool, bool, int, bool *, tree *);
2084 static enum tree_code cp_parser_ptr_operator
2086 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2088 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2090 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2092 static tree cp_parser_late_return_type_opt
2094 static tree cp_parser_declarator_id
2096 static tree cp_parser_type_id
2098 static tree cp_parser_template_type_arg
2101 static tree cp_parser_type_id_1
2103 static void cp_parser_type_specifier_seq
2105 static tree cp_parser_parameter_declaration_clause
2107 static tree cp_parser_parameter_declaration_list
2111 static tree cp_parser_default_argument
2113 static void cp_parser_function_body
2115 static tree cp_parser_initializer
2117 static tree cp_parser_initializer_clause
2119 static tree cp_parser_braced_list
2124 static bool cp_parser_ctor_initializer_opt_and_function_body
2127 static tree cp_parser_late_parsing_omp_declare_simd
2130 static tree cp_parser_late_parsing_cilk_simd_fn_info
2133 static tree synthesize_implicit_template_parm
2135 static tree finish_fully_implicit_template
2138 /* Classes [gram.class] */
2140 static tree cp_parser_class_name
2142 static tree cp_parser_class_specifier
2144 static tree cp_parser_class_head
2146 static enum tag_types cp_parser_class_key
2148 static void cp_parser_member_specification_opt
2150 static void cp_parser_member_declaration
2152 static tree cp_parser_pure_specifier
2154 static tree cp_parser_constant_initializer
2157 /* Derived classes [gram.class.derived] */
2159 static tree cp_parser_base_clause
2161 static tree cp_parser_base_specifier
2164 /* Special member functions [gram.special] */
2166 static tree cp_parser_conversion_function_id
2168 static tree cp_parser_conversion_type_id
2172 static bool cp_parser_ctor_initializer_opt
2174 static void cp_parser_mem_initializer_list
2176 static tree cp_parser_mem_initializer
2178 static tree cp_parser_mem_initializer_id
2181 /* Overloading [gram.over] */
2183 static tree cp_parser_operator_function_id
2185 static tree cp_parser_operator
2188 /* Templates [gram.temp] */
2190 static void cp_parser_template_declaration
2192 static tree cp_parser_template_parameter_list
2194 static tree cp_parser_template_parameter
2196 static tree cp_parser_type_parameter
2198 static tree cp_parser_template_id
2200 static tree cp_parser_template_name
2202 static tree cp_parser_template_argument_list
2204 static tree cp_parser_template_argument
2206 static void cp_parser_explicit_instantiation
2208 static void cp_parser_explicit_specialization
2211 /* Exception handling [gram.exception] */
2213 static tree cp_parser_try_block
2215 static bool cp_parser_function_try_block
2217 static void cp_parser_handler_seq
2219 static void cp_parser_handler
2221 static tree cp_parser_exception_declaration
2223 static tree cp_parser_throw_expression
2225 static tree cp_parser_exception_specification_opt
2227 static tree cp_parser_type_id_list
2230 /* GNU Extensions */
2232 static tree cp_parser_asm_specification_opt
2234 static tree cp_parser_asm_operand_list
2236 static tree cp_parser_asm_clobber_list
2238 static tree cp_parser_asm_label_list
2240 static bool cp_next_tokens_can_be_attribute_p
2242 static bool cp_next_tokens_can_be_gnu_attribute_p
2244 static bool cp_next_tokens_can_be_std_attribute_p
2246 static bool cp_nth_tokens_can_be_std_attribute_p
2248 static bool cp_nth_tokens_can_be_gnu_attribute_p
2250 static bool cp_nth_tokens_can_be_attribute_p
2252 static tree cp_parser_attributes_opt
2254 static tree cp_parser_gnu_attributes_opt
2256 static tree cp_parser_gnu_attribute_list
2258 static tree cp_parser_std_attribute
2260 static tree cp_parser_std_attribute_spec
2262 static tree cp_parser_std_attribute_spec_seq
2264 static bool cp_parser_extension_opt
2266 static void cp_parser_label_declaration
2269 /* Transactional Memory Extensions */
2271 static tree cp_parser_transaction
2273 static tree cp_parser_transaction_expression
2275 static bool cp_parser_function_transaction
2277 static tree cp_parser_transaction_cancel
2281 pragma_external,
2282 pragma_member,
2283 pragma_objc_icode,
2284 pragma_stmt,
2285 pragma_compound
2286 };
2287 static bool cp_parser_pragma
2290 /* Objective-C++ Productions */
2292 static tree cp_parser_objc_message_receiver
2294 static tree cp_parser_objc_message_args
2296 static tree cp_parser_objc_message_expression
2298 static tree cp_parser_objc_encode_expression
2300 static tree cp_parser_objc_defs_expression
2302 static tree cp_parser_objc_protocol_expression
2304 static tree cp_parser_objc_selector_expression
2306 static tree cp_parser_objc_expression
2308 static bool cp_parser_objc_selector_p
2310 static tree cp_parser_objc_selector
2312 static tree cp_parser_objc_protocol_refs_opt
2314 static void cp_parser_objc_declaration
2316 static tree cp_parser_objc_statement
2318 static bool cp_parser_objc_valid_prefix_attributes
2320 static void cp_parser_objc_at_property_declaration
2322 static void cp_parser_objc_at_synthesize_declaration
2324 static void cp_parser_objc_at_dynamic_declaration
2326 static tree cp_parser_objc_struct_declaration
2329 /* Utility Routines */
2331 static tree cp_parser_lookup_name
2333 static tree cp_parser_lookup_name_simple
2335 static tree cp_parser_maybe_treat_template_as_class
2337 static bool cp_parser_check_declarator_template_parameters
2339 static bool cp_parser_check_template_parameters
2341 static tree cp_parser_simple_cast_expression
2343 static tree cp_parser_global_scope_opt
2345 static bool cp_parser_constructor_declarator_p
2347 static tree cp_parser_function_definition_from_specifiers_and_declarator
2349 static tree cp_parser_function_definition_after_declarator
2351 static void cp_parser_template_declaration_after_export
2353 static void cp_parser_perform_template_parameter_access_checks
2355 static tree cp_parser_single_declaration
2357 static tree cp_parser_functional_cast
2359 static tree cp_parser_save_member_function_body
2361 static tree cp_parser_save_nsdmi
2363 static tree cp_parser_enclosed_template_argument_list
2365 static void cp_parser_save_default_args
2367 static void cp_parser_late_parsing_for_member
2369 static tree cp_parser_late_parse_one_default_arg
2371 static void cp_parser_late_parsing_nsdmi
2373 static void cp_parser_late_parsing_default_args
2375 static tree cp_parser_sizeof_operand
2377 static tree cp_parser_trait_expr
2379 static bool cp_parser_declares_only_class_p
2381 static void cp_parser_set_storage_class
2383 static void cp_parser_set_decl_spec_type
2385 static void set_and_check_decl_spec_loc
2388 static bool cp_parser_friend_p
2390 static void cp_parser_required_error
2396 static bool cp_parser_token_starts_function_definition_p
2398 static bool cp_parser_next_token_starts_class_definition_p
2400 static bool cp_parser_next_token_ends_template_argument_p
2402 static bool cp_parser_nth_token_starts_template_argument_list_p
2404 static enum tag_types cp_parser_token_is_class_key
2406 static void cp_parser_check_class_key
2408 static void cp_parser_check_access_in_redeclaration
2410 static bool cp_parser_optional_template_keyword
2412 static void cp_parser_pre_parsed_nested_name_specifier
2414 static bool cp_parser_cache_group
2416 static tree cp_parser_cache_defarg
2418 static void cp_parser_parse_tentatively
2420 static void cp_parser_commit_to_tentative_parse
2422 static void cp_parser_commit_to_topmost_tentative_parse
2424 static void cp_parser_abort_tentative_parse
2426 static bool cp_parser_parse_definitely
2430 static bool cp_parser_uncommitted_to_tentative_parse_p
2432 static void cp_parser_error
2434 static void cp_parser_name_lookup_error
2436 static bool cp_parser_simulate_error
2438 static bool cp_parser_check_type_definition
2440 static void cp_parser_check_for_definition_in_return_type
2442 static void cp_parser_check_for_invalid_template_id
2444 static bool cp_parser_non_integral_constant_expression
2446 static void cp_parser_diagnose_invalid_type_name
2448 static bool cp_parser_parse_and_diagnose_invalid_type_name
2450 static int cp_parser_skip_to_closing_parenthesis
2452 static void cp_parser_skip_to_end_of_statement
2454 static void cp_parser_consume_semicolon_at_end_of_statement
2456 static void cp_parser_skip_to_end_of_block_or_statement
2458 static bool cp_parser_skip_to_closing_brace
2460 static void cp_parser_skip_to_end_of_template_parameter_list
2462 static void cp_parser_skip_to_pragma_eol
2464 static bool cp_parser_error_occurred
2466 static bool cp_parser_allow_gnu_extensions_p
2468 static bool cp_parser_is_pure_string_literal
2470 static bool cp_parser_is_string_literal
2472 static bool cp_parser_is_keyword
2474 static tree cp_parser_make_typename_type
2479 /* Returns nonzero if we are parsing tentatively. */
2483 {
2485 }
2487 /* Returns nonzero if TOKEN is a string literal. */
2489 static bool
2491 {
2497 }
2499 /* Returns nonzero if TOKEN is a string literal
2500 of a user-defined string literal. */
2502 static bool
2504 {
2511 }
2513 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2515 static bool
2517 {
2519 }
2521 /* If not parsing tentatively, issue a diagnostic of the form
2522 FILE:LINE: MESSAGE before TOKEN
2523 where TOKEN is the next token in the input stream. MESSAGE
2524 (specified by the caller) is usually of the form "expected
2525 OTHER-TOKEN". */
2527 static void
2529 {
2531 {
2533 /* This diagnostic makes more sense if it is tagged to the line
2534 of the token we just peeked at. */
2538 {
2543 }
2546 /* Because c_parser_error does not understand
2547 CPP_KEYWORD, keywords are treated like
2548 identifiers. */
2551 }
2552 }
2554 /* Issue an error about name-lookup failing. NAME is the
2555 IDENTIFIER_NODE DECL is the result of
2556 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2557 the thing that we hoped to find. */
2559 static void
2561 tree name,
2562 tree decl,
2563 name_lookup_error desired,
2564 location_t location)
2565 {
2566 /* If name lookup completely failed, tell the user that NAME was not
2567 declared. */
2569 {
2582 else
2584 }
2586 {
2588 {
2605 }
2606 }
2608 {
2610 {
2620 name);
2624 }
2625 }
2626 else
2627 {
2629 {
2642 }
2643 }
2644 }
2646 /* If we are parsing tentatively, remember that an error has occurred
2647 during this tentative parse. Returns true if the error was
2648 simulated; false if a message should be issued by the caller. */
2650 static bool
2652 {
2654 {
2657 }
2659 }
2661 /* This function is called when a type is defined. If type
2662 definitions are forbidden at this point, an error message is
2663 issued. */
2665 static bool
2667 {
2668 /* If types are forbidden here, issue a message. */
2670 {
2671 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2672 in the message need to be interpreted. */
2675 }
2677 }
2679 /* This function is called when the DECLARATOR is processed. The TYPE
2680 was a type defined in the decl-specifiers. If it is invalid to
2681 define a type in the decl-specifiers for DECLARATOR, an error is
2682 issued. TYPE_LOCATION is the location of TYPE and is used
2683 for error reporting. */
2685 static void
2688 {
2689 /* [dcl.fct] forbids type definitions in return types.
2690 Unfortunately, it's not easy to know whether or not we are
2691 processing a return type until after the fact. */
2699 {
2704 type);
2705 }
2706 }
2708 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2709 "<" in any valid C++ program. If the next token is indeed "<",
2710 issue a message warning the user about what appears to be an
2711 invalid attempt to form a template-id. LOCATION is the location
2712 of the type-specifier (TYPE) */
2714 static void
2716 tree type,
2718 location_t location)
2719 {
2723 {
2727 {
2730 else
2732 }
2733 else
2735 /* Remember the location of the invalid "<". */
2738 /* Consume the "<". */
2740 /* Parse the template arguments. */
2742 /* Permanently remove the invalid template arguments so that
2743 this error message is not issued again. */
2746 }
2747 }
2749 /* If parsing an integral constant-expression, issue an error message
2750 about the fact that THING appeared and return true. Otherwise,
2751 return false. In either case, set
2752 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2754 static bool
2756 non_integral_constant thing)
2757 {
2760 {
2762 {
2765 {
2772 "enumeration type cannot appear in a "
2863 }
2867 }
2868 }
2870 }
2872 /* Emit a diagnostic for an invalid type name. SCOPE is the
2873 qualifying scope (or NULL, if none) for ID. This function commits
2874 to the current active tentative parse, if any. (Otherwise, the
2875 problematic construct might be encountered again later, resulting
2876 in duplicate error messages.) LOCATION is the location of ID. */
2878 static void
2881 location_t location)
2882 {
2885 /* Try to lookup the identifier. */
2895 /* If the lookup was ambiguous, an error will already have
2896 been issued. */
2898 /* If the lookup found a template-name, it means that the user forgot
2899 to specify an argument list. Emit a useful error message. */
2903 decl);
2907 /* Something like 'unsigned A a;' */
2910 {
2911 /* Issue an error message. */
2913 /* If we're in a template class, it's possible that the user was
2914 referring to a type from a base class. For example:
2916 template <typename T> struct A { typedef T X; };
2917 template <typename T> struct B : public A<T> { X x; };
2919 The user should have said "typename A<T>::X". */
2925 {
2926 tree b;
2929 b;
2931 {
2935 {
2936 tree field;
2937 /* Go from a particular instantiation of the
2938 template (which will have an empty TYPE_FIELDs),
2939 to the main version. */
2942 field;
2946 {
2951 }
2954 }
2955 }
2956 }
2957 }
2958 /* Here we diagnose qualified-ids where the scope is actually correct,
2959 but the identifier does not resolve to a valid type name. */
2961 {
2963 {
2968 else
2972 }
2975 {
2976 /* A<T>::A<T>() */
2982 }
2989 {
2994 else
2998 }
2999 else
3001 }
3002 }
3004 /* Check for a common situation where a type-name should be present,
3005 but is not, and issue a sensible error message. Returns true if an
3006 invalid type-name was detected.
3008 The situation handled by this function are variable declarations of the
3009 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3010 Usually, `ID' should name a type, but if we got here it means that it
3011 does not. We try to emit the best possible error message depending on
3012 how exactly the id-expression looks like. */
3014 static bool
3016 {
3017 tree id;
3020 /* Avoid duplicate error about ambiguous lookup. */
3022 {
3026 }
3035 /* If the next token is a (, this is a function with no explicit return
3036 type, i.e. constructor, destructor or conversion op. */
3039 {
3042 }
3046 /* Emit a diagnostic for the invalid type. */
3049 out:
3050 /* If we aren't in the middle of a declarator (i.e. in a
3051 parameter-declaration-clause), skip to the end of the declaration;
3052 there's no point in trying to process it. */
3056 }
3058 /* Consume tokens up to, and including, the next non-nested closing `)'.
3059 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3060 are doing error recovery. Returns -1 if OR_COMMA is true and we
3061 found an unnested comma. */
3063 static int
3068 {
3078 {
3082 {
3085 /* If we've run out of tokens, then there is no closing `)'. */
3088 /* This is good for lambda expression capture-lists. */
3098 /* This matches the processing in skip_to_end_of_statement. */
3124 {
3128 }
3133 }
3135 /* Consume the token. */
3137 }
3138 }
3140 /* Consume tokens until we reach the end of the current statement.
3141 Normally, that will be just before consuming a `;'. However, if a
3142 non-nested `}' comes first, then we stop before consuming that. */
3144 static void
3146 {
3149 /* Unwind generic function template scope if necessary. */
3154 {
3158 {
3161 /* If we've run out of tokens, stop. */
3165 /* If the next token is a `;', we have reached the end of the
3166 statement. */
3172 /* If this is a non-nested '}', stop before consuming it.
3173 That way, when confronted with something like:
3175 { 3 + }
3177 we stop before consuming the closing '}', even though we
3178 have not yet reached a `;'. */
3182 /* If it is the closing '}' for a block that we have
3183 scanned, stop -- but only after consuming the token.
3184 That way given:
3186 void f g () { ... }
3187 typedef int I;
3189 we will stop after the body of the erroneously declared
3190 function, but before consuming the following `typedef'
3191 declaration. */
3193 {
3196 }
3204 }
3206 /* Consume the token. */
3208 }
3209 }
3211 /* This function is called at the end of a statement or declaration.
3212 If the next token is a semicolon, it is consumed; otherwise, error
3213 recovery is attempted. */
3215 static void
3217 {
3218 /* Look for the trailing `;'. */
3220 {
3221 /* If there is additional (erroneous) input, skip to the end of
3222 the statement. */
3224 /* If the next token is now a `;', consume it. */
3227 }
3228 }
3230 /* Skip tokens until we have consumed an entire block, or until we
3231 have consumed a non-nested `;'. */
3233 static void
3235 {
3238 /* Unwind generic function template scope if necessary. */
3243 {
3247 {
3250 /* If we've run out of tokens, stop. */
3254 /* Stop if this is an unnested ';'. */
3260 /* Stop if this is an unnested '}', or closes the outermost
3261 nesting level. */
3262 nesting_depth--;
3270 /* Nest. */
3271 nesting_depth++;
3276 }
3278 /* Consume the token. */
3280 }
3281 }
3283 /* Skip tokens until a non-nested closing curly brace is the next
3284 token, or there are no more tokens. Return true in the first case,
3285 false otherwise. */
3287 static bool
3289 {
3293 {
3297 {
3300 /* If we've run out of tokens, stop. */
3304 /* If the next token is a non-nested `}', then we have reached
3305 the end of the current block. */
3311 /* If it the next token is a `{', then we are entering a new
3312 block. Consume the entire block. */
3318 }
3320 /* Consume the token. */
3322 }
3323 }
3325 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3326 parameter is the PRAGMA token, allowing us to purge the entire pragma
3327 sequence. */
3329 static void
3331 {
3336 do
3340 /* Ensure that the pragma is not parsed again. */
3342 }
3344 /* Require pragma end of line, resyncing with it as necessary. The
3345 arguments are as for cp_parser_skip_to_pragma_eol. */
3347 static void
3349 {
3353 }
3355 /* This is a simple wrapper around make_typename_type. When the id is
3356 an unresolved identifier node, we can provide a superior diagnostic
3357 using cp_parser_diagnose_invalid_type_name. */
3359 static tree
3362 {
3363 tree result;
3365 {
3371 }
3373 }
3375 /* This is a wrapper around the
3376 make_{pointer,ptrmem,reference}_declarator functions that decides
3377 which one to call based on the CODE and CLASS_TYPE arguments. The
3378 CODE argument should be one of the values returned by
3379 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3380 appertain to the pointer or reference. */
3384 cp_cv_quals cv_qualifiers,
3386 tree attributes)
3387 {
3394 else
3404 }
3406 /* Create a new C++ parser. */
3410 {
3415 /* cp_lexer_new_main is called before doing GC allocation because
3416 cp_lexer_new_main might load a PCH file. */
3419 /* Initialize the binops_by_token so that we can get the tree
3420 directly from the token. */
3428 /* For now, we always accept GNU extensions. */
3431 /* The `>' token is a greater-than operator, not the end of a
3432 template-id. */
3437 /* We are not parsing a constant-expression. */
3442 /* Local variable names are not forbidden. */
3445 /* We are not processing an `extern "C"' declaration. */
3448 /* We are not processing a declarator. */
3451 /* We are not processing a template-argument-list. */
3454 /* We are not in an iteration statement. */
3457 /* We are not in a switch statement. */
3460 /* We are not parsing a type-id inside an expression. */
3463 /* Declarations aren't implicitly extern "C". */
3466 /* String literals should be translated to the execution character set. */
3469 /* We are not parsing a function body. */
3472 /* We can correct until told otherwise. */
3475 /* The unparsed function queue is empty. */
3478 /* There are no classes being defined. */
3481 /* No template parameters apply. */
3484 /* Not declaring an implicit function template. */
3491 }
3493 /* Create a cp_lexer structure which will emit the tokens in CACHE
3494 and push it onto the parser's lexer stack. This is used for delayed
3495 parsing of in-class method bodies and default arguments, and should
3496 not be confused with tentative parsing. */
3497 static void
3499 {
3504 /* Move the current source position to that of the first token in the
3505 new lexer. */
3507 }
3509 /* Pop the top lexer off the parser stack. This is never used for the
3510 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3511 static void
3513 {
3518 /* Put the current source position back where it was before this
3519 lexer was pushed. */
3521 }
3523 /* Lexical conventions [gram.lex] */
3525 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3526 identifier. */
3528 static tree
3530 {
3533 /* Look for the identifier. */
3535 /* Return the value. */
3537 }
3539 /* Parse a sequence of adjacent string constants. Returns a
3540 TREE_STRING representing the combined, nul-terminated string
3541 constant. If TRANSLATE is true, translate the string to the
3542 execution character set. If WIDE_OK is true, a wide string is
3543 invalid here.
3545 C++98 [lex.string] says that if a narrow string literal token is
3546 adjacent to a wide string literal token, the behavior is undefined.
3547 However, C99 6.4.5p4 says that this results in a wide string literal.
3548 We follow C99 here, for consistency with the C front end.
3550 This code is largely lifted from lex_string() in c-lex.c.
3552 FUTURE: ObjC++ will need to handle @-strings here. */
3553 static tree
3555 {
3556 tree value;
3563 tree string_tree;
3569 {
3572 }
3575 {
3579 }
3580 else
3581 {
3584 }
3587 /* Try to avoid the overhead of creating and destroying an obstack
3588 for the common case of just one string. */
3591 {
3599 {
3603 }
3604 else
3608 }
3609 else
3610 {
3614 do
3615 {
3617 count++;
3622 {
3625 {
3628 }
3631 {
3636 }
3638 }
3639 else
3643 {
3648 "unsupported non-standard concatenation "
3650 }
3656 {
3660 }
3661 else
3662 {
3666 }
3667 }
3671 }
3674 {
3677 }
3681 {
3686 {
3701 }
3706 {
3711 }
3712 }
3713 else
3714 /* cpp_interpret_string has issued an error. */
3721 }
3723 /* Look up a literal operator with the name and the exact arguments. */
3725 static tree
3727 {
3734 {
3740 {
3743 {
3753 }
3756 /* May be this should be sufficient_parms_p instead,
3757 depending on how exactly should user-defined literals
3758 work in presence of default arguments on the literal
3759 operator parameters. */
3762 }
3763 }
3766 }
3768 /* Parse a user-defined char constant. Returns a call to a user-defined
3769 literal operator taking the character as an argument. */
3771 static tree
3773 {
3781 /* Build up a call to the user-defined operator */
3782 /* Lookup the name we got back from the id-expression. */
3787 {
3792 }
3801 }
3803 /* A subroutine of cp_parser_userdef_numeric_literal to
3804 create a char... template parameter pack from a string node. */
3806 static tree
3808 {
3809 tree charvec;
3815 /* Fill in CHARVEC with all of the parameters. */
3820 /* Build the argument packs. */
3827 }
3829 /* A subroutine of cp_parser_userdef_numeric_literal to
3830 create a char... template parameter pack from a string node. */
3832 static tree
3834 {
3835 tree charvec;
3846 /* First template parm is character type. */
3849 /* Fill in CHARVEC with all of the parameters. */
3856 /* Build the argument packs. */
3863 }
3865 /* Parse a user-defined numeric constant. returns a call to a user-defined
3866 literal operator. */
3868 static tree
3870 {
3881 /* Look for a literal operator taking the exact type of numeric argument
3882 as the literal value. */
3887 {
3890 {
3894 long_long_unsigned_type_node);
3895 else
3896 {
3900 long_double_type_node);
3904 }
3907 }
3908 }
3911 /* If the numeric argument didn't work, look for a raw literal
3912 operator taking a const char* argument consisting of the number
3913 in string format. */
3918 {
3921 {
3924 }
3925 }
3928 /* If the raw literal didn't work, look for a non-type template
3929 function with parameter pack char.... Call the function with
3930 template parameter characters representing the number. */
3934 {
3939 {
3942 }
3943 }
3951 }
3953 /* Parse a user-defined string constant. Returns a call to a user-defined
3954 literal operator taking a character pointer and the length of the string
3955 as arguments. */
3957 static tree
3959 {
3969 /* Look for a template function with typename parameter CharT
3970 and parameter pack CharT... Call the function with
3971 template parameter characters representing the string. */
3975 {
3980 {
3983 }
3984 }
3987 /* Build up a call to the user-defined operator */
3988 /* Lookup the name we got back from the id-expression. */
3994 {
3998 }
4007 }
4010 /* Basic concepts [gram.basic] */
4012 /* Parse a translation-unit.
4014 translation-unit:
4015 declaration-seq [opt]
4017 Returns TRUE if all went well. */
4019 static bool
4021 {
4022 /* The address of the first non-permanent object on the declarator
4023 obstack. */
4028 /* Create the declarator obstack, if necessary. */
4030 {
4032 /* Create the error declarator. */
4034 /* Create the empty parameter list. */
4036 /* Remember where the base of the declarator obstack lies. */
4038 }
4042 /* If there are no tokens left then all went well. */
4044 {
4045 /* Get rid of the token array; we don't need it any more. */
4049 /* This file might have been a context that's implicitly extern
4050 "C". If so, pop the lang context. (Only relevant for PCH.) */
4052 {
4055 }
4057 /* Finish up. */
4061 }
4062 else
4063 {
4066 }
4068 /* Make sure the declarator obstack was fully cleaned up. */
4072 /* All went well. */
4074 }
4076 /* Return the appropriate tsubst flags for parsing, possibly in N3276
4077 decltype context. */
4081 {
4086 }
4088 /* Expressions [gram.expr] */
4090 /* Parse a primary-expression.
4092 primary-expression:
4093 literal
4094 this
4095 ( expression )
4096 id-expression
4098 GNU Extensions:
4100 primary-expression:
4101 ( compound-statement )
4102 __builtin_va_arg ( assignment-expression , type-id )
4103 __builtin_offsetof ( type-id , offsetof-expression )
4105 C++ Extensions:
4106 __has_nothrow_assign ( type-id )
4107 __has_nothrow_constructor ( type-id )
4108 __has_nothrow_copy ( type-id )
4109 __has_trivial_assign ( type-id )
4110 __has_trivial_constructor ( type-id )
4111 __has_trivial_copy ( type-id )
4112 __has_trivial_destructor ( type-id )
4113 __has_virtual_destructor ( type-id )
4114 __is_abstract ( type-id )
4115 __is_base_of ( type-id , type-id )
4116 __is_class ( type-id )
4117 __is_convertible_to ( type-id , type-id )
4118 __is_empty ( type-id )
4119 __is_enum ( type-id )
4120 __is_final ( type-id )
4121 __is_literal_type ( type-id )
4122 __is_pod ( type-id )
4123 __is_polymorphic ( type-id )
4124 __is_std_layout ( type-id )
4125 __is_trivial ( type-id )
4126 __is_union ( type-id )
4128 Objective-C++ Extension:
4130 primary-expression:
4131 objc-expression
4133 literal:
4134 __null
4136 ADDRESS_P is true iff this expression was immediately preceded by
4137 "&" and therefore might denote a pointer-to-member. CAST_P is true
4138 iff this expression is the target of a cast. TEMPLATE_ARG_P is
4139 true iff this expression is a template argument.
4141 Returns a representation of the expression. Upon return, *IDK
4142 indicates what kind of id-expression (if any) was present. */
4144 static tree
4151 {
4154 /* Assume the primary expression is not an id-expression. */
4157 /* Peek at the next token. */
4160 {
4161 /* literal:
4162 integer-literal
4163 character-literal
4164 floating-literal
4165 string-literal
4166 boolean-literal
4167 pointer-literal
4168 user-defined-literal */
4178 {
4182 }
4183 /* Floating-point literals are only allowed in an integral
4184 constant expression if they are cast to an integral or
4185 enumeration type. */
4189 {
4190 /* CAST_P will be set even in invalid code like "int(2.7 +
4191 ...)". Therefore, we have to check that the next token
4192 is sure to end the cast. */
4194 {
4199 enumerator-definition. */
4201 /* The curly brace at the end of an enum-specifier. */
4203 /* The end of a statement. */
4205 /* The end of the cast-expression. */
4207 /* The end of an array bound. */
4209 /* The closing ">" in a template-argument-list. */
4212 /* C++0x only: A ">>" treated like two ">" tokens,
4213 in a template-argument-list. */
4218 }
4220 /* If we are within a cast, then the constraint that the
4221 cast is to an integral or enumeration type will be
4222 checked at that point. If we are not within a cast, then
4223 this code is invalid. */
4226 }
4245 /* ??? Should wide strings be allowed when parser->translate_strings_p
4246 is false (i.e. in attributes)? If not, we can kill the third
4247 argument to cp_parser_string_literal. */
4253 {
4254 tree expr;
4257 /* Consume the `('. */
4259 /* Within a parenthesized expression, a `>' token is always
4260 the greater-than operator. */
4261 saved_greater_than_is_operator_p
4264 /* If we see `( { ' then we are looking at the beginning of
4265 a GNU statement-expression. */
4268 {
4269 /* Statement-expressions are not allowed by the standard. */
4273 /* And they're not allowed outside of a function-body; you
4274 cannot, for example, write:
4276 int i = ({ int j = 3; j + 1; });
4278 at class or namespace scope. */
4281 {
4283 "statement-expressions are not allowed outside "
4287 }
4288 else
4289 {
4290 /* Start the statement-expression. */
4292 /* Parse the compound-statement. */
4294 /* Finish up. */
4296 }
4297 }
4298 else
4299 {
4300 /* Parse the parenthesized expression. */
4302 /* Let the front end know that this expression was
4303 enclosed in parentheses. This matters in case, for
4304 example, the expression is of the form `A::B', since
4305 `&A::B' might be a pointer-to-member, but `&(A::B)' is
4306 not. */
4308 /* DR 705: Wrapping an unqualified name in parentheses
4309 suppresses arg-dependent lookup. We want to pass back
4310 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4311 (c++/37862), but none of the others. */
4314 }
4315 /* The `>' token might be the end of a template-id or
4316 template-parameter-list now. */
4317 parser->greater_than_is_operator_p
4319 /* Consume the `)'. */
4324 }
4328 /* We have an Objective-C++ message. */
4330 {
4332 /* Don't warn about a failed tentative parse. */
4337 }
4341 /* We have an Objective-C++ string literal. */
4348 {
4349 /* These two are the boolean literals. */
4357 /* The `__null' literal. */
4362 /* The `nullptr' literal. */
4367 /* Recognize the `this' keyword. */
4371 {
4375 }
4376 /* Pointers cannot appear in constant-expressions. */
4381 /* The `operator' keyword can be the beginning of an
4382 id-expression. */
4389 {
4390 non_integral_constant name;
4392 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4393 __func__ are the names of variables -- but they are
4394 treated specially. Therefore, they are handled here,
4395 rather than relying on the generic id-expression logic
4396 below. Grammatically, these names are id-expressions.
4398 Consume the token. */
4402 {
4414 }
4419 /* Look up the name. */
4421 }
4424 {
4425 tree expression;
4426 tree type;
4427 source_location type_location;
4429 /* The `__builtin_va_arg' construct is used to handle
4430 `va_arg'. Consume the `__builtin_va_arg' token. */
4432 /* Look for the opening `('. */
4434 /* Now, parse the assignment-expression. */
4437 /* Look for the `,'. */
4440 /* Parse the type-id. */
4442 /* Look for the closing `)'. */
4444 /* Using `va_arg' in a constant-expression is not
4445 allowed. */
4447 NIC_VA_ARG))
4450 }
4478 /* Objective-C++ expressions. */
4488 {
4493 }
4497 }
4499 /* An id-expression can start with either an identifier, a
4500 `::' as the beginning of a qualified-id, or the "operator"
4501 keyword. */
4506 {
4507 tree id_expression;
4508 tree decl;
4514 id_expression:
4515 /* Parse the id-expression. */
4516 id_expression
4533 /* If we have a template-id, then no further lookup is
4534 required. If the template-id was for a template-class, we
4535 will sometimes have a TYPE_DECL at this point. */
4539 /* Look up the name. */
4540 else
4541 {
4542 tree ambiguous_decls;
4544 /* If we already know that this lookup is ambiguous, then
4545 we've already issued an error message; there's no reason
4546 to check again. */
4549 {
4552 }
4555 none_type,
4556 template_p,
4561 /* If the lookup was ambiguous, an error will already have
4562 been issued. */
4566 /* In Objective-C++, we may have an Objective-C 2.0
4567 dot-syntax for classes here. */
4572 {
4573 tree component;
4580 }
4582 /* In Objective-C++, an instance variable (ivar) may be preferred
4583 to whatever cp_parser_lookup_name() found. */
4586 /* If name lookup gives us a SCOPE_REF, then the
4587 qualifying scope was dependent. */
4589 {
4590 /* At this point, we do not know if DECL is a valid
4591 integral constant expression. We assume that it is
4592 in fact such an expression, so that code like:
4594 template <int N> struct A {
4595 int a[B<N>::i];
4596 };
4598 is accepted. At template-instantiation time, we
4599 will check that B<N>::i is actually a constant. */
4601 }
4602 /* Check to see if DECL is a local variable in a context
4603 where that is forbidden. */
4606 {
4607 /* It might be that we only found DECL because we are
4608 trying to be generous with pre-ISO scoping rules.
4609 For example, consider:
4611 int i;
4612 void g() {
4613 for (int i = 0; i < 10; ++i) {}
4614 extern void f(int j = i);
4615 }
4617 Here, name look up will originally find the out
4618 of scope `i'. We need to issue a warning message,
4619 but then use the global `i'. */
4622 {
4625 decl);
4627 }
4628 }
4629 }
4631 decl = (finish_id_expression
4633 idk,
4638 template_arg_p,
4644 }
4646 /* Anything else is an error. */
4650 }
4651 }
4659 {
4662 }
4664 /* Parse an id-expression.
4666 id-expression:
4667 unqualified-id
4668 qualified-id
4670 qualified-id:
4671 :: [opt] nested-name-specifier template [opt] unqualified-id
4672 :: identifier
4673 :: operator-function-id
4674 :: template-id
4676 Return a representation of the unqualified portion of the
4677 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
4678 a `::' or nested-name-specifier.
4680 Often, if the id-expression was a qualified-id, the caller will
4681 want to make a SCOPE_REF to represent the qualified-id. This
4682 function does not do this in order to avoid wastefully creating
4683 SCOPE_REFs when they are not required.
4685 If TEMPLATE_KEYWORD_P is true, then we have just seen the
4686 `template' keyword.
4688 If CHECK_DEPENDENCY_P is false, then names are looked up inside
4689 uninstantiated templates.
4691 If *TEMPLATE_P is non-NULL, it is set to true iff the
4692 `template' keyword is used to explicitly indicate that the entity
4693 named is a template.
4695 If DECLARATOR_P is true, the id-expression is appearing as part of
4696 a declarator, rather than as part of an expression. */
4698 static tree
4705 {
4709 /* Assume the `template' keyword was not used. */
4713 /* Look for the optional `::' operator. */
4714 global_scope_p
4717 /* Look for the optional nested-name-specifier. */
4718 nested_name_specifier_p
4721 check_dependency_p,
4723 declarator_p)
4725 /* If there is a nested-name-specifier, then we are looking at
4726 the first qualified-id production. */
4728 {
4729 tree saved_scope;
4730 tree saved_object_scope;
4731 tree saved_qualifying_scope;
4732 tree unqualified_id;
4735 /* See if the next token is the `template' keyword. */
4739 /* Name lookup we do during the processing of the
4740 unqualified-id might obliterate SCOPE. */
4744 /* Process the final unqualified-id. */
4746 check_dependency_p,
4747 declarator_p,
4749 /* Restore the SAVED_SCOPE for our caller. */
4755 }
4756 /* Otherwise, if we are in global scope, then we are looking at one
4757 of the other qualified-id productions. */
4759 {
4761 tree id;
4763 /* Peek at the next token. */
4766 /* If it's an identifier, and the next token is not a "<", then
4767 we can avoid the template-id case. This is an optimization
4768 for this common case. */
4770 && !cp_parser_nth_token_starts_template_argument_list_p
4775 /* Try a template-id. */
4779 none_type,
4780 declarator_p);
4781 /* If that worked, we're done. */
4785 /* Peek at the next token. (Changes in the token buffer may
4786 have invalidated the pointer obtained above.) */
4790 {
4797 /* Fall through. */
4802 }
4803 }
4804 else
4807 declarator_p,
4808 optional_p);
4809 }
4811 /* Parse an unqualified-id.
4813 unqualified-id:
4814 identifier
4815 operator-function-id
4816 conversion-function-id
4817 ~ class-name
4818 template-id
4820 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
4821 keyword, in a construct like `A::template ...'.
4823 Returns a representation of unqualified-id. For the `identifier'
4824 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
4825 production a BIT_NOT_EXPR is returned; the operand of the
4826 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
4827 other productions, see the documentation accompanying the
4828 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
4829 names are looked up in uninstantiated templates. If DECLARATOR_P
4830 is true, the unqualified-id is appearing as part of a declarator,
4831 rather than as part of an expression. */
4833 static tree
4839 {
4842 /* Peek at the next token. */
4846 {
4848 {
4849 tree id;
4851 /* We don't know yet whether or not this will be a
4852 template-id. */
4854 /* Try a template-id. */
4856 check_dependency_p,
4857 none_type,
4858 declarator_p);
4859 /* If it worked, we're done. */
4862 /* Otherwise, it's an ordinary identifier. */
4864 }
4868 check_dependency_p,
4869 none_type,
4870 declarator_p);
4873 {
4874 tree type_decl;
4875 tree qualifying_scope;
4876 tree object_scope;
4877 tree scope;
4880 /* Consume the `~' token. */
4882 /* Parse the class-name. The standard, as written, seems to
4883 say that:
4885 template <typename T> struct S { ~S (); };
4886 template <typename T> S<T>::~S() {}
4888 is invalid, since `~' must be followed by a class-name, but
4889 `S<T>' is dependent, and so not known to be a class.
4890 That's not right; we need to look in uninstantiated
4891 templates. A further complication arises from:
4893 template <typename T> void f(T t) {
4894 t.T::~T();
4895 }
4897 Here, it is not possible to look up `T' in the scope of `T'
4898 itself. We must look in both the current scope, and the
4899 scope of the containing complete expression.
4901 Yet another issue is:
4903 struct S {
4904 int S;
4905 ~S();
4906 };
4908 S::~S() {}
4910 The standard does not seem to say that the `S' in `~S'
4911 should refer to the type `S' and not the data member
4912 `S::S'. */
4914 /* DR 244 says that we look up the name after the "~" in the
4915 same scope as we looked up the qualifying name. That idea
4916 isn't fully worked out; it's more complicated than that. */
4921 /* Check for invalid scopes. */
4923 {
4927 }
4929 {
4933 scope);
4938 }
4941 /* If the name is of the form "X::~X" it's OK even if X is a
4942 typedef. */
4951 {
4954 }
4956 /* ~auto means the destructor of whatever the object is. */
4958 {
4961 "%<~auto%> only available with "
4965 }
4967 /* If there was an explicit qualification (S::~T), first look
4968 in the scope given by the qualification (i.e., S).
4970 Note: in the calls to cp_parser_class_name below we pass
4971 typename_type so that lookup finds the injected-class-name
4972 rather than the constructor. */
4976 {
4981 typename_type,
4984 declarator_p);
4987 }
4988 /* In "N::S::~S", look in "N" as well. */
4990 {
4995 type_decl
4999 typename_type,
5002 declarator_p);
5005 }
5006 /* In "p->S::~T", look in the scope given by "*p" as well. */
5008 {
5013 type_decl
5017 typename_type,
5020 declarator_p);
5023 }
5024 /* Look in the surrounding context. */
5026 {
5032 type_decl
5036 typename_type,
5039 declarator_p);
5042 {
5043 /* We couldn't find a type with this name, so just accept
5044 it and check for a match at instantiation time. */
5049 }
5050 }
5051 /* If an error occurred, assume that the name of the
5052 destructor is the same as the name of the qualifying
5053 class. That allows us to keep parsing after running
5054 into ill-formed destructor names. */
5060 /* Check that destructor name and scope match. */
5062 {
5069 }
5071 /* [class.dtor]
5073 A typedef-name that names a class shall not be used as the
5074 identifier in the declarator for a destructor declaration. */
5081 type_decl);
5084 }
5088 {
5089 tree id;
5091 /* This could be a template-id, so we try that first. */
5093 /* Try a template-id. */
5096 none_type,
5097 declarator_p);
5098 /* If that worked, we're done. */
5101 /* We still don't know whether we're looking at an
5102 operator-function-id or a conversion-function-id. */
5104 /* Try an operator-function-id. */
5106 /* If that didn't work, try a conversion-function-id. */
5110 {
5111 /* 17.6.3.3.5 */
5117 }
5120 }
5121 /* Fall through. */
5128 }
5129 }
5131 /* Parse an (optional) nested-name-specifier.
5133 nested-name-specifier: [C++98]
5134 class-or-namespace-name :: nested-name-specifier [opt]
5135 class-or-namespace-name :: template nested-name-specifier [opt]
5137 nested-name-specifier: [C++0x]
5138 type-name ::
5139 namespace-name ::
5140 nested-name-specifier identifier ::
5141 nested-name-specifier template [opt] simple-template-id ::
5143 PARSER->SCOPE should be set appropriately before this function is
5144 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
5145 effect. TYPE_P is TRUE if we non-type bindings should be ignored
5146 in name lookups.
5148 Sets PARSER->SCOPE to the class (TYPE) or namespace
5149 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
5150 it unchanged if there is no nested-name-specifier. Returns the new
5151 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
5153 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
5154 part of a declaration and/or decl-specifier. */
5156 static tree
5162 {
5167 /* Remember where the nested-name-specifier starts. */
5169 {
5172 }
5175 {
5176 tree new_scope;
5177 tree old_scope;
5178 tree saved_qualifying_scope;
5181 /* Spot cases that cannot be the beginning of a
5182 nested-name-specifier. */
5185 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
5186 the already parsed nested-name-specifier. */
5188 {
5189 /* Grab the nested-name-specifier and continue the loop. */
5191 /* If we originally encountered this nested-name-specifier
5192 with IS_DECLARATION set to false, we will not have
5193 resolved TYPENAME_TYPEs, so we must do so here. */
5196 {
5201 }
5204 }
5206 /* Spot cases that cannot be the beginning of a
5207 nested-name-specifier. On the second and subsequent times
5208 through the loop, we look for the `template' keyword. */
5210 ;
5211 /* A template-id can start a nested-name-specifier. */
5213 ;
5214 /* DR 743: decltype can be used in a nested-name-specifier. */
5216 ;
5217 else
5218 {
5219 /* If the next token is not an identifier, then it is
5220 definitely not a type-name or namespace-name. */
5223 /* If the following token is neither a `<' (to begin a
5224 template-id), nor a `::', then we are not looking at a
5225 nested-name-specifier. */
5231 {
5235 }
5238 && !cp_parser_nth_token_starts_template_argument_list_p
5241 }
5243 /* The nested-name-specifier is optional, so we parse
5244 tentatively. */
5247 /* Look for the optional `template' keyword, if this isn't the
5248 first time through the loop. */
5251 else
5254 /* Save the old scope since the name lookup we are about to do
5255 might destroy it. */
5258 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
5259 look up names in "X<T>::I" in order to determine that "Y" is
5260 a template. So, if we have a typename at this point, we make
5261 an effort to look through it. */
5263 && !typename_keyword_p
5268 /* Parse the qualifying entity. */
5269 new_scope
5271 typename_keyword_p,
5272 template_keyword_p,
5273 check_dependency_p,
5274 type_p,
5275 is_declaration);
5276 /* Look for the `::' token. */
5279 /* If we found what we wanted, we keep going; otherwise, we're
5280 done. */
5282 {
5285 /* Restore the OLD_SCOPE since it was valid before the
5286 failed attempt at finding the last
5287 class-or-namespace-name. */
5291 /* If the next token is a decltype, and the one after that is a
5292 `::', then the decltype has failed to resolve to a class or
5293 enumeration type. Give this error even when parsing
5294 tentatively since it can't possibly be valid--and we're going
5295 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
5296 won't get another chance.*/
5300 {
5307 /* As below. */
5310 }
5314 /* If the next token is an identifier, and the one after
5315 that is a `::', then any valid interpretation would have
5316 found a class-or-namespace-name. */
5322 {
5325 {
5327 {
5328 tree decl;
5329 tree ambiguous_decls;
5332 none_type,
5341 decl);
5343 {
5344 // cp_parser_lookup_name has the same diagnostic,
5345 // thus make sure to emit it at most once.
5348 {
5353 }
5355 }
5356 else
5357 {
5359 cp_parser_name_lookup_error
5362 else
5363 cp_parser_name_lookup_error
5366 }
5367 }
5370 /* Treat this as a successful nested-name-specifier
5371 due to:
5373 [basic.lookup.qual]
5375 If the name found is not a class-name (clause
5376 _class_) or namespace-name (_namespace.def_), the
5377 program is ill-formed. */
5379 }
5381 }
5383 }
5384 /* We've found one valid nested-name-specifier. */
5386 /* Name lookup always gives us a DECL. */
5389 /* Uses of "template" must be followed by actual templates. */
5401 new_scope);
5402 /* If it is a class scope, try to complete it; we are about to
5403 be looking up names inside the class. */
5405 /* Since checking types for dependency can be expensive,
5406 avoid doing it if the type is already complete. */
5408 /* Do not try to complete dependent types. */
5410 {
5412 /* If it is a typedef to current class, use the current
5413 class instead, as the typedef won't have any names inside
5414 it yet. */
5418 }
5419 /* Make sure we look in the right scope the next time through
5420 the loop. */
5422 }
5424 /* If parsing tentatively, replace the sequence of tokens that makes
5425 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
5426 token. That way, should we re-parse the token stream, we will
5427 not have to repeat the effort required to do the parse, nor will
5428 we issue duplicate error messages. */
5430 {
5434 /* Reset the contents of the START token. */
5436 /* Retrieve any deferred checks. Do not pop this access checks yet
5437 so the memory will not be reclaimed during token replacing below. */
5445 /* Purge all subsequent tokens. */
5447 }
5453 }
5455 /* Parse a nested-name-specifier. See
5456 cp_parser_nested_name_specifier_opt for details. This function
5457 behaves identically, except that it will an issue an error if no
5458 nested-name-specifier is present. */
5460 static tree
5466 {
5467 tree scope;
5469 /* Look for the nested-name-specifier. */
5471 typename_keyword_p,
5472 check_dependency_p,
5473 type_p,
5474 is_declaration);
5475 /* If it was not present, issue an error message. */
5477 {
5480 }
5483 }
5485 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
5486 this is either a class-name or a namespace-name (which corresponds
5487 to the class-or-namespace-name production in the grammar). For
5488 C++0x, it can also be a type-name that refers to an enumeration
5489 type or a simple-template-id.
5491 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
5492 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
5493 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
5494 TYPE_P is TRUE iff the next name should be taken as a class-name,
5495 even the same name is declared to be another entity in the same
5496 scope.
5498 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
5499 specified by the class-or-namespace-name. If neither is found the
5500 ERROR_MARK_NODE is returned. */
5502 static tree
5509 {
5510 tree saved_scope;
5511 tree saved_qualifying_scope;
5512 tree saved_object_scope;
5513 tree scope;
5517 /* DR 743: decltype can appear in a nested-name-specifier. */
5519 {
5523 {
5526 }
5530 }
5532 /* Before we try to parse the class-name, we must save away the
5533 current PARSER->SCOPE since cp_parser_class_name will destroy
5534 it. */
5538 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
5539 there is no need to look for a namespace-name. */
5540 only_class_p = template_keyword_p
5545 typename_keyword_p,
5546 template_keyword_p,
5548 check_dependency_p,
5550 is_declaration);
5552 /* If that didn't work and we're in C++0x mode, try for a type-name. */
5556 {
5557 /* Restore the saved scope. */
5562 /* Parse tentatively. */
5565 /* Parse a type-name */
5568 /* "If the name found does not designate a namespace or a class,
5569 enumeration, or dependent type, the program is ill-formed."
5571 We cover classes and dependent types above and namespaces below,
5572 so this code is only looking for enums. */
5578 }
5579 /* If that didn't work, try for a namespace-name. */
5581 {
5582 /* Restore the saved scope. */
5586 /* If we are not looking at an identifier followed by the scope
5587 resolution operator, then this is not part of a
5588 nested-name-specifier. (Note that this function is only used
5589 to parse the components of a nested-name-specifier.) */
5594 }
5597 }
5599 /* Parse a postfix-expression.
5601 postfix-expression:
5602 primary-expression
5603 postfix-expression [ expression ]
5604 postfix-expression ( expression-list [opt] )
5605 simple-type-specifier ( expression-list [opt] )
5606 typename :: [opt] nested-name-specifier identifier
5607 ( expression-list [opt] )
5608 typename :: [opt] nested-name-specifier template [opt] template-id
5609 ( expression-list [opt] )
5610 postfix-expression . template [opt] id-expression
5611 postfix-expression -> template [opt] id-expression
5612 postfix-expression . pseudo-destructor-name
5613 postfix-expression -> pseudo-destructor-name
5614 postfix-expression ++
5615 postfix-expression --
5616 dynamic_cast < type-id > ( expression )
5617 static_cast < type-id > ( expression )
5618 reinterpret_cast < type-id > ( expression )
5619 const_cast < type-id > ( expression )
5620 typeid ( expression )
5621 typeid ( type-id )
5623 GNU Extension:
5625 postfix-expression:
5626 ( type-id ) { initializer-list , [opt] }
5628 This extension is a GNU version of the C99 compound-literal
5629 construct. (The C99 grammar uses `type-name' instead of `type-id',
5630 but they are essentially the same concept.)
5632 If ADDRESS_P is true, the postfix expression is the operand of the
5633 `&' operator. CAST_P is true if this expression is the target of a
5634 cast.
5636 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
5637 class member access expressions [expr.ref].
5639 Returns a representation of the expression. */
5641 static tree
5645 {
5647 location_t loc;
5654 /* Peek at the next token. */
5657 /* Some of the productions are determined by keywords. */
5660 {
5665 {
5666 tree type;
5667 tree expression;
5671 /* All of these can be handled in the same way from the point
5672 of view of parsing. Begin by consuming the token
5673 identifying the cast. */
5676 /* New types cannot be defined in the cast. */
5678 parser->type_definition_forbidden_message
5681 /* Look for the opening `<'. */
5683 /* Parse the type to which we are casting. */
5688 /* Look for the closing `>'. */
5690 /* Restore the old message. */
5693 bool saved_greater_than_is_operator_p
5697 /* And the expression which is being cast. */
5702 parser->greater_than_is_operator_p
5705 /* Only type conversions to integral or enumeration types
5706 can be used in constant-expressions. */
5712 {
5714 postfix_expression
5718 postfix_expression
5722 postfix_expression
5724 tf_warning_or_error);
5727 postfix_expression
5732 }
5733 }
5737 {
5738 tree type;
5742 /* Consume the `typeid' token. */
5744 /* Look for the `(' token. */
5746 /* Types cannot be defined in a `typeid' expression. */
5748 parser->type_definition_forbidden_message
5750 /* We can't be sure yet whether we're looking at a type-id or an
5751 expression. */
5753 /* Try a type-id first. */
5758 /* Look for the `)' token. Otherwise, we can't be sure that
5759 we're not looking at an expression: consider `typeid (int
5760 (3))', for example. */
5762 /* If all went well, simply lookup the type-id. */
5765 /* Otherwise, fall back to the expression variant. */
5766 else
5767 {
5768 tree expression;
5770 /* Look for an expression. */
5772 /* Compute its typeid. */
5774 /* Look for the `)' token. */
5776 }
5777 /* Restore the saved message. */
5779 /* `typeid' may not appear in an integral constant expression. */
5782 }
5786 {
5787 tree type;
5788 /* The syntax permitted here is the same permitted for an
5789 elaborated-type-specifier. */
5794 }
5798 {
5802 {
5807 }
5809 {
5814 }
5815 else
5816 {
5817 /* Consecutive _Cilk_spawns are not allowed in a statement. */
5820 }
5822 postfix_expression =
5826 {
5830 }
5832 {
5837 }
5838 else
5839 {
5841 postfix_expression);
5845 }
5847 }
5850 {
5853 tree p;
5867 tf_warning_or_error);
5870 tf_warning_or_error);
5871 else
5872 {
5876 }
5878 }
5881 {
5882 tree type;
5884 /* If the next thing is a simple-type-specifier, we may be
5885 looking at a functional cast. We could also be looking at
5886 an id-expression. So, we try the functional cast, and if
5887 that doesn't work we fall back to the primary-expression. */
5889 /* Look for the simple-type-specifier. */
5892 CP_PARSER_FLAGS_NONE);
5893 /* Parse the cast itself. */
5895 postfix_expression
5897 /* If that worked, we're done. */
5901 /* If the functional-cast didn't work out, try a
5902 compound-literal. */
5905 {
5910 /* Consume the `('. */
5913 /* Avoid calling cp_parser_type_id pointlessly, see comment
5914 in cp_parser_cast_expression about c++/29234. */
5917 compound_literal_p
5922 /* Roll back the tokens we skipped. */
5927 else
5928 {
5929 /* Parse the type. */
5934 /* Look for the `)'. */
5936 }
5938 /* If things aren't going well, there's no need to
5939 keep going. */
5941 {
5943 /* Parse the brace-enclosed initializer list. */
5946 }
5947 /* If that worked, we're definitely looking at a
5948 compound-literal expression. */
5950 {
5951 /* Warn the user that a compound literal is not
5952 allowed in standard C++. */
5955 /* For simplicity, we disallow compound literals in
5956 constant-expressions. We could
5957 allow compound literals of integer type, whose
5958 initializer was a constant, in constant
5959 expressions. Permitting that usage, as a further
5960 extension, would not change the meaning of any
5961 currently accepted programs. (Of course, as
5962 compound literals are not part of ISO C++, the
5963 standard has nothing to say.) */
5965 NIC_NCC))
5966 {
5969 }
5970 /* Form the representation of the compound-literal. */
5971 postfix_expression
5973 tf_warning_or_error);
5975 }
5976 }
5978 /* It must be a primary-expression. */
5979 postfix_expression
5982 decltype_p,
5984 }
5986 }
5988 /* Note that we don't need to worry about calling build_cplus_new on a
5989 class-valued CALL_EXPR in decltype when it isn't the end of the
5990 postfix-expression; unary_complex_lvalue will take care of that for
5991 all these cases. */
5993 /* Keep looping until the postfix-expression is complete. */
5995 {
5999 /* It is not a Koenig lookup function call. */
6000 postfix_expression
6003 /* Peek at the next token. */
6007 {
6010 {
6012 "two consecutive %<[%> shall "
6015 }
6016 postfix_expression
6018 postfix_expression,
6020 decltype_p);
6026 /* postfix-expression ( expression-list [opt] ) */
6027 {
6037 is_builtin_constant_p
6040 {
6041 /* The whole point of __builtin_constant_p is to allow
6042 non-constant expressions to appear as arguments. */
6043 saved_integral_constant_expression_p
6045 saved_non_integral_constant_expression_p
6048 }
6049 args = (cp_parser_parenthesized_expression_list
6054 {
6055 parser->integral_constant_expression_p
6057 parser->non_integral_constant_expression_p
6059 }
6062 {
6065 }
6067 /* Function calls are not permitted in
6068 constant-expressions. */
6071 NIC_FUNC_CALL))
6072 {
6076 }
6081 {
6083 {
6085 {
6088 postfix_expression
6090 complain);
6091 }
6092 else
6093 postfix_expression
6095 }
6096 /* We do not perform argument-dependent lookup if
6097 normal lookup finds a non-function, in accordance
6098 with the expected resolution of DR 218. */
6101 {
6105 /* Do not do argument dependent lookup if regular
6106 lookup finds a member function or a block-scope
6107 function declaration. [basic.lookup.argdep]/3 */
6110 {
6113 postfix_expression
6115 complain);
6116 }
6117 }
6118 }
6121 {
6131 {
6132 postfix_expression
6136 }
6139 {
6140 postfix_expression
6141 = (build_new_method_call
6147 complain));
6148 }
6149 else
6150 postfix_expression
6154 complain);
6155 }
6159 postfix_expression = (build_offset_ref_call_from_tree
6161 complain));
6163 /* A call to a static class member, or a namespace-scope
6164 function. */
6165 postfix_expression
6168 koenig_p,
6169 complain);
6170 else
6171 /* All other function calls. */
6172 postfix_expression
6175 koenig_p,
6176 complain);
6178 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
6182 }
6187 /* postfix-expression . template [opt] id-expression
6188 postfix-expression . pseudo-destructor-name
6189 postfix-expression -> template [opt] id-expression
6190 postfix-expression -> pseudo-destructor-name */
6192 /* Consume the `.' or `->' operator. */
6195 postfix_expression
6197 postfix_expression,
6204 /* postfix-expression ++ */
6205 /* Consume the `++' token. */
6207 /* Generate a representation for the complete expression. */
6208 postfix_expression
6210 POSTINCREMENT_EXPR);
6211 /* Increments may not appear in constant-expressions. */
6219 /* postfix-expression -- */
6220 /* Consume the `--' token. */
6222 /* Generate a representation for the complete expression. */
6223 postfix_expression
6225 POSTDECREMENT_EXPR);
6226 /* Decrements may not appear in constant-expressions. */
6238 else
6240 }
6241 }
6243 /* We should never get here. */
6246 }
6248 /* This function parses Cilk Plus array notations. If a normal array expr. is
6249 parsed then the array index is passed back to the caller through *INIT_INDEX
6250 and the function returns a NULL_TREE. If array notation expr. is parsed,
6251 then *INIT_INDEX is ignored by the caller and the function returns
6252 a tree of type ARRAY_NOTATION_REF. If some error occurred it returns
6253 error_mark_node. */
6255 static tree
6257 tree array_value)
6258 {
6262 {
6265 }
6274 {
6277 }
6279 {
6280 /* Consume the ':'. */
6283 /* If we are here, then we have a case like this A[:]. */
6285 {
6289 }
6293 }
6294 else
6295 {
6296 /* If we are here, then there are three valid possibilities:
6297 1. ARRAY [ EXP ]
6298 2. ARRAY [ EXP : EXP ]
6299 3. ARRAY [ EXP : EXP : EXP ] */
6303 {
6304 /* This indicates that we have a normal array expression. */
6307 }
6309 /* Consume the ':'. */
6313 {
6316 }
6317 }
6322 {
6326 }
6332 }
6334 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6335 by cp_parser_builtin_offsetof. We're looking for
6337 postfix-expression [ expression ]
6338 postfix-expression [ braced-init-list ] (C++11)
6340 FOR_OFFSETOF is set if we're being called in that context, which
6341 changes how we deal with integer constant expressions. */
6343 static tree
6345 tree postfix_expression,
6348 {
6353 /* Consume the `[' token. */
6359 /* Parse the index expression. */
6360 /* ??? For offsetof, there is a question of what to allow here. If
6361 offsetof is not being used in an integral constant expression context,
6362 then we *could* get the right answer by computing the value at runtime.
6363 If we are in an integral constant expression context, then we might
6364 could accept any constant expression; hard to say without analysis.
6365 Rather than open the barn door too wide right away, allow only integer
6366 constant expressions here. */
6369 else
6370 {
6372 {
6379 {
6381 "braced list index is not allowed with array "
6385 }
6386 }
6388 {
6389 /* Here are have these two options:
6390 ARRAY[EXP : EXP] - Array notation expr with default
6391 stride of 1.
6392 ARRAY[EXP : EXP : EXP] - Array Notation with user-defined
6393 stride. */
6395 postfix_expression);
6398 }
6399 else
6401 }
6405 /* Look for the closing `]'. */
6408 /* Build the ARRAY_REF. */
6412 /* When not doing offsetof, array references are not permitted in
6413 constant-expressions. */
6419 }
6421 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6422 by cp_parser_builtin_offsetof. We're looking for
6424 postfix-expression . template [opt] id-expression
6425 postfix-expression . pseudo-destructor-name
6426 postfix-expression -> template [opt] id-expression
6427 postfix-expression -> pseudo-destructor-name
6429 FOR_OFFSETOF is set if we're being called in that context. That sorta
6430 limits what of the above we'll actually accept, but nevermind.
6431 TOKEN_TYPE is the "." or "->" token, which will already have been
6432 removed from the stream. */
6434 static tree
6437 tree postfix_expression,
6439 location_t location)
6440 {
6441 tree name;
6446 /* If this is a `->' operator, dereference the pointer. */
6449 tf_warning_or_error);
6450 /* Check to see whether or not the expression is type-dependent. */
6452 /* The identifier following the `->' or `.' is not qualified. */
6458 /* Enter the scope corresponding to the type of the object
6459 given by the POSTFIX_EXPRESSION. */
6461 {
6463 /* According to the standard, no expression should ever have
6464 reference type. Unfortunately, we do not currently match
6465 the standard in this respect in that our internal representation
6466 of an expression may have reference type even when the standard
6467 says it does not. Therefore, we have to manually obtain the
6468 underlying type here. */
6470 /* The type of the POSTFIX_EXPRESSION must be complete. */
6472 {
6474 postfix_expression);
6476 }
6477 /* Unlike the object expression in other contexts, *this is not
6478 required to be of complete type for purposes of class member
6479 access (5.2.5) outside the member function body. */
6483 /* Let the name lookup machinery know that we are processing a
6484 class member access expression. */
6486 /* If something went wrong, we want to be able to discern that case,
6487 as opposed to the case where there was no SCOPE due to the type
6488 of expression being dependent. */
6491 /* If the SCOPE was erroneous, make the various semantic analysis
6492 functions exit quickly -- and without issuing additional error
6493 messages. */
6496 }
6498 /* Assume this expression is not a pseudo-destructor access. */
6501 /* If the SCOPE is a scalar type, then, if this is a valid program,
6502 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
6503 is type dependent, it can be pseudo-destructor-name or something else.
6504 Try to parse it as pseudo-destructor-name first. */
6506 {
6507 tree s;
6508 tree type;
6511 /* Parse the pseudo-destructor-name. */
6520 {
6522 postfix_expression
6525 }
6526 }
6529 {
6530 /* If the SCOPE is not a scalar type, we are looking at an
6531 ordinary class member access expression, rather than a
6532 pseudo-destructor-name. */
6535 /* Parse the id-expression. */
6536 name = (cp_parser_id_expression
6543 /* In general, build a SCOPE_REF if the member name is qualified.
6544 However, if the name was not dependent and has already been
6545 resolved; there is no need to build the SCOPE_REF. For example;
6547 struct X { void f(); };
6548 template <typename T> void f(T* t) { t->X::f(); }
6550 Even though "t" is dependent, "X::f" is not and has been resolved
6551 to a BASELINK; there is no need to include scope information. */
6553 /* But we do need to remember that there was an explicit scope for
6554 virtual function calls. */
6558 /* If the name is a template-id that names a type, we will get a
6559 TYPE_DECL here. That is invalid code. */
6561 {
6564 }
6565 else
6566 {
6568 {
6570 {
6574 }
6575 else
6578 name,
6579 template_p);
6583 }
6585 adjust_result_of_qualified_name_lookup
6587 postfix_expression
6589 template_p,
6590 tf_warning_or_error);
6591 }
6592 }
6594 /* We no longer need to look up names in the scope of the object on
6595 the left-hand side of the `.' or `->' operator. */
6598 /* Outside of offsetof, these operators may not appear in
6599 constant-expressions. */
6601 && (cp_parser_non_integral_constant_expression
6606 }
6608 /* Parse a parenthesized expression-list.
6610 expression-list:
6611 assignment-expression
6612 expression-list, assignment-expression
6614 attribute-list:
6615 expression-list
6616 identifier
6617 identifier, expression-list
6619 CAST_P is true if this expression is the target of a cast.
6621 ALLOW_EXPANSION_P is true if this expression allows expansion of an
6622 argument pack.
6624 Returns a vector of trees. Each element is a representation of an
6625 assignment-expression. NULL is returned if the ( and or ) are
6626 missing. An empty, but allocated, vector is returned on no
6627 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
6628 if we are parsing an attribute list for an attribute that wants a
6629 plain identifier argument, normal_attr for an attribute that wants
6630 an expression, or non_attr if we aren't parsing an attribute list. If
6631 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
6632 not all of the expressions in the list were constant. */
6640 {
6646 /* Assume all the expressions will be constant. */
6655 /* Within a parenthesized expression, a `>' token is always
6656 the greater-than operator. */
6657 saved_greater_than_is_operator_p
6661 /* Consume expressions until there are no more. */
6664 {
6665 tree expr;
6667 /* At the beginning of attribute lists, check to see if the
6668 next token is an identifier. */
6671 {
6674 /* Consume the identifier. */
6676 /* Save the identifier. */
6678 }
6679 else
6680 {
6683 /* Parse the next assignment-expression. */
6685 {
6686 /* A braced-init-list. */
6692 }
6694 {
6695 expr = (cp_parser_constant_expression
6700 }
6701 else
6707 /* If we have an ellipsis, then this is an expression
6708 expansion. */
6711 {
6712 /* Consume the `...'. */
6715 /* Build the argument pack. */
6717 }
6719 /* Add it to the list. We add error_mark_node
6720 expressions to the list, so that we can still tell if
6721 the correct form for a parenthesized expression-list
6722 is found. That gives better errors. */
6727 }
6729 /* After the first item, attribute lists look the same as
6730 expression lists. */
6733 get_comma:;
6734 /* If the next token isn't a `,', then we are done. */
6738 /* Otherwise, consume the `,' and keep going. */
6740 }
6743 {
6746 skip_comma:;
6747 /* We try and resync to an unnested comma, as that will give the
6748 user better diagnostics. */
6756 {
6757 parser->greater_than_is_operator_p
6760 }
6761 }
6763 parser->greater_than_is_operator_p
6770 }
6772 /* Parse a pseudo-destructor-name.
6774 pseudo-destructor-name:
6775 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
6776 :: [opt] nested-name-specifier template template-id :: ~ type-name
6777 :: [opt] nested-name-specifier [opt] ~ type-name
6779 If either of the first two productions is used, sets *SCOPE to the
6780 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
6781 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
6782 or ERROR_MARK_NODE if the parse fails. */
6784 static void
6786 tree object,
6789 {
6792 /* Handle ~auto. */
6796 {
6799 "%<~auto%> only available with "
6806 }
6808 /* Assume that things will not work out. */
6811 /* Look for the optional `::' operator. */
6813 /* Look for the optional nested-name-specifier. */
6814 nested_name_specifier_p
6821 /* Now, if we saw a nested-name-specifier, we might be doing the
6822 second production. */
6825 {
6826 /* Consume the `template' keyword. */
6828 /* Parse the template-id. */
6832 class_type,
6834 /* Look for the `::' token. */
6836 }
6837 /* If the next token is not a `~', then there might be some
6838 additional qualification. */
6840 {
6841 /* At this point, we're looking for "type-name :: ~". The type-name
6842 must not be a class-name, since this is a pseudo-destructor. So,
6843 it must be either an enum-name, or a typedef-name -- both of which
6844 are just identifiers. So, we peek ahead to check that the "::"
6845 and "~" tokens are present; if they are not, then we can avoid
6846 calling type_name. */
6850 {
6853 }
6855 /* Look for the type-name. */
6860 /* Look for the `::' token. */
6862 }
6863 else
6866 /* Look for the `~'. */
6869 /* Once we see the ~, this has to be a pseudo-destructor. */
6873 /* Look for the type-name again. We are not responsible for
6874 checking that it matches the first type-name. */
6876 }
6878 /* Parse a unary-expression.
6880 unary-expression:
6881 postfix-expression
6882 ++ cast-expression
6883 -- cast-expression
6884 unary-operator cast-expression
6885 sizeof unary-expression
6886 sizeof ( type-id )
6887 alignof ( type-id ) [C++0x]
6888 new-expression
6889 delete-expression
6891 GNU Extensions:
6893 unary-expression:
6894 __extension__ cast-expression
6895 __alignof__ unary-expression
6896 __alignof__ ( type-id )
6897 alignof unary-expression [C++0x]
6898 __real__ cast-expression
6899 __imag__ cast-expression
6900 && identifier
6901 sizeof ( type-id ) { initializer-list , [opt] }
6902 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
6903 __alignof__ ( type-id ) { initializer-list , [opt] }
6905 ADDRESS_P is true iff the unary-expression is appearing as the
6906 operand of the `&' operator. CAST_P is true if this expression is
6907 the target of a cast.
6909 Returns a representation of the expression. */
6911 static tree
6914 {
6918 /* Peek at the next token. */
6920 /* Some keywords give away the kind of expression. */
6922 {
6926 {
6929 {
6932 location_t first_loc;
6935 /* Consume the token. */
6938 /* Parse the operand. */
6943 else
6944 {
6945 /* ISO C++ defines alignof only with types, not with
6946 expressions. So pedwarn if alignof is used with a non-
6947 type expression. However, __alignof__ is ok. */
6950 "ISO C++ does not allow %<alignof%> "
6954 }
6955 /* For SIZEOF_EXPR, just issue diagnostics, but keep
6956 SIZEOF_EXPR with the original operand. */
6958 {
6960 {
6962 {
6965 error_mark_node));
6967 }
6968 else
6972 }
6974 }
6976 }
6985 {
6986 /* The saved value of the PEDANTIC flag. */
6988 tree expr;
6990 /* Save away the PEDANTIC flag. */
6992 /* Parse the cast-expression. */
6994 /* Restore the PEDANTIC flag. */
6998 }
7002 {
7003 tree expression;
7005 /* Consume the `__real__' or `__imag__' token. */
7007 /* Parse the cast-expression. */
7009 /* Create the complete representation. */
7013 expression,
7014 tf_warning_or_error);
7015 }
7023 {
7024 tree expr;
7034 parser->type_definition_forbidden_message
7037 saved_integral_constant_expression_p
7039 saved_non_integral_constant_expression_p
7043 saved_greater_than_is_operator_p
7053 parser->greater_than_is_operator_p
7056 parser->integral_constant_expression_p
7058 parser->non_integral_constant_expression_p
7065 }
7069 }
7070 }
7072 /* Look for the `:: new' and `:: delete', which also signal the
7073 beginning of a new-expression, or delete-expression,
7074 respectively. If the next token is `::', then it might be one of
7075 these. */
7077 {
7080 /* See if the token after the `::' is one of the keywords in
7081 which we're interested. */
7083 /* If it's `new', we have a new-expression. */
7086 /* Similarly, for `delete'. */
7089 }
7091 /* Look for a unary operator. */
7093 /* The `++' and `--' operators can be handled similarly, even though
7094 they are not technically unary-operators in the grammar. */
7096 {
7101 /* Handle the GNU address-of-label extension. */
7104 {
7105 tree identifier;
7106 tree expression;
7109 /* Consume the '&&' token. */
7111 /* Look for the identifier. */
7113 /* Create an expression representing the address. */
7116 NIC_ADDR_LABEL))
7119 }
7120 }
7122 {
7123 tree cast_expression;
7129 /* Consume the operator token. */
7131 /* Parse the cast-expression. */
7132 cast_expression
7137 pidk);
7138 /* Now, build an appropriate representation. */
7140 {
7144 RO_UNARY_STAR,
7145 complain);
7150 /* Fall through. */
7153 cast_expression,
7154 complain);
7161 /* Fall through. */
7171 }
7175 non_constant_p))
7179 }
7183 decltype_p,
7184 pidk);
7185 }
7190 {
7193 }
7195 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
7196 unary-operator, the corresponding tree code is returned. */
7198 static enum tree_code
7200 {
7202 {
7223 }
7224 }
7226 /* Parse a new-expression.
7228 new-expression:
7229 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
7230 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
7232 Returns a representation of the expression. */
7234 static tree
7236 {
7239 tree type;
7242 tree ret;
7244 /* Look for the optional `::' operator. */
7245 global_scope_p
7249 /* Look for the `new' operator. */
7251 /* There's no easy way to tell a new-placement from the
7252 `( type-id )' construct. */
7254 /* Look for a new-placement. */
7256 /* If that didn't work out, there's no new-placement. */
7258 {
7262 }
7264 /* If the next token is a `(', then we have a parenthesized
7265 type-id. */
7267 {
7271 /* Consume the `('. */
7274 /* Parse the type-id. */
7275 parser->type_definition_forbidden_message
7280 /* Look for the closing `)'. */
7283 /* There should not be a direct-new-declarator in this production,
7284 but GCC used to allowed this, so we check and emit a sensible error
7285 message for this case. */
7287 {
7293 }
7294 }
7295 /* Otherwise, there must be a new-type-id. */
7296 else
7299 /* If the next token is a `(' or '{', then we have a new-initializer. */
7303 else
7306 /* A new-expression may not appear in an integral constant
7307 expression. */
7310 else
7311 {
7312 /* Create a representation of the new-expression. */
7314 tf_warning_or_error);
7315 }
7323 }
7325 /* Parse a new-placement.
7327 new-placement:
7328 ( expression-list )
7330 Returns the same representation as for an expression-list. */
7334 {
7337 /* Parse the expression-list. */
7338 expression_list = (cp_parser_parenthesized_expression_list
7344 }
7346 /* Parse a new-type-id.
7348 new-type-id:
7349 type-specifier-seq new-declarator [opt]
7351 Returns the TYPE allocated. If the new-type-id indicates an array
7352 type, *NELTS is set to the number of elements in the last array
7353 bound; the TYPE will not include the last array bound. */
7355 static tree
7357 {
7358 cp_decl_specifier_seq type_specifier_seq;
7364 /* The type-specifier sequence must not contain type definitions.
7365 (It cannot contain declarations of new types either, but if they
7366 are not definitions we will catch that because they are not
7367 complete.) */
7369 parser->type_definition_forbidden_message
7371 /* Parse the type-specifier-seq. */
7375 /* Restore the old message. */
7381 /* Parse the new-declarator. */
7384 /* Determine the number of elements in the last array dimension, if
7385 any. */
7387 /* Skip down to the last array dimension. */
7392 {
7395 }
7400 {
7403 }
7406 {
7413 else
7415 }
7418 }
7420 /* Parse an (optional) new-declarator.
7422 new-declarator:
7423 ptr-operator new-declarator [opt]
7424 direct-new-declarator
7426 Returns the declarator. */
7430 {
7433 cp_cv_quals cv_quals;
7435 /* We don't know if there's a ptr-operator next, or not. */
7437 /* Look for a ptr-operator. */
7439 /* If that worked, look for more new-declarators. */
7441 {
7444 /* Parse another optional declarator. */
7447 declarator = cp_parser_make_indirect_declarator
7451 }
7453 /* If the next token is a `[', there is a direct-new-declarator. */
7458 }
7460 /* Parse a direct-new-declarator.
7462 direct-new-declarator:
7463 [ expression ]
7464 direct-new-declarator [constant-expression]
7466 */
7470 {
7474 {
7475 tree expression;
7478 /* Look for the opening `['. */
7483 /* The standard requires that the expression have integral
7484 type. DR 74 adds enumeration types. We believe that the
7485 real intent is that these expressions be handled like the
7486 expression in a `switch' condition, which also allows
7487 classes with a single conversion to integral or
7488 enumeration type. */
7490 {
7491 expression
7493 expression,
7496 {
7498 "expression in new-declarator must have integral "
7501 }
7502 }
7504 /* Look for the closing `]'. */
7507 /* Add this bound to the declarator. */
7510 /* If the next token is not a `[', then there are no more
7511 bounds. */
7514 }
7517 }
7519 /* Parse a new-initializer.
7521 new-initializer:
7522 ( expression-list [opt] )
7523 braced-init-list
7525 Returns a representation of the expression-list. */
7529 {
7533 {
7534 tree t;
7541 }
7542 else
7543 expression_list = (cp_parser_parenthesized_expression_list
7549 }
7551 /* Parse a delete-expression.
7553 delete-expression:
7554 :: [opt] delete cast-expression
7555 :: [opt] delete [ ] cast-expression
7557 Returns a representation of the expression. */
7559 static tree
7561 {
7564 tree expression;
7566 /* Look for the optional `::' operator. */
7567 global_scope_p
7571 /* Look for the `delete' keyword. */
7573 /* See if the array syntax is in use. */
7575 {
7576 /* Consume the `[' token. */
7578 /* Look for the `]' token. */
7580 /* Remember that this is the `[]' construct. */
7582 }
7583 else
7586 /* Parse the cast-expression. */
7589 /* A delete-expression may not appear in an integral constant
7590 expression. */
7595 tf_warning_or_error);
7596 }
7598 /* Returns true if TOKEN may start a cast-expression and false
7599 otherwise. */
7601 static bool
7603 {
7606 {
7647 /* In ((type ()) () the last () isn't a valid cast-expression,
7648 so the whole must be parsed as postfix-expression. */
7652 /* '[' may start a primary-expression in obj-c++. */
7658 }
7659 }
7661 /* Parse a cast-expression.
7663 cast-expression:
7664 unary-expression
7665 ( type-id ) cast-expression
7667 ADDRESS_P is true iff the unary-expression is appearing as the
7668 operand of the `&' operator. CAST_P is true if this expression is
7669 the target of a cast.
7671 Returns a representation of the expression. */
7673 static tree
7676 {
7677 /* If it's a `(', then we might be looking at a cast. */
7679 {
7685 /* There's no way to know yet whether or not this is a cast.
7686 For example, `(int (3))' is a unary-expression, while `(int)
7687 3' is a cast. So, we resort to parsing tentatively. */
7689 /* Types may not be defined in a cast. */
7691 parser->type_definition_forbidden_message
7693 /* Consume the `('. */
7695 /* A very tricky bit is that `(struct S) { 3 }' is a
7696 compound-literal (which we permit in C++ as an extension).
7697 But, that construct is not a cast-expression -- it is a
7698 postfix-expression. (The reason is that `(struct S) { 3 }.i'
7699 is legal; if the compound-literal were a cast-expression,
7700 you'd need an extra set of parentheses.) But, if we parse
7701 the type-id, and it happens to be a class-specifier, then we
7702 will commit to the parse at that point, because we cannot
7703 undo the action that is done when creating a new class. So,
7704 then we cannot back up and do a postfix-expression.
7705 Another tricky case is the following (c++/29234):
7707 struct S { void operator () (); };
7709 void foo ()
7710 {
7711 ( S()() );
7712 }
7714 As a type-id we parse the parenthesized S()() as a function
7715 returning a function, groktypename complains and we cannot
7716 back up in this case either.
7718 Therefore, we scan ahead to the closing `)', and check to see
7719 if the tokens after the `)' can start a cast-expression. Otherwise
7720 we are dealing with an unary-expression, a postfix-expression
7721 or something else.
7723 Save tokens so that we can put them back. */
7726 /* We may be looking at a cast-expression. */
7727 cast_expression_p
7732 /* Roll back the tokens we skipped. */
7734 /* If we aren't looking at a cast-expression, simulate an error so
7735 that the call to cp_parser_parse_definitely below will fail. */
7738 else
7739 {
7742 /* Look for the type-id. */
7744 /* Look for the closing `)'. */
7747 }
7749 /* Restore the saved message. */
7752 /* At this point this can only be either a cast or a
7753 parenthesized ctor such as `(T ())' that looks like a cast to
7754 function returning T. */
7756 {
7762 pidk);
7764 /* Warn about old-style casts, if so requested. */
7771 /* Only type conversions to integral or enumeration types
7772 can be used in constant-expressions. */
7775 NIC_CAST))
7778 /* Perform the cast. */
7781 }
7782 else
7784 }
7786 /* If we get here, then it's not a cast, so it must be a
7787 unary-expression. */
7790 }
7792 /* Parse a binary expression of the general form:
7794 pm-expression:
7795 cast-expression
7796 pm-expression .* cast-expression
7797 pm-expression ->* cast-expression
7799 multiplicative-expression:
7800 pm-expression
7801 multiplicative-expression * pm-expression
7802 multiplicative-expression / pm-expression
7803 multiplicative-expression % pm-expression
7805 additive-expression:
7806 multiplicative-expression
7807 additive-expression + multiplicative-expression
7808 additive-expression - multiplicative-expression
7810 shift-expression:
7811 additive-expression
7812 shift-expression << additive-expression
7813 shift-expression >> additive-expression
7815 relational-expression:
7816 shift-expression
7817 relational-expression < shift-expression
7818 relational-expression > shift-expression
7819 relational-expression <= shift-expression
7820 relational-expression >= shift-expression
7822 GNU Extension:
7824 relational-expression:
7825 relational-expression <? shift-expression
7826 relational-expression >? shift-expression
7828 equality-expression:
7829 relational-expression
7830 equality-expression == relational-expression
7831 equality-expression != relational-expression
7833 and-expression:
7834 equality-expression
7835 and-expression & equality-expression
7837 exclusive-or-expression:
7838 and-expression
7839 exclusive-or-expression ^ and-expression
7841 inclusive-or-expression:
7842 exclusive-or-expression
7843 inclusive-or-expression | exclusive-or-expression
7845 logical-and-expression:
7846 inclusive-or-expression
7847 logical-and-expression && inclusive-or-expression
7849 logical-or-expression:
7850 logical-and-expression
7851 logical-or-expression || logical-and-expression
7853 All these are implemented with a single function like:
7855 binary-expression:
7856 simple-cast-expression
7857 binary-expression <token> binary-expression
7859 CAST_P is true if this expression is the target of a cast.
7861 The binops_by_token map is used to get the tree codes for each <token> type.
7862 binary-expressions are associated according to a precedence table. */
7864 #define TOKEN_PRECEDENCE(token) \
7865 (((token->type == CPP_GREATER \
7866 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
7867 && !parser->greater_than_is_operator_p) \
7868 ? PREC_NOT_OPERATOR \
7869 : binops_by_token[token->type].prec)
7871 static tree
7877 {
7878 cp_parser_expression_stack stack;
7880 cp_parser_expression_stack_entry current;
7881 tree rhs;
7885 tree overload;
7886 bool parenthesized_not_lhs_warn
7889 /* Parse the first expression. */
7899 {
7900 /* Get an operator token. */
7906 {
7908 "%<>>%> operator is treated"
7912 }
7916 /* Popping an entry off the stack means we completed a subexpression:
7917 - either we found a token which is not an operator (`>' where it is not
7918 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
7919 will happen repeatedly;
7920 - or, we found an operator which has lower priority. This is the case
7921 where the recursive descent *ascends*, as in `3 * 4 + 5' after
7922 parsing `3 * 4'. */
7924 {
7927 else
7929 }
7931 get_rhs:
7935 /* We used the operator token. */
7938 /* For "false && x" or "true || x", x will never be executed;
7939 disable warnings while evaluating it. */
7945 /* Extract another operand. It may be the RHS of this expression
7946 or the LHS of a new, higher priority expression. */
7950 /* Get another operator token. Look up its precedence to avoid
7951 building a useless (immediately popped) stack entry for common
7952 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
7956 {
7957 /* ... and prepare to parse the RHS of the new, higher priority
7958 expression. Since precedence levels on the stack are
7959 monotonically increasing, we do not have to care about
7960 stack overflows. */
7969 pop:
7971 /* If the stack is not empty, we have parsed into LHS the right side
7972 (`4' in the example above) of an expression we had suspended.
7973 We can use the information on the stack to recover the LHS (`3')
7974 from the stack together with the tree code (`MULT_EXPR'), and
7975 the precedence of the higher level subexpression
7976 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
7977 which will be used to actually build the additive expression. */
7982 }
7984 /* Undo the disabling of warnings done above. */
7996 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
7997 ERROR_MARK for everything that is not a binary expression.
7998 This makes warn_about_parentheses miss some warnings that
7999 involve unary operators. For unary expressions we should
8000 pass the correct tree_code unless the unary expression was
8001 surrounded by parentheses.
8002 */
8008 == tcc_comparison
8011 else
8020 /* If the binary operator required the use of an overloaded operator,
8021 then this expression cannot be an integral constant-expression.
8022 An overloaded operator can be used even if both operands are
8023 otherwise permissible in an integral constant-expression if at
8024 least one of the operands is of enumeration type. */
8028 NIC_OVERLOADED))
8030 }
8033 }
8035 static tree
8040 {
8043 }
8045 /* Parse the `? expression : assignment-expression' part of a
8046 conditional-expression. The LOGICAL_OR_EXPR is the
8047 logical-or-expression that started the conditional-expression.
8048 Returns a representation of the entire conditional-expression.
8050 This routine is used by cp_parser_assignment_expression.
8052 ? expression : assignment-expression
8054 GNU Extensions:
8056 ? : assignment-expression */
8058 static tree
8060 {
8061 tree expr;
8062 tree assignment_expr;
8066 /* Consume the `?' token. */
8071 {
8074 /* Implicit true clause. */
8078 }
8079 else
8080 {
8083 /* Parse the expression. */
8086 c_inhibit_evaluation_warnings +=
8090 }
8092 /* The next token should be a `:'. */
8094 /* Parse the assignment-expression. */
8098 /* Build the conditional-expression. */
8100 expr,
8101 assignment_expr,
8102 tf_warning_or_error);
8103 }
8105 /* Parse an assignment-expression.
8107 assignment-expression:
8108 conditional-expression
8109 logical-or-expression assignment-operator assignment_expression
8110 throw-expression
8112 CAST_P is true if this expression is the target of a cast.
8113 DECLTYPE_P is true if this expression is the operand of decltype.
8115 Returns a representation for the expression. */
8117 static tree
8120 {
8121 tree expr;
8123 /* If the next token is the `throw' keyword, then we're looking at
8124 a throw-expression. */
8127 /* Otherwise, it must be that we are looking at a
8128 logical-or-expression. */
8129 else
8130 {
8131 /* Parse the binary expressions (logical-or-expression). */
8133 decltype_p,
8135 /* If the next token is a `?' then we're actually looking at a
8136 conditional-expression. */
8139 else
8140 {
8143 /* If it's an assignment-operator, we're using the second
8144 production. */
8145 enum tree_code assignment_operator
8148 {
8150 location_t saved_input_location;
8152 /* Parse the right-hand side of the assignment. */
8158 /* An assignment may not appear in a
8159 constant-expression. */
8161 NIC_ASSIGNMENT))
8163 /* Build the assignment expression. Its default
8164 location is the location of the '=' token. */
8168 assignment_operator,
8169 rhs,
8172 }
8173 }
8174 }
8177 }
8179 static tree
8182 {
8185 }
8187 /* Parse an (optional) assignment-operator.
8189 assignment-operator: one of
8190 = *= /= %= += -= >>= <<= &= ^= |=
8192 GNU Extension:
8194 assignment-operator: one of
8195 <?= >?=
8197 If the next token is an assignment operator, the corresponding tree
8198 code is returned, and the token is consumed. For example, for
8199 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
8200 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
8201 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
8202 operator, ERROR_MARK is returned. */
8204 static enum tree_code
8206 {
8210 /* Peek at the next token. */
8214 {
8260 /* Nothing else is an assignment operator. */
8262 }
8264 /* If it was an assignment operator, consume it. */
8269 }
8271 /* Parse an expression.
8273 expression:
8274 assignment-expression
8275 expression , assignment-expression
8277 CAST_P is true if this expression is the target of a cast.
8278 DECLTYPE_P is true if this expression is the immediate operand of decltype,
8279 except possibly parenthesized or on the RHS of a comma (N3276).
8281 Returns a representation of the expression. */
8283 static tree
8286 {
8291 {
8292 tree assignment_expression;
8294 /* Parse the next assignment-expression. */
8295 assignment_expression
8298 /* We don't create a temporary for a call that is the immediate operand
8299 of decltype or on the RHS of a comma. But when we see a comma, we
8300 need to create a temporary for a call on the LHS. */
8305 assignment_expression
8309 /* If this is the first assignment-expression, we can just
8310 save it away. */
8313 else
8315 assignment_expression,
8317 /* If the next token is not a comma, then we are done with the
8318 expression. */
8321 /* Consume the `,'. */
8324 /* A comma operator cannot appear in a constant-expression. */
8327 }
8330 }
8334 {
8336 }
8338 /* Parse a constant-expression.
8340 constant-expression:
8341 conditional-expression
8343 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
8344 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
8345 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
8346 is false, NON_CONSTANT_P should be NULL. */
8348 static tree
8352 {
8356 tree expression;
8358 /* It might seem that we could simply parse the
8359 conditional-expression, and then check to see if it were
8360 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
8361 one that the compiler can figure out is constant, possibly after
8362 doing some simplifications or optimizations. The standard has a
8363 precise definition of constant-expression, and we must honor
8364 that, even though it is somewhat more restrictive.
8366 For example:
8368 int i[(2, 3)];
8370 is not a legal declaration, because `(2, 3)' is not a
8371 constant-expression. The `,' operator is forbidden in a
8372 constant-expression. However, GCC's constant-folding machinery
8373 will fold this operation to an INTEGER_CST for `3'. */
8375 /* Save the old settings. */
8377 saved_allow_non_integral_constant_expression_p
8380 /* We are now parsing a constant-expression. */
8382 parser->allow_non_integral_constant_expression_p
8385 /* Although the grammar says "conditional-expression", we parse an
8386 "assignment-expression", which also permits "throw-expression"
8387 and the use of assignment operators. In the case that
8388 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
8389 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
8390 actually essential that we look for an assignment-expression.
8391 For example, cp_parser_initializer_clauses uses this function to
8392 determine whether a particular assignment-expression is in fact
8393 constant. */
8395 /* Restore the old settings. */
8396 parser->integral_constant_expression_p
8398 parser->allow_non_integral_constant_expression_p
8401 {
8402 /* Require an rvalue constant expression here; that's what our
8403 callers expect. Reference constant expressions are handled
8404 separately in e.g. cp_parser_template_argument. */
8409 }
8412 parser->non_integral_constant_expression_p
8416 }
8418 /* Parse __builtin_offsetof.
8420 offsetof-expression:
8421 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
8423 offsetof-member-designator:
8424 id-expression
8425 | offsetof-member-designator "." id-expression
8426 | offsetof-member-designator "[" expression "]"
8427 | offsetof-member-designator "->" id-expression */
8429 static tree
8431 {
8434 cp_id_kind dummy;
8437 /* We're about to accept non-integral-constant things, but will
8438 definitely yield an integral constant expression. Save and
8439 restore these values around our local parsing. */
8443 /* Consume the "__builtin_offsetof" token. */
8445 /* Consume the opening `('. */
8447 /* Parse the type-id. */
8449 /* Look for the `,'. */
8453 /* Build the (type *)null that begins the traditional offsetof macro. */
8455 tf_warning_or_error);
8457 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
8461 {
8464 {
8466 /* offsetof-member-designator "[" expression "]" */
8472 /* offsetof-member-designator "->" identifier */
8475 /* FALLTHRU */
8478 /* offsetof-member-designator "." identifier */
8486 /* Consume the ")" token. */
8491 /* Error. We know the following require will fail, but
8492 that gives the proper error message. */
8497 }
8498 }
8500 success:
8501 /* If we're processing a template, we can't finish the semantics yet.
8502 Otherwise we can fold the entire expression now. */
8505 else
8508 failure:
8513 }
8515 /* Parse a trait expression.
8517 Returns a representation of the expression, the underlying type
8518 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
8520 static tree
8522 {
8523 cp_trait_kind kind;
8526 cp_decl_specifier_seq decl_specs;
8529 {
8606 }
8608 /* Consume the token. */
8618 /* Build a trivial decl-specifier-seq. */
8622 /* Call grokdeclarator to figure out what type this is. */
8627 {
8635 /* Build a trivial decl-specifier-seq. */
8639 /* Call grokdeclarator to figure out what type this is. */
8642 }
8646 /* Complete the trait expression, which may mean either processing
8647 the trait expr now or saving it for template instantiation. */
8649 {
8658 }
8659 }
8661 /* Lambdas that appear in variable initializer or default argument scope
8662 get that in their mangling, so we need to record it. We might as well
8663 use the count for function and namespace scopes as well. */
8667 {
8668 tree t;
8673 static void
8675 {
8676 tree_int ti;
8678 /* Once we're inside a function, we ignore other scopes and just push
8679 the function again so that popping works properly. */
8686 {
8687 /* Don't reset the count if we're still in the same function. */
8690 }
8691 }
8693 static void
8695 {
8698 }
8700 static void
8702 {
8705 {
8708 }
8710 }
8712 /* Parse a lambda expression.
8714 lambda-expression:
8715 lambda-introducer lambda-declarator [opt] compound-statement
8717 Returns a representation of the expression. */
8719 static tree
8721 {
8723 tree type;
8730 {
8732 {
8736 }
8738 }
8740 /* We may be in the middle of deferred access check. Disable
8741 it now. */
8752 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
8755 /* Now that we've started the type, add the capture fields for any
8756 explicit captures. */
8759 {
8760 /* Inside the class, surrounding template-parameter-lists do not apply. */
8761 unsigned int saved_num_template_parameter_lists
8765 bool fully_implicit_function_template_p
8769 bool auto_is_implicit_function_template_parm_p
8780 /* By virtue of defining a local class, a lambda expression has access to
8781 the private variables of enclosing classes. */
8788 {
8791 }
8793 /* The capture list was built up in reverse order; fix that now. */
8805 parser->fully_implicit_function_template_p
8809 parser->auto_is_implicit_function_template_parm_p
8811 }
8815 /* This field is only used during parsing of the lambda. */
8818 /* This lambda shouldn't have any proxies left at this point. */
8820 /* And now that we're done, push proxies for an enclosing lambda. */
8825 else
8827 }
8829 /* Parse the beginning of a lambda expression.
8831 lambda-introducer:
8832 [ lambda-capture [opt] ]
8834 LAMBDA_EXPR is the current representation of the lambda expression. */
8836 static void
8838 {
8839 /* Need commas after the first capture. */
8842 /* Eat the leading `['. */
8845 /* Record default capture mode. "[&" "[=" "[&," "[=," */
8853 {
8856 }
8859 {
8861 tree capture_id;
8862 tree capture_init_expr;
8866 enum capture_kind_type
8867 {
8868 BY_COPY,
8869 BY_REFERENCE
8870 };
8874 {
8877 }
8881 else
8884 /* Possibly capture `this'. */
8886 {
8896 explicit_init_p);
8898 }
8900 /* Remember whether we want to capture as a reference or not. */
8902 {
8905 }
8907 /* Get the identifier. */
8912 /* Would be nice to have a cp_parser_skip_to_closing_x for general
8913 delimiters, but I modified this to stop on unnested ']' as well. It
8914 was already changed to stop on unnested '}', so the
8915 "closing_parenthesis" name is no more misleading with my change. */
8916 {
8922 }
8924 /* Find the initializer for this capture. */
8928 {
8930 /* An explicit initializer exists. */
8933 "lambda capture initializers "
8939 {
8942 }
8943 }
8944 else
8945 {
8948 /* Turn the identifier into an id-expression. */
8949 capture_init_expr
8954 {
8957 }
8961 {
8964 capture_init_expr);
8967 }
8970 {
8973 capture_init_expr))
8976 }
8978 capture_init_expr
8979 = finish_id_expression
8981 capture_init_expr,
8995 {
8998 }
8999 else
9001 }
9005 {
9010 capture_id);
9014 "capture of %qD redundant with by-reference capture "
9016 }
9019 capture_id,
9020 capture_init_expr,
9022 explicit_init_p);
9023 }
9026 }
9028 /* Parse the (optional) middle of a lambda expression.
9030 lambda-declarator:
9031 < template-parameter-list [opt] >
9032 ( parameter-declaration-clause [opt] )
9033 attribute-specifier [opt]
9034 mutable [opt]
9035 exception-specification [opt]
9036 lambda-return-type-clause [opt]
9038 LAMBDA_EXPR is the current representation of the lambda expression. */
9040 static bool
9042 {
9043 /* 5.1.1.4 of the standard says:
9044 If a lambda-expression does not include a lambda-declarator, it is as if
9045 the lambda-declarator were ().
9046 This means an empty parameter list, no attributes, and no exception
9047 specification. */
9053 /* The template-parameter-list is optional, but must begin with
9054 an opening angle if present. */
9056 {
9059 "lambda templates are only available with "
9068 /* We just processed one more parameter list. */
9070 }
9072 /* The parameter-declaration-clause is optional (unless
9073 template-parameter-list was given), but must begin with an
9074 opening parenthesis if present. */
9076 {
9081 /* Parse parameters. */
9084 /* Default arguments shall not be specified in the
9085 parameter-declaration-clause of a lambda-declarator. */
9095 /* Parse optional `mutable' keyword. */
9097 {
9100 }
9102 /* Parse optional exception specification. */
9105 /* Parse optional trailing return type. */
9107 {
9111 }
9113 /* The function parameters must be in scope all the way until after the
9114 trailing-return-type in case of decltype. */
9116 }
9120 /* Create the function call operator.
9122 Messing with declarators like this is no uglier than building up the
9123 FUNCTION_DECL by hand, and this is less likely to get out of sync with
9124 other code. */
9125 {
9126 cp_decl_specifier_seq return_type_specs;
9128 tree fco;
9135 else
9136 /* Maybe we will deduce the return type later. */
9142 sfk_none);
9147 VIRT_SPEC_UNSPECIFIED,
9148 REF_QUAL_NONE,
9149 exception_spec,
9154 declarator,
9155 attributes);
9157 {
9160 /* Give the object parameter a different name. */
9164 }
9166 {
9170 }
9179 }
9180 }
9182 /* Parse the body of a lambda expression, which is simply
9184 compound-statement
9186 but which requires special handling.
9187 LAMBDA_EXPR is the current representation of the lambda expression. */
9189 static void
9191 {
9196 else
9197 /* Still increment function_depth so that we don't GC in the
9198 middle of an expression. */
9200 /* Clear this in case we're in the middle of a default argument. */
9203 /* Finish the function call operator
9204 - class_specifier
9205 + late_parsing_for_member
9206 + function_definition_after_declarator
9207 + ctor_initializer_opt_and_function_body */
9208 {
9210 tree body;
9212 tree compound_stmt;
9213 tree cap;
9215 /* Let the front end know that we are going to be defining this
9216 function. */
9218 NULL_TREE,
9227 /* Push the proxies for any explicit captures. */
9234 /* 5.1.1.4 of the standard says:
9235 If a lambda-expression does not include a trailing-return-type, it
9236 is as if the trailing-return-type denotes the following type:
9237 * if the compound-statement is of the form
9238 { return attribute-specifier [opt] expression ; }
9239 the type of the returned expression after lvalue-to-rvalue
9240 conversion (_conv.lval_ 4.1), array-to-pointer conversion
9241 (_conv.array_ 4.2), and function-to-pointer conversion
9242 (_conv.func_ 4.3);
9243 * otherwise, void. */
9245 /* In a lambda that has neither a lambda-return-type-clause
9246 nor a deducible form, errors should be reported for return statements
9247 in the body. Since we used void as the placeholder return type, parsing
9248 the body as usual will give such desired behavior. */
9252 {
9256 /* Parse tentatively in case there's more after the initial return
9257 statement. */
9268 {
9272 /* Will get error here if type not deduced yet. */
9276 }
9277 }
9280 {
9285 }
9289 out:
9293 /* Finish the function and generate code for it if necessary. */
9296 /* Only expand if the call op is not a template. */
9299 }
9304 else
9306 }
9308 /* Statements [gram.stmt.stmt] */
9310 /* Parse a statement.
9312 statement:
9313 labeled-statement
9314 expression-statement
9315 compound-statement
9316 selection-statement
9317 iteration-statement
9318 jump-statement
9319 declaration-statement
9320 try-block
9322 C++11:
9324 statement:
9325 labeled-statement
9326 attribute-specifier-seq (opt) expression-statement
9327 attribute-specifier-seq (opt) compound-statement
9328 attribute-specifier-seq (opt) selection-statement
9329 attribute-specifier-seq (opt) iteration-statement
9330 attribute-specifier-seq (opt) jump-statement
9331 declaration-statement
9332 attribute-specifier-seq (opt) try-block
9334 TM Extension:
9336 statement:
9337 atomic-statement
9339 IN_COMPOUND is true when the statement is nested inside a
9340 cp_parser_compound_statement; this matters for certain pragmas.
9342 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9343 is a (possibly labeled) if statement which is not enclosed in braces
9344 and has an else clause. This is used to implement -Wparentheses. */
9346 static void
9349 {
9354 restart:
9357 /* There is no statement yet. */
9363 /* In obj-c++, seeing '[[' might be the either the beginning of
9364 c++11 attributes, or a nested objc-message-expression. So
9365 let's parse the c++11 attributes tentatively. */
9369 {
9372 }
9374 /* Peek at the next token. */
9376 /* Remember the location of the first token in the statement. */
9378 /* If this is a keyword, then that will often determine what kind of
9379 statement we have. */
9381 {
9385 {
9388 /* Looks like a labeled-statement with a case label.
9389 Parse the label, and then use tail recursion to parse
9390 the statement. */
9415 {
9420 }
9421 else
9422 {
9426 }
9430 /* Objective-C++ exception-handling constructs. */
9444 /* This must be a namespace alias definition. */
9457 /* It might be a keyword like `int' that can start a
9458 declaration-statement. */
9460 }
9461 }
9463 {
9464 /* If the next token is a `:', then we are looking at a
9465 labeled-statement. */
9468 {
9469 /* Looks like a labeled-statement with an ordinary label.
9470 Parse the label, and then use tail recursion to parse
9471 the statement. */
9475 }
9476 }
9477 /* Anything that starts with a `{' must be a compound-statement. */
9480 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
9481 a statement all its own. */
9483 {
9484 /* Only certain OpenMP pragmas are attached to statements, and thus
9485 are considered statements themselves. All others are not. In
9486 the context of a compound, accept the pragma as a "statement" and
9487 return so that we can check for a close brace. Otherwise we
9488 require a real statement and must go back and read one. */
9494 }
9496 {
9499 }
9501 /* Everything else must be a declaration-statement or an
9502 expression-statement. Try for the declaration-statement
9503 first, unless we are looking at a `;', in which case we know that
9504 we have an expression-statement. */
9506 {
9508 {
9510 {
9511 /* Attributes should be parsed as part of the the
9512 declaration, so let's un-parse them. */
9515 }
9518 /* Try to parse the declaration-statement. */
9520 /* If that worked, we're done. */
9523 }
9524 /* Look for an expression-statement instead. */
9526 }
9528 /* Set the line number for the statement. */
9532 /* Note that for now, we don't do anything with c++11 statements
9533 parsed at this level. */
9536 OPT_Wattributes,
9538 }
9540 /* Parse the label for a labeled-statement, i.e.
9542 identifier :
9543 case constant-expression :
9544 default :
9546 GNU Extension:
9547 case constant-expression ... constant-expression : statement
9549 When a label is parsed without errors, the label is added to the
9550 parse tree by the finish_* functions, so this function doesn't
9551 have to return the label. */
9553 static void
9555 {
9560 /* The next token should be an identifier. */
9564 {
9567 }
9571 {
9573 {
9577 /* Consume the `case' token. */
9579 /* Parse the constant-expression. */
9582 NULL);
9586 {
9587 /* Consume the `...' token. */
9589 expr_hi =
9592 NULL);
9593 /* We don't need to emit warnings here, as the common code
9594 will do this for us. */
9595 }
9596 else
9601 else
9604 expr);
9605 }
9609 /* Consume the `default' token. */
9614 else
9619 /* Anything else must be an ordinary label. */
9622 }
9624 /* Require the `:' token. */
9627 /* An ordinary label may optionally be followed by attributes.
9628 However, this is only permitted if the attributes are then
9629 followed by a semicolon. This is because, for backward
9630 compatibility, when parsing
9631 lab: __attribute__ ((unused)) int i;
9632 we want the attribute to attach to "i", not "lab". */
9635 {
9636 tree attrs;
9643 ;
9644 else
9646 }
9652 }
9654 /* Parse an expression-statement.
9656 expression-statement:
9657 expression [opt] ;
9659 Returns the new EXPR_STMT -- or NULL_TREE if the expression
9660 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
9661 indicates whether this expression-statement is part of an
9662 expression statement. */
9664 static tree
9666 {
9670 /* If the next token is a ';', then there is no expression
9671 statement. */
9673 {
9677 {
9680 }
9681 }
9683 /* Give a helpful message for "A<T>::type t;" and the like. */
9686 {
9693 {
9694 /* A::A a; */
9699 }
9700 }
9702 /* Consume the final `;'. */
9707 /* This is the final expression statement of a statement
9708 expression. */
9714 }
9716 /* Parse a compound-statement.
9718 compound-statement:
9719 { statement-seq [opt] }
9721 GNU extension:
9723 compound-statement:
9724 { label-declaration-seq [opt] statement-seq [opt] }
9726 label-declaration-seq:
9727 label-declaration
9728 label-declaration-seq label-declaration
9730 Returns a tree representing the statement. */
9732 static tree
9735 {
9736 tree compound_stmt;
9738 /* Consume the `{'. */
9745 /* Begin the compound-statement. */
9747 /* If the next keyword is `__label__' we have a label declaration. */
9750 /* Parse an (optional) statement-seq. */
9752 /* Finish the compound-statement. */
9754 /* Consume the `}'. */
9758 }
9760 /* Parse an (optional) statement-seq.
9762 statement-seq:
9763 statement
9764 statement-seq [opt] statement */
9766 static void
9768 {
9769 /* Scan statements until there aren't any more. */
9771 {
9774 /* If we are looking at a `}', then we have run out of
9775 statements; the same is true if we have reached the end
9776 of file, or have stumbled upon a stray '@end'. */
9783 /* If we are in a compound statement and find 'else' then
9784 something went wrong. */
9786 {
9789 else
9790 {
9793 }
9794 }
9796 /* Parse the statement. */
9798 }
9799 }
9801 /* Parse a selection-statement.
9803 selection-statement:
9804 if ( condition ) statement
9805 if ( condition ) statement else statement
9806 switch ( condition ) statement
9808 Returns the new IF_STMT or SWITCH_STMT.
9810 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9811 is a (possibly labeled) if statement which is not enclosed in
9812 braces and has an else clause. This is used to implement
9813 -Wparentheses. */
9815 static tree
9817 {
9824 /* Peek at the next token. */
9827 /* See what kind of keyword it is. */
9830 {
9833 {
9834 tree statement;
9835 tree condition;
9837 /* Look for the `('. */
9839 {
9842 }
9844 /* Begin the selection-statement. */
9847 else
9850 /* Parse the condition. */
9852 /* Look for the `)'. */
9858 {
9862 /* Add the condition. */
9865 /* Parse the then-clause. */
9869 {
9877 }
9878 else
9884 /* If the next token is `else', parse the else-clause. */
9886 RID_ELSE))
9887 {
9888 /* Consume the `else' keyword. */
9891 /* Parse the else-clause. */
9893 {
9894 location_t loc;
9901 }
9902 else
9907 /* If we are currently parsing a then-clause, then
9908 IF_P will not be NULL. We set it to true to
9909 indicate that this if statement has an else clause.
9910 This may trigger the Wparentheses warning below
9911 when we get back up to the parent if statement. */
9914 }
9915 else
9916 {
9917 /* This if statement does not have an else clause. If
9918 NESTED_IF is true, then the then-clause is an if
9919 statement which does have an else clause. We warn
9920 about the potential ambiguity. */
9923 "suggest explicit braces to avoid ambiguous"
9925 }
9927 /* Now we're all done with the if-statement. */
9929 }
9930 else
9931 {
9935 /* Add the condition. */
9938 /* Parse the body of the switch-statement. */
9947 /* Now we're all done with the switch-statement. */
9949 }
9952 }
9958 }
9959 }
9961 /* Parse a condition.
9963 condition:
9964 expression
9965 type-specifier-seq declarator = initializer-clause
9966 type-specifier-seq declarator braced-init-list
9968 GNU Extension:
9970 condition:
9971 type-specifier-seq declarator asm-specification [opt]
9972 attributes [opt] = assignment-expression
9974 Returns the expression that should be tested. */
9976 static tree
9978 {
9979 cp_decl_specifier_seq type_specifiers;
9983 /* Try the declaration first. */
9985 /* New types are not allowed in the type-specifier-seq for a
9986 condition. */
9988 parser->type_definition_forbidden_message
9990 /* Parse the type-specifier-seq. */
9992 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
9995 /* Restore the saved message. */
9997 /* If all is well, we might be looking at a declaration. */
9999 {
10000 tree decl;
10001 tree asm_specification;
10002 tree attributes;
10006 /* Parse the declarator. */
10011 /* Parse the attributes. */
10013 /* Parse the asm-specification. */
10015 /* If the next token is not an `=' or '{', then we might still be
10016 looking at an expression. For example:
10018 if (A(a).x)
10020 looks like a decl-specifier-seq and a declarator -- but then
10021 there is no `=', so this is an expression. */
10026 /* If we did see an `=' or '{', then we are looking at a declaration
10027 for sure. */
10029 {
10030 tree pushed_scope;
10034 /* Create the declaration. */
10040 /* Parse the initializer. */
10042 {
10046 }
10047 else
10048 {
10049 /* Consume the `='. */
10052 }
10056 /* Process the initializer. */
10059 asm_specification,
10060 flags);
10066 }
10067 }
10068 /* If we didn't even get past the declarator successfully, we are
10069 definitely not looking at a declaration. */
10070 else
10073 /* Otherwise, we are looking at an expression. */
10075 }
10077 /* Parses a for-statement or range-for-statement until the closing ')',
10078 not included. */
10080 static tree
10082 {
10086 /* Begin the for-statement. */
10089 /* Parse the initialization. */
10094 else
10096 }
10098 static tree
10100 {
10101 /* Normal for loop */
10104 tree stmt;
10107 /* The for-init-statement has already been parsed in
10108 cp_parser_for_init_statement, so no work is needed here. */
10111 /* If there's a condition, process it. */
10115 {
10119 }
10121 /* Look for the `;'. */
10124 /* If there's an expression, process it. */
10130 }
10132 /* Tries to parse a range-based for-statement:
10134 range-based-for:
10135 decl-specifier-seq declarator : expression
10137 The decl-specifier-seq declarator and the `:' are already parsed by
10138 cp_parser_for_init_statement. If processing_template_decl it returns a
10139 newly created RANGE_FOR_STMT; if not, it is converted to a
10140 regular FOR_STMT. */
10142 static tree
10145 {
10149 {
10152 }
10153 else
10156 /* If in template, STMT is converted to a normal for-statement
10157 at instantiation. If not, it is done just ahead. */
10159 {
10167 /* do_auto_deduction doesn't mess with template init-lists. */
10170 }
10171 else
10172 {
10175 }
10177 }
10179 /* Subroutine of cp_convert_range_for: given the initializer expression,
10180 builds up the range temporary. */
10182 static tree
10184 {
10187 /* Find out the type deduced by the declaration
10188 `auto &&__range = range_expr'. */
10193 /* Create the __range variable. */
10200 }
10202 /* Used by cp_parser_range_for in template context: we aren't going to
10203 do a full conversion yet, but we still need to resolve auto in the
10204 type of the for-range-declaration if present. This is basically
10205 a shortcut version of cp_convert_range_for. */
10207 static void
10209 {
10212 {
10215 iter_type = (cp_parser_perform_range_for_lookup
10218 {
10220 iter_type);
10222 tf_warning_or_error);
10225 }
10226 }
10227 }
10229 /* Converts a range-based for-statement into a normal
10230 for-statement, as per the definition.
10232 for (RANGE_DECL : RANGE_EXPR)
10233 BLOCK
10235 should be equivalent to:
10237 {
10238 auto &&__range = RANGE_EXPR;
10239 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
10240 __begin != __end;
10241 ++__begin)
10242 {
10243 RANGE_DECL = *__begin;
10244 BLOCK
10245 }
10246 }
10248 If RANGE_EXPR is an array:
10249 BEGIN_EXPR = __range
10250 END_EXPR = __range + ARRAY_SIZE(__range)
10251 Else if RANGE_EXPR has a member 'begin' or 'end':
10252 BEGIN_EXPR = __range.begin()
10253 END_EXPR = __range.end()
10254 Else:
10255 BEGIN_EXPR = begin(__range)
10256 END_EXPR = end(__range);
10258 If __range has a member 'begin' but not 'end', or vice versa, we must
10259 still use the second alternative (it will surely fail, however).
10260 When calling begin()/end() in the third alternative we must use
10261 argument dependent lookup, but always considering 'std' as an associated
10262 namespace. */
10264 tree
10267 {
10273 /* If an error happened previously do nothing or else a lot of
10274 unhelpful errors would be issued. */
10276 else
10277 {
10278 tree range_temp;
10282 /* Can't bind a reference to an array of runtime bound. */
10284 else
10285 {
10290 LOOKUP_ONLYCONVERTING);
10292 }
10295 }
10297 /* The new for initialization statement. */
10305 LOOKUP_ONLYCONVERTING);
10314 LOOKUP_ONLYCONVERTING);
10318 /* The new for condition. */
10325 /* The new increment expression. */
10328 tf_warning_or_error);
10331 /* The declaration is initialized with *__begin inside the loop body. */
10334 tf_warning_or_error),
10336 LOOKUP_ONLYCONVERTING);
10339 }
10341 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
10342 We need to solve both at the same time because the method used
10343 depends on the existence of members begin or end.
10344 Returns the type deduced for the iterator expression. */
10346 static tree
10348 {
10350 {
10353 }
10356 {
10361 }
10363 {
10364 /* If RANGE is an array, we will use pointer arithmetic. */
10367 range,
10371 }
10372 else
10373 {
10374 /* If it is not an array, we must do a bit of magic. */
10384 tf_warning_or_error);
10387 tf_warning_or_error);
10390 {
10391 /* Use the member functions. */
10394 else
10400 else
10403 }
10404 else
10405 {
10406 /* Use global functions with ADL. */
10413 tf_warning_or_error);
10415 tf_warning_or_error);
10417 tf_warning_or_error);
10419 tf_warning_or_error);
10422 }
10424 /* Last common checks. */
10426 {
10427 /* If one of the expressions is an error do no more checks. */
10430 }
10433 /* Can happen, when, eg, in a template context, Koenig lookup
10434 can't resolve begin/end (c++/58503). */
10436 else
10437 {
10439 /* The unqualified type of the __begin and __end temporaries should
10440 be the same, as required by the multiple auto declaration. */
10446 }
10447 }
10448 }
10450 /* Helper function for cp_parser_perform_range_for_lookup.
10451 Builds a tree for RANGE.IDENTIFIER(). */
10453 static tree
10455 {
10468 tf_warning_or_error);
10471 }
10473 /* Parse an iteration-statement.
10475 iteration-statement:
10476 while ( condition ) statement
10477 do statement while ( expression ) ;
10478 for ( for-init-statement condition [opt] ; expression [opt] )
10479 statement
10481 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
10483 static tree
10485 {
10488 tree statement;
10491 /* Peek at the next token. */
10496 /* Remember whether or not we are already within an iteration
10497 statement. */
10500 /* See what kind of keyword it is. */
10503 {
10505 {
10506 tree condition;
10508 /* Begin the while-statement. */
10510 /* Look for the `('. */
10512 /* Parse the condition. */
10515 /* Look for the `)'. */
10517 /* Parse the dependent statement. */
10521 /* We're done with the while-statement. */
10523 }
10527 {
10528 tree expression;
10530 /* Begin the do-statement. */
10532 /* Parse the body of the do-statement. */
10537 /* Look for the `while' keyword. */
10539 /* Look for the `('. */
10541 /* Parse the expression. */
10543 /* We're done with the do-statement. */
10545 /* Look for the `)'. */
10547 /* Look for the `;'. */
10549 }
10553 {
10554 /* Look for the `('. */
10559 /* Look for the `)'. */
10562 /* Parse the body of the for-statement. */
10567 /* We're done with the for-statement. */
10569 }
10576 }
10579 }
10581 /* Parse a for-init-statement or the declarator of a range-based-for.
10582 Returns true if a range-based-for declaration is seen.
10584 for-init-statement:
10585 expression-statement
10586 simple-declaration */
10588 static bool
10590 {
10591 /* If the next token is a `;', then we have an empty
10592 expression-statement. Grammatically, this is also a
10593 simple-declaration, but an invalid one, because it does not
10594 declare anything. Therefore, if we did not handle this case
10595 specially, we would issue an error message about an invalid
10596 declaration. */
10598 {
10604 /* We're going to speculatively look for a declaration, falling back
10605 to an expression, if necessary. */
10607 /* Parse the declaration. */
10610 decl);
10613 {
10614 /* It is a range-for, consume the ':' */
10618 {
10620 "range-based %<for%> loops are not allowed "
10623 }
10624 }
10625 else
10626 /* The ';' is not consumed yet because we told
10627 cp_parser_simple_declaration not to. */
10632 /* If the tentative parse failed, then we shall need to look for an
10633 expression-statement. */
10634 }
10635 /* If we are here, it is an expression-statement. */
10638 }
10640 /* Parse a jump-statement.
10642 jump-statement:
10643 break ;
10644 continue ;
10645 return expression [opt] ;
10646 return braced-init-list ;
10647 goto identifier ;
10649 GNU extension:
10651 jump-statement:
10652 goto * expression ;
10654 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
10656 static tree
10658 {
10664 /* Peek at the next token. */
10669 /* See what kind of keyword it is. */
10672 {
10676 {
10696 }
10702 {
10709 /* Fall through. */
10719 }
10724 {
10725 tree expr;
10729 {
10733 }
10736 else
10737 /* If the next token is a `;', then there is no
10738 expression. */
10740 /* Build the return-statement. */
10742 /* Look for the final `;'. */
10744 }
10748 /* Create the goto-statement. */
10750 {
10751 /* Issue a warning about this use of a GNU extension. */
10753 /* Consume the '*' token. */
10755 /* Parse the dependent expression. */
10757 }
10758 else
10760 /* Look for the final `;'. */
10767 }
10770 }
10772 /* Parse a declaration-statement.
10774 declaration-statement:
10775 block-declaration */
10777 static void
10779 {
10782 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
10785 /* Parse the block-declaration. */
10788 /* Free any declarators allocated. */
10790 }
10792 /* Some dependent statements (like `if (cond) statement'), are
10793 implicitly in their own scope. In other words, if the statement is
10794 a single statement (as opposed to a compound-statement), it is
10795 none-the-less treated as if it were enclosed in braces. Any
10796 declarations appearing in the dependent statement are out of scope
10797 after control passes that point. This function parses a statement,
10798 but ensures that is in its own scope, even if it is not a
10799 compound-statement.
10801 If IF_P is not NULL, *IF_P is set to indicate whether the statement
10802 is a (possibly labeled) if statement which is not enclosed in
10803 braces and has an else clause. This is used to implement
10804 -Wparentheses.
10806 Returns the new statement. */
10808 static tree
10810 {
10811 tree statement;
10816 /* Mark if () ; with a special NOP_EXPR. */
10818 {
10822 }
10823 /* if a compound is opened, we simply parse the statement directly. */
10826 /* If the token is not a `{', then we must take special action. */
10827 else
10828 {
10829 /* Create a compound-statement. */
10831 /* Parse the dependent-statement. */
10833 /* Finish the dummy compound-statement. */
10835 }
10837 /* Return the statement. */
10839 }
10841 /* For some dependent statements (like `while (cond) statement'), we
10842 have already created a scope. Therefore, even if the dependent
10843 statement is a compound-statement, we do not want to create another
10844 scope. */
10846 static void
10848 {
10849 /* If the token is a `{', then we must take special action. */
10852 else
10853 {
10854 /* Avoid calling cp_parser_compound_statement, so that we
10855 don't create a new scope. Do everything else by hand. */
10857 /* If the next keyword is `__label__' we have a label declaration. */
10860 /* Parse an (optional) statement-seq. */
10863 }
10864 }
10866 /* Declarations [gram.dcl.dcl] */
10868 /* Parse an optional declaration-sequence.
10870 declaration-seq:
10871 declaration
10872 declaration-seq declaration */
10874 static void
10876 {
10878 {
10889 {
10890 /* A declaration consisting of a single semicolon is
10891 invalid. Allow it unless we're being pedantic. */
10896 }
10898 /* If we're entering or exiting a region that's implicitly
10899 extern "C", modify the lang context appropriately. */
10901 {
10904 }
10906 {
10909 }
10912 {
10913 /* A top-level declaration can consist solely of a #pragma.
10914 A nested declaration cannot, so this is done here and not
10915 in cp_parser_declaration. (A #pragma at block scope is
10916 handled in cp_parser_statement.) */
10919 }
10921 /* Parse the declaration itself. */
10923 }
10924 }
10926 /* Parse a declaration.
10928 declaration:
10929 block-declaration
10930 function-definition
10931 template-declaration
10932 explicit-instantiation
10933 explicit-specialization
10934 linkage-specification
10935 namespace-definition
10937 GNU extension:
10939 declaration:
10940 __extension__ declaration */
10942 static void
10944 {
10945 cp_token token1;
10946 cp_token token2;
10951 /* Check for the `__extension__' keyword. */
10953 {
10954 /* Parse the qualified declaration. */
10956 /* Restore the PEDANTIC flag. */
10960 }
10962 /* Try to figure out what kind of declaration is present. */
10967 else
10968 {
10971 }
10973 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
10976 /* If the next token is `extern' and the following token is a string
10977 literal, then we have a linkage specification. */
10981 /* If the next token is `template', then we have either a template
10982 declaration, an explicit instantiation, or an explicit
10983 specialization. */
10985 {
10986 /* `template <>' indicates a template specialization. */
10990 /* `template <' indicates a template declaration. */
10993 /* Anything else must be an explicit instantiation. */
10994 else
10996 }
10997 /* If the next token is `export', then we have a template
10998 declaration. */
11001 /* If the next token is `extern', 'static' or 'inline' and the one
11002 after that is `template', we have a GNU extended explicit
11003 instantiation directive. */
11010 /* If the next token is `namespace', check for a named or unnamed
11011 namespace definition. */
11017 /* An unnamed namespace definition. */
11021 /* An inline (associated) namespace definition. */
11025 /* Objective-C++ declaration/definition. */
11032 /* We must have either a block declaration or a function
11033 definition. */
11034 else
11035 /* Try to parse a block-declaration, or a function-definition. */
11038 /* Free any declarators allocated. */
11040 }
11042 /* Parse a block-declaration.
11044 block-declaration:
11045 simple-declaration
11046 asm-definition
11047 namespace-alias-definition
11048 using-declaration
11049 using-directive
11051 GNU Extension:
11053 block-declaration:
11054 __extension__ block-declaration
11056 C++0x Extension:
11058 block-declaration:
11059 static_assert-declaration
11061 If STATEMENT_P is TRUE, then this block-declaration is occurring as
11062 part of a declaration-statement. */
11064 static void
11067 {
11071 /* Check for the `__extension__' keyword. */
11073 {
11074 /* Parse the qualified declaration. */
11076 /* Restore the PEDANTIC flag. */
11080 }
11082 /* Peek at the next token to figure out which kind of declaration is
11083 present. */
11086 /* If the next keyword is `asm', we have an asm-definition. */
11088 {
11092 }
11093 /* If the next keyword is `namespace', we have a
11094 namespace-alias-definition. */
11097 /* If the next keyword is `using', we have a
11098 using-declaration, a using-directive, or an alias-declaration. */
11100 {
11105 /* If the token after `using' is `namespace', then we have a
11106 using-directive. */
11110 /* If the second token after 'using' is '=', then we have an
11111 alias-declaration. */
11117 /* Otherwise, it's a using-declaration. */
11118 else
11121 }
11122 /* If the next keyword is `__label__' we have a misplaced label
11123 declaration. */
11125 {
11129 /* If the next token is now a `;', consume it. */
11132 }
11133 /* If the next token is `static_assert' we have a static assertion. */
11136 /* Anything else must be a simple-declaration. */
11137 else
11140 }
11142 /* Parse a simple-declaration.
11144 simple-declaration:
11145 decl-specifier-seq [opt] init-declarator-list [opt] ;
11147 init-declarator-list:
11148 init-declarator
11149 init-declarator-list , init-declarator
11151 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
11152 function-definition as a simple-declaration.
11154 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
11155 parsed declaration if it is an uninitialized single declarator not followed
11156 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
11157 if present, will not be consumed. */
11159 static void
11163 {
11164 cp_decl_specifier_seq decl_specifiers;
11171 /* Defer access checks until we know what is being declared; the
11172 checks for names appearing in the decl-specifier-seq should be
11173 done as if we were in the scope of the thing being declared. */
11176 /* Parse the decl-specifier-seq. We have to keep track of whether
11177 or not the decl-specifier-seq declares a named class or
11178 enumeration type, since that is the only case in which the
11179 init-declarator-list is allowed to be empty.
11181 [dcl.dcl]
11183 In a simple-declaration, the optional init-declarator-list can be
11184 omitted only when declaring a class or enumeration, that is when
11185 the decl-specifier-seq contains either a class-specifier, an
11186 elaborated-type-specifier, or an enum-specifier. */
11188 CP_PARSER_FLAGS_OPTIONAL,
11191 /* We no longer need to defer access checks. */
11194 /* In a block scope, a valid declaration must always have a
11195 decl-specifier-seq. By not trying to parse declarators, we can
11196 resolve the declaration/expression ambiguity more quickly. */
11199 {
11202 }
11204 /* If the next two tokens are both identifiers, the code is
11205 erroneous. The usual cause of this situation is code like:
11207 T t;
11209 where "T" should name a type -- but does not. */
11212 {
11213 /* If parsing tentatively, we should commit; we really are
11214 looking at a declaration. */
11216 /* Give up. */
11218 }
11220 /* If we have seen at least one decl-specifier, and the next token
11221 is not a parenthesis, then we must be looking at a declaration.
11222 (After "int (" we might be looking at a functional cast.) */
11229 /* Keep going until we hit the `;' at the end of the simple
11230 declaration. */
11233 CPP_SEMICOLON))
11234 {
11237 tree decl;
11240 {
11241 /* If we are processing next declarator, coma is expected */
11247 }
11248 else
11251 /* Parse the init-declarator. */
11254 function_definition_allowed_p,
11256 declares_class_or_enum,
11258 maybe_range_for_decl);
11259 /* If an error occurred while parsing tentatively, exit quickly.
11260 (That usually happens when in the body of a function; each
11261 statement is treated as a declaration-statement until proven
11262 otherwise.) */
11265 /* Handle function definitions specially. */
11267 {
11268 /* If the next token is a `,', then we are probably
11269 processing something like:
11271 void f() {}, *p;
11273 which is erroneous. */
11275 {
11278 "mixing"
11280 }
11281 /* Otherwise, we're done with the list of declarators. */
11282 else
11283 {
11286 }
11287 }
11290 /* The next token should be either a `,' or a `;'. */
11292 /* If it's a `,', there are more declarators to come. */
11295 /* If it's a `;', we are done. */
11298 /* Anything else is an error. */
11299 else
11300 {
11301 /* If we have already issued an error message we don't need
11302 to issue another one. */
11306 /* Skip tokens until we reach the end of the statement. */
11308 /* If the next token is now a `;', consume it. */
11312 }
11313 /* After the first time around, a function-definition is not
11314 allowed -- even if it was OK at first. For example:
11316 int i, f() {}
11318 is not valid. */
11320 }
11322 /* Issue an error message if no declarators are present, and the
11323 decl-specifier-seq does not itself declare a class or
11324 enumeration: [dcl.dcl]/3. */
11326 {
11328 {
11332 /* Ensure an error is issued anyway when finish_decltype_type,
11333 called via cp_parser_decl_specifier_seq, returns a class or
11334 an enumeration (c++/51786). */
11337 }
11338 /* Perform any deferred access checks. */
11340 }
11342 /* Consume the `;'. */
11346 done:
11348 }
11350 /* Parse a decl-specifier-seq.
11352 decl-specifier-seq:
11353 decl-specifier-seq [opt] decl-specifier
11354 decl-specifier attribute-specifier-seq [opt] (C++11)
11356 decl-specifier:
11357 storage-class-specifier
11358 type-specifier
11359 function-specifier
11360 friend
11361 typedef
11363 GNU Extension:
11365 decl-specifier:
11366 attributes
11368 Set *DECL_SPECS to a representation of the decl-specifier-seq.
11370 The parser flags FLAGS is used to control type-specifier parsing.
11372 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
11373 flags:
11375 1: one of the decl-specifiers is an elaborated-type-specifier
11376 (i.e., a type declaration)
11377 2: one of the decl-specifiers is an enum-specifier or a
11378 class-specifier (i.e., a type definition)
11380 */
11382 static void
11384 cp_parser_flags flags,
11387 {
11391 cp_decl_spec ds;
11393 /* Clear DECL_SPECS. */
11396 /* Assume no class or enumeration type is declared. */
11399 /* Keep reading specifiers until there are no more to read. */
11401 {
11406 /* Peek at the next token. */
11409 /* Save the first token of the decl spec list for error
11410 reporting. */
11413 /* Handle attributes. */
11415 {
11416 /* Parse the attributes. */
11419 /* In a sequence of declaration specifiers, c++11 attributes
11420 appertain to the type that precede them. In that case
11421 [dcl.spec]/1 says:
11423 The attribute-specifier-seq affects the type only for
11424 the declaration it appears in, not other declarations
11425 involving the same type.
11427 But for now let's force the user to position the
11428 attribute either at the beginning of the declaration or
11429 after the declarator-id, which would clearly mean that it
11430 applies to the declarator. */
11432 {
11434 /* The c++11 attribute is at the beginning of the
11435 declaration. It appertains to the entity being
11437 else
11438 {
11440 {
11441 /* This is an attribute following a
11442 class-specifier. */
11447 }
11448 else
11449 {
11450 decl_specs->std_attributes
11452 attrs);
11455 }
11457 }
11458 }
11460 decl_specs->attributes
11462 attrs);
11466 }
11467 /* Assume we will find a decl-specifier keyword. */
11469 /* If the next token is an appropriate keyword, we can simply
11470 add it to the list. */
11472 {
11473 /* decl-specifier:
11474 friend
11475 constexpr */
11478 {
11481 }
11482 else
11483 {
11485 /* Consume the token. */
11487 }
11495 /* function-specifier:
11496 inline
11497 virtual
11498 explicit */
11505 /* decl-specifier:
11506 typedef */
11509 /* Consume the token. */
11511 /* A constructor declarator cannot appear in a typedef. */
11513 /* The "typedef" keyword can only occur in a declaration; we
11514 may as well commit at this point. */
11521 /* storage-class-specifier:
11522 auto
11523 register
11524 static
11525 extern
11526 mutable
11528 GNU Extension:
11529 thread */
11532 {
11533 /* Consume the token. */
11536 /* Complain about `auto' as a storage specifier, if
11537 we're complaining about C++0x compatibility. */
11541 /* Set the storage class anyway. */
11543 token);
11544 }
11545 else
11546 /* C++0x auto type-specifier. */
11554 /* Consume the token. */
11557 token);
11560 /* Consume the token. */
11566 /* We did not yet find a decl-specifier yet. */
11569 }
11579 /* Constructors are a special case. The `S' in `S()' is not a
11580 decl-specifier; it is the beginning of the declarator. */
11581 constructor_p
11582 = (!found_decl_spec
11583 && constructor_possible_p
11584 && (cp_parser_constructor_declarator_p
11587 /* If we don't have a DECL_SPEC yet, then we must be looking at
11588 a type-specifier. */
11590 {
11593 tree type_spec;
11595 type_spec
11597 decl_specs,
11603 /* If this type-specifier referenced a user-defined type
11604 (a typedef, class-name, etc.), then we can't allow any
11605 more such type-specifiers henceforth.
11607 [dcl.spec]
11609 The longest sequence of decl-specifiers that could
11610 possibly be a type name is taken as the
11611 decl-specifier-seq of a declaration. The sequence shall
11612 be self-consistent as described below.
11614 [dcl.type]
11616 As a general rule, at most one type-specifier is allowed
11617 in the complete decl-specifier-seq of a declaration. The
11618 only exceptions are the following:
11620 -- const or volatile can be combined with any other
11621 type-specifier.
11623 -- signed or unsigned can be combined with char, long,
11624 short, or int.
11626 -- ..
11628 Example:
11630 typedef char* Pc;
11631 void g (const int Pc);
11633 Here, Pc is *not* part of the decl-specifier seq; it's
11634 the declarator. Therefore, once we see a type-specifier
11635 (other than a cv-qualifier), we forbid any additional
11636 user-defined types. We *do* still allow things like `int
11637 int' to be considered a decl-specifier-seq, and issue the
11638 error message later. */
11641 /* A constructor declarator cannot follow a type-specifier. */
11643 {
11648 }
11649 }
11651 /* If we still do not have a DECL_SPEC, then there are no more
11652 decl-specifiers. */
11657 /* After we see one decl-specifier, further decl-specifiers are
11658 always optional. */
11660 }
11662 /* Don't allow a friend specifier with a class definition. */
11667 }
11669 /* Parse an (optional) storage-class-specifier.
11671 storage-class-specifier:
11672 auto
11673 register
11674 static
11675 extern
11676 mutable
11678 GNU Extension:
11680 storage-class-specifier:
11681 thread
11683 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
11685 static tree
11687 {
11689 {
11693 /* Fall through for C++98. */
11700 /* Consume the token. */
11705 }
11706 }
11708 /* Parse an (optional) function-specifier.
11710 function-specifier:
11711 inline
11712 virtual
11713 explicit
11715 Returns an IDENTIFIER_NODE corresponding to the keyword used.
11716 Updates DECL_SPECS, if it is non-NULL. */
11718 static tree
11721 {
11724 {
11730 /* 14.5.2.3 [temp.mem]
11732 A member function template shall not be virtual. */
11735 else
11745 }
11747 /* Consume the token. */
11749 }
11751 /* Parse a linkage-specification.
11753 linkage-specification:
11754 extern string-literal { declaration-seq [opt] }
11755 extern string-literal declaration */
11757 static void
11759 {
11760 tree linkage;
11762 /* Look for the `extern' keyword. */
11765 /* Look for the string-literal. */
11768 /* Transform the literal into an identifier. If the literal is a
11769 wide-character string, or contains embedded NULs, then we can't
11770 handle it as the user wants. */
11773 {
11775 /* Assume C++ linkage. */
11777 }
11778 else
11781 /* We're now using the new linkage. */
11784 /* If the next token is a `{', then we're using the first
11785 production. */
11787 {
11790 /* Consume the `{' token. */
11792 /* Parse the declarations. */
11794 /* Look for the closing `}'. */
11796 }
11797 /* Otherwise, there's just one declaration. */
11798 else
11799 {
11802 saved_in_unbraced_linkage_specification_p
11806 parser->in_unbraced_linkage_specification_p
11808 }
11810 /* We're done with the linkage-specification. */
11812 }
11814 /* Parse a static_assert-declaration.
11816 static_assert-declaration:
11817 static_assert ( constant-expression , string-literal ) ;
11819 If MEMBER_P, this static_assert is a class member. */
11821 static void
11823 {
11824 tree condition;
11825 tree message;
11827 location_t saved_loc;
11830 /* Peek at the `static_assert' token so we can keep track of exactly
11831 where the static assertion started. */
11835 /* Look for the `static_assert' keyword. */
11837 RT_STATIC_ASSERT))
11840 /* We know we are in a static assertion; commit to any tentative
11841 parse. */
11845 /* Parse the `(' starting the static assertion condition. */
11848 /* Parse the constant-expression. Allow a non-constant expression
11849 here in order to give better diagnostics in finish_static_assert. */
11850 condition =
11855 /* Parse the separating `,'. */
11858 /* Parse the string-literal message. */
11863 /* A `)' completes the static assertion. */
11870 /* A semicolon terminates the declaration. */
11873 /* Complete the static assertion, which may mean either processing
11874 the static assert now or saving it for template instantiation. */
11876 }
11878 /* Parse the expression in decltype ( expression ). */
11880 static tree
11883 {
11885 tree expr;
11887 /* First, try parsing an id-expression. */
11898 {
11901 cp_id_kind idk;
11905 /* Lookup the name we got back from the id-expression. */
11916 {
11917 /* Complete lookup of the id-expression. */
11918 expr = (finish_id_expression
11931 /* We found an id-expression, but it was something that we
11932 should not have found. This is an error, not something
11933 we can recover from, so note that we found an
11934 id-expression and we'll recover as gracefully as
11935 possible. */
11937 }
11942 /* We have an id-expression. */
11944 }
11947 {
11948 /* Abort the id-expression parse. */
11951 /* Parsing tentatively, again. */
11954 /* Parse a class member access. */
11962 /* We have an id-expression. */
11964 }
11967 /* We have parsed the complete id-expression or member access. */
11969 else
11970 {
11971 /* Abort our attempt to parse an id-expression or member access
11972 expression. */
11975 /* Parse a full expression. */
11978 }
11981 }
11983 /* Parse a `decltype' type. Returns the type.
11985 simple-type-specifier:
11986 decltype ( expression )
11987 C++14 proposal:
11988 decltype ( auto ) */
11990 static tree
11992 {
11993 tree expr;
12002 {
12003 /* Already parsed. */
12006 }
12008 /* Look for the `decltype' token. */
12012 /* Parse the opening `('. */
12016 /* decltype (auto) */
12019 {
12026 }
12028 /* Types cannot be defined in a `decltype' expression. Save away the
12029 old message. */
12032 /* And create the new one. */
12033 parser->type_definition_forbidden_message
12036 /* The restrictions on constant-expressions do not apply inside
12037 decltype expressions. */
12038 saved_integral_constant_expression_p
12040 saved_non_integral_constant_expression_p
12044 /* Within a parenthesized expression, a `>' token is always
12045 the greater-than operator. */
12046 saved_greater_than_is_operator_p
12050 /* Do not actually evaluate the expression. */
12053 /* Do not warn about problems with the expression. */
12058 /* Go back to evaluating expressions. */
12062 /* The `>' token might be the end of a template-id or
12063 template-parameter-list now. */
12064 parser->greater_than_is_operator_p
12067 /* Restore the old message and the integral constant expression
12068 flags. */
12070 parser->integral_constant_expression_p
12072 parser->non_integral_constant_expression_p
12075 /* Parse to the closing `)'. */
12077 {
12081 }
12084 tf_warning_or_error);
12086 rewrite:
12087 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
12088 it again. */
12095 }
12097 /* Special member functions [gram.special] */
12099 /* Parse a conversion-function-id.
12101 conversion-function-id:
12102 operator conversion-type-id
12104 Returns an IDENTIFIER_NODE representing the operator. */
12106 static tree
12108 {
12109 tree type;
12110 tree saved_scope;
12111 tree saved_qualifying_scope;
12112 tree saved_object_scope;
12115 /* Look for the `operator' token. */
12118 /* When we parse the conversion-type-id, the current scope will be
12119 reset. However, we need that information in able to look up the
12120 conversion function later, so we save it here. */
12124 /* We must enter the scope of the class so that the names of
12125 entities declared within the class are available in the
12126 conversion-type-id. For example, consider:
12128 struct S {
12129 typedef int I;
12130 operator I();
12131 };
12133 S::operator I() { ... }
12135 In order to see that `I' is a type-name in the definition, we
12136 must be in the scope of `S'. */
12139 /* Parse the conversion-type-id. */
12141 /* Leave the scope of the class, if any. */
12144 /* Restore the saved scope. */
12148 /* If the TYPE is invalid, indicate failure. */
12152 }
12154 /* Parse a conversion-type-id:
12156 conversion-type-id:
12157 type-specifier-seq conversion-declarator [opt]
12159 Returns the TYPE specified. */
12161 static tree
12163 {
12164 tree attributes;
12165 cp_decl_specifier_seq type_specifiers;
12167 tree type_specified;
12170 /* Parse the attributes. */
12174 parser->type_definition_forbidden_message
12177 /* Parse the type-specifiers. */
12184 /* If that didn't work, stop. */
12187 /* Parse the conversion-declarator. */
12195 /* Don't give this error when parsing tentatively. This happens to
12196 work because we always parse this definitively once. */
12199 {
12201 {
12204 }
12208 }
12211 }
12213 /* Parse an (optional) conversion-declarator.
12215 conversion-declarator:
12216 ptr-operator conversion-declarator [opt]
12218 */
12222 {
12225 cp_cv_quals cv_quals;
12227 /* We don't know if there's a ptr-operator next, or not. */
12229 /* Try the ptr-operator. */
12232 /* If it worked, look for more conversion-declarators. */
12234 {
12237 /* Parse another optional declarator. */
12240 declarator = cp_parser_make_indirect_declarator
12244 }
12247 }
12249 /* Parse an (optional) ctor-initializer.
12251 ctor-initializer:
12252 : mem-initializer-list
12254 Returns TRUE iff the ctor-initializer was actually present. */
12256 static bool
12258 {
12259 /* If the next token is not a `:', then there is no
12260 ctor-initializer. */
12262 {
12263 /* Do default initialization of any bases and members. */
12268 }
12270 /* Consume the `:' token. */
12272 /* And the mem-initializer-list. */
12276 }
12278 /* Parse a mem-initializer-list.
12280 mem-initializer-list:
12281 mem-initializer ... [opt]
12282 mem-initializer ... [opt] , mem-initializer-list */
12284 static void
12286 {
12291 /* Let the semantic analysis code know that we are starting the
12292 mem-initializer-list. */
12297 /* Loop through the list. */
12299 {
12300 tree mem_initializer;
12303 /* Parse the mem-initializer. */
12305 /* If the next token is a `...', we're expanding member initializers. */
12307 {
12308 /* Consume the `...'. */
12311 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
12312 can be expanded but members cannot. */
12315 {
12320 }
12322 /* Construct the pack expansion type. */
12325 }
12328 {
12332 }
12333 /* Look for a target constructor. */
12337 {
12340 {
12344 }
12346 }
12347 /* Add it to the list, unless it was erroneous. */
12349 {
12352 }
12353 /* If the next token is not a `,', we're done. */
12356 /* Consume the `,' token. */
12358 }
12360 /* Perform semantic analysis. */
12363 }
12365 /* Parse a mem-initializer.
12367 mem-initializer:
12368 mem-initializer-id ( expression-list [opt] )
12369 mem-initializer-id braced-init-list
12371 GNU extension:
12373 mem-initializer:
12374 ( expression-list [opt] )
12376 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
12377 class) or FIELD_DECL (for a non-static data member) to initialize;
12378 the TREE_VALUE is the expression-list. An empty initialization
12379 list is represented by void_list_node. */
12381 static tree
12383 {
12384 tree mem_initializer_id;
12385 tree expression_list;
12386 tree member;
12389 /* Find out what is being initialized. */
12391 {
12395 }
12396 else
12397 {
12401 }
12407 {
12414 }
12415 else
12416 {
12426 }
12436 }
12438 /* Parse a mem-initializer-id.
12440 mem-initializer-id:
12441 :: [opt] nested-name-specifier [opt] class-name
12442 identifier
12444 Returns a TYPE indicating the class to be initializer for the first
12445 production. Returns an IDENTIFIER_NODE indicating the data member
12446 to be initialized for the second production. */
12448 static tree
12450 {
12454 tree id;
12458 /* `typename' is not allowed in this context ([temp.res]). */
12460 {
12462 "keyword %<typename%> not allowed in this context (a qualified "
12465 }
12466 /* Look for the optional `::' operator. */
12467 global_scope_p
12471 /* Look for the optional nested-name-specifier. The simplest way to
12472 implement:
12474 [temp.res]
12476 The keyword `typename' is not permitted in a base-specifier or
12477 mem-initializer; in these contexts a qualified name that
12478 depends on a template-parameter is implicitly assumed to be a
12479 type name.
12481 is to assume that we have seen the `typename' keyword at this
12482 point. */
12483 nested_name_specifier_p
12492 /* If there is a `::' operator or a nested-name-specifier, then we
12493 are definitely looking for a class-name. */
12498 typename_type,
12502 /* Otherwise, we could also be looking for an ordinary identifier. */
12504 /* Try a class-name. */
12508 none_type,
12512 /* If we found one, we're done. */
12515 /* Otherwise, look for an ordinary identifier. */
12517 }
12519 /* Overloading [gram.over] */
12521 /* Parse an operator-function-id.
12523 operator-function-id:
12524 operator operator
12526 Returns an IDENTIFIER_NODE for the operator which is a
12527 human-readable spelling of the identifier, e.g., `operator +'. */
12529 static tree
12531 {
12532 /* Look for the `operator' keyword. */
12535 /* And then the name of the operator itself. */
12537 }
12539 /* Return an identifier node for a user-defined literal operator.
12540 The suffix identifier is chained to the operator name identifier. */
12542 static tree
12544 {
12545 tree identifier;
12552 }
12554 /* Parse an operator.
12556 operator:
12557 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
12558 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
12559 || ++ -- , ->* -> () []
12561 GNU Extensions:
12563 operator:
12564 <? >? <?= >?=
12566 Returns an IDENTIFIER_NODE for the operator which is a
12567 human-readable spelling of the identifier, e.g., `operator +'. */
12569 static tree
12571 {
12576 /* Peek at the next token. */
12578 /* Figure out which operator we have. */
12580 {
12582 {
12585 /* The keyword should be either `new' or `delete'. */
12590 else
12593 /* Consume the `new' or `delete' token. */
12596 /* Peek at the next token. */
12598 /* If it's a `[' token then this is the array variant of the
12599 operator. */
12601 {
12602 /* Consume the `[' token. */
12604 /* Look for the `]' token. */
12608 }
12609 /* Otherwise, we have the non-array variant. */
12610 else
12614 }
12761 /* Consume the `('. */
12763 /* Look for the matching `)'. */
12768 /* Consume the `['. */
12770 /* Look for the matching `]'. */
12779 /* Fall through. */
12785 {
12788 }
12790 {
12793 }
12794 /* Consume the string. */
12796 /* Look for the suffix identifier. */
12799 {
12802 {
12805 }
12806 }
12808 {
12812 }
12813 else
12814 {
12817 }
12824 /* Fall through. */
12830 {
12833 }
12834 {
12837 {
12840 }
12842 /* Consume the user-defined string literal. */
12845 {
12848 }
12849 else
12851 }
12854 /* Anything else is an error. */
12856 }
12858 /* If we have selected an identifier, we need to consume the
12859 operator token. */
12862 /* Otherwise, no valid operator name was present. */
12863 else
12864 {
12867 }
12870 }
12872 /* Parse a template-declaration.
12874 template-declaration:
12875 export [opt] template < template-parameter-list > declaration
12877 If MEMBER_P is TRUE, this template-declaration occurs within a
12878 class-specifier.
12880 The grammar rule given by the standard isn't correct. What
12881 is really meant is:
12883 template-declaration:
12884 export [opt] template-parameter-list-seq
12885 decl-specifier-seq [opt] init-declarator [opt] ;
12886 export [opt] template-parameter-list-seq
12887 function-definition
12889 template-parameter-list-seq:
12890 template-parameter-list-seq [opt]
12891 template < template-parameter-list > */
12893 static void
12895 {
12896 /* Check for `export'. */
12898 {
12899 /* Consume the `export' token. */
12901 /* Warn that we do not support `export'. */
12903 }
12906 }
12908 /* Parse a template-parameter-list.
12910 template-parameter-list:
12911 template-parameter
12912 template-parameter-list , template-parameter
12914 Returns a TREE_LIST. Each node represents a template parameter.
12915 The nodes are connected via their TREE_CHAINs. */
12917 static tree
12919 {
12924 /* The loop below parses the template parms. We first need to know
12925 the total number of template parms to be able to compute proper
12926 canonical types of each dependent type. So after the loop, when
12927 we know the total number of template parms,
12928 end_template_parm_list computes the proper canonical types and
12929 fixes up the dependent types accordingly. */
12931 {
12932 tree parameter;
12935 location_t parm_loc;
12937 /* Parse the template-parameter. */
12942 /* Add it to the list. */
12945 parm_loc,
12946 parameter,
12947 is_non_type,
12948 is_parameter_pack);
12949 else
12950 {
12953 }
12955 /* If the next token is not a `,', we're done. */
12958 /* Otherwise, consume the `,' token. */
12960 }
12963 }
12965 /* Parse a template-parameter.
12967 template-parameter:
12968 type-parameter
12969 parameter-declaration
12971 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
12972 the parameter. The TREE_PURPOSE is the default value, if any.
12973 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
12974 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
12975 set to true iff this parameter is a parameter pack. */
12977 static tree
12980 {
12984 tree parm;
12986 /* Assume it is a type parameter or a template parameter. */
12988 /* Assume it not a parameter pack. */
12990 /* Peek at the next token. */
12992 /* If it is `class' or `template', we have a type-parameter. */
12995 /* If it is `class' or `typename' we do not know yet whether it is a
12996 type parameter or a non-type parameter. Consider:
12998 template <typename T, typename T::X X> ...
13000 or:
13002 template <class C, class D*> ...
13004 Here, the first parameter is a type parameter, and the second is
13005 a non-type parameter. We can tell by looking at the token after
13006 the identifier -- if it is a `,', `=', or `>' then we have a type
13007 parameter. */
13009 {
13010 /* Peek at the token after `class' or `typename'. */
13012 /* If it's an ellipsis, we have a template type parameter
13013 pack. */
13016 /* If it's an identifier, skip it. */
13019 /* Now, see if the token looks like the end of a template
13020 parameter. */
13025 }
13027 /* Otherwise, it is a non-type parameter.
13029 [temp.param]
13031 When parsing a default template-argument for a non-type
13032 template-parameter, the first non-nested `>' is taken as the end
13033 of the template parameter-list rather than a greater-than
13034 operator. */
13036 parameter_declarator
13043 /* If the parameter declaration is marked as a parameter pack, set
13044 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
13045 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
13046 grokdeclarator. */
13049 {
13052 }
13055 {
13056 /* Can happen in some cases of erroneous input (c++/34892). */
13058 /* Consume the `...' for better error recovery. */
13060 }
13061 /* If the next token is an ellipsis, and we don't already have it
13062 marked as a parameter pack, then we have a parameter pack (that
13063 has no declarator). */
13066 && (declarator_can_be_parameter_pack
13068 {
13069 /* Consume the `...'. */
13074 }
13075 /* We might end up with a pack expansion as the type of the non-type
13076 template parameter, in which case this is a non-type template
13077 parameter pack. */
13080 {
13084 }
13087 {
13088 /* Parameter packs cannot have default arguments. However, a
13089 user may try to do so, so we'll parse them and give an
13090 appropriate diagnostic here. */
13094 /* Find the name of the parameter pack. */
13103 else
13107 /* Parse the default argument, but throw away the result. */
13109 }
13119 }
13121 /* Parse a type-parameter.
13123 type-parameter:
13124 class identifier [opt]
13125 class identifier [opt] = type-id
13126 typename identifier [opt]
13127 typename identifier [opt] = type-id
13128 template < template-parameter-list > class identifier [opt]
13129 template < template-parameter-list > class identifier [opt]
13130 = id-expression
13132 GNU Extension (variadic templates):
13134 type-parameter:
13135 class ... identifier [opt]
13136 typename ... identifier [opt]
13138 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
13139 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
13140 the declaration of the parameter.
13142 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
13144 static tree
13146 {
13148 tree parameter;
13150 /* Look for a keyword to tell us what kind of parameter this is. */
13156 {
13159 {
13160 tree identifier;
13161 tree default_argument;
13163 /* If the next token is an ellipsis, we have a template
13164 argument pack. */
13166 {
13167 /* Consume the `...' token. */
13172 }
13174 /* If the next token is an identifier, then it names the
13175 parameter. */
13178 else
13181 /* Create the parameter. */
13184 /* If the next token is an `=', we have a default argument. */
13186 {
13187 /* Consume the `=' token. */
13189 /* Parse the default-argument. */
13193 /* Template parameter packs cannot have default
13194 arguments. */
13196 {
13199 "template parameter pack %qD cannot have a "
13201 else
13203 "template parameter packs cannot have "
13206 }
13208 }
13209 else
13212 /* Create the combined representation of the parameter and the
13213 default argument. */
13215 }
13219 {
13220 tree identifier;
13221 tree default_argument;
13223 /* Look for the `<'. */
13225 /* Parse the template-parameter-list. */
13227 /* Look for the `>'. */
13229 /* Look for the `class' keyword. */
13231 /* If the next token is an ellipsis, we have a template
13232 argument pack. */
13234 {
13235 /* Consume the `...' token. */
13240 }
13241 /* If the next token is an `=', then there is a
13242 default-argument. If the next token is a `>', we are at
13243 the end of the parameter-list. If the next token is a `,',
13244 then we are at the end of this parameter. */
13248 {
13250 /* Treat invalid names as if the parameter were nameless. */
13253 }
13254 else
13257 /* Create the template parameter. */
13259 identifier);
13261 /* If the next token is an `=', then there is a
13262 default-argument. */
13264 {
13267 /* Consume the `='. */
13269 /* Parse the id-expression. */
13271 /* save token before parsing the id-expression, for error
13272 reporting */
13274 default_argument
13282 /* If the id-expression was a template-id that refers to
13283 a template-class, we already have the declaration here,
13284 so no further lookup is needed. */
13285 ;
13286 else
13287 /* Look up the name. */
13288 default_argument
13290 none_type,
13296 /* See if the default argument is valid. */
13297 default_argument
13300 /* Template parameter packs cannot have default
13301 arguments. */
13303 {
13306 "template parameter pack %qD cannot "
13308 identifier);
13309 else
13313 }
13315 }
13316 else
13319 /* Create the combined representation of the parameter and the
13320 default argument. */
13322 }
13328 }
13331 }
13333 /* Parse a template-id.
13335 template-id:
13336 template-name < template-argument-list [opt] >
13338 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
13339 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
13340 returned. Otherwise, if the template-name names a function, or set
13341 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
13342 names a class, returns a TYPE_DECL for the specialization.
13344 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
13345 uninstantiated templates. */
13347 static tree
13353 {
13355 tree templ;
13356 tree arguments;
13357 tree template_id;
13364 /* If the next token corresponds to a template-id, there is no need
13365 to reparse it. */
13368 {
13371 /* Get the stored value. */
13373 /* Perform any access checks that were deferred. */
13376 {
13381 tf_warning_or_error);
13382 }
13383 /* Return the stored value. */
13385 }
13387 /* Avoid performing name lookup if there is no possibility of
13388 finding a template-id. */
13391 && !cp_parser_nth_token_starts_template_argument_list_p
13393 {
13396 }
13398 /* Remember where the template-id starts. */
13404 /* Parse the template-name. */
13407 check_dependency_p,
13408 is_declaration,
13409 tag_type,
13412 {
13415 }
13417 /* If we find the sequence `[:' after a template-name, it's probably
13418 a digraph-typo for `< ::'. Substitute the tokens and check if we can
13419 parse correctly the argument list. */
13426 {
13428 /* Change `:' into `::'. */
13430 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
13431 CPP_LESS. */
13434 /* Parse the arguments. */
13437 {
13438 /* If we couldn't parse an argument list, then we revert our changes
13439 and return simply an error. Maybe this is not a template-id
13440 after all. */
13445 }
13446 /* Otherwise, emit an error about the invalid digraph, but continue
13447 parsing because we got our argument list. */
13450 {
13453 "%<<:%> is an alternate spelling for %<[%>."
13456 {
13458 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
13461 }
13462 }
13463 }
13464 else
13465 {
13466 /* Look for the `<' that starts the template-argument-list. */
13468 {
13471 }
13472 /* Parse the arguments. */
13474 }
13476 /* Build a representation of the specialization. */
13479 TEMPLATE_ID_EXPR,
13483 {
13485 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
13486 template (rather than some instantiation thereof) only if
13487 is not nested within some other construct. For example, in
13488 "template <typename T> void f(T) { A<T>::", A<T> is just an
13489 instantiation of A. */
13492 CPP_SCOPE));
13493 template_id
13495 }
13496 else
13497 {
13498 /* If it's not a class-template or a template-template, it should be
13499 a function-template. */
13505 }
13507 /* If parsing tentatively, replace the sequence of tokens that makes
13508 up the template-id with a CPP_TEMPLATE_ID token. That way,
13509 should we re-parse the token stream, we will not have to repeat
13510 the effort required to do the parse, nor will we issue duplicate
13511 error messages about problems during instantiation of the
13512 template. */
13514 /* Don't do this if we had a parse error in a declarator; re-parsing
13515 might succeed if a name changes meaning (60361). */
13519 {
13522 /* Reset the contents of the START_OF_ID token. */
13524 /* Retrieve any deferred checks. Do not pop this access checks yet
13525 so the memory will not be reclaimed during token replacing below. */
13531 /* Purge all subsequent tokens. */
13534 /* ??? Can we actually assume that, if template_id ==
13535 error_mark_node, we will have issued a diagnostic to the
13536 user, as opposed to simply marking the tentative parse as
13537 failed? */
13540 }
13544 }
13546 /* Parse a template-name.
13548 template-name:
13549 identifier
13551 The standard should actually say:
13553 template-name:
13554 identifier
13555 operator-function-id
13557 A defect report has been filed about this issue.
13559 A conversion-function-id cannot be a template name because they cannot
13560 be part of a template-id. In fact, looking at this code:
13562 a.operator K<int>()
13564 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
13565 It is impossible to call a templated conversion-function-id with an
13566 explicit argument list, since the only allowed template parameter is
13567 the type to which it is converting.
13569 If TEMPLATE_KEYWORD_P is true, then we have just seen the
13570 `template' keyword, in a construction like:
13572 T::template f<3>()
13574 In that case `f' is taken to be a template-name, even though there
13575 is no way of knowing for sure.
13577 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
13578 name refers to a set of overloaded functions, at least one of which
13579 is a template, or an IDENTIFIER_NODE with the name of the template,
13580 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
13581 names are looked up inside uninstantiated templates. */
13583 static tree
13590 {
13591 tree identifier;
13592 tree decl;
13593 tree fns;
13596 /* If the next token is `operator', then we have either an
13597 operator-function-id or a conversion-function-id. */
13599 {
13600 /* We don't know whether we're looking at an
13601 operator-function-id or a conversion-function-id. */
13603 /* Try an operator-function-id. */
13605 /* If that didn't work, try a conversion-function-id. */
13607 {
13610 }
13611 }
13612 /* Look for the identifier. */
13613 else
13616 /* If we didn't find an identifier, we don't have a template-id. */
13620 /* If the name immediately followed the `template' keyword, then it
13621 is a template-name. However, if the next token is not `<', then
13622 we do not treat it as a template-name, since it is not being used
13623 as part of a template-id. This enables us to handle constructs
13624 like:
13626 template <typename T> struct S { S(); };
13627 template <typename T> S<T>::S();
13629 correctly. We would treat `S' as a template -- if it were `S<T>'
13630 -- but we do not if there is no `<'. */
13634 {
13635 /* In a declaration, in a dependent context, we pretend that the
13636 "template" keyword was present in order to improve error
13637 recovery. For example, given:
13639 template <typename T> void f(T::X<int>);
13641 we want to treat "X<int>" as a template-id. */
13643 && !template_keyword_p
13645 && check_dependency_p
13647 /* Do not do this for dtors (or ctors), since they never
13648 need the template keyword before their name. */
13650 {
13653 /* Explain what went wrong. */
13655 identifier);
13658 /* If parsing tentatively, find the location of the "<" token. */
13661 /* Parse the template arguments so that we can issue error
13662 messages about them. */
13665 /* Skip tokens until we find a good place from which to
13666 continue parsing. */
13671 /* If parsing tentatively, permanently remove the
13672 template argument list. That will prevent duplicate
13673 error messages from being issued about the missing
13674 "template" keyword. */
13680 }
13682 /* If the "template" keyword is present, then there is generally
13683 no point in doing name-lookup, so we just return IDENTIFIER.
13684 But, if the qualifying scope is non-dependent then we can
13685 (and must) do name-lookup normally. */
13691 }
13693 /* Look up the name. */
13695 tag_type,
13698 check_dependency_p,
13702 /* If DECL is a template, then the name was a template-name. */
13704 ;
13705 else
13706 {
13709 /* The standard does not explicitly indicate whether a name that
13710 names a set of overloaded declarations, some of which are
13711 templates, is a template-name. However, such a name should
13712 be a template-name; otherwise, there is no way to form a
13713 template-id for the overloaded templates. */
13721 {
13722 /* The name does not name a template. */
13725 }
13726 }
13728 /* If DECL is dependent, and refers to a function, then just return
13729 its name; we will look it up again during template instantiation. */
13731 {
13735 }
13738 }
13740 /* Parse a template-argument-list.
13742 template-argument-list:
13743 template-argument ... [opt]
13744 template-argument-list , template-argument ... [opt]
13746 Returns a TREE_VEC containing the arguments. */
13748 static tree
13750 {
13755 tree vec;
13762 /* Even if the template-id appears in an integral
13763 constant-expression, the contents of the argument list do
13764 not. */
13770 /* Parse the arguments. */
13771 do
13772 {
13773 tree argument;
13776 /* Consume the comma. */
13779 /* Parse the template-argument. */
13782 /* If the next token is an ellipsis, we're expanding a template
13783 argument pack. */
13785 {
13787 {
13791 }
13792 /* Consume the `...' token. */
13795 /* Make the argument into a TYPE_PACK_EXPANSION or
13796 EXPR_PACK_EXPANSION. */
13798 }
13801 {
13805 {
13808 }
13809 else
13811 }
13813 }
13826 #ifdef ENABLE_CHECKING
13828 #endif
13830 }
13832 /* Parse a template-argument.
13834 template-argument:
13835 assignment-expression
13836 type-id
13837 id-expression
13839 The representation is that of an assignment-expression, type-id, or
13840 id-expression -- except that the qualified id-expression is
13841 evaluated, so that the value returned is either a DECL or an
13842 OVERLOAD.
13844 Although the standard says "assignment-expression", it forbids
13845 throw-expressions or assignments in the template argument.
13846 Therefore, we use "conditional-expression" instead. */
13848 static tree
13850 {
13851 tree argument;
13857 cp_id_kind idk;
13859 /* There's really no way to know what we're looking at, so we just
13860 try each alternative in order.
13862 [temp.arg]
13864 In a template-argument, an ambiguity between a type-id and an
13865 expression is resolved to a type-id, regardless of the form of
13866 the corresponding template-parameter.
13868 Therefore, we try a type-id first. */
13871 /* If there was no error parsing the type-id but the next token is a
13872 '>>', our behavior depends on which dialect of C++ we're
13873 parsing. In C++98, we probably found a typo for '> >'. But there
13874 are type-id which are also valid expressions. For instance:
13876 struct X { int operator >> (int); };
13877 template <int V> struct Foo {};
13878 Foo<X () >> 5> r;
13880 Here 'X()' is a valid type-id of a function type, but the user just
13881 wanted to write the expression "X() >> 5". Thus, we remember that we
13882 found a valid type-id, but we still try to parse the argument as an
13883 expression to see what happens.
13885 In C++0x, the '>>' will be considered two separate '>'
13886 tokens. */
13890 {
13893 }
13894 else
13895 {
13896 /* If the next token isn't a `,' or a `>', then this argument wasn't
13897 really finished. This means that the argument is not a valid
13898 type-id. */
13901 /* If that worked, we're done. */
13904 }
13905 /* We're still not sure what the argument will be. */
13907 /* Try a template. */
13915 /* If the next token isn't a `,' or a `>', then this argument wasn't
13916 really finished. */
13920 {
13921 /* Figure out what is being referred to. If the id-expression
13922 was for a class template specialization, then we will have a
13923 TYPE_DECL at this point. There is no need to do name lookup
13924 at this point in that case. */
13927 none_type,
13936 }
13939 /* It must be a non-type argument. There permitted cases are given
13940 in [temp.arg.nontype]:
13942 -- an integral constant-expression of integral or enumeration
13943 type; or
13945 -- the name of a non-type template-parameter; or
13947 -- the name of an object or function with external linkage...
13949 -- the address of an object or function with external linkage...
13951 -- a pointer to member... */
13952 /* Look for a non-type template parameter. */
13954 {
13966 }
13968 /* If the next token is "&", the argument must be the address of an
13969 object or function with external linkage. */
13972 {
13975 }
13976 /* See if we might have an id-expression. */
13983 {
13986 address_p,
13993 else
13994 {
13995 tree probe;
13998 {
13999 /* Strip the dereference temporarily. */
14002 }
14004 /* If we're in a template, we represent a qualified-id referring
14005 to a static data member as a SCOPE_REF even if the scope isn't
14006 dependent so that we can check access control later. */
14011 {
14012 /* A variable without external linkage might still be a
14013 valid constant-expression, so no error is issued here
14014 if the external-linkage check fails. */
14017 }
14019 /* All overloaded functions are allowed; if the external
14020 linkage test does not pass, an error will be issued
14021 later. */
14022 ;
14026 /* A pointer-to-member. */
14027 ;
14029 ;
14030 else
14034 {
14037 tf_warning_or_error);
14038 else
14041 }
14042 }
14043 }
14044 /* If the argument started with "&", there are no other valid
14045 alternatives at this point. */
14047 {
14050 }
14052 /* If the argument wasn't successfully parsed as a type-id followed
14053 by '>>', the argument can only be a constant expression now.
14054 Otherwise, we try parsing the constant-expression tentatively,
14055 because the argument could really be a type-id. */
14067 /* We did our best to parse the argument as a non type-id, but that
14068 was the only alternative that matched (albeit with a '>' after
14069 it). We can assume it's just a typo from the user, and a
14070 diagnostic will then be issued. */
14072 }
14074 /* Parse an explicit-instantiation.
14076 explicit-instantiation:
14077 template declaration
14079 Although the standard says `declaration', what it really means is:
14081 explicit-instantiation:
14082 template decl-specifier-seq [opt] declarator [opt] ;
14084 Things like `template int S<int>::i = 5, int S<double>::j;' are not
14085 supposed to be allowed. A defect report has been filed about this
14086 issue.
14088 GNU Extension:
14090 explicit-instantiation:
14091 storage-class-specifier template
14092 decl-specifier-seq [opt] declarator [opt] ;
14093 function-specifier template
14094 decl-specifier-seq [opt] declarator [opt] ; */
14096 static void
14098 {
14100 cp_decl_specifier_seq decl_specifiers;
14105 /* Look for an (optional) storage-class-specifier or
14106 function-specifier. */
14108 {
14109 extension_specifier
14112 extension_specifier
14115 }
14117 /* Look for the `template' keyword. */
14119 /* Let the front end know that we are processing an explicit
14120 instantiation. */
14122 /* [temp.explicit] says that we are supposed to ignore access
14123 control while processing explicit instantiation directives. */
14125 /* Parse a decl-specifier-seq. */
14127 CP_PARSER_FLAGS_OPTIONAL,
14130 /* If there was exactly one decl-specifier, and it declared a class,
14131 and there's no declarator, then we have an explicit type
14132 instantiation. */
14134 {
14135 tree type;
14139 /* Turn access control back on for names used during
14140 template instantiation. */
14145 }
14146 else
14147 {
14149 tree decl;
14151 /* Parse the declarator. */
14152 declarator
14162 {
14165 "explicit instantiation shall not use"
14169 "explicit instantiation shall not use"
14174 /* Turn access control back on for names used during
14175 template instantiation. */
14177 /* Do the explicit instantiation. */
14179 }
14180 else
14181 {
14183 /* Skip the body of the explicit instantiation. */
14185 }
14186 }
14187 /* We're done with the instantiation. */
14193 }
14195 /* Parse an explicit-specialization.
14197 explicit-specialization:
14198 template < > declaration
14200 Although the standard says `declaration', what it really means is:
14202 explicit-specialization:
14203 template <> decl-specifier [opt] init-declarator [opt] ;
14204 template <> function-definition
14205 template <> explicit-specialization
14206 template <> template-declaration */
14208 static void
14210 {
14214 /* Look for the `template' keyword. */
14216 /* Look for the `<'. */
14218 /* Look for the `>'. */
14220 /* We have processed another parameter list. */
14222 /* [temp]
14224 A template ... explicit specialization ... shall not have C
14225 linkage. */
14227 {
14229 /* Give it C++ linkage to avoid confusing other parts of the
14230 front end. */
14233 }
14234 else
14236 /* Let the front end know that we are beginning a specialization. */
14238 {
14241 }
14243 /* If the next keyword is `template', we need to figure out whether
14244 or not we're looking a template-declaration. */
14246 {
14251 else
14253 }
14254 else
14255 /* Parse the dependent declaration. */
14261 /* We're done with the specialization. */
14263 /* For the erroneous case of a template with C linkage, we pushed an
14264 implicit C++ linkage scope; exit that scope now. */
14267 /* We're done with this parameter list. */
14269 }
14271 /* Parse a type-specifier.
14273 type-specifier:
14274 simple-type-specifier
14275 class-specifier
14276 enum-specifier
14277 elaborated-type-specifier
14278 cv-qualifier
14280 GNU Extension:
14282 type-specifier:
14283 __complex__
14285 Returns a representation of the type-specifier. For a
14286 class-specifier, enum-specifier, or elaborated-type-specifier, a
14287 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
14289 The parser flags FLAGS is used to control type-specifier parsing.
14291 If IS_DECLARATION is TRUE, then this type-specifier is appearing
14292 in a decl-specifier-seq.
14294 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
14295 class-specifier, enum-specifier, or elaborated-type-specifier, then
14296 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
14297 if a type is declared; 2 if it is defined. Otherwise, it is set to
14298 zero.
14300 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
14301 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
14302 is set to FALSE. */
14304 static tree
14306 cp_parser_flags flags,
14311 {
14317 /* Assume this type-specifier does not declare a new type. */
14320 /* And that it does not specify a cv-qualifier. */
14323 /* Peek at the next token. */
14326 /* If we're looking at a keyword, we can use that to guide the
14327 production we choose. */
14330 {
14335 /* Look for the enum-specifier. */
14337 /* If that worked, we're done. */
14339 {
14344 type_spec,
14345 token,
14348 }
14349 else
14352 /* Any of these indicate either a class-specifier, or an
14353 elaborated-type-specifier. */
14360 /* Parse tentatively so that we can back up if we don't find a
14361 class-specifier. */
14363 /* Look for the class-specifier. */
14366 /* If that worked, we're done. */
14368 {
14373 type_spec,
14374 token,
14377 }
14379 /* Fall through. */
14380 elaborated_type_specifier:
14381 /* We're declaring (not defining) a class or enum. */
14385 /* Fall through. */
14387 /* Look for an elaborated-type-specifier. */
14388 type_spec
14389 = (cp_parser_elaborated_type_specifier
14392 is_declaration));
14395 type_spec,
14396 token,
14419 /* The `__complex__' keyword is a GNU extension. */
14425 }
14427 /* Handle simple keywords. */
14429 {
14431 {
14434 }
14436 }
14438 /* If we do not already have a type-specifier, assume we are looking
14439 at a simple-type-specifier. */
14441 decl_specs,
14442 flags);
14444 /* If we didn't find a type-specifier, and a type-specifier was not
14445 optional in this context, issue an error message. */
14447 {
14450 }
14453 }
14455 /* Parse a simple-type-specifier.
14457 simple-type-specifier:
14458 :: [opt] nested-name-specifier [opt] type-name
14459 :: [opt] nested-name-specifier template template-id
14460 char
14461 wchar_t
14462 bool
14463 short
14464 int
14465 long
14466 signed
14467 unsigned
14468 float
14469 double
14470 void
14472 C++0x Extension:
14474 simple-type-specifier:
14475 auto
14476 decltype ( expression )
14477 char16_t
14478 char32_t
14479 __underlying_type ( type-id )
14481 GNU Extension:
14483 simple-type-specifier:
14484 __int128
14485 __typeof__ unary-expression
14486 __typeof__ ( type-id )
14487 __typeof__ ( type-id ) { initializer-list , [opt] }
14489 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
14490 appropriately updated. */
14492 static tree
14495 cp_parser_flags flags)
14496 {
14500 /* Peek at the next token. */
14503 /* If we're looking at a keyword, things are easy. */
14505 {
14565 {
14569 {
14572 "use of %<auto%> in lambda parameter declaration "
14573 "only available with "
14575 }
14578 "use of %<auto%> in parameter declaration "
14579 "only available with "
14581 else
14583 "ISO C++ forbids use of %<auto%> in parameter "
14585 }
14586 else
14591 /* Since DR 743, decltype can either be a simple-type-specifier by
14592 itself or begin a nested-name-specifier. Parsing it will replace
14593 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
14594 handling below decide what to do. */
14600 /* Consume the `typeof' token. */
14602 /* Parse the operand to `typeof'. */
14604 /* If it is not already a TYPE, take its type. */
14610 token,
14619 token,
14629 token,
14634 }
14636 /* If token is an already-parsed decltype not followed by ::,
14637 it's a simple-type-specifier. */
14640 {
14644 token,
14648 }
14650 /* If the type-specifier was for a built-in type, we're done. */
14652 {
14653 /* Record the type. */
14660 type,
14661 token,
14666 /* Consume the token. */
14669 /* There is no valid C++ program where a non-template type is
14670 followed by a "<". That usually indicates that the user thought
14671 that the type was a template. */
14676 }
14678 /* The type-specifier must be a user-defined type. */
14680 {
14684 /* Don't gobble tokens or issue error messages if this is an
14685 optional type-specifier. */
14689 /* Look for the optional `::' operator. */
14690 global_p
14694 /* Look for the nested-name specifier. */
14695 qualified_p
14703 /* If we have seen a nested-name-specifier, and the next token
14704 is `template', then we are using the template-id production. */
14707 {
14708 /* Look for the template-id. */
14712 none_type,
14714 /* If the template-id did not name a type, we are out of
14715 luck. */
14717 {
14720 }
14721 }
14722 /* Otherwise, look for a type-name. */
14723 else
14725 /* Keep track of all name-lookups performed in class scopes. */
14727 && !global_p
14728 && !qualified_p
14732 /* If it didn't work out, we don't have a TYPE. */
14738 token,
14740 }
14742 /* If we didn't get a type-name, issue an error message. */
14744 {
14747 }
14750 {
14751 /* See if TYPE is an Objective-C type, and if so, parse and
14752 accept any protocol references following it. Do this before
14753 the cp_parser_check_for_invalid_template_id() call, because
14754 Objective-C types can be followed by '<...>' which would
14755 enclose protocol names rather than template arguments, and so
14756 everything is fine. */
14759 {
14763 /* Clobber the "unqualified" type previously entered into
14764 DECL_SPECS with the new, improved protocol-qualified version. */
14769 }
14771 /* There is no valid C++ program where a non-template type is
14772 followed by a "<". That usually indicates that the user
14773 thought that the type was a template. */
14775 none_type,
14777 }
14780 }
14782 /* Parse a type-name.
14784 type-name:
14785 class-name
14786 enum-name
14787 typedef-name
14788 simple-template-id [in c++0x]
14790 enum-name:
14791 identifier
14793 typedef-name:
14794 identifier
14796 Returns a TYPE_DECL for the type. */
14798 static tree
14800 {
14801 tree type_decl;
14803 /* We can't know yet whether it is a class-name or not. */
14805 /* Try a class-name. */
14809 none_type,
14813 /* If it's not a class-name, keep looking. */
14815 {
14817 /* It must be a typedef-name or an enum-name. */
14821 /* It is either a simple-template-id representing an
14822 instantiation of an alias template... */
14826 none_type,
14828 /* Note that this must be an instantiation of an alias template
14829 because [temp.names]/6 says:
14831 A template-id that names an alias template specialization
14832 is a type-name.
14834 Whereas [temp.names]/7 says:
14836 A simple-template-id that names a class template
14837 specialization is a class-name. */
14842 else
14846 /* ... Or a typedef-name or an enum-name. */
14848 }
14851 }
14853 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
14855 enum-name:
14856 identifier
14858 typedef-name:
14859 identifier
14861 Returns a TYPE_DECL for the type. */
14863 static tree
14865 {
14866 tree type_decl;
14867 tree identifier;
14874 /* Look up the type-name. */
14881 {
14882 /* See if this is an Objective-C type. */
14887 }
14889 /* Issue an error if we did not find a type-name. */
14891 /* In Objective-C, we have the complication that class names are
14892 normally type names and start declarations (eg, the
14893 "NSObject" in "NSObject *object;"), but can be used in an
14894 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
14895 is an expression. So, a classname followed by a dot is not a
14896 valid type-name. */
14899 {
14904 }
14905 /* Remember that the name was used in the definition of the
14906 current class so that we can check later to see if the
14907 meaning would have been different after the class was
14908 entirely defined. */
14914 }
14916 /* Parse an elaborated-type-specifier. Note that the grammar given
14917 here incorporates the resolution to DR68.
14919 elaborated-type-specifier:
14920 class-key :: [opt] nested-name-specifier [opt] identifier
14921 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
14922 enum-key :: [opt] nested-name-specifier [opt] identifier
14923 typename :: [opt] nested-name-specifier identifier
14924 typename :: [opt] nested-name-specifier template [opt]
14925 template-id
14927 GNU extension:
14929 elaborated-type-specifier:
14930 class-key attributes :: [opt] nested-name-specifier [opt] identifier
14931 class-key attributes :: [opt] nested-name-specifier [opt]
14932 template [opt] template-id
14933 enum attributes :: [opt] nested-name-specifier [opt] identifier
14935 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
14936 declared `friend'. If IS_DECLARATION is TRUE, then this
14937 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
14938 something is being declared.
14940 Returns the TYPE specified. */
14942 static tree
14946 {
14948 tree identifier;
14951 tree globalscope;
14954 /* See if we're looking at the `enum' keyword. */
14956 {
14957 /* Consume the `enum' token. */
14959 /* Remember that it's an enumeration type. */
14961 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
14962 enums) is used here. */
14965 {
14969 /* Consume the `struct' or `class' and parse it anyway. */
14971 }
14972 /* Parse the attributes. */
14974 }
14975 /* Or, it might be `typename'. */
14977 RID_TYPENAME))
14978 {
14979 /* Consume the `typename' token. */
14981 /* Remember that it's a `typename' type. */
14983 }
14984 /* Otherwise it must be a class-key. */
14985 else
14986 {
14990 /* Parse the attributes. */
14992 }
14994 /* Look for the `::' operator. */
14997 /* Look for the nested-name-specifier. */
14999 {
15004 is_declaration))
15006 }
15007 else
15008 /* Even though `typename' is not present, the proposed resolution
15009 to Core Issue 180 says that in `class A<T>::B', `B' should be
15010 considered a type-name, even if `A<T>' is dependent. */
15015 is_declaration);
15016 /* For everything but enumeration types, consider a template-id.
15017 For an enumeration type, consider only a plain identifier. */
15019 {
15021 tree decl;
15023 /* Allow the `template' keyword. */
15025 /* If we didn't see `template', we don't know if there's a
15026 template-id or not. */
15029 /* Parse the template-id. */
15033 tag_type,
15034 is_declaration);
15035 /* If we didn't find a template-id, look for an ordinary
15036 identifier. */
15038 ;
15039 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
15040 in effect, then we must assume that, upon instantiation, the
15041 template will correspond to a class. */
15045 typename_type,
15047 /* If the `typename' keyword is in effect and DECL is not a type
15048 decl, then type is non existent. */
15050 ;
15056 }
15059 {
15064 {
15067 }
15069 /* For a `typename', we needn't call xref_tag. */
15073 identifier,
15075 /* Look up a qualified name in the usual way. */
15077 {
15078 tree decl;
15079 tree ambiguous_decls;
15082 tag_type,
15089 /* If the lookup was ambiguous, an error will already have been
15090 issued. */
15094 /* If we are parsing friend declaration, DECL may be a
15095 TEMPLATE_DECL tree node here. However, we need to check
15096 whether this TEMPLATE_DECL results in valid code. Consider
15097 the following example:
15099 namespace N {
15100 template <class T> class C {};
15101 }
15102 class X {
15103 template <class T> friend class N::C; // #1, valid code
15104 };
15105 template <class T> class Y {
15106 friend class N::C; // #2, invalid code
15107 };
15109 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
15110 name lookup of `N::C'. We see that friend declaration must
15111 be template for the code to be valid. Note that
15112 processing_template_decl does not work here since it is
15113 always 1 for the above two cases. */
15115 decl = (cp_parser_maybe_treat_template_as_class
15120 {
15123 identifier,
15126 }
15129 {
15133 allow_template);
15137 }
15139 /* Forward declarations of nested types, such as
15141 class C1::C2;
15142 class C1::C2::C3;
15144 are invalid unless all components preceding the final '::'
15145 are complete. If all enclosing types are complete, these
15146 declarations become merely pointless.
15148 Invalid forward declarations of nested types are errors
15149 caught elsewhere in parsing. Those that are pointless arrive
15150 here. */
15157 }
15158 else
15159 {
15160 /* An elaborated-type-specifier sometimes introduces a new type and
15161 sometimes names an existing type. Normally, the rule is that it
15162 introduces a new type only if there is not an existing type of
15163 the same name already in scope. For example, given:
15165 struct S {};
15166 void f() { struct S s; }
15168 the `struct S' in the body of `f' is the same `struct S' as in
15169 the global scope; the existing definition is used. However, if
15170 there were no global declaration, this would introduce a new
15171 local class named `S'.
15173 An exception to this rule applies to the following code:
15175 namespace N { struct S; }
15177 Here, the elaborated-type-specifier names a new type
15178 unconditionally; even if there is already an `S' in the
15179 containing scope this declaration names a new type.
15180 This exception only applies if the elaborated-type-specifier
15181 forms the complete declaration:
15183 [class.name]
15185 A declaration consisting solely of `class-key identifier ;' is
15186 either a redeclaration of the name in the current scope or a
15187 forward declaration of the identifier as a class name. It
15188 introduces the name into the current scope.
15190 We are in this situation precisely when the next token is a `;'.
15192 An exception to the exception is that a `friend' declaration does
15193 *not* name a new type; i.e., given:
15195 struct S { friend struct T; };
15197 `T' is not a new type in the scope of `S'.
15199 Also, `new struct S' or `sizeof (struct S)' never results in the
15200 definition of a new type; a new type can only be declared in a
15201 declaration context. */
15203 tag_scope ts;
15207 /* Friends have special name lookup rules. */
15211 CPP_SEMICOLON))
15212 /* This is a `class-key identifier ;' */
15214 else
15217 template_p =
15221 /* An unqualified name was used to reference this type, so
15222 there were no qualifying templates. */
15229 }
15230 }
15235 /* Allow attributes on forward declarations of classes. */
15237 {
15247 else
15250 }
15253 {
15254 /* Indicate whether this class was declared as a `class' or as a
15255 `struct'. */
15259 }
15261 /* A "<" cannot follow an elaborated type specifier. If that
15262 happens, the user was probably trying to form a template-id. */
15267 }
15269 /* Parse an enum-specifier.
15271 enum-specifier:
15272 enum-head { enumerator-list [opt] }
15273 enum-head { enumerator-list , } [C++0x]
15275 enum-head:
15276 enum-key identifier [opt] enum-base [opt]
15277 enum-key nested-name-specifier identifier enum-base [opt]
15279 enum-key:
15280 enum
15281 enum class [C++0x]
15282 enum struct [C++0x]
15284 enum-base: [C++0x]
15285 : type-specifier-seq
15287 opaque-enum-specifier:
15288 enum-key identifier enum-base [opt] ;
15290 GNU Extensions:
15291 enum-key attributes[opt] identifier [opt] enum-base [opt]
15292 { enumerator-list [opt] }attributes[opt]
15293 enum-key attributes[opt] identifier [opt] enum-base [opt]
15294 { enumerator-list, }attributes[opt] [C++0x]
15296 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
15297 if the token stream isn't an enum-specifier after all. */
15299 static tree
15301 {
15302 tree identifier;
15304 tree prev_scope;
15306 tree attributes;
15319 /* Parse tentatively so that we can back up if we don't find a
15320 enum-specifier. */
15323 /* Caller guarantees that the current token is 'enum', an identifier
15324 possibly follows, and the token after that is an opening brace.
15325 If we don't have an identifier, fabricate an anonymous name for
15326 the enumeration being defined. */
15329 /* Parse the "class" or "struct", which indicates a scoped
15330 enumeration type in C++0x. */
15333 {
15337 /* Consume the `struct' or `class' token. */
15341 }
15345 /* Clear the qualification. */
15350 /* Figure out in what scope the declaration is being placed. */
15356 nested_name_specifier
15364 {
15365 tree name;
15369 enum_type,
15374 input_location);
15376 {
15379 {
15380 /* Are template enums allowed in ISO? */
15384 /* ignore a typename reference, for it will be solved by name
15385 in start_enum. */
15387 }
15388 }
15391 else
15394 }
15395 else
15396 {
15399 else
15400 {
15406 }
15407 }
15410 /* Check for the `:' that denotes a specified underlying type in C++0x.
15411 Note that a ':' could also indicate a bitfield width, however. */
15413 {
15414 cp_decl_specifier_seq type_specifiers;
15416 /* Consume the `:'. */
15419 /* Parse the type-specifier-seq. */
15424 /* At this point this is surely not elaborated type specifier. */
15433 /* If that didn't work, stop. */
15435 {
15441 }
15442 }
15444 /* Look for the `{' but don't consume it yet. */
15446 {
15448 {
15451 {
15454 }
15455 }
15456 /* An opaque-enum-specifier must have a ';' here. */
15459 {
15462 {
15465 }
15466 }
15467 }
15473 {
15475 {
15479 }
15481 {
15483 }
15484 }
15486 /* Issue an error message if type-definitions are forbidden here. */
15489 else
15490 /* Create the new type. We do this before consuming the opening
15491 brace so the enum will be recorded as being on the line of its
15492 tag (or the 'enum' keyword, if there is no tag). */
15496 /* If the next token is not '{' it is an opaque-enum-specifier or an
15497 elaborated-type-specifier. */
15499 {
15503 {
15504 /* The following catches invalid code such as:
15505 enum class S<int>::E { A, B, C }; */
15513 {
15517 nested_name_specifier);
15519 }
15520 /* If that scope does not contain the scope in which the
15521 class was originally declared, the program is invalid. */
15523 nested_name_specifier))
15524 {
15527 "declaration of %qD in namespace %qD which does not "
15530 else
15532 "declaration of %qD in %qD which does not "
15536 }
15537 }
15542 /* Consume the opening brace. */
15549 {
15553 }
15554 else
15555 {
15561 }
15565 /* If the next token is not '}', then there are some enumerators. */
15567 {
15571 }
15572 else
15575 /* Consume the final '}'. */
15581 }
15582 else
15583 {
15584 /* If a ';' follows, then it is an opaque-enum-specifier
15585 and additional restrictions apply. */
15587 {
15594 }
15595 }
15597 /* Look for trailing attributes to apply to this enumeration, and
15598 apply them if appropriate. */
15600 {
15604 trailing_attr,
15606 }
15608 /* Finish up the enumeration. */
15610 {
15615 }
15618 {
15620 {
15623 }
15625 {
15627 }
15628 }
15629 out:
15632 }
15634 /* Parse an enumerator-list. The enumerators all have the indicated
15635 TYPE.
15637 enumerator-list:
15638 enumerator-definition
15639 enumerator-list , enumerator-definition */
15641 static void
15643 {
15645 {
15646 /* Parse an enumerator-definition. */
15649 /* If the next token is not a ',', we've reached the end of
15650 the list. */
15653 /* Otherwise, consume the `,' and keep going. */
15655 /* If the next token is a `}', there is a trailing comma. */
15657 {
15662 }
15663 }
15664 }
15666 /* Parse an enumerator-definition. The enumerator has the indicated
15667 TYPE.
15669 enumerator-definition:
15670 enumerator
15671 enumerator = constant-expression
15673 enumerator:
15674 identifier */
15676 static void
15678 {
15679 tree identifier;
15680 tree value;
15681 location_t loc;
15683 /* Save the input location because we are interested in the location
15684 of the identifier and not the location of the explicit value. */
15687 /* Look for the identifier. */
15692 /* If the next token is an '=', then there is an explicit value. */
15694 {
15695 /* Consume the `=' token. */
15697 /* Parse the value. */
15700 NULL);
15701 }
15702 else
15705 /* If we are processing a template, make sure the initializer of the
15706 enumerator doesn't contain any bare template parameter pack. */
15710 /* integral_constant_value will pull out this expression, so make sure
15711 it's folded as appropriate. */
15714 /* Create the enumerator. */
15716 }
15718 /* Parse a namespace-name.
15720 namespace-name:
15721 original-namespace-name
15722 namespace-alias
15724 Returns the NAMESPACE_DECL for the namespace. */
15726 static tree
15728 {
15729 tree identifier;
15730 tree namespace_decl;
15734 /* Get the name of the namespace. */
15739 /* Look up the identifier in the currently active scope. Look only
15740 for namespaces, due to:
15742 [basic.lookup.udir]
15744 When looking up a namespace-name in a using-directive or alias
15745 definition, only namespace names are considered.
15747 And:
15749 [basic.lookup.qual]
15751 During the lookup of a name preceding the :: scope resolution
15752 operator, object, function, and enumerator names are ignored.
15754 (Note that cp_parser_qualifying_entity only calls this
15755 function if the token after the name is the scope resolution
15756 operator.) */
15758 none_type,
15764 /* If it's not a namespace, issue an error. */
15767 {
15772 }
15775 }
15777 /* Parse a namespace-definition.
15779 namespace-definition:
15780 named-namespace-definition
15781 unnamed-namespace-definition
15783 named-namespace-definition:
15784 original-namespace-definition
15785 extension-namespace-definition
15787 original-namespace-definition:
15788 namespace identifier { namespace-body }
15790 extension-namespace-definition:
15791 namespace original-namespace-name { namespace-body }
15793 unnamed-namespace-definition:
15794 namespace { namespace-body } */
15796 static void
15798 {
15805 {
15809 }
15810 else
15813 /* Look for the `namespace' keyword. */
15816 /* Get the name of the namespace. We do not attempt to distinguish
15817 between an original-namespace-definition and an
15818 extension-namespace-definition at this point. The semantic
15819 analysis routines are responsible for that. */
15822 else
15825 /* Parse any specified attributes. */
15828 /* Look for the `{' to start the namespace. */
15830 /* Start the namespace. */
15833 /* "inline namespace" is equivalent to a stub namespace definition
15834 followed by a strong using directive. */
15836 {
15838 /* Set up namespace association. */
15842 /* Import the contents of the inline namespace. */
15846 }
15850 /* Parse the body of the namespace. */
15856 /* Finish the namespace. */
15858 /* Look for the final `}'. */
15860 }
15862 /* Parse a namespace-body.
15864 namespace-body:
15865 declaration-seq [opt] */
15867 static void
15869 {
15871 }
15873 /* Parse a namespace-alias-definition.
15875 namespace-alias-definition:
15876 namespace identifier = qualified-namespace-specifier ; */
15878 static void
15880 {
15881 tree identifier;
15882 tree namespace_specifier;
15886 /* Look for the `namespace' keyword. */
15888 /* Look for the identifier. */
15892 /* Look for the `=' token. */
15895 {
15897 /* Skip the definition. */
15902 }
15904 /* Look for the qualified-namespace-specifier. */
15905 namespace_specifier
15907 /* Look for the `;' token. */
15910 /* Register the alias in the symbol table. */
15912 }
15914 /* Parse a qualified-namespace-specifier.
15916 qualified-namespace-specifier:
15917 :: [opt] nested-name-specifier [opt] namespace-name
15919 Returns a NAMESPACE_DECL corresponding to the specified
15920 namespace. */
15922 static tree
15924 {
15925 /* Look for the optional `::'. */
15929 /* Look for the optional nested-name-specifier. */
15937 }
15939 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
15940 access declaration.
15942 using-declaration:
15943 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
15944 using :: unqualified-id ;
15946 access-declaration:
15947 qualified-id ;
15949 */
15951 static bool
15954 {
15958 tree decl;
15959 tree identifier;
15960 tree qscope;
15965 {
15968 }
15969 else
15970 {
15971 /* Look for the `using' keyword. */
15974 /* Peek at the next token. */
15976 /* See if it's `typename'. */
15978 {
15979 /* Remember that we've seen it. */
15981 /* Consume the `typename' token. */
15983 }
15984 }
15986 /* Look for the optional global scope qualification. */
15987 global_scope_p
15992 /* If we saw `typename', or didn't see `::', then there must be a
15993 nested-name-specifier present. */
15995 {
16001 {
16004 }
16005 }
16006 /* Otherwise, we could be in either of the two productions. In that
16007 case, treat the nested-name-specifier as optional. */
16008 else
16018 /* Something has already gone wrong; there's no need to parse
16019 further. Since an error has occurred, the return value of
16020 cp_parser_parse_definitely will be false, as required. */
16024 /* Parse the unqualified-id. */
16032 {
16037 }
16039 /* The function we call to handle a using-declaration is different
16040 depending on what scope we are in. */
16042 ;
16045 /* [namespace.udecl]
16047 A using declaration shall not name a template-id. */
16050 else
16051 {
16053 {
16054 /* Create the USING_DECL. */
16061 {
16064 }
16065 else
16066 /* Add it to the list of members in this class. */
16068 }
16069 else
16070 {
16072 identifier,
16079 {
16082 }
16085 else
16087 }
16088 }
16090 /* Look for the final `;'. */
16095 "access declarations are deprecated "
16096 "in favour of using-declarations; "
16100 }
16102 /* Parse an alias-declaration.
16104 alias-declaration:
16105 using identifier attribute-specifier-seq [opt] = type-id */
16107 static tree
16109 {
16111 location_t id_location;
16113 cp_decl_specifier_seq decl_specs;
16117 /* Look for the `using' keyword. */
16118 cp_token *using_token
16140 /* Now we are going to parse the type-id of the declaration. */
16142 /*
16143 [dcl.type]/3 says:
16145 "A type-specifier-seq shall not define a class or enumeration
16146 unless it appears in the type-id of an alias-declaration (7.1.3) that
16147 is not the declaration of a template-declaration."
16149 In other words, if we currently are in an alias template, the
16150 type-id should not define a type.
16152 So let's set parser->type_definition_forbidden_message in that
16153 case; cp_parser_check_type_definition (called by
16154 cp_parser_class_specifier) will then emit an error if a type is
16155 defined in the type-id. */
16157 {
16161 }
16165 /* Restore the error message if need be. */
16171 {
16174 }
16176 /* A typedef-name can also be introduced by an alias-declaration. The
16177 identifier following the using keyword becomes a typedef-name. It has
16178 the same semantics as if it were introduced by the typedef
16179 specifier. In particular, it does not define a new type and it shall
16180 not appear in the type-id. */
16185 {
16188 ds_attribute,
16189 attrs_token);
16190 }
16192 ds_typedef,
16193 using_token);
16195 ds_alias,
16196 using_token);
16205 else
16216 /* If decl is a template, return its TEMPLATE_DECL so that it gets
16217 added into the symbol table; otherwise, return the TYPE_DECL. */
16221 {
16225 }
16228 }
16230 /* Parse a using-directive.
16232 using-directive:
16233 using namespace :: [opt] nested-name-specifier [opt]
16234 namespace-name ; */
16236 static void
16238 {
16239 tree namespace_decl;
16240 tree attribs;
16242 /* Look for the `using' keyword. */
16244 /* And the `namespace' keyword. */
16246 /* Look for the optional `::' operator. */
16248 /* And the optional nested-name-specifier. */
16254 /* Get the namespace being used. */
16256 /* And any specified attributes. */
16258 /* Update the symbol table. */
16260 /* Look for the final `;'. */
16262 }
16264 /* Parse an asm-definition.
16266 asm-definition:
16267 asm ( string-literal ) ;
16269 GNU Extension:
16271 asm-definition:
16272 asm volatile [opt] ( string-literal ) ;
16273 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
16274 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16275 : asm-operand-list [opt] ) ;
16276 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16277 : asm-operand-list [opt]
16278 : asm-clobber-list [opt] ) ;
16279 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
16280 : asm-clobber-list [opt]
16281 : asm-goto-list ) ; */
16283 static void
16285 {
16286 tree string;
16291 tree asm_stmt;
16299 /* Look for the `asm' keyword. */
16301 /* See if the next token is `volatile'. */
16304 {
16305 /* Remember that we saw the `volatile' keyword. */
16307 /* Consume the token. */
16309 }
16313 {
16314 /* Remember that we saw the `goto' keyword. */
16316 /* Consume the token. */
16318 }
16319 /* Look for the opening `('. */
16322 /* Look for the string. */
16325 {
16329 }
16331 /* If we're allowing GNU extensions, check for the extended assembly
16332 syntax. Unfortunately, the `:' tokens need not be separated by
16333 a space in C, and so, for compatibility, we tolerate that here
16334 too. Doing that means that we have to treat the `::' operator as
16335 two `:' tokens. */
16340 {
16345 /* The extended syntax was used. */
16348 /* Look for outputs. */
16350 {
16351 /* Consume the `:'. */
16353 /* Parse the output-operands. */
16355 CPP_COLON)
16357 CPP_SCOPE)
16359 CPP_CLOSE_PAREN)
16365 }
16366 /* If the next token is `::', there are no outputs, and the
16367 next token is the beginning of the inputs. */
16369 /* The inputs are coming next. */
16372 /* Look for inputs. */
16375 {
16376 /* Consume the `:' or `::'. */
16378 /* Parse the output-operands. */
16380 CPP_COLON)
16382 CPP_SCOPE)
16384 CPP_CLOSE_PAREN))
16389 }
16391 /* The clobbers are coming next. */
16394 /* Look for clobbers. */
16397 {
16399 /* Consume the `:' or `::'. */
16401 /* Parse the clobbers. */
16403 CPP_COLON)
16405 CPP_CLOSE_PAREN))
16407 }
16410 /* The labels are coming next. */
16413 /* Look for labels. */
16416 {
16418 /* Consume the `:' or `::'. */
16420 /* Parse the labels. */
16422 }
16426 }
16430 /* Look for the closing `)'. */
16438 {
16439 /* Create the ASM_EXPR. */
16441 {
16444 /* If the extended syntax was not used, mark the ASM_EXPR. */
16446 {
16452 }
16453 }
16454 else
16456 }
16457 }
16459 /* Declarators [gram.dcl.decl] */
16461 /* Parse an init-declarator.
16463 init-declarator:
16464 declarator initializer [opt]
16466 GNU Extension:
16468 init-declarator:
16469 declarator asm-specification [opt] attributes [opt] initializer [opt]
16471 function-definition:
16472 decl-specifier-seq [opt] declarator ctor-initializer [opt]
16473 function-body
16474 decl-specifier-seq [opt] declarator function-try-block
16476 GNU Extension:
16478 function-definition:
16479 __extension__ function-definition
16481 TM Extension:
16483 function-definition:
16484 decl-specifier-seq [opt] declarator function-transaction-block
16486 The DECL_SPECIFIERS apply to this declarator. Returns a
16487 representation of the entity declared. If MEMBER_P is TRUE, then
16488 this declarator appears in a class scope. The new DECL created by
16489 this declarator is returned.
16491 The CHECKS are access checks that should be performed once we know
16492 what entity is being declared (and, therefore, what classes have
16493 befriended it).
16495 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
16496 for a function-definition here as well. If the declarator is a
16497 declarator for a function-definition, *FUNCTION_DEFINITION_P will
16498 be TRUE upon return. By that point, the function-definition will
16499 have been completely parsed.
16501 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
16502 is FALSE.
16504 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
16505 parsed declaration if it is an uninitialized single declarator not followed
16506 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
16507 if present, will not be consumed. If returned, this declarator will be
16508 created with SD_INITIALIZED but will not call cp_finish_decl. */
16510 static tree
16519 {
16523 tree prefix_attributes;
16525 tree asm_specification;
16526 tree initializer;
16528 tree scope;
16530 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
16531 initialized with "= ..", CPP_OPEN_PAREN if initialized with
16532 "(...)". */
16542 /* Gather the attributes that were provided with the
16543 decl-specifiers. */
16546 /* Assume that this is not the declarator for a function
16547 definition. */
16551 /* Default arguments are only permitted for function parameters. */
16555 /* Defer access checks while parsing the declarator; we cannot know
16556 what names are accessible until we know what is being
16557 declared. */
16560 /* Parse the declarator. */
16562 declarator
16566 member_p);
16567 /* Gather up the deferred checks. */
16572 /* If the DECLARATOR was erroneous, there's no need to go
16573 further. */
16577 /* Check that the number of template-parameter-lists is OK. */
16587 /* Figure out what scope the entity declared by the DECLARATOR is
16588 located in. `grokdeclarator' sometimes changes the scope, so
16589 we compute it now. */
16592 /* Perform any lookups in the declared type which were thought to be
16593 dependent, but are not in the scope of the declarator. */
16594 decl_specifiers->type
16597 /* If we're allowing GNU extensions, look for an
16598 asm-specification. */
16600 {
16601 /* Look for an asm-specification. */
16604 }
16605 else
16608 /* Look for attributes. */
16612 /* Peek at the next token. */
16616 {
16617 /* Check to see if the token indicates the start of a
16618 function-definition. */
16620 {
16622 {
16623 /* If a function-definition should not appear here, issue an
16624 error message. */
16628 }
16630 location_t func_brace_location
16633 /* Neither attributes nor an asm-specification are allowed
16634 on a function-definition. */
16637 "an asm-specification is not allowed "
16641 "attributes are not allowed "
16643 /* This is a function-definition. */
16646 /* Parse the function definition. */
16649 decl_specifiers,
16650 declarator,
16651 prefix_attributes);
16652 else
16653 decl =
16654 (cp_parser_function_definition_from_specifiers_and_declarator
16658 {
16659 /* This is where the prologue starts... */
16662 }
16665 }
16666 }
16668 /* [dcl.dcl]
16670 Only in function declarations for constructors, destructors, and
16671 type conversions can the decl-specifier-seq be omitted.
16673 We explicitly postpone this check past the point where we handle
16674 function-definitions because we tolerate function-definitions
16675 that are missing their return types in some modes. */
16677 {
16681 }
16683 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
16687 {
16695 {
16701 }
16702 }
16703 else
16704 {
16705 /* If the init-declarator isn't initialized and isn't followed by a
16706 `,' or `;', it's not a valid init-declarator. */
16709 {
16712 else
16713 {
16716 }
16717 }
16720 }
16722 /* Because start_decl has side-effects, we should only call it if we
16723 know we're going ahead. By this point, we know that we cannot
16724 possibly be looking at any other construct. */
16727 /* If the decl specifiers were bad, issue an error now that we're
16728 sure this was intended to be a declarator. Then continue
16729 declaring the variable(s), as int, to try to cut down on further
16730 errors. */
16733 {
16736 }
16738 /* Check to see whether or not this declaration is a friend. */
16741 /* Enter the newly declared entry in the symbol table. If we're
16742 processing a declaration in a class-specifier, we wait until
16743 after processing the initializer. */
16745 {
16752 /* Adjust location of decl if declarator->id_loc is more appropriate:
16753 set, and decl wasn't merged with another decl, in which case its
16754 location would be different from input_location, and more accurate. */
16759 }
16761 /* Enter the SCOPE. That way unqualified names appearing in the
16762 initializer will be looked up in SCOPE. */
16765 /* Perform deferred access control checks, now that we know in which
16766 SCOPE the declared entity resides. */
16768 {
16771 /* If the entity being declared is a function, pretend that we
16772 are in its scope. If it is a `friend', it may have access to
16773 things that would not otherwise be accessible. */
16775 {
16778 }
16780 /* Perform access checks for template parameters. */
16783 /* Perform the access control checks for the declarator and the
16784 decl-specifiers. */
16787 /* Restore the saved value. */
16790 }
16792 /* Parse the initializer. */
16797 {
16799 {
16803 else
16804 {
16805 /* If the declaration was erroneous, we don't really
16806 know what the user intended, so just silently
16807 consume the initializer. */
16815 }
16816 }
16817 else
16818 {
16819 /* We want to record the extra mangling scope for in-class
16820 initializers of class members and initializers of static data
16821 member templates. The former involves deferring
16822 parsing of the initializer until end of class as with default
16823 arguments. So right here we only handle the latter. */
16833 }
16834 }
16836 /* The old parser allows attributes to appear after a parenthesized
16837 initializer. Mark Mitchell proposed removing this functionality
16838 on the GCC mailing lists on 2002-08-13. This parser accepts the
16839 attributes -- but ignores them. */
16846 /* A non-template declaration involving a function parameter list containing
16847 an implicit template parameter will have been made into a template. If it
16848 turns out that the resulting declaration is not an actual function then
16849 finish the template declaration here. An error message will already have
16850 been issued. */
16853 {
16855 {
16858 }
16860 }
16862 /* For an in-class declaration, use `grokfield' to create the
16863 declaration. */
16865 {
16867 {
16870 }
16878 }
16880 /* Finish processing the declaration. But, skip member
16881 declarations. */
16883 {
16886 asm_specification,
16887 /* If the initializer is in parentheses, then this is
16888 a direct-initialization, which means that an
16889 `explicit' constructor is OK. Otherwise, an
16890 `explicit' constructor cannot be used. */
16893 }
16896 /* Core issue #226 (C++0x only): A default template-argument
16897 shall not be specified in a friend class template
16898 declaration. */
16907 {
16910 else
16912 }
16915 }
16917 /* Parse a declarator.
16919 declarator:
16920 direct-declarator
16921 ptr-operator declarator
16923 abstract-declarator:
16924 ptr-operator abstract-declarator [opt]
16925 direct-abstract-declarator
16927 GNU Extensions:
16929 declarator:
16930 attributes [opt] direct-declarator
16931 attributes [opt] ptr-operator declarator
16933 abstract-declarator:
16934 attributes [opt] ptr-operator abstract-declarator [opt]
16935 attributes [opt] direct-abstract-declarator
16937 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
16938 detect constructor, destructor or conversion operators. It is set
16939 to -1 if the declarator is a name, and +1 if it is a
16940 function. Otherwise it is set to zero. Usually you just want to
16941 test for >0, but internally the negative value is used.
16943 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
16944 a decl-specifier-seq unless it declares a constructor, destructor,
16945 or conversion. It might seem that we could check this condition in
16946 semantic analysis, rather than parsing, but that makes it difficult
16947 to handle something like `f()'. We want to notice that there are
16948 no decl-specifiers, and therefore realize that this is an
16949 expression, not a declaration.)
16951 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
16952 the declarator is a direct-declarator of the form "(...)".
16954 MEMBER_P is true iff this declarator is a member-declarator. */
16958 cp_parser_declarator_kind dcl_kind,
16962 {
16965 cp_cv_quals cv_quals;
16966 tree class_type;
16969 /* Assume this is not a constructor, destructor, or type-conversion
16970 operator. */
16977 /* Check for the ptr-operator production. */
16979 /* Parse the ptr-operator. */
16985 /* If that worked, then we have a ptr-operator. */
16987 {
16988 /* If a ptr-operator was found, then this declarator was not
16989 parenthesized. */
16992 /* The dependent declarator is optional if we are parsing an
16993 abstract-declarator. */
16997 /* Parse the dependent declarator. */
17003 /* If we are parsing an abstract-declarator, we must handle the
17004 case where the dependent declarator is absent. */
17009 declarator = cp_parser_make_indirect_declarator
17011 }
17012 /* Everything else is a direct-declarator. */
17013 else
17014 {
17017 CPP_OPEN_PAREN);
17019 ctor_dtor_or_conv_p,
17020 member_p);
17021 }
17026 }
17028 /* Parse a direct-declarator or direct-abstract-declarator.
17030 direct-declarator:
17031 declarator-id
17032 direct-declarator ( parameter-declaration-clause )
17033 cv-qualifier-seq [opt]
17034 ref-qualifier [opt]
17035 exception-specification [opt]
17036 direct-declarator [ constant-expression [opt] ]
17037 ( declarator )
17039 direct-abstract-declarator:
17040 direct-abstract-declarator [opt]
17041 ( parameter-declaration-clause )
17042 cv-qualifier-seq [opt]
17043 ref-qualifier [opt]
17044 exception-specification [opt]
17045 direct-abstract-declarator [opt] [ constant-expression [opt] ]
17046 ( abstract-declarator )
17048 Returns a representation of the declarator. DCL_KIND is
17049 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
17050 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
17051 we are parsing a direct-declarator. It is
17052 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
17053 of ambiguity we prefer an abstract declarator, as per
17054 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
17055 cp_parser_declarator. */
17059 cp_parser_declarator_kind dcl_kind,
17062 {
17072 {
17073 /* Peek at the next token. */
17076 {
17077 /* This is either a parameter-declaration-clause, or a
17078 parenthesized declarator. When we know we are parsing a
17079 named declarator, it must be a parenthesized declarator
17080 if FIRST is true. For instance, `(int)' is a
17081 parameter-declaration-clause, with an omitted
17082 direct-abstract-declarator. But `((*))', is a
17083 parenthesized abstract declarator. Finally, when T is a
17084 template parameter `(T)' is a
17085 parameter-declaration-clause, and not a parenthesized
17086 named declarator.
17088 We first try and parse a parameter-declaration-clause,
17089 and then try a nested declarator (if FIRST is true).
17091 It is not an error for it not to be a
17092 parameter-declaration-clause, even when FIRST is
17093 false. Consider,
17095 int i (int);
17096 int i (3);
17098 The first is the declaration of a function while the
17099 second is the definition of a variable, including its
17100 initializer.
17102 Having seen only the parenthesis, we cannot know which of
17103 these two alternatives should be selected. Even more
17104 complex are examples like:
17106 int i (int (a));
17107 int i (int (3));
17109 The former is a function-declaration; the latter is a
17110 variable initialization.
17112 Thus again, we try a parameter-declaration-clause, and if
17113 that fails, we back out and return. */
17116 {
17117 tree params;
17120 /* In a member-declarator, the only valid interpretation
17121 of a parenthesis is the start of a
17122 parameter-declaration-clause. (It is invalid to
17123 initialize a static data member with a parenthesized
17124 initializer; only the "=" form of initialization is
17125 permitted.) */
17129 /* Consume the `('. */
17132 {
17133 /* If this is going to be an abstract declarator, we're
17134 in a declarator and we can't have default args. */
17137 }
17141 /* Parse the parameter-declaration-clause. */
17144 /* Consume the `)'. */
17147 /* If all went well, parse the cv-qualifier-seq,
17148 ref-qualifier and the exception-specification. */
17150 {
17151 cp_cv_quals cv_quals;
17152 cp_virt_specifiers virt_specifiers;
17153 cp_ref_qualifier ref_qual;
17154 tree exception_specification;
17155 tree late_return;
17156 tree attrs;
17166 /* Parse the cv-qualifier-seq. */
17168 /* Parse the ref-qualifier. */
17170 /* And the exception-specification. */
17171 exception_specification
17176 /* In here, we handle cases where attribute is used after
17177 the function declaration. For example:
17178 void func (int x) __attribute__((vector(..))); */
17181 {
17185 CPP_SEMICOLON)
17187 CPP_OPEN_BRACE))
17190 ;
17191 else
17193 }
17194 late_return = (cp_parser_late_return_type_opt
17199 /* Parse the virt-specifier-seq. */
17202 /* Create the function-declarator. */
17204 params,
17205 cv_quals,
17206 virt_specifiers,
17207 ref_qual,
17208 exception_specification,
17209 late_return);
17211 /* Any subsequent parameter lists are to do with
17212 return type, so are not those of the declared
17213 function. */
17215 }
17217 /* Remove the function parms from scope. */
17221 /* Repeat the main loop. */
17223 }
17225 /* If this is the first, we can try a parenthesized
17226 declarator. */
17228 {
17234 /* Consume the `('. */
17236 /* Parse the nested declarator. */
17239 declarator
17242 member_p);
17245 /* Expect a `)'. */
17252 }
17253 /* Otherwise, we must be done. */
17254 else
17256 }
17260 {
17261 /* Parse an array-declarator. */
17270 /* Consume the `['. */
17272 /* Peek at the next token. */
17274 /* If the next token is `]', then there is no
17275 constant-expression. */
17277 {
17279 bounds
17289 {
17290 /* Normally, the array bound must be an integral constant
17291 expression. However, as an extension, we allow VLAs
17292 in function scopes as long as they aren't part of a
17293 parameter declaration. */
17297 }
17300 {
17301 /* Remember this wasn't a constant-expression. */
17304 }
17305 }
17306 else
17308 /* Look for the closing `]'. */
17310 {
17313 }
17318 }
17320 {
17321 {
17322 tree qualifying_scope;
17323 tree unqualified_name;
17324 tree attrs;
17325 special_function_kind sfk;
17330 /* Parse a declarator-id */
17333 {
17336 /* If we see an ellipsis, we should be looking at a
17337 parameter pack. */
17339 {
17340 /* Consume the `...' */
17344 }
17345 }
17348 unqualified_name
17352 {
17356 {
17357 /* Check whether an error occurred. */
17360 /* We already consumed the ellipsis to mark a
17361 parameter pack, but we have no way to report it,
17362 so abort the tentative parse. We will be exiting
17363 immediately anyway. */
17365 }
17366 else
17372 && (qualifying_scope
17374 {
17377 }
17378 }
17383 {
17388 }
17394 {
17395 /* In the declaration of a member of a template class
17396 outside of the class itself, the SCOPE will sometimes
17397 be a TYPENAME_TYPE. For example, given:
17399 template <typename T>
17400 int S<T>::R::i = 3;
17402 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
17403 this context, we must resolve S<T>::R to an ordinary
17404 type, rather than a typename type.
17406 The reason we normally avoid resolving TYPENAME_TYPEs
17407 is that a specialization of `S' might render
17408 `S<T>::R' not a type. However, if `S' is
17409 specialized, then this `i' will not be used, so there
17410 is no harm in resolving the types here. */
17411 tree type;
17413 /* Resolve the TYPENAME_TYPE. */
17416 /* If that failed, the declarator is invalid. */
17418 {
17421 "cannot define member of dependent typedef "
17423 else
17428 }
17430 }
17435 {
17436 tree class_type;
17441 else
17445 {
17448 {
17451 {
17455 "use %<%T::%D%> instead of %<%T::%D%> to "
17457 class_type,
17462 }
17463 else
17465 }
17466 else
17467 {
17468 /* We do not attempt to print the declarator
17469 here because we do not have enough
17470 information about its original syntactic
17471 form. */
17475 }
17476 }
17479 {
17485 for an anonymous type, even if the type
17486 got a name for linkage purposes. */
17489 class_type))
17490 {
17493 }
17501 }
17502 }
17504 unqualified_name,
17505 sfk);
17512 }
17514 handle_declarator:;
17517 {
17518 /* Any names that appear after the declarator-id for a
17519 member are looked up in the containing scope. */
17521 {
17522 /* But declarations with qualified-ids can't appear in a
17523 function. */
17527 }
17529 }
17533 /* Default args are only allowed on function
17534 declarations. */
17536 else
17540 }
17541 /* We're done. */
17542 else
17544 }
17546 /* For an abstract declarator, we might wind up with nothing at this
17547 point. That's an error; the declarator is not optional. */
17551 /* If we entered a scope, we must exit it now. */
17559 }
17561 /* Parse a ptr-operator.
17563 ptr-operator:
17564 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17565 * cv-qualifier-seq [opt]
17566 &
17567 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
17568 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17570 GNU Extension:
17572 ptr-operator:
17573 & cv-qualifier-seq [opt]
17575 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
17576 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
17577 an rvalue reference. In the case of a pointer-to-member, *TYPE is
17578 filled in with the TYPE containing the member. *CV_QUALS is
17579 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
17580 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
17581 Note that the tree codes returned by this function have nothing
17582 to do with the types of trees that will be eventually be created
17583 to represent the pointer or reference type being parsed. They are
17584 just constants with suggestive names. */
17585 static enum tree_code
17590 {
17595 /* Assume that it's not a pointer-to-member. */
17597 /* And that there are no cv-qualifiers. */
17600 /* Peek at the next token. */
17603 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
17613 {
17614 /* Consume the `*', `&' or `&&'. */
17617 /* A `*' can be followed by a cv-qualifier-seq, and so can a
17618 `&', if we are allowing GNU extensions. (The only qualifier
17619 that can legally appear after `&' is `restrict', but that is
17620 enforced during semantic analysis. */
17628 }
17629 else
17630 {
17631 /* Try the pointer-to-member case. */
17633 /* Look for the optional `::' operator. */
17636 /* Look for the nested-name specifier. */
17643 /* If we found it, and the next token is a `*', then we are
17644 indeed looking at a pointer-to-member operator. */
17647 {
17648 /* Indicate that the `*' operator was used. */
17656 else
17657 {
17658 /* The type of which the member is a member is given by the
17659 current SCOPE. */
17661 /* The next name will not be qualified. */
17665 /* Look for optional c++11 attributes. */
17669 /* Look for the optional cv-qualifier-seq. */
17671 }
17672 }
17673 /* If that didn't work we don't have a ptr-operator. */
17676 }
17679 }
17681 /* Parse an (optional) cv-qualifier-seq.
17683 cv-qualifier-seq:
17684 cv-qualifier cv-qualifier-seq [opt]
17686 cv-qualifier:
17687 const
17688 volatile
17690 GNU Extension:
17692 cv-qualifier:
17693 __restrict__
17695 Returns a bitmask representing the cv-qualifiers. */
17697 static cp_cv_quals
17699 {
17703 {
17705 cp_cv_quals cv_qualifier;
17707 /* Peek at the next token. */
17709 /* See if it's a cv-qualifier. */
17711 {
17727 }
17733 {
17736 }
17737 else
17738 {
17741 }
17742 }
17745 }
17747 /* Parse an (optional) ref-qualifier
17749 ref-qualifier:
17750 &
17751 &&
17753 Returns cp_ref_qualifier representing ref-qualifier. */
17755 static cp_ref_qualifier
17757 {
17760 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
17765 {
17770 {
17782 }
17787 {
17790 }
17791 else
17792 {
17795 }
17796 }
17799 }
17801 /* Parse an (optional) virt-specifier-seq.
17803 virt-specifier-seq:
17804 virt-specifier virt-specifier-seq [opt]
17806 virt-specifier:
17807 override
17808 final
17810 Returns a bitmask representing the virt-specifiers. */
17812 static cp_virt_specifiers
17814 {
17818 {
17820 cp_virt_specifiers virt_specifier;
17822 /* Peek at the next token. */
17824 /* See if it's a virt-specifier-qualifier. */
17828 {
17831 }
17833 {
17836 }
17838 {
17840 }
17841 else
17845 {
17848 }
17849 else
17850 {
17853 }
17854 }
17856 }
17858 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
17859 is in scope even though it isn't real. */
17861 void
17863 {
17864 tree this_parm;
17867 {
17868 /* We don't clear this between NSDMIs. Is it already what we want? */
17873 }
17876 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
17878 current_class_ref
17881 }
17883 /* Return true iff our current scope is a non-static data member
17884 initializer. */
17886 bool
17888 {
17889 /* We recognize NSDMI context by the context-less 'this' pointer set up
17890 by the function above. */
17894 }
17896 /* Parse a late-specified return type, if any. This is not a separate
17897 non-terminal, but part of a function declarator, which looks like
17899 -> trailing-type-specifier-seq abstract-declarator(opt)
17901 Returns the type indicated by the type-id.
17903 In addition to this this parses any queued up omp declare simd
17904 clauses and Cilk Plus SIMD-enabled function's vector attributes.
17906 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
17907 function. */
17909 static tree
17911 cp_cv_quals quals)
17912 {
17916 && declarator
17922 /* Peek at the next token. */
17924 /* A late-specified return type is indicated by an initial '->'. */
17931 {
17932 /* DR 1207: 'this' is in scope in the trailing return type. */
17934 }
17937 {
17938 /* Consume the ->. */
17942 }
17945 declarator->std_attributes
17949 declarator->std_attributes
17954 {
17957 }
17960 }
17962 /* Parse a declarator-id.
17964 declarator-id:
17965 id-expression
17966 :: [opt] nested-name-specifier [opt] type-name
17968 In the `id-expression' case, the value returned is as for
17969 cp_parser_id_expression if the id-expression was an unqualified-id.
17970 If the id-expression was a qualified-id, then a SCOPE_REF is
17971 returned. The first operand is the scope (either a NAMESPACE_DECL
17972 or TREE_TYPE), but the second is still just a representation of an
17973 unqualified-id. */
17975 static tree
17977 {
17978 tree id;
17979 /* The expression must be an id-expression. Assume that qualified
17980 names are the names of types so that:
17982 template <class T>
17983 int S<T>::R::i = 3;
17985 will work; we must treat `S<T>::R' as the name of a type.
17986 Similarly, assume that qualified names are templates, where
17987 required, so that:
17989 template <class T>
17990 int S<T>::R<T>::i = 3;
17992 will work, too. */
17998 optional_p);
18002 }
18004 /* Parse a type-id.
18006 type-id:
18007 type-specifier-seq abstract-declarator [opt]
18009 Returns the TYPE specified. */
18011 static tree
18014 {
18015 cp_decl_specifier_seq type_specifier_seq;
18018 /* Parse the type-specifier-seq. */
18020 is_trailing_return,
18025 /* There might or might not be an abstract declarator. */
18027 /* Look for the declarator. */
18028 abstract_declarator
18032 /* Check to see if there really was a declarator. */
18037 /* None of the valid uses of 'auto' in C++14 involve the type-id
18038 nonterminal, but it is valid in a trailing-return-type. */
18041 {
18042 /* A type-id with type 'auto' is only ok if the abstract declarator
18043 is a function declarator with a late-specified return type. */
18048 else
18049 {
18052 }
18053 }
18056 is_template_arg);
18057 }
18060 {
18062 }
18065 {
18066 tree r;
18068 parser->type_definition_forbidden_message
18073 {
18076 }
18078 }
18081 {
18083 }
18085 /* Parse a type-specifier-seq.
18087 type-specifier-seq:
18088 type-specifier type-specifier-seq [opt]
18090 GNU extension:
18092 type-specifier-seq:
18093 attributes type-specifier-seq [opt]
18095 If IS_DECLARATION is true, we are at the start of a "condition" or
18096 exception-declaration, so we might be followed by a declarator-id.
18098 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
18099 i.e. we've just seen "->".
18101 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
18103 static void
18108 {
18113 /* Clear the TYPE_SPECIFIER_SEQ. */
18116 /* In the context of a trailing return type, enum E { } is an
18117 elaborated-type-specifier followed by a function-body, not an
18118 enum-specifier. */
18122 /* Parse the type-specifiers and attributes. */
18124 {
18125 tree type_specifier;
18128 /* Check for attributes first. */
18130 {
18135 }
18137 /* record the token of the beginning of the type specifier seq,
18138 for error reporting purposes*/
18142 /* Look for the type-specifier. */
18144 flags,
18145 type_specifier_seq,
18147 NULL,
18150 {
18151 /* If the first type-specifier could not be found, this is not a
18152 type-specifier-seq at all. */
18154 {
18155 /* Set in_declarator_p to avoid skipping to the semicolon. */
18167 }
18168 /* If subsequent type-specifiers could not be found, the
18169 type-specifier-seq is complete. */
18171 }
18174 /* The standard says that a condition can be:
18176 type-specifier-seq declarator = assignment-expression
18178 However, given:
18180 struct S {};
18181 if (int S = ...)
18183 we should treat the "S" as a declarator, not as a
18184 type-specifier. The standard doesn't say that explicitly for
18185 type-specifier-seq, but it does say that for
18186 decl-specifier-seq in an ordinary declaration. Perhaps it
18187 would be clearer just to allow a decl-specifier-seq here, and
18188 then add a semantic restriction that if any decl-specifiers
18189 that are not type-specifiers appear, the program is invalid. */
18192 }
18193 }
18195 /* Return whether the function currently being declared has an associated
18196 template parameter list. */
18198 static bool
18200 {
18213 }
18215 /* Parse a parameter-declaration-clause.
18217 parameter-declaration-clause:
18218 parameter-declaration-list [opt] ... [opt]
18219 parameter-declaration-list , ...
18221 Returns a representation for the parameter declarations. A return
18222 value of NULL indicates a parameter-declaration-clause consisting
18223 only of an ellipsis. */
18225 static tree
18227 {
18228 tree parameters;
18237 parser->auto_is_implicit_function_template_parm_p
18239 }
18245 && !processing_template_parmlist
18251 /* Peek at the next token. */
18253 /* Check for trivial parameter-declaration-clauses. */
18255 {
18256 /* Consume the `...' token. */
18259 }
18261 /* There are no parameters. */
18262 {
18263 #ifndef NO_IMPLICIT_EXTERN_C
18268 else
18269 #endif
18271 }
18272 /* Check for `(void)', too, which is a special case. */
18276 {
18277 /* Consume the `void' token. */
18279 /* There are no parameters. */
18281 }
18283 /* Parse the parameter-declaration-list. */
18285 /* If a parse error occurred while parsing the
18286 parameter-declaration-list, then the entire
18287 parameter-declaration-clause is erroneous. */
18291 /* Peek at the next token. */
18293 /* If it's a `,', the clause should terminate with an ellipsis. */
18295 {
18296 /* Consume the `,'. */
18298 /* Expect an ellipsis. */
18299 ellipsis_p
18301 }
18302 /* It might also be `...' if the optional trailing `,' was
18303 omitted. */
18305 {
18306 /* Consume the `...' token. */
18308 /* And remember that we saw it. */
18310 }
18311 else
18314 /* Finish the parameter list. */
18319 }
18321 /* Parse a parameter-declaration-list.
18323 parameter-declaration-list:
18324 parameter-declaration
18325 parameter-declaration-list , parameter-declaration
18327 Returns a representation of the parameter-declaration-list, as for
18328 cp_parser_parameter_declaration_clause. However, the
18329 `void_list_node' is never appended to the list. Upon return,
18330 *IS_ERROR will be true iff an error occurred. */
18332 static tree
18334 {
18340 /* Assume all will go well. */
18342 /* The special considerations that apply to a function within an
18343 unbraced linkage specifications do not apply to the parameters
18344 to the function. */
18345 saved_in_unbraced_linkage_specification_p
18349 /* Look for more parameters. */
18351 {
18359 /* Parse the parameter. */
18360 parameter
18365 /* We don't know yet if the enclosing context is deprecated, so wait
18366 and warn in grokparms if appropriate. */
18370 {
18371 /* If a function parameter pack was specified and an implicit template
18372 parameter was introduced during cp_parser_parameter_declaration,
18373 change any implicit parameters introduced into packs. */
18377 {
18385 }
18389 PARM,
18392 }
18396 /* If a parse error occurred parsing the parameter declaration,
18397 then the entire parameter-declaration-list is erroneous. */
18399 {
18403 }
18413 {
18417 }
18419 /* Add the new parameter to the list. */
18423 /* Peek at the next token. */
18426 /* These are for Objective-C++ */
18429 /* The parameter-declaration-list is complete. */
18432 {
18435 /* Peek at the next token. */
18437 /* If it's an ellipsis, then the list is complete. */
18440 /* Otherwise, there must be more parameters. Consume the
18441 `,'. */
18443 /* When parsing something like:
18445 int i(float f, double d)
18447 we can tell after seeing the declaration for "f" that we
18448 are not looking at an initialization of a variable "i",
18449 but rather at the declaration of a function "i".
18451 Due to the fact that the parsing of template arguments
18452 (as specified to a template-id) requires backtracking we
18453 cannot use this technique when inside a template argument
18454 list. */
18458 /* However, a parameter-declaration of the form
18459 "float(f)" (which is a valid declaration of a
18460 parameter "f") can also be interpreted as an
18461 expression (the conversion of "f" to "float"). */
18464 }
18465 else
18466 {
18474 }
18475 }
18477 parser->in_unbraced_linkage_specification_p
18480 /* Reset implicit_template_scope if we are about to leave the function
18481 parameter list that introduced it. Note that for out-of-line member
18482 definitions, there will be one or more class scopes before we get to
18483 the template parameter scope. */
18487 {
18491 {
18494 }
18495 }
18498 }
18500 /* Parse a parameter declaration.
18502 parameter-declaration:
18503 decl-specifier-seq ... [opt] declarator
18504 decl-specifier-seq declarator = assignment-expression
18505 decl-specifier-seq ... [opt] abstract-declarator [opt]
18506 decl-specifier-seq abstract-declarator [opt] = assignment-expression
18508 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
18509 declares a template parameter. (In that case, a non-nested `>'
18510 token encountered during the parsing of the assignment-expression
18511 is not interpreted as a greater-than operator.)
18513 Returns a representation of the parameter, or NULL if an error
18514 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
18515 true iff the declarator is of the form "(p)". */
18521 {
18523 cp_decl_specifier_seq decl_specifiers;
18525 tree default_argument;
18529 /* In a template parameter, `>' is not an operator.
18531 [temp.param]
18533 When parsing a default template-argument for a non-type
18534 template-parameter, the first non-nested `>' is taken as the end
18535 of the template parameter-list rather than a greater-than
18536 operator. */
18538 /* Type definitions may not appear in parameter types. */
18540 parser->type_definition_forbidden_message
18543 /* Parse the declaration-specifiers. */
18545 CP_PARSER_FLAGS_NONE,
18549 /* Complain about missing 'typename' or other invalid type names. */
18554 /* If an error occurred, there's no reason to attempt to parse the
18555 rest of the declaration. */
18557 {
18560 }
18562 /* Peek at the next token. */
18565 /* If the next token is a `)', `,', `=', `>', or `...', then there
18566 is no declarator. However, when variadic templates are enabled,
18567 there may be a declarator following `...'. */
18572 {
18576 }
18577 /* Otherwise, there should be a declarator. */
18578 else
18579 {
18583 /* After seeing a decl-specifier-seq, if the next token is not a
18584 "(", there is no possibility that the code is a valid
18585 expression. Therefore, if parsing tentatively, we commit at
18586 this point. */
18588 /* In an expression context, having seen:
18590 (int((char ...
18592 we cannot be sure whether we are looking at a
18593 function-type (taking a "char" as a parameter) or a cast
18594 of some object of type "char" to "int". */
18600 /* Parse the declarator. */
18603 CP_PARSER_DECLARATOR_EITHER,
18605 parenthesized_p,
18608 /* After the declarator, allow more attributes. */
18609 decl_specifiers.attributes
18612 }
18614 /* If the next token is an ellipsis, and we have not seen a
18615 declarator name, and the type of the declarator contains parameter
18616 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
18617 a parameter pack expansion expression. Otherwise, leave the
18618 ellipsis for a C-style variadic function. */
18621 {
18632 {
18633 /* Consume the `...'. */
18637 /* Build a pack expansion type */
18640 else
18642 }
18643 }
18645 /* The restriction on defining new types applies only to the type
18646 of the parameter, not to the default argument. */
18649 /* If the next token is `=', then process a default argument. */
18651 {
18653 /* If we are defining a class, then the tokens that make up the
18654 default argument must be saved and processed later. */
18659 /* Outside of a class definition, we can just parse the
18660 assignment-expression. */
18661 else
18662 default_argument
18666 {
18669 else
18670 {
18672 "default arguments are only "
18675 }
18676 }
18680 {
18681 /* Find the name of the parameter pack. */
18688 template_parm_p
18694 else
18696 template_parm_p
18703 }
18704 }
18705 else
18709 declarator,
18710 default_argument);
18711 }
18713 /* Parse a default argument and return it.
18715 TEMPLATE_PARM_P is true if this is a default argument for a
18716 non-type template parameter. */
18717 static tree
18719 {
18725 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
18726 set correctly. */
18729 /* Local variable names (and the `this' keyword) may not
18730 appear in a default argument. */
18733 /* Parse the assignment-expression. */
18738 /* The "this" pointer is not valid in a default argument. */
18740 {
18745 }
18746 default_argument
18748 /* Restore the "this" pointer. */
18750 {
18753 }
18762 }
18764 /* Parse a function-body.
18766 function-body:
18767 compound_statement */
18769 static void
18771 {
18773 }
18775 /* Parse a ctor-initializer-opt followed by a function-body. Return
18776 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
18777 is true we are parsing a function-try-block. */
18779 static bool
18782 {
18790 /* Begin the function body. */
18792 /* Parse the optional ctor-initializer. */
18795 /* If we're parsing a constexpr constructor definition, we need
18796 to check that the constructor body is indeed empty. However,
18797 before we get to cp_parser_function_body lot of junk has been
18798 generated, so we can't just check that we have an empty block.
18799 Rather we take a snapshot of the outermost block, and check whether
18800 cp_parser_function_body changed its state. */
18802 {
18806 }
18807 /* Parse the function-body. */
18811 /* Finish the function body. */
18815 }
18817 /* Parse an initializer.
18819 initializer:
18820 = initializer-clause
18821 ( expression-list )
18823 Returns an expression representing the initializer. If no
18824 initializer is present, NULL_TREE is returned.
18826 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
18827 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
18828 set to TRUE if there is no initializer present. If there is an
18829 initializer, and it is not a constant-expression, *NON_CONSTANT_P
18830 is set to true; otherwise it is set to false. */
18832 static tree
18835 {
18837 tree init;
18839 /* Peek at the next token. */
18842 /* Let our caller know whether or not this initializer was
18843 parenthesized. */
18845 /* Assume that the initializer is constant. */
18849 {
18850 /* Consume the `='. */
18852 /* Parse the initializer-clause. */
18854 }
18856 {
18861 non_constant_p);
18866 }
18868 {
18873 }
18874 else
18875 {
18876 /* Anything else is an error. */
18879 }
18882 }
18884 /* Parse an initializer-clause.
18886 initializer-clause:
18887 assignment-expression
18888 braced-init-list
18890 Returns an expression representing the initializer.
18892 If the `assignment-expression' production is used the value
18893 returned is simply a representation for the expression.
18895 Otherwise, calls cp_parser_braced_list. */
18897 static tree
18899 {
18900 tree initializer;
18902 /* Assume the expression is constant. */
18905 /* If it is not a `{', then we are looking at an
18906 assignment-expression. */
18908 {
18909 initializer
18912 non_constant_p);
18913 }
18914 else
18918 }
18920 /* Parse a brace-enclosed initializer list.
18922 braced-init-list:
18923 { initializer-list , [opt] }
18924 { }
18926 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
18927 the elements of the initializer-list (or NULL, if the last
18928 production is used). The TREE_TYPE for the CONSTRUCTOR will be
18929 NULL_TREE. There is no way to detect whether or not the optional
18930 trailing `,' was provided. NON_CONSTANT_P is as for
18931 cp_parser_initializer. */
18933 static tree
18935 {
18936 tree initializer;
18938 /* Consume the `{' token. */
18940 /* Create a CONSTRUCTOR to represent the braced-initializer. */
18942 /* If it's not a `}', then there is a non-trivial initializer. */
18944 {
18945 /* Parse the initializer list. */
18948 /* A trailing `,' token is allowed. */
18951 }
18952 else
18954 /* Now, there should be a trailing `}'. */
18958 }
18960 /* Parse an initializer-list.
18962 initializer-list:
18963 initializer-clause ... [opt]
18964 initializer-list , initializer-clause ... [opt]
18966 GNU Extension:
18968 initializer-list:
18969 designation initializer-clause ...[opt]
18970 initializer-list , designation initializer-clause ...[opt]
18972 designation:
18973 . identifier =
18974 identifier :
18975 [ constant-expression ] =
18977 Returns a vec of constructor_elt. The VALUE of each elt is an expression
18978 for the initializer. If the INDEX of the elt is non-NULL, it is the
18979 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
18980 as for cp_parser_initializer. */
18984 {
18987 /* Assume all of the expressions are constant. */
18990 /* Parse the rest of the list. */
18992 {
18994 tree designator;
18995 tree initializer;
18998 /* If the next token is an identifier and the following one is a
18999 colon, we are looking at the GNU designated-initializer
19000 syntax. */
19004 {
19005 /* Warn the user that they are using an extension. */
19008 /* Consume the identifier. */
19010 /* Consume the `:'. */
19012 }
19013 /* Also handle the C99 syntax, '. id ='. */
19018 {
19019 /* Warn the user that they are using an extension. */
19022 /* Consume the `.'. */
19024 /* Consume the identifier. */
19026 /* Consume the `='. */
19028 }
19029 /* Also handle C99 array designators, '[ const ] ='. */
19033 {
19034 /* In C++11, [ could start a lambda-introducer. */
19046 }
19047 else
19050 /* Parse the initializer. */
19053 /* If any clause is non-constant, so is the entire initializer. */
19057 /* If we have an ellipsis, this is an initializer pack
19058 expansion. */
19060 {
19061 /* Consume the `...'. */
19064 /* Turn the initializer into an initializer expansion. */
19066 }
19068 /* Add it to the vector. */
19071 /* If the next token is not a comma, we have reached the end of
19072 the list. */
19076 /* Peek at the next token. */
19078 /* If the next token is a `}', then we're still done. An
19079 initializer-clause can have a trailing `,' after the
19080 initializer-list and before the closing `}'. */
19084 /* Consume the `,' token. */
19086 }
19089 }
19091 /* Classes [gram.class] */
19093 /* Parse a class-name.
19095 class-name:
19096 identifier
19097 template-id
19099 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
19100 to indicate that names looked up in dependent types should be
19101 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
19102 keyword has been used to indicate that the name that appears next
19103 is a template. TAG_TYPE indicates the explicit tag given before
19104 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
19105 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
19106 is the class being defined in a class-head.
19108 Returns the TYPE_DECL representing the class. */
19110 static tree
19118 {
19119 tree decl;
19120 tree scope;
19125 /* All class-names start with an identifier. */
19128 {
19131 }
19133 /* PARSER->SCOPE can be cleared when parsing the template-arguments
19134 to a template-id, so we save it here. */
19139 /* Any name names a type if we're following the `typename' keyword
19140 in a qualified name where the enclosing scope is type-dependent. */
19143 /* Handle the common case (an identifier, but not a template-id)
19144 efficiently. */
19147 {
19151 /* Look for the identifier. */
19155 /* If the next token isn't an identifier, we are certainly not
19156 looking at a class-name. */
19159 /* If we know this is a type-name, there's no need to look it
19160 up. */
19163 else
19164 {
19165 tree ambiguous_decls;
19166 /* If we already know that this lookup is ambiguous, then
19167 we've already issued an error message; there's no reason
19168 to check again. */
19170 {
19173 }
19174 /* If the next token is a `::', then the name must be a type
19175 name.
19177 [basic.lookup.qual]
19179 During the lookup for a name preceding the :: scope
19180 resolution operator, object, function, and enumerator
19181 names are ignored. */
19184 /* Look up the name. */
19186 tag_type,
19189 check_dependency_p,
19193 {
19197 }
19198 }
19199 }
19200 else
19201 {
19202 /* Try a template-id. */
19204 check_dependency_p,
19205 tag_type,
19206 is_declaration);
19209 }
19213 /* If this is a typename, create a TYPENAME_TYPE. */
19215 {
19220 }
19224 /* Check to see that it is really the name of a class. */
19228 /* Situations like this:
19230 template <typename T> struct A {
19231 typename T::template X<int>::I i;
19232 };
19234 are problematic. Is `T::template X<int>' a class-name? The
19235 standard does not seem to be definitive, but there is no other
19236 valid interpretation of the following `::'. Therefore, those
19237 names are considered class-names. */
19238 {
19242 }
19246 /* In Objective-C 2.0, a classname followed by '.' starts a
19247 dot-syntax expression, and it's not a type-name. */
19259 }
19261 /* Parse a class-specifier.
19263 class-specifier:
19264 class-head { member-specification [opt] }
19266 Returns the TREE_TYPE representing the class. */
19268 static tree
19270 {
19271 tree type;
19285 /* Parse the class-head. */
19288 /* If the class-head was a semantic disaster, skip the entire body
19289 of the class. */
19291 {
19295 }
19297 /* Look for the `{'. */
19299 {
19302 }
19306 /* Issue an error message if type-definitions are forbidden here. */
19308 /* Remember that we are defining one more class. */
19310 /* Inside the class, surrounding template-parameter-lists do not
19311 apply. */
19312 saved_num_template_parameter_lists
19315 /* We are not in a function body. */
19318 /* Or in a loop. */
19321 /* Or in a switch. */
19324 /* We are not immediately inside an extern "lang" block. */
19325 saved_in_unbraced_linkage_specification_p
19329 /* Start the class. */
19331 {
19334 }
19338 /* If the type is erroneous, skip the entire body of the class. */
19340 else
19341 /* Parse the member-specification. */
19344 /* Look for the trailing `}'. */
19346 /* Look for trailing attributes to apply to this class. */
19354 /* We've finished a type definition. Check for the common syntax
19355 error of forgetting a semicolon after the definition. We need to
19356 be careful, as we can't just check for not-a-semicolon and be done
19357 with it; the user might have typed:
19359 class X { } c = ...;
19360 class X { } *p = ...;
19362 and so forth. Instead, enumerate all the possible tokens that
19363 might follow this production; if we don't see one of them, then
19364 complain and silently insert the semicolon. */
19365 {
19370 /* Don't try to parse c++11 attributes here. As per the
19371 grammar, that should be a task for
19372 cp_parser_decl_specifier_seq. */
19376 {
19387 /* While it's legal for type qualifiers and storage class
19388 specifiers to follow type definitions in the grammar, only
19389 compiler testsuites contain code like that. Assume that if
19390 we see such code, then what we're really seeing is a case
19391 like:
19393 class X { }
19394 const <type> var = ...;
19396 or
19398 class Y { }
19399 static <type> func (...) ...
19401 i.e. the qualifier or specifier applies to the next
19402 declaration. To do so, however, we need to look ahead one
19403 more token to see if *that* token is a type specifier.
19405 This code could be improved to handle:
19407 class Z { }
19408 static const <type> var = ...; */
19411 {
19414 /* Handling user-defined types here would be nice, but very
19415 tricky. */
19416 want_semicolon
19419 }
19423 }
19425 /* If we don't have a type, then something is very wrong and we
19426 shouldn't try to do anything clever. Likewise for not seeing the
19427 closing brace. */
19429 {
19430 cp_token_position prev
19441 else
19444 /* Unget one token and smash it to look as though we encountered
19445 a semicolon in the input stream. */
19450 }
19451 }
19453 /* If this class is not itself within the scope of another class,
19454 then we need to parse the bodies of all of the queued function
19455 definitions. Note that the queued functions defined in a class
19456 are not always processed immediately following the
19457 class-specifier for that class. Consider:
19459 struct A {
19460 struct B { void f() { sizeof (A); } };
19461 };
19463 If `f' were processed before the processing of `A' were
19464 completed, there would be no way to compute the size of `A'.
19465 Note that the nesting we are interested in here is lexical --
19466 not the semantic nesting given by TYPE_CONTEXT. In particular,
19467 for:
19469 struct A { struct B; };
19470 struct A::B { void f() { } };
19472 there is no need to delay the parsing of `A::B::f'. */
19474 {
19475 tree decl;
19482 /* In a first pass, parse default arguments to the functions.
19483 Then, in a second pass, parse the bodies of the functions.
19484 This two-phased approach handles cases like:
19486 struct S {
19487 void f() { g(); }
19488 void g(int i = 3);
19489 };
19491 */
19493 {
19495 /* If there are default arguments that have not yet been processed,
19496 take care of them now. */
19498 {
19503 }
19504 /* Make sure that any template parameters are in scope. */
19506 /* Parse the default argument expressions. */
19508 /* Remove any template parameters from the symbol table. */
19510 }
19512 /* Now parse any NSDMIs. */
19516 {
19518 {
19523 }
19526 }
19533 /* Now do some post-NSDMI bookkeeping. */
19539 /* Now parse the body of the functions. */
19541 {
19542 /* OpenMP UDRs need to be parsed before all other functions. */
19549 }
19550 else
19554 }
19555 else
19558 /* Put back any saved access checks. */
19561 /* Restore saved state. */
19565 parser->num_template_parameter_lists
19567 parser->in_unbraced_linkage_specification_p
19571 }
19573 static tree
19575 {
19576 tree ret;
19581 }
19583 /* Parse a class-head.
19585 class-head:
19586 class-key identifier [opt] base-clause [opt]
19587 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
19588 class-key nested-name-specifier [opt] template-id
19589 base-clause [opt]
19591 class-virt-specifier:
19592 final
19594 GNU Extensions:
19595 class-key attributes identifier [opt] base-clause [opt]
19596 class-key attributes nested-name-specifier identifier base-clause [opt]
19597 class-key attributes nested-name-specifier [opt] template-id
19598 base-clause [opt]
19600 Upon return BASES is initialized to the list of base classes (or
19601 NULL, if there are none) in the same form returned by
19602 cp_parser_base_clause.
19604 Returns the TYPE of the indicated class. Sets
19605 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
19606 involving a nested-name-specifier was used, and FALSE otherwise.
19608 Returns error_mark_node if this is not a class-head.
19610 Returns NULL_TREE if the class-head is syntactically valid, but
19611 semantically invalid in a way that means we should skip the entire
19612 body of the class. */
19614 static tree
19617 {
19618 tree nested_name_specifier;
19622 tree attributes;
19623 tree bases;
19633 /* Assume no nested-name-specifier will be present. */
19635 /* Assume no template parameter lists will be used in defining the
19636 type. */
19640 /* Look for the class-key. */
19645 /* Parse the attributes. */
19648 /* If the next token is `::', that is invalid -- but sometimes
19649 people do try to write:
19651 struct ::S {};
19653 Handle this gracefully by accepting the extra qualifier, and then
19654 issuing an error about it later if this really is a
19655 class-head. If it turns out just to be an elaborated type
19656 specifier, remain silent. */
19662 /* Determine the name of the class. Begin by looking for an
19663 optional nested-name-specifier. */
19665 nested_name_specifier
19671 /* If there was a nested-name-specifier, then there *must* be an
19672 identifier. */
19674 {
19676 /* Although the grammar says `identifier', it really means
19677 `class-name' or `template-name'. You are only allowed to
19678 define a class that has already been declared with this
19679 syntax.
19681 The proposed resolution for Core Issue 180 says that wherever
19682 you see `class T::X' you should treat `X' as a type-name.
19684 It is OK to define an inaccessible class; for example:
19686 class A { class B; };
19687 class A::B {};
19689 We do not know if we will see a class-name, or a
19690 template-name. We look for a class-name first, in case the
19691 class-name is a template-id; if we looked for the
19692 template-name first we would stop after the template-name. */
19697 class_type,
19701 /* If that didn't work, ignore the nested-name-specifier. */
19703 {
19709 }
19710 /* If we could not find a corresponding TYPE, treat this
19711 declaration like an unqualified declaration. */
19714 /* Otherwise, count the number of templates used in TYPE and its
19715 containing scopes. */
19716 else
19717 {
19718 tree scope;
19730 }
19731 }
19732 /* Otherwise, the identifier is optional. */
19733 else
19734 {
19735 /* We don't know whether what comes next is a template-id,
19736 an identifier, or nothing at all. */
19738 /* Check for a template-id. */
19743 class_key,
19745 /* If that didn't work, it could still be an identifier. */
19747 {
19749 {
19752 }
19753 else
19755 }
19756 else
19757 {
19760 }
19761 }
19766 {
19768 class_key,
19770 }
19773 /* If it's not a `:' or a `{' then we can't really be looking at a
19774 class-head, since a class-head only appears as part of a
19775 class-specifier. We have to detect this situation before calling
19776 xref_tag, since that has irreversible side-effects. */
19778 {
19782 }
19784 /* At this point, we're going ahead with the class-specifier, even
19785 if some other problem occurs. */
19788 {
19793 }
19794 /* Issue the error about the overly-qualified name now. */
19796 {
19801 }
19803 {
19808 }
19810 {
19811 tree scope;
19813 /* Reject typedef-names in class heads. */
19815 {
19818 type);
19821 }
19823 /* Figure out in what scope the declaration is being placed. */
19825 /* If that scope does not contain the scope in which the
19826 class was originally declared, the program is invalid. */
19828 {
19831 "declaration of %qD in namespace %qD which does not "
19834 else
19840 }
19841 /* [dcl.meaning]
19843 A declarator-id shall not be qualified except for the
19844 definition of a ... nested class outside of its class
19845 ... [or] the definition or explicit instantiation of a
19846 class member of a namespace outside of its namespace. */
19848 {
19853 }
19854 }
19855 /* An explicit-specialization must be preceded by "template <>". If
19856 it is not, try to recover gracefully. */
19860 {
19864 /* Take the same action that would have been taken by
19865 cp_parser_explicit_specialization. */
19868 }
19869 /* There must be no "return" statements between this point and the
19870 end of this function; set "type "to the correct return value and
19871 use "goto done;" to return. */
19872 /* Make sure that the right number of template parameters were
19873 present. */
19877 {
19878 /* If something went wrong, there is no point in even trying to
19879 process the class-definition. */
19882 }
19884 /* Look up the type. */
19886 {
19890 {
19894 }
19895 else
19896 {
19899 }
19902 }
19904 {
19905 tree class_type;
19907 /* Given:
19909 template <typename T> struct S { struct T };
19910 template <typename T> struct S<T>::T { };
19912 we will get a TYPENAME_TYPE when processing the definition of
19913 `S::T'. We need to resolve it to the actual type before we
19914 try to define it. */
19916 {
19921 else
19922 {
19925 }
19926 }
19930 {
19933 }
19936 /* Enter the scope indicated by the nested-name-specifier. */
19938 /* Get the canonical version of this type. */
19940 /* Call push_template_decl if it seems like we should be defining a
19941 template either from the template headers or the type we're
19942 defining, so that we diagnose both extra and missing headers. */
19948 {
19951 {
19954 }
19955 }
19959 }
19961 {
19962 /* If the class was unnamed, create a dummy name. */
19967 }
19969 /* Indicate whether this class was declared as a `class' or as a
19970 `struct'. */
19975 /* If this type was already complete, and we see another definition,
19976 that's an error. */
19978 {
19980 type);
19982 type);
19985 }
19990 {
19991 /* Apply attributes now, before any use of the class as a template
19992 argument in its base list. */
19995 }
19997 /* We will have entered the scope containing the class; the names of
19998 base classes should be looked up in that context. For example:
20000 struct A { struct B {}; struct C; };
20001 struct A::C : B {};
20003 is valid. */
20005 /* Get the list of base-classes, if there is one. */
20007 {
20008 /* PR59482: enter the class scope so that base-specifiers are looked
20009 up correctly. */
20013 /* PR59482: get out of the previously pushed class scope so that the
20014 subsequent pops pop the right thing. */
20017 }
20018 else
20021 /* If we're really defining a class, process the base classes.
20022 If they're invalid, fail. */
20027 done:
20028 /* Leave the scope given by the nested-name-specifier. We will
20029 enter the class scope itself while processing the members. */
20034 {
20037 }
20043 out:
20046 }
20048 /* Parse a class-key.
20050 class-key:
20051 class
20052 struct
20053 union
20055 Returns the kind of class-key specified, or none_type to indicate
20056 error. */
20058 static enum tag_types
20060 {
20064 /* Look for the class-key. */
20069 /* Check to see if the TOKEN is a class-key. */
20074 }
20076 /* Parse an (optional) member-specification.
20078 member-specification:
20079 member-declaration member-specification [opt]
20080 access-specifier : member-specification [opt] */
20082 static void
20084 {
20086 {
20090 /* Peek at the next token. */
20092 /* If it's a `}', or EOF then we've seen all the members. */
20098 /* See if this token is a keyword. */
20101 {
20105 /* Consume the access-specifier. */
20107 /* Remember which access-specifier is active. */
20109 /* Look for the `:'. */
20114 /* Accept #pragmas at class scope. */
20116 {
20119 }
20121 /* Otherwise, the next construction must be a
20122 member-declaration. */
20124 }
20125 }
20126 }
20128 /* Parse a member-declaration.
20130 member-declaration:
20131 decl-specifier-seq [opt] member-declarator-list [opt] ;
20132 function-definition ; [opt]
20133 :: [opt] nested-name-specifier template [opt] unqualified-id ;
20134 using-declaration
20135 template-declaration
20136 alias-declaration
20138 member-declarator-list:
20139 member-declarator
20140 member-declarator-list , member-declarator
20142 member-declarator:
20143 declarator pure-specifier [opt]
20144 declarator constant-initializer [opt]
20145 identifier [opt] : constant-expression
20147 GNU Extensions:
20149 member-declaration:
20150 __extension__ member-declaration
20152 member-declarator:
20153 declarator attributes [opt] pure-specifier [opt]
20154 declarator attributes [opt] constant-initializer [opt]
20155 identifier [opt] attributes [opt] : constant-expression
20157 C++0x Extensions:
20159 member-declaration:
20160 static_assert-declaration */
20162 static void
20164 {
20165 cp_decl_specifier_seq decl_specifiers;
20166 tree prefix_attributes;
20167 tree decl;
20176 /* Check for the `__extension__' keyword. */
20178 {
20179 /* Recurse. */
20181 /* Restore the old value of the PEDANTIC flag. */
20185 }
20187 /* Check for a template-declaration. */
20189 {
20190 /* An explicit specialization here is an error condition, and we
20191 expect the specialization handler to detect and report this. */
20195 else
20199 }
20201 /* Check for a using-declaration. */
20203 {
20205 {
20206 /* Parse the using-declaration. */
20210 }
20211 else
20212 {
20213 tree decl;
20217 /* Note that if we actually see the '=' token after the
20218 identifier, cp_parser_alias_declaration commits the
20219 tentative parse. In that case, we really expects an
20220 alias-declaration. Otherwise, we expect a using
20221 declaration. */
20222 alias_decl_expected =
20228 else
20232 }
20233 }
20235 /* Check for @defs. */
20237 {
20242 {
20247 }
20249 }
20251 /* If the next token is `static_assert' we have a static assertion. */
20253 {
20256 }
20263 /* Parse the decl-specifier-seq. */
20266 CP_PARSER_FLAGS_OPTIONAL,
20269 /* Check for an invalid type-name. */
20273 /* If there is no declarator, then the decl-specifier-seq should
20274 specify a type. */
20276 {
20277 /* If there was no decl-specifier-seq, and the next token is a
20278 `;', then we have something like:
20280 struct S { ; };
20282 [class.mem]
20284 Each member-declaration shall declare at least one member
20285 name of the class. */
20287 {
20291 }
20292 else
20293 {
20294 tree type;
20296 /* See if this declaration is a friend. */
20298 /* If there were decl-specifiers, check to see if there was
20299 a class-declaration. */
20302 /* Nested classes have already been added to the class, but
20303 a `friend' needs to be explicitly registered. */
20305 {
20306 /* If the `friend' keyword was present, the friend must
20307 be introduced with a class-key. */
20310 "in C++03 a class-key must be used "
20312 /* In this case:
20314 template <typename T> struct A {
20315 friend struct A<T>::B;
20316 };
20318 A<T>::B will be represented by a TYPENAME_TYPE, and
20319 therefore not recognized by check_tag_decl. */
20321 {
20325 }
20328 "friend declaration does not name a class or "
20330 else
20333 }
20334 /* If there is no TYPE, an error message will already have
20335 been issued. */
20337 ;
20338 /* An anonymous aggregate has to be handled specially; such
20339 a declaration really declares a data member (with a
20340 particular type), as opposed to a nested class. */
20342 {
20343 /* C++11 9.5/6. */
20346 "a storage class on an anonymous aggregate "
20349 /* Remove constructors and such from TYPE, now that we
20350 know it is an anonymous aggregate. */
20352 /* And make the corresponding data member. */
20355 /* Add it to the class. */
20357 }
20358 else
20359 cp_parser_check_access_in_redeclaration
20362 }
20363 }
20364 else
20365 {
20368 /* Clear attributes from the decl_specifiers but keep them
20369 around as prefix attributes that apply them to the entity
20370 being declared. */
20374 /* See if these declarations will be friends. */
20377 /* Keep going until we hit the `;' at the end of the
20378 declaration. */
20380 {
20382 tree first_attribute;
20384 /* Peek at the next token. */
20387 /* Check for a bitfield declaration. */
20392 {
20393 tree identifier;
20394 tree width;
20396 /* Get the name of the bitfield. Note that we cannot just
20397 check TOKEN here because it may have been invalidated by
20398 the call to cp_lexer_peek_nth_token above. */
20401 else
20404 /* Consume the `:' token. */
20406 /* Get the width of the bitfield. */
20407 width
20410 NULL);
20412 /* Look for attributes that apply to the bitfield. */
20414 /* Remember which attributes are prefix attributes and
20415 which are not. */
20417 /* Combine the attributes. */
20420 /* Create the bitfield declaration. */
20423 identifier,
20424 sfk_none)
20427 width,
20428 attributes);
20429 }
20430 else
20431 {
20433 tree initializer;
20434 tree asm_specification;
20437 /* Parse the declarator. */
20438 declarator
20444 /* If something went wrong parsing the declarator, make sure
20445 that we at least consume some tokens. */
20447 {
20448 /* Skip to the end of the statement. */
20450 /* If the next token is not a semicolon, that is
20451 probably because we just skipped over the body of
20452 a function. So, we consume a semicolon if
20453 present, but do not issue an error message if it
20454 is not present. */
20456 CPP_SEMICOLON))
20459 }
20462 cp_parser_check_for_definition_in_return_type
20466 /* Look for an asm-specification. */
20468 /* Look for attributes that apply to the declaration. */
20470 /* Remember which attributes are prefix attributes and
20471 which are not. */
20473 /* Combine the attributes. */
20476 /* If it's an `=', then we have a constant-initializer or a
20477 pure-specifier. It is not correct to parse the
20478 initializer before registering the member declaration
20479 since the member declaration should be in scope while
20480 its initializer is processed. However, the rest of the
20481 front end does not yet provide an interface that allows
20482 us to handle this correctly. */
20484 {
20485 /* In [class.mem]:
20487 A pure-specifier shall be used only in the declaration of
20488 a virtual function.
20490 A member-declarator can contain a constant-initializer
20491 only if it declares a static member of integral or
20492 enumeration type.
20494 Therefore, if the DECLARATOR is for a function, we look
20495 for a pure-specifier; otherwise, we look for a
20496 constant-initializer. When we call `grokfield', it will
20497 perform more stringent semantics checks. */
20509 {
20511 /* Don't require a constant rvalue in C++11, since we
20512 might want a reference constant. We'll enforce
20513 constancy later. */
20515 /* Parse the initializer. */
20518 }
20519 else
20520 /* Parse the initializer. */
20522 }
20525 {
20529 else
20531 }
20532 /* Otherwise, there is no initializer. */
20533 else
20536 /* See if we are probably looking at a function
20537 definition. We are certainly not looking at a
20538 member-declarator. Calling `grokfield' has
20539 side-effects, so we must not do it unless we are sure
20540 that we are looking at a member-declarator. */
20543 {
20544 /* The grammar does not allow a pure-specifier to be
20545 used when a member function is defined. (It is
20546 possible that this fact is an oversight in the
20547 standard, since a pure function may be defined
20548 outside of the class-specifier. */
20554 declarator,
20555 attributes);
20558 /* If the member was not a friend, declare it here. */
20561 /* Peek at the next token. */
20563 /* If the next token is a semicolon, consume it. */
20567 }
20568 else
20571 /* Create the declaration. */
20576 {
20579 else
20581 }
20582 }
20586 /* Reset PREFIX_ATTRIBUTES. */
20592 /* If there is any qualification still in effect, clear it
20593 now; we will be starting fresh with the next declarator. */
20597 /* If it's a `,', then there are more declarators. */
20599 {
20602 {
20606 }
20607 }
20608 /* If the next token isn't a `;', then we have a parse error. */
20610 CPP_SEMICOLON))
20611 {
20612 /* The next token might be a ways away from where the
20613 actual semicolon is missing. Find the previous token
20614 and use that for our error position. */
20619 /* Assume that the user meant to provide a semicolon. If
20620 we were to cp_parser_skip_to_end_of_statement, we might
20621 skip to a semicolon inside a member function definition
20622 and issue nonsensical error messages. */
20624 }
20627 {
20628 /* Add DECL to the list of members. */
20637 /* Add DECL to the queue of NSDMI to be parsed later. */
20639 }
20643 }
20644 }
20647 out:
20649 }
20651 /* Parse a pure-specifier.
20653 pure-specifier:
20654 = 0
20656 Returns INTEGER_ZERO_NODE if a pure specifier is found.
20657 Otherwise, ERROR_MARK_NODE is returned. */
20659 static tree
20661 {
20664 /* Look for the `=' token. */
20667 /* Look for the `0' token. */
20676 /* Accept = default or = delete in c++0x mode. */
20679 {
20682 }
20684 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
20686 {
20691 }
20693 {
20696 }
20699 }
20701 /* Parse a constant-initializer.
20703 constant-initializer:
20704 = constant-expression
20706 Returns a representation of the constant-expression. */
20708 static tree
20710 {
20711 /* Look for the `=' token. */
20715 /* It is invalid to write:
20717 struct S { static const int i = { 7 }; };
20719 */
20721 {
20724 /* Consume the opening brace. */
20726 /* Skip the initializer. */
20728 /* Look for the trailing `}'. */
20732 }
20736 NULL);
20737 }
20739 /* Derived classes [gram.class.derived] */
20741 /* Parse a base-clause.
20743 base-clause:
20744 : base-specifier-list
20746 base-specifier-list:
20747 base-specifier ... [opt]
20748 base-specifier-list , base-specifier ... [opt]
20750 Returns a TREE_LIST representing the base-classes, in the order in
20751 which they were declared. The representation of each node is as
20752 described by cp_parser_base_specifier.
20754 In the case that no bases are specified, this function will return
20755 NULL_TREE, not ERROR_MARK_NODE. */
20757 static tree
20759 {
20762 /* Look for the `:' that begins the list. */
20765 /* Scan the base-specifier-list. */
20767 {
20769 tree base;
20772 /* Look for the base-specifier. */
20774 /* Look for the (optional) ellipsis. */
20776 {
20777 /* Consume the `...'. */
20781 }
20783 /* Add BASE to the front of the list. */
20785 {
20787 /* Make this a pack expansion type. */
20791 {
20794 }
20795 }
20796 /* Peek at the next token. */
20798 /* If it's not a comma, then the list is complete. */
20801 /* Consume the `,'. */
20803 }
20805 /* PARSER->SCOPE may still be non-NULL at this point, if the last
20806 base class had a qualified name. However, the next name that
20807 appears is certainly not qualified. */
20813 }
20815 /* Parse a base-specifier.
20817 base-specifier:
20818 :: [opt] nested-name-specifier [opt] class-name
20819 virtual access-specifier [opt] :: [opt] nested-name-specifier
20820 [opt] class-name
20821 access-specifier virtual [opt] :: [opt] nested-name-specifier
20822 [opt] class-name
20824 Returns a TREE_LIST. The TREE_PURPOSE will be one of
20825 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
20826 indicate the specifiers provided. The TREE_VALUE will be a TYPE
20827 (or the ERROR_MARK_NODE) indicating the type that was specified. */
20829 static tree
20831 {
20839 tree type;
20841 /* Process the optional `virtual' and `access-specifier'. */
20843 {
20844 /* Peek at the next token. */
20846 /* Process `virtual'. */
20848 {
20850 /* If `virtual' appears more than once, issue an error. */
20852 {
20856 }
20860 /* Consume the `virtual' token. */
20868 /* If more than one access specifier appears, issue an
20869 error. */
20872 {
20876 }
20880 /* Consume the access-specifier. */
20888 }
20889 }
20890 /* It is not uncommon to see programs mechanically, erroneously, use
20891 the 'typename' keyword to denote (dependent) qualified types
20892 as base classes. */
20894 {
20899 else
20901 "keyword %<typename%> not allowed in this context "
20904 }
20906 /* Look for the optional `::' operator. */
20908 /* Look for the nested-name-specifier. The simplest way to
20909 implement:
20911 [temp.res]
20913 The keyword `typename' is not permitted in a base-specifier or
20914 mem-initializer; in these contexts a qualified name that
20915 depends on a template-parameter is implicitly assumed to be a
20916 type name.
20918 is to pretend that we have seen the `typename' keyword at this
20919 point. */
20923 typename_type,
20925 /* If the base class is given by a qualified name, assume that names
20926 we see are type names or templates, as appropriate. */
20932 /* DR 950 allows decltype as a base-specifier. */
20934 else
20935 {
20936 /* Otherwise, look for the class-name. */
20938 class_scope_p,
20939 template_p,
20940 typename_type,
20945 }
20951 }
20953 /* Exception handling [gram.exception] */
20955 /* Parse an (optional) noexcept-specification.
20957 noexcept-specification:
20958 noexcept ( constant-expression ) [opt]
20960 If no noexcept-specification is present, returns NULL_TREE.
20961 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
20962 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
20963 there are no parentheses. CONSUMED_EXPR will be set accordingly.
20964 Otherwise, returns a noexcept specification unless RETURN_COND is true,
20965 in which case a boolean condition is returned instead. */
20967 static tree
20972 {
20976 /* Peek at the next token. */
20979 /* Is it a noexcept-specification? */
20981 {
20982 tree expr;
20986 {
20990 {
20991 /* Types may not be defined in an exception-specification. */
20993 parser->type_definition_forbidden_message
20998 /* Restore the saved message. */
21000 }
21001 else
21002 {
21005 }
21008 }
21009 else
21010 {
21014 }
21016 /* We cannot build a noexcept-spec right away because this will check
21017 that expr is a constexpr. */
21020 else
21022 }
21023 else
21025 }
21027 /* Parse an (optional) exception-specification.
21029 exception-specification:
21030 throw ( type-id-list [opt] )
21032 Returns a TREE_LIST representing the exception-specification. The
21033 TREE_VALUE of each node is a type. */
21035 static tree
21037 {
21039 tree type_id_list;
21042 /* Peek at the next token. */
21045 /* Is it a noexcept-specification? */
21051 /* If it's not `throw', then there's no exception-specification. */
21055 #if 0
21056 /* Enable this once a lot of code has transitioned to noexcept? */
21060 #endif
21062 /* Consume the `throw'. */
21065 /* Look for the `('. */
21068 /* Peek at the next token. */
21070 /* If it's not a `)', then there is a type-id-list. */
21072 {
21073 /* Types may not be defined in an exception-specification. */
21075 parser->type_definition_forbidden_message
21077 /* Parse the type-id-list. */
21079 /* Restore the saved message. */
21081 }
21082 else
21085 /* Look for the `)'. */
21089 }
21091 /* Parse an (optional) type-id-list.
21093 type-id-list:
21094 type-id ... [opt]
21095 type-id-list , type-id ... [opt]
21097 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
21098 in the order that the types were presented. */
21100 static tree
21102 {
21106 {
21108 tree type;
21110 /* Get the next type-id. */
21112 /* Parse the optional ellipsis. */
21114 {
21115 /* Consume the `...'. */
21118 /* Turn the type into a pack expansion expression. */
21120 }
21121 /* Add it to the list. */
21123 /* Peek at the next token. */
21125 /* If it is not a `,', we are done. */
21128 /* Consume the `,'. */
21130 }
21133 }
21135 /* Parse a try-block.
21137 try-block:
21138 try compound-statement handler-seq */
21140 static tree
21142 {
21143 tree try_block;
21153 }
21155 /* Parse a function-try-block.
21157 function-try-block:
21158 try ctor-initializer [opt] function-body handler-seq */
21160 static bool
21162 {
21163 tree compound_stmt;
21164 tree try_block;
21167 /* Look for the `try' keyword. */
21170 /* Let the rest of the front end know where we are. */
21172 /* Parse the function-body. */
21173 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
21175 /* We're done with the `try' part. */
21177 /* Parse the handlers. */
21179 /* We're done with the handlers. */
21183 }
21185 /* Parse a handler-seq.
21187 handler-seq:
21188 handler handler-seq [opt] */
21190 static void
21192 {
21194 {
21197 /* Parse the handler. */
21199 /* Peek at the next token. */
21201 /* If it's not `catch' then there are no more handlers. */
21204 }
21205 }
21207 /* Parse a handler.
21209 handler:
21210 catch ( exception-declaration ) compound-statement */
21212 static void
21214 {
21215 tree handler;
21216 tree declaration;
21226 }
21228 /* Parse an exception-declaration.
21230 exception-declaration:
21231 type-specifier-seq declarator
21232 type-specifier-seq abstract-declarator
21233 type-specifier-seq
21234 ...
21236 Returns a VAR_DECL for the declaration, or NULL_TREE if the
21237 ellipsis variant is used. */
21239 static tree
21241 {
21242 cp_decl_specifier_seq type_specifiers;
21246 /* If it's an ellipsis, it's easy to handle. */
21248 {
21249 /* Consume the `...' token. */
21252 }
21254 /* Types may not be defined in exception-declarations. */
21256 parser->type_definition_forbidden_message
21259 /* Parse the type-specifier-seq. */
21263 /* If it's a `)', then there is no declarator. */
21266 else
21272 /* Restore the saved message. */
21279 }
21281 /* Parse a throw-expression.
21283 throw-expression:
21284 throw assignment-expression [opt]
21286 Returns a THROW_EXPR representing the throw-expression. */
21288 static tree
21290 {
21291 tree expression;
21296 /* Figure out whether or not there is an assignment-expression
21297 following the "throw" keyword. */
21305 else
21310 }
21312 /* GNU Extensions */
21314 /* Parse an (optional) asm-specification.
21316 asm-specification:
21317 asm ( string-literal )
21319 If the asm-specification is present, returns a STRING_CST
21320 corresponding to the string-literal. Otherwise, returns
21321 NULL_TREE. */
21323 static tree
21325 {
21327 tree asm_specification;
21329 /* Peek at the next token. */
21331 /* If the next token isn't the `asm' keyword, then there's no
21332 asm-specification. */
21336 /* Consume the `asm' token. */
21338 /* Look for the `('. */
21341 /* Look for the string-literal. */
21344 /* Look for the `)'. */
21348 }
21350 /* Parse an asm-operand-list.
21352 asm-operand-list:
21353 asm-operand
21354 asm-operand-list , asm-operand
21356 asm-operand:
21357 string-literal ( expression )
21358 [ string-literal ] string-literal ( expression )
21360 Returns a TREE_LIST representing the operands. The TREE_VALUE of
21361 each node is the expression. The TREE_PURPOSE is itself a
21362 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
21363 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
21364 is a STRING_CST for the string literal before the parenthesis. Returns
21365 ERROR_MARK_NODE if any of the operands are invalid. */
21367 static tree
21369 {
21374 {
21375 tree string_literal;
21376 tree expression;
21377 tree name;
21380 {
21381 /* Consume the `[' token. */
21383 /* Read the operand name. */
21388 /* Look for the closing `]'. */
21390 }
21391 else
21393 /* Look for the string-literal. */
21396 /* Look for the `('. */
21398 /* Parse the expression. */
21400 /* Look for the `)'. */
21408 /* Add this operand to the list. */
21410 expression,
21411 asm_operands);
21412 /* If the next token is not a `,', there are no more
21413 operands. */
21416 /* Consume the `,'. */
21418 }
21421 }
21423 /* Parse an asm-clobber-list.
21425 asm-clobber-list:
21426 string-literal
21427 asm-clobber-list , string-literal
21429 Returns a TREE_LIST, indicating the clobbers in the order that they
21430 appeared. The TREE_VALUE of each node is a STRING_CST. */
21432 static tree
21434 {
21438 {
21439 tree string_literal;
21441 /* Look for the string literal. */
21443 /* Add it to the list. */
21445 /* If the next token is not a `,', then the list is
21446 complete. */
21449 /* Consume the `,' token. */
21451 }
21454 }
21456 /* Parse an asm-label-list.
21458 asm-label-list:
21459 identifier
21460 asm-label-list , identifier
21462 Returns a TREE_LIST, indicating the labels in the order that they
21463 appeared. The TREE_VALUE of each node is a label. */
21465 static tree
21467 {
21471 {
21474 /* Look for the identifier. */
21477 {
21480 {
21486 }
21487 }
21488 /* If the next token is not a `,', then the list is
21489 complete. */
21492 /* Consume the `,' token. */
21494 }
21497 }
21499 /* Return TRUE iff the next tokens in the stream are possibly the
21500 beginning of a GNU extension attribute. */
21502 static bool
21504 {
21506 }
21508 /* Return TRUE iff the next tokens in the stream are possibly the
21509 beginning of a standard C++-11 attribute specifier. */
21511 static bool
21513 {
21515 }
21517 /* Return TRUE iff the next Nth tokens in the stream are possibly the
21518 beginning of a standard C++-11 attribute specifier. */
21520 static bool
21522 {
21530 }
21532 /* Return TRUE iff the next Nth tokens in the stream are possibly the
21533 beginning of a GNU extension attribute. */
21535 static bool
21537 {
21541 }
21543 /* Return true iff the next tokens can be the beginning of either a
21544 GNU attribute list, or a standard C++11 attribute sequence. */
21546 static bool
21548 {
21551 }
21553 /* Return true iff the next Nth tokens can be the beginning of either
21554 a GNU attribute list, or a standard C++11 attribute sequence. */
21556 static bool
21558 {
21561 }
21563 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
21564 of GNU attributes, or return NULL. */
21566 static tree
21568 {
21572 }
21574 #define CILK_SIMD_FN_CLAUSE_MASK \
21575 ((OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_VECTORLENGTH) \
21576 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_LINEAR) \
21577 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_UNIFORM) \
21578 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_MASK) \
21579 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_NOMASK))
21581 /* Parses the Cilk Plus SIMD-enabled function's attribute. Syntax:
21582 vector [(<clauses>)] */
21584 static void
21586 {
21590 {
21595 }
21598 {
21601 paren_scope++;
21602 }
21604 {
21607 paren_scope++;
21609 paren_scope--;
21610 /* Do not push the last ')' */
21613 }
21622 }
21624 /* Parse an (optional) series of attributes.
21626 attributes:
21627 attributes attribute
21629 attribute:
21630 __attribute__ (( attribute-list [opt] ))
21632 The return value is as for cp_parser_gnu_attribute_list. */
21634 static tree
21636 {
21640 {
21642 tree attribute_list;
21645 /* Peek at the next token. */
21647 /* If it's not `__attribute__', then we're done. */
21651 /* Consume the `__attribute__' keyword. */
21653 /* Look for the two `(' tokens. */
21657 /* Peek at the next token. */
21660 /* Parse the attribute-list. */
21662 else
21663 /* If the next token is a `)', then there is no attribute
21664 list. */
21667 /* Look for the two `)' tokens. */
21675 /* Add these new attributes to the list. */
21677 }
21680 }
21682 /* Returns true of NAME is an IDENTIFIER_NODE with identiifer "vector,"
21683 "__vector" or "__vector__." */
21687 {
21691 }
21693 /* Parse a GNU attribute-list.
21695 attribute-list:
21696 attribute
21697 attribute-list , attribute
21699 attribute:
21700 identifier
21701 identifier ( identifier )
21702 identifier ( identifier , expression-list )
21703 identifier ( expression-list )
21705 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
21706 to an attribute. The TREE_PURPOSE of each node is the identifier
21707 indicating which attribute is in use. The TREE_VALUE represents
21708 the arguments, if any. */
21710 static tree
21712 {
21718 {
21720 tree identifier;
21721 tree attribute;
21723 /* Look for the identifier. We also allow keywords here; for
21724 example `__attribute__ ((const))' is legal. */
21728 {
21731 /* Consume the token, but save it since we need it for the
21732 SIMD enabled function parsing. */
21735 /* Save away the identifier that indicates which attribute
21736 this is. */
21738 /* For keywords, use the canonical spelling, not the
21739 parsed identifier. */
21745 /* Peek at the next token. */
21747 /* If it's an `(', then parse the attribute arguments. */
21749 {
21754 {
21757 }
21758 else
21759 vec = cp_parser_parenthesized_expression_list
21765 else
21766 {
21769 }
21770 /* Save the arguments away. */
21772 }
21774 {
21777 }
21780 {
21781 /* Add this attribute to the list. */
21784 }
21787 }
21788 /* Now, look for more attributes. If the next token isn't a
21789 `,', we're done. */
21793 /* Consume the comma and keep going. */
21795 }
21798 /* We built up the list in reverse order. */
21800 }
21802 /* Parse a standard C++11 attribute.
21804 The returned representation is a TREE_LIST which TREE_PURPOSE is
21805 the scoped name of the attribute, and the TREE_VALUE is its
21806 arguments list.
21808 Note that the scoped name of the attribute is itself a TREE_LIST
21809 which TREE_PURPOSE is the namespace of the attribute, and
21810 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
21811 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
21812 and which TREE_PURPOSE is directly the attribute name.
21814 Clients of the attribute code should use get_attribute_namespace
21815 and get_attribute_name to get the actual namespace and name of
21816 attributes, regardless of their being GNU or C++11 attributes.
21818 attribute:
21819 attribute-token attribute-argument-clause [opt]
21821 attribute-token:
21822 identifier
21823 attribute-scoped-token
21825 attribute-scoped-token:
21826 attribute-namespace :: identifier
21828 attribute-namespace:
21829 identifier
21831 attribute-argument-clause:
21832 ( balanced-token-seq )
21834 balanced-token-seq:
21835 balanced-token [opt]
21836 balanced-token-seq balanced-token
21838 balanced-token:
21839 ( balanced-token-seq )
21840 [ balanced-token-seq ]
21841 { balanced-token-seq }. */
21843 static tree
21845 {
21849 /* First, parse name of the the attribute, a.k.a
21850 attribute-token. */
21867 {
21868 /* We are seeing a scoped attribute token. */
21878 else
21879 {
21883 }
21885 NULL_TREE);
21887 }
21888 else
21889 {
21891 NULL_TREE);
21892 /* C++11 noreturn attribute is equivalent to GNU's. */
21895 /* C++14 deprecated attribute is equivalent to GNU's. */
21898 }
21900 /* Now parse the optional argument clause of the attribute. */
21905 {
21911 /* A GNU attribute that takes an identifier in parameter. */
21914 vec = cp_parser_parenthesized_expression_list
21920 else
21921 {
21924 }
21928 else
21930 }
21933 }
21935 /* Parse a list of standard C++-11 attributes.
21937 attribute-list:
21938 attribute [opt]
21939 attribute-list , attribute[opt]
21940 attribute ...
21941 attribute-list , attribute ...
21942 */
21944 static tree
21946 {
21951 {
21956 {
21959 }
21964 }
21967 }
21969 /* Parse a standard C++-11 attribute specifier.
21971 attribute-specifier:
21972 [ [ attribute-list ] ]
21973 alignment-specifier
21975 alignment-specifier:
21976 alignas ( type-id ... [opt] )
21977 alignas ( alignment-expression ... [opt] ). */
21979 static tree
21981 {
21987 {
21996 else
21997 /* Warn about parsing c++11 attribute in non-c++1 mode, only
21998 when we are sure that we have actually parsed them. */
22000 }
22001 else
22002 {
22003 tree alignas_expr;
22005 /* Look for an alignment-specifier. */
22017 {
22020 }
22026 {
22030 alignas_expr =
22038 }
22041 {
22044 }
22048 /* Build the C++-11 representation of an 'aligned'
22049 attribute. */
22050 attributes =
22054 }
22057 }
22059 /* Parse a standard C++-11 attribute-specifier-seq.
22061 attribute-specifier-seq:
22062 attribute-specifier-seq [opt] attribute-specifier
22063 */
22065 static tree
22067 {
22071 {
22080 }
22084 }
22086 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
22087 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
22088 current value of the PEDANTIC flag, regardless of whether or not
22089 the `__extension__' keyword is present. The caller is responsible
22090 for restoring the value of the PEDANTIC flag. */
22092 static bool
22094 {
22095 /* Save the old value of the PEDANTIC flag. */
22099 {
22100 /* Consume the `__extension__' token. */
22102 /* We're not being pedantic while the `__extension__' keyword is
22103 in effect. */
22107 }
22110 }
22112 /* Parse a label declaration.
22114 label-declaration:
22115 __label__ label-declarator-seq ;
22117 label-declarator-seq:
22118 identifier , label-declarator-seq
22119 identifier */
22121 static void
22123 {
22124 /* Look for the `__label__' keyword. */
22128 {
22129 tree identifier;
22131 /* Look for an identifier. */
22133 /* If we failed, stop. */
22136 /* Declare it as a label. */
22138 /* If the next token is a `;', stop. */
22141 /* Look for the `,' separating the label declarations. */
22143 }
22145 /* Look for the final `;'. */
22147 }
22149 /* Support Functions */
22151 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
22152 NAME should have one of the representations used for an
22153 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
22154 is returned. If PARSER->SCOPE is a dependent type, then a
22155 SCOPE_REF is returned.
22157 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
22158 returned; the name was already resolved when the TEMPLATE_ID_EXPR
22159 was formed. Abstractly, such entities should not be passed to this
22160 function, because they do not need to be looked up, but it is
22161 simpler to check for this special case here, rather than at the
22162 call-sites.
22164 In cases not explicitly covered above, this function returns a
22165 DECL, OVERLOAD, or baselink representing the result of the lookup.
22166 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
22167 is returned.
22169 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
22170 (e.g., "struct") that was used. In that case bindings that do not
22171 refer to types are ignored.
22173 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
22174 ignored.
22176 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
22177 are ignored.
22179 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
22180 types.
22182 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
22183 TREE_LIST of candidates if name-lookup results in an ambiguity, and
22184 NULL_TREE otherwise. */
22186 static tree
22193 location_t name_location)
22194 {
22195 tree decl;
22198 /* Assume that the lookup will be unambiguous. */
22202 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
22203 no longer valid. Note that if we are parsing tentatively, and
22204 the parse fails, OBJECT_TYPE will be automatically restored. */
22210 /* A template-id has already been resolved; there is no lookup to
22211 do. */
22215 {
22219 }
22221 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
22222 it should already have been checked to make sure that the name
22223 used matches the type being destroyed. */
22225 {
22226 tree type;
22228 /* Figure out to which type this destructor applies. */
22233 else
22235 /* If that's not a class type, there is no destructor. */
22242 /* If it was a class type, return the destructor. */
22244 }
22246 /* By this point, the NAME should be an ordinary identifier. If
22247 the id-expression was a qualified name, the qualifying scope is
22248 stored in PARSER->SCOPE at this point. */
22251 /* Perform the lookup. */
22253 {
22259 /* If the SCOPE is dependent, the lookup must be deferred until
22260 the template is instantiated -- unless we are explicitly
22261 looking up names in uninstantiated templates. Even then, we
22262 cannot look up the name if the scope is not a class type; it
22263 might, for example, be a template type parameter. */
22268 /* Defer lookup. */
22270 else
22271 {
22274 /* If PARSER->SCOPE is a dependent type, then it must be a
22275 class type, and we must not be checking dependencies;
22276 otherwise, we would have processed this lookup above. So
22277 that PARSER->SCOPE is not considered a dependent base by
22278 lookup_member, we must enter the scope here. */
22282 /* If the PARSER->SCOPE is a template specialization, it
22283 may be instantiated during name lookup. In that case,
22284 errors may be issued. Even if we rollback the current
22285 tentative parse, those errors are valid. */
22290 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
22291 lookup result and the nested-name-specifier nominates a class C:
22292 * if the name specified after the nested-name-specifier, when
22293 looked up in C, is the injected-class-name of C (Clause 9), or
22294 * if the name specified after the nested-name-specifier is the
22295 same as the identifier or the simple-template-id's template-
22296 name in the last component of the nested-name-specifier,
22297 the name is instead considered to name the constructor of
22298 class C. [ Note: for example, the constructor is not an
22299 acceptable lookup result in an elaborated-type-specifier so
22300 the constructor would not be used in place of the
22301 injected-class-name. --end note ] Such a constructor name
22302 shall be used only in the declarator-id of a declaration that
22303 names a constructor or in a using-declaration. */
22311 /* If we have a single function from a using decl, pull it out. */
22318 }
22320 /* If the scope is a dependent type and either we deferred lookup or
22321 we did lookup but didn't find the name, rememeber the name. */
22324 {
22326 {
22327 tree type;
22329 /* The resolution to Core Issue 180 says that `struct
22330 A::B' should be considered a type-name, even if `A'
22331 is dependent. */
22336 }
22340 CPP_CLOSE_PAREN)))
22344 else
22347 is_template);
22348 }
22351 }
22353 {
22354 /* Look up the name in the scope of the OBJECT_TYPE, unless the
22355 OBJECT_TYPE is not a class. */
22357 /* If the OBJECT_TYPE is a template specialization, it may
22358 be instantiated during name lookup. In that case, errors
22359 may be issued. Even if we rollback the current tentative
22360 parse, those errors are valid. */
22362 name,
22365 tf_warning_or_error);
22366 else
22370 /* Look it up in the enclosing context. */
22376 }
22377 else
22378 {
22384 }
22386 /* If the lookup failed, let our caller know. */
22390 /* Pull out the template from an injected-class-name (or multiple). */
22394 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
22396 {
22399 /* The error message we have to print is too complicated for
22400 cp_parser_error, so we incorporate its actions directly. */
22402 {
22404 name);
22406 }
22408 }
22416 /* If we have resolved the name of a member declaration, check to
22417 see if the declaration is accessible. When the name resolves to
22418 set of overloaded functions, accessibility is checked when
22419 overload resolution is done.
22421 During an explicit instantiation, access is not checked at all,
22422 as per [temp.explicit]. */
22429 }
22431 /* Like cp_parser_lookup_name, but for use in the typical case where
22432 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
22433 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
22435 static tree
22437 {
22439 none_type,
22444 location);
22445 }
22447 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
22448 the current context, return the TYPE_DECL. If TAG_NAME_P is
22449 true, the DECL indicates the class being defined in a class-head,
22450 or declared in an elaborated-type-specifier.
22452 Otherwise, return DECL. */
22454 static tree
22456 {
22457 /* If the TEMPLATE_DECL is being declared as part of a class-head,
22458 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
22460 struct A {
22461 template <typename T> struct B;
22462 };
22464 template <typename T> struct A::B {};
22466 Similarly, in an elaborated-type-specifier:
22468 namespace N { struct X{}; }
22470 struct A {
22471 template <typename T> friend struct N::X;
22472 };
22474 However, if the DECL refers to a class type, and we are in
22475 the scope of the class, then the name lookup automatically
22476 finds the TYPE_DECL created by build_self_reference rather
22477 than a TEMPLATE_DECL. For example, in:
22479 template <class T> struct S {
22480 S s;
22481 };
22483 there is no need to handle such case. */
22489 }
22491 /* If too many, or too few, template-parameter lists apply to the
22492 declarator, issue an error message. Returns TRUE if all went well,
22493 and FALSE otherwise. */
22495 static bool
22498 location_t declarator_location)
22499 {
22501 {
22503 {
22511 /* If the DECLARATOR has the form `X<y>' then it uses one
22512 additional level of template parameters. */
22515 return cp_parser_check_template_parameters
22517 }
22532 }
22534 }
22536 /* NUM_TEMPLATES were used in the current declaration. If that is
22537 invalid, return FALSE and issue an error messages. Otherwise,
22538 return TRUE. If DECLARATOR is non-NULL, then we are checking a
22539 declarator and we can print more accurate diagnostics. */
22541 static bool
22544 location_t location,
22546 {
22547 /* If there are the same number of template classes and parameter
22548 lists, that's OK. */
22551 /* If there are more, but only one more, then we are referring to a
22552 member template. That's OK too. */
22555 /* If there are more template classes than parameter lists, we have
22556 something like:
22558 template <class T> void S<T>::R<T>::f (); */
22560 {
22570 else
22573 }
22574 /* Otherwise, there are too many template parameter lists. We have
22575 something like:
22577 template <class T> template <class U> void S::f(); */
22580 }
22582 /* Parse an optional `::' token indicating that the following name is
22583 from the global namespace. If so, PARSER->SCOPE is set to the
22584 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
22585 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
22586 Returns the new value of PARSER->SCOPE, if the `::' token is
22587 present, and NULL_TREE otherwise. */
22589 static tree
22591 {
22594 /* Peek at the next token. */
22596 /* If we're looking at a `::' token then we're starting from the
22597 global namespace, not our current location. */
22599 {
22600 /* Consume the `::' token. */
22602 /* Set the SCOPE so that we know where to start the lookup. */
22608 }
22610 {
22614 }
22617 }
22619 /* Returns TRUE if the upcoming token sequence is the start of a
22620 constructor declarator. If FRIEND_P is true, the declarator is
22621 preceded by the `friend' specifier. */
22623 static bool
22625 {
22628 tree nested_name_specifier;
22631 /* The common case is that this is not a constructor declarator, so
22632 try to avoid doing lots of work if at all possible. It's not
22633 valid declare a constructor at function scope. */
22636 /* And only certain tokens can begin a constructor declarator. */
22644 /* Parse tentatively; we are going to roll back all of the tokens
22645 consumed here. */
22647 /* Assume that we are looking at a constructor declarator. */
22650 /* Look for the optional `::' operator. */
22653 /* Look for the nested-name-specifier. */
22654 nested_name_specifier
22665 /* Outside of a class-specifier, there must be a
22666 nested-name-specifier. */
22672 /* If we have a class scope, this is easy; DR 147 says that S::S always
22673 names the constructor, and no other qualified name could. */
22676 {
22686 }
22687 /* If we still think that this might be a constructor-declarator,
22688 look for a class-name. */
22690 {
22691 /* If we have:
22693 template <typename T> struct S {
22694 S();
22695 };
22697 we must recognize that the nested `S' names a class. */
22698 tree type_decl;
22702 none_type,
22706 /* If there was no class-name, then this is not a constructor.
22707 Otherwise, if we are in a class-specifier and we aren't
22708 handling a friend declaration, check that its type matches
22709 current_class_type (c++/38313). Note: error_mark_node
22710 is left alone for error recovery purposes. */
22712 && (outside_class_specifier_p
22717 /* If we're still considering a constructor, we have to see a `(',
22718 to begin the parameter-declaration-clause, followed by either a
22719 `)', an `...', or a decl-specifier. We need to check for a
22720 type-specifier to avoid being fooled into thinking that:
22722 S (f) (int);
22724 is a constructor. (It is actually a function named `f' that
22725 takes one parameter (of type `int') and returns a value of type
22726 `S'. */
22734 /* A parameter declaration begins with a decl-specifier,
22735 which is either the "attribute" keyword, a storage class
22736 specifier, or (usually) a type-specifier. */
22738 {
22739 tree type;
22743 /* Names appearing in the type-specifier should be looked up
22744 in the scope of the class. */
22747 else
22748 {
22751 {
22755 {
22758 }
22759 }
22761 }
22763 /* Inside the constructor parameter list, surrounding
22764 template-parameter-lists do not apply. */
22765 saved_num_template_parameter_lists
22769 /* Look for the type-specifier. */
22771 CP_PARSER_FLAGS_NONE,
22777 parser->num_template_parameter_lists
22780 /* Leave the scope of the class. */
22785 }
22786 }
22788 /* We did not really want to consume any tokens. */
22792 }
22794 /* Parse the definition of the function given by the DECL_SPECIFIERS,
22795 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
22796 they must be performed once we are in the scope of the function.
22798 Returns the function defined. */
22800 static tree
22801 cp_parser_function_definition_from_specifiers_and_declarator
22804 tree attributes,
22806 {
22807 tree fn;
22810 /* Begin the function-definition. */
22813 /* The things we're about to see are not directly qualified by any
22814 template headers we've seen thus far. */
22817 /* If there were names looked up in the decl-specifier-seq that we
22818 did not check, check them now. We must wait until we are in the
22819 scope of the function to perform the checks, since the function
22820 might be a friend. */
22824 {
22827 }
22830 {
22831 /* Skip the entire function. */
22834 }
22836 {
22837 /* Seen already, skip it. An error message has already been output. */
22841 /* If this is a function from a class, pop the nested class. */
22844 }
22845 else
22846 {
22847 timevar_id_t tv;
22850 else
22856 }
22859 }
22861 /* Parse the part of a function-definition that follows the
22862 declarator. INLINE_P is TRUE iff this function is an inline
22863 function defined within a class-specifier.
22865 Returns the function defined. */
22867 static tree
22870 {
22871 tree fn;
22877 bool fully_implicit_function_template_p
22880 tree implicit_template_parms
22883 cp_binding_level* implicit_template_scope
22889 /* If the next token is `return', then the code may be trying to
22890 make use of the "named return value" extension that G++ used to
22891 support. */
22894 {
22895 /* Consume the `return' keyword. */
22897 /* Look for the identifier that indicates what value is to be
22898 returned. */
22900 /* Issue an error message. */
22903 /* Skip tokens until we reach the start of the function body. */
22905 {
22912 }
22913 }
22914 /* The `extern' in `extern "C" void f () { ... }' does not apply to
22915 anything declared inside `f'. */
22916 saved_in_unbraced_linkage_specification_p
22919 /* Inside the function, surrounding template-parameter-lists do not
22920 apply. */
22921 saved_num_template_parameter_lists
22927 /* If the next token is `try', `__transaction_atomic', or
22928 `__transaction_relaxed`, then we are looking at either function-try-block
22929 or function-transaction-block. Note that all of these include the
22930 function-body. */
22933 RID_TRANSACTION_ATOMIC);
22935 RID_TRANSACTION_RELAXED))
22937 RID_TRANSACTION_RELAXED);
22940 else
22941 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
22946 /* Finish the function. */
22949 /* Generate code for it, if necessary. */
22951 /* Restore the saved values. */
22952 parser->in_unbraced_linkage_specification_p
22954 parser->num_template_parameter_lists
22958 parser->fully_implicit_function_template_p
22960 parser->implicit_template_parms
22962 parser->implicit_template_scope
22969 }
22971 /* Parse a template-declaration, assuming that the `export' (and
22972 `extern') keywords, if present, has already been scanned. MEMBER_P
22973 is as for cp_parser_template_declaration. */
22975 static void
22977 {
22980 tree parameter_list;
22985 /* Look for the `template' keyword. */
22990 /* And the `<'. */
22994 {
22995 /* 14.5.2.2 [temp.mem]
22997 A local class shall not have member templates. */
23002 }
23003 /* [temp]
23005 A template ... shall not have C linkage. */
23007 {
23009 /* Give it C++ linkage to avoid confusing other parts of the
23010 front end. */
23013 }
23014 else
23017 /* We cannot perform access checks on the template parameter
23018 declarations until we know what is being declared, just as we
23019 cannot check the decl-specifier list. */
23022 /* If the next token is `>', then we have an invalid
23023 specialization. Rather than complain about an invalid template
23024 parameter, issue an error message here. */
23026 {
23030 }
23031 else
23032 {
23033 /* Parse the template parameters. */
23035 }
23037 /* Get the deferred access checks from the parameter list. These
23038 will be checked once we know what is being declared, as for a
23039 member template the checks must be performed in the scope of the
23040 class containing the member. */
23043 /* Look for the `>'. */
23045 /* We just processed one more parameter list. */
23047 /* If the next token is `template', there are more template
23048 parameters. */
23050 RID_TEMPLATE))
23055 else
23056 {
23057 /* There are no access checks when parsing a template, as we do not
23058 know if a specialization will be a friend. */
23062 checks,
23063 member_p,
23068 /* If this is a member template declaration, let the front
23069 end know. */
23071 {
23076 }
23081 }
23082 /* We are done with the current parameter list. */
23087 /* Finish up. */
23090 /* Check the template arguments for a literal operator template. */
23094 {
23098 else
23099 {
23102 {
23108 }
23110 {
23118 }
23119 else
23121 }
23124 " Expected non-type template argument pack <char...>"
23126 decl);
23127 }
23128 /* Register member declarations. */
23131 /* For the erroneous case of a template with C linkage, we pushed an
23132 implicit C++ linkage scope; exit that scope now. */
23135 /* If DECL is a function template, we must return to parse it later.
23136 (Even though there is no definition, there might be default
23137 arguments that need handling.) */
23141 }
23143 /* Perform the deferred access checks from a template-parameter-list.
23144 CHECKS is a TREE_LIST of access checks, as returned by
23145 get_deferred_access_checks. */
23147 static void
23148 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
23149 {
23153 }
23155 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
23156 `function-definition' sequence that follows a template header.
23157 If MEMBER_P is true, this declaration appears in a class scope.
23159 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
23160 *FRIEND_P is set to TRUE iff the declaration is a friend. */
23162 static tree
23168 {
23171 cp_decl_specifier_seq decl_specifiers;
23175 /* This function is only used when processing a template
23176 declaration. */
23180 /* Defer access checks until we know what is being declared. */
23183 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
23184 alternative. */
23187 CP_PARSER_FLAGS_OPTIONAL,
23193 /* There are no template typedefs. */
23195 {
23199 }
23201 /* Gather up the access checks that occurred the
23202 decl-specifier-seq. */
23205 /* Check for the declaration of a template class. */
23207 {
23209 {
23212 /* In this case:
23214 struct C {
23215 friend template <typename T> struct A<T>::B;
23216 };
23218 A<T>::B will be represented by a TYPENAME_TYPE, and
23219 therefore not recognized by shadow_tag. */
23221 && !decl
23228 else
23231 /* Perform access checks for template parameters. */
23233 }
23234 }
23236 /* Complain about missing 'typename' or other invalid type names. */
23239 {
23240 /* cp_parser_parse_and_diagnose_invalid_type_name calls
23241 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
23242 the rest of this declaration. */
23245 }
23247 /* If it's not a template class, try for a template function. If
23248 the next token is a `;', then this declaration does not declare
23249 anything. But, if there were errors in the decl-specifiers, then
23250 the error might well have come from an attempted class-specifier.
23251 In that case, there's no need to warn about a missing declarator. */
23255 {
23258 checks,
23260 member_p,
23261 declares_class_or_enum,
23263 NULL);
23265 /* 7.1.1-1 [dcl.stc]
23267 A storage-class-specifier shall not be specified in an explicit
23268 specialization... */
23270 && explicit_specialization_p
23272 {
23276 }
23280 }
23282 /* Look for a trailing `;' after the declaration. */
23288 out:
23291 /* Clear any current qualification; whatever comes next is the start
23292 of something new. */
23298 }
23300 /* Parse a cast-expression that is not the operand of a unary "&". */
23302 static tree
23304 {
23307 }
23309 /* Parse a functional cast to TYPE. Returns an expression
23310 representing the cast. */
23312 static tree
23314 {
23316 tree expression_list;
23317 tree cast;
23324 {
23332 tf_warning_or_error);
23333 }
23342 else
23343 {
23346 }
23349 tf_warning_or_error);
23350 /* [expr.const]/1: In an integral constant expression "only type
23351 conversions to integral or enumeration type can be used". */
23357 NIC_CONSTRUCTOR))
23360 }
23362 /* Save the tokens that make up the body of a member function defined
23363 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
23364 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
23365 specifiers applied to the declaration. Returns the FUNCTION_DECL
23366 for the member function. */
23368 static tree
23372 tree attributes)
23373 {
23376 tree fn;
23378 /* Create the FUNCTION_DECL. */
23381 /* If something went badly wrong, bail out now. */
23383 {
23384 /* If there's a function-body, skip it. */
23389 }
23391 /* Remember it, if there default args to post process. */
23394 /* Save away the tokens that make up the body of the
23395 function. */
23397 /* Handle function try blocks. */
23400 /* We can have braced-init-list mem-initializers before the fn body. */
23402 {
23405 {
23406 /* cache_group will stop after an un-nested { } pair, too. */
23410 /* variadic mem-inits have ... after the ')'. */
23413 }
23414 }
23416 /* Handle function try blocks. */
23421 /* Save away the inline definition; we will process it when the
23422 class is complete. */
23426 /* We need to know that this was defined in the class, so that
23427 friend templates are handled correctly. */
23430 /* Add FN to the queue of functions to be parsed later. */
23434 }
23436 /* Save the tokens that make up the in-class initializer for a non-static
23437 data member. Returns a DEFAULT_ARG. */
23439 static tree
23441 {
23443 }
23445 /* Parse a template-argument-list, as well as the trailing ">" (but
23446 not the opening "<"). See cp_parser_template_argument_list for the
23447 return value. */
23449 static tree
23451 {
23452 tree arguments;
23453 tree saved_scope;
23454 tree saved_qualifying_scope;
23455 tree saved_object_scope;
23460 /* [temp.names]
23462 When parsing a template-id, the first non-nested `>' is taken as
23463 the end of the template-argument-list rather than a greater-than
23464 operator. */
23465 saved_greater_than_is_operator_p
23468 /* Parsing the argument list may modify SCOPE, so we save it
23469 here. */
23473 /* We need to evaluate the template arguments, even though this
23474 template-id may be nested within a "sizeof". */
23479 /* Parse the template-argument-list itself. */
23483 else
23485 /* Look for the `>' that ends the template-argument-list. If we find
23486 a '>>' instead, it's probably just a typo. */
23488 {
23490 {
23491 /* In C++0x, a `>>' in a template argument list or cast
23492 expression is considered to be two separate `>'
23493 tokens. So, change the current token to a `>', but don't
23494 consume it: it will be consumed later when the outer
23495 template argument list (or cast expression) is parsed.
23496 Note that this replacement of `>' for `>>' is necessary
23497 even if we are parsing tentatively: in the tentative
23498 case, after calling
23499 cp_parser_enclosed_template_argument_list we will always
23500 throw away all of the template arguments and the first
23501 closing `>', either because the template argument list
23502 was erroneous or because we are replacing those tokens
23503 with a CPP_TEMPLATE_ID token. The second `>' (which will
23504 not have been thrown away) is needed either to close an
23505 outer template argument list or to complete a new-style
23506 cast. */
23509 }
23511 {
23512 /* If we're in a nested template argument list, the '>>' has
23513 to be a typo for '> >'. We emit the error message, but we
23514 continue parsing and we push a '>' as next token, so that
23515 the argument list will be parsed correctly. Note that the
23516 global source location is still on the token before the
23517 '>>', so we need to say explicitly where we want it. */
23523 }
23524 else
23525 {
23526 /* If this is not a nested template argument list, the '>>'
23527 is a typo for '>'. Emit an error message and continue.
23528 Same deal about the token location, but here we can get it
23529 right by consuming the '>>' before issuing the diagnostic. */
23532 "spurious %<>>%>, use %<>%> to terminate "
23534 }
23535 }
23536 else
23538 /* The `>' token might be a greater-than operator again now. */
23539 parser->greater_than_is_operator_p
23541 /* Restore the SAVED_SCOPE. */
23549 }
23551 /* MEMBER_FUNCTION is a member function, or a friend. If default
23552 arguments, or the body of the function have not yet been parsed,
23553 parse them now. */
23555 static void
23557 {
23559 /* If this member is a template, get the underlying
23560 FUNCTION_DECL. */
23564 /* There should not be any class definitions in progress at this
23565 point; the bodies of members are only parsed outside of all class
23566 definitions. */
23568 /* While we're parsing the member functions we might encounter more
23569 classes. We want to handle them right away, but we don't want
23570 them getting mixed up with functions that are currently in the
23571 queue. */
23574 /* Make sure that any template parameters are in scope. */
23577 /* If the body of the function has not yet been parsed, parse it
23578 now. */
23580 {
23581 tree function_scope;
23584 /* The function is no longer pending; we are processing it. */
23589 /* If this is a local class, enter the scope of the containing
23590 function. */
23595 /* Push the body of the function onto the lexer stack. */
23598 /* Let the front end know that we going to be defining this
23599 function. */
23603 /* Don't do access checking if it is a templated function. */
23607 /* #pragma omp declare reduction needs special parsing. */
23609 {
23614 }
23615 else
23616 /* Now, parse the body of the function. */
23623 /* Leave the scope of the containing function. */
23627 }
23629 /* Remove any template parameters from the symbol table. */
23632 /* Restore the queue. */
23635 }
23637 /* If DECL contains any default args, remember it on the unparsed
23638 functions queue. */
23640 static void
23642 {
23643 tree probe;
23646 probe;
23649 {
23653 }
23654 }
23656 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
23657 which is either a FIELD_DECL or PARM_DECL. Parse it and return
23658 the result. For a PARM_DECL, PARMTYPE is the corresponding type
23659 from the parameter-type-list. */
23661 static tree
23664 {
23666 tree parsed_arg;
23672 /* Push the saved tokens for the default argument onto the parser's
23673 lexer stack. */
23679 /* Parse the default argument. */
23690 {
23691 /* In a non-template class, check conversions now. In a template,
23692 we'll wait and instantiate these as needed. */
23695 tf_warning_or_error);
23696 else
23698 }
23700 /* If the token stream has not been completely used up, then
23701 there was extra junk after the end of the default
23702 argument. */
23704 {
23707 else
23709 }
23711 /* Revert to the main lexer. */
23715 }
23717 /* FIELD is a non-static data member with an initializer which we saved for
23718 later; parse it now. */
23720 static void
23722 {
23723 tree def;
23730 NULL_TREE);
23736 }
23738 /* FN is a FUNCTION_DECL which may contains a parameter with an
23739 unparsed DEFAULT_ARG. Parse the default args now. This function
23740 assumes that the current scope is the scope in which the default
23741 argument should be processed. */
23743 static void
23745 {
23749 /* While we're parsing the default args, we might (due to the
23750 statement expression extension) encounter more classes. We want
23751 to handle them right away, but we don't want them getting mixed
23752 up with default args that are currently in the queue. */
23755 /* Local variable names (and the `this' keyword) may not appear
23756 in a default argument. */
23767 {
23769 tree parsed_arg;
23771 tree copy;
23778 /* This can happen for a friend declaration for a function
23779 already declared with default arguments. */
23782 parsed_arg
23784 default_arg,
23787 {
23789 }
23793 /* Update any instantiations we've already created. */
23797 }
23801 /* Make sure no default arg is missing. */
23804 /* Restore the state of local_variables_forbidden_p. */
23807 /* Restore the queue. */
23809 }
23811 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
23813 sizeof ... ( identifier )
23815 where the 'sizeof' token has already been consumed. */
23817 static tree
23819 {
23820 /* Consume the `...'. */
23827 else
23835 /* The name is not qualified. */
23853 }
23855 /* Parse the operand of `sizeof' (or a similar operator). Returns
23856 either a TYPE or an expression, depending on the form of the
23857 input. The KEYWORD indicates which kind of expression we have
23858 encountered. */
23860 static tree
23862 {
23869 /* If it's a `...', then we are computing the length of a parameter
23870 pack. */
23875 /* Types cannot be defined in a `sizeof' expression. Save away the
23876 old message. */
23878 /* And create the new one. */
23884 /* The restrictions on constant-expressions do not apply inside
23885 sizeof expressions. */
23886 saved_integral_constant_expression_p
23888 saved_non_integral_constant_expression_p
23892 /* Do not actually evaluate the expression. */
23895 /* If it's a `(', then we might be looking at the type-id
23896 construction. */
23898 {
23902 /* We can't be sure yet whether we're looking at a type-id or an
23903 expression. */
23905 /* Consume the `('. */
23907 /* Note: as a GNU Extension, compound literals are considered
23908 postfix-expressions as they are in C99, so they are valid
23909 arguments to sizeof. See comment in cp_parser_cast_expression
23910 for details. */
23912 /* Skip tokens until the next token is a closing parenthesis.
23913 If we find the closing `)', and the next token is a `{', then
23914 we are looking at a compound-literal. */
23915 compound_literal_p
23919 /* Roll back the tokens we skipped. */
23921 /* If we were looking at a compound-literal, simulate an error
23922 so that the call to cp_parser_parse_definitely below will
23923 fail. */
23926 else
23927 {
23930 /* Look for the type-id. */
23932 /* Look for the closing `)'. */
23935 }
23937 /* If all went well, then we're done. */
23939 {
23940 cp_decl_specifier_seq decl_specs;
23942 /* Build a trivial decl-specifier-seq. */
23946 /* Call grokdeclarator to figure out what type this is. */
23949 TYPENAME,
23952 }
23953 }
23955 /* If the type-id production did not work out, then we must be
23956 looking at the unary-expression production. */
23961 /* Go back to evaluating expressions. */
23965 /* Free the message we created. */
23967 /* And restore the old one. */
23969 parser->integral_constant_expression_p
23971 parser->non_integral_constant_expression_p
23975 }
23977 /* If the current declaration has no declarator, return true. */
23979 static bool
23981 {
23982 /* If the next token is a `;' or a `,' then there is no
23983 declarator. */
23986 }
23988 /* Update the DECL_SPECS to reflect the storage class indicated by
23989 KEYWORD. */
23991 static void
23996 {
23997 cp_storage_class storage_class;
24000 {
24004 }
24006 {
24009 }
24014 {
24017 }
24020 {
24038 }
24042 /* A storage class specifier cannot be applied alongside a typedef
24043 specifier. If there is a typedef specifier present then set
24044 conflicting_specifiers_p which will trigger an error later
24045 on in grokdeclarator. */
24048 }
24050 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
24051 is true, the type is a class or enum definition. */
24053 static void
24055 tree type_spec,
24058 {
24061 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
24062 (with, for example, in "typedef int wchar_t;") we remember that
24063 this is what happened. In system headers, we ignore these
24064 declarations so that G++ can work with system headers that are not
24065 C++-safe. */
24067 && !type_definition_p
24077 {
24080 ds_redefined_builtin_type_spec,
24081 token);
24083 {
24087 }
24088 }
24091 else
24092 {
24097 }
24098 }
24100 /* True iff TOKEN is the GNU keyword __thread. */
24102 static bool
24104 {
24107 }
24109 /* Set the location for a declarator specifier and check if it is
24110 duplicated.
24112 DECL_SPECS is the sequence of declarator specifiers onto which to
24113 set the location.
24115 DS is the single declarator specifier to set which location is to
24116 be set onto the existing sequence of declarators.
24118 LOCATION is the location for the declarator specifier to
24119 consider. */
24121 static void
24124 {
24133 {
24137 }
24138 else
24139 {
24141 {
24145 else
24146 {
24149 OPT_Wlong_long,
24151 }
24152 }
24154 {
24159 else
24161 }
24162 else
24163 {
24179 "__complex"
24180 };
24183 }
24184 }
24185 }
24187 /* Return true iff the declarator specifier DS is present in the
24188 sequence of declarator specifiers DECL_SPECS. */
24190 bool
24192 cp_decl_spec ds)
24193 {
24200 }
24202 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
24203 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
24205 static bool
24207 {
24209 }
24211 /* Issue an error message indicating that TOKEN_DESC was expected.
24212 If KEYWORD is true, it indicated this function is called by
24213 cp_parser_require_keword and the required token can only be
24214 a indicated keyword. */
24216 static void
24218 required_token token_desc,
24220 {
24222 {
24291 }
24293 {
24295 {
24374 }
24375 }
24376 else
24378 }
24382 /* If the next token is of the indicated TYPE, consume it. Otherwise,
24383 issue an error message indicating that TOKEN_DESC was expected.
24385 Returns the token consumed, if the token had the appropriate type.
24386 Otherwise, returns NULL. */
24391 required_token token_desc)
24392 {
24395 else
24396 {
24397 /* Output the MESSAGE -- unless we're parsing tentatively. */
24401 }
24402 }
24404 /* An error message is produced if the next token is not '>'.
24405 All further tokens are skipped until the desired token is
24406 found or '{', '}', ';' or an unbalanced ')' or ']'. */
24408 static void
24410 {
24411 /* Current level of '< ... >'. */
24413 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
24416 /* Are we ready, yet? If not, issue error message. */
24420 /* Skip tokens until the desired token is found. */
24422 {
24423 /* Peek at the next token. */
24425 {
24433 /* C++0x views the `>>' operator as two `>' tokens, but
24434 C++98 does not. */
24437 {
24438 /* We've hit a `>>' where the first `>' closes the
24439 template argument list, and the second `>' is
24440 spurious. Just consume the `>>' and stop; we've
24441 already produced at least one error. */
24444 }
24445 /* Fall through for C++0x, so we handle the second `>' in
24446 the `>>'. */
24450 {
24451 /* We've reached the token we want, consume it and stop. */
24454 }
24473 /* The '>' was probably forgotten, don't look further. */
24478 }
24480 /* Consume this token. */
24482 }
24483 }
24485 /* If the next token is the indicated keyword, consume it. Otherwise,
24486 issue an error message indicating that TOKEN_DESC was expected.
24488 Returns the token consumed, if the token had the appropriate type.
24489 Otherwise, returns NULL. */
24494 required_token token_desc)
24495 {
24499 {
24502 }
24505 }
24507 /* Returns TRUE iff TOKEN is a token that can begin the body of a
24508 function-definition. */
24510 static bool
24512 {
24515 /* A ctor-initializer begins with a `:'. */
24517 /* A function-try-block begins with `try'. */
24519 /* A function-transaction-block begins with `__transaction_atomic'
24520 or `__transaction_relaxed'. */
24523 /* The named return value extension begins with `return'. */
24525 }
24527 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
24528 definition. */
24530 static bool
24532 {
24539 }
24541 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
24542 C++0x) ending a template-argument. */
24544 static bool
24546 {
24554 }
24556 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
24557 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
24559 static bool
24562 {
24568 /* Check for the sequence `<::' in the original code. It would be lexed as
24569 `[:', where `[' is a digraph, and there is no whitespace before
24570 `:'. */
24572 {
24577 }
24579 }
24581 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
24582 or none_type otherwise. */
24584 static enum tag_types
24586 {
24588 {
24598 }
24599 }
24601 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
24603 static void
24605 {
24609 {
24613 type))
24616 }
24617 }
24619 /* Issue an error message if DECL is redeclared with different
24620 access than its original declaration [class.access.spec/3].
24621 This applies to nested classes and nested class templates.
24622 [class.mem/1]. */
24624 static void
24626 {
24635 }
24637 /* Look for the `template' keyword, as a syntactic disambiguator.
24638 Return TRUE iff it is present, in which case it will be
24639 consumed. */
24641 static bool
24643 {
24645 {
24646 /* In C++98 the `template' keyword can only be used within templates;
24647 outside templates the parser can always figure out what is a
24648 template and what is not. In C++11, per the resolution of DR 468,
24649 `template' is allowed in cases where it is not strictly necessary. */
24652 {
24655 "in C++98 %<template%> (as a disambiguator) is only "
24657 /* If this part of the token stream is rescanned, the same
24658 error message would be generated. So, we purge the token
24659 from the stream. */
24662 }
24663 else
24664 {
24665 /* Consume the `template' keyword. */
24668 }
24669 }
24671 }
24673 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
24674 set PARSER->SCOPE, and perform other related actions. */
24676 static void
24678 {
24684 /* Get the stored value. */
24686 /* Perform any access checks that were deferred. */
24689 {
24694 }
24695 /* Set the scope from the stored value. */
24699 }
24701 /* Consume tokens up through a non-nested END token. Returns TRUE if we
24702 encounter the end of a block before what we were looking for. */
24704 static bool
24708 {
24710 {
24713 /* Abort a parenthesized expression if we encounter a semicolon. */
24717 /* If we've reached the end of the file, stop. */
24723 /* We've hit the end of an enclosing block, so there's been some
24724 kind of syntax error. */
24727 /* Consume the token. */
24729 /* See if it starts a new group. */
24731 {
24733 /* In theory this should probably check end == '}', but
24734 cp_parser_save_member_function_body needs it to exit
24735 after either '}' or ')' when called with ')'. */
24738 }
24740 {
24744 }
24749 }
24750 }
24752 /* Like above, for caching a default argument or NSDMI. Both of these are
24753 terminated by a non-nested comma, but it can be unclear whether or not a
24754 comma is nested in a template argument list unless we do more parsing.
24755 In order to handle this ambiguity, when we encounter a ',' after a '<'
24756 we try to parse what follows as a parameter-declaration-list (in the
24757 case of a default argument) or a member-declarator (in the case of an
24758 NSDMI). If that succeeds, then we stop caching. */
24760 static tree
24762 {
24767 tree default_argument;
24769 /* Add tokens until we have processed the entire default
24770 argument. We add the range [first_token, token). */
24773 {
24774 /* For list-initialization, this is straightforward. */
24777 }
24779 {
24782 /* Peek at the next token. */
24784 /* What we do depends on what token we have. */
24786 {
24787 /* In valid code, a default argument must be
24788 immediately followed by a `,' `)', or `...'. */
24791 {
24792 /* If we've seen a '<', we might be in a
24793 template-argument-list. Until Core issue 325 is
24794 resolved, we don't know how this situation ought
24795 to be handled, so try to DTRT. We check whether
24796 what comes after the comma is a valid parameter
24797 declaration list. If it is, then the comma ends
24798 the default argument; otherwise the default
24799 argument continues. */
24802 /* Set ITALP so cp_parser_parameter_declaration_list
24803 doesn't decide to commit to this parse. */
24811 {
24817 }
24818 else
24819 {
24823 }
24830 }
24833 /* If we run into a non-nested `;', `}', or `]',
24834 then the code is invalid -- but the default
24835 argument is certainly over. */
24840 /* Handle correctly int n = sizeof ... ( p ); */
24843 /* Update DEPTH, if necessary. */
24858 /* This might be the comparison operator, or it might
24859 start a template argument list. */
24866 /* Fall through for C++0x, which treats the `>>'
24867 operator like two `>' tokens in certain
24868 cases. */
24872 {
24873 /* This might be an operator, or it might close a
24874 template argument list. But if a previous '<'
24875 started a template argument list, this will have
24876 closed it, so we can't be in one anymore. */
24880 }
24883 /* If we run out of tokens, issue an error message. */
24892 /* In these cases, we should look for template-ids.
24893 For example, if the default argument is
24894 `X<int, double>()', we need to do name lookup to
24895 figure out whether or not `X' is a template; if
24896 so, the `,' does not end the default argument.
24898 That is not yet done. */
24903 }
24905 /* If we've reached the end, stop. */
24909 /* Add the token to the token block. */
24911 }
24913 /* Create a DEFAULT_ARG to represent the unparsed default
24914 argument. */
24921 }
24923 /* Begin parsing tentatively. We always save tokens while parsing
24924 tentatively so that if the tentative parsing fails we can restore the
24925 tokens. */
24927 static void
24929 {
24930 /* Enter a new parsing context. */
24932 /* Begin saving tokens. */
24934 /* In order to avoid repetitive access control error messages,
24935 access checks are queued up until we are no longer parsing
24936 tentatively. */
24938 }
24940 /* Commit to the currently active tentative parse. */
24942 static void
24944 {
24948 /* Mark all of the levels as committed. */
24951 {
24958 }
24959 }
24961 /* Commit to the topmost currently active tentative parse.
24963 Note that this function shouldn't be called when there are
24964 irreversible side-effects while in a tentative state. For
24965 example, we shouldn't create a permanent entry in the symbol
24966 table, or issue an error message that might not apply if the
24967 tentative parse is aborted. */
24969 static void
24971 {
24976 {
24984 }
24985 }
24987 /* Abort the currently active tentative parse. All consumed tokens
24988 will be rolled back, and no diagnostics will be issued. */
24990 static void
24992 {
24996 /* Now, pretend that we want to see if the construct was
24997 successfully parsed. */
24999 }
25001 /* Stop parsing tentatively. If a parse error has occurred, restore the
25002 token stream. Otherwise, commit to the tokens we have consumed.
25003 Returns true if no error occurred; false otherwise. */
25005 static bool
25007 {
25011 /* Remember whether or not an error occurred, since we are about to
25012 destroy that information. */
25014 /* Remove the topmost context from the stack. */
25017 /* If no parse errors occurred, commit to the tentative parse. */
25019 {
25020 /* Commit to the tokens read tentatively, unless that was
25021 already done. */
25026 }
25027 /* Otherwise, if errors occurred, roll back our state so that things
25028 are just as they were before we began the tentative parse. */
25029 else
25030 {
25033 }
25034 /* Add the context to the front of the free list. */
25039 }
25041 /* Returns true if we are parsing tentatively and are not committed to
25042 this tentative parse. */
25044 static bool
25046 {
25049 }
25051 /* Returns nonzero iff an error has occurred during the most recent
25052 tentative parse. */
25054 static bool
25056 {
25059 }
25061 /* Returns nonzero if GNU extensions are allowed. */
25063 static bool
25065 {
25067 }
25068 \f
25069 /* Objective-C++ Productions */
25072 /* Parse an Objective-C expression, which feeds into a primary-expression
25073 above.
25075 objc-expression:
25076 objc-message-expression
25077 objc-string-literal
25078 objc-encode-expression
25079 objc-protocol-expression
25080 objc-selector-expression
25082 Returns a tree representation of the expression. */
25084 static tree
25086 {
25087 /* Try to figure out what kind of declaration is present. */
25091 {
25101 {
25113 }
25119 }
25122 }
25124 /* Parse an Objective-C message expression.
25126 objc-message-expression:
25127 [ objc-message-receiver objc-message-args ]
25129 Returns a representation of an Objective-C message. */
25131 static tree
25133 {
25142 }
25144 /* Parse an objc-message-receiver.
25146 objc-message-receiver:
25147 expression
25148 simple-type-specifier
25150 Returns a representation of the type or expression. */
25152 static tree
25154 {
25155 tree rcv;
25157 /* An Objective-C message receiver may be either (1) a type
25158 or (2) an expression. */
25167 CP_PARSER_FLAGS_NONE);
25170 }
25172 /* Parse the arguments and selectors comprising an Objective-C message.
25174 objc-message-args:
25175 objc-selector
25176 objc-selector-args
25177 objc-selector-args , objc-comma-args
25179 objc-selector-args:
25180 objc-selector [opt] : assignment-expression
25181 objc-selector-args objc-selector [opt] : assignment-expression
25183 objc-comma-args:
25184 assignment-expression
25185 objc-comma-args , assignment-expression
25187 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
25188 selector arguments and TREE_VALUE containing a list of comma
25189 arguments. */
25191 static tree
25193 {
25199 {
25205 /* Detect if we have a unary selector. */
25214 sel_args
25219 }
25221 /* Handle non-selector arguments, if any. */
25223 {
25224 tree arg;
25229 addl_args
25234 }
25237 {
25240 }
25243 }
25245 /* Parse an Objective-C encode expression.
25247 objc-encode-expression:
25248 @encode objc-typename
25250 Returns an encoded representation of the type argument. */
25252 static tree
25254 {
25255 tree type;
25265 {
25269 }
25271 /* This happens if we find @encode(T) (where T is a template
25272 typename or something dependent on a template typename) when
25273 parsing a template. In that case, we can't compile it
25274 immediately, but we rather create an AT_ENCODE_EXPR which will
25275 need to be instantiated when the template is used.
25276 */
25278 {
25282 }
25285 }
25287 /* Parse an Objective-C @defs expression. */
25289 static tree
25291 {
25292 tree name;
25300 }
25302 /* Parse an Objective-C protocol expression.
25304 objc-protocol-expression:
25305 @protocol ( identifier )
25307 Returns a representation of the protocol expression. */
25309 static tree
25311 {
25312 tree proto;
25320 }
25322 /* Parse an Objective-C selector expression.
25324 objc-selector-expression:
25325 @selector ( objc-method-signature )
25327 objc-method-signature:
25328 objc-selector
25329 objc-selector-seq
25331 objc-selector-seq:
25332 objc-selector :
25333 objc-selector-seq objc-selector :
25335 Returns a representation of the method selector. */
25337 static tree
25339 {
25351 {
25360 {
25361 /* Detect if we have a unary selector. */
25363 {
25366 }
25367 else
25368 {
25370 }
25371 }
25376 {
25377 sel_seq
25380 sel_seq
25383 }
25384 else
25385 sel_seq
25390 }
25392 finish_selector:
25396 }
25398 /* Parse a list of identifiers.
25400 objc-identifier-list:
25401 identifier
25402 objc-identifier-list , identifier
25404 Returns a TREE_LIST of identifier nodes. */
25406 static tree
25408 {
25409 tree identifier;
25410 tree list;
25421 {
25428 identifier));
25430 }
25433 }
25435 /* Parse an Objective-C alias declaration.
25437 objc-alias-declaration:
25438 @compatibility_alias identifier identifier ;
25440 This function registers the alias mapping with the Objective-C front end.
25441 It returns nothing. */
25443 static void
25445 {
25453 }
25455 /* Parse an Objective-C class forward-declaration.
25457 objc-class-declaration:
25458 @class objc-identifier-list ;
25460 The function registers the forward declarations with the Objective-C
25461 front end. It returns nothing. */
25463 static void
25465 {
25468 {
25469 tree id;
25479 else
25481 }
25483 }
25485 /* Parse a list of Objective-C protocol references.
25487 objc-protocol-refs-opt:
25488 objc-protocol-refs [opt]
25490 objc-protocol-refs:
25491 < objc-identifier-list >
25493 Returns a TREE_LIST of identifiers, if any. */
25495 static tree
25497 {
25501 {
25505 }
25508 }
25510 /* Parse a Objective-C visibility specification. */
25512 static void
25514 {
25518 {
25533 }
25535 /* Eat '@private'/'@protected'/'@public'. */
25537 }
25539 /* Parse an Objective-C method type. Return 'true' if it is a class
25540 (+) method, and 'false' if it is an instance (-) method. */
25544 {
25547 else
25549 }
25551 /* Parse an Objective-C protocol qualifier. */
25553 static tree
25555 {
25568 {
25573 }
25576 }
25578 /* Parse an Objective-C typename. */
25580 static tree
25582 {
25586 {
25592 /* An ObjC type name may consist of just protocol qualifiers, in which
25593 case the type shall default to 'id'. */
25595 {
25598 /* If the type could not be parsed, an error has already
25599 been produced. For error recovery, behave as if it had
25600 not been specified, which will use the default type
25601 'id'. */
25603 {
25605 /* We need to skip to the closing parenthesis as
25606 cp_parser_type_id() does not seem to do it for
25607 us. */
25612 }
25613 }
25617 }
25620 }
25622 /* Check to see if TYPE refers to an Objective-C selector name. */
25624 static bool
25626 {
25632 }
25634 /* Parse an Objective-C selector. */
25636 static tree
25638 {
25642 {
25645 }
25647 /* C++ operator names are allowed to appear in ObjC selectors. */
25649 {
25662 }
25663 }
25665 /* Parse an Objective-C params list. */
25667 static tree
25669 {
25675 {
25685 /* Detect if we have a unary selector. */
25688 {
25691 }
25695 {
25696 /* Something went quite wrong. There should be a colon
25697 here, but there is not. Stop parsing parameters. */
25699 }
25701 /* New ObjC allows attributes on parameters too. */
25706 params
25709 type_name,
25710 identifier,
25711 parm_attr));
25714 }
25717 {
25720 }
25722 /* We allow tail attributes for the method. */
25724 {
25732 }
25735 {
25738 }
25740 }
25742 /* Parse the non-keyword Objective-C params. */
25744 static tree
25747 {
25753 {
25755 tree parm;
25761 {
25766 }
25768 /* TODO: parse attributes for tail parameters. */
25777 }
25779 /* We allow tail attributes for the method. */
25781 {
25783 {
25788 }
25789 else
25790 /* We have an error, but parse the attributes, so that we can
25791 carry on. */
25797 }
25800 }
25802 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
25804 static void
25806 {
25809 /* If the next token is `extern' and the following token is a string
25810 literal, then we have a linkage specification. */
25812 && cp_parser_is_pure_string_literal
25815 /* Handle #pragma, if any. */
25818 /* Allow stray semicolons. */
25821 /* Mark methods as optional or required, when building protocols. */
25823 {
25826 }
25828 {
25831 }
25834 /* Other stray characters must generate errors. */
25836 {
25840 }
25841 /* Finally, try to parse a block-declaration, or a function-definition. */
25842 else
25844 }
25846 /* Parse a method signature. */
25848 static tree
25850 {
25866 }
25868 static bool
25870 {
25871 tree tattr;
25876 /* If the attributes are followed by a method introducer, this is not allowed.
25877 Dump the attributes and flag the situation. */
25882 /* Otherwise, the attributes introduce some interstitial code, possibly so
25883 rewind to allow that check. */
25886 }
25888 /* Parse an Objective-C method prototype list. */
25890 static void
25892 {
25896 {
25898 {
25903 else
25907 {
25911 }
25914 }
25920 OPT_Wattributes,
25922 else
25923 /* Allow for interspersed non-ObjC++ code. */
25927 }
25931 else
25935 }
25937 /* Parse an Objective-C method definition list. */
25939 static void
25941 {
25945 {
25946 tree meth;
25949 {
25955 else
25960 {
25964 }
25966 NULL_TREE);
25968 /* For historical reasons, we accept an optional semicolon. */
25975 {
25982 }
25983 }
25984 /* The following case will be removed once @synthesize is
25985 completely implemented. */
25996 else
25997 /* Allow for interspersed non-ObjC++ code. */
26001 }
26005 else
26009 }
26011 /* Parse Objective-C ivars. */
26013 static void
26015 {
26026 {
26027 cp_decl_specifier_seq declspecs;
26029 tree prefix_attributes;
26037 CP_PARSER_FLAGS_OPTIONAL,
26041 /* auto, register, static, extern, mutable. */
26043 {
26046 }
26048 /* thread_local. */
26050 {
26053 }
26055 /* typedef. */
26057 {
26060 }
26065 /* Keep going until we hit the `;' at the end of the
26066 declaration. */
26068 {
26073 /* Check for a (possibly unnamed) bitfield declaration. */
26081 {
26082 /* Get the name of the bitfield. */
26085 sfk_none);
26087 eat_colon:
26089 /* Get the width of the bitfield. */
26090 width
26093 NULL);
26094 }
26095 else
26096 {
26097 /* Parse the declarator. */
26098 declarator
26103 }
26105 /* Look for attributes that apply to the ivar. */
26107 /* Remember which attributes are prefix attributes and
26108 which are not. */
26110 /* Combine the attributes. */
26114 /* Create the bitfield declaration. */
26116 width,
26117 attributes);
26118 else
26123 /* Add the instance variable. */
26127 /* Reset PREFIX_ATTRIBUTES. */
26136 {
26139 }
26141 }
26145 }
26150 /* Do not consume the RID_AT_END, so it will be read again as terminating
26151 the @interface of @implementation. */
26155 /* For historical reasons, we accept an optional semicolon. */
26158 }
26160 /* Parse an Objective-C protocol declaration. */
26162 static void
26164 {
26170 {
26175 }
26177 /* See if we have a forward declaration or a definition. */
26180 /* Try a forward declaration first. */
26182 {
26184 {
26185 tree id;
26195 else
26197 }
26199 }
26201 /* Ok, we got a full-fledged definition (or at least should). */
26202 else
26203 {
26208 }
26209 }
26211 /* Parse an Objective-C superclass or category. */
26213 static void
26218 {
26224 {
26227 }
26229 {
26232 /* If there is no category name, and this is an @interface, we
26233 have a class extension. */
26235 {
26238 }
26239 else
26243 }
26244 }
26246 /* Parse an Objective-C class interface. */
26248 static void
26250 {
26257 {
26258 /* It's hard to recover because even if valid @interface stuff
26259 is to follow, we can't compile it (or validate it) if we
26260 don't even know which class it refers to. Let's assume this
26261 was a stray '@interface' token in the stream and skip it.
26262 */
26264 }
26269 /* We have either a class or a category on our hands. */
26272 else
26273 {
26275 /* Handle instance variable declarations, if any. */
26278 }
26281 }
26283 /* Parse an Objective-C class implementation. */
26285 static void
26287 {
26294 {
26295 /* It's hard to recover because even if valid @implementation
26296 stuff is to follow, we can't compile it (or validate it) if
26297 we don't even know which class it refers to. Let's assume
26298 this was a stray '@implementation' token in the stream and
26299 skip it.
26300 */
26302 }
26306 /* We have either a class or a category on our hands. */
26309 else
26310 {
26312 /* Handle instance variable declarations, if any. */
26315 }
26318 }
26320 /* Consume the @end token and finish off the implementation. */
26322 static void
26324 {
26327 }
26329 /* Parse an Objective-C declaration. */
26331 static void
26333 {
26334 /* Try to figure out what kind of declaration is present. */
26339 {
26355 }
26358 {
26381 }
26382 }
26384 /* Parse an Objective-C try-catch-finally statement.
26386 objc-try-catch-finally-stmt:
26387 @try compound-statement objc-catch-clause-seq [opt]
26388 objc-finally-clause [opt]
26390 objc-catch-clause-seq:
26391 objc-catch-clause objc-catch-clause-seq [opt]
26393 objc-catch-clause:
26394 @catch ( objc-exception-declaration ) compound-statement
26396 objc-finally-clause:
26397 @finally compound-statement
26399 objc-exception-declaration:
26400 parameter-declaration
26401 '...'
26403 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
26405 Returns NULL_TREE.
26407 PS: This function is identical to c_parser_objc_try_catch_finally_statement
26408 for C. Keep them in sync. */
26410 static tree
26412 {
26413 location_t location;
26414 tree stmt;
26419 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
26420 node, lest it get absorbed into the surrounding block. */
26426 {
26435 {
26436 /* We have "@catch (...)" (where the '...' are literally
26437 what is in the code). Skip the '...'.
26438 parameter_declaration is set to NULL_TREE, and
26439 objc_being_catch_clauses() knows that that means
26440 '...'. */
26443 }
26444 else
26445 {
26446 /* We have "@catch (NSException *exception)" or something
26447 like that. Parse the parameter declaration. */
26451 else
26456 }
26459 else
26460 {
26461 /* If there was no open parenthesis, we are recovering from
26462 an error, and we are trying to figure out what mistake
26463 the user has made. */
26465 /* If there is an immediate closing parenthesis, the user
26466 probably forgot the opening one (ie, they typed "@catch
26467 NSException *e)". Parse the closing parenthesis and keep
26468 going. */
26472 /* If these is no immediate closing parenthesis, the user
26473 probably doesn't know that parenthesis are required at
26474 all (ie, they typed "@catch NSException *e"). So, just
26475 forget about the closing parenthesis and keep going. */
26476 }
26480 }
26482 {
26485 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
26486 node, lest it get absorbed into the surrounding block. */
26490 }
26493 }
26495 /* Parse an Objective-C synchronized statement.
26497 objc-synchronized-stmt:
26498 @synchronized ( expression ) compound-statement
26500 Returns NULL_TREE. */
26502 static tree
26504 {
26505 location_t location;
26516 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
26517 node, lest it get absorbed into the surrounding block. */
26522 }
26524 /* Parse an Objective-C throw statement.
26526 objc-throw-stmt:
26527 @throw assignment-expression [opt] ;
26529 Returns a constructed '@throw' statement. */
26531 static tree
26533 {
26545 }
26547 /* Parse an Objective-C statement. */
26549 static tree
26551 {
26552 /* Try to figure out what kind of declaration is present. */
26556 {
26567 }
26570 }
26572 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
26573 look ahead to see if an objc keyword follows the attributes. This
26574 is to detect the use of prefix attributes on ObjC @interface and
26575 @protocol. */
26577 static bool
26579 {
26584 {
26587 }
26590 }
26592 /* This routine is a minimal replacement for
26593 c_parser_struct_declaration () used when parsing the list of
26594 types/names or ObjC++ properties. For example, when parsing the
26595 code
26597 @property (readonly) int a, b, c;
26599 this function is responsible for parsing "int a, int b, int c" and
26600 returning the declarations as CHAIN of DECLs.
26602 TODO: Share this code with cp_parser_objc_class_ivars. It's very
26603 similar parsing. */
26604 static tree
26606 {
26608 cp_decl_specifier_seq declspecs;
26610 tree prefix_attributes;
26613 CP_PARSER_FLAGS_NONE,
26620 /* auto, register, static, extern, mutable. */
26622 {
26625 }
26627 /* thread_local. */
26629 {
26632 }
26634 /* typedef. */
26636 {
26639 }
26644 /* Keep going until we hit the `;' at the end of the declaration. */
26646 {
26651 /* Parse the declarator. */
26655 /* Look for attributes that apply to the ivar. */
26657 /* Remember which attributes are prefix attributes and
26658 which are not. */
26660 /* Combine the attributes. */
26670 /* Reset PREFIX_ATTRIBUTES. */
26681 {
26684 }
26685 else
26687 }
26689 }
26691 /* Parse an Objective-C @property declaration. The syntax is:
26693 objc-property-declaration:
26694 '@property' objc-property-attributes[opt] struct-declaration ;
26696 objc-property-attributes:
26697 '(' objc-property-attribute-list ')'
26699 objc-property-attribute-list:
26700 objc-property-attribute
26701 objc-property-attribute-list, objc-property-attribute
26703 objc-property-attribute
26704 'getter' = identifier
26705 'setter' = identifier
26706 'readonly'
26707 'readwrite'
26708 'assign'
26709 'retain'
26710 'copy'
26711 'nonatomic'
26713 For example:
26714 @property NSString *name;
26715 @property (readonly) id object;
26716 @property (retain, nonatomic, getter=getTheName) id name;
26717 @property int a, b, c;
26719 PS: This function is identical to
26720 c_parser_objc_at_property_declaration for C. Keep them in sync. */
26721 static void
26723 {
26724 /* The following variables hold the attributes of the properties as
26725 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
26726 seen. When we see an attribute, we set them to 'true' (if they
26727 are boolean properties) or to the identifier (if they have an
26728 argument, ie, for getter and setter). Note that here we only
26729 parse the list of attributes, check the syntax and accumulate the
26730 attributes that we find. objc_add_property_declaration() will
26731 then process the information. */
26741 /* 'properties' is the list of properties that we read. Usually a
26742 single one, but maybe more (eg, in "@property int a, b, c;" there
26743 are three). */
26744 tree properties;
26745 location_t loc;
26751 /* Parse the optional attribute list... */
26753 {
26754 /* Eat the '('. */
26758 {
26764 {
26767 }
26771 {
26782 {
26786 else
26791 }
26794 {
26798 }
26800 {
26802 {
26805 }
26806 else
26810 else
26812 }
26813 else
26814 {
26816 {
26819 }
26820 else
26822 }
26828 }
26835 else
26837 }
26839 /* FIXME: "@property (setter, assign);" will generate a spurious
26840 "error: expected ‘)’ before ‘,’ token". This is because
26841 cp_parser_require, unlike the C counterpart, will produce an
26842 error even if we are in error recovery. */
26844 {
26849 }
26850 }
26852 /* ... and the property declaration(s). */
26856 {
26858 /* If the next token is now a `;', consume it. */
26862 }
26866 else
26867 {
26868 /* Comma-separated properties are chained together in
26869 reverse order; add them one by one. */
26878 }
26881 }
26883 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
26885 objc-synthesize-declaration:
26886 @synthesize objc-synthesize-identifier-list ;
26888 objc-synthesize-identifier-list:
26889 objc-synthesize-identifier
26890 objc-synthesize-identifier-list, objc-synthesize-identifier
26892 objc-synthesize-identifier
26893 identifier
26894 identifier = identifier
26896 For example:
26897 @synthesize MyProperty;
26898 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
26900 PS: This function is identical to c_parser_objc_at_synthesize_declaration
26901 for C. Keep them in sync.
26902 */
26903 static void
26905 {
26907 location_t loc;
26912 {
26916 {
26919 }
26921 {
26925 {
26928 }
26929 }
26930 else
26935 else
26937 }
26940 }
26942 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
26944 objc-dynamic-declaration:
26945 @dynamic identifier-list ;
26947 For example:
26948 @dynamic MyProperty;
26949 @dynamic MyProperty, AnotherProperty;
26951 PS: This function is identical to c_parser_objc_at_dynamic_declaration
26952 for C. Keep them in sync.
26953 */
26954 static void
26956 {
26958 location_t loc;
26963 {
26964 tree property;
26967 {
26970 }
26974 else
26976 }
26979 }
26981 \f
26982 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 parsing routines. */
26984 /* Returns name of the next clause.
26985 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
26986 the token is not consumed. Otherwise appropriate pragma_omp_clause is
26987 returned and the token is consumed. */
26989 static pragma_omp_clause
26991 {
27003 {
27008 {
27111 }
27112 }
27118 }
27120 /* Validate that a clause of the given type does not already exist. */
27122 static void
27125 {
27126 tree c;
27130 {
27133 }
27134 }
27136 /* OpenMP 2.5:
27137 variable-list:
27138 identifier
27139 variable-list , identifier
27141 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
27142 colon). An opening parenthesis will have been consumed by the caller.
27144 If KIND is nonzero, create the appropriate node and install the decl
27145 in OMP_CLAUSE_DECL and add the node to the head of the list.
27147 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
27148 return the list created.
27150 COLON can be NULL if only closing parenthesis should end the list,
27151 or pointer to bool which will receive false if the list is terminated
27152 by closing parenthesis or true if the list is terminated by colon. */
27154 static tree
27157 {
27161 {
27164 }
27166 {
27183 {
27185 {
27191 {
27198 NULL);
27200 parser->colon_corrects_to_scope_p
27204 else
27205 {
27206 /* Look for `:'. */
27210 CPP_CLOSE_SQUARE))
27213 NULL);
27214 }
27215 /* Look for the closing `]'. */
27217 RT_CLOSE_SQUARE))
27220 }
27224 }
27230 }
27231 else
27234 get_comma:
27238 }
27244 {
27248 }
27251 {
27254 /* Try to resync to an unnested comma. Copied from
27255 cp_parser_parenthesized_expression_list. */
27256 skip_comma:
27265 }
27268 }
27270 /* Similarly, but expect leading and trailing parenthesis. This is a very
27271 common case for omp clauses. */
27273 static tree
27275 {
27279 }
27281 /* OpenMP 3.0:
27282 collapse ( constant-expression ) */
27284 static tree
27286 {
27288 location_t loc;
27289 HOST_WIDE_INT n;
27309 {
27312 }
27320 }
27322 /* OpenMP 2.5:
27323 default ( shared | none ) */
27325 static tree
27327 {
27329 tree c;
27334 {
27339 {
27354 }
27357 }
27358 else
27359 {
27360 invalid_kind:
27362 }
27378 }
27380 /* OpenMP 3.1:
27381 final ( expression ) */
27383 static tree
27385 {
27406 }
27408 /* OpenMP 2.5:
27409 if ( expression ) */
27411 static tree
27413 {
27434 }
27436 /* OpenMP 3.1:
27437 mergeable */
27439 static tree
27442 {
27443 tree c;
27446 location);
27451 }
27453 /* OpenMP 2.5:
27454 nowait */
27456 static tree
27459 {
27460 tree c;
27467 }
27469 /* OpenMP 2.5:
27470 num_threads ( expression ) */
27472 static tree
27474 location_t location)
27475 {
27497 }
27499 /* OpenMP 2.5:
27500 ordered */
27502 static tree
27505 {
27506 tree c;
27514 }
27516 /* OpenMP 2.5:
27517 reduction ( reduction-operator : variable-list )
27519 reduction-operator:
27520 One of: + * - & ^ | && ||
27522 OpenMP 3.1:
27524 reduction-operator:
27525 One of: + * - & ^ | && || min max
27527 OpenMP 4.0:
27529 reduction-operator:
27530 One of: + * - & ^ | && ||
27531 id-expression */
27533 static tree
27535 {
27543 {
27553 }
27557 else
27558 {
27569 {
27599 }
27600 else
27601 {
27603 resync_fail:
27608 }
27609 }
27615 NULL);
27617 {
27620 }
27623 }
27625 /* OpenMP 2.5:
27626 schedule ( schedule-kind )
27627 schedule ( schedule-kind , expression )
27629 schedule-kind:
27630 static | dynamic | guided | runtime | auto */
27632 static tree
27634 {
27643 {
27648 {
27669 }
27670 }
27675 else
27680 {
27695 else
27700 }
27708 invalid_kind:
27710 resync_fail:
27715 }
27717 /* OpenMP 3.0:
27718 untied */
27720 static tree
27723 {
27724 tree c;
27731 }
27733 /* OpenMP 4.0:
27734 inbranch
27735 notinbranch */
27737 static tree
27740 {
27745 }
27747 /* OpenMP 4.0:
27748 parallel
27749 for
27750 sections
27751 taskgroup */
27753 static tree
27757 {
27761 }
27763 /* OpenMP 4.0:
27764 num_teams ( expression ) */
27766 static tree
27768 location_t location)
27769 {
27791 }
27793 /* OpenMP 4.0:
27794 thread_limit ( expression ) */
27796 static tree
27798 location_t location)
27799 {
27821 }
27823 /* OpenMP 4.0:
27824 aligned ( variable-list )
27825 aligned ( variable-list : constant-expression ) */
27827 static tree
27829 {
27840 {
27850 }
27856 }
27858 /* OpenMP 4.0:
27859 linear ( variable-list )
27860 linear ( variable-list : expression ) */
27862 static tree
27865 {
27876 {
27880 {
27883 }
27891 }
27897 }
27899 /* OpenMP 4.0:
27900 safelen ( constant-expression ) */
27902 static tree
27904 location_t location)
27905 {
27926 }
27928 /* OpenMP 4.0:
27929 simdlen ( constant-expression ) */
27931 static tree
27933 location_t location)
27934 {
27955 }
27957 /* OpenMP 4.0:
27958 depend ( depend-kind : variable-list )
27960 depend-kind:
27961 in | out | inout */
27963 static tree
27965 {
27973 {
27983 else
27985 }
27986 else
27994 NULL);
28001 invalid_kind:
28003 resync_fail:
28008 }
28010 /* OpenMP 4.0:
28011 map ( map-kind : variable-list )
28012 map ( variable-list )
28014 map-kind:
28015 alloc | to | from | tofrom */
28017 static tree
28019 {
28028 {
28040 else
28041 {
28047 }
28050 }
28053 NULL);
28059 }
28061 /* OpenMP 4.0:
28062 device ( expression ) */
28064 static tree
28066 location_t location)
28067 {
28089 }
28091 /* OpenMP 4.0:
28092 dist_schedule ( static )
28093 dist_schedule ( static , expression ) */
28095 static tree
28097 location_t location)
28098 {
28111 {
28122 }
28127 location);
28131 invalid_kind:
28133 resync_fail:
28138 }
28140 /* OpenMP 4.0:
28141 proc_bind ( proc-bind-kind )
28143 proc-bind-kind:
28144 master | close | spread */
28146 static tree
28148 location_t location)
28149 {
28150 tree c;
28157 {
28167 else
28169 }
28170 else
28179 location);
28184 invalid_kind:
28186 resync_fail:
28191 }
28193 /* Parse all OpenMP clauses. The set clauses allowed by the directive
28194 is a bitmask in MASK. Return the list of clauses found; the result
28195 of clause default goes in *pdefault. */
28197 static tree
28201 {
28208 {
28209 pragma_omp_clause c_kind;
28220 {
28232 clauses);
28246 clauses);
28255 clauses);
28279 clauses);
28293 clauses);
28310 OMP_CLAUSE_NOTINBRANCH,
28319 {
28320 clause_not_first:
28324 }
28349 clauses);
28354 clauses);
28359 clauses);
28422 }
28427 {
28428 /* Remove the invalid clause(s) from the list to avoid
28429 confusing the rest of the compiler. */
28432 }
28433 }
28434 saw_error:
28435 /* In Cilk Plus SIMD enabled functions there is no pragma_token, so
28436 no reason to skip to the end. */
28442 }
28444 /* OpenMP 2.5:
28445 structured-block:
28446 statement
28448 In practice, we're also interested in adding the statement to an
28449 outer node. So it is convenient if we work around the fact that
28450 cp_parser_statement calls add_stmt. */
28452 static unsigned
28454 {
28457 /* Only move the values to IN_OMP_BLOCK if they weren't false.
28458 This preserves the "not within loop or switch" style error messages
28459 for nonsense cases like
28460 void foo() {
28461 #pragma omp single
28462 break;
28463 }
28464 */
28469 }
28471 static void
28473 {
28475 }
28477 static tree
28479 {
28487 }
28489 /* OpenMP 2.5:
28490 # pragma omp atomic new-line
28491 expression-stmt
28493 expression-stmt:
28494 x binop= expr | x++ | ++x | x-- | --x
28495 binop:
28496 +, *, -, /, &, ^, |, <<, >>
28498 where x is an lvalue expression with scalar type.
28500 OpenMP 3.1:
28501 # pragma omp atomic new-line
28502 update-stmt
28504 # pragma omp atomic read new-line
28505 read-stmt
28507 # pragma omp atomic write new-line
28508 write-stmt
28510 # pragma omp atomic update new-line
28511 update-stmt
28513 # pragma omp atomic capture new-line
28514 capture-stmt
28516 # pragma omp atomic capture new-line
28517 capture-block
28519 read-stmt:
28520 v = x
28521 write-stmt:
28522 x = expr
28523 update-stmt:
28524 expression-stmt | x = x binop expr
28525 capture-stmt:
28526 v = expression-stmt
28527 capture-block:
28528 { v = x; update-stmt; } | { update-stmt; v = x; }
28530 OpenMP 4.0:
28531 update-stmt:
28532 expression-stmt | x = x binop expr | x = expr binop x
28533 capture-stmt:
28534 v = update-stmt
28535 capture-block:
28536 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
28538 where x and v are lvalue expressions with scalar type. */
28540 static void
28542 {
28550 {
28555 {
28561 }
28562 }
28564 {
28576 else
28580 }
28582 {
28588 {
28593 {
28596 }
28597 }
28598 }
28602 {
28613 else
28619 {
28620 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
28621 opcode. */
28626 }
28630 {
28633 }
28634 else
28635 {
28642 }
28645 }
28647 restart:
28652 {
28659 /* FALLTHROUGH */
28669 /* FALLTHROUGH */
28684 /* Undo effects of boolean_increment for post {in,de}crement. */
28686 /* FALLTHRU */
28690 {
28691 /* Undo effects of boolean_increment. */
28693 {
28694 /* This is pre or post increment. */
28699 && !structured_block
28703 }
28704 }
28705 /* FALLTHRU */
28708 {
28743 {
28747 }
28750 {
28756 {
28761 }
28763 {
28774 {
28776 {
28781 }
28782 else
28784 }
28788 }
28791 {
28798 }
28802 }
28806 {
28809 {
28817 }
28819 {
28824 }
28859 }
28870 /* FALLTHROUGH */
28875 }
28882 }
28883 stmt_done:
28885 {
28898 }
28900 {
28903 }
28904 done:
28910 saw_error:
28913 {
28917 {
28921 }
28922 }
28923 }
28926 /* OpenMP 2.5:
28927 # pragma omp barrier new-line */
28929 static void
28931 {
28934 }
28936 /* OpenMP 2.5:
28937 # pragma omp critical [(name)] new-line
28938 structured-block */
28940 static tree
28942 {
28946 {
28958 }
28963 }
28965 /* OpenMP 2.5:
28966 # pragma omp flush flush-vars[opt] new-line
28968 flush-vars:
28969 ( variable-list ) */
28971 static void
28973 {
28979 }
28981 /* Helper function, to parse omp for increment expression. */
28983 static tree
28985 {
28990 {
28993 }
28996 {
29005 /* Fall through: OpenMP disallows NE_EXPR. */
29008 }
29010 /* If decl is an iterator, preserve LHS and RHS of the relational
29011 expr until finish_omp_for. */
29021 }
29023 /* Helper function, to parse omp for increment expression. */
29025 static tree
29027 {
29031 cp_id_kind idk;
29035 {
29043 }
29051 {
29056 }
29063 {
29067 }
29079 do
29080 {
29087 {
29089 {
29092 else
29094 tf_warning_or_error);
29095 }
29096 else
29099 }
29100 }
29104 {
29108 }
29109 else
29113 }
29115 /* Parse the initialization statement of either an OpenMP for loop or
29116 a Cilk Plus for loop.
29118 PARSING_OPENMP is true if parsing OpenMP, or false if parsing Cilk
29119 Plus.
29121 Return true if the resulting construct should have an
29122 OMP_CLAUSE_PRIVATE added to it. */
29124 static bool
29132 {
29138 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
29140 init-expr:
29141 var = lb
29142 integer-type var = lb
29143 random-access-iterator-type var = lb
29144 pointer-type var = lb
29145 */
29146 cp_decl_specifier_seq type_specifiers;
29148 /* First, try to parse as an initialized declaration. See
29149 cp_parser_condition, from whence the bulk of this is copied. */
29156 {
29157 /* If parsing a type specifier seq succeeded, then this
29158 MUST be a initialized declaration. */
29163 CP_PARSER_DECLARATOR_NAMED,
29173 else
29174 {
29184 {
29186 CPP_OPEN_PAREN))
29187 {
29191 else
29194 }
29195 else
29196 /* Trigger an error. */
29201 }
29205 {
29213 {
29216 auto_node);
29221 }
29224 asm_specification,
29225 LOOKUP_ONLYCONVERTING);
29227 {
29230 }
29231 else
29234 }
29235 else
29236 {
29237 /* Consume '='. */
29241 non_class:
29244 else
29247 asm_specification,
29248 LOOKUP_ONLYCONVERTING);
29249 }
29253 }
29254 }
29255 else
29256 {
29257 cp_id_kind idk;
29258 /* If parsing a type specifier sequence failed, then
29259 this MUST be a simple expression. */
29264 && decl
29267 {
29268 tree rhs;
29275 rhs,
29276 tf_warning_or_error));
29278 }
29279 else
29280 {
29285 {
29289 }
29290 }
29291 }
29293 }
29295 /* Parse the restricted form of the for statement allowed by OpenMP. */
29297 static tree
29300 {
29304 location_t loc_first;
29323 {
29326 location_t loc;
29329 {
29332 }
29341 add_private_clause
29349 {
29352 {
29358 }
29359 else
29361 }
29368 {
29373 {
29377 }
29380 {
29381 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
29382 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
29391 }
29392 else
29393 {
29398 }
29399 }
29402 {
29403 tree c;
29405 {
29414 decl);
29418 decl);
29419 }
29421 {
29426 {
29429 }
29430 }
29431 }
29440 {
29441 /* If decl is an iterator, preserve the operator on decl
29442 until finish_omp_for. */
29444 && ((processing_template_decl
29448 else
29452 }
29467 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
29468 in between the collapsed for loops to be still considered perfectly
29469 nested. Hopefully the final version clarifies this.
29470 For now handle (multiple) {'s and empty statements. */
29472 do
29473 {
29477 {
29479 bracecount++;
29480 }
29484 else
29485 {
29492 }
29493 }
29497 {
29500 }
29501 }
29503 /* Note that we saved the original contents of this flag when we entered
29504 the structured block, and so we don't need to re-save it here. */
29507 else
29510 /* Note that the grammar doesn't call for a structured block here,
29511 though the loop as a whole is a structured block. */
29518 else
29523 {
29525 {
29527 nbraces--;
29528 }
29531 else
29532 {
29534 {
29537 }
29542 }
29543 }
29550 }
29552 /* Helper function for OpenMP parsing, split clauses and call
29553 finish_omp_clauses on each of the set of clauses afterwards. */
29555 static void
29558 {
29564 }
29566 /* OpenMP 4.0:
29567 #pragma omp simd simd-clause[optseq] new-line
29568 for-loop */
29570 #define OMP_SIMD_CLAUSE_MASK \
29571 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
29572 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
29573 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
29574 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29575 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
29576 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
29577 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
29579 static tree
29582 {
29594 {
29597 }
29608 }
29610 /* OpenMP 2.5:
29611 #pragma omp for for-clause[optseq] new-line
29612 for-loop
29614 OpenMP 4.0:
29615 #pragma omp for simd for-simd-clause[optseq] new-line
29616 for-loop */
29618 #define OMP_FOR_CLAUSE_MASK \
29619 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29620 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
29621 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
29622 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
29623 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
29624 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
29625 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
29626 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
29628 static tree
29631 {
29642 {
29647 {
29655 cclauses);
29659 cclauses);
29671 }
29672 }
29674 {
29677 }
29682 {
29685 }
29696 }
29698 /* OpenMP 2.5:
29699 # pragma omp master new-line
29700 structured-block */
29702 static tree
29704 {
29708 }
29710 /* OpenMP 2.5:
29711 # pragma omp ordered new-line
29712 structured-block */
29714 static tree
29716 {
29720 }
29722 /* OpenMP 2.5:
29724 section-scope:
29725 { section-sequence }
29727 section-sequence:
29728 section-directive[opt] structured-block
29729 section-sequence section-directive structured-block */
29731 static tree
29733 {
29744 {
29748 }
29751 {
29759 {
29763 }
29765 {
29768 }
29773 }
29784 }
29786 /* OpenMP 2.5:
29787 # pragma omp sections sections-clause[optseq] newline
29788 sections-scope */
29790 #define OMP_SECTIONS_CLAUSE_MASK \
29791 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29792 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
29793 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
29794 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
29795 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
29797 static tree
29800 {
29812 {
29815 }
29822 }
29824 /* OpenMP 2.5:
29825 # pragma omp parallel parallel-clause[optseq] new-line
29826 structured-block
29827 # pragma omp parallel for parallel-for-clause[optseq] new-line
29828 structured-block
29829 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
29830 structured-block
29832 OpenMP 4.0:
29833 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
29834 structured-block */
29836 #define OMP_PARALLEL_CLAUSE_MASK \
29837 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
29838 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29839 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
29840 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
29841 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
29842 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
29843 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
29844 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
29845 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
29847 static tree
29850 {
29859 {
29872 block);
29877 }
29879 {
29883 }
29885 {
29888 }
29890 {
29894 {
29904 block);
29907 }
29908 }
29918 }
29920 /* OpenMP 2.5:
29921 # pragma omp single single-clause[optseq] new-line
29922 structured-block */
29924 #define OMP_SINGLE_CLAUSE_MASK \
29925 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29926 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
29927 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
29928 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
29930 static tree
29932 {
29942 }
29944 /* OpenMP 3.0:
29945 # pragma omp task task-clause[optseq] new-line
29946 structured-block */
29948 #define OMP_TASK_CLAUSE_MASK \
29949 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
29950 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
29951 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
29952 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
29953 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
29954 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
29955 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
29956 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
29957 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND))
29959 static tree
29961 {
29972 }
29974 /* OpenMP 3.0:
29975 # pragma omp taskwait new-line */
29977 static void
29979 {
29982 }
29984 /* OpenMP 3.1:
29985 # pragma omp taskyield new-line */
29987 static void
29989 {
29992 }
29994 /* OpenMP 4.0:
29995 # pragma omp taskgroup new-line
29996 structured-block */
29998 static tree
30000 {
30004 }
30007 /* OpenMP 2.5:
30008 # pragma omp threadprivate (variable-list) */
30010 static void
30012 {
30013 tree vars;
30019 }
30021 /* OpenMP 4.0:
30022 # pragma omp cancel cancel-clause[optseq] new-line */
30024 #define OMP_CANCEL_CLAUSE_MASK \
30025 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
30026 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
30027 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
30028 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
30029 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30031 static void
30033 {
30037 }
30039 /* OpenMP 4.0:
30040 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
30042 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
30043 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
30044 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
30045 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
30046 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
30048 static void
30050 {
30051 tree clauses;
30055 {
30060 {
30063 }
30064 }
30066 {
30070 }
30073 OMP_CANCELLATION_POINT_CLAUSE_MASK,
30075 pragma_tok);
30077 }
30079 /* OpenMP 4.0:
30080 #pragma omp distribute distribute-clause[optseq] new-line
30081 for-loop */
30083 #define OMP_DISTRIBUTE_CLAUSE_MASK \
30084 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30085 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30086 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
30087 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30089 static tree
30092 {
30101 {
30109 else
30112 {
30118 {
30121 cclauses);
30122 else
30124 cclauses);
30125 }
30130 cclauses);
30131 else
30133 cclauses);
30145 }
30146 }
30148 {
30151 }
30156 {
30159 }
30170 }
30172 /* OpenMP 4.0:
30173 # pragma omp teams teams-clause[optseq] new-line
30174 structured-block */
30176 #define OMP_TEAMS_CLAUSE_MASK \
30177 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30178 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30179 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
30180 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30181 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
30182 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
30183 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
30185 static tree
30188 {
30197 {
30201 {
30209 cclauses);
30213 cclauses);
30224 }
30225 }
30227 {
30230 }
30235 {
30238 }
30246 }
30248 /* OpenMP 4.0:
30249 # pragma omp target data target-data-clause[optseq] new-line
30250 structured-block */
30252 #define OMP_TARGET_DATA_CLAUSE_MASK \
30253 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
30254 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
30255 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30257 static tree
30259 {
30271 }
30273 /* OpenMP 4.0:
30274 # pragma omp target update target-update-clause[optseq] new-line */
30276 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
30277 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
30278 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
30279 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
30280 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30282 static bool
30285 {
30287 {
30289 "%<#pragma omp target update%> may only be "
30293 }
30295 tree clauses
30300 {
30302 "%<#pragma omp target update must contain at least one "
30305 }
30313 }
30315 /* OpenMP 4.0:
30316 # pragma omp target target-clause[optseq] new-line
30317 structured-block */
30319 #define OMP_TARGET_CLAUSE_MASK \
30320 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
30321 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
30322 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
30324 static bool
30327 {
30329 {
30333 }
30336 {
30341 {
30349 {
30351 OMP_TARGET_CLAUSE_MASK,
30352 cclauses);
30354 }
30370 }
30372 {
30375 }
30377 {
30381 }
30383 {
30386 }
30387 }
30401 }
30403 /* OpenMP 4.0:
30404 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
30406 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
30407 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
30408 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
30409 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
30410 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
30411 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
30412 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
30414 static void
30417 {
30419 cp_omp_declare_simd_data data;
30421 {
30426 }
30437 {
30441 {
30454 }
30459 "%<#pragma omp declare simd%> not immediately followed by "
30463 }
30464 }
30466 /* Handles the delayed parsing of the Cilk Plus SIMD-enabled function.
30467 This function is modelled similar to the late parsing of omp declare
30468 simd. */
30470 static tree
30472 {
30478 {
30484 }
30486 {
30490 }
30495 {
30502 NULL);
30516 }
30521 }
30523 /* Finalize #pragma omp declare simd clauses after direct declarator has
30524 been parsed, and put that into "omp declare simd" attribute. */
30526 static tree
30528 {
30534 {
30539 }
30544 {
30562 }
30566 }
30569 /* OpenMP 4.0:
30570 # pragma omp declare target new-line
30571 declarations and definitions
30572 # pragma omp end declare target new-line */
30574 static void
30576 {
30579 }
30581 static void
30583 {
30586 {
30589 }
30591 {
30595 {
30598 }
30601 else
30602 {
30606 }
30607 }
30608 else
30609 {
30613 }
30617 "%<#pragma omp end declare target%> without corresponding "
30619 else
30621 }
30623 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
30624 expression and optional initializer clause of
30625 #pragma omp declare reduction. We store the expression(s) as
30626 either 3, 6 or 7 special statements inside of the artificial function's
30627 body. The first two statements are DECL_EXPRs for the artificial
30628 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
30629 expression that uses those variables.
30630 If there was any INITIALIZER clause, this is followed by further statements,
30631 the fourth and fifth statements are DECL_EXPRs for the artificial
30632 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
30633 constructor variant (first token after open paren is not omp_priv),
30634 then the sixth statement is a statement with the function call expression
30635 that uses the OMP_PRIV and optionally OMP_ORIG variable.
30636 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
30637 to initialize the OMP_PRIV artificial variable and there is seventh
30638 statement, a DECL_EXPR of the OMP_PRIV statement again. */
30640 static bool
30642 {
30654 tree combiner;
30669 {
30672 }
30675 {
30682 {
30685 }
30701 {
30705 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
30709 == CPP_CLOSE_PAREN
30712 {
30716 }
30721 }
30722 else
30723 {
30739 {
30744 }
30746 tree arg;
30759 }
30770 }
30776 }
30778 /* OpenMP 4.0
30779 #pragma omp declare reduction (reduction-id : typename-list : expression) \
30780 initializer-clause[opt] new-line
30782 initializer-clause:
30783 initializer (omp_priv initializer)
30784 initializer (function-name (argument-list)) */
30786 static void
30789 {
30799 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
30806 {
30838 }
30850 /* Types may not be defined in declare reduction type list. */
30853 parser->type_definition_forbidden_message
30859 saved_colon_doesnt_start_class_def_p
30864 {
30868 ;
30889 else
30894 else
30896 }
30898 /* Restore the saved message. */
30901 parser->colon_doesnt_start_class_def_p
30906 {
30907 fail:
30910 }
30916 {
30917 tree fntype
30920 NULL_TREE);
30939 {
30944 }
30946 {
30948 {
30957 }
30964 }
30965 else
30966 {
30969 }
30972 else
30975 {
30978 }
30980 {
30983 else
30988 }
30993 else
30994 {
31003 }
31010 }
31014 done:
31015 /* Free any declarators allocated. */
31017 }
31019 /* OpenMP 4.0
31020 #pragma omp declare simd declare-simd-clauses[optseq] new-line
31021 #pragma omp declare reduction (reduction-id : typename-list : expression) \
31022 initializer-clause[opt] new-line
31023 #pragma omp declare target new-line */
31025 static void
31028 {
31030 {
31035 {
31038 context);
31040 }
31043 {
31046 context);
31048 }
31050 {
31053 }
31055 {
31059 }
31060 }
31064 }
31066 /* Main entry point to OpenMP statement pragmas. */
31068 static void
31070 {
31071 tree stmt;
31076 {
31124 }
31128 }
31129 \f
31130 /* Transactional Memory parsing routines. */
31132 /* Parse a transaction attribute.
31134 txn-attribute:
31135 attribute
31136 [ [ identifier ] ]
31138 ??? Simplify this when C++0x bracket attributes are
31139 implemented properly. */
31141 static tree
31143 {
31158 {
31162 /* For keywords, use the canonical spelling,
31163 not the parsed identifier. */
31167 }
31168 else
31172 error1:
31175 }
31177 /* Parse a __transaction_atomic or __transaction_relaxed statement.
31179 transaction-statement:
31180 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
31181 compound-statement
31182 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
31183 */
31185 static tree
31187 {
31202 else
31203 {
31207 }
31209 /* Parse a noexcept specification. */
31212 /* Keep track if we're in the lexical scope of an outer transaction. */
31224 }
31226 /* Parse a __transaction_atomic or __transaction_relaxed expression.
31228 transaction-expression:
31229 __transaction_atomic txn-noexcept-spec[opt] ( expression )
31230 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
31231 */
31233 static tree
31235 {
31260 /* Set this early. This might mean that we allow transaction_cancel in
31261 an expression that we find out later actually has to be a constexpr.
31262 However, we expect that cxx_constant_value will be able to deal with
31263 this; also, if the noexcept has no constexpr, then what we parse next
31264 really is a transaction's body. */
31267 /* Parse a noexcept specification. */
31273 {
31280 }
31281 else
31282 {
31283 /* The only expression that is available got parsed for the noexcept
31284 already. noexcept is true then. */
31287 }
31296 }
31298 /* Parse a function-transaction-block.
31300 function-transaction-block:
31301 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
31302 function-body
31303 __transaction_atomic txn-attribute[opt] function-try-block
31304 __transaction_relaxed ctor-initializer[opt] function-body
31305 __transaction_relaxed function-try-block
31306 */
31308 static bool
31310 {
31326 else
31327 {
31331 }
31339 else
31340 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
31348 }
31350 /* Parse a __transaction_cancel statement.
31352 cancel-statement:
31353 __transaction_cancel txn-attribute[opt] ;
31354 __transaction_cancel txn-attribute[opt] throw-expression ;
31356 ??? Cancel and throw is not yet implemented. */
31358 static tree
31360 {
31366 RT_TRANSACTION_CANCEL);
31373 /* ??? Parse cancel-and-throw here. */
31378 {
31382 }
31384 {
31388 }
31390 {
31393 {
31399 }
31400 }
31402 {
31406 }
31412 }
31413 \f
31414 /* The parser. */
31418 \f
31419 /* Special handling for the first token or line in the file. The first
31420 thing in the file might be #pragma GCC pch_preprocess, which loads a
31421 PCH file, which is a GC collection point. So we need to handle this
31422 first pragma without benefit of an existing lexer structure.
31424 Always returns one token to the caller in *FIRST_TOKEN. This is
31425 either the true first token of the file, or the first token after
31426 the initial pragma. */
31428 static void
31430 {
31439 {
31446 }
31447 else
31450 /* Skip to the end of the pragma. */
31454 /* Now actually load the PCH file. */
31458 /* Read one more token to return to our caller. We have to do this
31459 after reading the PCH file in, since its pointers have to be
31460 live. */
31462 }
31464 /* Normal parsing of a pragma token. Here we can (and must) use the
31465 regular lexer. */
31467 static bool
31469 {
31481 {
31489 {
31499 }
31504 {
31514 }
31519 {
31525 "%<#pragma omp taskwait%> may only be "
31530 }
31535 {
31541 "%<#pragma omp taskyield%> may only be "
31546 }
31551 {
31557 "%<#pragma omp cancel%> may only be "
31562 }
31567 {
31573 "%<#pragma omp cancellation point%> may only be "
31578 }
31616 "%<#pragma omp section%> may only be used in "
31621 {
31628 {
31631 }
31634 }
31638 {
31642 }
31651 bad_stmt:
31654 }
31658 }
31660 /* The interface the pragma parsers have to the lexer. */
31662 enum cpp_ttype
31664 {
31677 else
31678 {
31682 }
31685 }
31687 \f
31688 /* External interface. */
31690 /* Parse one entire translation unit. */
31692 void
31694 {
31698 {
31701 }
31709 }
31711 /* Parses the Cilk Plus #pragma simd and SIMD-enabled function attribute's
31712 vectorlength clause:
31713 Syntax:
31714 vectorlength ( constant-expression ) */
31716 static tree
31719 {
31721 tree expr;
31722 /* The vectorlength clause in #pragma simd behaves exactly like OpenMP's
31723 safelen clause. Thus, vectorlength is represented as OMP 4.0
31724 safelen. For SIMD-enabled function it is represented by OMP 4.0
31725 simdlen. */
31728 loc);
31729 else
31731 loc);
31739 /* If expr == error_mark_node, then don't emit any errors nor
31740 create a clause. if any of the above functions returns
31741 error mark node then they would have emitted an error message. */
31743 ;
31751 else
31752 {
31753 tree c;
31755 {
31760 }
31761 else
31762 {
31767 }
31768 }
31773 }
31775 /* Handles the Cilk Plus #pragma simd linear clause.
31776 Syntax:
31777 linear ( simd-linear-variable-list )
31779 simd-linear-variable-list:
31780 simd-linear-variable
31781 simd-linear-variable-list , simd-linear-variable
31783 simd-linear-variable:
31784 id-expression
31785 id-expression : simd-linear-step
31787 simd-linear-step:
31788 conditional-expression */
31790 static tree
31792 {
31798 {
31802 }
31807 {
31810 {
31814 }
31821 {
31825 }
31826 else
31827 {
31831 /* If present, parse the linear step. Otherwise, assume the default
31832 value of 1. */
31834 {
31841 {
31842 /* If an error has occurred, then the whole pragma is
31843 considered ill-formed. Thus, no reason to keep
31844 parsing. */
31847 }
31855 else
31857 "step size must be an integer constant "
31859 }
31861 /* Use the OMP_CLAUSE_LINEAR, which has the same semantics. */
31867 }
31872 else
31873 {
31878 }
31879 }
31883 }
31885 /* Returns the name of the next clause. If the clause is not
31886 recognized, then PRAGMA_CILK_CLAUSE_NONE is returned and the next
31887 token is not consumed. Otherwise, the appropriate enum from the
31888 pragma_simd_clause is returned and the token is consumed. */
31890 static pragma_omp_clause
31892 {
31893 pragma_omp_clause clause_type;
31910 else
31915 }
31917 /* Parses all the #pragma simd clauses. Returns a list of clauses found. */
31919 static tree
31921 {
31926 {
31927 pragma_omp_clause c_kind;
31934 /* Use the OpenMP 4.0 equivalent function. */
31937 /* Use the OpenMP 4.0 equivalent function. */
31939 clauses);
31941 /* Use the OMP 4.0 equivalent function. */
31943 clauses);
31945 /* Use the OMP 4.0 equivalent function. */
31947 else
31948 {
31952 }
31953 }
31959 else
31961 }
31963 /* Main entry-point for parsing Cilk Plus <#pragma simd> for loops. */
31965 static void
31967 {
31974 {
31978 }
31988 }
31990 /* Create an identifier for a generic parameter type (a synthesized
31991 template parameter implied by `auto' or a concept identifier). */
31994 static tree
31996 {
32000 }
32002 /* Predicate that behaves as is_auto_or_concept but matches the parent
32003 node of the generic type rather than the generic type itself. This
32004 allows for type transformation in add_implicit_template_parms. */
32008 {
32010 }
32012 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
32013 (creating a new template parameter list if necessary). Returns the newly
32014 created template type parm. */
32016 tree
32018 {
32021 /* We are either continuing a function template that already contains implicit
32022 template parameters, creating a new fully-implicit function template, or
32023 extending an existing explicit function template with implicit template
32024 parameters. */
32032 {
32036 }
32037 else
32038 {
32039 /* Roll back to the existing template parameter scope (in the case of
32040 extending an explicit function template) or introduce a new template
32041 parameter scope ahead of the function parameter scope (or class scope
32042 in the case of out-of-line member definitions). The function scope is
32043 added back after template parameter synthesis below. */
32048 {
32051 }
32053 {
32054 /* If not defining a class, then any class scope is a scope level in
32055 an out-of-line member definition. In this case simply wind back
32056 beyond the first such scope to inject the template parameter list.
32057 Otherwise wind back to the class being defined. The latter can
32058 occur in class member friend declarations such as:
32060 class A {
32061 void foo (auto);
32062 };
32063 class B {
32064 friend void A::foo (auto);
32065 };
32067 The template parameter list synthesized for the friend declaration
32068 must be injected in the scope of 'B'. This can also occur in
32069 erroneous cases such as:
32071 struct A {
32072 struct B {
32073 void foo (auto);
32074 };
32075 void B::foo (auto) {}
32076 };
32078 Here the attempted definition of 'B::foo' within 'A' is ill-formed
32079 but, nevertheless, the template parameter list synthesized for the
32080 declarator should be injected into the scope of 'A' as if the
32081 ill-formed template was specified explicitly. */
32084 {
32087 }
32088 }
32094 {
32095 /* Introduce a new template parameter list for implicit template
32096 parameters. */
32100 parser->implicit_template_scope
32107 }
32108 else
32109 {
32110 /* Synthesize implicit template parameters at the end of the explicit
32111 template parameter list. */
32118 parser->implicit_template_parms
32120 }
32121 }
32123 /* Synthesize a new template parameter and track the current template
32124 parameter chain with implicit_template_parms. */
32128 synth_id);
32129 tree new_parm
32131 input_location,
32138 parser->implicit_template_parms
32140 else
32145 /* If creating a fully implicit function template, start the new implicit
32146 template parameter list with this synthesized type, otherwise grow the
32147 current template parameter list. */
32150 {
32157 }
32158 else
32159 {
32164 }
32169 }
32171 /* Finish the declaration of a fully implicit function template. Such a
32172 template has no explicit template parameter list so has not been through the
32173 normal template head and tail processing. synthesize_implicit_template_parm
32174 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
32175 provided if the declaration is a class member such that its template
32176 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
32177 form is returned. Otherwise NULL_TREE is returned. */
32179 tree
32181 {
32186 {
32190 }
32200 }