2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Written by Mark Mitchell <mark@codesourcery.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
26 #include "dyn-string.h"
34 #include "diagnostic.h"
44 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
45 and c-lex.c) and the C++ parser. */
47 /* A token's value and its associated deferred access checks and
50 struct tree_check
GTY(())
52 /* The value associated with the token. */
54 /* The checks that have been associated with value. */
55 VEC (deferred_access_check
, gc
)* checks
;
56 /* The token's qualifying scope (used when it is a
57 CPP_NESTED_NAME_SPECIFIER). */
58 tree qualifying_scope
;
63 typedef struct cp_token
GTY (())
65 /* The kind of token. */
66 ENUM_BITFIELD (cpp_ttype
) type
: 8;
67 /* If this token is a keyword, this value indicates which keyword.
68 Otherwise, this value is RID_MAX. */
69 ENUM_BITFIELD (rid
) keyword
: 8;
72 /* Identifier for the pragma. */
73 ENUM_BITFIELD (pragma_kind
) pragma_kind
: 6;
74 /* True if this token is from a context where it is implicitly extern "C" */
75 BOOL_BITFIELD implicit_extern_c
: 1;
76 /* True for a CPP_NAME token that is not a keyword (i.e., for which
77 KEYWORD is RID_MAX) iff this name was looked up and found to be
78 ambiguous. An error has already been reported. */
79 BOOL_BITFIELD ambiguous_p
: 1;
80 /* The value associated with this token, if any. */
81 union cp_token_value
{
82 /* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID. */
83 struct tree_check
* GTY((tag ("1"))) tree_check_value
;
84 /* Use for all other tokens. */
85 tree
GTY((tag ("0"))) value
;
86 } GTY((desc ("(%1.type == CPP_TEMPLATE_ID) || (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u
;
87 /* The location at which this token was found. */
91 /* We use a stack of token pointer for saving token sets. */
92 typedef struct cp_token
*cp_token_position
;
93 DEF_VEC_P (cp_token_position
);
94 DEF_VEC_ALLOC_P (cp_token_position
,heap
);
96 static cp_token eof_token
=
98 CPP_EOF
, RID_MAX
, 0, PRAGMA_NONE
, false, 0, { NULL
},
102 /* The cp_lexer structure represents the C++ lexer. It is responsible
103 for managing the token stream from the preprocessor and supplying
104 it to the parser. Tokens are never added to the cp_lexer after
107 typedef struct cp_lexer
GTY (())
109 /* The memory allocated for the buffer. NULL if this lexer does not
110 own the token buffer. */
111 cp_token
* GTY ((length ("%h.buffer_length"))) buffer
;
112 /* If the lexer owns the buffer, this is the number of tokens in the
114 size_t buffer_length
;
116 /* A pointer just past the last available token. The tokens
117 in this lexer are [buffer, last_token). */
118 cp_token_position
GTY ((skip
)) last_token
;
120 /* The next available token. If NEXT_TOKEN is &eof_token, then there are
121 no more available tokens. */
122 cp_token_position
GTY ((skip
)) next_token
;
124 /* A stack indicating positions at which cp_lexer_save_tokens was
125 called. The top entry is the most recent position at which we
126 began saving tokens. If the stack is non-empty, we are saving
128 VEC(cp_token_position
,heap
) *GTY ((skip
)) saved_tokens
;
130 /* The next lexer in a linked list of lexers. */
131 struct cp_lexer
*next
;
133 /* True if we should output debugging information. */
136 /* True if we're in the context of parsing a pragma, and should not
137 increment past the end-of-line marker. */
141 /* cp_token_cache is a range of tokens. There is no need to represent
142 allocate heap memory for it, since tokens are never removed from the
143 lexer's array. There is also no need for the GC to walk through
144 a cp_token_cache, since everything in here is referenced through
147 typedef struct cp_token_cache
GTY(())
149 /* The beginning of the token range. */
150 cp_token
* GTY((skip
)) first
;
152 /* Points immediately after the last token in the range. */
153 cp_token
* GTY ((skip
)) last
;
158 static cp_lexer
*cp_lexer_new_main
160 static cp_lexer
*cp_lexer_new_from_tokens
161 (cp_token_cache
*tokens
);
162 static void cp_lexer_destroy
164 static int cp_lexer_saving_tokens
166 static cp_token_position cp_lexer_token_position
168 static cp_token
*cp_lexer_token_at
169 (cp_lexer
*, cp_token_position
);
170 static void cp_lexer_get_preprocessor_token
171 (cp_lexer
*, cp_token
*);
172 static inline cp_token
*cp_lexer_peek_token
174 static cp_token
*cp_lexer_peek_nth_token
175 (cp_lexer
*, size_t);
176 static inline bool cp_lexer_next_token_is
177 (cp_lexer
*, enum cpp_ttype
);
178 static bool cp_lexer_next_token_is_not
179 (cp_lexer
*, enum cpp_ttype
);
180 static bool cp_lexer_next_token_is_keyword
181 (cp_lexer
*, enum rid
);
182 static cp_token
*cp_lexer_consume_token
184 static void cp_lexer_purge_token
186 static void cp_lexer_purge_tokens_after
187 (cp_lexer
*, cp_token_position
);
188 static void cp_lexer_save_tokens
190 static void cp_lexer_commit_tokens
192 static void cp_lexer_rollback_tokens
194 #ifdef ENABLE_CHECKING
195 static void cp_lexer_print_token
196 (FILE *, cp_token
*);
197 static inline bool cp_lexer_debugging_p
199 static void cp_lexer_start_debugging
200 (cp_lexer
*) ATTRIBUTE_UNUSED
;
201 static void cp_lexer_stop_debugging
202 (cp_lexer
*) ATTRIBUTE_UNUSED
;
204 /* If we define cp_lexer_debug_stream to NULL it will provoke warnings
205 about passing NULL to functions that require non-NULL arguments
206 (fputs, fprintf). It will never be used, so all we need is a value
207 of the right type that's guaranteed not to be NULL. */
208 #define cp_lexer_debug_stream stdout
209 #define cp_lexer_print_token(str, tok) (void) 0
210 #define cp_lexer_debugging_p(lexer) 0
211 #endif /* ENABLE_CHECKING */
213 static cp_token_cache
*cp_token_cache_new
214 (cp_token
*, cp_token
*);
216 static void cp_parser_initial_pragma
219 /* Manifest constants. */
220 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
221 #define CP_SAVED_TOKEN_STACK 5
223 /* A token type for keywords, as opposed to ordinary identifiers. */
224 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
226 /* A token type for template-ids. If a template-id is processed while
227 parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
228 the value of the CPP_TEMPLATE_ID is whatever was returned by
229 cp_parser_template_id. */
230 #define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
232 /* A token type for nested-name-specifiers. If a
233 nested-name-specifier is processed while parsing tentatively, it is
234 replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
235 CPP_NESTED_NAME_SPECIFIER is whatever was returned by
236 cp_parser_nested_name_specifier_opt. */
237 #define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
239 /* A token type for tokens that are not tokens at all; these are used
240 to represent slots in the array where there used to be a token
241 that has now been deleted. */
242 #define CPP_PURGED ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
244 /* The number of token types, including C++-specific ones. */
245 #define N_CP_TTYPES ((int) (CPP_PURGED + 1))
249 #ifdef ENABLE_CHECKING
250 /* The stream to which debugging output should be written. */
251 static FILE *cp_lexer_debug_stream
;
252 #endif /* ENABLE_CHECKING */
254 /* Create a new main C++ lexer, the lexer that gets tokens from the
258 cp_lexer_new_main (void)
260 cp_token first_token
;
267 /* It's possible that parsing the first pragma will load a PCH file,
268 which is a GC collection point. So we have to do that before
269 allocating any memory. */
270 cp_parser_initial_pragma (&first_token
);
272 c_common_no_more_pch ();
274 /* Allocate the memory. */
275 lexer
= GGC_CNEW (cp_lexer
);
277 #ifdef ENABLE_CHECKING
278 /* Initially we are not debugging. */
279 lexer
->debugging_p
= false;
280 #endif /* ENABLE_CHECKING */
281 lexer
->saved_tokens
= VEC_alloc (cp_token_position
, heap
,
282 CP_SAVED_TOKEN_STACK
);
284 /* Create the buffer. */
285 alloc
= CP_LEXER_BUFFER_SIZE
;
286 buffer
= GGC_NEWVEC (cp_token
, alloc
);
288 /* Put the first token in the buffer. */
293 /* Get the remaining tokens from the preprocessor. */
294 while (pos
->type
!= CPP_EOF
)
301 buffer
= GGC_RESIZEVEC (cp_token
, buffer
, alloc
);
302 pos
= buffer
+ space
;
304 cp_lexer_get_preprocessor_token (lexer
, pos
);
306 lexer
->buffer
= buffer
;
307 lexer
->buffer_length
= alloc
- space
;
308 lexer
->last_token
= pos
;
309 lexer
->next_token
= lexer
->buffer_length
? buffer
: &eof_token
;
311 /* Subsequent preprocessor diagnostics should use compiler
312 diagnostic functions to get the compiler source location. */
313 cpp_get_options (parse_in
)->client_diagnostic
= true;
314 cpp_get_callbacks (parse_in
)->error
= cp_cpp_error
;
316 gcc_assert (lexer
->next_token
->type
!= CPP_PURGED
);
320 /* Create a new lexer whose token stream is primed with the tokens in
321 CACHE. When these tokens are exhausted, no new tokens will be read. */
324 cp_lexer_new_from_tokens (cp_token_cache
*cache
)
326 cp_token
*first
= cache
->first
;
327 cp_token
*last
= cache
->last
;
328 cp_lexer
*lexer
= GGC_CNEW (cp_lexer
);
330 /* We do not own the buffer. */
331 lexer
->buffer
= NULL
;
332 lexer
->buffer_length
= 0;
333 lexer
->next_token
= first
== last
? &eof_token
: first
;
334 lexer
->last_token
= last
;
336 lexer
->saved_tokens
= VEC_alloc (cp_token_position
, heap
,
337 CP_SAVED_TOKEN_STACK
);
339 #ifdef ENABLE_CHECKING
340 /* Initially we are not debugging. */
341 lexer
->debugging_p
= false;
344 gcc_assert (lexer
->next_token
->type
!= CPP_PURGED
);
348 /* Frees all resources associated with LEXER. */
351 cp_lexer_destroy (cp_lexer
*lexer
)
354 ggc_free (lexer
->buffer
);
355 VEC_free (cp_token_position
, heap
, lexer
->saved_tokens
);
359 /* Returns nonzero if debugging information should be output. */
361 #ifdef ENABLE_CHECKING
364 cp_lexer_debugging_p (cp_lexer
*lexer
)
366 return lexer
->debugging_p
;
369 #endif /* ENABLE_CHECKING */
371 static inline cp_token_position
372 cp_lexer_token_position (cp_lexer
*lexer
, bool previous_p
)
374 gcc_assert (!previous_p
|| lexer
->next_token
!= &eof_token
);
376 return lexer
->next_token
- previous_p
;
379 static inline cp_token
*
380 cp_lexer_token_at (cp_lexer
*lexer ATTRIBUTE_UNUSED
, cp_token_position pos
)
385 /* nonzero if we are presently saving tokens. */
388 cp_lexer_saving_tokens (const cp_lexer
* lexer
)
390 return VEC_length (cp_token_position
, lexer
->saved_tokens
) != 0;
393 /* Store the next token from the preprocessor in *TOKEN. Return true
394 if we reach EOF. If LEXER is NULL, assume we are handling an
395 initial #pragma pch_preprocess, and thus want the lexer to return
396 processed strings. */
399 cp_lexer_get_preprocessor_token (cp_lexer
*lexer
, cp_token
*token
)
401 static int is_extern_c
= 0;
403 /* Get a new token from the preprocessor. */
405 = c_lex_with_flags (&token
->u
.value
, &token
->location
, &token
->flags
,
406 lexer
== NULL
? 0 : C_LEX_RAW_STRINGS
);
407 token
->keyword
= RID_MAX
;
408 token
->pragma_kind
= PRAGMA_NONE
;
410 /* On some systems, some header files are surrounded by an
411 implicit extern "C" block. Set a flag in the token if it
412 comes from such a header. */
413 is_extern_c
+= pending_lang_change
;
414 pending_lang_change
= 0;
415 token
->implicit_extern_c
= is_extern_c
> 0;
417 /* Check to see if this token is a keyword. */
418 if (token
->type
== CPP_NAME
)
420 if (C_IS_RESERVED_WORD (token
->u
.value
))
422 /* Mark this token as a keyword. */
423 token
->type
= CPP_KEYWORD
;
424 /* Record which keyword. */
425 token
->keyword
= C_RID_CODE (token
->u
.value
);
426 /* Update the value. Some keywords are mapped to particular
427 entities, rather than simply having the value of the
428 corresponding IDENTIFIER_NODE. For example, `__const' is
429 mapped to `const'. */
430 token
->u
.value
= ridpointers
[token
->keyword
];
434 if (warn_cxx0x_compat
435 && C_RID_CODE (token
->u
.value
) >= RID_FIRST_CXX0X
436 && C_RID_CODE (token
->u
.value
) <= RID_LAST_CXX0X
)
438 /* Warn about the C++0x keyword (but still treat it as
440 warning (OPT_Wc__0x_compat
,
441 "identifier %<%s%> will become a keyword in C++0x",
442 IDENTIFIER_POINTER (token
->u
.value
));
444 /* Clear out the C_RID_CODE so we don't warn about this
445 particular identifier-turned-keyword again. */
446 C_SET_RID_CODE (token
->u
.value
, RID_MAX
);
449 token
->ambiguous_p
= false;
450 token
->keyword
= RID_MAX
;
453 /* Handle Objective-C++ keywords. */
454 else if (token
->type
== CPP_AT_NAME
)
456 token
->type
= CPP_KEYWORD
;
457 switch (C_RID_CODE (token
->u
.value
))
459 /* Map 'class' to '@class', 'private' to '@private', etc. */
460 case RID_CLASS
: token
->keyword
= RID_AT_CLASS
; break;
461 case RID_PRIVATE
: token
->keyword
= RID_AT_PRIVATE
; break;
462 case RID_PROTECTED
: token
->keyword
= RID_AT_PROTECTED
; break;
463 case RID_PUBLIC
: token
->keyword
= RID_AT_PUBLIC
; break;
464 case RID_THROW
: token
->keyword
= RID_AT_THROW
; break;
465 case RID_TRY
: token
->keyword
= RID_AT_TRY
; break;
466 case RID_CATCH
: token
->keyword
= RID_AT_CATCH
; break;
467 default: token
->keyword
= C_RID_CODE (token
->u
.value
);
470 else if (token
->type
== CPP_PRAGMA
)
472 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
473 token
->pragma_kind
= TREE_INT_CST_LOW (token
->u
.value
);
474 token
->u
.value
= NULL_TREE
;
478 /* Update the globals input_location and the input file stack from TOKEN. */
480 cp_lexer_set_source_position_from_token (cp_token
*token
)
482 if (token
->type
!= CPP_EOF
)
484 input_location
= token
->location
;
488 /* Return a pointer to the next token in the token stream, but do not
491 static inline cp_token
*
492 cp_lexer_peek_token (cp_lexer
*lexer
)
494 if (cp_lexer_debugging_p (lexer
))
496 fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream
);
497 cp_lexer_print_token (cp_lexer_debug_stream
, lexer
->next_token
);
498 putc ('\n', cp_lexer_debug_stream
);
500 return lexer
->next_token
;
503 /* Return true if the next token has the indicated TYPE. */
506 cp_lexer_next_token_is (cp_lexer
* lexer
, enum cpp_ttype type
)
508 return cp_lexer_peek_token (lexer
)->type
== type
;
511 /* Return true if the next token does not have the indicated TYPE. */
514 cp_lexer_next_token_is_not (cp_lexer
* lexer
, enum cpp_ttype type
)
516 return !cp_lexer_next_token_is (lexer
, type
);
519 /* Return true if the next token is the indicated KEYWORD. */
522 cp_lexer_next_token_is_keyword (cp_lexer
* lexer
, enum rid keyword
)
524 return cp_lexer_peek_token (lexer
)->keyword
== keyword
;
527 /* Return true if the next token is not the indicated KEYWORD. */
530 cp_lexer_next_token_is_not_keyword (cp_lexer
* lexer
, enum rid keyword
)
532 return cp_lexer_peek_token (lexer
)->keyword
!= keyword
;
535 /* Return true if the next token is a keyword for a decl-specifier. */
538 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer
*lexer
)
542 token
= cp_lexer_peek_token (lexer
);
543 switch (token
->keyword
)
545 /* auto specifier: storage-class-specifier in C++,
546 simple-type-specifier in C++0x. */
548 /* Storage classes. */
554 /* Elaborated type specifiers. */
560 /* Simple type specifiers. */
574 /* GNU extensions. */
577 /* C++0x extensions. */
586 /* Return a pointer to the Nth token in the token stream. If N is 1,
587 then this is precisely equivalent to cp_lexer_peek_token (except
588 that it is not inline). One would like to disallow that case, but
589 there is one case (cp_parser_nth_token_starts_template_id) where
590 the caller passes a variable for N and it might be 1. */
593 cp_lexer_peek_nth_token (cp_lexer
* lexer
, size_t n
)
597 /* N is 1-based, not zero-based. */
600 if (cp_lexer_debugging_p (lexer
))
601 fprintf (cp_lexer_debug_stream
,
602 "cp_lexer: peeking ahead %ld at token: ", (long)n
);
605 token
= lexer
->next_token
;
606 gcc_assert (!n
|| token
!= &eof_token
);
610 if (token
== lexer
->last_token
)
616 if (token
->type
!= CPP_PURGED
)
620 if (cp_lexer_debugging_p (lexer
))
622 cp_lexer_print_token (cp_lexer_debug_stream
, token
);
623 putc ('\n', cp_lexer_debug_stream
);
629 /* Return the next token, and advance the lexer's next_token pointer
630 to point to the next non-purged token. */
633 cp_lexer_consume_token (cp_lexer
* lexer
)
635 cp_token
*token
= lexer
->next_token
;
637 gcc_assert (token
!= &eof_token
);
638 gcc_assert (!lexer
->in_pragma
|| token
->type
!= CPP_PRAGMA_EOL
);
643 if (lexer
->next_token
== lexer
->last_token
)
645 lexer
->next_token
= &eof_token
;
650 while (lexer
->next_token
->type
== CPP_PURGED
);
652 cp_lexer_set_source_position_from_token (token
);
654 /* Provide debugging output. */
655 if (cp_lexer_debugging_p (lexer
))
657 fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream
);
658 cp_lexer_print_token (cp_lexer_debug_stream
, token
);
659 putc ('\n', cp_lexer_debug_stream
);
665 /* Permanently remove the next token from the token stream, and
666 advance the next_token pointer to refer to the next non-purged
670 cp_lexer_purge_token (cp_lexer
*lexer
)
672 cp_token
*tok
= lexer
->next_token
;
674 gcc_assert (tok
!= &eof_token
);
675 tok
->type
= CPP_PURGED
;
676 tok
->location
= UNKNOWN_LOCATION
;
677 tok
->u
.value
= NULL_TREE
;
678 tok
->keyword
= RID_MAX
;
683 if (tok
== lexer
->last_token
)
689 while (tok
->type
== CPP_PURGED
);
690 lexer
->next_token
= tok
;
693 /* Permanently remove all tokens after TOK, up to, but not
694 including, the token that will be returned next by
695 cp_lexer_peek_token. */
698 cp_lexer_purge_tokens_after (cp_lexer
*lexer
, cp_token
*tok
)
700 cp_token
*peek
= lexer
->next_token
;
702 if (peek
== &eof_token
)
703 peek
= lexer
->last_token
;
705 gcc_assert (tok
< peek
);
707 for ( tok
+= 1; tok
!= peek
; tok
+= 1)
709 tok
->type
= CPP_PURGED
;
710 tok
->location
= UNKNOWN_LOCATION
;
711 tok
->u
.value
= NULL_TREE
;
712 tok
->keyword
= RID_MAX
;
716 /* Begin saving tokens. All tokens consumed after this point will be
720 cp_lexer_save_tokens (cp_lexer
* lexer
)
722 /* Provide debugging output. */
723 if (cp_lexer_debugging_p (lexer
))
724 fprintf (cp_lexer_debug_stream
, "cp_lexer: saving tokens\n");
726 VEC_safe_push (cp_token_position
, heap
,
727 lexer
->saved_tokens
, lexer
->next_token
);
730 /* Commit to the portion of the token stream most recently saved. */
733 cp_lexer_commit_tokens (cp_lexer
* lexer
)
735 /* Provide debugging output. */
736 if (cp_lexer_debugging_p (lexer
))
737 fprintf (cp_lexer_debug_stream
, "cp_lexer: committing tokens\n");
739 VEC_pop (cp_token_position
, lexer
->saved_tokens
);
742 /* Return all tokens saved since the last call to cp_lexer_save_tokens
743 to the token stream. Stop saving tokens. */
746 cp_lexer_rollback_tokens (cp_lexer
* lexer
)
748 /* Provide debugging output. */
749 if (cp_lexer_debugging_p (lexer
))
750 fprintf (cp_lexer_debug_stream
, "cp_lexer: restoring tokens\n");
752 lexer
->next_token
= VEC_pop (cp_token_position
, lexer
->saved_tokens
);
755 /* Print a representation of the TOKEN on the STREAM. */
757 #ifdef ENABLE_CHECKING
760 cp_lexer_print_token (FILE * stream
, cp_token
*token
)
762 /* We don't use cpp_type2name here because the parser defines
763 a few tokens of its own. */
764 static const char *const token_names
[] = {
765 /* cpplib-defined token types */
771 /* C++ parser token types - see "Manifest constants", above. */
774 "NESTED_NAME_SPECIFIER",
778 /* If we have a name for the token, print it out. Otherwise, we
779 simply give the numeric code. */
780 gcc_assert (token
->type
< ARRAY_SIZE(token_names
));
781 fputs (token_names
[token
->type
], stream
);
783 /* For some tokens, print the associated data. */
787 /* Some keywords have a value that is not an IDENTIFIER_NODE.
788 For example, `struct' is mapped to an INTEGER_CST. */
789 if (TREE_CODE (token
->u
.value
) != IDENTIFIER_NODE
)
791 /* else fall through */
793 fputs (IDENTIFIER_POINTER (token
->u
.value
), stream
);
800 fprintf (stream
, " \"%s\"", TREE_STRING_POINTER (token
->u
.value
));
808 /* Start emitting debugging information. */
811 cp_lexer_start_debugging (cp_lexer
* lexer
)
813 lexer
->debugging_p
= true;
816 /* Stop emitting debugging information. */
819 cp_lexer_stop_debugging (cp_lexer
* lexer
)
821 lexer
->debugging_p
= false;
824 #endif /* ENABLE_CHECKING */
826 /* Create a new cp_token_cache, representing a range of tokens. */
828 static cp_token_cache
*
829 cp_token_cache_new (cp_token
*first
, cp_token
*last
)
831 cp_token_cache
*cache
= GGC_NEW (cp_token_cache
);
832 cache
->first
= first
;
838 /* Decl-specifiers. */
840 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
843 clear_decl_specs (cp_decl_specifier_seq
*decl_specs
)
845 memset (decl_specs
, 0, sizeof (cp_decl_specifier_seq
));
850 /* Nothing other than the parser should be creating declarators;
851 declarators are a semi-syntactic representation of C++ entities.
852 Other parts of the front end that need to create entities (like
853 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
855 static cp_declarator
*make_call_declarator
856 (cp_declarator
*, tree
, cp_cv_quals
, tree
, tree
);
857 static cp_declarator
*make_array_declarator
858 (cp_declarator
*, tree
);
859 static cp_declarator
*make_pointer_declarator
860 (cp_cv_quals
, cp_declarator
*);
861 static cp_declarator
*make_reference_declarator
862 (cp_cv_quals
, cp_declarator
*, bool);
863 static cp_parameter_declarator
*make_parameter_declarator
864 (cp_decl_specifier_seq
*, cp_declarator
*, tree
);
865 static cp_declarator
*make_ptrmem_declarator
866 (cp_cv_quals
, tree
, cp_declarator
*);
868 /* An erroneous declarator. */
869 static cp_declarator
*cp_error_declarator
;
871 /* The obstack on which declarators and related data structures are
873 static struct obstack declarator_obstack
;
875 /* Alloc BYTES from the declarator memory pool. */
878 alloc_declarator (size_t bytes
)
880 return obstack_alloc (&declarator_obstack
, bytes
);
883 /* Allocate a declarator of the indicated KIND. Clear fields that are
884 common to all declarators. */
886 static cp_declarator
*
887 make_declarator (cp_declarator_kind kind
)
889 cp_declarator
*declarator
;
891 declarator
= (cp_declarator
*) alloc_declarator (sizeof (cp_declarator
));
892 declarator
->kind
= kind
;
893 declarator
->attributes
= NULL_TREE
;
894 declarator
->declarator
= NULL
;
895 declarator
->parameter_pack_p
= false;
900 /* Make a declarator for a generalized identifier. If
901 QUALIFYING_SCOPE is non-NULL, the identifier is
902 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
903 UNQUALIFIED_NAME. SFK indicates the kind of special function this
906 static cp_declarator
*
907 make_id_declarator (tree qualifying_scope
, tree unqualified_name
,
908 special_function_kind sfk
)
910 cp_declarator
*declarator
;
912 /* It is valid to write:
914 class C { void f(); };
918 The standard is not clear about whether `typedef const C D' is
919 legal; as of 2002-09-15 the committee is considering that
920 question. EDG 3.0 allows that syntax. Therefore, we do as
922 if (qualifying_scope
&& TYPE_P (qualifying_scope
))
923 qualifying_scope
= TYPE_MAIN_VARIANT (qualifying_scope
);
925 gcc_assert (TREE_CODE (unqualified_name
) == IDENTIFIER_NODE
926 || TREE_CODE (unqualified_name
) == BIT_NOT_EXPR
927 || TREE_CODE (unqualified_name
) == TEMPLATE_ID_EXPR
);
929 declarator
= make_declarator (cdk_id
);
930 declarator
->u
.id
.qualifying_scope
= qualifying_scope
;
931 declarator
->u
.id
.unqualified_name
= unqualified_name
;
932 declarator
->u
.id
.sfk
= sfk
;
937 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
938 of modifiers such as const or volatile to apply to the pointer
939 type, represented as identifiers. */
942 make_pointer_declarator (cp_cv_quals cv_qualifiers
, cp_declarator
*target
)
944 cp_declarator
*declarator
;
946 declarator
= make_declarator (cdk_pointer
);
947 declarator
->declarator
= target
;
948 declarator
->u
.pointer
.qualifiers
= cv_qualifiers
;
949 declarator
->u
.pointer
.class_type
= NULL_TREE
;
952 declarator
->parameter_pack_p
= target
->parameter_pack_p
;
953 target
->parameter_pack_p
= false;
956 declarator
->parameter_pack_p
= false;
961 /* Like make_pointer_declarator -- but for references. */
964 make_reference_declarator (cp_cv_quals cv_qualifiers
, cp_declarator
*target
,
967 cp_declarator
*declarator
;
969 declarator
= make_declarator (cdk_reference
);
970 declarator
->declarator
= target
;
971 declarator
->u
.reference
.qualifiers
= cv_qualifiers
;
972 declarator
->u
.reference
.rvalue_ref
= rvalue_ref
;
975 declarator
->parameter_pack_p
= target
->parameter_pack_p
;
976 target
->parameter_pack_p
= false;
979 declarator
->parameter_pack_p
= false;
984 /* Like make_pointer_declarator -- but for a pointer to a non-static
985 member of CLASS_TYPE. */
988 make_ptrmem_declarator (cp_cv_quals cv_qualifiers
, tree class_type
,
989 cp_declarator
*pointee
)
991 cp_declarator
*declarator
;
993 declarator
= make_declarator (cdk_ptrmem
);
994 declarator
->declarator
= pointee
;
995 declarator
->u
.pointer
.qualifiers
= cv_qualifiers
;
996 declarator
->u
.pointer
.class_type
= class_type
;
1000 declarator
->parameter_pack_p
= pointee
->parameter_pack_p
;
1001 pointee
->parameter_pack_p
= false;
1004 declarator
->parameter_pack_p
= false;
1009 /* Make a declarator for the function given by TARGET, with the
1010 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1011 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1012 indicates what exceptions can be thrown. */
1015 make_call_declarator (cp_declarator
*target
,
1017 cp_cv_quals cv_qualifiers
,
1018 tree exception_specification
,
1019 tree late_return_type
)
1021 cp_declarator
*declarator
;
1023 declarator
= make_declarator (cdk_function
);
1024 declarator
->declarator
= target
;
1025 declarator
->u
.function
.parameters
= parms
;
1026 declarator
->u
.function
.qualifiers
= cv_qualifiers
;
1027 declarator
->u
.function
.exception_specification
= exception_specification
;
1028 declarator
->u
.function
.late_return_type
= late_return_type
;
1031 declarator
->parameter_pack_p
= target
->parameter_pack_p
;
1032 target
->parameter_pack_p
= false;
1035 declarator
->parameter_pack_p
= false;
1040 /* Make a declarator for an array of BOUNDS elements, each of which is
1041 defined by ELEMENT. */
1044 make_array_declarator (cp_declarator
*element
, tree bounds
)
1046 cp_declarator
*declarator
;
1048 declarator
= make_declarator (cdk_array
);
1049 declarator
->declarator
= element
;
1050 declarator
->u
.array
.bounds
= bounds
;
1053 declarator
->parameter_pack_p
= element
->parameter_pack_p
;
1054 element
->parameter_pack_p
= false;
1057 declarator
->parameter_pack_p
= false;
1062 /* Determine whether the declarator we've seen so far can be a
1063 parameter pack, when followed by an ellipsis. */
1065 declarator_can_be_parameter_pack (cp_declarator
*declarator
)
1067 /* Search for a declarator name, or any other declarator that goes
1068 after the point where the ellipsis could appear in a parameter
1069 pack. If we find any of these, then this declarator can not be
1070 made into a parameter pack. */
1072 while (declarator
&& !found
)
1074 switch ((int)declarator
->kind
)
1085 declarator
= declarator
->declarator
;
1093 cp_parameter_declarator
*no_parameters
;
1095 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1096 DECLARATOR and DEFAULT_ARGUMENT. */
1098 cp_parameter_declarator
*
1099 make_parameter_declarator (cp_decl_specifier_seq
*decl_specifiers
,
1100 cp_declarator
*declarator
,
1101 tree default_argument
)
1103 cp_parameter_declarator
*parameter
;
1105 parameter
= ((cp_parameter_declarator
*)
1106 alloc_declarator (sizeof (cp_parameter_declarator
)));
1107 parameter
->next
= NULL
;
1108 if (decl_specifiers
)
1109 parameter
->decl_specifiers
= *decl_specifiers
;
1111 clear_decl_specs (¶meter
->decl_specifiers
);
1112 parameter
->declarator
= declarator
;
1113 parameter
->default_argument
= default_argument
;
1114 parameter
->ellipsis_p
= false;
1119 /* Returns true iff DECLARATOR is a declaration for a function. */
1122 function_declarator_p (const cp_declarator
*declarator
)
1126 if (declarator
->kind
== cdk_function
1127 && declarator
->declarator
->kind
== cdk_id
)
1129 if (declarator
->kind
== cdk_id
1130 || declarator
->kind
== cdk_error
)
1132 declarator
= declarator
->declarator
;
1142 A cp_parser parses the token stream as specified by the C++
1143 grammar. Its job is purely parsing, not semantic analysis. For
1144 example, the parser breaks the token stream into declarators,
1145 expressions, statements, and other similar syntactic constructs.
1146 It does not check that the types of the expressions on either side
1147 of an assignment-statement are compatible, or that a function is
1148 not declared with a parameter of type `void'.
1150 The parser invokes routines elsewhere in the compiler to perform
1151 semantic analysis and to build up the abstract syntax tree for the
1154 The parser (and the template instantiation code, which is, in a
1155 way, a close relative of parsing) are the only parts of the
1156 compiler that should be calling push_scope and pop_scope, or
1157 related functions. The parser (and template instantiation code)
1158 keeps track of what scope is presently active; everything else
1159 should simply honor that. (The code that generates static
1160 initializers may also need to set the scope, in order to check
1161 access control correctly when emitting the initializers.)
1166 The parser is of the standard recursive-descent variety. Upcoming
1167 tokens in the token stream are examined in order to determine which
1168 production to use when parsing a non-terminal. Some C++ constructs
1169 require arbitrary look ahead to disambiguate. For example, it is
1170 impossible, in the general case, to tell whether a statement is an
1171 expression or declaration without scanning the entire statement.
1172 Therefore, the parser is capable of "parsing tentatively." When the
1173 parser is not sure what construct comes next, it enters this mode.
1174 Then, while we attempt to parse the construct, the parser queues up
1175 error messages, rather than issuing them immediately, and saves the
1176 tokens it consumes. If the construct is parsed successfully, the
1177 parser "commits", i.e., it issues any queued error messages and
1178 the tokens that were being preserved are permanently discarded.
1179 If, however, the construct is not parsed successfully, the parser
1180 rolls back its state completely so that it can resume parsing using
1181 a different alternative.
1186 The performance of the parser could probably be improved substantially.
1187 We could often eliminate the need to parse tentatively by looking ahead
1188 a little bit. In some places, this approach might not entirely eliminate
1189 the need to parse tentatively, but it might still speed up the average
1192 /* Flags that are passed to some parsing functions. These values can
1193 be bitwise-ored together. */
1195 typedef enum cp_parser_flags
1198 CP_PARSER_FLAGS_NONE
= 0x0,
1199 /* The construct is optional. If it is not present, then no error
1200 should be issued. */
1201 CP_PARSER_FLAGS_OPTIONAL
= 0x1,
1202 /* When parsing a type-specifier, do not allow user-defined types. */
1203 CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
= 0x2
1206 /* The different kinds of declarators we want to parse. */
1208 typedef enum cp_parser_declarator_kind
1210 /* We want an abstract declarator. */
1211 CP_PARSER_DECLARATOR_ABSTRACT
,
1212 /* We want a named declarator. */
1213 CP_PARSER_DECLARATOR_NAMED
,
1214 /* We don't mind, but the name must be an unqualified-id. */
1215 CP_PARSER_DECLARATOR_EITHER
1216 } cp_parser_declarator_kind
;
1218 /* The precedence values used to parse binary expressions. The minimum value
1219 of PREC must be 1, because zero is reserved to quickly discriminate
1220 binary operators from other tokens. */
1225 PREC_LOGICAL_OR_EXPRESSION
,
1226 PREC_LOGICAL_AND_EXPRESSION
,
1227 PREC_INCLUSIVE_OR_EXPRESSION
,
1228 PREC_EXCLUSIVE_OR_EXPRESSION
,
1229 PREC_AND_EXPRESSION
,
1230 PREC_EQUALITY_EXPRESSION
,
1231 PREC_RELATIONAL_EXPRESSION
,
1232 PREC_SHIFT_EXPRESSION
,
1233 PREC_ADDITIVE_EXPRESSION
,
1234 PREC_MULTIPLICATIVE_EXPRESSION
,
1236 NUM_PREC_VALUES
= PREC_PM_EXPRESSION
1239 /* A mapping from a token type to a corresponding tree node type, with a
1240 precedence value. */
1242 typedef struct cp_parser_binary_operations_map_node
1244 /* The token type. */
1245 enum cpp_ttype token_type
;
1246 /* The corresponding tree code. */
1247 enum tree_code tree_type
;
1248 /* The precedence of this operator. */
1249 enum cp_parser_prec prec
;
1250 } cp_parser_binary_operations_map_node
;
1252 /* The status of a tentative parse. */
1254 typedef enum cp_parser_status_kind
1256 /* No errors have occurred. */
1257 CP_PARSER_STATUS_KIND_NO_ERROR
,
1258 /* An error has occurred. */
1259 CP_PARSER_STATUS_KIND_ERROR
,
1260 /* We are committed to this tentative parse, whether or not an error
1262 CP_PARSER_STATUS_KIND_COMMITTED
1263 } cp_parser_status_kind
;
1265 typedef struct cp_parser_expression_stack_entry
1267 /* Left hand side of the binary operation we are currently
1270 /* Original tree code for left hand side, if it was a binary
1271 expression itself (used for -Wparentheses). */
1272 enum tree_code lhs_type
;
1273 /* Tree code for the binary operation we are parsing. */
1274 enum tree_code tree_type
;
1275 /* Precedence of the binary operation we are parsing. */
1277 } cp_parser_expression_stack_entry
;
1279 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1280 entries because precedence levels on the stack are monotonically
1282 typedef struct cp_parser_expression_stack_entry
1283 cp_parser_expression_stack
[NUM_PREC_VALUES
];
1285 /* Context that is saved and restored when parsing tentatively. */
1286 typedef struct cp_parser_context
GTY (())
1288 /* If this is a tentative parsing context, the status of the
1290 enum cp_parser_status_kind status
;
1291 /* If non-NULL, we have just seen a `x->' or `x.' expression. Names
1292 that are looked up in this context must be looked up both in the
1293 scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
1294 the context of the containing expression. */
1297 /* The next parsing context in the stack. */
1298 struct cp_parser_context
*next
;
1299 } cp_parser_context
;
1303 /* Constructors and destructors. */
1305 static cp_parser_context
*cp_parser_context_new
1306 (cp_parser_context
*);
1308 /* Class variables. */
1310 static GTY((deletable
)) cp_parser_context
* cp_parser_context_free_list
;
1312 /* The operator-precedence table used by cp_parser_binary_expression.
1313 Transformed into an associative array (binops_by_token) by
1316 static const cp_parser_binary_operations_map_node binops
[] = {
1317 { CPP_DEREF_STAR
, MEMBER_REF
, PREC_PM_EXPRESSION
},
1318 { CPP_DOT_STAR
, DOTSTAR_EXPR
, PREC_PM_EXPRESSION
},
1320 { CPP_MULT
, MULT_EXPR
, PREC_MULTIPLICATIVE_EXPRESSION
},
1321 { CPP_DIV
, TRUNC_DIV_EXPR
, PREC_MULTIPLICATIVE_EXPRESSION
},
1322 { CPP_MOD
, TRUNC_MOD_EXPR
, PREC_MULTIPLICATIVE_EXPRESSION
},
1324 { CPP_PLUS
, PLUS_EXPR
, PREC_ADDITIVE_EXPRESSION
},
1325 { CPP_MINUS
, MINUS_EXPR
, PREC_ADDITIVE_EXPRESSION
},
1327 { CPP_LSHIFT
, LSHIFT_EXPR
, PREC_SHIFT_EXPRESSION
},
1328 { CPP_RSHIFT
, RSHIFT_EXPR
, PREC_SHIFT_EXPRESSION
},
1330 { CPP_LESS
, LT_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1331 { CPP_GREATER
, GT_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1332 { CPP_LESS_EQ
, LE_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1333 { CPP_GREATER_EQ
, GE_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1335 { CPP_EQ_EQ
, EQ_EXPR
, PREC_EQUALITY_EXPRESSION
},
1336 { CPP_NOT_EQ
, NE_EXPR
, PREC_EQUALITY_EXPRESSION
},
1338 { CPP_AND
, BIT_AND_EXPR
, PREC_AND_EXPRESSION
},
1340 { CPP_XOR
, BIT_XOR_EXPR
, PREC_EXCLUSIVE_OR_EXPRESSION
},
1342 { CPP_OR
, BIT_IOR_EXPR
, PREC_INCLUSIVE_OR_EXPRESSION
},
1344 { CPP_AND_AND
, TRUTH_ANDIF_EXPR
, PREC_LOGICAL_AND_EXPRESSION
},
1346 { CPP_OR_OR
, TRUTH_ORIF_EXPR
, PREC_LOGICAL_OR_EXPRESSION
}
1349 /* The same as binops, but initialized by cp_parser_new so that
1350 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1352 static cp_parser_binary_operations_map_node binops_by_token
[N_CP_TTYPES
];
1354 /* Constructors and destructors. */
1356 /* Construct a new context. The context below this one on the stack
1357 is given by NEXT. */
1359 static cp_parser_context
*
1360 cp_parser_context_new (cp_parser_context
* next
)
1362 cp_parser_context
*context
;
1364 /* Allocate the storage. */
1365 if (cp_parser_context_free_list
!= NULL
)
1367 /* Pull the first entry from the free list. */
1368 context
= cp_parser_context_free_list
;
1369 cp_parser_context_free_list
= context
->next
;
1370 memset (context
, 0, sizeof (*context
));
1373 context
= GGC_CNEW (cp_parser_context
);
1375 /* No errors have occurred yet in this context. */
1376 context
->status
= CP_PARSER_STATUS_KIND_NO_ERROR
;
1377 /* If this is not the bottommost context, copy information that we
1378 need from the previous context. */
1381 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1382 expression, then we are parsing one in this context, too. */
1383 context
->object_type
= next
->object_type
;
1384 /* Thread the stack. */
1385 context
->next
= next
;
1391 /* The cp_parser structure represents the C++ parser. */
1393 typedef struct cp_parser
GTY(())
1395 /* The lexer from which we are obtaining tokens. */
1398 /* The scope in which names should be looked up. If NULL_TREE, then
1399 we look up names in the scope that is currently open in the
1400 source program. If non-NULL, this is either a TYPE or
1401 NAMESPACE_DECL for the scope in which we should look. It can
1402 also be ERROR_MARK, when we've parsed a bogus scope.
1404 This value is not cleared automatically after a name is looked
1405 up, so we must be careful to clear it before starting a new look
1406 up sequence. (If it is not cleared, then `X::Y' followed by `Z'
1407 will look up `Z' in the scope of `X', rather than the current
1408 scope.) Unfortunately, it is difficult to tell when name lookup
1409 is complete, because we sometimes peek at a token, look it up,
1410 and then decide not to consume it. */
1413 /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
1414 last lookup took place. OBJECT_SCOPE is used if an expression
1415 like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
1416 respectively. QUALIFYING_SCOPE is used for an expression of the
1417 form "X::Y"; it refers to X. */
1419 tree qualifying_scope
;
1421 /* A stack of parsing contexts. All but the bottom entry on the
1422 stack will be tentative contexts.
1424 We parse tentatively in order to determine which construct is in
1425 use in some situations. For example, in order to determine
1426 whether a statement is an expression-statement or a
1427 declaration-statement we parse it tentatively as a
1428 declaration-statement. If that fails, we then reparse the same
1429 token stream as an expression-statement. */
1430 cp_parser_context
*context
;
1432 /* True if we are parsing GNU C++. If this flag is not set, then
1433 GNU extensions are not recognized. */
1434 bool allow_gnu_extensions_p
;
1436 /* TRUE if the `>' token should be interpreted as the greater-than
1437 operator. FALSE if it is the end of a template-id or
1438 template-parameter-list. In C++0x mode, this flag also applies to
1439 `>>' tokens, which are viewed as two consecutive `>' tokens when
1440 this flag is FALSE. */
1441 bool greater_than_is_operator_p
;
1443 /* TRUE if default arguments are allowed within a parameter list
1444 that starts at this point. FALSE if only a gnu extension makes
1445 them permissible. */
1446 bool default_arg_ok_p
;
1448 /* TRUE if we are parsing an integral constant-expression. See
1449 [expr.const] for a precise definition. */
1450 bool integral_constant_expression_p
;
1452 /* TRUE if we are parsing an integral constant-expression -- but a
1453 non-constant expression should be permitted as well. This flag
1454 is used when parsing an array bound so that GNU variable-length
1455 arrays are tolerated. */
1456 bool allow_non_integral_constant_expression_p
;
1458 /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
1459 been seen that makes the expression non-constant. */
1460 bool non_integral_constant_expression_p
;
1462 /* TRUE if local variable names and `this' are forbidden in the
1464 bool local_variables_forbidden_p
;
1466 /* TRUE if the declaration we are parsing is part of a
1467 linkage-specification of the form `extern string-literal
1469 bool in_unbraced_linkage_specification_p
;
1471 /* TRUE if we are presently parsing a declarator, after the
1472 direct-declarator. */
1473 bool in_declarator_p
;
1475 /* TRUE if we are presently parsing a template-argument-list. */
1476 bool in_template_argument_list_p
;
1478 /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
1479 to IN_OMP_BLOCK if parsing OpenMP structured block and
1480 IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
1481 this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
1482 iteration-statement, OpenMP block or loop within that switch. */
1483 #define IN_SWITCH_STMT 1
1484 #define IN_ITERATION_STMT 2
1485 #define IN_OMP_BLOCK 4
1486 #define IN_OMP_FOR 8
1487 #define IN_IF_STMT 16
1488 unsigned char in_statement
;
1490 /* TRUE if we are presently parsing the body of a switch statement.
1491 Note that this doesn't quite overlap with in_statement above.
1492 The difference relates to giving the right sets of error messages:
1493 "case not in switch" vs "break statement used with OpenMP...". */
1494 bool in_switch_statement_p
;
1496 /* TRUE if we are parsing a type-id in an expression context. In
1497 such a situation, both "type (expr)" and "type (type)" are valid
1499 bool in_type_id_in_expr_p
;
1501 /* TRUE if we are currently in a header file where declarations are
1502 implicitly extern "C". */
1503 bool implicit_extern_c
;
1505 /* TRUE if strings in expressions should be translated to the execution
1507 bool translate_strings_p
;
1509 /* TRUE if we are presently parsing the body of a function, but not
1511 bool in_function_body
;
1513 /* If non-NULL, then we are parsing a construct where new type
1514 definitions are not permitted. The string stored here will be
1515 issued as an error message if a type is defined. */
1516 const char *type_definition_forbidden_message
;
1518 /* A list of lists. The outer list is a stack, used for member
1519 functions of local classes. At each level there are two sub-list,
1520 one on TREE_VALUE and one on TREE_PURPOSE. Each of those
1521 sub-lists has a FUNCTION_DECL or TEMPLATE_DECL on their
1522 TREE_VALUE's. The functions are chained in reverse declaration
1525 The TREE_PURPOSE sublist contains those functions with default
1526 arguments that need post processing, and the TREE_VALUE sublist
1527 contains those functions with definitions that need post
1530 These lists can only be processed once the outermost class being
1531 defined is complete. */
1532 tree unparsed_functions_queues
;
1534 /* The number of classes whose definitions are currently in
1536 unsigned num_classes_being_defined
;
1538 /* The number of template parameter lists that apply directly to the
1539 current declaration. */
1540 unsigned num_template_parameter_lists
;
1545 /* Constructors and destructors. */
1547 static cp_parser
*cp_parser_new
1550 /* Routines to parse various constructs.
1552 Those that return `tree' will return the error_mark_node (rather
1553 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1554 Sometimes, they will return an ordinary node if error-recovery was
1555 attempted, even though a parse error occurred. So, to check
1556 whether or not a parse error occurred, you should always use
1557 cp_parser_error_occurred. If the construct is optional (indicated
1558 either by an `_opt' in the name of the function that does the
1559 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1560 the construct is not present. */
1562 /* Lexical conventions [gram.lex] */
1564 static tree cp_parser_identifier
1566 static tree cp_parser_string_literal
1567 (cp_parser
*, bool, bool);
1569 /* Basic concepts [gram.basic] */
1571 static bool cp_parser_translation_unit
1574 /* Expressions [gram.expr] */
1576 static tree cp_parser_primary_expression
1577 (cp_parser
*, bool, bool, bool, cp_id_kind
*);
1578 static tree cp_parser_id_expression
1579 (cp_parser
*, bool, bool, bool *, bool, bool);
1580 static tree cp_parser_unqualified_id
1581 (cp_parser
*, bool, bool, bool, bool);
1582 static tree cp_parser_nested_name_specifier_opt
1583 (cp_parser
*, bool, bool, bool, bool);
1584 static tree cp_parser_nested_name_specifier
1585 (cp_parser
*, bool, bool, bool, bool);
1586 static tree cp_parser_qualifying_entity
1587 (cp_parser
*, bool, bool, bool, bool, bool);
1588 static tree cp_parser_postfix_expression
1589 (cp_parser
*, bool, bool, bool, cp_id_kind
*);
1590 static tree cp_parser_postfix_open_square_expression
1591 (cp_parser
*, tree
, bool);
1592 static tree cp_parser_postfix_dot_deref_expression
1593 (cp_parser
*, enum cpp_ttype
, tree
, bool, cp_id_kind
*, location_t
);
1594 static tree cp_parser_parenthesized_expression_list
1595 (cp_parser
*, bool, bool, bool, bool *);
1596 static void cp_parser_pseudo_destructor_name
1597 (cp_parser
*, tree
*, tree
*);
1598 static tree cp_parser_unary_expression
1599 (cp_parser
*, bool, bool, cp_id_kind
*);
1600 static enum tree_code cp_parser_unary_operator
1602 static tree cp_parser_new_expression
1604 static tree cp_parser_new_placement
1606 static tree cp_parser_new_type_id
1607 (cp_parser
*, tree
*);
1608 static cp_declarator
*cp_parser_new_declarator_opt
1610 static cp_declarator
*cp_parser_direct_new_declarator
1612 static tree cp_parser_new_initializer
1614 static tree cp_parser_delete_expression
1616 static tree cp_parser_cast_expression
1617 (cp_parser
*, bool, bool, cp_id_kind
*);
1618 static tree cp_parser_binary_expression
1619 (cp_parser
*, bool, enum cp_parser_prec
, cp_id_kind
*);
1620 static tree cp_parser_question_colon_clause
1621 (cp_parser
*, tree
);
1622 static tree cp_parser_assignment_expression
1623 (cp_parser
*, bool, cp_id_kind
*);
1624 static enum tree_code cp_parser_assignment_operator_opt
1626 static tree cp_parser_expression
1627 (cp_parser
*, bool, cp_id_kind
*);
1628 static tree cp_parser_constant_expression
1629 (cp_parser
*, bool, bool *);
1630 static tree cp_parser_builtin_offsetof
1633 /* Statements [gram.stmt.stmt] */
1635 static void cp_parser_statement
1636 (cp_parser
*, tree
, bool, bool *);
1637 static void cp_parser_label_for_labeled_statement
1639 static tree cp_parser_expression_statement
1640 (cp_parser
*, tree
);
1641 static tree cp_parser_compound_statement
1642 (cp_parser
*, tree
, bool);
1643 static void cp_parser_statement_seq_opt
1644 (cp_parser
*, tree
);
1645 static tree cp_parser_selection_statement
1646 (cp_parser
*, bool *);
1647 static tree cp_parser_condition
1649 static tree cp_parser_iteration_statement
1651 static void cp_parser_for_init_statement
1653 static tree cp_parser_jump_statement
1655 static void cp_parser_declaration_statement
1658 static tree cp_parser_implicitly_scoped_statement
1659 (cp_parser
*, bool *);
1660 static void cp_parser_already_scoped_statement
1663 /* Declarations [gram.dcl.dcl] */
1665 static void cp_parser_declaration_seq_opt
1667 static void cp_parser_declaration
1669 static void cp_parser_block_declaration
1670 (cp_parser
*, bool);
1671 static void cp_parser_simple_declaration
1672 (cp_parser
*, bool);
1673 static void cp_parser_decl_specifier_seq
1674 (cp_parser
*, cp_parser_flags
, cp_decl_specifier_seq
*, int *);
1675 static tree cp_parser_storage_class_specifier_opt
1677 static tree cp_parser_function_specifier_opt
1678 (cp_parser
*, cp_decl_specifier_seq
*);
1679 static tree cp_parser_type_specifier
1680 (cp_parser
*, cp_parser_flags
, cp_decl_specifier_seq
*, bool,
1682 static tree cp_parser_simple_type_specifier
1683 (cp_parser
*, cp_decl_specifier_seq
*, cp_parser_flags
);
1684 static tree cp_parser_type_name
1686 static tree cp_parser_nonclass_name
1687 (cp_parser
* parser
);
1688 static tree cp_parser_elaborated_type_specifier
1689 (cp_parser
*, bool, bool);
1690 static tree cp_parser_enum_specifier
1692 static void cp_parser_enumerator_list
1693 (cp_parser
*, tree
);
1694 static void cp_parser_enumerator_definition
1695 (cp_parser
*, tree
);
1696 static tree cp_parser_namespace_name
1698 static void cp_parser_namespace_definition
1700 static void cp_parser_namespace_body
1702 static tree cp_parser_qualified_namespace_specifier
1704 static void cp_parser_namespace_alias_definition
1706 static bool cp_parser_using_declaration
1707 (cp_parser
*, bool);
1708 static void cp_parser_using_directive
1710 static void cp_parser_asm_definition
1712 static void cp_parser_linkage_specification
1714 static void cp_parser_static_assert
1715 (cp_parser
*, bool);
1716 static tree cp_parser_decltype
1719 /* Declarators [gram.dcl.decl] */
1721 static tree cp_parser_init_declarator
1722 (cp_parser
*, cp_decl_specifier_seq
*, VEC (deferred_access_check
,gc
)*, bool, bool, int, bool *);
1723 static cp_declarator
*cp_parser_declarator
1724 (cp_parser
*, cp_parser_declarator_kind
, int *, bool *, bool);
1725 static cp_declarator
*cp_parser_direct_declarator
1726 (cp_parser
*, cp_parser_declarator_kind
, int *, bool);
1727 static enum tree_code cp_parser_ptr_operator
1728 (cp_parser
*, tree
*, cp_cv_quals
*);
1729 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1731 static tree cp_parser_late_return_type_opt
1733 static tree cp_parser_declarator_id
1734 (cp_parser
*, bool);
1735 static tree cp_parser_type_id
1737 static void cp_parser_type_specifier_seq
1738 (cp_parser
*, bool, cp_decl_specifier_seq
*);
1739 static tree cp_parser_parameter_declaration_clause
1741 static tree cp_parser_parameter_declaration_list
1742 (cp_parser
*, bool *);
1743 static cp_parameter_declarator
*cp_parser_parameter_declaration
1744 (cp_parser
*, bool, bool *);
1745 static tree cp_parser_default_argument
1746 (cp_parser
*, bool);
1747 static void cp_parser_function_body
1749 static tree cp_parser_initializer
1750 (cp_parser
*, bool *, bool *);
1751 static tree cp_parser_initializer_clause
1752 (cp_parser
*, bool *);
1753 static tree cp_parser_braced_list
1754 (cp_parser
*, bool*);
1755 static VEC(constructor_elt
,gc
) *cp_parser_initializer_list
1756 (cp_parser
*, bool *);
1758 static bool cp_parser_ctor_initializer_opt_and_function_body
1761 /* Classes [gram.class] */
1763 static tree cp_parser_class_name
1764 (cp_parser
*, bool, bool, enum tag_types
, bool, bool, bool);
1765 static tree cp_parser_class_specifier
1767 static tree cp_parser_class_head
1768 (cp_parser
*, bool *, tree
*, tree
*);
1769 static enum tag_types cp_parser_class_key
1771 static void cp_parser_member_specification_opt
1773 static void cp_parser_member_declaration
1775 static tree cp_parser_pure_specifier
1777 static tree cp_parser_constant_initializer
1780 /* Derived classes [gram.class.derived] */
1782 static tree cp_parser_base_clause
1784 static tree cp_parser_base_specifier
1787 /* Special member functions [gram.special] */
1789 static tree cp_parser_conversion_function_id
1791 static tree cp_parser_conversion_type_id
1793 static cp_declarator
*cp_parser_conversion_declarator_opt
1795 static bool cp_parser_ctor_initializer_opt
1797 static void cp_parser_mem_initializer_list
1799 static tree cp_parser_mem_initializer
1801 static tree cp_parser_mem_initializer_id
1804 /* Overloading [gram.over] */
1806 static tree cp_parser_operator_function_id
1808 static tree cp_parser_operator
1811 /* Templates [gram.temp] */
1813 static void cp_parser_template_declaration
1814 (cp_parser
*, bool);
1815 static tree cp_parser_template_parameter_list
1817 static tree cp_parser_template_parameter
1818 (cp_parser
*, bool *, bool *);
1819 static tree cp_parser_type_parameter
1820 (cp_parser
*, bool *);
1821 static tree cp_parser_template_id
1822 (cp_parser
*, bool, bool, bool);
1823 static tree cp_parser_template_name
1824 (cp_parser
*, bool, bool, bool, bool *);
1825 static tree cp_parser_template_argument_list
1827 static tree cp_parser_template_argument
1829 static void cp_parser_explicit_instantiation
1831 static void cp_parser_explicit_specialization
1834 /* Exception handling [gram.exception] */
1836 static tree cp_parser_try_block
1838 static bool cp_parser_function_try_block
1840 static void cp_parser_handler_seq
1842 static void cp_parser_handler
1844 static tree cp_parser_exception_declaration
1846 static tree cp_parser_throw_expression
1848 static tree cp_parser_exception_specification_opt
1850 static tree cp_parser_type_id_list
1853 /* GNU Extensions */
1855 static tree cp_parser_asm_specification_opt
1857 static tree cp_parser_asm_operand_list
1859 static tree cp_parser_asm_clobber_list
1861 static tree cp_parser_attributes_opt
1863 static tree cp_parser_attribute_list
1865 static bool cp_parser_extension_opt
1866 (cp_parser
*, int *);
1867 static void cp_parser_label_declaration
1870 enum pragma_context
{ pragma_external
, pragma_stmt
, pragma_compound
};
1871 static bool cp_parser_pragma
1872 (cp_parser
*, enum pragma_context
);
1874 /* Objective-C++ Productions */
1876 static tree cp_parser_objc_message_receiver
1878 static tree cp_parser_objc_message_args
1880 static tree cp_parser_objc_message_expression
1882 static tree cp_parser_objc_encode_expression
1884 static tree cp_parser_objc_defs_expression
1886 static tree cp_parser_objc_protocol_expression
1888 static tree cp_parser_objc_selector_expression
1890 static tree cp_parser_objc_expression
1892 static bool cp_parser_objc_selector_p
1894 static tree cp_parser_objc_selector
1896 static tree cp_parser_objc_protocol_refs_opt
1898 static void cp_parser_objc_declaration
1900 static tree cp_parser_objc_statement
1903 /* Utility Routines */
1905 static tree cp_parser_lookup_name
1906 (cp_parser
*, tree
, enum tag_types
, bool, bool, bool, tree
*, location_t
);
1907 static tree cp_parser_lookup_name_simple
1908 (cp_parser
*, tree
, location_t
);
1909 static tree cp_parser_maybe_treat_template_as_class
1911 static bool cp_parser_check_declarator_template_parameters
1912 (cp_parser
*, cp_declarator
*, location_t
);
1913 static bool cp_parser_check_template_parameters
1914 (cp_parser
*, unsigned, location_t
);
1915 static tree cp_parser_simple_cast_expression
1917 static tree cp_parser_global_scope_opt
1918 (cp_parser
*, bool);
1919 static bool cp_parser_constructor_declarator_p
1920 (cp_parser
*, bool);
1921 static tree cp_parser_function_definition_from_specifiers_and_declarator
1922 (cp_parser
*, cp_decl_specifier_seq
*, tree
, const cp_declarator
*);
1923 static tree cp_parser_function_definition_after_declarator
1924 (cp_parser
*, bool);
1925 static void cp_parser_template_declaration_after_export
1926 (cp_parser
*, bool);
1927 static void cp_parser_perform_template_parameter_access_checks
1928 (VEC (deferred_access_check
,gc
)*);
1929 static tree cp_parser_single_declaration
1930 (cp_parser
*, VEC (deferred_access_check
,gc
)*, bool, bool, bool *);
1931 static tree cp_parser_functional_cast
1932 (cp_parser
*, tree
);
1933 static tree cp_parser_save_member_function_body
1934 (cp_parser
*, cp_decl_specifier_seq
*, cp_declarator
*, tree
);
1935 static tree cp_parser_enclosed_template_argument_list
1937 static void cp_parser_save_default_args
1938 (cp_parser
*, tree
);
1939 static void cp_parser_late_parsing_for_member
1940 (cp_parser
*, tree
);
1941 static void cp_parser_late_parsing_default_args
1942 (cp_parser
*, tree
);
1943 static tree cp_parser_sizeof_operand
1944 (cp_parser
*, enum rid
);
1945 static tree cp_parser_trait_expr
1946 (cp_parser
*, enum rid
);
1947 static bool cp_parser_declares_only_class_p
1949 static void cp_parser_set_storage_class
1950 (cp_parser
*, cp_decl_specifier_seq
*, enum rid
, location_t
);
1951 static void cp_parser_set_decl_spec_type
1952 (cp_decl_specifier_seq
*, tree
, location_t
, bool);
1953 static bool cp_parser_friend_p
1954 (const cp_decl_specifier_seq
*);
1955 static cp_token
*cp_parser_require
1956 (cp_parser
*, enum cpp_ttype
, const char *);
1957 static cp_token
*cp_parser_require_keyword
1958 (cp_parser
*, enum rid
, const char *);
1959 static bool cp_parser_token_starts_function_definition_p
1961 static bool cp_parser_next_token_starts_class_definition_p
1963 static bool cp_parser_next_token_ends_template_argument_p
1965 static bool cp_parser_nth_token_starts_template_argument_list_p
1966 (cp_parser
*, size_t);
1967 static enum tag_types cp_parser_token_is_class_key
1969 static void cp_parser_check_class_key
1970 (enum tag_types
, tree type
);
1971 static void cp_parser_check_access_in_redeclaration
1972 (tree type
, location_t location
);
1973 static bool cp_parser_optional_template_keyword
1975 static void cp_parser_pre_parsed_nested_name_specifier
1977 static bool cp_parser_cache_group
1978 (cp_parser
*, enum cpp_ttype
, unsigned);
1979 static void cp_parser_parse_tentatively
1981 static void cp_parser_commit_to_tentative_parse
1983 static void cp_parser_abort_tentative_parse
1985 static bool cp_parser_parse_definitely
1987 static inline bool cp_parser_parsing_tentatively
1989 static bool cp_parser_uncommitted_to_tentative_parse_p
1991 static void cp_parser_error
1992 (cp_parser
*, const char *);
1993 static void cp_parser_name_lookup_error
1994 (cp_parser
*, tree
, tree
, const char *, location_t
);
1995 static bool cp_parser_simulate_error
1997 static bool cp_parser_check_type_definition
1999 static void cp_parser_check_for_definition_in_return_type
2000 (cp_declarator
*, tree
, location_t type_location
);
2001 static void cp_parser_check_for_invalid_template_id
2002 (cp_parser
*, tree
, location_t location
);
2003 static bool cp_parser_non_integral_constant_expression
2004 (cp_parser
*, const char *);
2005 static void cp_parser_diagnose_invalid_type_name
2006 (cp_parser
*, tree
, tree
, location_t
);
2007 static bool cp_parser_parse_and_diagnose_invalid_type_name
2009 static int cp_parser_skip_to_closing_parenthesis
2010 (cp_parser
*, bool, bool, bool);
2011 static void cp_parser_skip_to_end_of_statement
2013 static void cp_parser_consume_semicolon_at_end_of_statement
2015 static void cp_parser_skip_to_end_of_block_or_statement
2017 static bool cp_parser_skip_to_closing_brace
2019 static void cp_parser_skip_to_end_of_template_parameter_list
2021 static void cp_parser_skip_to_pragma_eol
2022 (cp_parser
*, cp_token
*);
2023 static bool cp_parser_error_occurred
2025 static bool cp_parser_allow_gnu_extensions_p
2027 static bool cp_parser_is_string_literal
2029 static bool cp_parser_is_keyword
2030 (cp_token
*, enum rid
);
2031 static tree cp_parser_make_typename_type
2032 (cp_parser
*, tree
, tree
, location_t location
);
2033 static cp_declarator
* cp_parser_make_indirect_declarator
2034 (enum tree_code
, tree
, cp_cv_quals
, cp_declarator
*);
2036 /* Returns nonzero if we are parsing tentatively. */
2039 cp_parser_parsing_tentatively (cp_parser
* parser
)
2041 return parser
->context
->next
!= NULL
;
2044 /* Returns nonzero if TOKEN is a string literal. */
2047 cp_parser_is_string_literal (cp_token
* token
)
2049 return (token
->type
== CPP_STRING
||
2050 token
->type
== CPP_STRING16
||
2051 token
->type
== CPP_STRING32
||
2052 token
->type
== CPP_WSTRING
);
2055 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2058 cp_parser_is_keyword (cp_token
* token
, enum rid keyword
)
2060 return token
->keyword
== keyword
;
2063 /* If not parsing tentatively, issue a diagnostic of the form
2064 FILE:LINE: MESSAGE before TOKEN
2065 where TOKEN is the next token in the input stream. MESSAGE
2066 (specified by the caller) is usually of the form "expected
2070 cp_parser_error (cp_parser
* parser
, const char* message
)
2072 if (!cp_parser_simulate_error (parser
))
2074 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
2075 /* This diagnostic makes more sense if it is tagged to the line
2076 of the token we just peeked at. */
2077 cp_lexer_set_source_position_from_token (token
);
2079 if (token
->type
== CPP_PRAGMA
)
2081 error ("%H%<#pragma%> is not allowed here", &token
->location
);
2082 cp_parser_skip_to_pragma_eol (parser
, token
);
2086 c_parse_error (message
,
2087 /* Because c_parser_error does not understand
2088 CPP_KEYWORD, keywords are treated like
2090 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
2095 /* Issue an error about name-lookup failing. NAME is the
2096 IDENTIFIER_NODE DECL is the result of
2097 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2098 the thing that we hoped to find. */
2101 cp_parser_name_lookup_error (cp_parser
* parser
,
2104 const char* desired
,
2105 location_t location
)
2107 /* If name lookup completely failed, tell the user that NAME was not
2109 if (decl
== error_mark_node
)
2111 if (parser
->scope
&& parser
->scope
!= global_namespace
)
2112 error ("%H%<%E::%E%> has not been declared",
2113 &location
, parser
->scope
, name
);
2114 else if (parser
->scope
== global_namespace
)
2115 error ("%H%<::%E%> has not been declared", &location
, name
);
2116 else if (parser
->object_scope
2117 && !CLASS_TYPE_P (parser
->object_scope
))
2118 error ("%Hrequest for member %qE in non-class type %qT",
2119 &location
, name
, parser
->object_scope
);
2120 else if (parser
->object_scope
)
2121 error ("%H%<%T::%E%> has not been declared",
2122 &location
, parser
->object_scope
, name
);
2124 error ("%H%qE has not been declared", &location
, name
);
2126 else if (parser
->scope
&& parser
->scope
!= global_namespace
)
2127 error ("%H%<%E::%E%> %s", &location
, parser
->scope
, name
, desired
);
2128 else if (parser
->scope
== global_namespace
)
2129 error ("%H%<::%E%> %s", &location
, name
, desired
);
2131 error ("%H%qE %s", &location
, name
, desired
);
2134 /* If we are parsing tentatively, remember that an error has occurred
2135 during this tentative parse. Returns true if the error was
2136 simulated; false if a message should be issued by the caller. */
2139 cp_parser_simulate_error (cp_parser
* parser
)
2141 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
2143 parser
->context
->status
= CP_PARSER_STATUS_KIND_ERROR
;
2149 /* Check for repeated decl-specifiers. */
2152 cp_parser_check_decl_spec (cp_decl_specifier_seq
*decl_specs
,
2153 location_t location
)
2157 for (ds
= ds_first
; ds
!= ds_last
; ++ds
)
2159 unsigned count
= decl_specs
->specs
[(int)ds
];
2162 /* The "long" specifier is a special case because of "long long". */
2166 error ("%H%<long long long%> is too long for GCC", &location
);
2167 else if (pedantic
&& !in_system_header
&& warn_long_long
2168 && cxx_dialect
== cxx98
)
2169 pedwarn (location
, OPT_Wlong_long
,
2170 "ISO C++ 1998 does not support %<long long%>");
2174 static const char *const decl_spec_names
[] = {
2190 error ("%Hduplicate %qs", &location
, decl_spec_names
[(int)ds
]);
2195 /* This function is called when a type is defined. If type
2196 definitions are forbidden at this point, an error message is
2200 cp_parser_check_type_definition (cp_parser
* parser
)
2202 /* If types are forbidden here, issue a message. */
2203 if (parser
->type_definition_forbidden_message
)
2205 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2206 in the message need to be interpreted. */
2207 error (parser
->type_definition_forbidden_message
);
2213 /* This function is called when the DECLARATOR is processed. The TYPE
2214 was a type defined in the decl-specifiers. If it is invalid to
2215 define a type in the decl-specifiers for DECLARATOR, an error is
2216 issued. TYPE_LOCATION is the location of TYPE and is used
2217 for error reporting. */
2220 cp_parser_check_for_definition_in_return_type (cp_declarator
*declarator
,
2221 tree type
, location_t type_location
)
2223 /* [dcl.fct] forbids type definitions in return types.
2224 Unfortunately, it's not easy to know whether or not we are
2225 processing a return type until after the fact. */
2227 && (declarator
->kind
== cdk_pointer
2228 || declarator
->kind
== cdk_reference
2229 || declarator
->kind
== cdk_ptrmem
))
2230 declarator
= declarator
->declarator
;
2232 && declarator
->kind
== cdk_function
)
2234 error ("%Hnew types may not be defined in a return type", &type_location
);
2235 inform (type_location
,
2236 "(perhaps a semicolon is missing after the definition of %qT)",
2241 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2242 "<" in any valid C++ program. If the next token is indeed "<",
2243 issue a message warning the user about what appears to be an
2244 invalid attempt to form a template-id. LOCATION is the location
2245 of the type-specifier (TYPE) */
2248 cp_parser_check_for_invalid_template_id (cp_parser
* parser
,
2249 tree type
, location_t location
)
2251 cp_token_position start
= 0;
2253 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
2256 error ("%H%qT is not a template", &location
, type
);
2257 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
2258 error ("%H%qE is not a template", &location
, type
);
2260 error ("%Hinvalid template-id", &location
);
2261 /* Remember the location of the invalid "<". */
2262 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
2263 start
= cp_lexer_token_position (parser
->lexer
, true);
2264 /* Consume the "<". */
2265 cp_lexer_consume_token (parser
->lexer
);
2266 /* Parse the template arguments. */
2267 cp_parser_enclosed_template_argument_list (parser
);
2268 /* Permanently remove the invalid template arguments so that
2269 this error message is not issued again. */
2271 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
2275 /* If parsing an integral constant-expression, issue an error message
2276 about the fact that THING appeared and return true. Otherwise,
2277 return false. In either case, set
2278 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2281 cp_parser_non_integral_constant_expression (cp_parser
*parser
,
2284 parser
->non_integral_constant_expression_p
= true;
2285 if (parser
->integral_constant_expression_p
)
2287 if (!parser
->allow_non_integral_constant_expression_p
)
2289 /* Don't use `%s' to print THING, because quotations (`%<', `%>')
2290 in the message need to be interpreted. */
2291 char *message
= concat (thing
,
2292 " cannot appear in a constant-expression",
2302 /* Emit a diagnostic for an invalid type name. SCOPE is the
2303 qualifying scope (or NULL, if none) for ID. This function commits
2304 to the current active tentative parse, if any. (Otherwise, the
2305 problematic construct might be encountered again later, resulting
2306 in duplicate error messages.) LOCATION is the location of ID. */
2309 cp_parser_diagnose_invalid_type_name (cp_parser
*parser
,
2310 tree scope
, tree id
,
2311 location_t location
)
2313 tree decl
, old_scope
;
2314 /* Try to lookup the identifier. */
2315 old_scope
= parser
->scope
;
2316 parser
->scope
= scope
;
2317 decl
= cp_parser_lookup_name_simple (parser
, id
, location
);
2318 parser
->scope
= old_scope
;
2319 /* If the lookup found a template-name, it means that the user forgot
2320 to specify an argument list. Emit a useful error message. */
2321 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2322 error ("%Hinvalid use of template-name %qE without an argument list",
2324 else if (TREE_CODE (id
) == BIT_NOT_EXPR
)
2325 error ("%Hinvalid use of destructor %qD as a type", &location
, id
);
2326 else if (TREE_CODE (decl
) == TYPE_DECL
)
2327 /* Something like 'unsigned A a;' */
2328 error ("%Hinvalid combination of multiple type-specifiers",
2330 else if (!parser
->scope
)
2332 /* Issue an error message. */
2333 error ("%H%qE does not name a type", &location
, id
);
2334 /* If we're in a template class, it's possible that the user was
2335 referring to a type from a base class. For example:
2337 template <typename T> struct A { typedef T X; };
2338 template <typename T> struct B : public A<T> { X x; };
2340 The user should have said "typename A<T>::X". */
2341 if (processing_template_decl
&& current_class_type
2342 && TYPE_BINFO (current_class_type
))
2346 for (b
= TREE_CHAIN (TYPE_BINFO (current_class_type
));
2350 tree base_type
= BINFO_TYPE (b
);
2351 if (CLASS_TYPE_P (base_type
)
2352 && dependent_type_p (base_type
))
2355 /* Go from a particular instantiation of the
2356 template (which will have an empty TYPE_FIELDs),
2357 to the main version. */
2358 base_type
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type
);
2359 for (field
= TYPE_FIELDS (base_type
);
2361 field
= TREE_CHAIN (field
))
2362 if (TREE_CODE (field
) == TYPE_DECL
2363 && DECL_NAME (field
) == id
)
2366 "(perhaps %<typename %T::%E%> was intended)",
2367 BINFO_TYPE (b
), id
);
2376 /* Here we diagnose qualified-ids where the scope is actually correct,
2377 but the identifier does not resolve to a valid type name. */
2378 else if (parser
->scope
!= error_mark_node
)
2380 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
2381 error ("%H%qE in namespace %qE does not name a type",
2382 &location
, id
, parser
->scope
);
2383 else if (TYPE_P (parser
->scope
))
2384 error ("%H%qE in class %qT does not name a type",
2385 &location
, id
, parser
->scope
);
2389 cp_parser_commit_to_tentative_parse (parser
);
2392 /* Check for a common situation where a type-name should be present,
2393 but is not, and issue a sensible error message. Returns true if an
2394 invalid type-name was detected.
2396 The situation handled by this function are variable declarations of the
2397 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2398 Usually, `ID' should name a type, but if we got here it means that it
2399 does not. We try to emit the best possible error message depending on
2400 how exactly the id-expression looks like. */
2403 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser
*parser
)
2406 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
2408 cp_parser_parse_tentatively (parser
);
2409 id
= cp_parser_id_expression (parser
,
2410 /*template_keyword_p=*/false,
2411 /*check_dependency_p=*/true,
2412 /*template_p=*/NULL
,
2413 /*declarator_p=*/true,
2414 /*optional_p=*/false);
2415 /* After the id-expression, there should be a plain identifier,
2416 otherwise this is not a simple variable declaration. Also, if
2417 the scope is dependent, we cannot do much. */
2418 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
2419 || (parser
->scope
&& TYPE_P (parser
->scope
)
2420 && dependent_type_p (parser
->scope
))
2421 || TREE_CODE (id
) == TYPE_DECL
)
2423 cp_parser_abort_tentative_parse (parser
);
2426 if (!cp_parser_parse_definitely (parser
))
2429 /* Emit a diagnostic for the invalid type. */
2430 cp_parser_diagnose_invalid_type_name (parser
, parser
->scope
,
2431 id
, token
->location
);
2432 /* Skip to the end of the declaration; there's no point in
2433 trying to process it. */
2434 cp_parser_skip_to_end_of_block_or_statement (parser
);
2438 /* Consume tokens up to, and including, the next non-nested closing `)'.
2439 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
2440 are doing error recovery. Returns -1 if OR_COMMA is true and we
2441 found an unnested comma. */
2444 cp_parser_skip_to_closing_parenthesis (cp_parser
*parser
,
2449 unsigned paren_depth
= 0;
2450 unsigned brace_depth
= 0;
2452 if (recovering
&& !or_comma
2453 && cp_parser_uncommitted_to_tentative_parse_p (parser
))
2458 cp_token
* token
= cp_lexer_peek_token (parser
->lexer
);
2460 switch (token
->type
)
2463 case CPP_PRAGMA_EOL
:
2464 /* If we've run out of tokens, then there is no closing `)'. */
2468 /* This matches the processing in skip_to_end_of_statement. */
2473 case CPP_OPEN_BRACE
:
2476 case CPP_CLOSE_BRACE
:
2482 if (recovering
&& or_comma
&& !brace_depth
&& !paren_depth
)
2486 case CPP_OPEN_PAREN
:
2491 case CPP_CLOSE_PAREN
:
2492 if (!brace_depth
&& !paren_depth
--)
2495 cp_lexer_consume_token (parser
->lexer
);
2504 /* Consume the token. */
2505 cp_lexer_consume_token (parser
->lexer
);
2509 /* Consume tokens until we reach the end of the current statement.
2510 Normally, that will be just before consuming a `;'. However, if a
2511 non-nested `}' comes first, then we stop before consuming that. */
2514 cp_parser_skip_to_end_of_statement (cp_parser
* parser
)
2516 unsigned nesting_depth
= 0;
2520 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
2522 switch (token
->type
)
2525 case CPP_PRAGMA_EOL
:
2526 /* If we've run out of tokens, stop. */
2530 /* If the next token is a `;', we have reached the end of the
2536 case CPP_CLOSE_BRACE
:
2537 /* If this is a non-nested '}', stop before consuming it.
2538 That way, when confronted with something like:
2542 we stop before consuming the closing '}', even though we
2543 have not yet reached a `;'. */
2544 if (nesting_depth
== 0)
2547 /* If it is the closing '}' for a block that we have
2548 scanned, stop -- but only after consuming the token.
2554 we will stop after the body of the erroneously declared
2555 function, but before consuming the following `typedef'
2557 if (--nesting_depth
== 0)
2559 cp_lexer_consume_token (parser
->lexer
);
2563 case CPP_OPEN_BRACE
:
2571 /* Consume the token. */
2572 cp_lexer_consume_token (parser
->lexer
);
2576 /* This function is called at the end of a statement or declaration.
2577 If the next token is a semicolon, it is consumed; otherwise, error
2578 recovery is attempted. */
2581 cp_parser_consume_semicolon_at_end_of_statement (cp_parser
*parser
)
2583 /* Look for the trailing `;'. */
2584 if (!cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>"))
2586 /* If there is additional (erroneous) input, skip to the end of
2588 cp_parser_skip_to_end_of_statement (parser
);
2589 /* If the next token is now a `;', consume it. */
2590 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
2591 cp_lexer_consume_token (parser
->lexer
);
2595 /* Skip tokens until we have consumed an entire block, or until we
2596 have consumed a non-nested `;'. */
2599 cp_parser_skip_to_end_of_block_or_statement (cp_parser
* parser
)
2601 int nesting_depth
= 0;
2603 while (nesting_depth
>= 0)
2605 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
2607 switch (token
->type
)
2610 case CPP_PRAGMA_EOL
:
2611 /* If we've run out of tokens, stop. */
2615 /* Stop if this is an unnested ';'. */
2620 case CPP_CLOSE_BRACE
:
2621 /* Stop if this is an unnested '}', or closes the outermost
2628 case CPP_OPEN_BRACE
:
2637 /* Consume the token. */
2638 cp_lexer_consume_token (parser
->lexer
);
2642 /* Skip tokens until a non-nested closing curly brace is the next
2643 token, or there are no more tokens. Return true in the first case,
2647 cp_parser_skip_to_closing_brace (cp_parser
*parser
)
2649 unsigned nesting_depth
= 0;
2653 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
2655 switch (token
->type
)
2658 case CPP_PRAGMA_EOL
:
2659 /* If we've run out of tokens, stop. */
2662 case CPP_CLOSE_BRACE
:
2663 /* If the next token is a non-nested `}', then we have reached
2664 the end of the current block. */
2665 if (nesting_depth
-- == 0)
2669 case CPP_OPEN_BRACE
:
2670 /* If it the next token is a `{', then we are entering a new
2671 block. Consume the entire block. */
2679 /* Consume the token. */
2680 cp_lexer_consume_token (parser
->lexer
);
2684 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
2685 parameter is the PRAGMA token, allowing us to purge the entire pragma
2689 cp_parser_skip_to_pragma_eol (cp_parser
* parser
, cp_token
*pragma_tok
)
2693 parser
->lexer
->in_pragma
= false;
2696 token
= cp_lexer_consume_token (parser
->lexer
);
2697 while (token
->type
!= CPP_PRAGMA_EOL
&& token
->type
!= CPP_EOF
);
2699 /* Ensure that the pragma is not parsed again. */
2700 cp_lexer_purge_tokens_after (parser
->lexer
, pragma_tok
);
2703 /* Require pragma end of line, resyncing with it as necessary. The
2704 arguments are as for cp_parser_skip_to_pragma_eol. */
2707 cp_parser_require_pragma_eol (cp_parser
*parser
, cp_token
*pragma_tok
)
2709 parser
->lexer
->in_pragma
= false;
2710 if (!cp_parser_require (parser
, CPP_PRAGMA_EOL
, "end of line"))
2711 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
2714 /* This is a simple wrapper around make_typename_type. When the id is
2715 an unresolved identifier node, we can provide a superior diagnostic
2716 using cp_parser_diagnose_invalid_type_name. */
2719 cp_parser_make_typename_type (cp_parser
*parser
, tree scope
,
2720 tree id
, location_t id_location
)
2723 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
2725 result
= make_typename_type (scope
, id
, typename_type
,
2726 /*complain=*/tf_none
);
2727 if (result
== error_mark_node
)
2728 cp_parser_diagnose_invalid_type_name (parser
, scope
, id
, id_location
);
2731 return make_typename_type (scope
, id
, typename_type
, tf_error
);
2734 /* This is a wrapper around the
2735 make_{pointer,ptrmem,reference}_declarator functions that decides
2736 which one to call based on the CODE and CLASS_TYPE arguments. The
2737 CODE argument should be one of the values returned by
2738 cp_parser_ptr_operator. */
2739 static cp_declarator
*
2740 cp_parser_make_indirect_declarator (enum tree_code code
, tree class_type
,
2741 cp_cv_quals cv_qualifiers
,
2742 cp_declarator
*target
)
2744 if (code
== ERROR_MARK
)
2745 return cp_error_declarator
;
2747 if (code
== INDIRECT_REF
)
2748 if (class_type
== NULL_TREE
)
2749 return make_pointer_declarator (cv_qualifiers
, target
);
2751 return make_ptrmem_declarator (cv_qualifiers
, class_type
, target
);
2752 else if (code
== ADDR_EXPR
&& class_type
== NULL_TREE
)
2753 return make_reference_declarator (cv_qualifiers
, target
, false);
2754 else if (code
== NON_LVALUE_EXPR
&& class_type
== NULL_TREE
)
2755 return make_reference_declarator (cv_qualifiers
, target
, true);
2759 /* Create a new C++ parser. */
2762 cp_parser_new (void)
2768 /* cp_lexer_new_main is called before calling ggc_alloc because
2769 cp_lexer_new_main might load a PCH file. */
2770 lexer
= cp_lexer_new_main ();
2772 /* Initialize the binops_by_token so that we can get the tree
2773 directly from the token. */
2774 for (i
= 0; i
< sizeof (binops
) / sizeof (binops
[0]); i
++)
2775 binops_by_token
[binops
[i
].token_type
] = binops
[i
];
2777 parser
= GGC_CNEW (cp_parser
);
2778 parser
->lexer
= lexer
;
2779 parser
->context
= cp_parser_context_new (NULL
);
2781 /* For now, we always accept GNU extensions. */
2782 parser
->allow_gnu_extensions_p
= 1;
2784 /* The `>' token is a greater-than operator, not the end of a
2786 parser
->greater_than_is_operator_p
= true;
2788 parser
->default_arg_ok_p
= true;
2790 /* We are not parsing a constant-expression. */
2791 parser
->integral_constant_expression_p
= false;
2792 parser
->allow_non_integral_constant_expression_p
= false;
2793 parser
->non_integral_constant_expression_p
= false;
2795 /* Local variable names are not forbidden. */
2796 parser
->local_variables_forbidden_p
= false;
2798 /* We are not processing an `extern "C"' declaration. */
2799 parser
->in_unbraced_linkage_specification_p
= false;
2801 /* We are not processing a declarator. */
2802 parser
->in_declarator_p
= false;
2804 /* We are not processing a template-argument-list. */
2805 parser
->in_template_argument_list_p
= false;
2807 /* We are not in an iteration statement. */
2808 parser
->in_statement
= 0;
2810 /* We are not in a switch statement. */
2811 parser
->in_switch_statement_p
= false;
2813 /* We are not parsing a type-id inside an expression. */
2814 parser
->in_type_id_in_expr_p
= false;
2816 /* Declarations aren't implicitly extern "C". */
2817 parser
->implicit_extern_c
= false;
2819 /* String literals should be translated to the execution character set. */
2820 parser
->translate_strings_p
= true;
2822 /* We are not parsing a function body. */
2823 parser
->in_function_body
= false;
2825 /* The unparsed function queue is empty. */
2826 parser
->unparsed_functions_queues
= build_tree_list (NULL_TREE
, NULL_TREE
);
2828 /* There are no classes being defined. */
2829 parser
->num_classes_being_defined
= 0;
2831 /* No template parameters apply. */
2832 parser
->num_template_parameter_lists
= 0;
2837 /* Create a cp_lexer structure which will emit the tokens in CACHE
2838 and push it onto the parser's lexer stack. This is used for delayed
2839 parsing of in-class method bodies and default arguments, and should
2840 not be confused with tentative parsing. */
2842 cp_parser_push_lexer_for_tokens (cp_parser
*parser
, cp_token_cache
*cache
)
2844 cp_lexer
*lexer
= cp_lexer_new_from_tokens (cache
);
2845 lexer
->next
= parser
->lexer
;
2846 parser
->lexer
= lexer
;
2848 /* Move the current source position to that of the first token in the
2850 cp_lexer_set_source_position_from_token (lexer
->next_token
);
2853 /* Pop the top lexer off the parser stack. This is never used for the
2854 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
2856 cp_parser_pop_lexer (cp_parser
*parser
)
2858 cp_lexer
*lexer
= parser
->lexer
;
2859 parser
->lexer
= lexer
->next
;
2860 cp_lexer_destroy (lexer
);
2862 /* Put the current source position back where it was before this
2863 lexer was pushed. */
2864 cp_lexer_set_source_position_from_token (parser
->lexer
->next_token
);
2867 /* Lexical conventions [gram.lex] */
2869 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
2873 cp_parser_identifier (cp_parser
* parser
)
2877 /* Look for the identifier. */
2878 token
= cp_parser_require (parser
, CPP_NAME
, "identifier");
2879 /* Return the value. */
2880 return token
? token
->u
.value
: error_mark_node
;
2883 /* Parse a sequence of adjacent string constants. Returns a
2884 TREE_STRING representing the combined, nul-terminated string
2885 constant. If TRANSLATE is true, translate the string to the
2886 execution character set. If WIDE_OK is true, a wide string is
2889 C++98 [lex.string] says that if a narrow string literal token is
2890 adjacent to a wide string literal token, the behavior is undefined.
2891 However, C99 6.4.5p4 says that this results in a wide string literal.
2892 We follow C99 here, for consistency with the C front end.
2894 This code is largely lifted from lex_string() in c-lex.c.
2896 FUTURE: ObjC++ will need to handle @-strings here. */
2898 cp_parser_string_literal (cp_parser
*parser
, bool translate
, bool wide_ok
)
2902 struct obstack str_ob
;
2903 cpp_string str
, istr
, *strs
;
2905 enum cpp_ttype type
;
2907 tok
= cp_lexer_peek_token (parser
->lexer
);
2908 if (!cp_parser_is_string_literal (tok
))
2910 cp_parser_error (parser
, "expected string-literal");
2911 return error_mark_node
;
2916 /* Try to avoid the overhead of creating and destroying an obstack
2917 for the common case of just one string. */
2918 if (!cp_parser_is_string_literal
2919 (cp_lexer_peek_nth_token (parser
->lexer
, 2)))
2921 cp_lexer_consume_token (parser
->lexer
);
2923 str
.text
= (const unsigned char *)TREE_STRING_POINTER (tok
->u
.value
);
2924 str
.len
= TREE_STRING_LENGTH (tok
->u
.value
);
2931 gcc_obstack_init (&str_ob
);
2936 cp_lexer_consume_token (parser
->lexer
);
2938 str
.text
= (const unsigned char *)TREE_STRING_POINTER (tok
->u
.value
);
2939 str
.len
= TREE_STRING_LENGTH (tok
->u
.value
);
2941 if (type
!= tok
->type
)
2943 if (type
== CPP_STRING
)
2945 else if (tok
->type
!= CPP_STRING
)
2946 error ("%Hunsupported non-standard concatenation "
2947 "of string literals", &tok
->location
);
2950 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
2952 tok
= cp_lexer_peek_token (parser
->lexer
);
2954 while (cp_parser_is_string_literal (tok
));
2956 strs
= (cpp_string
*) obstack_finish (&str_ob
);
2959 if (type
!= CPP_STRING
&& !wide_ok
)
2961 cp_parser_error (parser
, "a wide string is invalid in this context");
2965 if ((translate
? cpp_interpret_string
: cpp_interpret_string_notranslate
)
2966 (parse_in
, strs
, count
, &istr
, type
))
2968 value
= build_string (istr
.len
, (const char *)istr
.text
);
2969 free (CONST_CAST (unsigned char *, istr
.text
));
2975 TREE_TYPE (value
) = char_array_type_node
;
2978 TREE_TYPE (value
) = char16_array_type_node
;
2981 TREE_TYPE (value
) = char32_array_type_node
;
2984 TREE_TYPE (value
) = wchar_array_type_node
;
2988 value
= fix_string_type (value
);
2991 /* cpp_interpret_string has issued an error. */
2992 value
= error_mark_node
;
2995 obstack_free (&str_ob
, 0);
3001 /* Basic concepts [gram.basic] */
3003 /* Parse a translation-unit.
3006 declaration-seq [opt]
3008 Returns TRUE if all went well. */
3011 cp_parser_translation_unit (cp_parser
* parser
)
3013 /* The address of the first non-permanent object on the declarator
3015 static void *declarator_obstack_base
;
3019 /* Create the declarator obstack, if necessary. */
3020 if (!cp_error_declarator
)
3022 gcc_obstack_init (&declarator_obstack
);
3023 /* Create the error declarator. */
3024 cp_error_declarator
= make_declarator (cdk_error
);
3025 /* Create the empty parameter list. */
3026 no_parameters
= make_parameter_declarator (NULL
, NULL
, NULL_TREE
);
3027 /* Remember where the base of the declarator obstack lies. */
3028 declarator_obstack_base
= obstack_next_free (&declarator_obstack
);
3031 cp_parser_declaration_seq_opt (parser
);
3033 /* If there are no tokens left then all went well. */
3034 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
3036 /* Get rid of the token array; we don't need it any more. */
3037 cp_lexer_destroy (parser
->lexer
);
3038 parser
->lexer
= NULL
;
3040 /* This file might have been a context that's implicitly extern
3041 "C". If so, pop the lang context. (Only relevant for PCH.) */
3042 if (parser
->implicit_extern_c
)
3044 pop_lang_context ();
3045 parser
->implicit_extern_c
= false;
3049 finish_translation_unit ();
3055 cp_parser_error (parser
, "expected declaration");
3059 /* Make sure the declarator obstack was fully cleaned up. */
3060 gcc_assert (obstack_next_free (&declarator_obstack
)
3061 == declarator_obstack_base
);
3063 /* All went well. */
3067 /* Expressions [gram.expr] */
3069 /* Parse a primary-expression.
3080 ( compound-statement )
3081 __builtin_va_arg ( assignment-expression , type-id )
3082 __builtin_offsetof ( type-id , offsetof-expression )
3085 __has_nothrow_assign ( type-id )
3086 __has_nothrow_constructor ( type-id )
3087 __has_nothrow_copy ( type-id )
3088 __has_trivial_assign ( type-id )
3089 __has_trivial_constructor ( type-id )
3090 __has_trivial_copy ( type-id )
3091 __has_trivial_destructor ( type-id )
3092 __has_virtual_destructor ( type-id )
3093 __is_abstract ( type-id )
3094 __is_base_of ( type-id , type-id )
3095 __is_class ( type-id )
3096 __is_convertible_to ( type-id , type-id )
3097 __is_empty ( type-id )
3098 __is_enum ( type-id )
3099 __is_pod ( type-id )
3100 __is_polymorphic ( type-id )
3101 __is_union ( type-id )
3103 Objective-C++ Extension:
3111 ADDRESS_P is true iff this expression was immediately preceded by
3112 "&" and therefore might denote a pointer-to-member. CAST_P is true
3113 iff this expression is the target of a cast. TEMPLATE_ARG_P is
3114 true iff this expression is a template argument.
3116 Returns a representation of the expression. Upon return, *IDK
3117 indicates what kind of id-expression (if any) was present. */
3120 cp_parser_primary_expression (cp_parser
*parser
,
3123 bool template_arg_p
,
3126 cp_token
*token
= NULL
;
3128 /* Assume the primary expression is not an id-expression. */
3129 *idk
= CP_ID_KIND_NONE
;
3131 /* Peek at the next token. */
3132 token
= cp_lexer_peek_token (parser
->lexer
);
3133 switch (token
->type
)
3146 token
= cp_lexer_consume_token (parser
->lexer
);
3147 /* Floating-point literals are only allowed in an integral
3148 constant expression if they are cast to an integral or
3149 enumeration type. */
3150 if (TREE_CODE (token
->u
.value
) == REAL_CST
3151 && parser
->integral_constant_expression_p
3154 /* CAST_P will be set even in invalid code like "int(2.7 +
3155 ...)". Therefore, we have to check that the next token
3156 is sure to end the cast. */
3159 cp_token
*next_token
;
3161 next_token
= cp_lexer_peek_token (parser
->lexer
);
3162 if (/* The comma at the end of an
3163 enumerator-definition. */
3164 next_token
->type
!= CPP_COMMA
3165 /* The curly brace at the end of an enum-specifier. */
3166 && next_token
->type
!= CPP_CLOSE_BRACE
3167 /* The end of a statement. */
3168 && next_token
->type
!= CPP_SEMICOLON
3169 /* The end of the cast-expression. */
3170 && next_token
->type
!= CPP_CLOSE_PAREN
3171 /* The end of an array bound. */
3172 && next_token
->type
!= CPP_CLOSE_SQUARE
3173 /* The closing ">" in a template-argument-list. */
3174 && (next_token
->type
!= CPP_GREATER
3175 || parser
->greater_than_is_operator_p
)
3176 /* C++0x only: A ">>" treated like two ">" tokens,
3177 in a template-argument-list. */
3178 && (next_token
->type
!= CPP_RSHIFT
3179 || (cxx_dialect
== cxx98
)
3180 || parser
->greater_than_is_operator_p
))
3184 /* If we are within a cast, then the constraint that the
3185 cast is to an integral or enumeration type will be
3186 checked at that point. If we are not within a cast, then
3187 this code is invalid. */
3189 cp_parser_non_integral_constant_expression
3190 (parser
, "floating-point literal");
3192 return token
->u
.value
;
3198 /* ??? Should wide strings be allowed when parser->translate_strings_p
3199 is false (i.e. in attributes)? If not, we can kill the third
3200 argument to cp_parser_string_literal. */
3201 return cp_parser_string_literal (parser
,
3202 parser
->translate_strings_p
,
3205 case CPP_OPEN_PAREN
:
3208 bool saved_greater_than_is_operator_p
;
3210 /* Consume the `('. */
3211 cp_lexer_consume_token (parser
->lexer
);
3212 /* Within a parenthesized expression, a `>' token is always
3213 the greater-than operator. */
3214 saved_greater_than_is_operator_p
3215 = parser
->greater_than_is_operator_p
;
3216 parser
->greater_than_is_operator_p
= true;
3217 /* If we see `( { ' then we are looking at the beginning of
3218 a GNU statement-expression. */
3219 if (cp_parser_allow_gnu_extensions_p (parser
)
3220 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
3222 /* Statement-expressions are not allowed by the standard. */
3223 pedwarn (token
->location
, OPT_pedantic
,
3224 "ISO C++ forbids braced-groups within expressions");
3226 /* And they're not allowed outside of a function-body; you
3227 cannot, for example, write:
3229 int i = ({ int j = 3; j + 1; });
3231 at class or namespace scope. */
3232 if (!parser
->in_function_body
3233 || parser
->in_template_argument_list_p
)
3235 error ("%Hstatement-expressions are not allowed outside "
3236 "functions nor in template-argument lists",
3238 cp_parser_skip_to_end_of_block_or_statement (parser
);
3239 expr
= error_mark_node
;
3243 /* Start the statement-expression. */
3244 expr
= begin_stmt_expr ();
3245 /* Parse the compound-statement. */
3246 cp_parser_compound_statement (parser
, expr
, false);
3248 expr
= finish_stmt_expr (expr
, false);
3253 /* Parse the parenthesized expression. */
3254 expr
= cp_parser_expression (parser
, cast_p
, idk
);
3255 /* Let the front end know that this expression was
3256 enclosed in parentheses. This matters in case, for
3257 example, the expression is of the form `A::B', since
3258 `&A::B' might be a pointer-to-member, but `&(A::B)' is
3260 finish_parenthesized_expr (expr
);
3262 /* The `>' token might be the end of a template-id or
3263 template-parameter-list now. */
3264 parser
->greater_than_is_operator_p
3265 = saved_greater_than_is_operator_p
;
3266 /* Consume the `)'. */
3267 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
3268 cp_parser_skip_to_end_of_statement (parser
);
3274 switch (token
->keyword
)
3276 /* These two are the boolean literals. */
3278 cp_lexer_consume_token (parser
->lexer
);
3279 return boolean_true_node
;
3281 cp_lexer_consume_token (parser
->lexer
);
3282 return boolean_false_node
;
3284 /* The `__null' literal. */
3286 cp_lexer_consume_token (parser
->lexer
);
3289 /* Recognize the `this' keyword. */
3291 cp_lexer_consume_token (parser
->lexer
);
3292 if (parser
->local_variables_forbidden_p
)
3294 error ("%H%<this%> may not be used in this context",
3296 return error_mark_node
;
3298 /* Pointers cannot appear in constant-expressions. */
3299 if (cp_parser_non_integral_constant_expression (parser
, "%<this%>"))
3300 return error_mark_node
;
3301 return finish_this_expr ();
3303 /* The `operator' keyword can be the beginning of an
3308 case RID_FUNCTION_NAME
:
3309 case RID_PRETTY_FUNCTION_NAME
:
3310 case RID_C99_FUNCTION_NAME
:
3314 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
3315 __func__ are the names of variables -- but they are
3316 treated specially. Therefore, they are handled here,
3317 rather than relying on the generic id-expression logic
3318 below. Grammatically, these names are id-expressions.
3320 Consume the token. */
3321 token
= cp_lexer_consume_token (parser
->lexer
);
3323 switch (token
->keyword
)
3325 case RID_FUNCTION_NAME
:
3326 name
= "%<__FUNCTION__%>";
3328 case RID_PRETTY_FUNCTION_NAME
:
3329 name
= "%<__PRETTY_FUNCTION__%>";
3331 case RID_C99_FUNCTION_NAME
:
3332 name
= "%<__func__%>";
3338 if (cp_parser_non_integral_constant_expression (parser
, name
))
3339 return error_mark_node
;
3341 /* Look up the name. */
3342 return finish_fname (token
->u
.value
);
3350 /* The `__builtin_va_arg' construct is used to handle
3351 `va_arg'. Consume the `__builtin_va_arg' token. */
3352 cp_lexer_consume_token (parser
->lexer
);
3353 /* Look for the opening `('. */
3354 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
3355 /* Now, parse the assignment-expression. */
3356 expression
= cp_parser_assignment_expression (parser
,
3357 /*cast_p=*/false, NULL
);
3358 /* Look for the `,'. */
3359 cp_parser_require (parser
, CPP_COMMA
, "%<,%>");
3360 /* Parse the type-id. */
3361 type
= cp_parser_type_id (parser
);
3362 /* Look for the closing `)'. */
3363 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
3364 /* Using `va_arg' in a constant-expression is not
3366 if (cp_parser_non_integral_constant_expression (parser
,
3368 return error_mark_node
;
3369 return build_x_va_arg (expression
, type
);
3373 return cp_parser_builtin_offsetof (parser
);
3375 case RID_HAS_NOTHROW_ASSIGN
:
3376 case RID_HAS_NOTHROW_CONSTRUCTOR
:
3377 case RID_HAS_NOTHROW_COPY
:
3378 case RID_HAS_TRIVIAL_ASSIGN
:
3379 case RID_HAS_TRIVIAL_CONSTRUCTOR
:
3380 case RID_HAS_TRIVIAL_COPY
:
3381 case RID_HAS_TRIVIAL_DESTRUCTOR
:
3382 case RID_HAS_VIRTUAL_DESTRUCTOR
:
3383 case RID_IS_ABSTRACT
:
3384 case RID_IS_BASE_OF
:
3386 case RID_IS_CONVERTIBLE_TO
:
3390 case RID_IS_POLYMORPHIC
:
3392 return cp_parser_trait_expr (parser
, token
->keyword
);
3394 /* Objective-C++ expressions. */
3396 case RID_AT_PROTOCOL
:
3397 case RID_AT_SELECTOR
:
3398 return cp_parser_objc_expression (parser
);
3401 cp_parser_error (parser
, "expected primary-expression");
3402 return error_mark_node
;
3405 /* An id-expression can start with either an identifier, a
3406 `::' as the beginning of a qualified-id, or the "operator"
3410 case CPP_TEMPLATE_ID
:
3411 case CPP_NESTED_NAME_SPECIFIER
:
3415 const char *error_msg
;
3418 cp_token
*id_expr_token
;
3421 /* Parse the id-expression. */
3423 = cp_parser_id_expression (parser
,
3424 /*template_keyword_p=*/false,
3425 /*check_dependency_p=*/true,
3427 /*declarator_p=*/false,
3428 /*optional_p=*/false);
3429 if (id_expression
== error_mark_node
)
3430 return error_mark_node
;
3431 id_expr_token
= token
;
3432 token
= cp_lexer_peek_token (parser
->lexer
);
3433 done
= (token
->type
!= CPP_OPEN_SQUARE
3434 && token
->type
!= CPP_OPEN_PAREN
3435 && token
->type
!= CPP_DOT
3436 && token
->type
!= CPP_DEREF
3437 && token
->type
!= CPP_PLUS_PLUS
3438 && token
->type
!= CPP_MINUS_MINUS
);
3439 /* If we have a template-id, then no further lookup is
3440 required. If the template-id was for a template-class, we
3441 will sometimes have a TYPE_DECL at this point. */
3442 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
3443 || TREE_CODE (id_expression
) == TYPE_DECL
)
3444 decl
= id_expression
;
3445 /* Look up the name. */
3448 tree ambiguous_decls
;
3450 decl
= cp_parser_lookup_name (parser
, id_expression
,
3453 /*is_namespace=*/false,
3454 /*check_dependency=*/true,
3456 id_expr_token
->location
);
3457 /* If the lookup was ambiguous, an error will already have
3459 if (ambiguous_decls
)
3460 return error_mark_node
;
3462 /* In Objective-C++, an instance variable (ivar) may be preferred
3463 to whatever cp_parser_lookup_name() found. */
3464 decl
= objc_lookup_ivar (decl
, id_expression
);
3466 /* If name lookup gives us a SCOPE_REF, then the
3467 qualifying scope was dependent. */
3468 if (TREE_CODE (decl
) == SCOPE_REF
)
3470 /* At this point, we do not know if DECL is a valid
3471 integral constant expression. We assume that it is
3472 in fact such an expression, so that code like:
3474 template <int N> struct A {
3478 is accepted. At template-instantiation time, we
3479 will check that B<N>::i is actually a constant. */
3482 /* Check to see if DECL is a local variable in a context
3483 where that is forbidden. */
3484 if (parser
->local_variables_forbidden_p
3485 && local_variable_p (decl
))
3487 /* It might be that we only found DECL because we are
3488 trying to be generous with pre-ISO scoping rules.
3489 For example, consider:
3493 for (int i = 0; i < 10; ++i) {}
3494 extern void f(int j = i);
3497 Here, name look up will originally find the out
3498 of scope `i'. We need to issue a warning message,
3499 but then use the global `i'. */
3500 decl
= check_for_out_of_scope_variable (decl
);
3501 if (local_variable_p (decl
))
3503 error ("%Hlocal variable %qD may not appear in this context",
3504 &id_expr_token
->location
, decl
);
3505 return error_mark_node
;
3510 decl
= (finish_id_expression
3511 (id_expression
, decl
, parser
->scope
,
3513 parser
->integral_constant_expression_p
,
3514 parser
->allow_non_integral_constant_expression_p
,
3515 &parser
->non_integral_constant_expression_p
,
3516 template_p
, done
, address_p
,
3519 id_expr_token
->location
));
3521 cp_parser_error (parser
, error_msg
);
3525 /* Anything else is an error. */
3527 /* ...unless we have an Objective-C++ message or string literal,
3529 if (c_dialect_objc ()
3530 && (token
->type
== CPP_OPEN_SQUARE
3531 || token
->type
== CPP_OBJC_STRING
))
3532 return cp_parser_objc_expression (parser
);
3534 cp_parser_error (parser
, "expected primary-expression");
3535 return error_mark_node
;
3539 /* Parse an id-expression.
3546 :: [opt] nested-name-specifier template [opt] unqualified-id
3548 :: operator-function-id
3551 Return a representation of the unqualified portion of the
3552 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
3553 a `::' or nested-name-specifier.
3555 Often, if the id-expression was a qualified-id, the caller will
3556 want to make a SCOPE_REF to represent the qualified-id. This
3557 function does not do this in order to avoid wastefully creating
3558 SCOPE_REFs when they are not required.
3560 If TEMPLATE_KEYWORD_P is true, then we have just seen the
3563 If CHECK_DEPENDENCY_P is false, then names are looked up inside
3564 uninstantiated templates.
3566 If *TEMPLATE_P is non-NULL, it is set to true iff the
3567 `template' keyword is used to explicitly indicate that the entity
3568 named is a template.
3570 If DECLARATOR_P is true, the id-expression is appearing as part of
3571 a declarator, rather than as part of an expression. */
3574 cp_parser_id_expression (cp_parser
*parser
,
3575 bool template_keyword_p
,
3576 bool check_dependency_p
,
3581 bool global_scope_p
;
3582 bool nested_name_specifier_p
;
3584 /* Assume the `template' keyword was not used. */
3586 *template_p
= template_keyword_p
;
3588 /* Look for the optional `::' operator. */
3590 = (cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false)
3592 /* Look for the optional nested-name-specifier. */
3593 nested_name_specifier_p
3594 = (cp_parser_nested_name_specifier_opt (parser
,
3595 /*typename_keyword_p=*/false,
3600 /* If there is a nested-name-specifier, then we are looking at
3601 the first qualified-id production. */
3602 if (nested_name_specifier_p
)
3605 tree saved_object_scope
;
3606 tree saved_qualifying_scope
;
3607 tree unqualified_id
;
3610 /* See if the next token is the `template' keyword. */
3612 template_p
= &is_template
;
3613 *template_p
= cp_parser_optional_template_keyword (parser
);
3614 /* Name lookup we do during the processing of the
3615 unqualified-id might obliterate SCOPE. */
3616 saved_scope
= parser
->scope
;
3617 saved_object_scope
= parser
->object_scope
;
3618 saved_qualifying_scope
= parser
->qualifying_scope
;
3619 /* Process the final unqualified-id. */
3620 unqualified_id
= cp_parser_unqualified_id (parser
, *template_p
,
3623 /*optional_p=*/false);
3624 /* Restore the SAVED_SCOPE for our caller. */
3625 parser
->scope
= saved_scope
;
3626 parser
->object_scope
= saved_object_scope
;
3627 parser
->qualifying_scope
= saved_qualifying_scope
;
3629 return unqualified_id
;
3631 /* Otherwise, if we are in global scope, then we are looking at one
3632 of the other qualified-id productions. */
3633 else if (global_scope_p
)
3638 /* Peek at the next token. */
3639 token
= cp_lexer_peek_token (parser
->lexer
);
3641 /* If it's an identifier, and the next token is not a "<", then
3642 we can avoid the template-id case. This is an optimization
3643 for this common case. */
3644 if (token
->type
== CPP_NAME
3645 && !cp_parser_nth_token_starts_template_argument_list_p
3647 return cp_parser_identifier (parser
);
3649 cp_parser_parse_tentatively (parser
);
3650 /* Try a template-id. */
3651 id
= cp_parser_template_id (parser
,
3652 /*template_keyword_p=*/false,
3653 /*check_dependency_p=*/true,
3655 /* If that worked, we're done. */
3656 if (cp_parser_parse_definitely (parser
))
3659 /* Peek at the next token. (Changes in the token buffer may
3660 have invalidated the pointer obtained above.) */
3661 token
= cp_lexer_peek_token (parser
->lexer
);
3663 switch (token
->type
)
3666 return cp_parser_identifier (parser
);
3669 if (token
->keyword
== RID_OPERATOR
)
3670 return cp_parser_operator_function_id (parser
);
3674 cp_parser_error (parser
, "expected id-expression");
3675 return error_mark_node
;
3679 return cp_parser_unqualified_id (parser
, template_keyword_p
,
3680 /*check_dependency_p=*/true,
3685 /* Parse an unqualified-id.
3689 operator-function-id
3690 conversion-function-id
3694 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
3695 keyword, in a construct like `A::template ...'.
3697 Returns a representation of unqualified-id. For the `identifier'
3698 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
3699 production a BIT_NOT_EXPR is returned; the operand of the
3700 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
3701 other productions, see the documentation accompanying the
3702 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
3703 names are looked up in uninstantiated templates. If DECLARATOR_P
3704 is true, the unqualified-id is appearing as part of a declarator,
3705 rather than as part of an expression. */
3708 cp_parser_unqualified_id (cp_parser
* parser
,
3709 bool template_keyword_p
,
3710 bool check_dependency_p
,
3716 /* Peek at the next token. */
3717 token
= cp_lexer_peek_token (parser
->lexer
);
3719 switch (token
->type
)
3725 /* We don't know yet whether or not this will be a
3727 cp_parser_parse_tentatively (parser
);
3728 /* Try a template-id. */
3729 id
= cp_parser_template_id (parser
, template_keyword_p
,
3732 /* If it worked, we're done. */
3733 if (cp_parser_parse_definitely (parser
))
3735 /* Otherwise, it's an ordinary identifier. */
3736 return cp_parser_identifier (parser
);
3739 case CPP_TEMPLATE_ID
:
3740 return cp_parser_template_id (parser
, template_keyword_p
,
3747 tree qualifying_scope
;
3752 /* Consume the `~' token. */
3753 cp_lexer_consume_token (parser
->lexer
);
3754 /* Parse the class-name. The standard, as written, seems to
3757 template <typename T> struct S { ~S (); };
3758 template <typename T> S<T>::~S() {}
3760 is invalid, since `~' must be followed by a class-name, but
3761 `S<T>' is dependent, and so not known to be a class.
3762 That's not right; we need to look in uninstantiated
3763 templates. A further complication arises from:
3765 template <typename T> void f(T t) {
3769 Here, it is not possible to look up `T' in the scope of `T'
3770 itself. We must look in both the current scope, and the
3771 scope of the containing complete expression.
3773 Yet another issue is:
3782 The standard does not seem to say that the `S' in `~S'
3783 should refer to the type `S' and not the data member
3786 /* DR 244 says that we look up the name after the "~" in the
3787 same scope as we looked up the qualifying name. That idea
3788 isn't fully worked out; it's more complicated than that. */
3789 scope
= parser
->scope
;
3790 object_scope
= parser
->object_scope
;
3791 qualifying_scope
= parser
->qualifying_scope
;
3793 /* Check for invalid scopes. */
3794 if (scope
== error_mark_node
)
3796 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
3797 cp_lexer_consume_token (parser
->lexer
);
3798 return error_mark_node
;
3800 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
3802 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
3803 error ("%Hscope %qT before %<~%> is not a class-name",
3804 &token
->location
, scope
);
3805 cp_parser_simulate_error (parser
);
3806 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
3807 cp_lexer_consume_token (parser
->lexer
);
3808 return error_mark_node
;
3810 gcc_assert (!scope
|| TYPE_P (scope
));
3812 /* If the name is of the form "X::~X" it's OK. */
3813 token
= cp_lexer_peek_token (parser
->lexer
);
3815 && token
->type
== CPP_NAME
3816 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
3818 && constructor_name_p (token
->u
.value
, scope
))
3820 cp_lexer_consume_token (parser
->lexer
);
3821 return build_nt (BIT_NOT_EXPR
, scope
);
3824 /* If there was an explicit qualification (S::~T), first look
3825 in the scope given by the qualification (i.e., S). */
3827 type_decl
= NULL_TREE
;
3830 cp_parser_parse_tentatively (parser
);
3831 type_decl
= cp_parser_class_name (parser
,
3832 /*typename_keyword_p=*/false,
3833 /*template_keyword_p=*/false,
3835 /*check_dependency=*/false,
3836 /*class_head_p=*/false,
3838 if (cp_parser_parse_definitely (parser
))
3841 /* In "N::S::~S", look in "N" as well. */
3842 if (!done
&& scope
&& qualifying_scope
)
3844 cp_parser_parse_tentatively (parser
);
3845 parser
->scope
= qualifying_scope
;
3846 parser
->object_scope
= NULL_TREE
;
3847 parser
->qualifying_scope
= NULL_TREE
;
3849 = cp_parser_class_name (parser
,
3850 /*typename_keyword_p=*/false,
3851 /*template_keyword_p=*/false,
3853 /*check_dependency=*/false,
3854 /*class_head_p=*/false,
3856 if (cp_parser_parse_definitely (parser
))
3859 /* In "p->S::~T", look in the scope given by "*p" as well. */
3860 else if (!done
&& object_scope
)
3862 cp_parser_parse_tentatively (parser
);
3863 parser
->scope
= object_scope
;
3864 parser
->object_scope
= NULL_TREE
;
3865 parser
->qualifying_scope
= NULL_TREE
;
3867 = cp_parser_class_name (parser
,
3868 /*typename_keyword_p=*/false,
3869 /*template_keyword_p=*/false,
3871 /*check_dependency=*/false,
3872 /*class_head_p=*/false,
3874 if (cp_parser_parse_definitely (parser
))
3877 /* Look in the surrounding context. */
3880 parser
->scope
= NULL_TREE
;
3881 parser
->object_scope
= NULL_TREE
;
3882 parser
->qualifying_scope
= NULL_TREE
;
3884 = cp_parser_class_name (parser
,
3885 /*typename_keyword_p=*/false,
3886 /*template_keyword_p=*/false,
3888 /*check_dependency=*/false,
3889 /*class_head_p=*/false,
3892 /* If an error occurred, assume that the name of the
3893 destructor is the same as the name of the qualifying
3894 class. That allows us to keep parsing after running
3895 into ill-formed destructor names. */
3896 if (type_decl
== error_mark_node
&& scope
)
3897 return build_nt (BIT_NOT_EXPR
, scope
);
3898 else if (type_decl
== error_mark_node
)
3899 return error_mark_node
;
3901 /* Check that destructor name and scope match. */
3902 if (declarator_p
&& scope
&& !check_dtor_name (scope
, type_decl
))
3904 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
3905 error ("%Hdeclaration of %<~%T%> as member of %qT",
3906 &token
->location
, type_decl
, scope
);
3907 cp_parser_simulate_error (parser
);
3908 return error_mark_node
;
3913 A typedef-name that names a class shall not be used as the
3914 identifier in the declarator for a destructor declaration. */
3916 && !DECL_IMPLICIT_TYPEDEF_P (type_decl
)
3917 && !DECL_SELF_REFERENCE_P (type_decl
)
3918 && !cp_parser_uncommitted_to_tentative_parse_p (parser
))
3919 error ("%Htypedef-name %qD used as destructor declarator",
3920 &token
->location
, type_decl
);
3922 return build_nt (BIT_NOT_EXPR
, TREE_TYPE (type_decl
));
3926 if (token
->keyword
== RID_OPERATOR
)
3930 /* This could be a template-id, so we try that first. */
3931 cp_parser_parse_tentatively (parser
);
3932 /* Try a template-id. */
3933 id
= cp_parser_template_id (parser
, template_keyword_p
,
3934 /*check_dependency_p=*/true,
3936 /* If that worked, we're done. */
3937 if (cp_parser_parse_definitely (parser
))
3939 /* We still don't know whether we're looking at an
3940 operator-function-id or a conversion-function-id. */
3941 cp_parser_parse_tentatively (parser
);
3942 /* Try an operator-function-id. */
3943 id
= cp_parser_operator_function_id (parser
);
3944 /* If that didn't work, try a conversion-function-id. */
3945 if (!cp_parser_parse_definitely (parser
))
3946 id
= cp_parser_conversion_function_id (parser
);
3955 cp_parser_error (parser
, "expected unqualified-id");
3956 return error_mark_node
;
3960 /* Parse an (optional) nested-name-specifier.
3962 nested-name-specifier: [C++98]
3963 class-or-namespace-name :: nested-name-specifier [opt]
3964 class-or-namespace-name :: template nested-name-specifier [opt]
3966 nested-name-specifier: [C++0x]
3969 nested-name-specifier identifier ::
3970 nested-name-specifier template [opt] simple-template-id ::
3972 PARSER->SCOPE should be set appropriately before this function is
3973 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
3974 effect. TYPE_P is TRUE if we non-type bindings should be ignored
3977 Sets PARSER->SCOPE to the class (TYPE) or namespace
3978 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
3979 it unchanged if there is no nested-name-specifier. Returns the new
3980 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
3982 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
3983 part of a declaration and/or decl-specifier. */
3986 cp_parser_nested_name_specifier_opt (cp_parser
*parser
,
3987 bool typename_keyword_p
,
3988 bool check_dependency_p
,
3990 bool is_declaration
)
3992 bool success
= false;
3993 cp_token_position start
= 0;
3996 /* Remember where the nested-name-specifier starts. */
3997 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
3999 start
= cp_lexer_token_position (parser
->lexer
, false);
4000 push_deferring_access_checks (dk_deferred
);
4007 tree saved_qualifying_scope
;
4008 bool template_keyword_p
;
4010 /* Spot cases that cannot be the beginning of a
4011 nested-name-specifier. */
4012 token
= cp_lexer_peek_token (parser
->lexer
);
4014 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
4015 the already parsed nested-name-specifier. */
4016 if (token
->type
== CPP_NESTED_NAME_SPECIFIER
)
4018 /* Grab the nested-name-specifier and continue the loop. */
4019 cp_parser_pre_parsed_nested_name_specifier (parser
);
4020 /* If we originally encountered this nested-name-specifier
4021 with IS_DECLARATION set to false, we will not have
4022 resolved TYPENAME_TYPEs, so we must do so here. */
4024 && TREE_CODE (parser
->scope
) == TYPENAME_TYPE
)
4026 new_scope
= resolve_typename_type (parser
->scope
,
4027 /*only_current_p=*/false);
4028 if (TREE_CODE (new_scope
) != TYPENAME_TYPE
)
4029 parser
->scope
= new_scope
;
4035 /* Spot cases that cannot be the beginning of a
4036 nested-name-specifier. On the second and subsequent times
4037 through the loop, we look for the `template' keyword. */
4038 if (success
&& token
->keyword
== RID_TEMPLATE
)
4040 /* A template-id can start a nested-name-specifier. */
4041 else if (token
->type
== CPP_TEMPLATE_ID
)
4045 /* If the next token is not an identifier, then it is
4046 definitely not a type-name or namespace-name. */
4047 if (token
->type
!= CPP_NAME
)
4049 /* If the following token is neither a `<' (to begin a
4050 template-id), nor a `::', then we are not looking at a
4051 nested-name-specifier. */
4052 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
4053 if (token
->type
!= CPP_SCOPE
4054 && !cp_parser_nth_token_starts_template_argument_list_p
4059 /* The nested-name-specifier is optional, so we parse
4061 cp_parser_parse_tentatively (parser
);
4063 /* Look for the optional `template' keyword, if this isn't the
4064 first time through the loop. */
4066 template_keyword_p
= cp_parser_optional_template_keyword (parser
);
4068 template_keyword_p
= false;
4070 /* Save the old scope since the name lookup we are about to do
4071 might destroy it. */
4072 old_scope
= parser
->scope
;
4073 saved_qualifying_scope
= parser
->qualifying_scope
;
4074 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
4075 look up names in "X<T>::I" in order to determine that "Y" is
4076 a template. So, if we have a typename at this point, we make
4077 an effort to look through it. */
4079 && !typename_keyword_p
4081 && TREE_CODE (parser
->scope
) == TYPENAME_TYPE
)
4082 parser
->scope
= resolve_typename_type (parser
->scope
,
4083 /*only_current_p=*/false);
4084 /* Parse the qualifying entity. */
4086 = cp_parser_qualifying_entity (parser
,
4092 /* Look for the `::' token. */
4093 cp_parser_require (parser
, CPP_SCOPE
, "%<::%>");
4095 /* If we found what we wanted, we keep going; otherwise, we're
4097 if (!cp_parser_parse_definitely (parser
))
4099 bool error_p
= false;
4101 /* Restore the OLD_SCOPE since it was valid before the
4102 failed attempt at finding the last
4103 class-or-namespace-name. */
4104 parser
->scope
= old_scope
;
4105 parser
->qualifying_scope
= saved_qualifying_scope
;
4106 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
4108 /* If the next token is an identifier, and the one after
4109 that is a `::', then any valid interpretation would have
4110 found a class-or-namespace-name. */
4111 while (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
4112 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
4114 && (cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
4117 token
= cp_lexer_consume_token (parser
->lexer
);
4120 if (!token
->ambiguous_p
)
4123 tree ambiguous_decls
;
4125 decl
= cp_parser_lookup_name (parser
, token
->u
.value
,
4127 /*is_template=*/false,
4128 /*is_namespace=*/false,
4129 /*check_dependency=*/true,
4132 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4133 error ("%H%qD used without template parameters",
4134 &token
->location
, decl
);
4135 else if (ambiguous_decls
)
4137 error ("%Hreference to %qD is ambiguous",
4138 &token
->location
, token
->u
.value
);
4139 print_candidates (ambiguous_decls
);
4140 decl
= error_mark_node
;
4144 const char* msg
= "is not a class or namespace";
4145 if (cxx_dialect
!= cxx98
)
4146 msg
= "is not a class, namespace, or enumeration";
4147 cp_parser_name_lookup_error
4148 (parser
, token
->u
.value
, decl
, msg
,
4152 parser
->scope
= error_mark_node
;
4154 /* Treat this as a successful nested-name-specifier
4159 If the name found is not a class-name (clause
4160 _class_) or namespace-name (_namespace.def_), the
4161 program is ill-formed. */
4164 cp_lexer_consume_token (parser
->lexer
);
4168 /* We've found one valid nested-name-specifier. */
4170 /* Name lookup always gives us a DECL. */
4171 if (TREE_CODE (new_scope
) == TYPE_DECL
)
4172 new_scope
= TREE_TYPE (new_scope
);
4173 /* Uses of "template" must be followed by actual templates. */
4174 if (template_keyword_p
4175 && !(CLASS_TYPE_P (new_scope
)
4176 && ((CLASSTYPE_USE_TEMPLATE (new_scope
)
4177 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope
)))
4178 || CLASSTYPE_IS_TEMPLATE (new_scope
)))
4179 && !(TREE_CODE (new_scope
) == TYPENAME_TYPE
4180 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope
))
4181 == TEMPLATE_ID_EXPR
)))
4182 permerror (input_location
, TYPE_P (new_scope
)
4183 ? "%qT is not a template"
4184 : "%qD is not a template",
4186 /* If it is a class scope, try to complete it; we are about to
4187 be looking up names inside the class. */
4188 if (TYPE_P (new_scope
)
4189 /* Since checking types for dependency can be expensive,
4190 avoid doing it if the type is already complete. */
4191 && !COMPLETE_TYPE_P (new_scope
)
4192 /* Do not try to complete dependent types. */
4193 && !dependent_type_p (new_scope
))
4195 new_scope
= complete_type (new_scope
);
4196 /* If it is a typedef to current class, use the current
4197 class instead, as the typedef won't have any names inside
4199 if (!COMPLETE_TYPE_P (new_scope
)
4200 && currently_open_class (new_scope
))
4201 new_scope
= TYPE_MAIN_VARIANT (new_scope
);
4203 /* Make sure we look in the right scope the next time through
4205 parser
->scope
= new_scope
;
4208 /* If parsing tentatively, replace the sequence of tokens that makes
4209 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
4210 token. That way, should we re-parse the token stream, we will
4211 not have to repeat the effort required to do the parse, nor will
4212 we issue duplicate error messages. */
4213 if (success
&& start
)
4217 token
= cp_lexer_token_at (parser
->lexer
, start
);
4218 /* Reset the contents of the START token. */
4219 token
->type
= CPP_NESTED_NAME_SPECIFIER
;
4220 /* Retrieve any deferred checks. Do not pop this access checks yet
4221 so the memory will not be reclaimed during token replacing below. */
4222 token
->u
.tree_check_value
= GGC_CNEW (struct tree_check
);
4223 token
->u
.tree_check_value
->value
= parser
->scope
;
4224 token
->u
.tree_check_value
->checks
= get_deferred_access_checks ();
4225 token
->u
.tree_check_value
->qualifying_scope
=
4226 parser
->qualifying_scope
;
4227 token
->keyword
= RID_MAX
;
4229 /* Purge all subsequent tokens. */
4230 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
4234 pop_to_parent_deferring_access_checks ();
4236 return success
? parser
->scope
: NULL_TREE
;
4239 /* Parse a nested-name-specifier. See
4240 cp_parser_nested_name_specifier_opt for details. This function
4241 behaves identically, except that it will an issue an error if no
4242 nested-name-specifier is present. */
4245 cp_parser_nested_name_specifier (cp_parser
*parser
,
4246 bool typename_keyword_p
,
4247 bool check_dependency_p
,
4249 bool is_declaration
)
4253 /* Look for the nested-name-specifier. */
4254 scope
= cp_parser_nested_name_specifier_opt (parser
,
4259 /* If it was not present, issue an error message. */
4262 cp_parser_error (parser
, "expected nested-name-specifier");
4263 parser
->scope
= NULL_TREE
;
4269 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
4270 this is either a class-name or a namespace-name (which corresponds
4271 to the class-or-namespace-name production in the grammar). For
4272 C++0x, it can also be a type-name that refers to an enumeration
4275 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
4276 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
4277 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
4278 TYPE_P is TRUE iff the next name should be taken as a class-name,
4279 even the same name is declared to be another entity in the same
4282 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
4283 specified by the class-or-namespace-name. If neither is found the
4284 ERROR_MARK_NODE is returned. */
4287 cp_parser_qualifying_entity (cp_parser
*parser
,
4288 bool typename_keyword_p
,
4289 bool template_keyword_p
,
4290 bool check_dependency_p
,
4292 bool is_declaration
)
4295 tree saved_qualifying_scope
;
4296 tree saved_object_scope
;
4299 bool successful_parse_p
;
4301 /* Before we try to parse the class-name, we must save away the
4302 current PARSER->SCOPE since cp_parser_class_name will destroy
4304 saved_scope
= parser
->scope
;
4305 saved_qualifying_scope
= parser
->qualifying_scope
;
4306 saved_object_scope
= parser
->object_scope
;
4307 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
4308 there is no need to look for a namespace-name. */
4309 only_class_p
= template_keyword_p
4310 || (saved_scope
&& TYPE_P (saved_scope
) && cxx_dialect
== cxx98
);
4312 cp_parser_parse_tentatively (parser
);
4313 scope
= cp_parser_class_name (parser
,
4316 type_p
? class_type
: none_type
,
4318 /*class_head_p=*/false,
4320 successful_parse_p
= only_class_p
|| cp_parser_parse_definitely (parser
);
4321 /* If that didn't work and we're in C++0x mode, try for a type-name. */
4323 && cxx_dialect
!= cxx98
4324 && !successful_parse_p
)
4326 /* Restore the saved scope. */
4327 parser
->scope
= saved_scope
;
4328 parser
->qualifying_scope
= saved_qualifying_scope
;
4329 parser
->object_scope
= saved_object_scope
;
4331 /* Parse tentatively. */
4332 cp_parser_parse_tentatively (parser
);
4334 /* Parse a typedef-name or enum-name. */
4335 scope
= cp_parser_nonclass_name (parser
);
4336 successful_parse_p
= cp_parser_parse_definitely (parser
);
4338 /* If that didn't work, try for a namespace-name. */
4339 if (!only_class_p
&& !successful_parse_p
)
4341 /* Restore the saved scope. */
4342 parser
->scope
= saved_scope
;
4343 parser
->qualifying_scope
= saved_qualifying_scope
;
4344 parser
->object_scope
= saved_object_scope
;
4345 /* If we are not looking at an identifier followed by the scope
4346 resolution operator, then this is not part of a
4347 nested-name-specifier. (Note that this function is only used
4348 to parse the components of a nested-name-specifier.) */
4349 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
)
4350 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
)
4351 return error_mark_node
;
4352 scope
= cp_parser_namespace_name (parser
);
4358 /* Parse a postfix-expression.
4362 postfix-expression [ expression ]
4363 postfix-expression ( expression-list [opt] )
4364 simple-type-specifier ( expression-list [opt] )
4365 typename :: [opt] nested-name-specifier identifier
4366 ( expression-list [opt] )
4367 typename :: [opt] nested-name-specifier template [opt] template-id
4368 ( expression-list [opt] )
4369 postfix-expression . template [opt] id-expression
4370 postfix-expression -> template [opt] id-expression
4371 postfix-expression . pseudo-destructor-name
4372 postfix-expression -> pseudo-destructor-name
4373 postfix-expression ++
4374 postfix-expression --
4375 dynamic_cast < type-id > ( expression )
4376 static_cast < type-id > ( expression )
4377 reinterpret_cast < type-id > ( expression )
4378 const_cast < type-id > ( expression )
4379 typeid ( expression )
4385 ( type-id ) { initializer-list , [opt] }
4387 This extension is a GNU version of the C99 compound-literal
4388 construct. (The C99 grammar uses `type-name' instead of `type-id',
4389 but they are essentially the same concept.)
4391 If ADDRESS_P is true, the postfix expression is the operand of the
4392 `&' operator. CAST_P is true if this expression is the target of a
4395 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
4396 class member access expressions [expr.ref].
4398 Returns a representation of the expression. */
4401 cp_parser_postfix_expression (cp_parser
*parser
, bool address_p
, bool cast_p
,
4402 bool member_access_only_p
,
4403 cp_id_kind
* pidk_return
)
4407 cp_id_kind idk
= CP_ID_KIND_NONE
;
4408 tree postfix_expression
= NULL_TREE
;
4409 bool is_member_access
= false;
4411 /* Peek at the next token. */
4412 token
= cp_lexer_peek_token (parser
->lexer
);
4413 /* Some of the productions are determined by keywords. */
4414 keyword
= token
->keyword
;
4424 const char *saved_message
;
4426 /* All of these can be handled in the same way from the point
4427 of view of parsing. Begin by consuming the token
4428 identifying the cast. */
4429 cp_lexer_consume_token (parser
->lexer
);
4431 /* New types cannot be defined in the cast. */
4432 saved_message
= parser
->type_definition_forbidden_message
;
4433 parser
->type_definition_forbidden_message
4434 = "types may not be defined in casts";
4436 /* Look for the opening `<'. */
4437 cp_parser_require (parser
, CPP_LESS
, "%<<%>");
4438 /* Parse the type to which we are casting. */
4439 type
= cp_parser_type_id (parser
);
4440 /* Look for the closing `>'. */
4441 cp_parser_require (parser
, CPP_GREATER
, "%<>%>");
4442 /* Restore the old message. */
4443 parser
->type_definition_forbidden_message
= saved_message
;
4445 /* And the expression which is being cast. */
4446 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
4447 expression
= cp_parser_expression (parser
, /*cast_p=*/true, & idk
);
4448 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
4450 /* Only type conversions to integral or enumeration types
4451 can be used in constant-expressions. */
4452 if (!cast_valid_in_integral_constant_expression_p (type
)
4453 && (cp_parser_non_integral_constant_expression
4455 "a cast to a type other than an integral or "
4456 "enumeration type")))
4457 return error_mark_node
;
4463 = build_dynamic_cast (type
, expression
, tf_warning_or_error
);
4467 = build_static_cast (type
, expression
, tf_warning_or_error
);
4471 = build_reinterpret_cast (type
, expression
,
4472 tf_warning_or_error
);
4476 = build_const_cast (type
, expression
, tf_warning_or_error
);
4487 const char *saved_message
;
4488 bool saved_in_type_id_in_expr_p
;
4490 /* Consume the `typeid' token. */
4491 cp_lexer_consume_token (parser
->lexer
);
4492 /* Look for the `(' token. */
4493 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
4494 /* Types cannot be defined in a `typeid' expression. */
4495 saved_message
= parser
->type_definition_forbidden_message
;
4496 parser
->type_definition_forbidden_message
4497 = "types may not be defined in a %<typeid%> expression";
4498 /* We can't be sure yet whether we're looking at a type-id or an
4500 cp_parser_parse_tentatively (parser
);
4501 /* Try a type-id first. */
4502 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
4503 parser
->in_type_id_in_expr_p
= true;
4504 type
= cp_parser_type_id (parser
);
4505 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
4506 /* Look for the `)' token. Otherwise, we can't be sure that
4507 we're not looking at an expression: consider `typeid (int
4508 (3))', for example. */
4509 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
4510 /* If all went well, simply lookup the type-id. */
4511 if (cp_parser_parse_definitely (parser
))
4512 postfix_expression
= get_typeid (type
);
4513 /* Otherwise, fall back to the expression variant. */
4518 /* Look for an expression. */
4519 expression
= cp_parser_expression (parser
, /*cast_p=*/false, & idk
);
4520 /* Compute its typeid. */
4521 postfix_expression
= build_typeid (expression
);
4522 /* Look for the `)' token. */
4523 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
4525 /* Restore the saved message. */
4526 parser
->type_definition_forbidden_message
= saved_message
;
4527 /* `typeid' may not appear in an integral constant expression. */
4528 if (cp_parser_non_integral_constant_expression(parser
,
4529 "%<typeid%> operator"))
4530 return error_mark_node
;
4537 /* The syntax permitted here is the same permitted for an
4538 elaborated-type-specifier. */
4539 type
= cp_parser_elaborated_type_specifier (parser
,
4540 /*is_friend=*/false,
4541 /*is_declaration=*/false);
4542 postfix_expression
= cp_parser_functional_cast (parser
, type
);
4550 /* If the next thing is a simple-type-specifier, we may be
4551 looking at a functional cast. We could also be looking at
4552 an id-expression. So, we try the functional cast, and if
4553 that doesn't work we fall back to the primary-expression. */
4554 cp_parser_parse_tentatively (parser
);
4555 /* Look for the simple-type-specifier. */
4556 type
= cp_parser_simple_type_specifier (parser
,
4557 /*decl_specs=*/NULL
,
4558 CP_PARSER_FLAGS_NONE
);
4559 /* Parse the cast itself. */
4560 if (!cp_parser_error_occurred (parser
))
4562 = cp_parser_functional_cast (parser
, type
);
4563 /* If that worked, we're done. */
4564 if (cp_parser_parse_definitely (parser
))
4567 /* If the functional-cast didn't work out, try a
4568 compound-literal. */
4569 if (cp_parser_allow_gnu_extensions_p (parser
)
4570 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
4572 VEC(constructor_elt
,gc
) *initializer_list
= NULL
;
4573 bool saved_in_type_id_in_expr_p
;
4575 cp_parser_parse_tentatively (parser
);
4576 /* Consume the `('. */
4577 cp_lexer_consume_token (parser
->lexer
);
4578 /* Parse the type. */
4579 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
4580 parser
->in_type_id_in_expr_p
= true;
4581 type
= cp_parser_type_id (parser
);
4582 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
4583 /* Look for the `)'. */
4584 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
4585 /* Look for the `{'. */
4586 cp_parser_require (parser
, CPP_OPEN_BRACE
, "%<{%>");
4587 /* If things aren't going well, there's no need to
4589 if (!cp_parser_error_occurred (parser
))
4591 bool non_constant_p
;
4592 /* Parse the initializer-list. */
4594 = cp_parser_initializer_list (parser
, &non_constant_p
);
4595 /* Allow a trailing `,'. */
4596 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
4597 cp_lexer_consume_token (parser
->lexer
);
4598 /* Look for the final `}'. */
4599 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
4601 /* If that worked, we're definitely looking at a
4602 compound-literal expression. */
4603 if (cp_parser_parse_definitely (parser
))
4605 /* Warn the user that a compound literal is not
4606 allowed in standard C++. */
4607 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids compound-literals");
4608 /* For simplicity, we disallow compound literals in
4609 constant-expressions. We could
4610 allow compound literals of integer type, whose
4611 initializer was a constant, in constant
4612 expressions. Permitting that usage, as a further
4613 extension, would not change the meaning of any
4614 currently accepted programs. (Of course, as
4615 compound literals are not part of ISO C++, the
4616 standard has nothing to say.) */
4617 if (cp_parser_non_integral_constant_expression
4618 (parser
, "non-constant compound literals"))
4620 postfix_expression
= error_mark_node
;
4623 /* Form the representation of the compound-literal. */
4625 = (finish_compound_literal
4626 (type
, build_constructor (init_list_type_node
,
4627 initializer_list
)));
4632 /* It must be a primary-expression. */
4634 = cp_parser_primary_expression (parser
, address_p
, cast_p
,
4635 /*template_arg_p=*/false,
4641 /* Keep looping until the postfix-expression is complete. */
4644 if (idk
== CP_ID_KIND_UNQUALIFIED
4645 && TREE_CODE (postfix_expression
) == IDENTIFIER_NODE
4646 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
))
4647 /* It is not a Koenig lookup function call. */
4649 = unqualified_name_lookup_error (postfix_expression
);
4651 /* Peek at the next token. */
4652 token
= cp_lexer_peek_token (parser
->lexer
);
4654 switch (token
->type
)
4656 case CPP_OPEN_SQUARE
:
4658 = cp_parser_postfix_open_square_expression (parser
,
4661 idk
= CP_ID_KIND_NONE
;
4662 is_member_access
= false;
4665 case CPP_OPEN_PAREN
:
4666 /* postfix-expression ( expression-list [opt] ) */
4669 bool is_builtin_constant_p
;
4670 bool saved_integral_constant_expression_p
= false;
4671 bool saved_non_integral_constant_expression_p
= false;
4674 is_member_access
= false;
4676 is_builtin_constant_p
4677 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression
);
4678 if (is_builtin_constant_p
)
4680 /* The whole point of __builtin_constant_p is to allow
4681 non-constant expressions to appear as arguments. */
4682 saved_integral_constant_expression_p
4683 = parser
->integral_constant_expression_p
;
4684 saved_non_integral_constant_expression_p
4685 = parser
->non_integral_constant_expression_p
;
4686 parser
->integral_constant_expression_p
= false;
4688 args
= (cp_parser_parenthesized_expression_list
4689 (parser
, /*is_attribute_list=*/false,
4690 /*cast_p=*/false, /*allow_expansion_p=*/true,
4691 /*non_constant_p=*/NULL
));
4692 if (is_builtin_constant_p
)
4694 parser
->integral_constant_expression_p
4695 = saved_integral_constant_expression_p
;
4696 parser
->non_integral_constant_expression_p
4697 = saved_non_integral_constant_expression_p
;
4700 if (args
== error_mark_node
)
4702 postfix_expression
= error_mark_node
;
4706 /* Function calls are not permitted in
4707 constant-expressions. */
4708 if (! builtin_valid_in_constant_expr_p (postfix_expression
)
4709 && cp_parser_non_integral_constant_expression (parser
,
4712 postfix_expression
= error_mark_node
;
4717 if (idk
== CP_ID_KIND_UNQUALIFIED
)
4719 if (TREE_CODE (postfix_expression
) == IDENTIFIER_NODE
)
4725 = perform_koenig_lookup (postfix_expression
, args
);
4729 = unqualified_fn_lookup_error (postfix_expression
);
4731 /* We do not perform argument-dependent lookup if
4732 normal lookup finds a non-function, in accordance
4733 with the expected resolution of DR 218. */
4734 else if (args
&& is_overloaded_fn (postfix_expression
))
4736 tree fn
= get_first_fn (postfix_expression
);
4738 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
4739 fn
= OVL_CURRENT (TREE_OPERAND (fn
, 0));
4741 /* Only do argument dependent lookup if regular
4742 lookup does not find a set of member functions.
4743 [basic.lookup.koenig]/2a */
4744 if (!DECL_FUNCTION_MEMBER_P (fn
))
4748 = perform_koenig_lookup (postfix_expression
, args
);
4753 if (TREE_CODE (postfix_expression
) == COMPONENT_REF
)
4755 tree instance
= TREE_OPERAND (postfix_expression
, 0);
4756 tree fn
= TREE_OPERAND (postfix_expression
, 1);
4758 if (processing_template_decl
4759 && (type_dependent_expression_p (instance
)
4760 || (!BASELINK_P (fn
)
4761 && TREE_CODE (fn
) != FIELD_DECL
)
4762 || type_dependent_expression_p (fn
)
4763 || any_type_dependent_arguments_p (args
)))
4766 = build_nt_call_list (postfix_expression
, args
);
4770 if (BASELINK_P (fn
))
4773 = (build_new_method_call
4774 (instance
, fn
, args
, NULL_TREE
,
4775 (idk
== CP_ID_KIND_QUALIFIED
4776 ? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
),
4778 tf_warning_or_error
));
4782 = finish_call_expr (postfix_expression
, args
,
4783 /*disallow_virtual=*/false,
4785 tf_warning_or_error
);
4787 else if (TREE_CODE (postfix_expression
) == OFFSET_REF
4788 || TREE_CODE (postfix_expression
) == MEMBER_REF
4789 || TREE_CODE (postfix_expression
) == DOTSTAR_EXPR
)
4790 postfix_expression
= (build_offset_ref_call_from_tree
4791 (postfix_expression
, args
));
4792 else if (idk
== CP_ID_KIND_QUALIFIED
)
4793 /* A call to a static class member, or a namespace-scope
4796 = finish_call_expr (postfix_expression
, args
,
4797 /*disallow_virtual=*/true,
4799 tf_warning_or_error
);
4801 /* All other function calls. */
4803 = finish_call_expr (postfix_expression
, args
,
4804 /*disallow_virtual=*/false,
4806 tf_warning_or_error
);
4808 if (warn_disallowed_functions
)
4809 warn_if_disallowed_function_p (postfix_expression
);
4811 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
4812 idk
= CP_ID_KIND_NONE
;
4818 /* postfix-expression . template [opt] id-expression
4819 postfix-expression . pseudo-destructor-name
4820 postfix-expression -> template [opt] id-expression
4821 postfix-expression -> pseudo-destructor-name */
4823 /* Consume the `.' or `->' operator. */
4824 cp_lexer_consume_token (parser
->lexer
);
4827 = cp_parser_postfix_dot_deref_expression (parser
, token
->type
,
4832 is_member_access
= true;
4836 /* postfix-expression ++ */
4837 /* Consume the `++' token. */
4838 cp_lexer_consume_token (parser
->lexer
);
4839 /* Generate a representation for the complete expression. */
4841 = finish_increment_expr (postfix_expression
,
4842 POSTINCREMENT_EXPR
);
4843 /* Increments may not appear in constant-expressions. */
4844 if (cp_parser_non_integral_constant_expression (parser
,
4846 postfix_expression
= error_mark_node
;
4847 idk
= CP_ID_KIND_NONE
;
4848 is_member_access
= false;
4851 case CPP_MINUS_MINUS
:
4852 /* postfix-expression -- */
4853 /* Consume the `--' token. */
4854 cp_lexer_consume_token (parser
->lexer
);
4855 /* Generate a representation for the complete expression. */
4857 = finish_increment_expr (postfix_expression
,
4858 POSTDECREMENT_EXPR
);
4859 /* Decrements may not appear in constant-expressions. */
4860 if (cp_parser_non_integral_constant_expression (parser
,
4862 postfix_expression
= error_mark_node
;
4863 idk
= CP_ID_KIND_NONE
;
4864 is_member_access
= false;
4868 if (pidk_return
!= NULL
)
4869 * pidk_return
= idk
;
4870 if (member_access_only_p
)
4871 return is_member_access
? postfix_expression
: error_mark_node
;
4873 return postfix_expression
;
4877 /* We should never get here. */
4879 return error_mark_node
;
4882 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
4883 by cp_parser_builtin_offsetof. We're looking for
4885 postfix-expression [ expression ]
4887 FOR_OFFSETOF is set if we're being called in that context, which
4888 changes how we deal with integer constant expressions. */
4891 cp_parser_postfix_open_square_expression (cp_parser
*parser
,
4892 tree postfix_expression
,
4897 /* Consume the `[' token. */
4898 cp_lexer_consume_token (parser
->lexer
);
4900 /* Parse the index expression. */
4901 /* ??? For offsetof, there is a question of what to allow here. If
4902 offsetof is not being used in an integral constant expression context,
4903 then we *could* get the right answer by computing the value at runtime.
4904 If we are in an integral constant expression context, then we might
4905 could accept any constant expression; hard to say without analysis.
4906 Rather than open the barn door too wide right away, allow only integer
4907 constant expressions here. */
4909 index
= cp_parser_constant_expression (parser
, false, NULL
);
4911 index
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
4913 /* Look for the closing `]'. */
4914 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>");
4916 /* Build the ARRAY_REF. */
4917 postfix_expression
= grok_array_decl (postfix_expression
, index
);
4919 /* When not doing offsetof, array references are not permitted in
4920 constant-expressions. */
4922 && (cp_parser_non_integral_constant_expression
4923 (parser
, "an array reference")))
4924 postfix_expression
= error_mark_node
;
4926 return postfix_expression
;
4929 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
4930 by cp_parser_builtin_offsetof. We're looking for
4932 postfix-expression . template [opt] id-expression
4933 postfix-expression . pseudo-destructor-name
4934 postfix-expression -> template [opt] id-expression
4935 postfix-expression -> pseudo-destructor-name
4937 FOR_OFFSETOF is set if we're being called in that context. That sorta
4938 limits what of the above we'll actually accept, but nevermind.
4939 TOKEN_TYPE is the "." or "->" token, which will already have been
4940 removed from the stream. */
4943 cp_parser_postfix_dot_deref_expression (cp_parser
*parser
,
4944 enum cpp_ttype token_type
,
4945 tree postfix_expression
,
4946 bool for_offsetof
, cp_id_kind
*idk
,
4947 location_t location
)
4951 bool pseudo_destructor_p
;
4952 tree scope
= NULL_TREE
;
4954 /* If this is a `->' operator, dereference the pointer. */
4955 if (token_type
== CPP_DEREF
)
4956 postfix_expression
= build_x_arrow (postfix_expression
);
4957 /* Check to see whether or not the expression is type-dependent. */
4958 dependent_p
= type_dependent_expression_p (postfix_expression
);
4959 /* The identifier following the `->' or `.' is not qualified. */
4960 parser
->scope
= NULL_TREE
;
4961 parser
->qualifying_scope
= NULL_TREE
;
4962 parser
->object_scope
= NULL_TREE
;
4963 *idk
= CP_ID_KIND_NONE
;
4965 /* Enter the scope corresponding to the type of the object
4966 given by the POSTFIX_EXPRESSION. */
4967 if (!dependent_p
&& TREE_TYPE (postfix_expression
) != NULL_TREE
)
4969 scope
= TREE_TYPE (postfix_expression
);
4970 /* According to the standard, no expression should ever have
4971 reference type. Unfortunately, we do not currently match
4972 the standard in this respect in that our internal representation
4973 of an expression may have reference type even when the standard
4974 says it does not. Therefore, we have to manually obtain the
4975 underlying type here. */
4976 scope
= non_reference (scope
);
4977 /* The type of the POSTFIX_EXPRESSION must be complete. */
4978 if (scope
== unknown_type_node
)
4980 error ("%H%qE does not have class type", &location
, postfix_expression
);
4984 scope
= complete_type_or_else (scope
, NULL_TREE
);
4985 /* Let the name lookup machinery know that we are processing a
4986 class member access expression. */
4987 parser
->context
->object_type
= scope
;
4988 /* If something went wrong, we want to be able to discern that case,
4989 as opposed to the case where there was no SCOPE due to the type
4990 of expression being dependent. */
4992 scope
= error_mark_node
;
4993 /* If the SCOPE was erroneous, make the various semantic analysis
4994 functions exit quickly -- and without issuing additional error
4996 if (scope
== error_mark_node
)
4997 postfix_expression
= error_mark_node
;
5000 /* Assume this expression is not a pseudo-destructor access. */
5001 pseudo_destructor_p
= false;
5003 /* If the SCOPE is a scalar type, then, if this is a valid program,
5004 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
5005 is type dependent, it can be pseudo-destructor-name or something else.
5006 Try to parse it as pseudo-destructor-name first. */
5007 if ((scope
&& SCALAR_TYPE_P (scope
)) || dependent_p
)
5012 cp_parser_parse_tentatively (parser
);
5013 /* Parse the pseudo-destructor-name. */
5015 cp_parser_pseudo_destructor_name (parser
, &s
, &type
);
5017 && (cp_parser_error_occurred (parser
)
5018 || TREE_CODE (type
) != TYPE_DECL
5019 || !SCALAR_TYPE_P (TREE_TYPE (type
))))
5020 cp_parser_abort_tentative_parse (parser
);
5021 else if (cp_parser_parse_definitely (parser
))
5023 pseudo_destructor_p
= true;
5025 = finish_pseudo_destructor_expr (postfix_expression
,
5026 s
, TREE_TYPE (type
));
5030 if (!pseudo_destructor_p
)
5032 /* If the SCOPE is not a scalar type, we are looking at an
5033 ordinary class member access expression, rather than a
5034 pseudo-destructor-name. */
5036 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
5037 /* Parse the id-expression. */
5038 name
= (cp_parser_id_expression
5040 cp_parser_optional_template_keyword (parser
),
5041 /*check_dependency_p=*/true,
5043 /*declarator_p=*/false,
5044 /*optional_p=*/false));
5045 /* In general, build a SCOPE_REF if the member name is qualified.
5046 However, if the name was not dependent and has already been
5047 resolved; there is no need to build the SCOPE_REF. For example;
5049 struct X { void f(); };
5050 template <typename T> void f(T* t) { t->X::f(); }
5052 Even though "t" is dependent, "X::f" is not and has been resolved
5053 to a BASELINK; there is no need to include scope information. */
5055 /* But we do need to remember that there was an explicit scope for
5056 virtual function calls. */
5058 *idk
= CP_ID_KIND_QUALIFIED
;
5060 /* If the name is a template-id that names a type, we will get a
5061 TYPE_DECL here. That is invalid code. */
5062 if (TREE_CODE (name
) == TYPE_DECL
)
5064 error ("%Hinvalid use of %qD", &token
->location
, name
);
5065 postfix_expression
= error_mark_node
;
5069 if (name
!= error_mark_node
&& !BASELINK_P (name
) && parser
->scope
)
5071 name
= build_qualified_name (/*type=*/NULL_TREE
,
5075 parser
->scope
= NULL_TREE
;
5076 parser
->qualifying_scope
= NULL_TREE
;
5077 parser
->object_scope
= NULL_TREE
;
5079 if (scope
&& name
&& BASELINK_P (name
))
5080 adjust_result_of_qualified_name_lookup
5081 (name
, BINFO_TYPE (BASELINK_ACCESS_BINFO (name
)), scope
);
5083 = finish_class_member_access_expr (postfix_expression
, name
,
5085 tf_warning_or_error
);
5089 /* We no longer need to look up names in the scope of the object on
5090 the left-hand side of the `.' or `->' operator. */
5091 parser
->context
->object_type
= NULL_TREE
;
5093 /* Outside of offsetof, these operators may not appear in
5094 constant-expressions. */
5096 && (cp_parser_non_integral_constant_expression
5097 (parser
, token_type
== CPP_DEREF
? "%<->%>" : "%<.%>")))
5098 postfix_expression
= error_mark_node
;
5100 return postfix_expression
;
5103 /* Parse a parenthesized expression-list.
5106 assignment-expression
5107 expression-list, assignment-expression
5112 identifier, expression-list
5114 CAST_P is true if this expression is the target of a cast.
5116 ALLOW_EXPANSION_P is true if this expression allows expansion of an
5119 Returns a TREE_LIST. The TREE_VALUE of each node is a
5120 representation of an assignment-expression. Note that a TREE_LIST
5121 is returned even if there is only a single expression in the list.
5122 error_mark_node is returned if the ( and or ) are
5123 missing. NULL_TREE is returned on no expressions. The parentheses
5124 are eaten. IS_ATTRIBUTE_LIST is true if this is really an attribute
5125 list being parsed. If NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P
5126 indicates whether or not all of the expressions in the list were
5130 cp_parser_parenthesized_expression_list (cp_parser
* parser
,
5131 bool is_attribute_list
,
5133 bool allow_expansion_p
,
5134 bool *non_constant_p
)
5136 tree expression_list
= NULL_TREE
;
5137 bool fold_expr_p
= is_attribute_list
;
5138 tree identifier
= NULL_TREE
;
5139 bool saved_greater_than_is_operator_p
;
5141 /* Assume all the expressions will be constant. */
5143 *non_constant_p
= false;
5145 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
5146 return error_mark_node
;
5148 /* Within a parenthesized expression, a `>' token is always
5149 the greater-than operator. */
5150 saved_greater_than_is_operator_p
5151 = parser
->greater_than_is_operator_p
;
5152 parser
->greater_than_is_operator_p
= true;
5154 /* Consume expressions until there are no more. */
5155 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
5160 /* At the beginning of attribute lists, check to see if the
5161 next token is an identifier. */
5162 if (is_attribute_list
5163 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_NAME
)
5167 /* Consume the identifier. */
5168 token
= cp_lexer_consume_token (parser
->lexer
);
5169 /* Save the identifier. */
5170 identifier
= token
->u
.value
;
5174 bool expr_non_constant_p
;
5176 /* Parse the next assignment-expression. */
5177 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
5179 /* A braced-init-list. */
5180 maybe_warn_cpp0x ("extended initializer lists");
5181 expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
5182 if (non_constant_p
&& expr_non_constant_p
)
5183 *non_constant_p
= true;
5185 else if (non_constant_p
)
5187 expr
= (cp_parser_constant_expression
5188 (parser
, /*allow_non_constant_p=*/true,
5189 &expr_non_constant_p
));
5190 if (expr_non_constant_p
)
5191 *non_constant_p
= true;
5194 expr
= cp_parser_assignment_expression (parser
, cast_p
, NULL
);
5197 expr
= fold_non_dependent_expr (expr
);
5199 /* If we have an ellipsis, then this is an expression
5201 if (allow_expansion_p
5202 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
5204 /* Consume the `...'. */
5205 cp_lexer_consume_token (parser
->lexer
);
5207 /* Build the argument pack. */
5208 expr
= make_pack_expansion (expr
);
5211 /* Add it to the list. We add error_mark_node
5212 expressions to the list, so that we can still tell if
5213 the correct form for a parenthesized expression-list
5214 is found. That gives better errors. */
5215 expression_list
= tree_cons (NULL_TREE
, expr
, expression_list
);
5217 if (expr
== error_mark_node
)
5221 /* After the first item, attribute lists look the same as
5222 expression lists. */
5223 is_attribute_list
= false;
5226 /* If the next token isn't a `,', then we are done. */
5227 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
5230 /* Otherwise, consume the `,' and keep going. */
5231 cp_lexer_consume_token (parser
->lexer
);
5234 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
5239 /* We try and resync to an unnested comma, as that will give the
5240 user better diagnostics. */
5241 ending
= cp_parser_skip_to_closing_parenthesis (parser
,
5242 /*recovering=*/true,
5244 /*consume_paren=*/true);
5249 parser
->greater_than_is_operator_p
5250 = saved_greater_than_is_operator_p
;
5251 return error_mark_node
;
5255 parser
->greater_than_is_operator_p
5256 = saved_greater_than_is_operator_p
;
5258 /* We built up the list in reverse order so we must reverse it now. */
5259 expression_list
= nreverse (expression_list
);
5261 expression_list
= tree_cons (NULL_TREE
, identifier
, expression_list
);
5263 return expression_list
;
5266 /* Parse a pseudo-destructor-name.
5268 pseudo-destructor-name:
5269 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
5270 :: [opt] nested-name-specifier template template-id :: ~ type-name
5271 :: [opt] nested-name-specifier [opt] ~ type-name
5273 If either of the first two productions is used, sets *SCOPE to the
5274 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
5275 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
5276 or ERROR_MARK_NODE if the parse fails. */
5279 cp_parser_pseudo_destructor_name (cp_parser
* parser
,
5283 bool nested_name_specifier_p
;
5285 /* Assume that things will not work out. */
5286 *type
= error_mark_node
;
5288 /* Look for the optional `::' operator. */
5289 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/true);
5290 /* Look for the optional nested-name-specifier. */
5291 nested_name_specifier_p
5292 = (cp_parser_nested_name_specifier_opt (parser
,
5293 /*typename_keyword_p=*/false,
5294 /*check_dependency_p=*/true,
5296 /*is_declaration=*/false)
5298 /* Now, if we saw a nested-name-specifier, we might be doing the
5299 second production. */
5300 if (nested_name_specifier_p
5301 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
5303 /* Consume the `template' keyword. */
5304 cp_lexer_consume_token (parser
->lexer
);
5305 /* Parse the template-id. */
5306 cp_parser_template_id (parser
,
5307 /*template_keyword_p=*/true,
5308 /*check_dependency_p=*/false,
5309 /*is_declaration=*/true);
5310 /* Look for the `::' token. */
5311 cp_parser_require (parser
, CPP_SCOPE
, "%<::%>");
5313 /* If the next token is not a `~', then there might be some
5314 additional qualification. */
5315 else if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMPL
))
5317 /* At this point, we're looking for "type-name :: ~". The type-name
5318 must not be a class-name, since this is a pseudo-destructor. So,
5319 it must be either an enum-name, or a typedef-name -- both of which
5320 are just identifiers. So, we peek ahead to check that the "::"
5321 and "~" tokens are present; if they are not, then we can avoid
5322 calling type_name. */
5323 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_NAME
5324 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
5325 || cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
!= CPP_COMPL
)
5327 cp_parser_error (parser
, "non-scalar type");
5331 /* Look for the type-name. */
5332 *scope
= TREE_TYPE (cp_parser_nonclass_name (parser
));
5333 if (*scope
== error_mark_node
)
5336 /* Look for the `::' token. */
5337 cp_parser_require (parser
, CPP_SCOPE
, "%<::%>");
5342 /* Look for the `~'. */
5343 cp_parser_require (parser
, CPP_COMPL
, "%<~%>");
5344 /* Look for the type-name again. We are not responsible for
5345 checking that it matches the first type-name. */
5346 *type
= cp_parser_nonclass_name (parser
);
5349 /* Parse a unary-expression.
5355 unary-operator cast-expression
5356 sizeof unary-expression
5364 __extension__ cast-expression
5365 __alignof__ unary-expression
5366 __alignof__ ( type-id )
5367 __real__ cast-expression
5368 __imag__ cast-expression
5371 ADDRESS_P is true iff the unary-expression is appearing as the
5372 operand of the `&' operator. CAST_P is true if this expression is
5373 the target of a cast.
5375 Returns a representation of the expression. */
5378 cp_parser_unary_expression (cp_parser
*parser
, bool address_p
, bool cast_p
,
5382 enum tree_code unary_operator
;
5384 /* Peek at the next token. */
5385 token
= cp_lexer_peek_token (parser
->lexer
);
5386 /* Some keywords give away the kind of expression. */
5387 if (token
->type
== CPP_KEYWORD
)
5389 enum rid keyword
= token
->keyword
;
5399 op
= keyword
== RID_ALIGNOF
? ALIGNOF_EXPR
: SIZEOF_EXPR
;
5400 /* Consume the token. */
5401 cp_lexer_consume_token (parser
->lexer
);
5402 /* Parse the operand. */
5403 operand
= cp_parser_sizeof_operand (parser
, keyword
);
5405 if (TYPE_P (operand
))
5406 return cxx_sizeof_or_alignof_type (operand
, op
, true);
5408 return cxx_sizeof_or_alignof_expr (operand
, op
, true);
5412 return cp_parser_new_expression (parser
);
5415 return cp_parser_delete_expression (parser
);
5419 /* The saved value of the PEDANTIC flag. */
5423 /* Save away the PEDANTIC flag. */
5424 cp_parser_extension_opt (parser
, &saved_pedantic
);
5425 /* Parse the cast-expression. */
5426 expr
= cp_parser_simple_cast_expression (parser
);
5427 /* Restore the PEDANTIC flag. */
5428 pedantic
= saved_pedantic
;
5438 /* Consume the `__real__' or `__imag__' token. */
5439 cp_lexer_consume_token (parser
->lexer
);
5440 /* Parse the cast-expression. */
5441 expression
= cp_parser_simple_cast_expression (parser
);
5442 /* Create the complete representation. */
5443 return build_x_unary_op ((keyword
== RID_REALPART
5444 ? REALPART_EXPR
: IMAGPART_EXPR
),
5446 tf_warning_or_error
);
5455 /* Look for the `:: new' and `:: delete', which also signal the
5456 beginning of a new-expression, or delete-expression,
5457 respectively. If the next token is `::', then it might be one of
5459 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
5463 /* See if the token after the `::' is one of the keywords in
5464 which we're interested. */
5465 keyword
= cp_lexer_peek_nth_token (parser
->lexer
, 2)->keyword
;
5466 /* If it's `new', we have a new-expression. */
5467 if (keyword
== RID_NEW
)
5468 return cp_parser_new_expression (parser
);
5469 /* Similarly, for `delete'. */
5470 else if (keyword
== RID_DELETE
)
5471 return cp_parser_delete_expression (parser
);
5474 /* Look for a unary operator. */
5475 unary_operator
= cp_parser_unary_operator (token
);
5476 /* The `++' and `--' operators can be handled similarly, even though
5477 they are not technically unary-operators in the grammar. */
5478 if (unary_operator
== ERROR_MARK
)
5480 if (token
->type
== CPP_PLUS_PLUS
)
5481 unary_operator
= PREINCREMENT_EXPR
;
5482 else if (token
->type
== CPP_MINUS_MINUS
)
5483 unary_operator
= PREDECREMENT_EXPR
;
5484 /* Handle the GNU address-of-label extension. */
5485 else if (cp_parser_allow_gnu_extensions_p (parser
)
5486 && token
->type
== CPP_AND_AND
)
5490 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
5492 /* Consume the '&&' token. */
5493 cp_lexer_consume_token (parser
->lexer
);
5494 /* Look for the identifier. */
5495 identifier
= cp_parser_identifier (parser
);
5496 /* Create an expression representing the address. */
5497 expression
= finish_label_address_expr (identifier
, loc
);
5498 if (cp_parser_non_integral_constant_expression (parser
,
5499 "the address of a label"))
5500 expression
= error_mark_node
;
5504 if (unary_operator
!= ERROR_MARK
)
5506 tree cast_expression
;
5507 tree expression
= error_mark_node
;
5508 const char *non_constant_p
= NULL
;
5510 /* Consume the operator token. */
5511 token
= cp_lexer_consume_token (parser
->lexer
);
5512 /* Parse the cast-expression. */
5514 = cp_parser_cast_expression (parser
,
5515 unary_operator
== ADDR_EXPR
,
5516 /*cast_p=*/false, pidk
);
5517 /* Now, build an appropriate representation. */
5518 switch (unary_operator
)
5521 non_constant_p
= "%<*%>";
5522 expression
= build_x_indirect_ref (cast_expression
, "unary *",
5523 tf_warning_or_error
);
5527 non_constant_p
= "%<&%>";
5530 expression
= build_x_unary_op (unary_operator
, cast_expression
,
5531 tf_warning_or_error
);
5534 case PREINCREMENT_EXPR
:
5535 case PREDECREMENT_EXPR
:
5536 non_constant_p
= (unary_operator
== PREINCREMENT_EXPR
5537 ? "%<++%>" : "%<--%>");
5539 case UNARY_PLUS_EXPR
:
5541 case TRUTH_NOT_EXPR
:
5542 expression
= finish_unary_op_expr (unary_operator
, cast_expression
);
5550 && cp_parser_non_integral_constant_expression (parser
,
5552 expression
= error_mark_node
;
5557 return cp_parser_postfix_expression (parser
, address_p
, cast_p
,
5558 /*member_access_only_p=*/false,
5562 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
5563 unary-operator, the corresponding tree code is returned. */
5565 static enum tree_code
5566 cp_parser_unary_operator (cp_token
* token
)
5568 switch (token
->type
)
5571 return INDIRECT_REF
;
5577 return UNARY_PLUS_EXPR
;
5583 return TRUTH_NOT_EXPR
;
5586 return BIT_NOT_EXPR
;
5593 /* Parse a new-expression.
5596 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
5597 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
5599 Returns a representation of the expression. */
5602 cp_parser_new_expression (cp_parser
* parser
)
5604 bool global_scope_p
;
5610 /* Look for the optional `::' operator. */
5612 = (cp_parser_global_scope_opt (parser
,
5613 /*current_scope_valid_p=*/false)
5615 /* Look for the `new' operator. */
5616 cp_parser_require_keyword (parser
, RID_NEW
, "%<new%>");
5617 /* There's no easy way to tell a new-placement from the
5618 `( type-id )' construct. */
5619 cp_parser_parse_tentatively (parser
);
5620 /* Look for a new-placement. */
5621 placement
= cp_parser_new_placement (parser
);
5622 /* If that didn't work out, there's no new-placement. */
5623 if (!cp_parser_parse_definitely (parser
))
5624 placement
= NULL_TREE
;
5626 /* If the next token is a `(', then we have a parenthesized
5628 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
5631 /* Consume the `('. */
5632 cp_lexer_consume_token (parser
->lexer
);
5633 /* Parse the type-id. */
5634 type
= cp_parser_type_id (parser
);
5635 /* Look for the closing `)'. */
5636 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
5637 token
= cp_lexer_peek_token (parser
->lexer
);
5638 /* There should not be a direct-new-declarator in this production,
5639 but GCC used to allowed this, so we check and emit a sensible error
5640 message for this case. */
5641 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
5643 error ("%Harray bound forbidden after parenthesized type-id",
5645 inform (token
->location
,
5646 "try removing the parentheses around the type-id");
5647 cp_parser_direct_new_declarator (parser
);
5651 /* Otherwise, there must be a new-type-id. */
5653 type
= cp_parser_new_type_id (parser
, &nelts
);
5655 /* If the next token is a `(' or '{', then we have a new-initializer. */
5656 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
5657 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
5658 initializer
= cp_parser_new_initializer (parser
);
5660 initializer
= NULL_TREE
;
5662 /* A new-expression may not appear in an integral constant
5664 if (cp_parser_non_integral_constant_expression (parser
, "%<new%>"))
5665 return error_mark_node
;
5667 /* Create a representation of the new-expression. */
5668 return build_new (placement
, type
, nelts
, initializer
, global_scope_p
,
5669 tf_warning_or_error
);
5672 /* Parse a new-placement.
5677 Returns the same representation as for an expression-list. */
5680 cp_parser_new_placement (cp_parser
* parser
)
5682 tree expression_list
;
5684 /* Parse the expression-list. */
5685 expression_list
= (cp_parser_parenthesized_expression_list
5686 (parser
, false, /*cast_p=*/false, /*allow_expansion_p=*/true,
5687 /*non_constant_p=*/NULL
));
5689 return expression_list
;
5692 /* Parse a new-type-id.
5695 type-specifier-seq new-declarator [opt]
5697 Returns the TYPE allocated. If the new-type-id indicates an array
5698 type, *NELTS is set to the number of elements in the last array
5699 bound; the TYPE will not include the last array bound. */
5702 cp_parser_new_type_id (cp_parser
* parser
, tree
*nelts
)
5704 cp_decl_specifier_seq type_specifier_seq
;
5705 cp_declarator
*new_declarator
;
5706 cp_declarator
*declarator
;
5707 cp_declarator
*outer_declarator
;
5708 const char *saved_message
;
5711 /* The type-specifier sequence must not contain type definitions.
5712 (It cannot contain declarations of new types either, but if they
5713 are not definitions we will catch that because they are not
5715 saved_message
= parser
->type_definition_forbidden_message
;
5716 parser
->type_definition_forbidden_message
5717 = "types may not be defined in a new-type-id";
5718 /* Parse the type-specifier-seq. */
5719 cp_parser_type_specifier_seq (parser
, /*is_condition=*/false,
5720 &type_specifier_seq
);
5721 /* Restore the old message. */
5722 parser
->type_definition_forbidden_message
= saved_message
;
5723 /* Parse the new-declarator. */
5724 new_declarator
= cp_parser_new_declarator_opt (parser
);
5726 /* Determine the number of elements in the last array dimension, if
5729 /* Skip down to the last array dimension. */
5730 declarator
= new_declarator
;
5731 outer_declarator
= NULL
;
5732 while (declarator
&& (declarator
->kind
== cdk_pointer
5733 || declarator
->kind
== cdk_ptrmem
))
5735 outer_declarator
= declarator
;
5736 declarator
= declarator
->declarator
;
5739 && declarator
->kind
== cdk_array
5740 && declarator
->declarator
5741 && declarator
->declarator
->kind
== cdk_array
)
5743 outer_declarator
= declarator
;
5744 declarator
= declarator
->declarator
;
5747 if (declarator
&& declarator
->kind
== cdk_array
)
5749 *nelts
= declarator
->u
.array
.bounds
;
5750 if (*nelts
== error_mark_node
)
5751 *nelts
= integer_one_node
;
5753 if (outer_declarator
)
5754 outer_declarator
->declarator
= declarator
->declarator
;
5756 new_declarator
= NULL
;
5759 type
= groktypename (&type_specifier_seq
, new_declarator
);
5763 /* Parse an (optional) new-declarator.
5766 ptr-operator new-declarator [opt]
5767 direct-new-declarator
5769 Returns the declarator. */
5771 static cp_declarator
*
5772 cp_parser_new_declarator_opt (cp_parser
* parser
)
5774 enum tree_code code
;
5776 cp_cv_quals cv_quals
;
5778 /* We don't know if there's a ptr-operator next, or not. */
5779 cp_parser_parse_tentatively (parser
);
5780 /* Look for a ptr-operator. */
5781 code
= cp_parser_ptr_operator (parser
, &type
, &cv_quals
);
5782 /* If that worked, look for more new-declarators. */
5783 if (cp_parser_parse_definitely (parser
))
5785 cp_declarator
*declarator
;
5787 /* Parse another optional declarator. */
5788 declarator
= cp_parser_new_declarator_opt (parser
);
5790 return cp_parser_make_indirect_declarator
5791 (code
, type
, cv_quals
, declarator
);
5794 /* If the next token is a `[', there is a direct-new-declarator. */
5795 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
5796 return cp_parser_direct_new_declarator (parser
);
5801 /* Parse a direct-new-declarator.
5803 direct-new-declarator:
5805 direct-new-declarator [constant-expression]
5809 static cp_declarator
*
5810 cp_parser_direct_new_declarator (cp_parser
* parser
)
5812 cp_declarator
*declarator
= NULL
;
5818 /* Look for the opening `['. */
5819 cp_parser_require (parser
, CPP_OPEN_SQUARE
, "%<[%>");
5820 /* The first expression is not required to be constant. */
5823 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
5824 expression
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
5825 /* The standard requires that the expression have integral
5826 type. DR 74 adds enumeration types. We believe that the
5827 real intent is that these expressions be handled like the
5828 expression in a `switch' condition, which also allows
5829 classes with a single conversion to integral or
5830 enumeration type. */
5831 if (!processing_template_decl
)
5834 = build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5839 error ("%Hexpression in new-declarator must have integral "
5840 "or enumeration type", &token
->location
);
5841 expression
= error_mark_node
;
5845 /* But all the other expressions must be. */
5848 = cp_parser_constant_expression (parser
,
5849 /*allow_non_constant=*/false,
5851 /* Look for the closing `]'. */
5852 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>");
5854 /* Add this bound to the declarator. */
5855 declarator
= make_array_declarator (declarator
, expression
);
5857 /* If the next token is not a `[', then there are no more
5859 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_SQUARE
))
5866 /* Parse a new-initializer.
5869 ( expression-list [opt] )
5872 Returns a representation of the expression-list. If there is no
5873 expression-list, VOID_ZERO_NODE is returned. */
5876 cp_parser_new_initializer (cp_parser
* parser
)
5878 tree expression_list
;
5880 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
5882 bool expr_non_constant_p
;
5883 maybe_warn_cpp0x ("extended initializer lists");
5884 expression_list
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
5885 CONSTRUCTOR_IS_DIRECT_INIT (expression_list
) = 1;
5886 expression_list
= build_tree_list (NULL_TREE
, expression_list
);
5889 expression_list
= (cp_parser_parenthesized_expression_list
5890 (parser
, false, /*cast_p=*/false, /*allow_expansion_p=*/true,
5891 /*non_constant_p=*/NULL
));
5892 if (!expression_list
)
5893 expression_list
= void_zero_node
;
5895 return expression_list
;
5898 /* Parse a delete-expression.
5901 :: [opt] delete cast-expression
5902 :: [opt] delete [ ] cast-expression
5904 Returns a representation of the expression. */
5907 cp_parser_delete_expression (cp_parser
* parser
)
5909 bool global_scope_p
;
5913 /* Look for the optional `::' operator. */
5915 = (cp_parser_global_scope_opt (parser
,
5916 /*current_scope_valid_p=*/false)
5918 /* Look for the `delete' keyword. */
5919 cp_parser_require_keyword (parser
, RID_DELETE
, "%<delete%>");
5920 /* See if the array syntax is in use. */
5921 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
5923 /* Consume the `[' token. */
5924 cp_lexer_consume_token (parser
->lexer
);
5925 /* Look for the `]' token. */
5926 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>");
5927 /* Remember that this is the `[]' construct. */
5933 /* Parse the cast-expression. */
5934 expression
= cp_parser_simple_cast_expression (parser
);
5936 /* A delete-expression may not appear in an integral constant
5938 if (cp_parser_non_integral_constant_expression (parser
, "%<delete%>"))
5939 return error_mark_node
;
5941 return delete_sanity (expression
, NULL_TREE
, array_p
, global_scope_p
);
5944 /* Returns true if TOKEN may start a cast-expression and false
5948 cp_parser_token_starts_cast_expression (cp_token
*token
)
5950 switch (token
->type
)
5956 case CPP_CLOSE_SQUARE
:
5957 case CPP_CLOSE_PAREN
:
5958 case CPP_CLOSE_BRACE
:
5962 case CPP_DEREF_STAR
:
5970 case CPP_GREATER_EQ
:
5990 /* '[' may start a primary-expression in obj-c++. */
5991 case CPP_OPEN_SQUARE
:
5992 return c_dialect_objc ();
5999 /* Parse a cast-expression.
6003 ( type-id ) cast-expression
6005 ADDRESS_P is true iff the unary-expression is appearing as the
6006 operand of the `&' operator. CAST_P is true if this expression is
6007 the target of a cast.
6009 Returns a representation of the expression. */
6012 cp_parser_cast_expression (cp_parser
*parser
, bool address_p
, bool cast_p
,
6015 /* If it's a `(', then we might be looking at a cast. */
6016 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
6018 tree type
= NULL_TREE
;
6019 tree expr
= NULL_TREE
;
6020 bool compound_literal_p
;
6021 const char *saved_message
;
6023 /* There's no way to know yet whether or not this is a cast.
6024 For example, `(int (3))' is a unary-expression, while `(int)
6025 3' is a cast. So, we resort to parsing tentatively. */
6026 cp_parser_parse_tentatively (parser
);
6027 /* Types may not be defined in a cast. */
6028 saved_message
= parser
->type_definition_forbidden_message
;
6029 parser
->type_definition_forbidden_message
6030 = "types may not be defined in casts";
6031 /* Consume the `('. */
6032 cp_lexer_consume_token (parser
->lexer
);
6033 /* A very tricky bit is that `(struct S) { 3 }' is a
6034 compound-literal (which we permit in C++ as an extension).
6035 But, that construct is not a cast-expression -- it is a
6036 postfix-expression. (The reason is that `(struct S) { 3 }.i'
6037 is legal; if the compound-literal were a cast-expression,
6038 you'd need an extra set of parentheses.) But, if we parse
6039 the type-id, and it happens to be a class-specifier, then we
6040 will commit to the parse at that point, because we cannot
6041 undo the action that is done when creating a new class. So,
6042 then we cannot back up and do a postfix-expression.
6044 Therefore, we scan ahead to the closing `)', and check to see
6045 if the token after the `)' is a `{'. If so, we are not
6046 looking at a cast-expression.
6048 Save tokens so that we can put them back. */
6049 cp_lexer_save_tokens (parser
->lexer
);
6050 /* Skip tokens until the next token is a closing parenthesis.
6051 If we find the closing `)', and the next token is a `{', then
6052 we are looking at a compound-literal. */
6054 = (cp_parser_skip_to_closing_parenthesis (parser
, false, false,
6055 /*consume_paren=*/true)
6056 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
));
6057 /* Roll back the tokens we skipped. */
6058 cp_lexer_rollback_tokens (parser
->lexer
);
6059 /* If we were looking at a compound-literal, simulate an error
6060 so that the call to cp_parser_parse_definitely below will
6062 if (compound_literal_p
)
6063 cp_parser_simulate_error (parser
);
6066 bool saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
6067 parser
->in_type_id_in_expr_p
= true;
6068 /* Look for the type-id. */
6069 type
= cp_parser_type_id (parser
);
6070 /* Look for the closing `)'. */
6071 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
6072 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
6075 /* Restore the saved message. */
6076 parser
->type_definition_forbidden_message
= saved_message
;
6078 /* At this point this can only be either a cast or a
6079 parenthesized ctor such as `(T ())' that looks like a cast to
6080 function returning T. */
6081 if (!cp_parser_error_occurred (parser
)
6082 && cp_parser_token_starts_cast_expression (cp_lexer_peek_token
6085 cp_parser_parse_definitely (parser
);
6086 expr
= cp_parser_cast_expression (parser
,
6087 /*address_p=*/false,
6088 /*cast_p=*/true, pidk
);
6090 /* Warn about old-style casts, if so requested. */
6091 if (warn_old_style_cast
6092 && !in_system_header
6093 && !VOID_TYPE_P (type
)
6094 && current_lang_name
!= lang_name_c
)
6095 warning (OPT_Wold_style_cast
, "use of old-style cast");
6097 /* Only type conversions to integral or enumeration types
6098 can be used in constant-expressions. */
6099 if (!cast_valid_in_integral_constant_expression_p (type
)
6100 && (cp_parser_non_integral_constant_expression
6102 "a cast to a type other than an integral or "
6103 "enumeration type")))
6104 return error_mark_node
;
6106 /* Perform the cast. */
6107 expr
= build_c_cast (type
, expr
);
6111 cp_parser_abort_tentative_parse (parser
);
6114 /* If we get here, then it's not a cast, so it must be a
6115 unary-expression. */
6116 return cp_parser_unary_expression (parser
, address_p
, cast_p
, pidk
);
6119 /* Parse a binary expression of the general form:
6123 pm-expression .* cast-expression
6124 pm-expression ->* cast-expression
6126 multiplicative-expression:
6128 multiplicative-expression * pm-expression
6129 multiplicative-expression / pm-expression
6130 multiplicative-expression % pm-expression
6132 additive-expression:
6133 multiplicative-expression
6134 additive-expression + multiplicative-expression
6135 additive-expression - multiplicative-expression
6139 shift-expression << additive-expression
6140 shift-expression >> additive-expression
6142 relational-expression:
6144 relational-expression < shift-expression
6145 relational-expression > shift-expression
6146 relational-expression <= shift-expression
6147 relational-expression >= shift-expression
6151 relational-expression:
6152 relational-expression <? shift-expression
6153 relational-expression >? shift-expression
6155 equality-expression:
6156 relational-expression
6157 equality-expression == relational-expression
6158 equality-expression != relational-expression
6162 and-expression & equality-expression
6164 exclusive-or-expression:
6166 exclusive-or-expression ^ and-expression
6168 inclusive-or-expression:
6169 exclusive-or-expression
6170 inclusive-or-expression | exclusive-or-expression
6172 logical-and-expression:
6173 inclusive-or-expression
6174 logical-and-expression && inclusive-or-expression
6176 logical-or-expression:
6177 logical-and-expression
6178 logical-or-expression || logical-and-expression
6180 All these are implemented with a single function like:
6183 simple-cast-expression
6184 binary-expression <token> binary-expression
6186 CAST_P is true if this expression is the target of a cast.
6188 The binops_by_token map is used to get the tree codes for each <token> type.
6189 binary-expressions are associated according to a precedence table. */
6191 #define TOKEN_PRECEDENCE(token) \
6192 (((token->type == CPP_GREATER \
6193 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
6194 && !parser->greater_than_is_operator_p) \
6195 ? PREC_NOT_OPERATOR \
6196 : binops_by_token[token->type].prec)
6199 cp_parser_binary_expression (cp_parser
* parser
, bool cast_p
,
6200 enum cp_parser_prec prec
,
6203 cp_parser_expression_stack stack
;
6204 cp_parser_expression_stack_entry
*sp
= &stack
[0];
6207 enum tree_code tree_type
, lhs_type
, rhs_type
;
6208 enum cp_parser_prec new_prec
, lookahead_prec
;
6211 /* Parse the first expression. */
6212 lhs
= cp_parser_cast_expression (parser
, /*address_p=*/false, cast_p
, pidk
);
6213 lhs_type
= ERROR_MARK
;
6217 /* Get an operator token. */
6218 token
= cp_lexer_peek_token (parser
->lexer
);
6220 if (warn_cxx0x_compat
6221 && token
->type
== CPP_RSHIFT
6222 && !parser
->greater_than_is_operator_p
)
6224 warning (OPT_Wc__0x_compat
,
6225 "%H%<>>%> operator will be treated as two right angle brackets in C++0x",
6227 warning (OPT_Wc__0x_compat
,
6228 "suggest parentheses around %<>>%> expression");
6231 new_prec
= TOKEN_PRECEDENCE (token
);
6233 /* Popping an entry off the stack means we completed a subexpression:
6234 - either we found a token which is not an operator (`>' where it is not
6235 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
6236 will happen repeatedly;
6237 - or, we found an operator which has lower priority. This is the case
6238 where the recursive descent *ascends*, as in `3 * 4 + 5' after
6240 if (new_prec
<= prec
)
6249 tree_type
= binops_by_token
[token
->type
].tree_type
;
6251 /* We used the operator token. */
6252 cp_lexer_consume_token (parser
->lexer
);
6254 /* Extract another operand. It may be the RHS of this expression
6255 or the LHS of a new, higher priority expression. */
6256 rhs
= cp_parser_simple_cast_expression (parser
);
6257 rhs_type
= ERROR_MARK
;
6259 /* Get another operator token. Look up its precedence to avoid
6260 building a useless (immediately popped) stack entry for common
6261 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
6262 token
= cp_lexer_peek_token (parser
->lexer
);
6263 lookahead_prec
= TOKEN_PRECEDENCE (token
);
6264 if (lookahead_prec
> new_prec
)
6266 /* ... and prepare to parse the RHS of the new, higher priority
6267 expression. Since precedence levels on the stack are
6268 monotonically increasing, we do not have to care about
6271 sp
->tree_type
= tree_type
;
6273 sp
->lhs_type
= lhs_type
;
6276 lhs_type
= rhs_type
;
6278 new_prec
= lookahead_prec
;
6282 /* If the stack is not empty, we have parsed into LHS the right side
6283 (`4' in the example above) of an expression we had suspended.
6284 We can use the information on the stack to recover the LHS (`3')
6285 from the stack together with the tree code (`MULT_EXPR'), and
6286 the precedence of the higher level subexpression
6287 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
6288 which will be used to actually build the additive expression. */
6291 tree_type
= sp
->tree_type
;
6293 rhs_type
= lhs_type
;
6295 lhs_type
= sp
->lhs_type
;
6298 overloaded_p
= false;
6299 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
6300 ERROR_MARK for everything that is not a binary expression.
6301 This makes warn_about_parentheses miss some warnings that
6302 involve unary operators. For unary expressions we should
6303 pass the correct tree_code unless the unary expression was
6304 surrounded by parentheses.
6306 lhs
= build_x_binary_op (tree_type
, lhs
, lhs_type
, rhs
, rhs_type
,
6307 &overloaded_p
, tf_warning_or_error
);
6308 lhs_type
= tree_type
;
6310 /* If the binary operator required the use of an overloaded operator,
6311 then this expression cannot be an integral constant-expression.
6312 An overloaded operator can be used even if both operands are
6313 otherwise permissible in an integral constant-expression if at
6314 least one of the operands is of enumeration type. */
6317 && (cp_parser_non_integral_constant_expression
6318 (parser
, "calls to overloaded operators")))
6319 return error_mark_node
;
6326 /* Parse the `? expression : assignment-expression' part of a
6327 conditional-expression. The LOGICAL_OR_EXPR is the
6328 logical-or-expression that started the conditional-expression.
6329 Returns a representation of the entire conditional-expression.
6331 This routine is used by cp_parser_assignment_expression.
6333 ? expression : assignment-expression
6337 ? : assignment-expression */
6340 cp_parser_question_colon_clause (cp_parser
* parser
, tree logical_or_expr
)
6343 tree assignment_expr
;
6345 /* Consume the `?' token. */
6346 cp_lexer_consume_token (parser
->lexer
);
6347 if (cp_parser_allow_gnu_extensions_p (parser
)
6348 && cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
6349 /* Implicit true clause. */
6352 /* Parse the expression. */
6353 expr
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
6355 /* The next token should be a `:'. */
6356 cp_parser_require (parser
, CPP_COLON
, "%<:%>");
6357 /* Parse the assignment-expression. */
6358 assignment_expr
= cp_parser_assignment_expression (parser
, /*cast_p=*/false, NULL
);
6360 /* Build the conditional-expression. */
6361 return build_x_conditional_expr (logical_or_expr
,
6364 tf_warning_or_error
);
6367 /* Parse an assignment-expression.
6369 assignment-expression:
6370 conditional-expression
6371 logical-or-expression assignment-operator assignment_expression
6374 CAST_P is true if this expression is the target of a cast.
6376 Returns a representation for the expression. */
6379 cp_parser_assignment_expression (cp_parser
* parser
, bool cast_p
,
6384 /* If the next token is the `throw' keyword, then we're looking at
6385 a throw-expression. */
6386 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_THROW
))
6387 expr
= cp_parser_throw_expression (parser
);
6388 /* Otherwise, it must be that we are looking at a
6389 logical-or-expression. */
6392 /* Parse the binary expressions (logical-or-expression). */
6393 expr
= cp_parser_binary_expression (parser
, cast_p
, PREC_NOT_OPERATOR
, pidk
);
6394 /* If the next token is a `?' then we're actually looking at a
6395 conditional-expression. */
6396 if (cp_lexer_next_token_is (parser
->lexer
, CPP_QUERY
))
6397 return cp_parser_question_colon_clause (parser
, expr
);
6400 enum tree_code assignment_operator
;
6402 /* If it's an assignment-operator, we're using the second
6405 = cp_parser_assignment_operator_opt (parser
);
6406 if (assignment_operator
!= ERROR_MARK
)
6408 bool non_constant_p
;
6410 /* Parse the right-hand side of the assignment. */
6411 tree rhs
= cp_parser_initializer_clause (parser
, &non_constant_p
);
6413 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
6414 maybe_warn_cpp0x ("extended initializer lists");
6416 /* An assignment may not appear in a
6417 constant-expression. */
6418 if (cp_parser_non_integral_constant_expression (parser
,
6420 return error_mark_node
;
6421 /* Build the assignment expression. */
6422 expr
= build_x_modify_expr (expr
,
6423 assignment_operator
,
6425 tf_warning_or_error
);
6433 /* Parse an (optional) assignment-operator.
6435 assignment-operator: one of
6436 = *= /= %= += -= >>= <<= &= ^= |=
6440 assignment-operator: one of
6443 If the next token is an assignment operator, the corresponding tree
6444 code is returned, and the token is consumed. For example, for
6445 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
6446 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
6447 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
6448 operator, ERROR_MARK is returned. */
6450 static enum tree_code
6451 cp_parser_assignment_operator_opt (cp_parser
* parser
)
6456 /* Peek at the next token. */
6457 token
= cp_lexer_peek_token (parser
->lexer
);
6459 switch (token
->type
)
6470 op
= TRUNC_DIV_EXPR
;
6474 op
= TRUNC_MOD_EXPR
;
6506 /* Nothing else is an assignment operator. */
6510 /* If it was an assignment operator, consume it. */
6511 if (op
!= ERROR_MARK
)
6512 cp_lexer_consume_token (parser
->lexer
);
6517 /* Parse an expression.
6520 assignment-expression
6521 expression , assignment-expression
6523 CAST_P is true if this expression is the target of a cast.
6525 Returns a representation of the expression. */
6528 cp_parser_expression (cp_parser
* parser
, bool cast_p
, cp_id_kind
* pidk
)
6530 tree expression
= NULL_TREE
;
6534 tree assignment_expression
;
6536 /* Parse the next assignment-expression. */
6537 assignment_expression
6538 = cp_parser_assignment_expression (parser
, cast_p
, pidk
);
6539 /* If this is the first assignment-expression, we can just
6542 expression
= assignment_expression
;
6544 expression
= build_x_compound_expr (expression
,
6545 assignment_expression
,
6546 tf_warning_or_error
);
6547 /* If the next token is not a comma, then we are done with the
6549 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
6551 /* Consume the `,'. */
6552 cp_lexer_consume_token (parser
->lexer
);
6553 /* A comma operator cannot appear in a constant-expression. */
6554 if (cp_parser_non_integral_constant_expression (parser
,
6555 "a comma operator"))
6556 expression
= error_mark_node
;
6562 /* Parse a constant-expression.
6564 constant-expression:
6565 conditional-expression
6567 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
6568 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
6569 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
6570 is false, NON_CONSTANT_P should be NULL. */
6573 cp_parser_constant_expression (cp_parser
* parser
,
6574 bool allow_non_constant_p
,
6575 bool *non_constant_p
)
6577 bool saved_integral_constant_expression_p
;
6578 bool saved_allow_non_integral_constant_expression_p
;
6579 bool saved_non_integral_constant_expression_p
;
6582 /* It might seem that we could simply parse the
6583 conditional-expression, and then check to see if it were
6584 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
6585 one that the compiler can figure out is constant, possibly after
6586 doing some simplifications or optimizations. The standard has a
6587 precise definition of constant-expression, and we must honor
6588 that, even though it is somewhat more restrictive.
6594 is not a legal declaration, because `(2, 3)' is not a
6595 constant-expression. The `,' operator is forbidden in a
6596 constant-expression. However, GCC's constant-folding machinery
6597 will fold this operation to an INTEGER_CST for `3'. */
6599 /* Save the old settings. */
6600 saved_integral_constant_expression_p
= parser
->integral_constant_expression_p
;
6601 saved_allow_non_integral_constant_expression_p
6602 = parser
->allow_non_integral_constant_expression_p
;
6603 saved_non_integral_constant_expression_p
= parser
->non_integral_constant_expression_p
;
6604 /* We are now parsing a constant-expression. */
6605 parser
->integral_constant_expression_p
= true;
6606 parser
->allow_non_integral_constant_expression_p
= allow_non_constant_p
;
6607 parser
->non_integral_constant_expression_p
= false;
6608 /* Although the grammar says "conditional-expression", we parse an
6609 "assignment-expression", which also permits "throw-expression"
6610 and the use of assignment operators. In the case that
6611 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
6612 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
6613 actually essential that we look for an assignment-expression.
6614 For example, cp_parser_initializer_clauses uses this function to
6615 determine whether a particular assignment-expression is in fact
6617 expression
= cp_parser_assignment_expression (parser
, /*cast_p=*/false, NULL
);
6618 /* Restore the old settings. */
6619 parser
->integral_constant_expression_p
6620 = saved_integral_constant_expression_p
;
6621 parser
->allow_non_integral_constant_expression_p
6622 = saved_allow_non_integral_constant_expression_p
;
6623 if (allow_non_constant_p
)
6624 *non_constant_p
= parser
->non_integral_constant_expression_p
;
6625 else if (parser
->non_integral_constant_expression_p
)
6626 expression
= error_mark_node
;
6627 parser
->non_integral_constant_expression_p
6628 = saved_non_integral_constant_expression_p
;
6633 /* Parse __builtin_offsetof.
6635 offsetof-expression:
6636 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
6638 offsetof-member-designator:
6640 | offsetof-member-designator "." id-expression
6641 | offsetof-member-designator "[" expression "]"
6642 | offsetof-member-designator "->" id-expression */
6645 cp_parser_builtin_offsetof (cp_parser
*parser
)
6647 int save_ice_p
, save_non_ice_p
;
6652 /* We're about to accept non-integral-constant things, but will
6653 definitely yield an integral constant expression. Save and
6654 restore these values around our local parsing. */
6655 save_ice_p
= parser
->integral_constant_expression_p
;
6656 save_non_ice_p
= parser
->non_integral_constant_expression_p
;
6658 /* Consume the "__builtin_offsetof" token. */
6659 cp_lexer_consume_token (parser
->lexer
);
6660 /* Consume the opening `('. */
6661 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
6662 /* Parse the type-id. */
6663 type
= cp_parser_type_id (parser
);
6664 /* Look for the `,'. */
6665 cp_parser_require (parser
, CPP_COMMA
, "%<,%>");
6666 token
= cp_lexer_peek_token (parser
->lexer
);
6668 /* Build the (type *)null that begins the traditional offsetof macro. */
6669 expr
= build_static_cast (build_pointer_type (type
), null_pointer_node
,
6670 tf_warning_or_error
);
6672 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
6673 expr
= cp_parser_postfix_dot_deref_expression (parser
, CPP_DEREF
, expr
,
6674 true, &dummy
, token
->location
);
6677 token
= cp_lexer_peek_token (parser
->lexer
);
6678 switch (token
->type
)
6680 case CPP_OPEN_SQUARE
:
6681 /* offsetof-member-designator "[" expression "]" */
6682 expr
= cp_parser_postfix_open_square_expression (parser
, expr
, true);
6686 /* offsetof-member-designator "->" identifier */
6687 expr
= grok_array_decl (expr
, integer_zero_node
);
6691 /* offsetof-member-designator "." identifier */
6692 cp_lexer_consume_token (parser
->lexer
);
6693 expr
= cp_parser_postfix_dot_deref_expression (parser
, CPP_DOT
,
6698 case CPP_CLOSE_PAREN
:
6699 /* Consume the ")" token. */
6700 cp_lexer_consume_token (parser
->lexer
);
6704 /* Error. We know the following require will fail, but
6705 that gives the proper error message. */
6706 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
6707 cp_parser_skip_to_closing_parenthesis (parser
, true, false, true);
6708 expr
= error_mark_node
;
6714 /* If we're processing a template, we can't finish the semantics yet.
6715 Otherwise we can fold the entire expression now. */
6716 if (processing_template_decl
)
6717 expr
= build1 (OFFSETOF_EXPR
, size_type_node
, expr
);
6719 expr
= finish_offsetof (expr
);
6722 parser
->integral_constant_expression_p
= save_ice_p
;
6723 parser
->non_integral_constant_expression_p
= save_non_ice_p
;
6728 /* Parse a trait expression. */
6731 cp_parser_trait_expr (cp_parser
* parser
, enum rid keyword
)
6734 tree type1
, type2
= NULL_TREE
;
6735 bool binary
= false;
6736 cp_decl_specifier_seq decl_specs
;
6740 case RID_HAS_NOTHROW_ASSIGN
:
6741 kind
= CPTK_HAS_NOTHROW_ASSIGN
;
6743 case RID_HAS_NOTHROW_CONSTRUCTOR
:
6744 kind
= CPTK_HAS_NOTHROW_CONSTRUCTOR
;
6746 case RID_HAS_NOTHROW_COPY
:
6747 kind
= CPTK_HAS_NOTHROW_COPY
;
6749 case RID_HAS_TRIVIAL_ASSIGN
:
6750 kind
= CPTK_HAS_TRIVIAL_ASSIGN
;
6752 case RID_HAS_TRIVIAL_CONSTRUCTOR
:
6753 kind
= CPTK_HAS_TRIVIAL_CONSTRUCTOR
;
6755 case RID_HAS_TRIVIAL_COPY
:
6756 kind
= CPTK_HAS_TRIVIAL_COPY
;
6758 case RID_HAS_TRIVIAL_DESTRUCTOR
:
6759 kind
= CPTK_HAS_TRIVIAL_DESTRUCTOR
;
6761 case RID_HAS_VIRTUAL_DESTRUCTOR
:
6762 kind
= CPTK_HAS_VIRTUAL_DESTRUCTOR
;
6764 case RID_IS_ABSTRACT
:
6765 kind
= CPTK_IS_ABSTRACT
;
6767 case RID_IS_BASE_OF
:
6768 kind
= CPTK_IS_BASE_OF
;
6772 kind
= CPTK_IS_CLASS
;
6774 case RID_IS_CONVERTIBLE_TO
:
6775 kind
= CPTK_IS_CONVERTIBLE_TO
;
6779 kind
= CPTK_IS_EMPTY
;
6782 kind
= CPTK_IS_ENUM
;
6787 case RID_IS_POLYMORPHIC
:
6788 kind
= CPTK_IS_POLYMORPHIC
;
6791 kind
= CPTK_IS_UNION
;
6797 /* Consume the token. */
6798 cp_lexer_consume_token (parser
->lexer
);
6800 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
6802 type1
= cp_parser_type_id (parser
);
6804 if (type1
== error_mark_node
)
6805 return error_mark_node
;
6807 /* Build a trivial decl-specifier-seq. */
6808 clear_decl_specs (&decl_specs
);
6809 decl_specs
.type
= type1
;
6811 /* Call grokdeclarator to figure out what type this is. */
6812 type1
= grokdeclarator (NULL
, &decl_specs
, TYPENAME
,
6813 /*initialized=*/0, /*attrlist=*/NULL
);
6817 cp_parser_require (parser
, CPP_COMMA
, "%<,%>");
6819 type2
= cp_parser_type_id (parser
);
6821 if (type2
== error_mark_node
)
6822 return error_mark_node
;
6824 /* Build a trivial decl-specifier-seq. */
6825 clear_decl_specs (&decl_specs
);
6826 decl_specs
.type
= type2
;
6828 /* Call grokdeclarator to figure out what type this is. */
6829 type2
= grokdeclarator (NULL
, &decl_specs
, TYPENAME
,
6830 /*initialized=*/0, /*attrlist=*/NULL
);
6833 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
6835 /* Complete the trait expression, which may mean either processing
6836 the trait expr now or saving it for template instantiation. */
6837 return finish_trait_expr (kind
, type1
, type2
);
6840 /* Statements [gram.stmt.stmt] */
6842 /* Parse a statement.
6846 expression-statement
6851 declaration-statement
6854 IN_COMPOUND is true when the statement is nested inside a
6855 cp_parser_compound_statement; this matters for certain pragmas.
6857 If IF_P is not NULL, *IF_P is set to indicate whether the statement
6858 is a (possibly labeled) if statement which is not enclosed in braces
6859 and has an else clause. This is used to implement -Wparentheses. */
6862 cp_parser_statement (cp_parser
* parser
, tree in_statement_expr
,
6863 bool in_compound
, bool *if_p
)
6867 location_t statement_location
;
6872 /* There is no statement yet. */
6873 statement
= NULL_TREE
;
6874 /* Peek at the next token. */
6875 token
= cp_lexer_peek_token (parser
->lexer
);
6876 /* Remember the location of the first token in the statement. */
6877 statement_location
= token
->location
;
6878 /* If this is a keyword, then that will often determine what kind of
6879 statement we have. */
6880 if (token
->type
== CPP_KEYWORD
)
6882 enum rid keyword
= token
->keyword
;
6888 /* Looks like a labeled-statement with a case label.
6889 Parse the label, and then use tail recursion to parse
6891 cp_parser_label_for_labeled_statement (parser
);
6896 statement
= cp_parser_selection_statement (parser
, if_p
);
6902 statement
= cp_parser_iteration_statement (parser
);
6909 statement
= cp_parser_jump_statement (parser
);
6912 /* Objective-C++ exception-handling constructs. */
6915 case RID_AT_FINALLY
:
6916 case RID_AT_SYNCHRONIZED
:
6918 statement
= cp_parser_objc_statement (parser
);
6922 statement
= cp_parser_try_block (parser
);
6926 /* This must be a namespace alias definition. */
6927 cp_parser_declaration_statement (parser
);
6931 /* It might be a keyword like `int' that can start a
6932 declaration-statement. */
6936 else if (token
->type
== CPP_NAME
)
6938 /* If the next token is a `:', then we are looking at a
6939 labeled-statement. */
6940 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
6941 if (token
->type
== CPP_COLON
)
6943 /* Looks like a labeled-statement with an ordinary label.
6944 Parse the label, and then use tail recursion to parse
6946 cp_parser_label_for_labeled_statement (parser
);
6950 /* Anything that starts with a `{' must be a compound-statement. */
6951 else if (token
->type
== CPP_OPEN_BRACE
)
6952 statement
= cp_parser_compound_statement (parser
, NULL
, false);
6953 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
6954 a statement all its own. */
6955 else if (token
->type
== CPP_PRAGMA
)
6957 /* Only certain OpenMP pragmas are attached to statements, and thus
6958 are considered statements themselves. All others are not. In
6959 the context of a compound, accept the pragma as a "statement" and
6960 return so that we can check for a close brace. Otherwise we
6961 require a real statement and must go back and read one. */
6963 cp_parser_pragma (parser
, pragma_compound
);
6964 else if (!cp_parser_pragma (parser
, pragma_stmt
))
6968 else if (token
->type
== CPP_EOF
)
6970 cp_parser_error (parser
, "expected statement");
6974 /* Everything else must be a declaration-statement or an
6975 expression-statement. Try for the declaration-statement
6976 first, unless we are looking at a `;', in which case we know that
6977 we have an expression-statement. */
6980 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
6982 cp_parser_parse_tentatively (parser
);
6983 /* Try to parse the declaration-statement. */
6984 cp_parser_declaration_statement (parser
);
6985 /* If that worked, we're done. */
6986 if (cp_parser_parse_definitely (parser
))
6989 /* Look for an expression-statement instead. */
6990 statement
= cp_parser_expression_statement (parser
, in_statement_expr
);
6993 /* Set the line number for the statement. */
6994 if (statement
&& STATEMENT_CODE_P (TREE_CODE (statement
)))
6995 SET_EXPR_LOCATION (statement
, statement_location
);
6998 /* Parse the label for a labeled-statement, i.e.
7001 case constant-expression :
7005 case constant-expression ... constant-expression : statement
7007 When a label is parsed without errors, the label is added to the
7008 parse tree by the finish_* functions, so this function doesn't
7009 have to return the label. */
7012 cp_parser_label_for_labeled_statement (cp_parser
* parser
)
7016 /* The next token should be an identifier. */
7017 token
= cp_lexer_peek_token (parser
->lexer
);
7018 if (token
->type
!= CPP_NAME
7019 && token
->type
!= CPP_KEYWORD
)
7021 cp_parser_error (parser
, "expected labeled-statement");
7025 switch (token
->keyword
)
7032 /* Consume the `case' token. */
7033 cp_lexer_consume_token (parser
->lexer
);
7034 /* Parse the constant-expression. */
7035 expr
= cp_parser_constant_expression (parser
,
7036 /*allow_non_constant_p=*/false,
7039 ellipsis
= cp_lexer_peek_token (parser
->lexer
);
7040 if (ellipsis
->type
== CPP_ELLIPSIS
)
7042 /* Consume the `...' token. */
7043 cp_lexer_consume_token (parser
->lexer
);
7045 cp_parser_constant_expression (parser
,
7046 /*allow_non_constant_p=*/false,
7048 /* We don't need to emit warnings here, as the common code
7049 will do this for us. */
7052 expr_hi
= NULL_TREE
;
7054 if (parser
->in_switch_statement_p
)
7055 finish_case_label (expr
, expr_hi
);
7057 error ("%Hcase label %qE not within a switch statement",
7058 &token
->location
, expr
);
7063 /* Consume the `default' token. */
7064 cp_lexer_consume_token (parser
->lexer
);
7066 if (parser
->in_switch_statement_p
)
7067 finish_case_label (NULL_TREE
, NULL_TREE
);
7069 error ("%Hcase label not within a switch statement", &token
->location
);
7073 /* Anything else must be an ordinary label. */
7074 finish_label_stmt (cp_parser_identifier (parser
));
7078 /* Require the `:' token. */
7079 cp_parser_require (parser
, CPP_COLON
, "%<:%>");
7082 /* Parse an expression-statement.
7084 expression-statement:
7087 Returns the new EXPR_STMT -- or NULL_TREE if the expression
7088 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
7089 indicates whether this expression-statement is part of an
7090 expression statement. */
7093 cp_parser_expression_statement (cp_parser
* parser
, tree in_statement_expr
)
7095 tree statement
= NULL_TREE
;
7097 /* If the next token is a ';', then there is no expression
7099 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
7100 statement
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
7102 /* Consume the final `;'. */
7103 cp_parser_consume_semicolon_at_end_of_statement (parser
);
7105 if (in_statement_expr
7106 && cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
7107 /* This is the final expression statement of a statement
7109 statement
= finish_stmt_expr_expr (statement
, in_statement_expr
);
7111 statement
= finish_expr_stmt (statement
);
7118 /* Parse a compound-statement.
7121 { statement-seq [opt] }
7126 { label-declaration-seq [opt] statement-seq [opt] }
7128 label-declaration-seq:
7130 label-declaration-seq label-declaration
7132 Returns a tree representing the statement. */
7135 cp_parser_compound_statement (cp_parser
*parser
, tree in_statement_expr
,
7140 /* Consume the `{'. */
7141 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, "%<{%>"))
7142 return error_mark_node
;
7143 /* Begin the compound-statement. */
7144 compound_stmt
= begin_compound_stmt (in_try
? BCS_TRY_BLOCK
: 0);
7145 /* If the next keyword is `__label__' we have a label declaration. */
7146 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_LABEL
))
7147 cp_parser_label_declaration (parser
);
7148 /* Parse an (optional) statement-seq. */
7149 cp_parser_statement_seq_opt (parser
, in_statement_expr
);
7150 /* Finish the compound-statement. */
7151 finish_compound_stmt (compound_stmt
);
7152 /* Consume the `}'. */
7153 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
7155 return compound_stmt
;
7158 /* Parse an (optional) statement-seq.
7162 statement-seq [opt] statement */
7165 cp_parser_statement_seq_opt (cp_parser
* parser
, tree in_statement_expr
)
7167 /* Scan statements until there aren't any more. */
7170 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
7172 /* If we're looking at a `}', then we've run out of statements. */
7173 if (token
->type
== CPP_CLOSE_BRACE
7174 || token
->type
== CPP_EOF
7175 || token
->type
== CPP_PRAGMA_EOL
)
7178 /* If we are in a compound statement and find 'else' then
7179 something went wrong. */
7180 else if (token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_ELSE
)
7182 if (parser
->in_statement
& IN_IF_STMT
)
7186 token
= cp_lexer_consume_token (parser
->lexer
);
7187 error ("%H%<else%> without a previous %<if%>", &token
->location
);
7191 /* Parse the statement. */
7192 cp_parser_statement (parser
, in_statement_expr
, true, NULL
);
7196 /* Parse a selection-statement.
7198 selection-statement:
7199 if ( condition ) statement
7200 if ( condition ) statement else statement
7201 switch ( condition ) statement
7203 Returns the new IF_STMT or SWITCH_STMT.
7205 If IF_P is not NULL, *IF_P is set to indicate whether the statement
7206 is a (possibly labeled) if statement which is not enclosed in
7207 braces and has an else clause. This is used to implement
7211 cp_parser_selection_statement (cp_parser
* parser
, bool *if_p
)
7219 /* Peek at the next token. */
7220 token
= cp_parser_require (parser
, CPP_KEYWORD
, "selection-statement");
7222 /* See what kind of keyword it is. */
7223 keyword
= token
->keyword
;
7232 /* Look for the `('. */
7233 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
7235 cp_parser_skip_to_end_of_statement (parser
);
7236 return error_mark_node
;
7239 /* Begin the selection-statement. */
7240 if (keyword
== RID_IF
)
7241 statement
= begin_if_stmt ();
7243 statement
= begin_switch_stmt ();
7245 /* Parse the condition. */
7246 condition
= cp_parser_condition (parser
);
7247 /* Look for the `)'. */
7248 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
7249 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
7250 /*consume_paren=*/true);
7252 if (keyword
== RID_IF
)
7255 unsigned char in_statement
;
7257 /* Add the condition. */
7258 finish_if_stmt_cond (condition
, statement
);
7260 /* Parse the then-clause. */
7261 in_statement
= parser
->in_statement
;
7262 parser
->in_statement
|= IN_IF_STMT
;
7263 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
7265 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
7266 add_stmt (build_empty_stmt ());
7267 cp_lexer_consume_token (parser
->lexer
);
7268 if (!cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ELSE
))
7269 warning_at (loc
, OPT_Wempty_body
, "suggest braces around "
7270 "empty body in an %<if%> statement");
7274 cp_parser_implicitly_scoped_statement (parser
, &nested_if
);
7275 parser
->in_statement
= in_statement
;
7277 finish_then_clause (statement
);
7279 /* If the next token is `else', parse the else-clause. */
7280 if (cp_lexer_next_token_is_keyword (parser
->lexer
,
7283 /* Consume the `else' keyword. */
7284 cp_lexer_consume_token (parser
->lexer
);
7285 begin_else_clause (statement
);
7286 /* Parse the else-clause. */
7287 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
7289 warning_at (cp_lexer_peek_token (parser
->lexer
)->location
,
7290 OPT_Wempty_body
, "suggest braces around "
7291 "empty body in an %<else%> statement");
7292 add_stmt (build_empty_stmt ());
7293 cp_lexer_consume_token (parser
->lexer
);
7296 cp_parser_implicitly_scoped_statement (parser
, NULL
);
7298 finish_else_clause (statement
);
7300 /* If we are currently parsing a then-clause, then
7301 IF_P will not be NULL. We set it to true to
7302 indicate that this if statement has an else clause.
7303 This may trigger the Wparentheses warning below
7304 when we get back up to the parent if statement. */
7310 /* This if statement does not have an else clause. If
7311 NESTED_IF is true, then the then-clause is an if
7312 statement which does have an else clause. We warn
7313 about the potential ambiguity. */
7315 warning (OPT_Wparentheses
,
7316 ("%Hsuggest explicit braces "
7317 "to avoid ambiguous %<else%>"),
7318 EXPR_LOCUS (statement
));
7321 /* Now we're all done with the if-statement. */
7322 finish_if_stmt (statement
);
7326 bool in_switch_statement_p
;
7327 unsigned char in_statement
;
7329 /* Add the condition. */
7330 finish_switch_cond (condition
, statement
);
7332 /* Parse the body of the switch-statement. */
7333 in_switch_statement_p
= parser
->in_switch_statement_p
;
7334 in_statement
= parser
->in_statement
;
7335 parser
->in_switch_statement_p
= true;
7336 parser
->in_statement
|= IN_SWITCH_STMT
;
7337 cp_parser_implicitly_scoped_statement (parser
, NULL
);
7338 parser
->in_switch_statement_p
= in_switch_statement_p
;
7339 parser
->in_statement
= in_statement
;
7341 /* Now we're all done with the switch-statement. */
7342 finish_switch_stmt (statement
);
7350 cp_parser_error (parser
, "expected selection-statement");
7351 return error_mark_node
;
7355 /* Parse a condition.
7359 type-specifier-seq declarator = initializer-clause
7360 type-specifier-seq declarator braced-init-list
7365 type-specifier-seq declarator asm-specification [opt]
7366 attributes [opt] = assignment-expression
7368 Returns the expression that should be tested. */
7371 cp_parser_condition (cp_parser
* parser
)
7373 cp_decl_specifier_seq type_specifiers
;
7374 const char *saved_message
;
7376 /* Try the declaration first. */
7377 cp_parser_parse_tentatively (parser
);
7378 /* New types are not allowed in the type-specifier-seq for a
7380 saved_message
= parser
->type_definition_forbidden_message
;
7381 parser
->type_definition_forbidden_message
7382 = "types may not be defined in conditions";
7383 /* Parse the type-specifier-seq. */
7384 cp_parser_type_specifier_seq (parser
, /*is_condition==*/true,
7386 /* Restore the saved message. */
7387 parser
->type_definition_forbidden_message
= saved_message
;
7388 /* If all is well, we might be looking at a declaration. */
7389 if (!cp_parser_error_occurred (parser
))
7392 tree asm_specification
;
7394 cp_declarator
*declarator
;
7395 tree initializer
= NULL_TREE
;
7397 /* Parse the declarator. */
7398 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
7399 /*ctor_dtor_or_conv_p=*/NULL
,
7400 /*parenthesized_p=*/NULL
,
7401 /*member_p=*/false);
7402 /* Parse the attributes. */
7403 attributes
= cp_parser_attributes_opt (parser
);
7404 /* Parse the asm-specification. */
7405 asm_specification
= cp_parser_asm_specification_opt (parser
);
7406 /* If the next token is not an `=' or '{', then we might still be
7407 looking at an expression. For example:
7411 looks like a decl-specifier-seq and a declarator -- but then
7412 there is no `=', so this is an expression. */
7413 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
)
7414 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
7415 cp_parser_simulate_error (parser
);
7417 /* If we did see an `=' or '{', then we are looking at a declaration
7419 if (cp_parser_parse_definitely (parser
))
7422 bool non_constant_p
;
7423 bool flags
= LOOKUP_ONLYCONVERTING
;
7425 /* Create the declaration. */
7426 decl
= start_decl (declarator
, &type_specifiers
,
7427 /*initialized_p=*/true,
7428 attributes
, /*prefix_attributes=*/NULL_TREE
,
7431 /* Parse the initializer. */
7432 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
7434 initializer
= cp_parser_braced_list (parser
, &non_constant_p
);
7435 CONSTRUCTOR_IS_DIRECT_INIT (initializer
) = 1;
7440 /* Consume the `='. */
7441 cp_parser_require (parser
, CPP_EQ
, "%<=%>");
7442 initializer
= cp_parser_initializer_clause (parser
, &non_constant_p
);
7444 if (BRACE_ENCLOSED_INITIALIZER_P (initializer
))
7445 maybe_warn_cpp0x ("extended initializer lists");
7447 if (!non_constant_p
)
7448 initializer
= fold_non_dependent_expr (initializer
);
7450 /* Process the initializer. */
7451 cp_finish_decl (decl
,
7452 initializer
, !non_constant_p
,
7457 pop_scope (pushed_scope
);
7459 return convert_from_reference (decl
);
7462 /* If we didn't even get past the declarator successfully, we are
7463 definitely not looking at a declaration. */
7465 cp_parser_abort_tentative_parse (parser
);
7467 /* Otherwise, we are looking at an expression. */
7468 return cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
7471 /* Parse an iteration-statement.
7473 iteration-statement:
7474 while ( condition ) statement
7475 do statement while ( expression ) ;
7476 for ( for-init-statement condition [opt] ; expression [opt] )
7479 Returns the new WHILE_STMT, DO_STMT, or FOR_STMT. */
7482 cp_parser_iteration_statement (cp_parser
* parser
)
7487 unsigned char in_statement
;
7489 /* Peek at the next token. */
7490 token
= cp_parser_require (parser
, CPP_KEYWORD
, "iteration-statement");
7492 return error_mark_node
;
7494 /* Remember whether or not we are already within an iteration
7496 in_statement
= parser
->in_statement
;
7498 /* See what kind of keyword it is. */
7499 keyword
= token
->keyword
;
7506 /* Begin the while-statement. */
7507 statement
= begin_while_stmt ();
7508 /* Look for the `('. */
7509 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
7510 /* Parse the condition. */
7511 condition
= cp_parser_condition (parser
);
7512 finish_while_stmt_cond (condition
, statement
);
7513 /* Look for the `)'. */
7514 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
7515 /* Parse the dependent statement. */
7516 parser
->in_statement
= IN_ITERATION_STMT
;
7517 cp_parser_already_scoped_statement (parser
);
7518 parser
->in_statement
= in_statement
;
7519 /* We're done with the while-statement. */
7520 finish_while_stmt (statement
);
7528 /* Begin the do-statement. */
7529 statement
= begin_do_stmt ();
7530 /* Parse the body of the do-statement. */
7531 parser
->in_statement
= IN_ITERATION_STMT
;
7532 cp_parser_implicitly_scoped_statement (parser
, NULL
);
7533 parser
->in_statement
= in_statement
;
7534 finish_do_body (statement
);
7535 /* Look for the `while' keyword. */
7536 cp_parser_require_keyword (parser
, RID_WHILE
, "%<while%>");
7537 /* Look for the `('. */
7538 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
7539 /* Parse the expression. */
7540 expression
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
7541 /* We're done with the do-statement. */
7542 finish_do_stmt (expression
, statement
);
7543 /* Look for the `)'. */
7544 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
7545 /* Look for the `;'. */
7546 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
7552 tree condition
= NULL_TREE
;
7553 tree expression
= NULL_TREE
;
7555 /* Begin the for-statement. */
7556 statement
= begin_for_stmt ();
7557 /* Look for the `('. */
7558 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
7559 /* Parse the initialization. */
7560 cp_parser_for_init_statement (parser
);
7561 finish_for_init_stmt (statement
);
7563 /* If there's a condition, process it. */
7564 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
7565 condition
= cp_parser_condition (parser
);
7566 finish_for_cond (condition
, statement
);
7567 /* Look for the `;'. */
7568 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
7570 /* If there's an expression, process it. */
7571 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
7572 expression
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
7573 finish_for_expr (expression
, statement
);
7574 /* Look for the `)'. */
7575 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
7577 /* Parse the body of the for-statement. */
7578 parser
->in_statement
= IN_ITERATION_STMT
;
7579 cp_parser_already_scoped_statement (parser
);
7580 parser
->in_statement
= in_statement
;
7582 /* We're done with the for-statement. */
7583 finish_for_stmt (statement
);
7588 cp_parser_error (parser
, "expected iteration-statement");
7589 statement
= error_mark_node
;
7596 /* Parse a for-init-statement.
7599 expression-statement
7600 simple-declaration */
7603 cp_parser_for_init_statement (cp_parser
* parser
)
7605 /* If the next token is a `;', then we have an empty
7606 expression-statement. Grammatically, this is also a
7607 simple-declaration, but an invalid one, because it does not
7608 declare anything. Therefore, if we did not handle this case
7609 specially, we would issue an error message about an invalid
7611 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
7613 /* We're going to speculatively look for a declaration, falling back
7614 to an expression, if necessary. */
7615 cp_parser_parse_tentatively (parser
);
7616 /* Parse the declaration. */
7617 cp_parser_simple_declaration (parser
,
7618 /*function_definition_allowed_p=*/false);
7619 /* If the tentative parse failed, then we shall need to look for an
7620 expression-statement. */
7621 if (cp_parser_parse_definitely (parser
))
7625 cp_parser_expression_statement (parser
, false);
7628 /* Parse a jump-statement.
7633 return expression [opt] ;
7634 return braced-init-list ;
7642 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
7645 cp_parser_jump_statement (cp_parser
* parser
)
7647 tree statement
= error_mark_node
;
7650 unsigned char in_statement
;
7652 /* Peek at the next token. */
7653 token
= cp_parser_require (parser
, CPP_KEYWORD
, "jump-statement");
7655 return error_mark_node
;
7657 /* See what kind of keyword it is. */
7658 keyword
= token
->keyword
;
7662 in_statement
= parser
->in_statement
& ~IN_IF_STMT
;
7663 switch (in_statement
)
7666 error ("%Hbreak statement not within loop or switch", &token
->location
);
7669 gcc_assert ((in_statement
& IN_SWITCH_STMT
)
7670 || in_statement
== IN_ITERATION_STMT
);
7671 statement
= finish_break_stmt ();
7674 error ("%Hinvalid exit from OpenMP structured block", &token
->location
);
7677 error ("%Hbreak statement used with OpenMP for loop", &token
->location
);
7680 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
7684 switch (parser
->in_statement
& ~(IN_SWITCH_STMT
| IN_IF_STMT
))
7687 error ("%Hcontinue statement not within a loop", &token
->location
);
7689 case IN_ITERATION_STMT
:
7691 statement
= finish_continue_stmt ();
7694 error ("%Hinvalid exit from OpenMP structured block", &token
->location
);
7699 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
7705 bool expr_non_constant_p
;
7707 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
7709 maybe_warn_cpp0x ("extended initializer lists");
7710 expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
7712 else if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
7713 expr
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
7715 /* If the next token is a `;', then there is no
7718 /* Build the return-statement. */
7719 statement
= finish_return_stmt (expr
);
7720 /* Look for the final `;'. */
7721 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
7726 /* Create the goto-statement. */
7727 if (cp_lexer_next_token_is (parser
->lexer
, CPP_MULT
))
7729 /* Issue a warning about this use of a GNU extension. */
7730 pedwarn (token
->location
, OPT_pedantic
, "ISO C++ forbids computed gotos");
7731 /* Consume the '*' token. */
7732 cp_lexer_consume_token (parser
->lexer
);
7733 /* Parse the dependent expression. */
7734 finish_goto_stmt (cp_parser_expression (parser
, /*cast_p=*/false, NULL
));
7737 finish_goto_stmt (cp_parser_identifier (parser
));
7738 /* Look for the final `;'. */
7739 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
7743 cp_parser_error (parser
, "expected jump-statement");
7750 /* Parse a declaration-statement.
7752 declaration-statement:
7753 block-declaration */
7756 cp_parser_declaration_statement (cp_parser
* parser
)
7760 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
7761 p
= obstack_alloc (&declarator_obstack
, 0);
7763 /* Parse the block-declaration. */
7764 cp_parser_block_declaration (parser
, /*statement_p=*/true);
7766 /* Free any declarators allocated. */
7767 obstack_free (&declarator_obstack
, p
);
7769 /* Finish off the statement. */
7773 /* Some dependent statements (like `if (cond) statement'), are
7774 implicitly in their own scope. In other words, if the statement is
7775 a single statement (as opposed to a compound-statement), it is
7776 none-the-less treated as if it were enclosed in braces. Any
7777 declarations appearing in the dependent statement are out of scope
7778 after control passes that point. This function parses a statement,
7779 but ensures that is in its own scope, even if it is not a
7782 If IF_P is not NULL, *IF_P is set to indicate whether the statement
7783 is a (possibly labeled) if statement which is not enclosed in
7784 braces and has an else clause. This is used to implement
7787 Returns the new statement. */
7790 cp_parser_implicitly_scoped_statement (cp_parser
* parser
, bool *if_p
)
7797 /* Mark if () ; with a special NOP_EXPR. */
7798 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
7800 cp_lexer_consume_token (parser
->lexer
);
7801 statement
= add_stmt (build_empty_stmt ());
7803 /* if a compound is opened, we simply parse the statement directly. */
7804 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
7805 statement
= cp_parser_compound_statement (parser
, NULL
, false);
7806 /* If the token is not a `{', then we must take special action. */
7809 /* Create a compound-statement. */
7810 statement
= begin_compound_stmt (0);
7811 /* Parse the dependent-statement. */
7812 cp_parser_statement (parser
, NULL_TREE
, false, if_p
);
7813 /* Finish the dummy compound-statement. */
7814 finish_compound_stmt (statement
);
7817 /* Return the statement. */
7821 /* For some dependent statements (like `while (cond) statement'), we
7822 have already created a scope. Therefore, even if the dependent
7823 statement is a compound-statement, we do not want to create another
7827 cp_parser_already_scoped_statement (cp_parser
* parser
)
7829 /* If the token is a `{', then we must take special action. */
7830 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
7831 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
7834 /* Avoid calling cp_parser_compound_statement, so that we
7835 don't create a new scope. Do everything else by hand. */
7836 cp_parser_require (parser
, CPP_OPEN_BRACE
, "%<{%>");
7837 cp_parser_statement_seq_opt (parser
, NULL_TREE
);
7838 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
7842 /* Declarations [gram.dcl.dcl] */
7844 /* Parse an optional declaration-sequence.
7848 declaration-seq declaration */
7851 cp_parser_declaration_seq_opt (cp_parser
* parser
)
7857 token
= cp_lexer_peek_token (parser
->lexer
);
7859 if (token
->type
== CPP_CLOSE_BRACE
7860 || token
->type
== CPP_EOF
7861 || token
->type
== CPP_PRAGMA_EOL
)
7864 if (token
->type
== CPP_SEMICOLON
)
7866 /* A declaration consisting of a single semicolon is
7867 invalid. Allow it unless we're being pedantic. */
7868 cp_lexer_consume_token (parser
->lexer
);
7869 if (!in_system_header
)
7870 pedwarn (input_location
, OPT_pedantic
, "extra %<;%>");
7874 /* If we're entering or exiting a region that's implicitly
7875 extern "C", modify the lang context appropriately. */
7876 if (!parser
->implicit_extern_c
&& token
->implicit_extern_c
)
7878 push_lang_context (lang_name_c
);
7879 parser
->implicit_extern_c
= true;
7881 else if (parser
->implicit_extern_c
&& !token
->implicit_extern_c
)
7883 pop_lang_context ();
7884 parser
->implicit_extern_c
= false;
7887 if (token
->type
== CPP_PRAGMA
)
7889 /* A top-level declaration can consist solely of a #pragma.
7890 A nested declaration cannot, so this is done here and not
7891 in cp_parser_declaration. (A #pragma at block scope is
7892 handled in cp_parser_statement.) */
7893 cp_parser_pragma (parser
, pragma_external
);
7897 /* Parse the declaration itself. */
7898 cp_parser_declaration (parser
);
7902 /* Parse a declaration.
7907 template-declaration
7908 explicit-instantiation
7909 explicit-specialization
7910 linkage-specification
7911 namespace-definition
7916 __extension__ declaration */
7919 cp_parser_declaration (cp_parser
* parser
)
7926 /* Check for the `__extension__' keyword. */
7927 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
7929 /* Parse the qualified declaration. */
7930 cp_parser_declaration (parser
);
7931 /* Restore the PEDANTIC flag. */
7932 pedantic
= saved_pedantic
;
7937 /* Try to figure out what kind of declaration is present. */
7938 token1
= *cp_lexer_peek_token (parser
->lexer
);
7940 if (token1
.type
!= CPP_EOF
)
7941 token2
= *cp_lexer_peek_nth_token (parser
->lexer
, 2);
7944 token2
.type
= CPP_EOF
;
7945 token2
.keyword
= RID_MAX
;
7948 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
7949 p
= obstack_alloc (&declarator_obstack
, 0);
7951 /* If the next token is `extern' and the following token is a string
7952 literal, then we have a linkage specification. */
7953 if (token1
.keyword
== RID_EXTERN
7954 && cp_parser_is_string_literal (&token2
))
7955 cp_parser_linkage_specification (parser
);
7956 /* If the next token is `template', then we have either a template
7957 declaration, an explicit instantiation, or an explicit
7959 else if (token1
.keyword
== RID_TEMPLATE
)
7961 /* `template <>' indicates a template specialization. */
7962 if (token2
.type
== CPP_LESS
7963 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_GREATER
)
7964 cp_parser_explicit_specialization (parser
);
7965 /* `template <' indicates a template declaration. */
7966 else if (token2
.type
== CPP_LESS
)
7967 cp_parser_template_declaration (parser
, /*member_p=*/false);
7968 /* Anything else must be an explicit instantiation. */
7970 cp_parser_explicit_instantiation (parser
);
7972 /* If the next token is `export', then we have a template
7974 else if (token1
.keyword
== RID_EXPORT
)
7975 cp_parser_template_declaration (parser
, /*member_p=*/false);
7976 /* If the next token is `extern', 'static' or 'inline' and the one
7977 after that is `template', we have a GNU extended explicit
7978 instantiation directive. */
7979 else if (cp_parser_allow_gnu_extensions_p (parser
)
7980 && (token1
.keyword
== RID_EXTERN
7981 || token1
.keyword
== RID_STATIC
7982 || token1
.keyword
== RID_INLINE
)
7983 && token2
.keyword
== RID_TEMPLATE
)
7984 cp_parser_explicit_instantiation (parser
);
7985 /* If the next token is `namespace', check for a named or unnamed
7986 namespace definition. */
7987 else if (token1
.keyword
== RID_NAMESPACE
7988 && (/* A named namespace definition. */
7989 (token2
.type
== CPP_NAME
7990 && (cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
7992 /* An unnamed namespace definition. */
7993 || token2
.type
== CPP_OPEN_BRACE
7994 || token2
.keyword
== RID_ATTRIBUTE
))
7995 cp_parser_namespace_definition (parser
);
7996 /* An inline (associated) namespace definition. */
7997 else if (token1
.keyword
== RID_INLINE
7998 && token2
.keyword
== RID_NAMESPACE
)
7999 cp_parser_namespace_definition (parser
);
8000 /* Objective-C++ declaration/definition. */
8001 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1
.keyword
))
8002 cp_parser_objc_declaration (parser
);
8003 /* We must have either a block declaration or a function
8006 /* Try to parse a block-declaration, or a function-definition. */
8007 cp_parser_block_declaration (parser
, /*statement_p=*/false);
8009 /* Free any declarators allocated. */
8010 obstack_free (&declarator_obstack
, p
);
8013 /* Parse a block-declaration.
8018 namespace-alias-definition
8025 __extension__ block-declaration
8030 static_assert-declaration
8032 If STATEMENT_P is TRUE, then this block-declaration is occurring as
8033 part of a declaration-statement. */
8036 cp_parser_block_declaration (cp_parser
*parser
,
8042 /* Check for the `__extension__' keyword. */
8043 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
8045 /* Parse the qualified declaration. */
8046 cp_parser_block_declaration (parser
, statement_p
);
8047 /* Restore the PEDANTIC flag. */
8048 pedantic
= saved_pedantic
;
8053 /* Peek at the next token to figure out which kind of declaration is
8055 token1
= cp_lexer_peek_token (parser
->lexer
);
8057 /* If the next keyword is `asm', we have an asm-definition. */
8058 if (token1
->keyword
== RID_ASM
)
8061 cp_parser_commit_to_tentative_parse (parser
);
8062 cp_parser_asm_definition (parser
);
8064 /* If the next keyword is `namespace', we have a
8065 namespace-alias-definition. */
8066 else if (token1
->keyword
== RID_NAMESPACE
)
8067 cp_parser_namespace_alias_definition (parser
);
8068 /* If the next keyword is `using', we have either a
8069 using-declaration or a using-directive. */
8070 else if (token1
->keyword
== RID_USING
)
8075 cp_parser_commit_to_tentative_parse (parser
);
8076 /* If the token after `using' is `namespace', then we have a
8078 token2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
8079 if (token2
->keyword
== RID_NAMESPACE
)
8080 cp_parser_using_directive (parser
);
8081 /* Otherwise, it's a using-declaration. */
8083 cp_parser_using_declaration (parser
,
8084 /*access_declaration_p=*/false);
8086 /* If the next keyword is `__label__' we have a misplaced label
8088 else if (token1
->keyword
== RID_LABEL
)
8090 cp_lexer_consume_token (parser
->lexer
);
8091 error ("%H%<__label__%> not at the beginning of a block", &token1
->location
);
8092 cp_parser_skip_to_end_of_statement (parser
);
8093 /* If the next token is now a `;', consume it. */
8094 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
8095 cp_lexer_consume_token (parser
->lexer
);
8097 /* If the next token is `static_assert' we have a static assertion. */
8098 else if (token1
->keyword
== RID_STATIC_ASSERT
)
8099 cp_parser_static_assert (parser
, /*member_p=*/false);
8100 /* Anything else must be a simple-declaration. */
8102 cp_parser_simple_declaration (parser
, !statement_p
);
8105 /* Parse a simple-declaration.
8108 decl-specifier-seq [opt] init-declarator-list [opt] ;
8110 init-declarator-list:
8112 init-declarator-list , init-declarator
8114 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
8115 function-definition as a simple-declaration. */
8118 cp_parser_simple_declaration (cp_parser
* parser
,
8119 bool function_definition_allowed_p
)
8121 cp_decl_specifier_seq decl_specifiers
;
8122 int declares_class_or_enum
;
8123 bool saw_declarator
;
8125 /* Defer access checks until we know what is being declared; the
8126 checks for names appearing in the decl-specifier-seq should be
8127 done as if we were in the scope of the thing being declared. */
8128 push_deferring_access_checks (dk_deferred
);
8130 /* Parse the decl-specifier-seq. We have to keep track of whether
8131 or not the decl-specifier-seq declares a named class or
8132 enumeration type, since that is the only case in which the
8133 init-declarator-list is allowed to be empty.
8137 In a simple-declaration, the optional init-declarator-list can be
8138 omitted only when declaring a class or enumeration, that is when
8139 the decl-specifier-seq contains either a class-specifier, an
8140 elaborated-type-specifier, or an enum-specifier. */
8141 cp_parser_decl_specifier_seq (parser
,
8142 CP_PARSER_FLAGS_OPTIONAL
,
8144 &declares_class_or_enum
);
8145 /* We no longer need to defer access checks. */
8146 stop_deferring_access_checks ();
8148 /* In a block scope, a valid declaration must always have a
8149 decl-specifier-seq. By not trying to parse declarators, we can
8150 resolve the declaration/expression ambiguity more quickly. */
8151 if (!function_definition_allowed_p
8152 && !decl_specifiers
.any_specifiers_p
)
8154 cp_parser_error (parser
, "expected declaration");
8158 /* If the next two tokens are both identifiers, the code is
8159 erroneous. The usual cause of this situation is code like:
8163 where "T" should name a type -- but does not. */
8164 if (!decl_specifiers
.type
8165 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
8167 /* If parsing tentatively, we should commit; we really are
8168 looking at a declaration. */
8169 cp_parser_commit_to_tentative_parse (parser
);
8174 /* If we have seen at least one decl-specifier, and the next token
8175 is not a parenthesis, then we must be looking at a declaration.
8176 (After "int (" we might be looking at a functional cast.) */
8177 if (decl_specifiers
.any_specifiers_p
8178 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
)
8179 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
)
8180 && !cp_parser_error_occurred (parser
))
8181 cp_parser_commit_to_tentative_parse (parser
);
8183 /* Keep going until we hit the `;' at the end of the simple
8185 saw_declarator
= false;
8186 while (cp_lexer_next_token_is_not (parser
->lexer
,
8190 bool function_definition_p
;
8195 /* If we are processing next declarator, coma is expected */
8196 token
= cp_lexer_peek_token (parser
->lexer
);
8197 gcc_assert (token
->type
== CPP_COMMA
);
8198 cp_lexer_consume_token (parser
->lexer
);
8201 saw_declarator
= true;
8203 /* Parse the init-declarator. */
8204 decl
= cp_parser_init_declarator (parser
, &decl_specifiers
,
8206 function_definition_allowed_p
,
8208 declares_class_or_enum
,
8209 &function_definition_p
);
8210 /* If an error occurred while parsing tentatively, exit quickly.
8211 (That usually happens when in the body of a function; each
8212 statement is treated as a declaration-statement until proven
8214 if (cp_parser_error_occurred (parser
))
8216 /* Handle function definitions specially. */
8217 if (function_definition_p
)
8219 /* If the next token is a `,', then we are probably
8220 processing something like:
8224 which is erroneous. */
8225 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
8227 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
8228 error ("%Hmixing declarations and function-definitions is forbidden",
8231 /* Otherwise, we're done with the list of declarators. */
8234 pop_deferring_access_checks ();
8238 /* The next token should be either a `,' or a `;'. */
8239 token
= cp_lexer_peek_token (parser
->lexer
);
8240 /* If it's a `,', there are more declarators to come. */
8241 if (token
->type
== CPP_COMMA
)
8242 /* will be consumed next time around */;
8243 /* If it's a `;', we are done. */
8244 else if (token
->type
== CPP_SEMICOLON
)
8246 /* Anything else is an error. */
8249 /* If we have already issued an error message we don't need
8250 to issue another one. */
8251 if (decl
!= error_mark_node
8252 || cp_parser_uncommitted_to_tentative_parse_p (parser
))
8253 cp_parser_error (parser
, "expected %<,%> or %<;%>");
8254 /* Skip tokens until we reach the end of the statement. */
8255 cp_parser_skip_to_end_of_statement (parser
);
8256 /* If the next token is now a `;', consume it. */
8257 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
8258 cp_lexer_consume_token (parser
->lexer
);
8261 /* After the first time around, a function-definition is not
8262 allowed -- even if it was OK at first. For example:
8267 function_definition_allowed_p
= false;
8270 /* Issue an error message if no declarators are present, and the
8271 decl-specifier-seq does not itself declare a class or
8273 if (!saw_declarator
)
8275 if (cp_parser_declares_only_class_p (parser
))
8276 shadow_tag (&decl_specifiers
);
8277 /* Perform any deferred access checks. */
8278 perform_deferred_access_checks ();
8281 /* Consume the `;'. */
8282 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
8285 pop_deferring_access_checks ();
8288 /* Parse a decl-specifier-seq.
8291 decl-specifier-seq [opt] decl-specifier
8294 storage-class-specifier
8305 Set *DECL_SPECS to a representation of the decl-specifier-seq.
8307 The parser flags FLAGS is used to control type-specifier parsing.
8309 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
8312 1: one of the decl-specifiers is an elaborated-type-specifier
8313 (i.e., a type declaration)
8314 2: one of the decl-specifiers is an enum-specifier or a
8315 class-specifier (i.e., a type definition)
8320 cp_parser_decl_specifier_seq (cp_parser
* parser
,
8321 cp_parser_flags flags
,
8322 cp_decl_specifier_seq
*decl_specs
,
8323 int* declares_class_or_enum
)
8325 bool constructor_possible_p
= !parser
->in_declarator_p
;
8326 cp_token
*start_token
= NULL
;
8328 /* Clear DECL_SPECS. */
8329 clear_decl_specs (decl_specs
);
8331 /* Assume no class or enumeration type is declared. */
8332 *declares_class_or_enum
= 0;
8334 /* Keep reading specifiers until there are no more to read. */
8338 bool found_decl_spec
;
8341 /* Peek at the next token. */
8342 token
= cp_lexer_peek_token (parser
->lexer
);
8344 /* Save the first token of the decl spec list for error
8347 start_token
= token
;
8348 /* Handle attributes. */
8349 if (token
->keyword
== RID_ATTRIBUTE
)
8351 /* Parse the attributes. */
8352 decl_specs
->attributes
8353 = chainon (decl_specs
->attributes
,
8354 cp_parser_attributes_opt (parser
));
8357 /* Assume we will find a decl-specifier keyword. */
8358 found_decl_spec
= true;
8359 /* If the next token is an appropriate keyword, we can simply
8360 add it to the list. */
8361 switch (token
->keyword
)
8366 if (!at_class_scope_p ())
8368 error ("%H%<friend%> used outside of class", &token
->location
);
8369 cp_lexer_purge_token (parser
->lexer
);
8373 ++decl_specs
->specs
[(int) ds_friend
];
8374 /* Consume the token. */
8375 cp_lexer_consume_token (parser
->lexer
);
8379 /* function-specifier:
8386 cp_parser_function_specifier_opt (parser
, decl_specs
);
8392 ++decl_specs
->specs
[(int) ds_typedef
];
8393 /* Consume the token. */
8394 cp_lexer_consume_token (parser
->lexer
);
8395 /* A constructor declarator cannot appear in a typedef. */
8396 constructor_possible_p
= false;
8397 /* The "typedef" keyword can only occur in a declaration; we
8398 may as well commit at this point. */
8399 cp_parser_commit_to_tentative_parse (parser
);
8401 if (decl_specs
->storage_class
!= sc_none
)
8402 decl_specs
->conflicting_specifiers_p
= true;
8405 /* storage-class-specifier:
8415 if (cxx_dialect
== cxx98
)
8417 /* Consume the token. */
8418 cp_lexer_consume_token (parser
->lexer
);
8420 /* Complain about `auto' as a storage specifier, if
8421 we're complaining about C++0x compatibility. */
8424 "%H%<auto%> will change meaning in C++0x; please remove it",
8427 /* Set the storage class anyway. */
8428 cp_parser_set_storage_class (parser
, decl_specs
, RID_AUTO
,
8432 /* C++0x auto type-specifier. */
8433 found_decl_spec
= false;
8440 /* Consume the token. */
8441 cp_lexer_consume_token (parser
->lexer
);
8442 cp_parser_set_storage_class (parser
, decl_specs
, token
->keyword
,
8446 /* Consume the token. */
8447 cp_lexer_consume_token (parser
->lexer
);
8448 ++decl_specs
->specs
[(int) ds_thread
];
8452 /* We did not yet find a decl-specifier yet. */
8453 found_decl_spec
= false;
8457 /* Constructors are a special case. The `S' in `S()' is not a
8458 decl-specifier; it is the beginning of the declarator. */
8461 && constructor_possible_p
8462 && (cp_parser_constructor_declarator_p
8463 (parser
, decl_specs
->specs
[(int) ds_friend
] != 0)));
8465 /* If we don't have a DECL_SPEC yet, then we must be looking at
8466 a type-specifier. */
8467 if (!found_decl_spec
&& !constructor_p
)
8469 int decl_spec_declares_class_or_enum
;
8470 bool is_cv_qualifier
;
8474 = cp_parser_type_specifier (parser
, flags
,
8476 /*is_declaration=*/true,
8477 &decl_spec_declares_class_or_enum
,
8479 *declares_class_or_enum
|= decl_spec_declares_class_or_enum
;
8481 /* If this type-specifier referenced a user-defined type
8482 (a typedef, class-name, etc.), then we can't allow any
8483 more such type-specifiers henceforth.
8487 The longest sequence of decl-specifiers that could
8488 possibly be a type name is taken as the
8489 decl-specifier-seq of a declaration. The sequence shall
8490 be self-consistent as described below.
8494 As a general rule, at most one type-specifier is allowed
8495 in the complete decl-specifier-seq of a declaration. The
8496 only exceptions are the following:
8498 -- const or volatile can be combined with any other
8501 -- signed or unsigned can be combined with char, long,
8509 void g (const int Pc);
8511 Here, Pc is *not* part of the decl-specifier seq; it's
8512 the declarator. Therefore, once we see a type-specifier
8513 (other than a cv-qualifier), we forbid any additional
8514 user-defined types. We *do* still allow things like `int
8515 int' to be considered a decl-specifier-seq, and issue the
8516 error message later. */
8517 if (type_spec
&& !is_cv_qualifier
)
8518 flags
|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
;
8519 /* A constructor declarator cannot follow a type-specifier. */
8522 constructor_possible_p
= false;
8523 found_decl_spec
= true;
8527 /* If we still do not have a DECL_SPEC, then there are no more
8529 if (!found_decl_spec
)
8532 decl_specs
->any_specifiers_p
= true;
8533 /* After we see one decl-specifier, further decl-specifiers are
8535 flags
|= CP_PARSER_FLAGS_OPTIONAL
;
8538 cp_parser_check_decl_spec (decl_specs
, start_token
->location
);
8540 /* Don't allow a friend specifier with a class definition. */
8541 if (decl_specs
->specs
[(int) ds_friend
] != 0
8542 && (*declares_class_or_enum
& 2))
8543 error ("%Hclass definition may not be declared a friend",
8544 &start_token
->location
);
8547 /* Parse an (optional) storage-class-specifier.
8549 storage-class-specifier:
8558 storage-class-specifier:
8561 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
8564 cp_parser_storage_class_specifier_opt (cp_parser
* parser
)
8566 switch (cp_lexer_peek_token (parser
->lexer
)->keyword
)
8569 if (cxx_dialect
!= cxx98
)
8571 /* Fall through for C++98. */
8578 /* Consume the token. */
8579 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
8586 /* Parse an (optional) function-specifier.
8593 Returns an IDENTIFIER_NODE corresponding to the keyword used.
8594 Updates DECL_SPECS, if it is non-NULL. */
8597 cp_parser_function_specifier_opt (cp_parser
* parser
,
8598 cp_decl_specifier_seq
*decl_specs
)
8600 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
8601 switch (token
->keyword
)
8605 ++decl_specs
->specs
[(int) ds_inline
];
8609 /* 14.5.2.3 [temp.mem]
8611 A member function template shall not be virtual. */
8612 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8613 error ("%Htemplates may not be %<virtual%>", &token
->location
);
8614 else if (decl_specs
)
8615 ++decl_specs
->specs
[(int) ds_virtual
];
8620 ++decl_specs
->specs
[(int) ds_explicit
];
8627 /* Consume the token. */
8628 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
8631 /* Parse a linkage-specification.
8633 linkage-specification:
8634 extern string-literal { declaration-seq [opt] }
8635 extern string-literal declaration */
8638 cp_parser_linkage_specification (cp_parser
* parser
)
8642 /* Look for the `extern' keyword. */
8643 cp_parser_require_keyword (parser
, RID_EXTERN
, "%<extern%>");
8645 /* Look for the string-literal. */
8646 linkage
= cp_parser_string_literal (parser
, false, false);
8648 /* Transform the literal into an identifier. If the literal is a
8649 wide-character string, or contains embedded NULs, then we can't
8650 handle it as the user wants. */
8651 if (strlen (TREE_STRING_POINTER (linkage
))
8652 != (size_t) (TREE_STRING_LENGTH (linkage
) - 1))
8654 cp_parser_error (parser
, "invalid linkage-specification");
8655 /* Assume C++ linkage. */
8656 linkage
= lang_name_cplusplus
;
8659 linkage
= get_identifier (TREE_STRING_POINTER (linkage
));
8661 /* We're now using the new linkage. */
8662 push_lang_context (linkage
);
8664 /* If the next token is a `{', then we're using the first
8666 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
8668 /* Consume the `{' token. */
8669 cp_lexer_consume_token (parser
->lexer
);
8670 /* Parse the declarations. */
8671 cp_parser_declaration_seq_opt (parser
);
8672 /* Look for the closing `}'. */
8673 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
8675 /* Otherwise, there's just one declaration. */
8678 bool saved_in_unbraced_linkage_specification_p
;
8680 saved_in_unbraced_linkage_specification_p
8681 = parser
->in_unbraced_linkage_specification_p
;
8682 parser
->in_unbraced_linkage_specification_p
= true;
8683 cp_parser_declaration (parser
);
8684 parser
->in_unbraced_linkage_specification_p
8685 = saved_in_unbraced_linkage_specification_p
;
8688 /* We're done with the linkage-specification. */
8689 pop_lang_context ();
8692 /* Parse a static_assert-declaration.
8694 static_assert-declaration:
8695 static_assert ( constant-expression , string-literal ) ;
8697 If MEMBER_P, this static_assert is a class member. */
8700 cp_parser_static_assert(cp_parser
*parser
, bool member_p
)
8705 location_t saved_loc
;
8707 /* Peek at the `static_assert' token so we can keep track of exactly
8708 where the static assertion started. */
8709 token
= cp_lexer_peek_token (parser
->lexer
);
8710 saved_loc
= token
->location
;
8712 /* Look for the `static_assert' keyword. */
8713 if (!cp_parser_require_keyword (parser
, RID_STATIC_ASSERT
,
8714 "%<static_assert%>"))
8717 /* We know we are in a static assertion; commit to any tentative
8719 if (cp_parser_parsing_tentatively (parser
))
8720 cp_parser_commit_to_tentative_parse (parser
);
8722 /* Parse the `(' starting the static assertion condition. */
8723 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
8725 /* Parse the constant-expression. */
8727 cp_parser_constant_expression (parser
,
8728 /*allow_non_constant_p=*/false,
8729 /*non_constant_p=*/NULL
);
8731 /* Parse the separating `,'. */
8732 cp_parser_require (parser
, CPP_COMMA
, "%<,%>");
8734 /* Parse the string-literal message. */
8735 message
= cp_parser_string_literal (parser
,
8736 /*translate=*/false,
8739 /* A `)' completes the static assertion. */
8740 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
8741 cp_parser_skip_to_closing_parenthesis (parser
,
8742 /*recovering=*/true,
8744 /*consume_paren=*/true);
8746 /* A semicolon terminates the declaration. */
8747 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
8749 /* Complete the static assertion, which may mean either processing
8750 the static assert now or saving it for template instantiation. */
8751 finish_static_assert (condition
, message
, saved_loc
, member_p
);
8754 /* Parse a `decltype' type. Returns the type.
8756 simple-type-specifier:
8757 decltype ( expression ) */
8760 cp_parser_decltype (cp_parser
*parser
)
8763 bool id_expression_or_member_access_p
= false;
8764 const char *saved_message
;
8765 bool saved_integral_constant_expression_p
;
8766 bool saved_non_integral_constant_expression_p
;
8767 cp_token
*id_expr_start_token
;
8769 /* Look for the `decltype' token. */
8770 if (!cp_parser_require_keyword (parser
, RID_DECLTYPE
, "%<decltype%>"))
8771 return error_mark_node
;
8773 /* Types cannot be defined in a `decltype' expression. Save away the
8775 saved_message
= parser
->type_definition_forbidden_message
;
8777 /* And create the new one. */
8778 parser
->type_definition_forbidden_message
8779 = "types may not be defined in %<decltype%> expressions";
8781 /* The restrictions on constant-expressions do not apply inside
8782 decltype expressions. */
8783 saved_integral_constant_expression_p
8784 = parser
->integral_constant_expression_p
;
8785 saved_non_integral_constant_expression_p
8786 = parser
->non_integral_constant_expression_p
;
8787 parser
->integral_constant_expression_p
= false;
8789 /* Do not actually evaluate the expression. */
8792 /* Parse the opening `('. */
8793 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
8794 return error_mark_node
;
8796 /* First, try parsing an id-expression. */
8797 id_expr_start_token
= cp_lexer_peek_token (parser
->lexer
);
8798 cp_parser_parse_tentatively (parser
);
8799 expr
= cp_parser_id_expression (parser
,
8800 /*template_keyword_p=*/false,
8801 /*check_dependency_p=*/true,
8802 /*template_p=*/NULL
,
8803 /*declarator_p=*/false,
8804 /*optional_p=*/false);
8806 if (!cp_parser_error_occurred (parser
) && expr
!= error_mark_node
)
8808 bool non_integral_constant_expression_p
= false;
8809 tree id_expression
= expr
;
8811 const char *error_msg
;
8813 if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
8814 /* Lookup the name we got back from the id-expression. */
8815 expr
= cp_parser_lookup_name (parser
, expr
,
8817 /*is_template=*/false,
8818 /*is_namespace=*/false,
8819 /*check_dependency=*/true,
8820 /*ambiguous_decls=*/NULL
,
8821 id_expr_start_token
->location
);
8824 && expr
!= error_mark_node
8825 && TREE_CODE (expr
) != TEMPLATE_ID_EXPR
8826 && TREE_CODE (expr
) != TYPE_DECL
8827 && (TREE_CODE (expr
) != BIT_NOT_EXPR
8828 || !TYPE_P (TREE_OPERAND (expr
, 0)))
8829 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
8831 /* Complete lookup of the id-expression. */
8832 expr
= (finish_id_expression
8833 (id_expression
, expr
, parser
->scope
, &idk
,
8834 /*integral_constant_expression_p=*/false,
8835 /*allow_non_integral_constant_expression_p=*/true,
8836 &non_integral_constant_expression_p
,
8837 /*template_p=*/false,
8839 /*address_p=*/false,
8840 /*template_arg_p=*/false,
8842 id_expr_start_token
->location
));
8844 if (expr
== error_mark_node
)
8845 /* We found an id-expression, but it was something that we
8846 should not have found. This is an error, not something
8847 we can recover from, so note that we found an
8848 id-expression and we'll recover as gracefully as
8850 id_expression_or_member_access_p
= true;
8854 && expr
!= error_mark_node
8855 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
8856 /* We have an id-expression. */
8857 id_expression_or_member_access_p
= true;
8860 if (!id_expression_or_member_access_p
)
8862 /* Abort the id-expression parse. */
8863 cp_parser_abort_tentative_parse (parser
);
8865 /* Parsing tentatively, again. */
8866 cp_parser_parse_tentatively (parser
);
8868 /* Parse a class member access. */
8869 expr
= cp_parser_postfix_expression (parser
, /*address_p=*/false,
8871 /*member_access_only_p=*/true, NULL
);
8874 && expr
!= error_mark_node
8875 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
8876 /* We have an id-expression. */
8877 id_expression_or_member_access_p
= true;
8880 if (id_expression_or_member_access_p
)
8881 /* We have parsed the complete id-expression or member access. */
8882 cp_parser_parse_definitely (parser
);
8885 /* Abort our attempt to parse an id-expression or member access
8887 cp_parser_abort_tentative_parse (parser
);
8889 /* Parse a full expression. */
8890 expr
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
8893 /* Go back to evaluating expressions. */
8896 /* Restore the old message and the integral constant expression
8898 parser
->type_definition_forbidden_message
= saved_message
;
8899 parser
->integral_constant_expression_p
8900 = saved_integral_constant_expression_p
;
8901 parser
->non_integral_constant_expression_p
8902 = saved_non_integral_constant_expression_p
;
8904 if (expr
== error_mark_node
)
8906 /* Skip everything up to the closing `)'. */
8907 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
8908 /*consume_paren=*/true);
8909 return error_mark_node
;
8912 /* Parse to the closing `)'. */
8913 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
8915 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
8916 /*consume_paren=*/true);
8917 return error_mark_node
;
8920 return finish_decltype_type (expr
, id_expression_or_member_access_p
);
8923 /* Special member functions [gram.special] */
8925 /* Parse a conversion-function-id.
8927 conversion-function-id:
8928 operator conversion-type-id
8930 Returns an IDENTIFIER_NODE representing the operator. */
8933 cp_parser_conversion_function_id (cp_parser
* parser
)
8937 tree saved_qualifying_scope
;
8938 tree saved_object_scope
;
8939 tree pushed_scope
= NULL_TREE
;
8941 /* Look for the `operator' token. */
8942 if (!cp_parser_require_keyword (parser
, RID_OPERATOR
, "%<operator%>"))
8943 return error_mark_node
;
8944 /* When we parse the conversion-type-id, the current scope will be
8945 reset. However, we need that information in able to look up the
8946 conversion function later, so we save it here. */
8947 saved_scope
= parser
->scope
;
8948 saved_qualifying_scope
= parser
->qualifying_scope
;
8949 saved_object_scope
= parser
->object_scope
;
8950 /* We must enter the scope of the class so that the names of
8951 entities declared within the class are available in the
8952 conversion-type-id. For example, consider:
8959 S::operator I() { ... }
8961 In order to see that `I' is a type-name in the definition, we
8962 must be in the scope of `S'. */
8964 pushed_scope
= push_scope (saved_scope
);
8965 /* Parse the conversion-type-id. */
8966 type
= cp_parser_conversion_type_id (parser
);
8967 /* Leave the scope of the class, if any. */
8969 pop_scope (pushed_scope
);
8970 /* Restore the saved scope. */
8971 parser
->scope
= saved_scope
;
8972 parser
->qualifying_scope
= saved_qualifying_scope
;
8973 parser
->object_scope
= saved_object_scope
;
8974 /* If the TYPE is invalid, indicate failure. */
8975 if (type
== error_mark_node
)
8976 return error_mark_node
;
8977 return mangle_conv_op_name_for_type (type
);
8980 /* Parse a conversion-type-id:
8983 type-specifier-seq conversion-declarator [opt]
8985 Returns the TYPE specified. */
8988 cp_parser_conversion_type_id (cp_parser
* parser
)
8991 cp_decl_specifier_seq type_specifiers
;
8992 cp_declarator
*declarator
;
8993 tree type_specified
;
8995 /* Parse the attributes. */
8996 attributes
= cp_parser_attributes_opt (parser
);
8997 /* Parse the type-specifiers. */
8998 cp_parser_type_specifier_seq (parser
, /*is_condition=*/false,
9000 /* If that didn't work, stop. */
9001 if (type_specifiers
.type
== error_mark_node
)
9002 return error_mark_node
;
9003 /* Parse the conversion-declarator. */
9004 declarator
= cp_parser_conversion_declarator_opt (parser
);
9006 type_specified
= grokdeclarator (declarator
, &type_specifiers
, TYPENAME
,
9007 /*initialized=*/0, &attributes
);
9009 cplus_decl_attributes (&type_specified
, attributes
, /*flags=*/0);
9011 /* Don't give this error when parsing tentatively. This happens to
9012 work because we always parse this definitively once. */
9013 if (! cp_parser_uncommitted_to_tentative_parse_p (parser
)
9014 && type_uses_auto (type_specified
))
9016 error ("invalid use of %<auto%> in conversion operator");
9017 return error_mark_node
;
9020 return type_specified
;
9023 /* Parse an (optional) conversion-declarator.
9025 conversion-declarator:
9026 ptr-operator conversion-declarator [opt]
9030 static cp_declarator
*
9031 cp_parser_conversion_declarator_opt (cp_parser
* parser
)
9033 enum tree_code code
;
9035 cp_cv_quals cv_quals
;
9037 /* We don't know if there's a ptr-operator next, or not. */
9038 cp_parser_parse_tentatively (parser
);
9039 /* Try the ptr-operator. */
9040 code
= cp_parser_ptr_operator (parser
, &class_type
, &cv_quals
);
9041 /* If it worked, look for more conversion-declarators. */
9042 if (cp_parser_parse_definitely (parser
))
9044 cp_declarator
*declarator
;
9046 /* Parse another optional declarator. */
9047 declarator
= cp_parser_conversion_declarator_opt (parser
);
9049 return cp_parser_make_indirect_declarator
9050 (code
, class_type
, cv_quals
, declarator
);
9056 /* Parse an (optional) ctor-initializer.
9059 : mem-initializer-list
9061 Returns TRUE iff the ctor-initializer was actually present. */
9064 cp_parser_ctor_initializer_opt (cp_parser
* parser
)
9066 /* If the next token is not a `:', then there is no
9067 ctor-initializer. */
9068 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
9070 /* Do default initialization of any bases and members. */
9071 if (DECL_CONSTRUCTOR_P (current_function_decl
))
9072 finish_mem_initializers (NULL_TREE
);
9077 /* Consume the `:' token. */
9078 cp_lexer_consume_token (parser
->lexer
);
9079 /* And the mem-initializer-list. */
9080 cp_parser_mem_initializer_list (parser
);
9085 /* Parse a mem-initializer-list.
9087 mem-initializer-list:
9088 mem-initializer ... [opt]
9089 mem-initializer ... [opt] , mem-initializer-list */
9092 cp_parser_mem_initializer_list (cp_parser
* parser
)
9094 tree mem_initializer_list
= NULL_TREE
;
9095 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
9097 /* Let the semantic analysis code know that we are starting the
9098 mem-initializer-list. */
9099 if (!DECL_CONSTRUCTOR_P (current_function_decl
))
9100 error ("%Honly constructors take base initializers",
9103 /* Loop through the list. */
9106 tree mem_initializer
;
9108 token
= cp_lexer_peek_token (parser
->lexer
);
9109 /* Parse the mem-initializer. */
9110 mem_initializer
= cp_parser_mem_initializer (parser
);
9111 /* If the next token is a `...', we're expanding member initializers. */
9112 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
9114 /* Consume the `...'. */
9115 cp_lexer_consume_token (parser
->lexer
);
9117 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
9118 can be expanded but members cannot. */
9119 if (mem_initializer
!= error_mark_node
9120 && !TYPE_P (TREE_PURPOSE (mem_initializer
)))
9122 error ("%Hcannot expand initializer for member %<%D%>",
9123 &token
->location
, TREE_PURPOSE (mem_initializer
));
9124 mem_initializer
= error_mark_node
;
9127 /* Construct the pack expansion type. */
9128 if (mem_initializer
!= error_mark_node
)
9129 mem_initializer
= make_pack_expansion (mem_initializer
);
9131 /* Add it to the list, unless it was erroneous. */
9132 if (mem_initializer
!= error_mark_node
)
9134 TREE_CHAIN (mem_initializer
) = mem_initializer_list
;
9135 mem_initializer_list
= mem_initializer
;
9137 /* If the next token is not a `,', we're done. */
9138 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
9140 /* Consume the `,' token. */
9141 cp_lexer_consume_token (parser
->lexer
);
9144 /* Perform semantic analysis. */
9145 if (DECL_CONSTRUCTOR_P (current_function_decl
))
9146 finish_mem_initializers (mem_initializer_list
);
9149 /* Parse a mem-initializer.
9152 mem-initializer-id ( expression-list [opt] )
9153 mem-initializer-id braced-init-list
9158 ( expression-list [opt] )
9160 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
9161 class) or FIELD_DECL (for a non-static data member) to initialize;
9162 the TREE_VALUE is the expression-list. An empty initialization
9163 list is represented by void_list_node. */
9166 cp_parser_mem_initializer (cp_parser
* parser
)
9168 tree mem_initializer_id
;
9169 tree expression_list
;
9171 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
9173 /* Find out what is being initialized. */
9174 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
9176 permerror (token
->location
,
9177 "anachronistic old-style base class initializer");
9178 mem_initializer_id
= NULL_TREE
;
9181 mem_initializer_id
= cp_parser_mem_initializer_id (parser
);
9182 member
= expand_member_init (mem_initializer_id
);
9183 if (member
&& !DECL_P (member
))
9184 in_base_initializer
= 1;
9186 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
9188 bool expr_non_constant_p
;
9189 maybe_warn_cpp0x ("extended initializer lists");
9190 expression_list
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
9191 CONSTRUCTOR_IS_DIRECT_INIT (expression_list
) = 1;
9192 expression_list
= build_tree_list (NULL_TREE
, expression_list
);
9196 = cp_parser_parenthesized_expression_list (parser
, false,
9198 /*allow_expansion_p=*/true,
9199 /*non_constant_p=*/NULL
);
9200 if (expression_list
== error_mark_node
)
9201 return error_mark_node
;
9202 if (!expression_list
)
9203 expression_list
= void_type_node
;
9205 in_base_initializer
= 0;
9207 return member
? build_tree_list (member
, expression_list
) : error_mark_node
;
9210 /* Parse a mem-initializer-id.
9213 :: [opt] nested-name-specifier [opt] class-name
9216 Returns a TYPE indicating the class to be initializer for the first
9217 production. Returns an IDENTIFIER_NODE indicating the data member
9218 to be initialized for the second production. */
9221 cp_parser_mem_initializer_id (cp_parser
* parser
)
9223 bool global_scope_p
;
9224 bool nested_name_specifier_p
;
9225 bool template_p
= false;
9228 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
9230 /* `typename' is not allowed in this context ([temp.res]). */
9231 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TYPENAME
))
9233 error ("%Hkeyword %<typename%> not allowed in this context (a qualified "
9234 "member initializer is implicitly a type)",
9236 cp_lexer_consume_token (parser
->lexer
);
9238 /* Look for the optional `::' operator. */
9240 = (cp_parser_global_scope_opt (parser
,
9241 /*current_scope_valid_p=*/false)
9243 /* Look for the optional nested-name-specifier. The simplest way to
9248 The keyword `typename' is not permitted in a base-specifier or
9249 mem-initializer; in these contexts a qualified name that
9250 depends on a template-parameter is implicitly assumed to be a
9253 is to assume that we have seen the `typename' keyword at this
9255 nested_name_specifier_p
9256 = (cp_parser_nested_name_specifier_opt (parser
,
9257 /*typename_keyword_p=*/true,
9258 /*check_dependency_p=*/true,
9260 /*is_declaration=*/true)
9262 if (nested_name_specifier_p
)
9263 template_p
= cp_parser_optional_template_keyword (parser
);
9264 /* If there is a `::' operator or a nested-name-specifier, then we
9265 are definitely looking for a class-name. */
9266 if (global_scope_p
|| nested_name_specifier_p
)
9267 return cp_parser_class_name (parser
,
9268 /*typename_keyword_p=*/true,
9269 /*template_keyword_p=*/template_p
,
9271 /*check_dependency_p=*/true,
9272 /*class_head_p=*/false,
9273 /*is_declaration=*/true);
9274 /* Otherwise, we could also be looking for an ordinary identifier. */
9275 cp_parser_parse_tentatively (parser
);
9276 /* Try a class-name. */
9277 id
= cp_parser_class_name (parser
,
9278 /*typename_keyword_p=*/true,
9279 /*template_keyword_p=*/false,
9281 /*check_dependency_p=*/true,
9282 /*class_head_p=*/false,
9283 /*is_declaration=*/true);
9284 /* If we found one, we're done. */
9285 if (cp_parser_parse_definitely (parser
))
9287 /* Otherwise, look for an ordinary identifier. */
9288 return cp_parser_identifier (parser
);
9291 /* Overloading [gram.over] */
9293 /* Parse an operator-function-id.
9295 operator-function-id:
9298 Returns an IDENTIFIER_NODE for the operator which is a
9299 human-readable spelling of the identifier, e.g., `operator +'. */
9302 cp_parser_operator_function_id (cp_parser
* parser
)
9304 /* Look for the `operator' keyword. */
9305 if (!cp_parser_require_keyword (parser
, RID_OPERATOR
, "%<operator%>"))
9306 return error_mark_node
;
9307 /* And then the name of the operator itself. */
9308 return cp_parser_operator (parser
);
9311 /* Parse an operator.
9314 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
9315 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
9316 || ++ -- , ->* -> () []
9323 Returns an IDENTIFIER_NODE for the operator which is a
9324 human-readable spelling of the identifier, e.g., `operator +'. */
9327 cp_parser_operator (cp_parser
* parser
)
9329 tree id
= NULL_TREE
;
9332 /* Peek at the next token. */
9333 token
= cp_lexer_peek_token (parser
->lexer
);
9334 /* Figure out which operator we have. */
9335 switch (token
->type
)
9341 /* The keyword should be either `new' or `delete'. */
9342 if (token
->keyword
== RID_NEW
)
9344 else if (token
->keyword
== RID_DELETE
)
9349 /* Consume the `new' or `delete' token. */
9350 cp_lexer_consume_token (parser
->lexer
);
9352 /* Peek at the next token. */
9353 token
= cp_lexer_peek_token (parser
->lexer
);
9354 /* If it's a `[' token then this is the array variant of the
9356 if (token
->type
== CPP_OPEN_SQUARE
)
9358 /* Consume the `[' token. */
9359 cp_lexer_consume_token (parser
->lexer
);
9360 /* Look for the `]' token. */
9361 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>");
9362 id
= ansi_opname (op
== NEW_EXPR
9363 ? VEC_NEW_EXPR
: VEC_DELETE_EXPR
);
9365 /* Otherwise, we have the non-array variant. */
9367 id
= ansi_opname (op
);
9373 id
= ansi_opname (PLUS_EXPR
);
9377 id
= ansi_opname (MINUS_EXPR
);
9381 id
= ansi_opname (MULT_EXPR
);
9385 id
= ansi_opname (TRUNC_DIV_EXPR
);
9389 id
= ansi_opname (TRUNC_MOD_EXPR
);
9393 id
= ansi_opname (BIT_XOR_EXPR
);
9397 id
= ansi_opname (BIT_AND_EXPR
);
9401 id
= ansi_opname (BIT_IOR_EXPR
);
9405 id
= ansi_opname (BIT_NOT_EXPR
);
9409 id
= ansi_opname (TRUTH_NOT_EXPR
);
9413 id
= ansi_assopname (NOP_EXPR
);
9417 id
= ansi_opname (LT_EXPR
);
9421 id
= ansi_opname (GT_EXPR
);
9425 id
= ansi_assopname (PLUS_EXPR
);
9429 id
= ansi_assopname (MINUS_EXPR
);
9433 id
= ansi_assopname (MULT_EXPR
);
9437 id
= ansi_assopname (TRUNC_DIV_EXPR
);
9441 id
= ansi_assopname (TRUNC_MOD_EXPR
);
9445 id
= ansi_assopname (BIT_XOR_EXPR
);
9449 id
= ansi_assopname (BIT_AND_EXPR
);
9453 id
= ansi_assopname (BIT_IOR_EXPR
);
9457 id
= ansi_opname (LSHIFT_EXPR
);
9461 id
= ansi_opname (RSHIFT_EXPR
);
9465 id
= ansi_assopname (LSHIFT_EXPR
);
9469 id
= ansi_assopname (RSHIFT_EXPR
);
9473 id
= ansi_opname (EQ_EXPR
);
9477 id
= ansi_opname (NE_EXPR
);
9481 id
= ansi_opname (LE_EXPR
);
9484 case CPP_GREATER_EQ
:
9485 id
= ansi_opname (GE_EXPR
);
9489 id
= ansi_opname (TRUTH_ANDIF_EXPR
);
9493 id
= ansi_opname (TRUTH_ORIF_EXPR
);
9497 id
= ansi_opname (POSTINCREMENT_EXPR
);
9500 case CPP_MINUS_MINUS
:
9501 id
= ansi_opname (PREDECREMENT_EXPR
);
9505 id
= ansi_opname (COMPOUND_EXPR
);
9508 case CPP_DEREF_STAR
:
9509 id
= ansi_opname (MEMBER_REF
);
9513 id
= ansi_opname (COMPONENT_REF
);
9516 case CPP_OPEN_PAREN
:
9517 /* Consume the `('. */
9518 cp_lexer_consume_token (parser
->lexer
);
9519 /* Look for the matching `)'. */
9520 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
9521 return ansi_opname (CALL_EXPR
);
9523 case CPP_OPEN_SQUARE
:
9524 /* Consume the `['. */
9525 cp_lexer_consume_token (parser
->lexer
);
9526 /* Look for the matching `]'. */
9527 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>");
9528 return ansi_opname (ARRAY_REF
);
9531 /* Anything else is an error. */
9535 /* If we have selected an identifier, we need to consume the
9538 cp_lexer_consume_token (parser
->lexer
);
9539 /* Otherwise, no valid operator name was present. */
9542 cp_parser_error (parser
, "expected operator");
9543 id
= error_mark_node
;
9549 /* Parse a template-declaration.
9551 template-declaration:
9552 export [opt] template < template-parameter-list > declaration
9554 If MEMBER_P is TRUE, this template-declaration occurs within a
9557 The grammar rule given by the standard isn't correct. What
9560 template-declaration:
9561 export [opt] template-parameter-list-seq
9562 decl-specifier-seq [opt] init-declarator [opt] ;
9563 export [opt] template-parameter-list-seq
9566 template-parameter-list-seq:
9567 template-parameter-list-seq [opt]
9568 template < template-parameter-list > */
9571 cp_parser_template_declaration (cp_parser
* parser
, bool member_p
)
9573 /* Check for `export'. */
9574 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_EXPORT
))
9576 /* Consume the `export' token. */
9577 cp_lexer_consume_token (parser
->lexer
);
9578 /* Warn that we do not support `export'. */
9579 warning (0, "keyword %<export%> not implemented, and will be ignored");
9582 cp_parser_template_declaration_after_export (parser
, member_p
);
9585 /* Parse a template-parameter-list.
9587 template-parameter-list:
9589 template-parameter-list , template-parameter
9591 Returns a TREE_LIST. Each node represents a template parameter.
9592 The nodes are connected via their TREE_CHAINs. */
9595 cp_parser_template_parameter_list (cp_parser
* parser
)
9597 tree parameter_list
= NULL_TREE
;
9599 begin_template_parm_list ();
9604 bool is_parameter_pack
;
9606 /* Parse the template-parameter. */
9607 parameter
= cp_parser_template_parameter (parser
,
9609 &is_parameter_pack
);
9610 /* Add it to the list. */
9611 if (parameter
!= error_mark_node
)
9612 parameter_list
= process_template_parm (parameter_list
,
9618 tree err_parm
= build_tree_list (parameter
, parameter
);
9619 TREE_VALUE (err_parm
) = error_mark_node
;
9620 parameter_list
= chainon (parameter_list
, err_parm
);
9623 /* If the next token is not a `,', we're done. */
9624 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
9626 /* Otherwise, consume the `,' token. */
9627 cp_lexer_consume_token (parser
->lexer
);
9630 return end_template_parm_list (parameter_list
);
9633 /* Parse a template-parameter.
9637 parameter-declaration
9639 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
9640 the parameter. The TREE_PURPOSE is the default value, if any.
9641 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
9642 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
9643 set to true iff this parameter is a parameter pack. */
9646 cp_parser_template_parameter (cp_parser
* parser
, bool *is_non_type
,
9647 bool *is_parameter_pack
)
9650 cp_parameter_declarator
*parameter_declarator
;
9651 cp_declarator
*id_declarator
;
9654 /* Assume it is a type parameter or a template parameter. */
9655 *is_non_type
= false;
9656 /* Assume it not a parameter pack. */
9657 *is_parameter_pack
= false;
9658 /* Peek at the next token. */
9659 token
= cp_lexer_peek_token (parser
->lexer
);
9660 /* If it is `class' or `template', we have a type-parameter. */
9661 if (token
->keyword
== RID_TEMPLATE
)
9662 return cp_parser_type_parameter (parser
, is_parameter_pack
);
9663 /* If it is `class' or `typename' we do not know yet whether it is a
9664 type parameter or a non-type parameter. Consider:
9666 template <typename T, typename T::X X> ...
9670 template <class C, class D*> ...
9672 Here, the first parameter is a type parameter, and the second is
9673 a non-type parameter. We can tell by looking at the token after
9674 the identifier -- if it is a `,', `=', or `>' then we have a type
9676 if (token
->keyword
== RID_TYPENAME
|| token
->keyword
== RID_CLASS
)
9678 /* Peek at the token after `class' or `typename'. */
9679 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
9680 /* If it's an ellipsis, we have a template type parameter
9682 if (token
->type
== CPP_ELLIPSIS
)
9683 return cp_parser_type_parameter (parser
, is_parameter_pack
);
9684 /* If it's an identifier, skip it. */
9685 if (token
->type
== CPP_NAME
)
9686 token
= cp_lexer_peek_nth_token (parser
->lexer
, 3);
9687 /* Now, see if the token looks like the end of a template
9689 if (token
->type
== CPP_COMMA
9690 || token
->type
== CPP_EQ
9691 || token
->type
== CPP_GREATER
)
9692 return cp_parser_type_parameter (parser
, is_parameter_pack
);
9695 /* Otherwise, it is a non-type parameter.
9699 When parsing a default template-argument for a non-type
9700 template-parameter, the first non-nested `>' is taken as the end
9701 of the template parameter-list rather than a greater-than
9703 *is_non_type
= true;
9704 parameter_declarator
9705 = cp_parser_parameter_declaration (parser
, /*template_parm_p=*/true,
9706 /*parenthesized_p=*/NULL
);
9708 /* If the parameter declaration is marked as a parameter pack, set
9709 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
9710 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
9712 if (parameter_declarator
9713 && parameter_declarator
->declarator
9714 && parameter_declarator
->declarator
->parameter_pack_p
)
9716 *is_parameter_pack
= true;
9717 parameter_declarator
->declarator
->parameter_pack_p
= false;
9720 /* If the next token is an ellipsis, and we don't already have it
9721 marked as a parameter pack, then we have a parameter pack (that
9722 has no declarator). */
9723 if (!*is_parameter_pack
9724 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
)
9725 && declarator_can_be_parameter_pack (parameter_declarator
->declarator
))
9727 /* Consume the `...'. */
9728 cp_lexer_consume_token (parser
->lexer
);
9729 maybe_warn_variadic_templates ();
9731 *is_parameter_pack
= true;
9733 /* We might end up with a pack expansion as the type of the non-type
9734 template parameter, in which case this is a non-type template
9736 else if (parameter_declarator
9737 && parameter_declarator
->decl_specifiers
.type
9738 && PACK_EXPANSION_P (parameter_declarator
->decl_specifiers
.type
))
9740 *is_parameter_pack
= true;
9741 parameter_declarator
->decl_specifiers
.type
=
9742 PACK_EXPANSION_PATTERN (parameter_declarator
->decl_specifiers
.type
);
9745 if (*is_parameter_pack
&& cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
9747 /* Parameter packs cannot have default arguments. However, a
9748 user may try to do so, so we'll parse them and give an
9749 appropriate diagnostic here. */
9751 /* Consume the `='. */
9752 cp_token
*start_token
= cp_lexer_peek_token (parser
->lexer
);
9753 cp_lexer_consume_token (parser
->lexer
);
9755 /* Find the name of the parameter pack. */
9756 id_declarator
= parameter_declarator
->declarator
;
9757 while (id_declarator
&& id_declarator
->kind
!= cdk_id
)
9758 id_declarator
= id_declarator
->declarator
;
9760 if (id_declarator
&& id_declarator
->kind
== cdk_id
)
9761 error ("%Htemplate parameter pack %qD cannot have a default argument",
9762 &start_token
->location
, id_declarator
->u
.id
.unqualified_name
);
9764 error ("%Htemplate parameter pack cannot have a default argument",
9765 &start_token
->location
);
9767 /* Parse the default argument, but throw away the result. */
9768 cp_parser_default_argument (parser
, /*template_parm_p=*/true);
9771 parm
= grokdeclarator (parameter_declarator
->declarator
,
9772 ¶meter_declarator
->decl_specifiers
,
9773 PARM
, /*initialized=*/0,
9775 if (parm
== error_mark_node
)
9776 return error_mark_node
;
9778 return build_tree_list (parameter_declarator
->default_argument
, parm
);
9781 /* Parse a type-parameter.
9784 class identifier [opt]
9785 class identifier [opt] = type-id
9786 typename identifier [opt]
9787 typename identifier [opt] = type-id
9788 template < template-parameter-list > class identifier [opt]
9789 template < template-parameter-list > class identifier [opt]
9792 GNU Extension (variadic templates):
9795 class ... identifier [opt]
9796 typename ... identifier [opt]
9798 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
9799 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
9800 the declaration of the parameter.
9802 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
9805 cp_parser_type_parameter (cp_parser
* parser
, bool *is_parameter_pack
)
9810 /* Look for a keyword to tell us what kind of parameter this is. */
9811 token
= cp_parser_require (parser
, CPP_KEYWORD
,
9812 "%<class%>, %<typename%>, or %<template%>");
9814 return error_mark_node
;
9816 switch (token
->keyword
)
9822 tree default_argument
;
9824 /* If the next token is an ellipsis, we have a template
9826 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
9828 /* Consume the `...' token. */
9829 cp_lexer_consume_token (parser
->lexer
);
9830 maybe_warn_variadic_templates ();
9832 *is_parameter_pack
= true;
9835 /* If the next token is an identifier, then it names the
9837 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
9838 identifier
= cp_parser_identifier (parser
);
9840 identifier
= NULL_TREE
;
9842 /* Create the parameter. */
9843 parameter
= finish_template_type_parm (class_type_node
, identifier
);
9845 /* If the next token is an `=', we have a default argument. */
9846 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
9848 /* Consume the `=' token. */
9849 cp_lexer_consume_token (parser
->lexer
);
9850 /* Parse the default-argument. */
9851 push_deferring_access_checks (dk_no_deferred
);
9852 default_argument
= cp_parser_type_id (parser
);
9854 /* Template parameter packs cannot have default
9856 if (*is_parameter_pack
)
9859 error ("%Htemplate parameter pack %qD cannot have a "
9860 "default argument", &token
->location
, identifier
);
9862 error ("%Htemplate parameter packs cannot have "
9863 "default arguments", &token
->location
);
9864 default_argument
= NULL_TREE
;
9866 pop_deferring_access_checks ();
9869 default_argument
= NULL_TREE
;
9871 /* Create the combined representation of the parameter and the
9872 default argument. */
9873 parameter
= build_tree_list (default_argument
, parameter
);
9879 tree parameter_list
;
9881 tree default_argument
;
9883 /* Look for the `<'. */
9884 cp_parser_require (parser
, CPP_LESS
, "%<<%>");
9885 /* Parse the template-parameter-list. */
9886 parameter_list
= cp_parser_template_parameter_list (parser
);
9887 /* Look for the `>'. */
9888 cp_parser_require (parser
, CPP_GREATER
, "%<>%>");
9889 /* Look for the `class' keyword. */
9890 cp_parser_require_keyword (parser
, RID_CLASS
, "%<class%>");
9891 /* If the next token is an ellipsis, we have a template
9893 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
9895 /* Consume the `...' token. */
9896 cp_lexer_consume_token (parser
->lexer
);
9897 maybe_warn_variadic_templates ();
9899 *is_parameter_pack
= true;
9901 /* If the next token is an `=', then there is a
9902 default-argument. If the next token is a `>', we are at
9903 the end of the parameter-list. If the next token is a `,',
9904 then we are at the end of this parameter. */
9905 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
)
9906 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_GREATER
)
9907 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
9909 identifier
= cp_parser_identifier (parser
);
9910 /* Treat invalid names as if the parameter were nameless. */
9911 if (identifier
== error_mark_node
)
9912 identifier
= NULL_TREE
;
9915 identifier
= NULL_TREE
;
9917 /* Create the template parameter. */
9918 parameter
= finish_template_template_parm (class_type_node
,
9921 /* If the next token is an `=', then there is a
9922 default-argument. */
9923 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
9927 /* Consume the `='. */
9928 cp_lexer_consume_token (parser
->lexer
);
9929 /* Parse the id-expression. */
9930 push_deferring_access_checks (dk_no_deferred
);
9931 /* save token before parsing the id-expression, for error
9933 token
= cp_lexer_peek_token (parser
->lexer
);
9935 = cp_parser_id_expression (parser
,
9936 /*template_keyword_p=*/false,
9937 /*check_dependency_p=*/true,
9938 /*template_p=*/&is_template
,
9939 /*declarator_p=*/false,
9940 /*optional_p=*/false);
9941 if (TREE_CODE (default_argument
) == TYPE_DECL
)
9942 /* If the id-expression was a template-id that refers to
9943 a template-class, we already have the declaration here,
9944 so no further lookup is needed. */
9947 /* Look up the name. */
9949 = cp_parser_lookup_name (parser
, default_argument
,
9951 /*is_template=*/is_template
,
9952 /*is_namespace=*/false,
9953 /*check_dependency=*/true,
9954 /*ambiguous_decls=*/NULL
,
9956 /* See if the default argument is valid. */
9958 = check_template_template_default_arg (default_argument
);
9960 /* Template parameter packs cannot have default
9962 if (*is_parameter_pack
)
9965 error ("%Htemplate parameter pack %qD cannot "
9966 "have a default argument",
9967 &token
->location
, identifier
);
9969 error ("%Htemplate parameter packs cannot "
9970 "have default arguments",
9972 default_argument
= NULL_TREE
;
9974 pop_deferring_access_checks ();
9977 default_argument
= NULL_TREE
;
9979 /* Create the combined representation of the parameter and the
9980 default argument. */
9981 parameter
= build_tree_list (default_argument
, parameter
);
9993 /* Parse a template-id.
9996 template-name < template-argument-list [opt] >
9998 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
9999 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
10000 returned. Otherwise, if the template-name names a function, or set
10001 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
10002 names a class, returns a TYPE_DECL for the specialization.
10004 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
10005 uninstantiated templates. */
10008 cp_parser_template_id (cp_parser
*parser
,
10009 bool template_keyword_p
,
10010 bool check_dependency_p
,
10011 bool is_declaration
)
10017 cp_token_position start_of_id
= 0;
10018 deferred_access_check
*chk
;
10019 VEC (deferred_access_check
,gc
) *access_check
;
10020 cp_token
*next_token
= NULL
, *next_token_2
= NULL
, *token
= NULL
;
10021 bool is_identifier
;
10023 /* If the next token corresponds to a template-id, there is no need
10025 next_token
= cp_lexer_peek_token (parser
->lexer
);
10026 if (next_token
->type
== CPP_TEMPLATE_ID
)
10028 struct tree_check
*check_value
;
10030 /* Get the stored value. */
10031 check_value
= cp_lexer_consume_token (parser
->lexer
)->u
.tree_check_value
;
10032 /* Perform any access checks that were deferred. */
10033 access_check
= check_value
->checks
;
10037 VEC_iterate (deferred_access_check
, access_check
, i
, chk
) ;
10040 perform_or_defer_access_check (chk
->binfo
,
10045 /* Return the stored value. */
10046 return check_value
->value
;
10049 /* Avoid performing name lookup if there is no possibility of
10050 finding a template-id. */
10051 if ((next_token
->type
!= CPP_NAME
&& next_token
->keyword
!= RID_OPERATOR
)
10052 || (next_token
->type
== CPP_NAME
10053 && !cp_parser_nth_token_starts_template_argument_list_p
10056 cp_parser_error (parser
, "expected template-id");
10057 return error_mark_node
;
10060 /* Remember where the template-id starts. */
10061 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
10062 start_of_id
= cp_lexer_token_position (parser
->lexer
, false);
10064 push_deferring_access_checks (dk_deferred
);
10066 /* Parse the template-name. */
10067 is_identifier
= false;
10068 token
= cp_lexer_peek_token (parser
->lexer
);
10069 templ
= cp_parser_template_name (parser
, template_keyword_p
,
10070 check_dependency_p
,
10073 if (templ
== error_mark_node
|| is_identifier
)
10075 pop_deferring_access_checks ();
10079 /* If we find the sequence `[:' after a template-name, it's probably
10080 a digraph-typo for `< ::'. Substitute the tokens and check if we can
10081 parse correctly the argument list. */
10082 next_token
= cp_lexer_peek_token (parser
->lexer
);
10083 next_token_2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
10084 if (next_token
->type
== CPP_OPEN_SQUARE
10085 && next_token
->flags
& DIGRAPH
10086 && next_token_2
->type
== CPP_COLON
10087 && !(next_token_2
->flags
& PREV_WHITE
))
10089 cp_parser_parse_tentatively (parser
);
10090 /* Change `:' into `::'. */
10091 next_token_2
->type
= CPP_SCOPE
;
10092 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
10094 cp_lexer_consume_token (parser
->lexer
);
10096 /* Parse the arguments. */
10097 arguments
= cp_parser_enclosed_template_argument_list (parser
);
10098 if (!cp_parser_parse_definitely (parser
))
10100 /* If we couldn't parse an argument list, then we revert our changes
10101 and return simply an error. Maybe this is not a template-id
10103 next_token_2
->type
= CPP_COLON
;
10104 cp_parser_error (parser
, "expected %<<%>");
10105 pop_deferring_access_checks ();
10106 return error_mark_node
;
10108 /* Otherwise, emit an error about the invalid digraph, but continue
10109 parsing because we got our argument list. */
10110 if (permerror (next_token
->location
,
10111 "%<<::%> cannot begin a template-argument list"))
10113 static bool hint
= false;
10114 inform (next_token
->location
,
10115 "%<<:%> is an alternate spelling for %<[%>."
10116 " Insert whitespace between %<<%> and %<::%>");
10117 if (!hint
&& !flag_permissive
)
10119 inform (next_token
->location
, "(if you use %<-fpermissive%>"
10120 " G++ will accept your code)");
10127 /* Look for the `<' that starts the template-argument-list. */
10128 if (!cp_parser_require (parser
, CPP_LESS
, "%<<%>"))
10130 pop_deferring_access_checks ();
10131 return error_mark_node
;
10133 /* Parse the arguments. */
10134 arguments
= cp_parser_enclosed_template_argument_list (parser
);
10137 /* Build a representation of the specialization. */
10138 if (TREE_CODE (templ
) == IDENTIFIER_NODE
)
10139 template_id
= build_min_nt (TEMPLATE_ID_EXPR
, templ
, arguments
);
10140 else if (DECL_CLASS_TEMPLATE_P (templ
)
10141 || DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
10143 bool entering_scope
;
10144 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
10145 template (rather than some instantiation thereof) only if
10146 is not nested within some other construct. For example, in
10147 "template <typename T> void f(T) { A<T>::", A<T> is just an
10148 instantiation of A. */
10149 entering_scope
= (template_parm_scope_p ()
10150 && cp_lexer_next_token_is (parser
->lexer
,
10153 = finish_template_type (templ
, arguments
, entering_scope
);
10157 /* If it's not a class-template or a template-template, it should be
10158 a function-template. */
10159 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ
)
10160 || TREE_CODE (templ
) == OVERLOAD
10161 || BASELINK_P (templ
)));
10163 template_id
= lookup_template_function (templ
, arguments
);
10166 /* If parsing tentatively, replace the sequence of tokens that makes
10167 up the template-id with a CPP_TEMPLATE_ID token. That way,
10168 should we re-parse the token stream, we will not have to repeat
10169 the effort required to do the parse, nor will we issue duplicate
10170 error messages about problems during instantiation of the
10174 cp_token
*token
= cp_lexer_token_at (parser
->lexer
, start_of_id
);
10176 /* Reset the contents of the START_OF_ID token. */
10177 token
->type
= CPP_TEMPLATE_ID
;
10178 /* Retrieve any deferred checks. Do not pop this access checks yet
10179 so the memory will not be reclaimed during token replacing below. */
10180 token
->u
.tree_check_value
= GGC_CNEW (struct tree_check
);
10181 token
->u
.tree_check_value
->value
= template_id
;
10182 token
->u
.tree_check_value
->checks
= get_deferred_access_checks ();
10183 token
->keyword
= RID_MAX
;
10185 /* Purge all subsequent tokens. */
10186 cp_lexer_purge_tokens_after (parser
->lexer
, start_of_id
);
10188 /* ??? Can we actually assume that, if template_id ==
10189 error_mark_node, we will have issued a diagnostic to the
10190 user, as opposed to simply marking the tentative parse as
10192 if (cp_parser_error_occurred (parser
) && template_id
!= error_mark_node
)
10193 error ("%Hparse error in template argument list",
10197 pop_deferring_access_checks ();
10198 return template_id
;
10201 /* Parse a template-name.
10206 The standard should actually say:
10210 operator-function-id
10212 A defect report has been filed about this issue.
10214 A conversion-function-id cannot be a template name because they cannot
10215 be part of a template-id. In fact, looking at this code:
10217 a.operator K<int>()
10219 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
10220 It is impossible to call a templated conversion-function-id with an
10221 explicit argument list, since the only allowed template parameter is
10222 the type to which it is converting.
10224 If TEMPLATE_KEYWORD_P is true, then we have just seen the
10225 `template' keyword, in a construction like:
10229 In that case `f' is taken to be a template-name, even though there
10230 is no way of knowing for sure.
10232 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
10233 name refers to a set of overloaded functions, at least one of which
10234 is a template, or an IDENTIFIER_NODE with the name of the template,
10235 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
10236 names are looked up inside uninstantiated templates. */
10239 cp_parser_template_name (cp_parser
* parser
,
10240 bool template_keyword_p
,
10241 bool check_dependency_p
,
10242 bool is_declaration
,
10243 bool *is_identifier
)
10248 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
10250 /* If the next token is `operator', then we have either an
10251 operator-function-id or a conversion-function-id. */
10252 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_OPERATOR
))
10254 /* We don't know whether we're looking at an
10255 operator-function-id or a conversion-function-id. */
10256 cp_parser_parse_tentatively (parser
);
10257 /* Try an operator-function-id. */
10258 identifier
= cp_parser_operator_function_id (parser
);
10259 /* If that didn't work, try a conversion-function-id. */
10260 if (!cp_parser_parse_definitely (parser
))
10262 cp_parser_error (parser
, "expected template-name");
10263 return error_mark_node
;
10266 /* Look for the identifier. */
10268 identifier
= cp_parser_identifier (parser
);
10270 /* If we didn't find an identifier, we don't have a template-id. */
10271 if (identifier
== error_mark_node
)
10272 return error_mark_node
;
10274 /* If the name immediately followed the `template' keyword, then it
10275 is a template-name. However, if the next token is not `<', then
10276 we do not treat it as a template-name, since it is not being used
10277 as part of a template-id. This enables us to handle constructs
10280 template <typename T> struct S { S(); };
10281 template <typename T> S<T>::S();
10283 correctly. We would treat `S' as a template -- if it were `S<T>'
10284 -- but we do not if there is no `<'. */
10286 if (processing_template_decl
10287 && cp_parser_nth_token_starts_template_argument_list_p (parser
, 1))
10289 /* In a declaration, in a dependent context, we pretend that the
10290 "template" keyword was present in order to improve error
10291 recovery. For example, given:
10293 template <typename T> void f(T::X<int>);
10295 we want to treat "X<int>" as a template-id. */
10297 && !template_keyword_p
10298 && parser
->scope
&& TYPE_P (parser
->scope
)
10299 && check_dependency_p
10300 && dependent_type_p (parser
->scope
)
10301 /* Do not do this for dtors (or ctors), since they never
10302 need the template keyword before their name. */
10303 && !constructor_name_p (identifier
, parser
->scope
))
10305 cp_token_position start
= 0;
10307 /* Explain what went wrong. */
10308 error ("%Hnon-template %qD used as template",
10309 &token
->location
, identifier
);
10310 inform (input_location
, "use %<%T::template %D%> to indicate that it is a template",
10311 parser
->scope
, identifier
);
10312 /* If parsing tentatively, find the location of the "<" token. */
10313 if (cp_parser_simulate_error (parser
))
10314 start
= cp_lexer_token_position (parser
->lexer
, true);
10315 /* Parse the template arguments so that we can issue error
10316 messages about them. */
10317 cp_lexer_consume_token (parser
->lexer
);
10318 cp_parser_enclosed_template_argument_list (parser
);
10319 /* Skip tokens until we find a good place from which to
10320 continue parsing. */
10321 cp_parser_skip_to_closing_parenthesis (parser
,
10322 /*recovering=*/true,
10324 /*consume_paren=*/false);
10325 /* If parsing tentatively, permanently remove the
10326 template argument list. That will prevent duplicate
10327 error messages from being issued about the missing
10328 "template" keyword. */
10330 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
10332 *is_identifier
= true;
10336 /* If the "template" keyword is present, then there is generally
10337 no point in doing name-lookup, so we just return IDENTIFIER.
10338 But, if the qualifying scope is non-dependent then we can
10339 (and must) do name-lookup normally. */
10340 if (template_keyword_p
10342 || (TYPE_P (parser
->scope
)
10343 && dependent_type_p (parser
->scope
))))
10347 /* Look up the name. */
10348 decl
= cp_parser_lookup_name (parser
, identifier
,
10350 /*is_template=*/false,
10351 /*is_namespace=*/false,
10352 check_dependency_p
,
10353 /*ambiguous_decls=*/NULL
,
10355 decl
= maybe_get_template_decl_from_type_decl (decl
);
10357 /* If DECL is a template, then the name was a template-name. */
10358 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
10362 tree fn
= NULL_TREE
;
10364 /* The standard does not explicitly indicate whether a name that
10365 names a set of overloaded declarations, some of which are
10366 templates, is a template-name. However, such a name should
10367 be a template-name; otherwise, there is no way to form a
10368 template-id for the overloaded templates. */
10369 fns
= BASELINK_P (decl
) ? BASELINK_FUNCTIONS (decl
) : decl
;
10370 if (TREE_CODE (fns
) == OVERLOAD
)
10371 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
10372 if (TREE_CODE (OVL_CURRENT (fn
)) == TEMPLATE_DECL
)
10377 /* The name does not name a template. */
10378 cp_parser_error (parser
, "expected template-name");
10379 return error_mark_node
;
10383 /* If DECL is dependent, and refers to a function, then just return
10384 its name; we will look it up again during template instantiation. */
10385 if (DECL_FUNCTION_TEMPLATE_P (decl
) || !DECL_P (decl
))
10387 tree scope
= CP_DECL_CONTEXT (get_first_fn (decl
));
10388 if (TYPE_P (scope
) && dependent_type_p (scope
))
10395 /* Parse a template-argument-list.
10397 template-argument-list:
10398 template-argument ... [opt]
10399 template-argument-list , template-argument ... [opt]
10401 Returns a TREE_VEC containing the arguments. */
10404 cp_parser_template_argument_list (cp_parser
* parser
)
10406 tree fixed_args
[10];
10407 unsigned n_args
= 0;
10408 unsigned alloced
= 10;
10409 tree
*arg_ary
= fixed_args
;
10411 bool saved_in_template_argument_list_p
;
10413 bool saved_non_ice_p
;
10415 saved_in_template_argument_list_p
= parser
->in_template_argument_list_p
;
10416 parser
->in_template_argument_list_p
= true;
10417 /* Even if the template-id appears in an integral
10418 constant-expression, the contents of the argument list do
10420 saved_ice_p
= parser
->integral_constant_expression_p
;
10421 parser
->integral_constant_expression_p
= false;
10422 saved_non_ice_p
= parser
->non_integral_constant_expression_p
;
10423 parser
->non_integral_constant_expression_p
= false;
10424 /* Parse the arguments. */
10430 /* Consume the comma. */
10431 cp_lexer_consume_token (parser
->lexer
);
10433 /* Parse the template-argument. */
10434 argument
= cp_parser_template_argument (parser
);
10436 /* If the next token is an ellipsis, we're expanding a template
10438 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
10440 /* Consume the `...' token. */
10441 cp_lexer_consume_token (parser
->lexer
);
10443 /* Make the argument into a TYPE_PACK_EXPANSION or
10444 EXPR_PACK_EXPANSION. */
10445 argument
= make_pack_expansion (argument
);
10448 if (n_args
== alloced
)
10452 if (arg_ary
== fixed_args
)
10454 arg_ary
= XNEWVEC (tree
, alloced
);
10455 memcpy (arg_ary
, fixed_args
, sizeof (tree
) * n_args
);
10458 arg_ary
= XRESIZEVEC (tree
, arg_ary
, alloced
);
10460 arg_ary
[n_args
++] = argument
;
10462 while (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
));
10464 vec
= make_tree_vec (n_args
);
10467 TREE_VEC_ELT (vec
, n_args
) = arg_ary
[n_args
];
10469 if (arg_ary
!= fixed_args
)
10471 parser
->non_integral_constant_expression_p
= saved_non_ice_p
;
10472 parser
->integral_constant_expression_p
= saved_ice_p
;
10473 parser
->in_template_argument_list_p
= saved_in_template_argument_list_p
;
10477 /* Parse a template-argument.
10480 assignment-expression
10484 The representation is that of an assignment-expression, type-id, or
10485 id-expression -- except that the qualified id-expression is
10486 evaluated, so that the value returned is either a DECL or an
10489 Although the standard says "assignment-expression", it forbids
10490 throw-expressions or assignments in the template argument.
10491 Therefore, we use "conditional-expression" instead. */
10494 cp_parser_template_argument (cp_parser
* parser
)
10499 bool maybe_type_id
= false;
10500 cp_token
*token
= NULL
, *argument_start_token
= NULL
;
10503 /* There's really no way to know what we're looking at, so we just
10504 try each alternative in order.
10508 In a template-argument, an ambiguity between a type-id and an
10509 expression is resolved to a type-id, regardless of the form of
10510 the corresponding template-parameter.
10512 Therefore, we try a type-id first. */
10513 cp_parser_parse_tentatively (parser
);
10514 argument
= cp_parser_type_id (parser
);
10515 /* If there was no error parsing the type-id but the next token is a
10516 '>>', our behavior depends on which dialect of C++ we're
10517 parsing. In C++98, we probably found a typo for '> >'. But there
10518 are type-id which are also valid expressions. For instance:
10520 struct X { int operator >> (int); };
10521 template <int V> struct Foo {};
10524 Here 'X()' is a valid type-id of a function type, but the user just
10525 wanted to write the expression "X() >> 5". Thus, we remember that we
10526 found a valid type-id, but we still try to parse the argument as an
10527 expression to see what happens.
10529 In C++0x, the '>>' will be considered two separate '>'
10531 if (!cp_parser_error_occurred (parser
)
10532 && cxx_dialect
== cxx98
10533 && cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
10535 maybe_type_id
= true;
10536 cp_parser_abort_tentative_parse (parser
);
10540 /* If the next token isn't a `,' or a `>', then this argument wasn't
10541 really finished. This means that the argument is not a valid
10543 if (!cp_parser_next_token_ends_template_argument_p (parser
))
10544 cp_parser_error (parser
, "expected template-argument");
10545 /* If that worked, we're done. */
10546 if (cp_parser_parse_definitely (parser
))
10549 /* We're still not sure what the argument will be. */
10550 cp_parser_parse_tentatively (parser
);
10551 /* Try a template. */
10552 argument_start_token
= cp_lexer_peek_token (parser
->lexer
);
10553 argument
= cp_parser_id_expression (parser
,
10554 /*template_keyword_p=*/false,
10555 /*check_dependency_p=*/true,
10557 /*declarator_p=*/false,
10558 /*optional_p=*/false);
10559 /* If the next token isn't a `,' or a `>', then this argument wasn't
10560 really finished. */
10561 if (!cp_parser_next_token_ends_template_argument_p (parser
))
10562 cp_parser_error (parser
, "expected template-argument");
10563 if (!cp_parser_error_occurred (parser
))
10565 /* Figure out what is being referred to. If the id-expression
10566 was for a class template specialization, then we will have a
10567 TYPE_DECL at this point. There is no need to do name lookup
10568 at this point in that case. */
10569 if (TREE_CODE (argument
) != TYPE_DECL
)
10570 argument
= cp_parser_lookup_name (parser
, argument
,
10572 /*is_template=*/template_p
,
10573 /*is_namespace=*/false,
10574 /*check_dependency=*/true,
10575 /*ambiguous_decls=*/NULL
,
10576 argument_start_token
->location
);
10577 if (TREE_CODE (argument
) != TEMPLATE_DECL
10578 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
10579 cp_parser_error (parser
, "expected template-name");
10581 if (cp_parser_parse_definitely (parser
))
10583 /* It must be a non-type argument. There permitted cases are given
10584 in [temp.arg.nontype]:
10586 -- an integral constant-expression of integral or enumeration
10589 -- the name of a non-type template-parameter; or
10591 -- the name of an object or function with external linkage...
10593 -- the address of an object or function with external linkage...
10595 -- a pointer to member... */
10596 /* Look for a non-type template parameter. */
10597 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
10599 cp_parser_parse_tentatively (parser
);
10600 argument
= cp_parser_primary_expression (parser
,
10601 /*address_p=*/false,
10603 /*template_arg_p=*/true,
10605 if (TREE_CODE (argument
) != TEMPLATE_PARM_INDEX
10606 || !cp_parser_next_token_ends_template_argument_p (parser
))
10607 cp_parser_simulate_error (parser
);
10608 if (cp_parser_parse_definitely (parser
))
10612 /* If the next token is "&", the argument must be the address of an
10613 object or function with external linkage. */
10614 address_p
= cp_lexer_next_token_is (parser
->lexer
, CPP_AND
);
10616 cp_lexer_consume_token (parser
->lexer
);
10617 /* See if we might have an id-expression. */
10618 token
= cp_lexer_peek_token (parser
->lexer
);
10619 if (token
->type
== CPP_NAME
10620 || token
->keyword
== RID_OPERATOR
10621 || token
->type
== CPP_SCOPE
10622 || token
->type
== CPP_TEMPLATE_ID
10623 || token
->type
== CPP_NESTED_NAME_SPECIFIER
)
10625 cp_parser_parse_tentatively (parser
);
10626 argument
= cp_parser_primary_expression (parser
,
10629 /*template_arg_p=*/true,
10631 if (cp_parser_error_occurred (parser
)
10632 || !cp_parser_next_token_ends_template_argument_p (parser
))
10633 cp_parser_abort_tentative_parse (parser
);
10636 if (TREE_CODE (argument
) == INDIRECT_REF
)
10638 gcc_assert (REFERENCE_REF_P (argument
));
10639 argument
= TREE_OPERAND (argument
, 0);
10642 if (TREE_CODE (argument
) == VAR_DECL
)
10644 /* A variable without external linkage might still be a
10645 valid constant-expression, so no error is issued here
10646 if the external-linkage check fails. */
10647 if (!address_p
&& !DECL_EXTERNAL_LINKAGE_P (argument
))
10648 cp_parser_simulate_error (parser
);
10650 else if (is_overloaded_fn (argument
))
10651 /* All overloaded functions are allowed; if the external
10652 linkage test does not pass, an error will be issued
10656 && (TREE_CODE (argument
) == OFFSET_REF
10657 || TREE_CODE (argument
) == SCOPE_REF
))
10658 /* A pointer-to-member. */
10660 else if (TREE_CODE (argument
) == TEMPLATE_PARM_INDEX
)
10663 cp_parser_simulate_error (parser
);
10665 if (cp_parser_parse_definitely (parser
))
10668 argument
= build_x_unary_op (ADDR_EXPR
, argument
,
10669 tf_warning_or_error
);
10674 /* If the argument started with "&", there are no other valid
10675 alternatives at this point. */
10678 cp_parser_error (parser
, "invalid non-type template argument");
10679 return error_mark_node
;
10682 /* If the argument wasn't successfully parsed as a type-id followed
10683 by '>>', the argument can only be a constant expression now.
10684 Otherwise, we try parsing the constant-expression tentatively,
10685 because the argument could really be a type-id. */
10687 cp_parser_parse_tentatively (parser
);
10688 argument
= cp_parser_constant_expression (parser
,
10689 /*allow_non_constant_p=*/false,
10690 /*non_constant_p=*/NULL
);
10691 argument
= fold_non_dependent_expr (argument
);
10692 if (!maybe_type_id
)
10694 if (!cp_parser_next_token_ends_template_argument_p (parser
))
10695 cp_parser_error (parser
, "expected template-argument");
10696 if (cp_parser_parse_definitely (parser
))
10698 /* We did our best to parse the argument as a non type-id, but that
10699 was the only alternative that matched (albeit with a '>' after
10700 it). We can assume it's just a typo from the user, and a
10701 diagnostic will then be issued. */
10702 return cp_parser_type_id (parser
);
10705 /* Parse an explicit-instantiation.
10707 explicit-instantiation:
10708 template declaration
10710 Although the standard says `declaration', what it really means is:
10712 explicit-instantiation:
10713 template decl-specifier-seq [opt] declarator [opt] ;
10715 Things like `template int S<int>::i = 5, int S<double>::j;' are not
10716 supposed to be allowed. A defect report has been filed about this
10721 explicit-instantiation:
10722 storage-class-specifier template
10723 decl-specifier-seq [opt] declarator [opt] ;
10724 function-specifier template
10725 decl-specifier-seq [opt] declarator [opt] ; */
10728 cp_parser_explicit_instantiation (cp_parser
* parser
)
10730 int declares_class_or_enum
;
10731 cp_decl_specifier_seq decl_specifiers
;
10732 tree extension_specifier
= NULL_TREE
;
10735 /* Look for an (optional) storage-class-specifier or
10736 function-specifier. */
10737 if (cp_parser_allow_gnu_extensions_p (parser
))
10739 extension_specifier
10740 = cp_parser_storage_class_specifier_opt (parser
);
10741 if (!extension_specifier
)
10742 extension_specifier
10743 = cp_parser_function_specifier_opt (parser
,
10744 /*decl_specs=*/NULL
);
10747 /* Look for the `template' keyword. */
10748 cp_parser_require_keyword (parser
, RID_TEMPLATE
, "%<template%>");
10749 /* Let the front end know that we are processing an explicit
10751 begin_explicit_instantiation ();
10752 /* [temp.explicit] says that we are supposed to ignore access
10753 control while processing explicit instantiation directives. */
10754 push_deferring_access_checks (dk_no_check
);
10755 /* Parse a decl-specifier-seq. */
10756 token
= cp_lexer_peek_token (parser
->lexer
);
10757 cp_parser_decl_specifier_seq (parser
,
10758 CP_PARSER_FLAGS_OPTIONAL
,
10760 &declares_class_or_enum
);
10761 /* If there was exactly one decl-specifier, and it declared a class,
10762 and there's no declarator, then we have an explicit type
10764 if (declares_class_or_enum
&& cp_parser_declares_only_class_p (parser
))
10768 type
= check_tag_decl (&decl_specifiers
);
10769 /* Turn access control back on for names used during
10770 template instantiation. */
10771 pop_deferring_access_checks ();
10773 do_type_instantiation (type
, extension_specifier
,
10774 /*complain=*/tf_error
);
10778 cp_declarator
*declarator
;
10781 /* Parse the declarator. */
10783 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
10784 /*ctor_dtor_or_conv_p=*/NULL
,
10785 /*parenthesized_p=*/NULL
,
10786 /*member_p=*/false);
10787 if (declares_class_or_enum
& 2)
10788 cp_parser_check_for_definition_in_return_type (declarator
,
10789 decl_specifiers
.type
,
10790 decl_specifiers
.type_location
);
10791 if (declarator
!= cp_error_declarator
)
10793 decl
= grokdeclarator (declarator
, &decl_specifiers
,
10794 NORMAL
, 0, &decl_specifiers
.attributes
);
10795 /* Turn access control back on for names used during
10796 template instantiation. */
10797 pop_deferring_access_checks ();
10798 /* Do the explicit instantiation. */
10799 do_decl_instantiation (decl
, extension_specifier
);
10803 pop_deferring_access_checks ();
10804 /* Skip the body of the explicit instantiation. */
10805 cp_parser_skip_to_end_of_statement (parser
);
10808 /* We're done with the instantiation. */
10809 end_explicit_instantiation ();
10811 cp_parser_consume_semicolon_at_end_of_statement (parser
);
10814 /* Parse an explicit-specialization.
10816 explicit-specialization:
10817 template < > declaration
10819 Although the standard says `declaration', what it really means is:
10821 explicit-specialization:
10822 template <> decl-specifier [opt] init-declarator [opt] ;
10823 template <> function-definition
10824 template <> explicit-specialization
10825 template <> template-declaration */
10828 cp_parser_explicit_specialization (cp_parser
* parser
)
10830 bool need_lang_pop
;
10831 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
10833 /* Look for the `template' keyword. */
10834 cp_parser_require_keyword (parser
, RID_TEMPLATE
, "%<template%>");
10835 /* Look for the `<'. */
10836 cp_parser_require (parser
, CPP_LESS
, "%<<%>");
10837 /* Look for the `>'. */
10838 cp_parser_require (parser
, CPP_GREATER
, "%<>%>");
10839 /* We have processed another parameter list. */
10840 ++parser
->num_template_parameter_lists
;
10843 A template ... explicit specialization ... shall not have C
10845 if (current_lang_name
== lang_name_c
)
10847 error ("%Htemplate specialization with C linkage", &token
->location
);
10848 /* Give it C++ linkage to avoid confusing other parts of the
10850 push_lang_context (lang_name_cplusplus
);
10851 need_lang_pop
= true;
10854 need_lang_pop
= false;
10855 /* Let the front end know that we are beginning a specialization. */
10856 if (!begin_specialization ())
10858 end_specialization ();
10859 cp_parser_skip_to_end_of_block_or_statement (parser
);
10863 /* If the next keyword is `template', we need to figure out whether
10864 or not we're looking a template-declaration. */
10865 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
10867 if (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_LESS
10868 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
!= CPP_GREATER
)
10869 cp_parser_template_declaration_after_export (parser
,
10870 /*member_p=*/false);
10872 cp_parser_explicit_specialization (parser
);
10875 /* Parse the dependent declaration. */
10876 cp_parser_single_declaration (parser
,
10878 /*member_p=*/false,
10879 /*explicit_specialization_p=*/true,
10880 /*friend_p=*/NULL
);
10881 /* We're done with the specialization. */
10882 end_specialization ();
10883 /* For the erroneous case of a template with C linkage, we pushed an
10884 implicit C++ linkage scope; exit that scope now. */
10886 pop_lang_context ();
10887 /* We're done with this parameter list. */
10888 --parser
->num_template_parameter_lists
;
10891 /* Parse a type-specifier.
10894 simple-type-specifier
10897 elaborated-type-specifier
10905 Returns a representation of the type-specifier. For a
10906 class-specifier, enum-specifier, or elaborated-type-specifier, a
10907 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
10909 The parser flags FLAGS is used to control type-specifier parsing.
10911 If IS_DECLARATION is TRUE, then this type-specifier is appearing
10912 in a decl-specifier-seq.
10914 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
10915 class-specifier, enum-specifier, or elaborated-type-specifier, then
10916 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
10917 if a type is declared; 2 if it is defined. Otherwise, it is set to
10920 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
10921 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
10922 is set to FALSE. */
10925 cp_parser_type_specifier (cp_parser
* parser
,
10926 cp_parser_flags flags
,
10927 cp_decl_specifier_seq
*decl_specs
,
10928 bool is_declaration
,
10929 int* declares_class_or_enum
,
10930 bool* is_cv_qualifier
)
10932 tree type_spec
= NULL_TREE
;
10935 cp_decl_spec ds
= ds_last
;
10937 /* Assume this type-specifier does not declare a new type. */
10938 if (declares_class_or_enum
)
10939 *declares_class_or_enum
= 0;
10940 /* And that it does not specify a cv-qualifier. */
10941 if (is_cv_qualifier
)
10942 *is_cv_qualifier
= false;
10943 /* Peek at the next token. */
10944 token
= cp_lexer_peek_token (parser
->lexer
);
10946 /* If we're looking at a keyword, we can use that to guide the
10947 production we choose. */
10948 keyword
= token
->keyword
;
10952 /* Look for the enum-specifier. */
10953 type_spec
= cp_parser_enum_specifier (parser
);
10954 /* If that worked, we're done. */
10957 if (declares_class_or_enum
)
10958 *declares_class_or_enum
= 2;
10960 cp_parser_set_decl_spec_type (decl_specs
,
10963 /*user_defined_p=*/true);
10967 goto elaborated_type_specifier
;
10969 /* Any of these indicate either a class-specifier, or an
10970 elaborated-type-specifier. */
10974 /* Parse tentatively so that we can back up if we don't find a
10975 class-specifier. */
10976 cp_parser_parse_tentatively (parser
);
10977 /* Look for the class-specifier. */
10978 type_spec
= cp_parser_class_specifier (parser
);
10979 /* If that worked, we're done. */
10980 if (cp_parser_parse_definitely (parser
))
10982 if (declares_class_or_enum
)
10983 *declares_class_or_enum
= 2;
10985 cp_parser_set_decl_spec_type (decl_specs
,
10988 /*user_defined_p=*/true);
10992 /* Fall through. */
10993 elaborated_type_specifier
:
10994 /* We're declaring (not defining) a class or enum. */
10995 if (declares_class_or_enum
)
10996 *declares_class_or_enum
= 1;
10998 /* Fall through. */
11000 /* Look for an elaborated-type-specifier. */
11002 = (cp_parser_elaborated_type_specifier
11004 decl_specs
&& decl_specs
->specs
[(int) ds_friend
],
11007 cp_parser_set_decl_spec_type (decl_specs
,
11010 /*user_defined_p=*/true);
11015 if (is_cv_qualifier
)
11016 *is_cv_qualifier
= true;
11021 if (is_cv_qualifier
)
11022 *is_cv_qualifier
= true;
11027 if (is_cv_qualifier
)
11028 *is_cv_qualifier
= true;
11032 /* The `__complex__' keyword is a GNU extension. */
11040 /* Handle simple keywords. */
11045 ++decl_specs
->specs
[(int)ds
];
11046 decl_specs
->any_specifiers_p
= true;
11048 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
11051 /* If we do not already have a type-specifier, assume we are looking
11052 at a simple-type-specifier. */
11053 type_spec
= cp_parser_simple_type_specifier (parser
,
11057 /* If we didn't find a type-specifier, and a type-specifier was not
11058 optional in this context, issue an error message. */
11059 if (!type_spec
&& !(flags
& CP_PARSER_FLAGS_OPTIONAL
))
11061 cp_parser_error (parser
, "expected type specifier");
11062 return error_mark_node
;
11068 /* Parse a simple-type-specifier.
11070 simple-type-specifier:
11071 :: [opt] nested-name-specifier [opt] type-name
11072 :: [opt] nested-name-specifier template template-id
11087 simple-type-specifier:
11089 decltype ( expression )
11095 simple-type-specifier:
11096 __typeof__ unary-expression
11097 __typeof__ ( type-id )
11099 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
11100 appropriately updated. */
11103 cp_parser_simple_type_specifier (cp_parser
* parser
,
11104 cp_decl_specifier_seq
*decl_specs
,
11105 cp_parser_flags flags
)
11107 tree type
= NULL_TREE
;
11110 /* Peek at the next token. */
11111 token
= cp_lexer_peek_token (parser
->lexer
);
11113 /* If we're looking at a keyword, things are easy. */
11114 switch (token
->keyword
)
11118 decl_specs
->explicit_char_p
= true;
11119 type
= char_type_node
;
11122 type
= char16_type_node
;
11125 type
= char32_type_node
;
11128 type
= wchar_type_node
;
11131 type
= boolean_type_node
;
11135 ++decl_specs
->specs
[(int) ds_short
];
11136 type
= short_integer_type_node
;
11140 decl_specs
->explicit_int_p
= true;
11141 type
= integer_type_node
;
11145 ++decl_specs
->specs
[(int) ds_long
];
11146 type
= long_integer_type_node
;
11150 ++decl_specs
->specs
[(int) ds_signed
];
11151 type
= integer_type_node
;
11155 ++decl_specs
->specs
[(int) ds_unsigned
];
11156 type
= unsigned_type_node
;
11159 type
= float_type_node
;
11162 type
= double_type_node
;
11165 type
= void_type_node
;
11169 maybe_warn_cpp0x ("C++0x auto");
11170 type
= make_auto ();
11174 /* Parse the `decltype' type. */
11175 type
= cp_parser_decltype (parser
);
11178 cp_parser_set_decl_spec_type (decl_specs
, type
,
11180 /*user_defined_p=*/true);
11185 /* Consume the `typeof' token. */
11186 cp_lexer_consume_token (parser
->lexer
);
11187 /* Parse the operand to `typeof'. */
11188 type
= cp_parser_sizeof_operand (parser
, RID_TYPEOF
);
11189 /* If it is not already a TYPE, take its type. */
11190 if (!TYPE_P (type
))
11191 type
= finish_typeof (type
);
11194 cp_parser_set_decl_spec_type (decl_specs
, type
,
11196 /*user_defined_p=*/true);
11204 /* If the type-specifier was for a built-in type, we're done. */
11209 /* Record the type. */
11211 && (token
->keyword
!= RID_SIGNED
11212 && token
->keyword
!= RID_UNSIGNED
11213 && token
->keyword
!= RID_SHORT
11214 && token
->keyword
!= RID_LONG
))
11215 cp_parser_set_decl_spec_type (decl_specs
,
11218 /*user_defined=*/false);
11220 decl_specs
->any_specifiers_p
= true;
11222 /* Consume the token. */
11223 id
= cp_lexer_consume_token (parser
->lexer
)->u
.value
;
11225 /* There is no valid C++ program where a non-template type is
11226 followed by a "<". That usually indicates that the user thought
11227 that the type was a template. */
11228 cp_parser_check_for_invalid_template_id (parser
, type
, token
->location
);
11230 return TYPE_NAME (type
);
11233 /* The type-specifier must be a user-defined type. */
11234 if (!(flags
& CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
))
11239 /* Don't gobble tokens or issue error messages if this is an
11240 optional type-specifier. */
11241 if (flags
& CP_PARSER_FLAGS_OPTIONAL
)
11242 cp_parser_parse_tentatively (parser
);
11244 /* Look for the optional `::' operator. */
11246 = (cp_parser_global_scope_opt (parser
,
11247 /*current_scope_valid_p=*/false)
11249 /* Look for the nested-name specifier. */
11251 = (cp_parser_nested_name_specifier_opt (parser
,
11252 /*typename_keyword_p=*/false,
11253 /*check_dependency_p=*/true,
11255 /*is_declaration=*/false)
11257 token
= cp_lexer_peek_token (parser
->lexer
);
11258 /* If we have seen a nested-name-specifier, and the next token
11259 is `template', then we are using the template-id production. */
11261 && cp_parser_optional_template_keyword (parser
))
11263 /* Look for the template-id. */
11264 type
= cp_parser_template_id (parser
,
11265 /*template_keyword_p=*/true,
11266 /*check_dependency_p=*/true,
11267 /*is_declaration=*/false);
11268 /* If the template-id did not name a type, we are out of
11270 if (TREE_CODE (type
) != TYPE_DECL
)
11272 cp_parser_error (parser
, "expected template-id for type");
11276 /* Otherwise, look for a type-name. */
11278 type
= cp_parser_type_name (parser
);
11279 /* Keep track of all name-lookups performed in class scopes. */
11283 && TREE_CODE (type
) == TYPE_DECL
11284 && TREE_CODE (DECL_NAME (type
)) == IDENTIFIER_NODE
)
11285 maybe_note_name_used_in_class (DECL_NAME (type
), type
);
11286 /* If it didn't work out, we don't have a TYPE. */
11287 if ((flags
& CP_PARSER_FLAGS_OPTIONAL
)
11288 && !cp_parser_parse_definitely (parser
))
11290 if (type
&& decl_specs
)
11291 cp_parser_set_decl_spec_type (decl_specs
, type
,
11293 /*user_defined=*/true);
11296 /* If we didn't get a type-name, issue an error message. */
11297 if (!type
&& !(flags
& CP_PARSER_FLAGS_OPTIONAL
))
11299 cp_parser_error (parser
, "expected type-name");
11300 return error_mark_node
;
11303 /* There is no valid C++ program where a non-template type is
11304 followed by a "<". That usually indicates that the user thought
11305 that the type was a template. */
11306 if (type
&& type
!= error_mark_node
)
11308 /* As a last-ditch effort, see if TYPE is an Objective-C type.
11309 If it is, then the '<'...'>' enclose protocol names rather than
11310 template arguments, and so everything is fine. */
11311 if (c_dialect_objc ()
11312 && (objc_is_id (type
) || objc_is_class_name (type
)))
11314 tree protos
= cp_parser_objc_protocol_refs_opt (parser
);
11315 tree qual_type
= objc_get_protocol_qualified_type (type
, protos
);
11317 /* Clobber the "unqualified" type previously entered into
11318 DECL_SPECS with the new, improved protocol-qualified version. */
11320 decl_specs
->type
= qual_type
;
11325 cp_parser_check_for_invalid_template_id (parser
, TREE_TYPE (type
),
11332 /* Parse a type-name.
11345 Returns a TYPE_DECL for the type. */
11348 cp_parser_type_name (cp_parser
* parser
)
11352 /* We can't know yet whether it is a class-name or not. */
11353 cp_parser_parse_tentatively (parser
);
11354 /* Try a class-name. */
11355 type_decl
= cp_parser_class_name (parser
,
11356 /*typename_keyword_p=*/false,
11357 /*template_keyword_p=*/false,
11359 /*check_dependency_p=*/true,
11360 /*class_head_p=*/false,
11361 /*is_declaration=*/false);
11362 /* If it's not a class-name, keep looking. */
11363 if (!cp_parser_parse_definitely (parser
))
11365 /* It must be a typedef-name or an enum-name. */
11366 return cp_parser_nonclass_name (parser
);
11372 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
11380 Returns a TYPE_DECL for the type. */
11383 cp_parser_nonclass_name (cp_parser
* parser
)
11388 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
11389 identifier
= cp_parser_identifier (parser
);
11390 if (identifier
== error_mark_node
)
11391 return error_mark_node
;
11393 /* Look up the type-name. */
11394 type_decl
= cp_parser_lookup_name_simple (parser
, identifier
, token
->location
);
11396 if (TREE_CODE (type_decl
) != TYPE_DECL
11397 && (objc_is_id (identifier
) || objc_is_class_name (identifier
)))
11399 /* See if this is an Objective-C type. */
11400 tree protos
= cp_parser_objc_protocol_refs_opt (parser
);
11401 tree type
= objc_get_protocol_qualified_type (identifier
, protos
);
11403 type_decl
= TYPE_NAME (type
);
11406 /* Issue an error if we did not find a type-name. */
11407 if (TREE_CODE (type_decl
) != TYPE_DECL
)
11409 if (!cp_parser_simulate_error (parser
))
11410 cp_parser_name_lookup_error (parser
, identifier
, type_decl
,
11411 "is not a type", token
->location
);
11412 return error_mark_node
;
11414 /* Remember that the name was used in the definition of the
11415 current class so that we can check later to see if the
11416 meaning would have been different after the class was
11417 entirely defined. */
11418 else if (type_decl
!= error_mark_node
11420 maybe_note_name_used_in_class (identifier
, type_decl
);
11425 /* Parse an elaborated-type-specifier. Note that the grammar given
11426 here incorporates the resolution to DR68.
11428 elaborated-type-specifier:
11429 class-key :: [opt] nested-name-specifier [opt] identifier
11430 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
11431 enum-key :: [opt] nested-name-specifier [opt] identifier
11432 typename :: [opt] nested-name-specifier identifier
11433 typename :: [opt] nested-name-specifier template [opt]
11438 elaborated-type-specifier:
11439 class-key attributes :: [opt] nested-name-specifier [opt] identifier
11440 class-key attributes :: [opt] nested-name-specifier [opt]
11441 template [opt] template-id
11442 enum attributes :: [opt] nested-name-specifier [opt] identifier
11444 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
11445 declared `friend'. If IS_DECLARATION is TRUE, then this
11446 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
11447 something is being declared.
11449 Returns the TYPE specified. */
11452 cp_parser_elaborated_type_specifier (cp_parser
* parser
,
11454 bool is_declaration
)
11456 enum tag_types tag_type
;
11458 tree type
= NULL_TREE
;
11459 tree attributes
= NULL_TREE
;
11460 cp_token
*token
= NULL
;
11462 /* See if we're looking at the `enum' keyword. */
11463 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ENUM
))
11465 /* Consume the `enum' token. */
11466 cp_lexer_consume_token (parser
->lexer
);
11467 /* Remember that it's an enumeration type. */
11468 tag_type
= enum_type
;
11469 /* Parse the optional `struct' or `class' key (for C++0x scoped
11471 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CLASS
)
11472 || cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STRUCT
))
11474 if (cxx_dialect
== cxx98
)
11475 maybe_warn_cpp0x ("scoped enums");
11477 /* Consume the `struct' or `class'. */
11478 cp_lexer_consume_token (parser
->lexer
);
11480 /* Parse the attributes. */
11481 attributes
= cp_parser_attributes_opt (parser
);
11483 /* Or, it might be `typename'. */
11484 else if (cp_lexer_next_token_is_keyword (parser
->lexer
,
11487 /* Consume the `typename' token. */
11488 cp_lexer_consume_token (parser
->lexer
);
11489 /* Remember that it's a `typename' type. */
11490 tag_type
= typename_type
;
11491 /* The `typename' keyword is only allowed in templates. */
11492 if (!processing_template_decl
)
11493 permerror (input_location
, "using %<typename%> outside of template");
11495 /* Otherwise it must be a class-key. */
11498 tag_type
= cp_parser_class_key (parser
);
11499 if (tag_type
== none_type
)
11500 return error_mark_node
;
11501 /* Parse the attributes. */
11502 attributes
= cp_parser_attributes_opt (parser
);
11505 /* Look for the `::' operator. */
11506 cp_parser_global_scope_opt (parser
,
11507 /*current_scope_valid_p=*/false);
11508 /* Look for the nested-name-specifier. */
11509 if (tag_type
== typename_type
)
11511 if (!cp_parser_nested_name_specifier (parser
,
11512 /*typename_keyword_p=*/true,
11513 /*check_dependency_p=*/true,
11516 return error_mark_node
;
11519 /* Even though `typename' is not present, the proposed resolution
11520 to Core Issue 180 says that in `class A<T>::B', `B' should be
11521 considered a type-name, even if `A<T>' is dependent. */
11522 cp_parser_nested_name_specifier_opt (parser
,
11523 /*typename_keyword_p=*/true,
11524 /*check_dependency_p=*/true,
11527 /* For everything but enumeration types, consider a template-id.
11528 For an enumeration type, consider only a plain identifier. */
11529 if (tag_type
!= enum_type
)
11531 bool template_p
= false;
11534 /* Allow the `template' keyword. */
11535 template_p
= cp_parser_optional_template_keyword (parser
);
11536 /* If we didn't see `template', we don't know if there's a
11537 template-id or not. */
11539 cp_parser_parse_tentatively (parser
);
11540 /* Parse the template-id. */
11541 token
= cp_lexer_peek_token (parser
->lexer
);
11542 decl
= cp_parser_template_id (parser
, template_p
,
11543 /*check_dependency_p=*/true,
11545 /* If we didn't find a template-id, look for an ordinary
11547 if (!template_p
&& !cp_parser_parse_definitely (parser
))
11549 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
11550 in effect, then we must assume that, upon instantiation, the
11551 template will correspond to a class. */
11552 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
11553 && tag_type
== typename_type
)
11554 type
= make_typename_type (parser
->scope
, decl
,
11556 /*complain=*/tf_error
);
11558 type
= TREE_TYPE (decl
);
11563 token
= cp_lexer_peek_token (parser
->lexer
);
11564 identifier
= cp_parser_identifier (parser
);
11566 if (identifier
== error_mark_node
)
11568 parser
->scope
= NULL_TREE
;
11569 return error_mark_node
;
11572 /* For a `typename', we needn't call xref_tag. */
11573 if (tag_type
== typename_type
11574 && TREE_CODE (parser
->scope
) != NAMESPACE_DECL
)
11575 return cp_parser_make_typename_type (parser
, parser
->scope
,
11578 /* Look up a qualified name in the usual way. */
11582 tree ambiguous_decls
;
11584 decl
= cp_parser_lookup_name (parser
, identifier
,
11586 /*is_template=*/false,
11587 /*is_namespace=*/false,
11588 /*check_dependency=*/true,
11592 /* If the lookup was ambiguous, an error will already have been
11594 if (ambiguous_decls
)
11595 return error_mark_node
;
11597 /* If we are parsing friend declaration, DECL may be a
11598 TEMPLATE_DECL tree node here. However, we need to check
11599 whether this TEMPLATE_DECL results in valid code. Consider
11600 the following example:
11603 template <class T> class C {};
11606 template <class T> friend class N::C; // #1, valid code
11608 template <class T> class Y {
11609 friend class N::C; // #2, invalid code
11612 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
11613 name lookup of `N::C'. We see that friend declaration must
11614 be template for the code to be valid. Note that
11615 processing_template_decl does not work here since it is
11616 always 1 for the above two cases. */
11618 decl
= (cp_parser_maybe_treat_template_as_class
11619 (decl
, /*tag_name_p=*/is_friend
11620 && parser
->num_template_parameter_lists
));
11622 if (TREE_CODE (decl
) != TYPE_DECL
)
11624 cp_parser_diagnose_invalid_type_name (parser
,
11628 return error_mark_node
;
11631 if (TREE_CODE (TREE_TYPE (decl
)) != TYPENAME_TYPE
)
11633 bool allow_template
= (parser
->num_template_parameter_lists
11634 || DECL_SELF_REFERENCE_P (decl
));
11635 type
= check_elaborated_type_specifier (tag_type
, decl
,
11638 if (type
== error_mark_node
)
11639 return error_mark_node
;
11642 /* Forward declarations of nested types, such as
11647 are invalid unless all components preceding the final '::'
11648 are complete. If all enclosing types are complete, these
11649 declarations become merely pointless.
11651 Invalid forward declarations of nested types are errors
11652 caught elsewhere in parsing. Those that are pointless arrive
11655 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
11656 && !is_friend
&& !processing_explicit_instantiation
)
11657 warning (0, "declaration %qD does not declare anything", decl
);
11659 type
= TREE_TYPE (decl
);
11663 /* An elaborated-type-specifier sometimes introduces a new type and
11664 sometimes names an existing type. Normally, the rule is that it
11665 introduces a new type only if there is not an existing type of
11666 the same name already in scope. For example, given:
11669 void f() { struct S s; }
11671 the `struct S' in the body of `f' is the same `struct S' as in
11672 the global scope; the existing definition is used. However, if
11673 there were no global declaration, this would introduce a new
11674 local class named `S'.
11676 An exception to this rule applies to the following code:
11678 namespace N { struct S; }
11680 Here, the elaborated-type-specifier names a new type
11681 unconditionally; even if there is already an `S' in the
11682 containing scope this declaration names a new type.
11683 This exception only applies if the elaborated-type-specifier
11684 forms the complete declaration:
11688 A declaration consisting solely of `class-key identifier ;' is
11689 either a redeclaration of the name in the current scope or a
11690 forward declaration of the identifier as a class name. It
11691 introduces the name into the current scope.
11693 We are in this situation precisely when the next token is a `;'.
11695 An exception to the exception is that a `friend' declaration does
11696 *not* name a new type; i.e., given:
11698 struct S { friend struct T; };
11700 `T' is not a new type in the scope of `S'.
11702 Also, `new struct S' or `sizeof (struct S)' never results in the
11703 definition of a new type; a new type can only be declared in a
11704 declaration context. */
11710 /* Friends have special name lookup rules. */
11711 ts
= ts_within_enclosing_non_class
;
11712 else if (is_declaration
11713 && cp_lexer_next_token_is (parser
->lexer
,
11715 /* This is a `class-key identifier ;' */
11721 (parser
->num_template_parameter_lists
11722 && (cp_parser_next_token_starts_class_definition_p (parser
)
11723 || cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)));
11724 /* An unqualified name was used to reference this type, so
11725 there were no qualifying templates. */
11726 if (!cp_parser_check_template_parameters (parser
,
11727 /*num_templates=*/0,
11729 return error_mark_node
;
11730 type
= xref_tag (tag_type
, identifier
, ts
, template_p
);
11734 if (type
== error_mark_node
)
11735 return error_mark_node
;
11737 /* Allow attributes on forward declarations of classes. */
11740 if (TREE_CODE (type
) == TYPENAME_TYPE
)
11741 warning (OPT_Wattributes
,
11742 "attributes ignored on uninstantiated type");
11743 else if (tag_type
!= enum_type
&& CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
11744 && ! processing_explicit_instantiation
)
11745 warning (OPT_Wattributes
,
11746 "attributes ignored on template instantiation");
11747 else if (is_declaration
&& cp_parser_declares_only_class_p (parser
))
11748 cplus_decl_attributes (&type
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
11750 warning (OPT_Wattributes
,
11751 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
11754 if (tag_type
!= enum_type
)
11755 cp_parser_check_class_key (tag_type
, type
);
11757 /* A "<" cannot follow an elaborated type specifier. If that
11758 happens, the user was probably trying to form a template-id. */
11759 cp_parser_check_for_invalid_template_id (parser
, type
, token
->location
);
11764 /* Parse an enum-specifier.
11767 enum-key identifier [opt] enum-base [opt] { enumerator-list [opt] }
11772 enum struct [C++0x]
11775 : type-specifier-seq
11778 enum-key attributes[opt] identifier [opt] enum-base [opt]
11779 { enumerator-list [opt] }attributes[opt]
11781 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
11782 if the token stream isn't an enum-specifier after all. */
11785 cp_parser_enum_specifier (cp_parser
* parser
)
11790 bool scoped_enum_p
= false;
11791 bool has_underlying_type
= false;
11792 tree underlying_type
= NULL_TREE
;
11794 /* Parse tentatively so that we can back up if we don't find a
11796 cp_parser_parse_tentatively (parser
);
11798 /* Caller guarantees that the current token is 'enum', an identifier
11799 possibly follows, and the token after that is an opening brace.
11800 If we don't have an identifier, fabricate an anonymous name for
11801 the enumeration being defined. */
11802 cp_lexer_consume_token (parser
->lexer
);
11804 /* Parse the "class" or "struct", which indicates a scoped
11805 enumeration type in C++0x. */
11806 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CLASS
)
11807 || cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STRUCT
))
11809 if (cxx_dialect
== cxx98
)
11810 maybe_warn_cpp0x ("scoped enums");
11812 /* Consume the `struct' or `class' token. */
11813 cp_lexer_consume_token (parser
->lexer
);
11815 scoped_enum_p
= true;
11818 attributes
= cp_parser_attributes_opt (parser
);
11820 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
11821 identifier
= cp_parser_identifier (parser
);
11823 identifier
= make_anon_name ();
11825 /* Check for the `:' that denotes a specified underlying type in C++0x. */
11826 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
11828 cp_decl_specifier_seq type_specifiers
;
11830 /* At this point this is surely not elaborated type specifier. */
11831 if (!cp_parser_parse_definitely (parser
))
11834 if (cxx_dialect
== cxx98
)
11835 maybe_warn_cpp0x ("scoped enums");
11837 /* Consume the `:'. */
11838 cp_lexer_consume_token (parser
->lexer
);
11840 has_underlying_type
= true;
11842 /* Parse the type-specifier-seq. */
11843 cp_parser_type_specifier_seq (parser
, /*is_condition=*/false,
11846 /* If that didn't work, stop. */
11847 if (type_specifiers
.type
!= error_mark_node
)
11849 underlying_type
= grokdeclarator (NULL
, &type_specifiers
, TYPENAME
,
11850 /*initialized=*/0, NULL
);
11851 if (underlying_type
== error_mark_node
)
11852 underlying_type
= NULL_TREE
;
11856 /* Look for the `{' but don't consume it yet. */
11857 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
11859 cp_parser_error (parser
, "expected %<{%>");
11860 if (has_underlying_type
)
11864 if (!has_underlying_type
&& !cp_parser_parse_definitely (parser
))
11867 /* Issue an error message if type-definitions are forbidden here. */
11868 if (!cp_parser_check_type_definition (parser
))
11869 type
= error_mark_node
;
11871 /* Create the new type. We do this before consuming the opening
11872 brace so the enum will be recorded as being on the line of its
11873 tag (or the 'enum' keyword, if there is no tag). */
11874 type
= start_enum (identifier
, underlying_type
, scoped_enum_p
);
11876 /* Consume the opening brace. */
11877 cp_lexer_consume_token (parser
->lexer
);
11879 if (type
== error_mark_node
)
11881 cp_parser_skip_to_end_of_block_or_statement (parser
);
11882 return error_mark_node
;
11885 /* If the next token is not '}', then there are some enumerators. */
11886 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_BRACE
))
11887 cp_parser_enumerator_list (parser
, type
);
11889 /* Consume the final '}'. */
11890 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
11892 /* Look for trailing attributes to apply to this enumeration, and
11893 apply them if appropriate. */
11894 if (cp_parser_allow_gnu_extensions_p (parser
))
11896 tree trailing_attr
= cp_parser_attributes_opt (parser
);
11897 cplus_decl_attributes (&type
,
11899 (int) ATTR_FLAG_TYPE_IN_PLACE
);
11902 /* Finish up the enumeration. */
11903 finish_enum (type
);
11908 /* Parse an enumerator-list. The enumerators all have the indicated
11912 enumerator-definition
11913 enumerator-list , enumerator-definition */
11916 cp_parser_enumerator_list (cp_parser
* parser
, tree type
)
11920 /* Parse an enumerator-definition. */
11921 cp_parser_enumerator_definition (parser
, type
);
11923 /* If the next token is not a ',', we've reached the end of
11925 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
11927 /* Otherwise, consume the `,' and keep going. */
11928 cp_lexer_consume_token (parser
->lexer
);
11929 /* If the next token is a `}', there is a trailing comma. */
11930 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
11932 if (!in_system_header
)
11933 pedwarn (input_location
, OPT_pedantic
, "comma at end of enumerator list");
11939 /* Parse an enumerator-definition. The enumerator has the indicated
11942 enumerator-definition:
11944 enumerator = constant-expression
11950 cp_parser_enumerator_definition (cp_parser
* parser
, tree type
)
11955 /* Look for the identifier. */
11956 identifier
= cp_parser_identifier (parser
);
11957 if (identifier
== error_mark_node
)
11960 /* If the next token is an '=', then there is an explicit value. */
11961 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
11963 /* Consume the `=' token. */
11964 cp_lexer_consume_token (parser
->lexer
);
11965 /* Parse the value. */
11966 value
= cp_parser_constant_expression (parser
,
11967 /*allow_non_constant_p=*/false,
11973 /* Create the enumerator. */
11974 build_enumerator (identifier
, value
, type
);
11977 /* Parse a namespace-name.
11980 original-namespace-name
11983 Returns the NAMESPACE_DECL for the namespace. */
11986 cp_parser_namespace_name (cp_parser
* parser
)
11989 tree namespace_decl
;
11991 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
11993 /* Get the name of the namespace. */
11994 identifier
= cp_parser_identifier (parser
);
11995 if (identifier
== error_mark_node
)
11996 return error_mark_node
;
11998 /* Look up the identifier in the currently active scope. Look only
11999 for namespaces, due to:
12001 [basic.lookup.udir]
12003 When looking up a namespace-name in a using-directive or alias
12004 definition, only namespace names are considered.
12008 [basic.lookup.qual]
12010 During the lookup of a name preceding the :: scope resolution
12011 operator, object, function, and enumerator names are ignored.
12013 (Note that cp_parser_qualifying_entity only calls this
12014 function if the token after the name is the scope resolution
12016 namespace_decl
= cp_parser_lookup_name (parser
, identifier
,
12018 /*is_template=*/false,
12019 /*is_namespace=*/true,
12020 /*check_dependency=*/true,
12021 /*ambiguous_decls=*/NULL
,
12023 /* If it's not a namespace, issue an error. */
12024 if (namespace_decl
== error_mark_node
12025 || TREE_CODE (namespace_decl
) != NAMESPACE_DECL
)
12027 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
12028 error ("%H%qD is not a namespace-name", &token
->location
, identifier
);
12029 cp_parser_error (parser
, "expected namespace-name");
12030 namespace_decl
= error_mark_node
;
12033 return namespace_decl
;
12036 /* Parse a namespace-definition.
12038 namespace-definition:
12039 named-namespace-definition
12040 unnamed-namespace-definition
12042 named-namespace-definition:
12043 original-namespace-definition
12044 extension-namespace-definition
12046 original-namespace-definition:
12047 namespace identifier { namespace-body }
12049 extension-namespace-definition:
12050 namespace original-namespace-name { namespace-body }
12052 unnamed-namespace-definition:
12053 namespace { namespace-body } */
12056 cp_parser_namespace_definition (cp_parser
* parser
)
12058 tree identifier
, attribs
;
12059 bool has_visibility
;
12062 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_INLINE
))
12065 cp_lexer_consume_token (parser
->lexer
);
12070 /* Look for the `namespace' keyword. */
12071 cp_parser_require_keyword (parser
, RID_NAMESPACE
, "%<namespace%>");
12073 /* Get the name of the namespace. We do not attempt to distinguish
12074 between an original-namespace-definition and an
12075 extension-namespace-definition at this point. The semantic
12076 analysis routines are responsible for that. */
12077 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
12078 identifier
= cp_parser_identifier (parser
);
12080 identifier
= NULL_TREE
;
12082 /* Parse any specified attributes. */
12083 attribs
= cp_parser_attributes_opt (parser
);
12085 /* Look for the `{' to start the namespace. */
12086 cp_parser_require (parser
, CPP_OPEN_BRACE
, "%<{%>");
12087 /* Start the namespace. */
12088 push_namespace (identifier
);
12090 /* "inline namespace" is equivalent to a stub namespace definition
12091 followed by a strong using directive. */
12094 tree name_space
= current_namespace
;
12095 /* Set up namespace association. */
12096 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
12097 = tree_cons (CP_DECL_CONTEXT (name_space
), NULL_TREE
,
12098 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
12099 /* Import the contents of the inline namespace. */
12101 do_using_directive (name_space
);
12102 push_namespace (identifier
);
12105 has_visibility
= handle_namespace_attrs (current_namespace
, attribs
);
12107 /* Parse the body of the namespace. */
12108 cp_parser_namespace_body (parser
);
12110 #ifdef HANDLE_PRAGMA_VISIBILITY
12111 if (has_visibility
)
12115 /* Finish the namespace. */
12117 /* Look for the final `}'. */
12118 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
12121 /* Parse a namespace-body.
12124 declaration-seq [opt] */
12127 cp_parser_namespace_body (cp_parser
* parser
)
12129 cp_parser_declaration_seq_opt (parser
);
12132 /* Parse a namespace-alias-definition.
12134 namespace-alias-definition:
12135 namespace identifier = qualified-namespace-specifier ; */
12138 cp_parser_namespace_alias_definition (cp_parser
* parser
)
12141 tree namespace_specifier
;
12143 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12145 /* Look for the `namespace' keyword. */
12146 cp_parser_require_keyword (parser
, RID_NAMESPACE
, "%<namespace%>");
12147 /* Look for the identifier. */
12148 identifier
= cp_parser_identifier (parser
);
12149 if (identifier
== error_mark_node
)
12151 /* Look for the `=' token. */
12152 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
)
12153 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
12155 error ("%H%<namespace%> definition is not allowed here", &token
->location
);
12156 /* Skip the definition. */
12157 cp_lexer_consume_token (parser
->lexer
);
12158 if (cp_parser_skip_to_closing_brace (parser
))
12159 cp_lexer_consume_token (parser
->lexer
);
12162 cp_parser_require (parser
, CPP_EQ
, "%<=%>");
12163 /* Look for the qualified-namespace-specifier. */
12164 namespace_specifier
12165 = cp_parser_qualified_namespace_specifier (parser
);
12166 /* Look for the `;' token. */
12167 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
12169 /* Register the alias in the symbol table. */
12170 do_namespace_alias (identifier
, namespace_specifier
);
12173 /* Parse a qualified-namespace-specifier.
12175 qualified-namespace-specifier:
12176 :: [opt] nested-name-specifier [opt] namespace-name
12178 Returns a NAMESPACE_DECL corresponding to the specified
12182 cp_parser_qualified_namespace_specifier (cp_parser
* parser
)
12184 /* Look for the optional `::'. */
12185 cp_parser_global_scope_opt (parser
,
12186 /*current_scope_valid_p=*/false);
12188 /* Look for the optional nested-name-specifier. */
12189 cp_parser_nested_name_specifier_opt (parser
,
12190 /*typename_keyword_p=*/false,
12191 /*check_dependency_p=*/true,
12193 /*is_declaration=*/true);
12195 return cp_parser_namespace_name (parser
);
12198 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
12199 access declaration.
12202 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
12203 using :: unqualified-id ;
12205 access-declaration:
12211 cp_parser_using_declaration (cp_parser
* parser
,
12212 bool access_declaration_p
)
12215 bool typename_p
= false;
12216 bool global_scope_p
;
12221 if (access_declaration_p
)
12222 cp_parser_parse_tentatively (parser
);
12225 /* Look for the `using' keyword. */
12226 cp_parser_require_keyword (parser
, RID_USING
, "%<using%>");
12228 /* Peek at the next token. */
12229 token
= cp_lexer_peek_token (parser
->lexer
);
12230 /* See if it's `typename'. */
12231 if (token
->keyword
== RID_TYPENAME
)
12233 /* Remember that we've seen it. */
12235 /* Consume the `typename' token. */
12236 cp_lexer_consume_token (parser
->lexer
);
12240 /* Look for the optional global scope qualification. */
12242 = (cp_parser_global_scope_opt (parser
,
12243 /*current_scope_valid_p=*/false)
12246 /* If we saw `typename', or didn't see `::', then there must be a
12247 nested-name-specifier present. */
12248 if (typename_p
|| !global_scope_p
)
12249 qscope
= cp_parser_nested_name_specifier (parser
, typename_p
,
12250 /*check_dependency_p=*/true,
12252 /*is_declaration=*/true);
12253 /* Otherwise, we could be in either of the two productions. In that
12254 case, treat the nested-name-specifier as optional. */
12256 qscope
= cp_parser_nested_name_specifier_opt (parser
,
12257 /*typename_keyword_p=*/false,
12258 /*check_dependency_p=*/true,
12260 /*is_declaration=*/true);
12262 qscope
= global_namespace
;
12264 if (access_declaration_p
&& cp_parser_error_occurred (parser
))
12265 /* Something has already gone wrong; there's no need to parse
12266 further. Since an error has occurred, the return value of
12267 cp_parser_parse_definitely will be false, as required. */
12268 return cp_parser_parse_definitely (parser
);
12270 token
= cp_lexer_peek_token (parser
->lexer
);
12271 /* Parse the unqualified-id. */
12272 identifier
= cp_parser_unqualified_id (parser
,
12273 /*template_keyword_p=*/false,
12274 /*check_dependency_p=*/true,
12275 /*declarator_p=*/true,
12276 /*optional_p=*/false);
12278 if (access_declaration_p
)
12280 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
12281 cp_parser_simulate_error (parser
);
12282 if (!cp_parser_parse_definitely (parser
))
12286 /* The function we call to handle a using-declaration is different
12287 depending on what scope we are in. */
12288 if (qscope
== error_mark_node
|| identifier
== error_mark_node
)
12290 else if (TREE_CODE (identifier
) != IDENTIFIER_NODE
12291 && TREE_CODE (identifier
) != BIT_NOT_EXPR
)
12292 /* [namespace.udecl]
12294 A using declaration shall not name a template-id. */
12295 error ("%Ha template-id may not appear in a using-declaration",
12299 if (at_class_scope_p ())
12301 /* Create the USING_DECL. */
12302 decl
= do_class_using_decl (parser
->scope
, identifier
);
12304 if (check_for_bare_parameter_packs (decl
))
12307 /* Add it to the list of members in this class. */
12308 finish_member_declaration (decl
);
12312 decl
= cp_parser_lookup_name_simple (parser
,
12315 if (decl
== error_mark_node
)
12316 cp_parser_name_lookup_error (parser
, identifier
,
12319 else if (check_for_bare_parameter_packs (decl
))
12321 else if (!at_namespace_scope_p ())
12322 do_local_using_decl (decl
, qscope
, identifier
);
12324 do_toplevel_using_decl (decl
, qscope
, identifier
);
12328 /* Look for the final `;'. */
12329 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
12334 /* Parse a using-directive.
12337 using namespace :: [opt] nested-name-specifier [opt]
12338 namespace-name ; */
12341 cp_parser_using_directive (cp_parser
* parser
)
12343 tree namespace_decl
;
12346 /* Look for the `using' keyword. */
12347 cp_parser_require_keyword (parser
, RID_USING
, "%<using%>");
12348 /* And the `namespace' keyword. */
12349 cp_parser_require_keyword (parser
, RID_NAMESPACE
, "%<namespace%>");
12350 /* Look for the optional `::' operator. */
12351 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false);
12352 /* And the optional nested-name-specifier. */
12353 cp_parser_nested_name_specifier_opt (parser
,
12354 /*typename_keyword_p=*/false,
12355 /*check_dependency_p=*/true,
12357 /*is_declaration=*/true);
12358 /* Get the namespace being used. */
12359 namespace_decl
= cp_parser_namespace_name (parser
);
12360 /* And any specified attributes. */
12361 attribs
= cp_parser_attributes_opt (parser
);
12362 /* Update the symbol table. */
12363 parse_using_directive (namespace_decl
, attribs
);
12364 /* Look for the final `;'. */
12365 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
12368 /* Parse an asm-definition.
12371 asm ( string-literal ) ;
12376 asm volatile [opt] ( string-literal ) ;
12377 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
12378 asm volatile [opt] ( string-literal : asm-operand-list [opt]
12379 : asm-operand-list [opt] ) ;
12380 asm volatile [opt] ( string-literal : asm-operand-list [opt]
12381 : asm-operand-list [opt]
12382 : asm-operand-list [opt] ) ; */
12385 cp_parser_asm_definition (cp_parser
* parser
)
12388 tree outputs
= NULL_TREE
;
12389 tree inputs
= NULL_TREE
;
12390 tree clobbers
= NULL_TREE
;
12392 bool volatile_p
= false;
12393 bool extended_p
= false;
12394 bool invalid_inputs_p
= false;
12395 bool invalid_outputs_p
= false;
12397 /* Look for the `asm' keyword. */
12398 cp_parser_require_keyword (parser
, RID_ASM
, "%<asm%>");
12399 /* See if the next token is `volatile'. */
12400 if (cp_parser_allow_gnu_extensions_p (parser
)
12401 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_VOLATILE
))
12403 /* Remember that we saw the `volatile' keyword. */
12405 /* Consume the token. */
12406 cp_lexer_consume_token (parser
->lexer
);
12408 /* Look for the opening `('. */
12409 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
12411 /* Look for the string. */
12412 string
= cp_parser_string_literal (parser
, false, false);
12413 if (string
== error_mark_node
)
12415 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
12416 /*consume_paren=*/true);
12420 /* If we're allowing GNU extensions, check for the extended assembly
12421 syntax. Unfortunately, the `:' tokens need not be separated by
12422 a space in C, and so, for compatibility, we tolerate that here
12423 too. Doing that means that we have to treat the `::' operator as
12425 if (cp_parser_allow_gnu_extensions_p (parser
)
12426 && parser
->in_function_body
12427 && (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
)
12428 || cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
)))
12430 bool inputs_p
= false;
12431 bool clobbers_p
= false;
12433 /* The extended syntax was used. */
12436 /* Look for outputs. */
12437 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
12439 /* Consume the `:'. */
12440 cp_lexer_consume_token (parser
->lexer
);
12441 /* Parse the output-operands. */
12442 if (cp_lexer_next_token_is_not (parser
->lexer
,
12444 && cp_lexer_next_token_is_not (parser
->lexer
,
12446 && cp_lexer_next_token_is_not (parser
->lexer
,
12448 outputs
= cp_parser_asm_operand_list (parser
);
12450 if (outputs
== error_mark_node
)
12451 invalid_outputs_p
= true;
12453 /* If the next token is `::', there are no outputs, and the
12454 next token is the beginning of the inputs. */
12455 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
12456 /* The inputs are coming next. */
12459 /* Look for inputs. */
12461 || cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
12463 /* Consume the `:' or `::'. */
12464 cp_lexer_consume_token (parser
->lexer
);
12465 /* Parse the output-operands. */
12466 if (cp_lexer_next_token_is_not (parser
->lexer
,
12468 && cp_lexer_next_token_is_not (parser
->lexer
,
12470 inputs
= cp_parser_asm_operand_list (parser
);
12472 if (inputs
== error_mark_node
)
12473 invalid_inputs_p
= true;
12475 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
12476 /* The clobbers are coming next. */
12479 /* Look for clobbers. */
12481 || cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
12483 /* Consume the `:' or `::'. */
12484 cp_lexer_consume_token (parser
->lexer
);
12485 /* Parse the clobbers. */
12486 if (cp_lexer_next_token_is_not (parser
->lexer
,
12488 clobbers
= cp_parser_asm_clobber_list (parser
);
12491 /* Look for the closing `)'. */
12492 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
12493 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
12494 /*consume_paren=*/true);
12495 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
12497 if (!invalid_inputs_p
&& !invalid_outputs_p
)
12499 /* Create the ASM_EXPR. */
12500 if (parser
->in_function_body
)
12502 asm_stmt
= finish_asm_stmt (volatile_p
, string
, outputs
,
12504 /* If the extended syntax was not used, mark the ASM_EXPR. */
12507 tree temp
= asm_stmt
;
12508 if (TREE_CODE (temp
) == CLEANUP_POINT_EXPR
)
12509 temp
= TREE_OPERAND (temp
, 0);
12511 ASM_INPUT_P (temp
) = 1;
12515 cgraph_add_asm_node (string
);
12519 /* Declarators [gram.dcl.decl] */
12521 /* Parse an init-declarator.
12524 declarator initializer [opt]
12529 declarator asm-specification [opt] attributes [opt] initializer [opt]
12531 function-definition:
12532 decl-specifier-seq [opt] declarator ctor-initializer [opt]
12534 decl-specifier-seq [opt] declarator function-try-block
12538 function-definition:
12539 __extension__ function-definition
12541 The DECL_SPECIFIERS apply to this declarator. Returns a
12542 representation of the entity declared. If MEMBER_P is TRUE, then
12543 this declarator appears in a class scope. The new DECL created by
12544 this declarator is returned.
12546 The CHECKS are access checks that should be performed once we know
12547 what entity is being declared (and, therefore, what classes have
12550 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
12551 for a function-definition here as well. If the declarator is a
12552 declarator for a function-definition, *FUNCTION_DEFINITION_P will
12553 be TRUE upon return. By that point, the function-definition will
12554 have been completely parsed.
12556 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
12560 cp_parser_init_declarator (cp_parser
* parser
,
12561 cp_decl_specifier_seq
*decl_specifiers
,
12562 VEC (deferred_access_check
,gc
)* checks
,
12563 bool function_definition_allowed_p
,
12565 int declares_class_or_enum
,
12566 bool* function_definition_p
)
12568 cp_token
*token
= NULL
, *asm_spec_start_token
= NULL
,
12569 *attributes_start_token
= NULL
;
12570 cp_declarator
*declarator
;
12571 tree prefix_attributes
;
12573 tree asm_specification
;
12575 tree decl
= NULL_TREE
;
12577 int is_initialized
;
12578 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
12579 initialized with "= ..", CPP_OPEN_PAREN if initialized with
12581 enum cpp_ttype initialization_kind
;
12582 bool is_direct_init
= false;
12583 bool is_non_constant_init
;
12584 int ctor_dtor_or_conv_p
;
12586 tree pushed_scope
= NULL
;
12588 /* Gather the attributes that were provided with the
12589 decl-specifiers. */
12590 prefix_attributes
= decl_specifiers
->attributes
;
12592 /* Assume that this is not the declarator for a function
12594 if (function_definition_p
)
12595 *function_definition_p
= false;
12597 /* Defer access checks while parsing the declarator; we cannot know
12598 what names are accessible until we know what is being
12600 resume_deferring_access_checks ();
12602 /* Parse the declarator. */
12603 token
= cp_lexer_peek_token (parser
->lexer
);
12605 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
12606 &ctor_dtor_or_conv_p
,
12607 /*parenthesized_p=*/NULL
,
12608 /*member_p=*/false);
12609 /* Gather up the deferred checks. */
12610 stop_deferring_access_checks ();
12612 /* If the DECLARATOR was erroneous, there's no need to go
12614 if (declarator
== cp_error_declarator
)
12615 return error_mark_node
;
12617 /* Check that the number of template-parameter-lists is OK. */
12618 if (!cp_parser_check_declarator_template_parameters (parser
, declarator
,
12620 return error_mark_node
;
12622 if (declares_class_or_enum
& 2)
12623 cp_parser_check_for_definition_in_return_type (declarator
,
12624 decl_specifiers
->type
,
12625 decl_specifiers
->type_location
);
12627 /* Figure out what scope the entity declared by the DECLARATOR is
12628 located in. `grokdeclarator' sometimes changes the scope, so
12629 we compute it now. */
12630 scope
= get_scope_of_declarator (declarator
);
12632 /* If we're allowing GNU extensions, look for an asm-specification
12634 if (cp_parser_allow_gnu_extensions_p (parser
))
12636 /* Look for an asm-specification. */
12637 asm_spec_start_token
= cp_lexer_peek_token (parser
->lexer
);
12638 asm_specification
= cp_parser_asm_specification_opt (parser
);
12639 /* And attributes. */
12640 attributes_start_token
= cp_lexer_peek_token (parser
->lexer
);
12641 attributes
= cp_parser_attributes_opt (parser
);
12645 asm_specification
= NULL_TREE
;
12646 attributes
= NULL_TREE
;
12649 /* Peek at the next token. */
12650 token
= cp_lexer_peek_token (parser
->lexer
);
12651 /* Check to see if the token indicates the start of a
12652 function-definition. */
12653 if (function_declarator_p (declarator
)
12654 && cp_parser_token_starts_function_definition_p (token
))
12656 if (!function_definition_allowed_p
)
12658 /* If a function-definition should not appear here, issue an
12660 cp_parser_error (parser
,
12661 "a function-definition is not allowed here");
12662 return error_mark_node
;
12666 location_t func_brace_location
12667 = cp_lexer_peek_token (parser
->lexer
)->location
;
12669 /* Neither attributes nor an asm-specification are allowed
12670 on a function-definition. */
12671 if (asm_specification
)
12672 error ("%Han asm-specification is not allowed "
12673 "on a function-definition",
12674 &asm_spec_start_token
->location
);
12676 error ("%Hattributes are not allowed on a function-definition",
12677 &attributes_start_token
->location
);
12678 /* This is a function-definition. */
12679 *function_definition_p
= true;
12681 /* Parse the function definition. */
12683 decl
= cp_parser_save_member_function_body (parser
,
12686 prefix_attributes
);
12689 = (cp_parser_function_definition_from_specifiers_and_declarator
12690 (parser
, decl_specifiers
, prefix_attributes
, declarator
));
12692 if (decl
!= error_mark_node
&& DECL_STRUCT_FUNCTION (decl
))
12694 /* This is where the prologue starts... */
12695 DECL_STRUCT_FUNCTION (decl
)->function_start_locus
12696 = func_brace_location
;
12705 Only in function declarations for constructors, destructors, and
12706 type conversions can the decl-specifier-seq be omitted.
12708 We explicitly postpone this check past the point where we handle
12709 function-definitions because we tolerate function-definitions
12710 that are missing their return types in some modes. */
12711 if (!decl_specifiers
->any_specifiers_p
&& ctor_dtor_or_conv_p
<= 0)
12713 cp_parser_error (parser
,
12714 "expected constructor, destructor, or type conversion");
12715 return error_mark_node
;
12718 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
12719 if (token
->type
== CPP_EQ
12720 || token
->type
== CPP_OPEN_PAREN
12721 || token
->type
== CPP_OPEN_BRACE
)
12723 is_initialized
= SD_INITIALIZED
;
12724 initialization_kind
= token
->type
;
12726 if (token
->type
== CPP_EQ
12727 && function_declarator_p (declarator
))
12729 cp_token
*t2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
12730 if (t2
->keyword
== RID_DEFAULT
)
12731 is_initialized
= SD_DEFAULTED
;
12732 else if (t2
->keyword
== RID_DELETE
)
12733 is_initialized
= SD_DELETED
;
12738 /* If the init-declarator isn't initialized and isn't followed by a
12739 `,' or `;', it's not a valid init-declarator. */
12740 if (token
->type
!= CPP_COMMA
12741 && token
->type
!= CPP_SEMICOLON
)
12743 cp_parser_error (parser
, "expected initializer");
12744 return error_mark_node
;
12746 is_initialized
= SD_UNINITIALIZED
;
12747 initialization_kind
= CPP_EOF
;
12750 /* Because start_decl has side-effects, we should only call it if we
12751 know we're going ahead. By this point, we know that we cannot
12752 possibly be looking at any other construct. */
12753 cp_parser_commit_to_tentative_parse (parser
);
12755 /* If the decl specifiers were bad, issue an error now that we're
12756 sure this was intended to be a declarator. Then continue
12757 declaring the variable(s), as int, to try to cut down on further
12759 if (decl_specifiers
->any_specifiers_p
12760 && decl_specifiers
->type
== error_mark_node
)
12762 cp_parser_error (parser
, "invalid type in declaration");
12763 decl_specifiers
->type
= integer_type_node
;
12766 /* Check to see whether or not this declaration is a friend. */
12767 friend_p
= cp_parser_friend_p (decl_specifiers
);
12769 /* Enter the newly declared entry in the symbol table. If we're
12770 processing a declaration in a class-specifier, we wait until
12771 after processing the initializer. */
12774 if (parser
->in_unbraced_linkage_specification_p
)
12775 decl_specifiers
->storage_class
= sc_extern
;
12776 decl
= start_decl (declarator
, decl_specifiers
,
12777 is_initialized
, attributes
, prefix_attributes
,
12781 /* Enter the SCOPE. That way unqualified names appearing in the
12782 initializer will be looked up in SCOPE. */
12783 pushed_scope
= push_scope (scope
);
12785 /* Perform deferred access control checks, now that we know in which
12786 SCOPE the declared entity resides. */
12787 if (!member_p
&& decl
)
12789 tree saved_current_function_decl
= NULL_TREE
;
12791 /* If the entity being declared is a function, pretend that we
12792 are in its scope. If it is a `friend', it may have access to
12793 things that would not otherwise be accessible. */
12794 if (TREE_CODE (decl
) == FUNCTION_DECL
)
12796 saved_current_function_decl
= current_function_decl
;
12797 current_function_decl
= decl
;
12800 /* Perform access checks for template parameters. */
12801 cp_parser_perform_template_parameter_access_checks (checks
);
12803 /* Perform the access control checks for the declarator and the
12804 decl-specifiers. */
12805 perform_deferred_access_checks ();
12807 /* Restore the saved value. */
12808 if (TREE_CODE (decl
) == FUNCTION_DECL
)
12809 current_function_decl
= saved_current_function_decl
;
12812 /* Parse the initializer. */
12813 initializer
= NULL_TREE
;
12814 is_direct_init
= false;
12815 is_non_constant_init
= true;
12816 if (is_initialized
)
12818 if (function_declarator_p (declarator
))
12820 cp_token
*initializer_start_token
= cp_lexer_peek_token (parser
->lexer
);
12821 if (initialization_kind
== CPP_EQ
)
12822 initializer
= cp_parser_pure_specifier (parser
);
12825 /* If the declaration was erroneous, we don't really
12826 know what the user intended, so just silently
12827 consume the initializer. */
12828 if (decl
!= error_mark_node
)
12829 error ("%Hinitializer provided for function",
12830 &initializer_start_token
->location
);
12831 cp_parser_skip_to_closing_parenthesis (parser
,
12832 /*recovering=*/true,
12833 /*or_comma=*/false,
12834 /*consume_paren=*/true);
12838 initializer
= cp_parser_initializer (parser
,
12840 &is_non_constant_init
);
12843 /* The old parser allows attributes to appear after a parenthesized
12844 initializer. Mark Mitchell proposed removing this functionality
12845 on the GCC mailing lists on 2002-08-13. This parser accepts the
12846 attributes -- but ignores them. */
12847 if (cp_parser_allow_gnu_extensions_p (parser
)
12848 && initialization_kind
== CPP_OPEN_PAREN
)
12849 if (cp_parser_attributes_opt (parser
))
12850 warning (OPT_Wattributes
,
12851 "attributes after parenthesized initializer ignored");
12853 /* For an in-class declaration, use `grokfield' to create the
12859 pop_scope (pushed_scope
);
12860 pushed_scope
= false;
12862 decl
= grokfield (declarator
, decl_specifiers
,
12863 initializer
, !is_non_constant_init
,
12864 /*asmspec=*/NULL_TREE
,
12865 prefix_attributes
);
12866 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
12867 cp_parser_save_default_args (parser
, decl
);
12870 /* Finish processing the declaration. But, skip friend
12872 if (!friend_p
&& decl
&& decl
!= error_mark_node
)
12874 cp_finish_decl (decl
,
12875 initializer
, !is_non_constant_init
,
12877 /* If the initializer is in parentheses, then this is
12878 a direct-initialization, which means that an
12879 `explicit' constructor is OK. Otherwise, an
12880 `explicit' constructor cannot be used. */
12881 ((is_direct_init
|| !is_initialized
)
12882 ? 0 : LOOKUP_ONLYCONVERTING
));
12884 else if ((cxx_dialect
!= cxx98
) && friend_p
12885 && decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
12886 /* Core issue #226 (C++0x only): A default template-argument
12887 shall not be specified in a friend class template
12889 check_default_tmpl_args (decl
, current_template_parms
, /*is_primary=*/1,
12890 /*is_partial=*/0, /*is_friend_decl=*/1);
12892 if (!friend_p
&& pushed_scope
)
12893 pop_scope (pushed_scope
);
12898 /* Parse a declarator.
12902 ptr-operator declarator
12904 abstract-declarator:
12905 ptr-operator abstract-declarator [opt]
12906 direct-abstract-declarator
12911 attributes [opt] direct-declarator
12912 attributes [opt] ptr-operator declarator
12914 abstract-declarator:
12915 attributes [opt] ptr-operator abstract-declarator [opt]
12916 attributes [opt] direct-abstract-declarator
12918 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
12919 detect constructor, destructor or conversion operators. It is set
12920 to -1 if the declarator is a name, and +1 if it is a
12921 function. Otherwise it is set to zero. Usually you just want to
12922 test for >0, but internally the negative value is used.
12924 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
12925 a decl-specifier-seq unless it declares a constructor, destructor,
12926 or conversion. It might seem that we could check this condition in
12927 semantic analysis, rather than parsing, but that makes it difficult
12928 to handle something like `f()'. We want to notice that there are
12929 no decl-specifiers, and therefore realize that this is an
12930 expression, not a declaration.)
12932 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
12933 the declarator is a direct-declarator of the form "(...)".
12935 MEMBER_P is true iff this declarator is a member-declarator. */
12937 static cp_declarator
*
12938 cp_parser_declarator (cp_parser
* parser
,
12939 cp_parser_declarator_kind dcl_kind
,
12940 int* ctor_dtor_or_conv_p
,
12941 bool* parenthesized_p
,
12945 cp_declarator
*declarator
;
12946 enum tree_code code
;
12947 cp_cv_quals cv_quals
;
12949 tree attributes
= NULL_TREE
;
12951 /* Assume this is not a constructor, destructor, or type-conversion
12953 if (ctor_dtor_or_conv_p
)
12954 *ctor_dtor_or_conv_p
= 0;
12956 if (cp_parser_allow_gnu_extensions_p (parser
))
12957 attributes
= cp_parser_attributes_opt (parser
);
12959 /* Peek at the next token. */
12960 token
= cp_lexer_peek_token (parser
->lexer
);
12962 /* Check for the ptr-operator production. */
12963 cp_parser_parse_tentatively (parser
);
12964 /* Parse the ptr-operator. */
12965 code
= cp_parser_ptr_operator (parser
,
12968 /* If that worked, then we have a ptr-operator. */
12969 if (cp_parser_parse_definitely (parser
))
12971 /* If a ptr-operator was found, then this declarator was not
12973 if (parenthesized_p
)
12974 *parenthesized_p
= true;
12975 /* The dependent declarator is optional if we are parsing an
12976 abstract-declarator. */
12977 if (dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
12978 cp_parser_parse_tentatively (parser
);
12980 /* Parse the dependent declarator. */
12981 declarator
= cp_parser_declarator (parser
, dcl_kind
,
12982 /*ctor_dtor_or_conv_p=*/NULL
,
12983 /*parenthesized_p=*/NULL
,
12984 /*member_p=*/false);
12986 /* If we are parsing an abstract-declarator, we must handle the
12987 case where the dependent declarator is absent. */
12988 if (dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
12989 && !cp_parser_parse_definitely (parser
))
12992 declarator
= cp_parser_make_indirect_declarator
12993 (code
, class_type
, cv_quals
, declarator
);
12995 /* Everything else is a direct-declarator. */
12998 if (parenthesized_p
)
12999 *parenthesized_p
= cp_lexer_next_token_is (parser
->lexer
,
13001 declarator
= cp_parser_direct_declarator (parser
, dcl_kind
,
13002 ctor_dtor_or_conv_p
,
13006 if (attributes
&& declarator
&& declarator
!= cp_error_declarator
)
13007 declarator
->attributes
= attributes
;
13012 /* Parse a direct-declarator or direct-abstract-declarator.
13016 direct-declarator ( parameter-declaration-clause )
13017 cv-qualifier-seq [opt]
13018 exception-specification [opt]
13019 direct-declarator [ constant-expression [opt] ]
13022 direct-abstract-declarator:
13023 direct-abstract-declarator [opt]
13024 ( parameter-declaration-clause )
13025 cv-qualifier-seq [opt]
13026 exception-specification [opt]
13027 direct-abstract-declarator [opt] [ constant-expression [opt] ]
13028 ( abstract-declarator )
13030 Returns a representation of the declarator. DCL_KIND is
13031 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
13032 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
13033 we are parsing a direct-declarator. It is
13034 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
13035 of ambiguity we prefer an abstract declarator, as per
13036 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
13037 cp_parser_declarator. */
13039 static cp_declarator
*
13040 cp_parser_direct_declarator (cp_parser
* parser
,
13041 cp_parser_declarator_kind dcl_kind
,
13042 int* ctor_dtor_or_conv_p
,
13046 cp_declarator
*declarator
= NULL
;
13047 tree scope
= NULL_TREE
;
13048 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
13049 bool saved_in_declarator_p
= parser
->in_declarator_p
;
13051 tree pushed_scope
= NULL_TREE
;
13055 /* Peek at the next token. */
13056 token
= cp_lexer_peek_token (parser
->lexer
);
13057 if (token
->type
== CPP_OPEN_PAREN
)
13059 /* This is either a parameter-declaration-clause, or a
13060 parenthesized declarator. When we know we are parsing a
13061 named declarator, it must be a parenthesized declarator
13062 if FIRST is true. For instance, `(int)' is a
13063 parameter-declaration-clause, with an omitted
13064 direct-abstract-declarator. But `((*))', is a
13065 parenthesized abstract declarator. Finally, when T is a
13066 template parameter `(T)' is a
13067 parameter-declaration-clause, and not a parenthesized
13070 We first try and parse a parameter-declaration-clause,
13071 and then try a nested declarator (if FIRST is true).
13073 It is not an error for it not to be a
13074 parameter-declaration-clause, even when FIRST is
13080 The first is the declaration of a function while the
13081 second is the definition of a variable, including its
13084 Having seen only the parenthesis, we cannot know which of
13085 these two alternatives should be selected. Even more
13086 complex are examples like:
13091 The former is a function-declaration; the latter is a
13092 variable initialization.
13094 Thus again, we try a parameter-declaration-clause, and if
13095 that fails, we back out and return. */
13097 if (!first
|| dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
13100 unsigned saved_num_template_parameter_lists
;
13101 bool is_declarator
= false;
13104 /* In a member-declarator, the only valid interpretation
13105 of a parenthesis is the start of a
13106 parameter-declaration-clause. (It is invalid to
13107 initialize a static data member with a parenthesized
13108 initializer; only the "=" form of initialization is
13111 cp_parser_parse_tentatively (parser
);
13113 /* Consume the `('. */
13114 cp_lexer_consume_token (parser
->lexer
);
13117 /* If this is going to be an abstract declarator, we're
13118 in a declarator and we can't have default args. */
13119 parser
->default_arg_ok_p
= false;
13120 parser
->in_declarator_p
= true;
13123 /* Inside the function parameter list, surrounding
13124 template-parameter-lists do not apply. */
13125 saved_num_template_parameter_lists
13126 = parser
->num_template_parameter_lists
;
13127 parser
->num_template_parameter_lists
= 0;
13129 begin_scope (sk_function_parms
, NULL_TREE
);
13131 /* Parse the parameter-declaration-clause. */
13132 params
= cp_parser_parameter_declaration_clause (parser
);
13134 parser
->num_template_parameter_lists
13135 = saved_num_template_parameter_lists
;
13137 /* If all went well, parse the cv-qualifier-seq and the
13138 exception-specification. */
13139 if (member_p
|| cp_parser_parse_definitely (parser
))
13141 cp_cv_quals cv_quals
;
13142 tree exception_specification
;
13145 is_declarator
= true;
13147 if (ctor_dtor_or_conv_p
)
13148 *ctor_dtor_or_conv_p
= *ctor_dtor_or_conv_p
< 0;
13150 /* Consume the `)'. */
13151 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
13153 /* Parse the cv-qualifier-seq. */
13154 cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
13155 /* And the exception-specification. */
13156 exception_specification
13157 = cp_parser_exception_specification_opt (parser
);
13160 = cp_parser_late_return_type_opt (parser
);
13162 /* Create the function-declarator. */
13163 declarator
= make_call_declarator (declarator
,
13166 exception_specification
,
13168 /* Any subsequent parameter lists are to do with
13169 return type, so are not those of the declared
13171 parser
->default_arg_ok_p
= false;
13174 /* Remove the function parms from scope. */
13175 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
13176 pop_binding (DECL_NAME (t
), t
);
13180 /* Repeat the main loop. */
13184 /* If this is the first, we can try a parenthesized
13188 bool saved_in_type_id_in_expr_p
;
13190 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
13191 parser
->in_declarator_p
= saved_in_declarator_p
;
13193 /* Consume the `('. */
13194 cp_lexer_consume_token (parser
->lexer
);
13195 /* Parse the nested declarator. */
13196 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
13197 parser
->in_type_id_in_expr_p
= true;
13199 = cp_parser_declarator (parser
, dcl_kind
, ctor_dtor_or_conv_p
,
13200 /*parenthesized_p=*/NULL
,
13202 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
13204 /* Expect a `)'. */
13205 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
13206 declarator
= cp_error_declarator
;
13207 if (declarator
== cp_error_declarator
)
13210 goto handle_declarator
;
13212 /* Otherwise, we must be done. */
13216 else if ((!first
|| dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
13217 && token
->type
== CPP_OPEN_SQUARE
)
13219 /* Parse an array-declarator. */
13222 if (ctor_dtor_or_conv_p
)
13223 *ctor_dtor_or_conv_p
= 0;
13226 parser
->default_arg_ok_p
= false;
13227 parser
->in_declarator_p
= true;
13228 /* Consume the `['. */
13229 cp_lexer_consume_token (parser
->lexer
);
13230 /* Peek at the next token. */
13231 token
= cp_lexer_peek_token (parser
->lexer
);
13232 /* If the next token is `]', then there is no
13233 constant-expression. */
13234 if (token
->type
!= CPP_CLOSE_SQUARE
)
13236 bool non_constant_p
;
13239 = cp_parser_constant_expression (parser
,
13240 /*allow_non_constant=*/true,
13242 if (!non_constant_p
)
13243 bounds
= fold_non_dependent_expr (bounds
);
13244 /* Normally, the array bound must be an integral constant
13245 expression. However, as an extension, we allow VLAs
13246 in function scopes. */
13247 else if (!parser
->in_function_body
)
13249 error ("%Harray bound is not an integer constant",
13251 bounds
= error_mark_node
;
13255 bounds
= NULL_TREE
;
13256 /* Look for the closing `]'. */
13257 if (!cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>"))
13259 declarator
= cp_error_declarator
;
13263 declarator
= make_array_declarator (declarator
, bounds
);
13265 else if (first
&& dcl_kind
!= CP_PARSER_DECLARATOR_ABSTRACT
)
13267 tree qualifying_scope
;
13268 tree unqualified_name
;
13269 special_function_kind sfk
;
13271 bool pack_expansion_p
= false;
13272 cp_token
*declarator_id_start_token
;
13274 /* Parse a declarator-id */
13275 abstract_ok
= (dcl_kind
== CP_PARSER_DECLARATOR_EITHER
);
13278 cp_parser_parse_tentatively (parser
);
13280 /* If we see an ellipsis, we should be looking at a
13282 if (token
->type
== CPP_ELLIPSIS
)
13284 /* Consume the `...' */
13285 cp_lexer_consume_token (parser
->lexer
);
13287 pack_expansion_p
= true;
13291 declarator_id_start_token
= cp_lexer_peek_token (parser
->lexer
);
13293 = cp_parser_declarator_id (parser
, /*optional_p=*/abstract_ok
);
13294 qualifying_scope
= parser
->scope
;
13299 if (!unqualified_name
&& pack_expansion_p
)
13301 /* Check whether an error occurred. */
13302 okay
= !cp_parser_error_occurred (parser
);
13304 /* We already consumed the ellipsis to mark a
13305 parameter pack, but we have no way to report it,
13306 so abort the tentative parse. We will be exiting
13307 immediately anyway. */
13308 cp_parser_abort_tentative_parse (parser
);
13311 okay
= cp_parser_parse_definitely (parser
);
13314 unqualified_name
= error_mark_node
;
13315 else if (unqualified_name
13316 && (qualifying_scope
13317 || (TREE_CODE (unqualified_name
)
13318 != IDENTIFIER_NODE
)))
13320 cp_parser_error (parser
, "expected unqualified-id");
13321 unqualified_name
= error_mark_node
;
13325 if (!unqualified_name
)
13327 if (unqualified_name
== error_mark_node
)
13329 declarator
= cp_error_declarator
;
13330 pack_expansion_p
= false;
13331 declarator
->parameter_pack_p
= false;
13335 if (qualifying_scope
&& at_namespace_scope_p ()
13336 && TREE_CODE (qualifying_scope
) == TYPENAME_TYPE
)
13338 /* In the declaration of a member of a template class
13339 outside of the class itself, the SCOPE will sometimes
13340 be a TYPENAME_TYPE. For example, given:
13342 template <typename T>
13343 int S<T>::R::i = 3;
13345 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
13346 this context, we must resolve S<T>::R to an ordinary
13347 type, rather than a typename type.
13349 The reason we normally avoid resolving TYPENAME_TYPEs
13350 is that a specialization of `S' might render
13351 `S<T>::R' not a type. However, if `S' is
13352 specialized, then this `i' will not be used, so there
13353 is no harm in resolving the types here. */
13356 /* Resolve the TYPENAME_TYPE. */
13357 type
= resolve_typename_type (qualifying_scope
,
13358 /*only_current_p=*/false);
13359 /* If that failed, the declarator is invalid. */
13360 if (TREE_CODE (type
) == TYPENAME_TYPE
)
13361 error ("%H%<%T::%E%> is not a type",
13362 &declarator_id_start_token
->location
,
13363 TYPE_CONTEXT (qualifying_scope
),
13364 TYPE_IDENTIFIER (qualifying_scope
));
13365 qualifying_scope
= type
;
13370 if (unqualified_name
)
13374 if (qualifying_scope
13375 && CLASS_TYPE_P (qualifying_scope
))
13376 class_type
= qualifying_scope
;
13378 class_type
= current_class_type
;
13380 if (TREE_CODE (unqualified_name
) == TYPE_DECL
)
13382 tree name_type
= TREE_TYPE (unqualified_name
);
13383 if (class_type
&& same_type_p (name_type
, class_type
))
13385 if (qualifying_scope
13386 && CLASSTYPE_USE_TEMPLATE (name_type
))
13388 error ("%Hinvalid use of constructor as a template",
13389 &declarator_id_start_token
->location
);
13390 inform (input_location
, "use %<%T::%D%> instead of %<%T::%D%> to "
13391 "name the constructor in a qualified name",
13393 DECL_NAME (TYPE_TI_TEMPLATE (class_type
)),
13394 class_type
, name_type
);
13395 declarator
= cp_error_declarator
;
13399 unqualified_name
= constructor_name (class_type
);
13403 /* We do not attempt to print the declarator
13404 here because we do not have enough
13405 information about its original syntactic
13407 cp_parser_error (parser
, "invalid declarator");
13408 declarator
= cp_error_declarator
;
13415 if (TREE_CODE (unqualified_name
) == BIT_NOT_EXPR
)
13416 sfk
= sfk_destructor
;
13417 else if (IDENTIFIER_TYPENAME_P (unqualified_name
))
13418 sfk
= sfk_conversion
;
13419 else if (/* There's no way to declare a constructor
13420 for an anonymous type, even if the type
13421 got a name for linkage purposes. */
13422 !TYPE_WAS_ANONYMOUS (class_type
)
13423 && constructor_name_p (unqualified_name
,
13426 unqualified_name
= constructor_name (class_type
);
13427 sfk
= sfk_constructor
;
13430 if (ctor_dtor_or_conv_p
&& sfk
!= sfk_none
)
13431 *ctor_dtor_or_conv_p
= -1;
13434 declarator
= make_id_declarator (qualifying_scope
,
13437 declarator
->id_loc
= token
->location
;
13438 declarator
->parameter_pack_p
= pack_expansion_p
;
13440 if (pack_expansion_p
)
13441 maybe_warn_variadic_templates ();
13443 handle_declarator
:;
13444 scope
= get_scope_of_declarator (declarator
);
13446 /* Any names that appear after the declarator-id for a
13447 member are looked up in the containing scope. */
13448 pushed_scope
= push_scope (scope
);
13449 parser
->in_declarator_p
= true;
13450 if ((ctor_dtor_or_conv_p
&& *ctor_dtor_or_conv_p
)
13451 || (declarator
&& declarator
->kind
== cdk_id
))
13452 /* Default args are only allowed on function
13454 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
13456 parser
->default_arg_ok_p
= false;
13465 /* For an abstract declarator, we might wind up with nothing at this
13466 point. That's an error; the declarator is not optional. */
13468 cp_parser_error (parser
, "expected declarator");
13470 /* If we entered a scope, we must exit it now. */
13472 pop_scope (pushed_scope
);
13474 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
13475 parser
->in_declarator_p
= saved_in_declarator_p
;
13480 /* Parse a ptr-operator.
13483 * cv-qualifier-seq [opt]
13485 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
13490 & cv-qualifier-seq [opt]
13492 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
13493 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
13494 an rvalue reference. In the case of a pointer-to-member, *TYPE is
13495 filled in with the TYPE containing the member. *CV_QUALS is
13496 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
13497 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
13498 Note that the tree codes returned by this function have nothing
13499 to do with the types of trees that will be eventually be created
13500 to represent the pointer or reference type being parsed. They are
13501 just constants with suggestive names. */
13502 static enum tree_code
13503 cp_parser_ptr_operator (cp_parser
* parser
,
13505 cp_cv_quals
*cv_quals
)
13507 enum tree_code code
= ERROR_MARK
;
13510 /* Assume that it's not a pointer-to-member. */
13512 /* And that there are no cv-qualifiers. */
13513 *cv_quals
= TYPE_UNQUALIFIED
;
13515 /* Peek at the next token. */
13516 token
= cp_lexer_peek_token (parser
->lexer
);
13518 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
13519 if (token
->type
== CPP_MULT
)
13520 code
= INDIRECT_REF
;
13521 else if (token
->type
== CPP_AND
)
13523 else if ((cxx_dialect
!= cxx98
) &&
13524 token
->type
== CPP_AND_AND
) /* C++0x only */
13525 code
= NON_LVALUE_EXPR
;
13527 if (code
!= ERROR_MARK
)
13529 /* Consume the `*', `&' or `&&'. */
13530 cp_lexer_consume_token (parser
->lexer
);
13532 /* A `*' can be followed by a cv-qualifier-seq, and so can a
13533 `&', if we are allowing GNU extensions. (The only qualifier
13534 that can legally appear after `&' is `restrict', but that is
13535 enforced during semantic analysis. */
13536 if (code
== INDIRECT_REF
13537 || cp_parser_allow_gnu_extensions_p (parser
))
13538 *cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
13542 /* Try the pointer-to-member case. */
13543 cp_parser_parse_tentatively (parser
);
13544 /* Look for the optional `::' operator. */
13545 cp_parser_global_scope_opt (parser
,
13546 /*current_scope_valid_p=*/false);
13547 /* Look for the nested-name specifier. */
13548 token
= cp_lexer_peek_token (parser
->lexer
);
13549 cp_parser_nested_name_specifier (parser
,
13550 /*typename_keyword_p=*/false,
13551 /*check_dependency_p=*/true,
13553 /*is_declaration=*/false);
13554 /* If we found it, and the next token is a `*', then we are
13555 indeed looking at a pointer-to-member operator. */
13556 if (!cp_parser_error_occurred (parser
)
13557 && cp_parser_require (parser
, CPP_MULT
, "%<*%>"))
13559 /* Indicate that the `*' operator was used. */
13560 code
= INDIRECT_REF
;
13562 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
13563 error ("%H%qD is a namespace", &token
->location
, parser
->scope
);
13566 /* The type of which the member is a member is given by the
13568 *type
= parser
->scope
;
13569 /* The next name will not be qualified. */
13570 parser
->scope
= NULL_TREE
;
13571 parser
->qualifying_scope
= NULL_TREE
;
13572 parser
->object_scope
= NULL_TREE
;
13573 /* Look for the optional cv-qualifier-seq. */
13574 *cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
13577 /* If that didn't work we don't have a ptr-operator. */
13578 if (!cp_parser_parse_definitely (parser
))
13579 cp_parser_error (parser
, "expected ptr-operator");
13585 /* Parse an (optional) cv-qualifier-seq.
13588 cv-qualifier cv-qualifier-seq [opt]
13599 Returns a bitmask representing the cv-qualifiers. */
13602 cp_parser_cv_qualifier_seq_opt (cp_parser
* parser
)
13604 cp_cv_quals cv_quals
= TYPE_UNQUALIFIED
;
13609 cp_cv_quals cv_qualifier
;
13611 /* Peek at the next token. */
13612 token
= cp_lexer_peek_token (parser
->lexer
);
13613 /* See if it's a cv-qualifier. */
13614 switch (token
->keyword
)
13617 cv_qualifier
= TYPE_QUAL_CONST
;
13621 cv_qualifier
= TYPE_QUAL_VOLATILE
;
13625 cv_qualifier
= TYPE_QUAL_RESTRICT
;
13629 cv_qualifier
= TYPE_UNQUALIFIED
;
13636 if (cv_quals
& cv_qualifier
)
13638 error ("%Hduplicate cv-qualifier", &token
->location
);
13639 cp_lexer_purge_token (parser
->lexer
);
13643 cp_lexer_consume_token (parser
->lexer
);
13644 cv_quals
|= cv_qualifier
;
13651 /* Parse a late-specified return type, if any. This is not a separate
13652 non-terminal, but part of a function declarator, which looks like
13656 Returns the type indicated by the type-id. */
13659 cp_parser_late_return_type_opt (cp_parser
* parser
)
13663 /* Peek at the next token. */
13664 token
= cp_lexer_peek_token (parser
->lexer
);
13665 /* A late-specified return type is indicated by an initial '->'. */
13666 if (token
->type
!= CPP_DEREF
)
13669 /* Consume the ->. */
13670 cp_lexer_consume_token (parser
->lexer
);
13672 return cp_parser_type_id (parser
);
13675 /* Parse a declarator-id.
13679 :: [opt] nested-name-specifier [opt] type-name
13681 In the `id-expression' case, the value returned is as for
13682 cp_parser_id_expression if the id-expression was an unqualified-id.
13683 If the id-expression was a qualified-id, then a SCOPE_REF is
13684 returned. The first operand is the scope (either a NAMESPACE_DECL
13685 or TREE_TYPE), but the second is still just a representation of an
13689 cp_parser_declarator_id (cp_parser
* parser
, bool optional_p
)
13692 /* The expression must be an id-expression. Assume that qualified
13693 names are the names of types so that:
13696 int S<T>::R::i = 3;
13698 will work; we must treat `S<T>::R' as the name of a type.
13699 Similarly, assume that qualified names are templates, where
13703 int S<T>::R<T>::i = 3;
13706 id
= cp_parser_id_expression (parser
,
13707 /*template_keyword_p=*/false,
13708 /*check_dependency_p=*/false,
13709 /*template_p=*/NULL
,
13710 /*declarator_p=*/true,
13712 if (id
&& BASELINK_P (id
))
13713 id
= BASELINK_FUNCTIONS (id
);
13717 /* Parse a type-id.
13720 type-specifier-seq abstract-declarator [opt]
13722 Returns the TYPE specified. */
13725 cp_parser_type_id (cp_parser
* parser
)
13727 cp_decl_specifier_seq type_specifier_seq
;
13728 cp_declarator
*abstract_declarator
;
13730 /* Parse the type-specifier-seq. */
13731 cp_parser_type_specifier_seq (parser
, /*is_condition=*/false,
13732 &type_specifier_seq
);
13733 if (type_specifier_seq
.type
== error_mark_node
)
13734 return error_mark_node
;
13736 /* There might or might not be an abstract declarator. */
13737 cp_parser_parse_tentatively (parser
);
13738 /* Look for the declarator. */
13739 abstract_declarator
13740 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_ABSTRACT
, NULL
,
13741 /*parenthesized_p=*/NULL
,
13742 /*member_p=*/false);
13743 /* Check to see if there really was a declarator. */
13744 if (!cp_parser_parse_definitely (parser
))
13745 abstract_declarator
= NULL
;
13747 if (type_specifier_seq
.type
13748 && type_uses_auto (type_specifier_seq
.type
))
13750 error ("invalid use of %<auto%>");
13751 return error_mark_node
;
13754 return groktypename (&type_specifier_seq
, abstract_declarator
);
13757 /* Parse a type-specifier-seq.
13759 type-specifier-seq:
13760 type-specifier type-specifier-seq [opt]
13764 type-specifier-seq:
13765 attributes type-specifier-seq [opt]
13767 If IS_CONDITION is true, we are at the start of a "condition",
13768 e.g., we've just seen "if (".
13770 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
13773 cp_parser_type_specifier_seq (cp_parser
* parser
,
13775 cp_decl_specifier_seq
*type_specifier_seq
)
13777 bool seen_type_specifier
= false;
13778 cp_parser_flags flags
= CP_PARSER_FLAGS_OPTIONAL
;
13779 cp_token
*start_token
= NULL
;
13781 /* Clear the TYPE_SPECIFIER_SEQ. */
13782 clear_decl_specs (type_specifier_seq
);
13784 /* Parse the type-specifiers and attributes. */
13787 tree type_specifier
;
13788 bool is_cv_qualifier
;
13790 /* Check for attributes first. */
13791 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ATTRIBUTE
))
13793 type_specifier_seq
->attributes
=
13794 chainon (type_specifier_seq
->attributes
,
13795 cp_parser_attributes_opt (parser
));
13799 /* record the token of the beginning of the type specifier seq,
13800 for error reporting purposes*/
13802 start_token
= cp_lexer_peek_token (parser
->lexer
);
13804 /* Look for the type-specifier. */
13805 type_specifier
= cp_parser_type_specifier (parser
,
13807 type_specifier_seq
,
13808 /*is_declaration=*/false,
13811 if (!type_specifier
)
13813 /* If the first type-specifier could not be found, this is not a
13814 type-specifier-seq at all. */
13815 if (!seen_type_specifier
)
13817 cp_parser_error (parser
, "expected type-specifier");
13818 type_specifier_seq
->type
= error_mark_node
;
13821 /* If subsequent type-specifiers could not be found, the
13822 type-specifier-seq is complete. */
13826 seen_type_specifier
= true;
13827 /* The standard says that a condition can be:
13829 type-specifier-seq declarator = assignment-expression
13836 we should treat the "S" as a declarator, not as a
13837 type-specifier. The standard doesn't say that explicitly for
13838 type-specifier-seq, but it does say that for
13839 decl-specifier-seq in an ordinary declaration. Perhaps it
13840 would be clearer just to allow a decl-specifier-seq here, and
13841 then add a semantic restriction that if any decl-specifiers
13842 that are not type-specifiers appear, the program is invalid. */
13843 if (is_condition
&& !is_cv_qualifier
)
13844 flags
|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
;
13847 cp_parser_check_decl_spec (type_specifier_seq
, start_token
->location
);
13850 /* Parse a parameter-declaration-clause.
13852 parameter-declaration-clause:
13853 parameter-declaration-list [opt] ... [opt]
13854 parameter-declaration-list , ...
13856 Returns a representation for the parameter declarations. A return
13857 value of NULL indicates a parameter-declaration-clause consisting
13858 only of an ellipsis. */
13861 cp_parser_parameter_declaration_clause (cp_parser
* parser
)
13868 /* Peek at the next token. */
13869 token
= cp_lexer_peek_token (parser
->lexer
);
13870 /* Check for trivial parameter-declaration-clauses. */
13871 if (token
->type
== CPP_ELLIPSIS
)
13873 /* Consume the `...' token. */
13874 cp_lexer_consume_token (parser
->lexer
);
13877 else if (token
->type
== CPP_CLOSE_PAREN
)
13878 /* There are no parameters. */
13880 #ifndef NO_IMPLICIT_EXTERN_C
13881 if (in_system_header
&& current_class_type
== NULL
13882 && current_lang_name
== lang_name_c
)
13886 return void_list_node
;
13888 /* Check for `(void)', too, which is a special case. */
13889 else if (token
->keyword
== RID_VOID
13890 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
13891 == CPP_CLOSE_PAREN
))
13893 /* Consume the `void' token. */
13894 cp_lexer_consume_token (parser
->lexer
);
13895 /* There are no parameters. */
13896 return void_list_node
;
13899 /* Parse the parameter-declaration-list. */
13900 parameters
= cp_parser_parameter_declaration_list (parser
, &is_error
);
13901 /* If a parse error occurred while parsing the
13902 parameter-declaration-list, then the entire
13903 parameter-declaration-clause is erroneous. */
13907 /* Peek at the next token. */
13908 token
= cp_lexer_peek_token (parser
->lexer
);
13909 /* If it's a `,', the clause should terminate with an ellipsis. */
13910 if (token
->type
== CPP_COMMA
)
13912 /* Consume the `,'. */
13913 cp_lexer_consume_token (parser
->lexer
);
13914 /* Expect an ellipsis. */
13916 = (cp_parser_require (parser
, CPP_ELLIPSIS
, "%<...%>") != NULL
);
13918 /* It might also be `...' if the optional trailing `,' was
13920 else if (token
->type
== CPP_ELLIPSIS
)
13922 /* Consume the `...' token. */
13923 cp_lexer_consume_token (parser
->lexer
);
13924 /* And remember that we saw it. */
13928 ellipsis_p
= false;
13930 /* Finish the parameter list. */
13932 parameters
= chainon (parameters
, void_list_node
);
13937 /* Parse a parameter-declaration-list.
13939 parameter-declaration-list:
13940 parameter-declaration
13941 parameter-declaration-list , parameter-declaration
13943 Returns a representation of the parameter-declaration-list, as for
13944 cp_parser_parameter_declaration_clause. However, the
13945 `void_list_node' is never appended to the list. Upon return,
13946 *IS_ERROR will be true iff an error occurred. */
13949 cp_parser_parameter_declaration_list (cp_parser
* parser
, bool *is_error
)
13951 tree parameters
= NULL_TREE
;
13952 tree
*tail
= ¶meters
;
13953 bool saved_in_unbraced_linkage_specification_p
;
13955 /* Assume all will go well. */
13957 /* The special considerations that apply to a function within an
13958 unbraced linkage specifications do not apply to the parameters
13959 to the function. */
13960 saved_in_unbraced_linkage_specification_p
13961 = parser
->in_unbraced_linkage_specification_p
;
13962 parser
->in_unbraced_linkage_specification_p
= false;
13964 /* Look for more parameters. */
13967 cp_parameter_declarator
*parameter
;
13968 tree decl
= error_mark_node
;
13969 bool parenthesized_p
;
13970 /* Parse the parameter. */
13972 = cp_parser_parameter_declaration (parser
,
13973 /*template_parm_p=*/false,
13976 /* We don't know yet if the enclosing context is deprecated, so wait
13977 and warn in grokparms if appropriate. */
13978 deprecated_state
= DEPRECATED_SUPPRESS
;
13981 decl
= grokdeclarator (parameter
->declarator
,
13982 ¶meter
->decl_specifiers
,
13984 parameter
->default_argument
!= NULL_TREE
,
13985 ¶meter
->decl_specifiers
.attributes
);
13987 deprecated_state
= DEPRECATED_NORMAL
;
13989 /* If a parse error occurred parsing the parameter declaration,
13990 then the entire parameter-declaration-list is erroneous. */
13991 if (decl
== error_mark_node
)
13994 parameters
= error_mark_node
;
13998 if (parameter
->decl_specifiers
.attributes
)
13999 cplus_decl_attributes (&decl
,
14000 parameter
->decl_specifiers
.attributes
,
14002 if (DECL_NAME (decl
))
14003 decl
= pushdecl (decl
);
14005 /* Add the new parameter to the list. */
14006 *tail
= build_tree_list (parameter
->default_argument
, decl
);
14007 tail
= &TREE_CHAIN (*tail
);
14009 /* Peek at the next token. */
14010 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
)
14011 || cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
)
14012 /* These are for Objective-C++ */
14013 || cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
14014 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
14015 /* The parameter-declaration-list is complete. */
14017 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
14021 /* Peek at the next token. */
14022 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
14023 /* If it's an ellipsis, then the list is complete. */
14024 if (token
->type
== CPP_ELLIPSIS
)
14026 /* Otherwise, there must be more parameters. Consume the
14028 cp_lexer_consume_token (parser
->lexer
);
14029 /* When parsing something like:
14031 int i(float f, double d)
14033 we can tell after seeing the declaration for "f" that we
14034 are not looking at an initialization of a variable "i",
14035 but rather at the declaration of a function "i".
14037 Due to the fact that the parsing of template arguments
14038 (as specified to a template-id) requires backtracking we
14039 cannot use this technique when inside a template argument
14041 if (!parser
->in_template_argument_list_p
14042 && !parser
->in_type_id_in_expr_p
14043 && cp_parser_uncommitted_to_tentative_parse_p (parser
)
14044 /* However, a parameter-declaration of the form
14045 "foat(f)" (which is a valid declaration of a
14046 parameter "f") can also be interpreted as an
14047 expression (the conversion of "f" to "float"). */
14048 && !parenthesized_p
)
14049 cp_parser_commit_to_tentative_parse (parser
);
14053 cp_parser_error (parser
, "expected %<,%> or %<...%>");
14054 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
14055 cp_parser_skip_to_closing_parenthesis (parser
,
14056 /*recovering=*/true,
14057 /*or_comma=*/false,
14058 /*consume_paren=*/false);
14063 parser
->in_unbraced_linkage_specification_p
14064 = saved_in_unbraced_linkage_specification_p
;
14069 /* Parse a parameter declaration.
14071 parameter-declaration:
14072 decl-specifier-seq ... [opt] declarator
14073 decl-specifier-seq declarator = assignment-expression
14074 decl-specifier-seq ... [opt] abstract-declarator [opt]
14075 decl-specifier-seq abstract-declarator [opt] = assignment-expression
14077 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
14078 declares a template parameter. (In that case, a non-nested `>'
14079 token encountered during the parsing of the assignment-expression
14080 is not interpreted as a greater-than operator.)
14082 Returns a representation of the parameter, or NULL if an error
14083 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
14084 true iff the declarator is of the form "(p)". */
14086 static cp_parameter_declarator
*
14087 cp_parser_parameter_declaration (cp_parser
*parser
,
14088 bool template_parm_p
,
14089 bool *parenthesized_p
)
14091 int declares_class_or_enum
;
14092 bool greater_than_is_operator_p
;
14093 cp_decl_specifier_seq decl_specifiers
;
14094 cp_declarator
*declarator
;
14095 tree default_argument
;
14096 cp_token
*token
= NULL
, *declarator_token_start
= NULL
;
14097 const char *saved_message
;
14099 /* In a template parameter, `>' is not an operator.
14103 When parsing a default template-argument for a non-type
14104 template-parameter, the first non-nested `>' is taken as the end
14105 of the template parameter-list rather than a greater-than
14107 greater_than_is_operator_p
= !template_parm_p
;
14109 /* Type definitions may not appear in parameter types. */
14110 saved_message
= parser
->type_definition_forbidden_message
;
14111 parser
->type_definition_forbidden_message
14112 = "types may not be defined in parameter types";
14114 /* Parse the declaration-specifiers. */
14115 cp_parser_decl_specifier_seq (parser
,
14116 CP_PARSER_FLAGS_NONE
,
14118 &declares_class_or_enum
);
14119 /* If an error occurred, there's no reason to attempt to parse the
14120 rest of the declaration. */
14121 if (cp_parser_error_occurred (parser
))
14123 parser
->type_definition_forbidden_message
= saved_message
;
14127 /* Peek at the next token. */
14128 token
= cp_lexer_peek_token (parser
->lexer
);
14130 /* If the next token is a `)', `,', `=', `>', or `...', then there
14131 is no declarator. However, when variadic templates are enabled,
14132 there may be a declarator following `...'. */
14133 if (token
->type
== CPP_CLOSE_PAREN
14134 || token
->type
== CPP_COMMA
14135 || token
->type
== CPP_EQ
14136 || token
->type
== CPP_GREATER
)
14139 if (parenthesized_p
)
14140 *parenthesized_p
= false;
14142 /* Otherwise, there should be a declarator. */
14145 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
14146 parser
->default_arg_ok_p
= false;
14148 /* After seeing a decl-specifier-seq, if the next token is not a
14149 "(", there is no possibility that the code is a valid
14150 expression. Therefore, if parsing tentatively, we commit at
14152 if (!parser
->in_template_argument_list_p
14153 /* In an expression context, having seen:
14157 we cannot be sure whether we are looking at a
14158 function-type (taking a "char" as a parameter) or a cast
14159 of some object of type "char" to "int". */
14160 && !parser
->in_type_id_in_expr_p
14161 && cp_parser_uncommitted_to_tentative_parse_p (parser
)
14162 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
))
14163 cp_parser_commit_to_tentative_parse (parser
);
14164 /* Parse the declarator. */
14165 declarator_token_start
= token
;
14166 declarator
= cp_parser_declarator (parser
,
14167 CP_PARSER_DECLARATOR_EITHER
,
14168 /*ctor_dtor_or_conv_p=*/NULL
,
14170 /*member_p=*/false);
14171 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
14172 /* After the declarator, allow more attributes. */
14173 decl_specifiers
.attributes
14174 = chainon (decl_specifiers
.attributes
,
14175 cp_parser_attributes_opt (parser
));
14178 /* If the next token is an ellipsis, and we have not seen a
14179 declarator name, and the type of the declarator contains parameter
14180 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
14181 a parameter pack expansion expression. Otherwise, leave the
14182 ellipsis for a C-style variadic function. */
14183 token
= cp_lexer_peek_token (parser
->lexer
);
14184 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
14186 tree type
= decl_specifiers
.type
;
14188 if (type
&& DECL_P (type
))
14189 type
= TREE_TYPE (type
);
14192 && TREE_CODE (type
) != TYPE_PACK_EXPANSION
14193 && declarator_can_be_parameter_pack (declarator
)
14194 && (!declarator
|| !declarator
->parameter_pack_p
)
14195 && uses_parameter_packs (type
))
14197 /* Consume the `...'. */
14198 cp_lexer_consume_token (parser
->lexer
);
14199 maybe_warn_variadic_templates ();
14201 /* Build a pack expansion type */
14203 declarator
->parameter_pack_p
= true;
14205 decl_specifiers
.type
= make_pack_expansion (type
);
14209 /* The restriction on defining new types applies only to the type
14210 of the parameter, not to the default argument. */
14211 parser
->type_definition_forbidden_message
= saved_message
;
14213 /* If the next token is `=', then process a default argument. */
14214 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
14216 /* Consume the `='. */
14217 cp_lexer_consume_token (parser
->lexer
);
14219 /* If we are defining a class, then the tokens that make up the
14220 default argument must be saved and processed later. */
14221 if (!template_parm_p
&& at_class_scope_p ()
14222 && TYPE_BEING_DEFINED (current_class_type
))
14224 unsigned depth
= 0;
14225 int maybe_template_id
= 0;
14226 cp_token
*first_token
;
14229 /* Add tokens until we have processed the entire default
14230 argument. We add the range [first_token, token). */
14231 first_token
= cp_lexer_peek_token (parser
->lexer
);
14236 /* Peek at the next token. */
14237 token
= cp_lexer_peek_token (parser
->lexer
);
14238 /* What we do depends on what token we have. */
14239 switch (token
->type
)
14241 /* In valid code, a default argument must be
14242 immediately followed by a `,' `)', or `...'. */
14244 if (depth
== 0 && maybe_template_id
)
14246 /* If we've seen a '<', we might be in a
14247 template-argument-list. Until Core issue 325 is
14248 resolved, we don't know how this situation ought
14249 to be handled, so try to DTRT. We check whether
14250 what comes after the comma is a valid parameter
14251 declaration list. If it is, then the comma ends
14252 the default argument; otherwise the default
14253 argument continues. */
14254 bool error
= false;
14256 /* Set ITALP so cp_parser_parameter_declaration_list
14257 doesn't decide to commit to this parse. */
14258 bool saved_italp
= parser
->in_template_argument_list_p
;
14259 parser
->in_template_argument_list_p
= true;
14261 cp_parser_parse_tentatively (parser
);
14262 cp_lexer_consume_token (parser
->lexer
);
14263 cp_parser_parameter_declaration_list (parser
, &error
);
14264 if (!cp_parser_error_occurred (parser
) && !error
)
14266 cp_parser_abort_tentative_parse (parser
);
14268 parser
->in_template_argument_list_p
= saved_italp
;
14271 case CPP_CLOSE_PAREN
:
14273 /* If we run into a non-nested `;', `}', or `]',
14274 then the code is invalid -- but the default
14275 argument is certainly over. */
14276 case CPP_SEMICOLON
:
14277 case CPP_CLOSE_BRACE
:
14278 case CPP_CLOSE_SQUARE
:
14281 /* Update DEPTH, if necessary. */
14282 else if (token
->type
== CPP_CLOSE_PAREN
14283 || token
->type
== CPP_CLOSE_BRACE
14284 || token
->type
== CPP_CLOSE_SQUARE
)
14288 case CPP_OPEN_PAREN
:
14289 case CPP_OPEN_SQUARE
:
14290 case CPP_OPEN_BRACE
:
14296 /* This might be the comparison operator, or it might
14297 start a template argument list. */
14298 ++maybe_template_id
;
14302 if (cxx_dialect
== cxx98
)
14304 /* Fall through for C++0x, which treats the `>>'
14305 operator like two `>' tokens in certain
14311 /* This might be an operator, or it might close a
14312 template argument list. But if a previous '<'
14313 started a template argument list, this will have
14314 closed it, so we can't be in one anymore. */
14315 maybe_template_id
-= 1 + (token
->type
== CPP_RSHIFT
);
14316 if (maybe_template_id
< 0)
14317 maybe_template_id
= 0;
14321 /* If we run out of tokens, issue an error message. */
14323 case CPP_PRAGMA_EOL
:
14324 error ("%Hfile ends in default argument", &token
->location
);
14330 /* In these cases, we should look for template-ids.
14331 For example, if the default argument is
14332 `X<int, double>()', we need to do name lookup to
14333 figure out whether or not `X' is a template; if
14334 so, the `,' does not end the default argument.
14336 That is not yet done. */
14343 /* If we've reached the end, stop. */
14347 /* Add the token to the token block. */
14348 token
= cp_lexer_consume_token (parser
->lexer
);
14351 /* Create a DEFAULT_ARG to represent the unparsed default
14353 default_argument
= make_node (DEFAULT_ARG
);
14354 DEFARG_TOKENS (default_argument
)
14355 = cp_token_cache_new (first_token
, token
);
14356 DEFARG_INSTANTIATIONS (default_argument
) = NULL
;
14358 /* Outside of a class definition, we can just parse the
14359 assignment-expression. */
14362 token
= cp_lexer_peek_token (parser
->lexer
);
14364 = cp_parser_default_argument (parser
, template_parm_p
);
14367 if (!parser
->default_arg_ok_p
)
14369 if (flag_permissive
)
14370 warning (0, "deprecated use of default argument for parameter of non-function");
14373 error ("%Hdefault arguments are only "
14374 "permitted for function parameters",
14376 default_argument
= NULL_TREE
;
14379 else if ((declarator
&& declarator
->parameter_pack_p
)
14380 || (decl_specifiers
.type
14381 && PACK_EXPANSION_P (decl_specifiers
.type
)))
14383 const char* kind
= template_parm_p
? "template " : "";
14385 /* Find the name of the parameter pack. */
14386 cp_declarator
*id_declarator
= declarator
;
14387 while (id_declarator
&& id_declarator
->kind
!= cdk_id
)
14388 id_declarator
= id_declarator
->declarator
;
14390 if (id_declarator
&& id_declarator
->kind
== cdk_id
)
14391 error ("%H%sparameter pack %qD cannot have a default argument",
14392 &declarator_token_start
->location
,
14393 kind
, id_declarator
->u
.id
.unqualified_name
);
14395 error ("%H%sparameter pack cannot have a default argument",
14396 &declarator_token_start
->location
, kind
);
14398 default_argument
= NULL_TREE
;
14402 default_argument
= NULL_TREE
;
14404 return make_parameter_declarator (&decl_specifiers
,
14409 /* Parse a default argument and return it.
14411 TEMPLATE_PARM_P is true if this is a default argument for a
14412 non-type template parameter. */
14414 cp_parser_default_argument (cp_parser
*parser
, bool template_parm_p
)
14416 tree default_argument
= NULL_TREE
;
14417 bool saved_greater_than_is_operator_p
;
14418 bool saved_local_variables_forbidden_p
;
14420 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
14422 saved_greater_than_is_operator_p
= parser
->greater_than_is_operator_p
;
14423 parser
->greater_than_is_operator_p
= !template_parm_p
;
14424 /* Local variable names (and the `this' keyword) may not
14425 appear in a default argument. */
14426 saved_local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
14427 parser
->local_variables_forbidden_p
= true;
14428 /* The default argument expression may cause implicitly
14429 defined member functions to be synthesized, which will
14430 result in garbage collection. We must treat this
14431 situation as if we were within the body of function so as
14432 to avoid collecting live data on the stack. */
14434 /* Parse the assignment-expression. */
14435 if (template_parm_p
)
14436 push_deferring_access_checks (dk_no_deferred
);
14438 = cp_parser_assignment_expression (parser
, /*cast_p=*/false, NULL
);
14439 if (template_parm_p
)
14440 pop_deferring_access_checks ();
14441 /* Restore saved state. */
14443 parser
->greater_than_is_operator_p
= saved_greater_than_is_operator_p
;
14444 parser
->local_variables_forbidden_p
= saved_local_variables_forbidden_p
;
14446 return default_argument
;
14449 /* Parse a function-body.
14452 compound_statement */
14455 cp_parser_function_body (cp_parser
*parser
)
14457 cp_parser_compound_statement (parser
, NULL
, false);
14460 /* Parse a ctor-initializer-opt followed by a function-body. Return
14461 true if a ctor-initializer was present. */
14464 cp_parser_ctor_initializer_opt_and_function_body (cp_parser
*parser
)
14467 bool ctor_initializer_p
;
14469 /* Begin the function body. */
14470 body
= begin_function_body ();
14471 /* Parse the optional ctor-initializer. */
14472 ctor_initializer_p
= cp_parser_ctor_initializer_opt (parser
);
14473 /* Parse the function-body. */
14474 cp_parser_function_body (parser
);
14475 /* Finish the function body. */
14476 finish_function_body (body
);
14478 return ctor_initializer_p
;
14481 /* Parse an initializer.
14484 = initializer-clause
14485 ( expression-list )
14487 Returns an expression representing the initializer. If no
14488 initializer is present, NULL_TREE is returned.
14490 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
14491 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
14492 set to TRUE if there is no initializer present. If there is an
14493 initializer, and it is not a constant-expression, *NON_CONSTANT_P
14494 is set to true; otherwise it is set to false. */
14497 cp_parser_initializer (cp_parser
* parser
, bool* is_direct_init
,
14498 bool* non_constant_p
)
14503 /* Peek at the next token. */
14504 token
= cp_lexer_peek_token (parser
->lexer
);
14506 /* Let our caller know whether or not this initializer was
14508 *is_direct_init
= (token
->type
!= CPP_EQ
);
14509 /* Assume that the initializer is constant. */
14510 *non_constant_p
= false;
14512 if (token
->type
== CPP_EQ
)
14514 /* Consume the `='. */
14515 cp_lexer_consume_token (parser
->lexer
);
14516 /* Parse the initializer-clause. */
14517 init
= cp_parser_initializer_clause (parser
, non_constant_p
);
14519 else if (token
->type
== CPP_OPEN_PAREN
)
14520 init
= cp_parser_parenthesized_expression_list (parser
, false,
14522 /*allow_expansion_p=*/true,
14524 else if (token
->type
== CPP_OPEN_BRACE
)
14526 maybe_warn_cpp0x ("extended initializer lists");
14527 init
= cp_parser_braced_list (parser
, non_constant_p
);
14528 CONSTRUCTOR_IS_DIRECT_INIT (init
) = 1;
14532 /* Anything else is an error. */
14533 cp_parser_error (parser
, "expected initializer");
14534 init
= error_mark_node
;
14540 /* Parse an initializer-clause.
14542 initializer-clause:
14543 assignment-expression
14546 Returns an expression representing the initializer.
14548 If the `assignment-expression' production is used the value
14549 returned is simply a representation for the expression.
14551 Otherwise, calls cp_parser_braced_list. */
14554 cp_parser_initializer_clause (cp_parser
* parser
, bool* non_constant_p
)
14558 /* Assume the expression is constant. */
14559 *non_constant_p
= false;
14561 /* If it is not a `{', then we are looking at an
14562 assignment-expression. */
14563 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
14566 = cp_parser_constant_expression (parser
,
14567 /*allow_non_constant_p=*/true,
14569 if (!*non_constant_p
)
14570 initializer
= fold_non_dependent_expr (initializer
);
14573 initializer
= cp_parser_braced_list (parser
, non_constant_p
);
14575 return initializer
;
14578 /* Parse a brace-enclosed initializer list.
14581 { initializer-list , [opt] }
14584 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
14585 the elements of the initializer-list (or NULL, if the last
14586 production is used). The TREE_TYPE for the CONSTRUCTOR will be
14587 NULL_TREE. There is no way to detect whether or not the optional
14588 trailing `,' was provided. NON_CONSTANT_P is as for
14589 cp_parser_initializer. */
14592 cp_parser_braced_list (cp_parser
* parser
, bool* non_constant_p
)
14596 /* Consume the `{' token. */
14597 cp_lexer_consume_token (parser
->lexer
);
14598 /* Create a CONSTRUCTOR to represent the braced-initializer. */
14599 initializer
= make_node (CONSTRUCTOR
);
14600 /* If it's not a `}', then there is a non-trivial initializer. */
14601 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_BRACE
))
14603 /* Parse the initializer list. */
14604 CONSTRUCTOR_ELTS (initializer
)
14605 = cp_parser_initializer_list (parser
, non_constant_p
);
14606 /* A trailing `,' token is allowed. */
14607 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
14608 cp_lexer_consume_token (parser
->lexer
);
14610 /* Now, there should be a trailing `}'. */
14611 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
14612 TREE_TYPE (initializer
) = init_list_type_node
;
14613 return initializer
;
14616 /* Parse an initializer-list.
14619 initializer-clause ... [opt]
14620 initializer-list , initializer-clause ... [opt]
14625 identifier : initializer-clause
14626 initializer-list, identifier : initializer-clause
14628 Returns a VEC of constructor_elt. The VALUE of each elt is an expression
14629 for the initializer. If the INDEX of the elt is non-NULL, it is the
14630 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
14631 as for cp_parser_initializer. */
14633 static VEC(constructor_elt
,gc
) *
14634 cp_parser_initializer_list (cp_parser
* parser
, bool* non_constant_p
)
14636 VEC(constructor_elt
,gc
) *v
= NULL
;
14638 /* Assume all of the expressions are constant. */
14639 *non_constant_p
= false;
14641 /* Parse the rest of the list. */
14647 bool clause_non_constant_p
;
14649 /* If the next token is an identifier and the following one is a
14650 colon, we are looking at the GNU designated-initializer
14652 if (cp_parser_allow_gnu_extensions_p (parser
)
14653 && cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
14654 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_COLON
)
14656 /* Warn the user that they are using an extension. */
14657 pedwarn (input_location
, OPT_pedantic
,
14658 "ISO C++ does not allow designated initializers");
14659 /* Consume the identifier. */
14660 identifier
= cp_lexer_consume_token (parser
->lexer
)->u
.value
;
14661 /* Consume the `:'. */
14662 cp_lexer_consume_token (parser
->lexer
);
14665 identifier
= NULL_TREE
;
14667 /* Parse the initializer. */
14668 initializer
= cp_parser_initializer_clause (parser
,
14669 &clause_non_constant_p
);
14670 /* If any clause is non-constant, so is the entire initializer. */
14671 if (clause_non_constant_p
)
14672 *non_constant_p
= true;
14674 /* If we have an ellipsis, this is an initializer pack
14676 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
14678 /* Consume the `...'. */
14679 cp_lexer_consume_token (parser
->lexer
);
14681 /* Turn the initializer into an initializer expansion. */
14682 initializer
= make_pack_expansion (initializer
);
14685 /* Add it to the vector. */
14686 CONSTRUCTOR_APPEND_ELT(v
, identifier
, initializer
);
14688 /* If the next token is not a comma, we have reached the end of
14690 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
14693 /* Peek at the next token. */
14694 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
14695 /* If the next token is a `}', then we're still done. An
14696 initializer-clause can have a trailing `,' after the
14697 initializer-list and before the closing `}'. */
14698 if (token
->type
== CPP_CLOSE_BRACE
)
14701 /* Consume the `,' token. */
14702 cp_lexer_consume_token (parser
->lexer
);
14708 /* Classes [gram.class] */
14710 /* Parse a class-name.
14716 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
14717 to indicate that names looked up in dependent types should be
14718 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
14719 keyword has been used to indicate that the name that appears next
14720 is a template. TAG_TYPE indicates the explicit tag given before
14721 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
14722 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
14723 is the class being defined in a class-head.
14725 Returns the TYPE_DECL representing the class. */
14728 cp_parser_class_name (cp_parser
*parser
,
14729 bool typename_keyword_p
,
14730 bool template_keyword_p
,
14731 enum tag_types tag_type
,
14732 bool check_dependency_p
,
14734 bool is_declaration
)
14740 tree identifier
= NULL_TREE
;
14742 /* All class-names start with an identifier. */
14743 token
= cp_lexer_peek_token (parser
->lexer
);
14744 if (token
->type
!= CPP_NAME
&& token
->type
!= CPP_TEMPLATE_ID
)
14746 cp_parser_error (parser
, "expected class-name");
14747 return error_mark_node
;
14750 /* PARSER->SCOPE can be cleared when parsing the template-arguments
14751 to a template-id, so we save it here. */
14752 scope
= parser
->scope
;
14753 if (scope
== error_mark_node
)
14754 return error_mark_node
;
14756 /* Any name names a type if we're following the `typename' keyword
14757 in a qualified name where the enclosing scope is type-dependent. */
14758 typename_p
= (typename_keyword_p
&& scope
&& TYPE_P (scope
)
14759 && dependent_type_p (scope
));
14760 /* Handle the common case (an identifier, but not a template-id)
14762 if (token
->type
== CPP_NAME
14763 && !cp_parser_nth_token_starts_template_argument_list_p (parser
, 2))
14765 cp_token
*identifier_token
;
14768 /* Look for the identifier. */
14769 identifier_token
= cp_lexer_peek_token (parser
->lexer
);
14770 ambiguous_p
= identifier_token
->ambiguous_p
;
14771 identifier
= cp_parser_identifier (parser
);
14772 /* If the next token isn't an identifier, we are certainly not
14773 looking at a class-name. */
14774 if (identifier
== error_mark_node
)
14775 decl
= error_mark_node
;
14776 /* If we know this is a type-name, there's no need to look it
14778 else if (typename_p
)
14782 tree ambiguous_decls
;
14783 /* If we already know that this lookup is ambiguous, then
14784 we've already issued an error message; there's no reason
14788 cp_parser_simulate_error (parser
);
14789 return error_mark_node
;
14791 /* If the next token is a `::', then the name must be a type
14794 [basic.lookup.qual]
14796 During the lookup for a name preceding the :: scope
14797 resolution operator, object, function, and enumerator
14798 names are ignored. */
14799 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
14800 tag_type
= typename_type
;
14801 /* Look up the name. */
14802 decl
= cp_parser_lookup_name (parser
, identifier
,
14804 /*is_template=*/false,
14805 /*is_namespace=*/false,
14806 check_dependency_p
,
14808 identifier_token
->location
);
14809 if (ambiguous_decls
)
14811 error ("%Hreference to %qD is ambiguous",
14812 &identifier_token
->location
, identifier
);
14813 print_candidates (ambiguous_decls
);
14814 if (cp_parser_parsing_tentatively (parser
))
14816 identifier_token
->ambiguous_p
= true;
14817 cp_parser_simulate_error (parser
);
14819 return error_mark_node
;
14825 /* Try a template-id. */
14826 decl
= cp_parser_template_id (parser
, template_keyword_p
,
14827 check_dependency_p
,
14829 if (decl
== error_mark_node
)
14830 return error_mark_node
;
14833 decl
= cp_parser_maybe_treat_template_as_class (decl
, class_head_p
);
14835 /* If this is a typename, create a TYPENAME_TYPE. */
14836 if (typename_p
&& decl
!= error_mark_node
)
14838 decl
= make_typename_type (scope
, decl
, typename_type
,
14839 /*complain=*/tf_error
);
14840 if (decl
!= error_mark_node
)
14841 decl
= TYPE_NAME (decl
);
14844 /* Check to see that it is really the name of a class. */
14845 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
14846 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
14847 && cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
14848 /* Situations like this:
14850 template <typename T> struct A {
14851 typename T::template X<int>::I i;
14854 are problematic. Is `T::template X<int>' a class-name? The
14855 standard does not seem to be definitive, but there is no other
14856 valid interpretation of the following `::'. Therefore, those
14857 names are considered class-names. */
14859 decl
= make_typename_type (scope
, decl
, tag_type
, tf_error
);
14860 if (decl
!= error_mark_node
)
14861 decl
= TYPE_NAME (decl
);
14863 else if (TREE_CODE (decl
) != TYPE_DECL
14864 || TREE_TYPE (decl
) == error_mark_node
14865 || !MAYBE_CLASS_TYPE_P (TREE_TYPE (decl
)))
14866 decl
= error_mark_node
;
14868 if (decl
== error_mark_node
)
14869 cp_parser_error (parser
, "expected class-name");
14870 else if (identifier
&& !parser
->scope
)
14871 maybe_note_name_used_in_class (identifier
, decl
);
14876 /* Parse a class-specifier.
14879 class-head { member-specification [opt] }
14881 Returns the TREE_TYPE representing the class. */
14884 cp_parser_class_specifier (cp_parser
* parser
)
14888 tree attributes
= NULL_TREE
;
14889 int has_trailing_semicolon
;
14890 bool nested_name_specifier_p
;
14891 unsigned saved_num_template_parameter_lists
;
14892 bool saved_in_function_body
;
14893 bool saved_in_unbraced_linkage_specification_p
;
14894 tree old_scope
= NULL_TREE
;
14895 tree scope
= NULL_TREE
;
14898 push_deferring_access_checks (dk_no_deferred
);
14900 /* Parse the class-head. */
14901 type
= cp_parser_class_head (parser
,
14902 &nested_name_specifier_p
,
14905 /* If the class-head was a semantic disaster, skip the entire body
14909 cp_parser_skip_to_end_of_block_or_statement (parser
);
14910 pop_deferring_access_checks ();
14911 return error_mark_node
;
14914 /* Look for the `{'. */
14915 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, "%<{%>"))
14917 pop_deferring_access_checks ();
14918 return error_mark_node
;
14921 /* Process the base classes. If they're invalid, skip the
14922 entire class body. */
14923 if (!xref_basetypes (type
, bases
))
14925 /* Consuming the closing brace yields better error messages
14927 if (cp_parser_skip_to_closing_brace (parser
))
14928 cp_lexer_consume_token (parser
->lexer
);
14929 pop_deferring_access_checks ();
14930 return error_mark_node
;
14933 /* Issue an error message if type-definitions are forbidden here. */
14934 cp_parser_check_type_definition (parser
);
14935 /* Remember that we are defining one more class. */
14936 ++parser
->num_classes_being_defined
;
14937 /* Inside the class, surrounding template-parameter-lists do not
14939 saved_num_template_parameter_lists
14940 = parser
->num_template_parameter_lists
;
14941 parser
->num_template_parameter_lists
= 0;
14942 /* We are not in a function body. */
14943 saved_in_function_body
= parser
->in_function_body
;
14944 parser
->in_function_body
= false;
14945 /* We are not immediately inside an extern "lang" block. */
14946 saved_in_unbraced_linkage_specification_p
14947 = parser
->in_unbraced_linkage_specification_p
;
14948 parser
->in_unbraced_linkage_specification_p
= false;
14950 /* Start the class. */
14951 if (nested_name_specifier_p
)
14953 scope
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (type
));
14954 old_scope
= push_inner_scope (scope
);
14956 type
= begin_class_definition (type
, attributes
);
14958 if (type
== error_mark_node
)
14959 /* If the type is erroneous, skip the entire body of the class. */
14960 cp_parser_skip_to_closing_brace (parser
);
14962 /* Parse the member-specification. */
14963 cp_parser_member_specification_opt (parser
);
14965 /* Look for the trailing `}'. */
14966 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
14967 /* We get better error messages by noticing a common problem: a
14968 missing trailing `;'. */
14969 token
= cp_lexer_peek_token (parser
->lexer
);
14970 has_trailing_semicolon
= (token
->type
== CPP_SEMICOLON
);
14971 /* Look for trailing attributes to apply to this class. */
14972 if (cp_parser_allow_gnu_extensions_p (parser
))
14973 attributes
= cp_parser_attributes_opt (parser
);
14974 if (type
!= error_mark_node
)
14975 type
= finish_struct (type
, attributes
);
14976 if (nested_name_specifier_p
)
14977 pop_inner_scope (old_scope
, scope
);
14978 /* If this class is not itself within the scope of another class,
14979 then we need to parse the bodies of all of the queued function
14980 definitions. Note that the queued functions defined in a class
14981 are not always processed immediately following the
14982 class-specifier for that class. Consider:
14985 struct B { void f() { sizeof (A); } };
14988 If `f' were processed before the processing of `A' were
14989 completed, there would be no way to compute the size of `A'.
14990 Note that the nesting we are interested in here is lexical --
14991 not the semantic nesting given by TYPE_CONTEXT. In particular,
14994 struct A { struct B; };
14995 struct A::B { void f() { } };
14997 there is no need to delay the parsing of `A::B::f'. */
14998 if (--parser
->num_classes_being_defined
== 0)
15002 tree class_type
= NULL_TREE
;
15003 tree pushed_scope
= NULL_TREE
;
15005 /* In a first pass, parse default arguments to the functions.
15006 Then, in a second pass, parse the bodies of the functions.
15007 This two-phased approach handles cases like:
15015 for (TREE_PURPOSE (parser
->unparsed_functions_queues
)
15016 = nreverse (TREE_PURPOSE (parser
->unparsed_functions_queues
));
15017 (queue_entry
= TREE_PURPOSE (parser
->unparsed_functions_queues
));
15018 TREE_PURPOSE (parser
->unparsed_functions_queues
)
15019 = TREE_CHAIN (TREE_PURPOSE (parser
->unparsed_functions_queues
)))
15021 fn
= TREE_VALUE (queue_entry
);
15022 /* If there are default arguments that have not yet been processed,
15023 take care of them now. */
15024 if (class_type
!= TREE_PURPOSE (queue_entry
))
15027 pop_scope (pushed_scope
);
15028 class_type
= TREE_PURPOSE (queue_entry
);
15029 pushed_scope
= push_scope (class_type
);
15031 /* Make sure that any template parameters are in scope. */
15032 maybe_begin_member_template_processing (fn
);
15033 /* Parse the default argument expressions. */
15034 cp_parser_late_parsing_default_args (parser
, fn
);
15035 /* Remove any template parameters from the symbol table. */
15036 maybe_end_member_template_processing ();
15039 pop_scope (pushed_scope
);
15040 /* Now parse the body of the functions. */
15041 for (TREE_VALUE (parser
->unparsed_functions_queues
)
15042 = nreverse (TREE_VALUE (parser
->unparsed_functions_queues
));
15043 (queue_entry
= TREE_VALUE (parser
->unparsed_functions_queues
));
15044 TREE_VALUE (parser
->unparsed_functions_queues
)
15045 = TREE_CHAIN (TREE_VALUE (parser
->unparsed_functions_queues
)))
15047 /* Figure out which function we need to process. */
15048 fn
= TREE_VALUE (queue_entry
);
15049 /* Parse the function. */
15050 cp_parser_late_parsing_for_member (parser
, fn
);
15054 /* Put back any saved access checks. */
15055 pop_deferring_access_checks ();
15057 /* Restore saved state. */
15058 parser
->in_function_body
= saved_in_function_body
;
15059 parser
->num_template_parameter_lists
15060 = saved_num_template_parameter_lists
;
15061 parser
->in_unbraced_linkage_specification_p
15062 = saved_in_unbraced_linkage_specification_p
;
15067 /* Parse a class-head.
15070 class-key identifier [opt] base-clause [opt]
15071 class-key nested-name-specifier identifier base-clause [opt]
15072 class-key nested-name-specifier [opt] template-id
15076 class-key attributes identifier [opt] base-clause [opt]
15077 class-key attributes nested-name-specifier identifier base-clause [opt]
15078 class-key attributes nested-name-specifier [opt] template-id
15081 Upon return BASES is initialized to the list of base classes (or
15082 NULL, if there are none) in the same form returned by
15083 cp_parser_base_clause.
15085 Returns the TYPE of the indicated class. Sets
15086 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
15087 involving a nested-name-specifier was used, and FALSE otherwise.
15089 Returns error_mark_node if this is not a class-head.
15091 Returns NULL_TREE if the class-head is syntactically valid, but
15092 semantically invalid in a way that means we should skip the entire
15093 body of the class. */
15096 cp_parser_class_head (cp_parser
* parser
,
15097 bool* nested_name_specifier_p
,
15098 tree
*attributes_p
,
15101 tree nested_name_specifier
;
15102 enum tag_types class_key
;
15103 tree id
= NULL_TREE
;
15104 tree type
= NULL_TREE
;
15106 bool template_id_p
= false;
15107 bool qualified_p
= false;
15108 bool invalid_nested_name_p
= false;
15109 bool invalid_explicit_specialization_p
= false;
15110 tree pushed_scope
= NULL_TREE
;
15111 unsigned num_templates
;
15112 cp_token
*type_start_token
= NULL
, *nested_name_specifier_token_start
= NULL
;
15113 /* Assume no nested-name-specifier will be present. */
15114 *nested_name_specifier_p
= false;
15115 /* Assume no template parameter lists will be used in defining the
15119 *bases
= NULL_TREE
;
15121 /* Look for the class-key. */
15122 class_key
= cp_parser_class_key (parser
);
15123 if (class_key
== none_type
)
15124 return error_mark_node
;
15126 /* Parse the attributes. */
15127 attributes
= cp_parser_attributes_opt (parser
);
15129 /* If the next token is `::', that is invalid -- but sometimes
15130 people do try to write:
15134 Handle this gracefully by accepting the extra qualifier, and then
15135 issuing an error about it later if this really is a
15136 class-head. If it turns out just to be an elaborated type
15137 specifier, remain silent. */
15138 if (cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false))
15139 qualified_p
= true;
15141 push_deferring_access_checks (dk_no_check
);
15143 /* Determine the name of the class. Begin by looking for an
15144 optional nested-name-specifier. */
15145 nested_name_specifier_token_start
= cp_lexer_peek_token (parser
->lexer
);
15146 nested_name_specifier
15147 = cp_parser_nested_name_specifier_opt (parser
,
15148 /*typename_keyword_p=*/false,
15149 /*check_dependency_p=*/false,
15151 /*is_declaration=*/false);
15152 /* If there was a nested-name-specifier, then there *must* be an
15154 if (nested_name_specifier
)
15156 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
15157 /* Although the grammar says `identifier', it really means
15158 `class-name' or `template-name'. You are only allowed to
15159 define a class that has already been declared with this
15162 The proposed resolution for Core Issue 180 says that wherever
15163 you see `class T::X' you should treat `X' as a type-name.
15165 It is OK to define an inaccessible class; for example:
15167 class A { class B; };
15170 We do not know if we will see a class-name, or a
15171 template-name. We look for a class-name first, in case the
15172 class-name is a template-id; if we looked for the
15173 template-name first we would stop after the template-name. */
15174 cp_parser_parse_tentatively (parser
);
15175 type
= cp_parser_class_name (parser
,
15176 /*typename_keyword_p=*/false,
15177 /*template_keyword_p=*/false,
15179 /*check_dependency_p=*/false,
15180 /*class_head_p=*/true,
15181 /*is_declaration=*/false);
15182 /* If that didn't work, ignore the nested-name-specifier. */
15183 if (!cp_parser_parse_definitely (parser
))
15185 invalid_nested_name_p
= true;
15186 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
15187 id
= cp_parser_identifier (parser
);
15188 if (id
== error_mark_node
)
15191 /* If we could not find a corresponding TYPE, treat this
15192 declaration like an unqualified declaration. */
15193 if (type
== error_mark_node
)
15194 nested_name_specifier
= NULL_TREE
;
15195 /* Otherwise, count the number of templates used in TYPE and its
15196 containing scopes. */
15201 for (scope
= TREE_TYPE (type
);
15202 scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
;
15203 scope
= (TYPE_P (scope
)
15204 ? TYPE_CONTEXT (scope
)
15205 : DECL_CONTEXT (scope
)))
15207 && CLASS_TYPE_P (scope
)
15208 && CLASSTYPE_TEMPLATE_INFO (scope
)
15209 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope
))
15210 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope
))
15214 /* Otherwise, the identifier is optional. */
15217 /* We don't know whether what comes next is a template-id,
15218 an identifier, or nothing at all. */
15219 cp_parser_parse_tentatively (parser
);
15220 /* Check for a template-id. */
15221 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
15222 id
= cp_parser_template_id (parser
,
15223 /*template_keyword_p=*/false,
15224 /*check_dependency_p=*/true,
15225 /*is_declaration=*/true);
15226 /* If that didn't work, it could still be an identifier. */
15227 if (!cp_parser_parse_definitely (parser
))
15229 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
15231 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
15232 id
= cp_parser_identifier (parser
);
15239 template_id_p
= true;
15244 pop_deferring_access_checks ();
15247 cp_parser_check_for_invalid_template_id (parser
, id
,
15248 type_start_token
->location
);
15250 /* If it's not a `:' or a `{' then we can't really be looking at a
15251 class-head, since a class-head only appears as part of a
15252 class-specifier. We have to detect this situation before calling
15253 xref_tag, since that has irreversible side-effects. */
15254 if (!cp_parser_next_token_starts_class_definition_p (parser
))
15256 cp_parser_error (parser
, "expected %<{%> or %<:%>");
15257 return error_mark_node
;
15260 /* At this point, we're going ahead with the class-specifier, even
15261 if some other problem occurs. */
15262 cp_parser_commit_to_tentative_parse (parser
);
15263 /* Issue the error about the overly-qualified name now. */
15266 cp_parser_error (parser
,
15267 "global qualification of class name is invalid");
15268 return error_mark_node
;
15270 else if (invalid_nested_name_p
)
15272 cp_parser_error (parser
,
15273 "qualified name does not name a class");
15274 return error_mark_node
;
15276 else if (nested_name_specifier
)
15280 /* Reject typedef-names in class heads. */
15281 if (!DECL_IMPLICIT_TYPEDEF_P (type
))
15283 error ("%Hinvalid class name in declaration of %qD",
15284 &type_start_token
->location
, type
);
15289 /* Figure out in what scope the declaration is being placed. */
15290 scope
= current_scope ();
15291 /* If that scope does not contain the scope in which the
15292 class was originally declared, the program is invalid. */
15293 if (scope
&& !is_ancestor (scope
, nested_name_specifier
))
15295 if (at_namespace_scope_p ())
15296 error ("%Hdeclaration of %qD in namespace %qD which does not "
15298 &type_start_token
->location
,
15299 type
, scope
, nested_name_specifier
);
15301 error ("%Hdeclaration of %qD in %qD which does not enclose %qD",
15302 &type_start_token
->location
,
15303 type
, scope
, nested_name_specifier
);
15309 A declarator-id shall not be qualified except for the
15310 definition of a ... nested class outside of its class
15311 ... [or] the definition or explicit instantiation of a
15312 class member of a namespace outside of its namespace. */
15313 if (scope
== nested_name_specifier
)
15315 permerror (input_location
, "%Hextra qualification not allowed",
15316 &nested_name_specifier_token_start
->location
);
15317 nested_name_specifier
= NULL_TREE
;
15321 /* An explicit-specialization must be preceded by "template <>". If
15322 it is not, try to recover gracefully. */
15323 if (at_namespace_scope_p ()
15324 && parser
->num_template_parameter_lists
== 0
15327 error ("%Han explicit specialization must be preceded by %<template <>%>",
15328 &type_start_token
->location
);
15329 invalid_explicit_specialization_p
= true;
15330 /* Take the same action that would have been taken by
15331 cp_parser_explicit_specialization. */
15332 ++parser
->num_template_parameter_lists
;
15333 begin_specialization ();
15335 /* There must be no "return" statements between this point and the
15336 end of this function; set "type "to the correct return value and
15337 use "goto done;" to return. */
15338 /* Make sure that the right number of template parameters were
15340 if (!cp_parser_check_template_parameters (parser
, num_templates
,
15341 type_start_token
->location
))
15343 /* If something went wrong, there is no point in even trying to
15344 process the class-definition. */
15349 /* Look up the type. */
15352 if (TREE_CODE (id
) == TEMPLATE_ID_EXPR
15353 && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id
, 0))
15354 || TREE_CODE (TREE_OPERAND (id
, 0)) == OVERLOAD
))
15356 error ("%Hfunction template %qD redeclared as a class template",
15357 &type_start_token
->location
, id
);
15358 type
= error_mark_node
;
15362 type
= TREE_TYPE (id
);
15363 type
= maybe_process_partial_specialization (type
);
15365 if (nested_name_specifier
)
15366 pushed_scope
= push_scope (nested_name_specifier
);
15368 else if (nested_name_specifier
)
15374 template <typename T> struct S { struct T };
15375 template <typename T> struct S<T>::T { };
15377 we will get a TYPENAME_TYPE when processing the definition of
15378 `S::T'. We need to resolve it to the actual type before we
15379 try to define it. */
15380 if (TREE_CODE (TREE_TYPE (type
)) == TYPENAME_TYPE
)
15382 class_type
= resolve_typename_type (TREE_TYPE (type
),
15383 /*only_current_p=*/false);
15384 if (TREE_CODE (class_type
) != TYPENAME_TYPE
)
15385 type
= TYPE_NAME (class_type
);
15388 cp_parser_error (parser
, "could not resolve typename type");
15389 type
= error_mark_node
;
15393 if (maybe_process_partial_specialization (TREE_TYPE (type
))
15394 == error_mark_node
)
15400 class_type
= current_class_type
;
15401 /* Enter the scope indicated by the nested-name-specifier. */
15402 pushed_scope
= push_scope (nested_name_specifier
);
15403 /* Get the canonical version of this type. */
15404 type
= TYPE_MAIN_DECL (TREE_TYPE (type
));
15405 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
15406 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type
)))
15408 type
= push_template_decl (type
);
15409 if (type
== error_mark_node
)
15416 type
= TREE_TYPE (type
);
15417 *nested_name_specifier_p
= true;
15419 else /* The name is not a nested name. */
15421 /* If the class was unnamed, create a dummy name. */
15423 id
= make_anon_name ();
15424 type
= xref_tag (class_key
, id
, /*tag_scope=*/ts_current
,
15425 parser
->num_template_parameter_lists
);
15428 /* Indicate whether this class was declared as a `class' or as a
15430 if (TREE_CODE (type
) == RECORD_TYPE
)
15431 CLASSTYPE_DECLARED_CLASS (type
) = (class_key
== class_type
);
15432 cp_parser_check_class_key (class_key
, type
);
15434 /* If this type was already complete, and we see another definition,
15435 that's an error. */
15436 if (type
!= error_mark_node
&& COMPLETE_TYPE_P (type
))
15438 error ("%Hredefinition of %q#T",
15439 &type_start_token
->location
, type
);
15440 error ("%Hprevious definition of %q+#T",
15441 &type_start_token
->location
, type
);
15445 else if (type
== error_mark_node
)
15448 /* We will have entered the scope containing the class; the names of
15449 base classes should be looked up in that context. For example:
15451 struct A { struct B {}; struct C; };
15452 struct A::C : B {};
15456 /* Get the list of base-classes, if there is one. */
15457 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
15458 *bases
= cp_parser_base_clause (parser
);
15461 /* Leave the scope given by the nested-name-specifier. We will
15462 enter the class scope itself while processing the members. */
15464 pop_scope (pushed_scope
);
15466 if (invalid_explicit_specialization_p
)
15468 end_specialization ();
15469 --parser
->num_template_parameter_lists
;
15471 *attributes_p
= attributes
;
15475 /* Parse a class-key.
15482 Returns the kind of class-key specified, or none_type to indicate
15485 static enum tag_types
15486 cp_parser_class_key (cp_parser
* parser
)
15489 enum tag_types tag_type
;
15491 /* Look for the class-key. */
15492 token
= cp_parser_require (parser
, CPP_KEYWORD
, "class-key");
15496 /* Check to see if the TOKEN is a class-key. */
15497 tag_type
= cp_parser_token_is_class_key (token
);
15499 cp_parser_error (parser
, "expected class-key");
15503 /* Parse an (optional) member-specification.
15505 member-specification:
15506 member-declaration member-specification [opt]
15507 access-specifier : member-specification [opt] */
15510 cp_parser_member_specification_opt (cp_parser
* parser
)
15517 /* Peek at the next token. */
15518 token
= cp_lexer_peek_token (parser
->lexer
);
15519 /* If it's a `}', or EOF then we've seen all the members. */
15520 if (token
->type
== CPP_CLOSE_BRACE
15521 || token
->type
== CPP_EOF
15522 || token
->type
== CPP_PRAGMA_EOL
)
15525 /* See if this token is a keyword. */
15526 keyword
= token
->keyword
;
15530 case RID_PROTECTED
:
15532 /* Consume the access-specifier. */
15533 cp_lexer_consume_token (parser
->lexer
);
15534 /* Remember which access-specifier is active. */
15535 current_access_specifier
= token
->u
.value
;
15536 /* Look for the `:'. */
15537 cp_parser_require (parser
, CPP_COLON
, "%<:%>");
15541 /* Accept #pragmas at class scope. */
15542 if (token
->type
== CPP_PRAGMA
)
15544 cp_parser_pragma (parser
, pragma_external
);
15548 /* Otherwise, the next construction must be a
15549 member-declaration. */
15550 cp_parser_member_declaration (parser
);
15555 /* Parse a member-declaration.
15557 member-declaration:
15558 decl-specifier-seq [opt] member-declarator-list [opt] ;
15559 function-definition ; [opt]
15560 :: [opt] nested-name-specifier template [opt] unqualified-id ;
15562 template-declaration
15564 member-declarator-list:
15566 member-declarator-list , member-declarator
15569 declarator pure-specifier [opt]
15570 declarator constant-initializer [opt]
15571 identifier [opt] : constant-expression
15575 member-declaration:
15576 __extension__ member-declaration
15579 declarator attributes [opt] pure-specifier [opt]
15580 declarator attributes [opt] constant-initializer [opt]
15581 identifier [opt] attributes [opt] : constant-expression
15585 member-declaration:
15586 static_assert-declaration */
15589 cp_parser_member_declaration (cp_parser
* parser
)
15591 cp_decl_specifier_seq decl_specifiers
;
15592 tree prefix_attributes
;
15594 int declares_class_or_enum
;
15596 cp_token
*token
= NULL
;
15597 cp_token
*decl_spec_token_start
= NULL
;
15598 cp_token
*initializer_token_start
= NULL
;
15599 int saved_pedantic
;
15601 /* Check for the `__extension__' keyword. */
15602 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
15605 cp_parser_member_declaration (parser
);
15606 /* Restore the old value of the PEDANTIC flag. */
15607 pedantic
= saved_pedantic
;
15612 /* Check for a template-declaration. */
15613 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
15615 /* An explicit specialization here is an error condition, and we
15616 expect the specialization handler to detect and report this. */
15617 if (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_LESS
15618 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_GREATER
)
15619 cp_parser_explicit_specialization (parser
);
15621 cp_parser_template_declaration (parser
, /*member_p=*/true);
15626 /* Check for a using-declaration. */
15627 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_USING
))
15629 /* Parse the using-declaration. */
15630 cp_parser_using_declaration (parser
,
15631 /*access_declaration_p=*/false);
15635 /* Check for @defs. */
15636 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_DEFS
))
15639 tree ivar_chains
= cp_parser_objc_defs_expression (parser
);
15640 ivar
= ivar_chains
;
15644 ivar
= TREE_CHAIN (member
);
15645 TREE_CHAIN (member
) = NULL_TREE
;
15646 finish_member_declaration (member
);
15651 /* If the next token is `static_assert' we have a static assertion. */
15652 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC_ASSERT
))
15654 cp_parser_static_assert (parser
, /*member_p=*/true);
15658 if (cp_parser_using_declaration (parser
, /*access_declaration=*/true))
15661 /* Parse the decl-specifier-seq. */
15662 decl_spec_token_start
= cp_lexer_peek_token (parser
->lexer
);
15663 cp_parser_decl_specifier_seq (parser
,
15664 CP_PARSER_FLAGS_OPTIONAL
,
15666 &declares_class_or_enum
);
15667 prefix_attributes
= decl_specifiers
.attributes
;
15668 decl_specifiers
.attributes
= NULL_TREE
;
15669 /* Check for an invalid type-name. */
15670 if (!decl_specifiers
.type
15671 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
15673 /* If there is no declarator, then the decl-specifier-seq should
15675 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
15677 /* If there was no decl-specifier-seq, and the next token is a
15678 `;', then we have something like:
15684 Each member-declaration shall declare at least one member
15685 name of the class. */
15686 if (!decl_specifiers
.any_specifiers_p
)
15688 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
15689 if (!in_system_header_at (token
->location
))
15690 pedwarn (token
->location
, OPT_pedantic
, "extra %<;%>");
15696 /* See if this declaration is a friend. */
15697 friend_p
= cp_parser_friend_p (&decl_specifiers
);
15698 /* If there were decl-specifiers, check to see if there was
15699 a class-declaration. */
15700 type
= check_tag_decl (&decl_specifiers
);
15701 /* Nested classes have already been added to the class, but
15702 a `friend' needs to be explicitly registered. */
15705 /* If the `friend' keyword was present, the friend must
15706 be introduced with a class-key. */
15707 if (!declares_class_or_enum
)
15708 error ("%Ha class-key must be used when declaring a friend",
15709 &decl_spec_token_start
->location
);
15712 template <typename T> struct A {
15713 friend struct A<T>::B;
15716 A<T>::B will be represented by a TYPENAME_TYPE, and
15717 therefore not recognized by check_tag_decl. */
15719 && decl_specifiers
.type
15720 && TYPE_P (decl_specifiers
.type
))
15721 type
= decl_specifiers
.type
;
15722 if (!type
|| !TYPE_P (type
))
15723 error ("%Hfriend declaration does not name a class or "
15724 "function", &decl_spec_token_start
->location
);
15726 make_friend_class (current_class_type
, type
,
15727 /*complain=*/true);
15729 /* If there is no TYPE, an error message will already have
15731 else if (!type
|| type
== error_mark_node
)
15733 /* An anonymous aggregate has to be handled specially; such
15734 a declaration really declares a data member (with a
15735 particular type), as opposed to a nested class. */
15736 else if (ANON_AGGR_TYPE_P (type
))
15738 /* Remove constructors and such from TYPE, now that we
15739 know it is an anonymous aggregate. */
15740 fixup_anonymous_aggr (type
);
15741 /* And make the corresponding data member. */
15742 decl
= build_decl (FIELD_DECL
, NULL_TREE
, type
);
15743 /* Add it to the class. */
15744 finish_member_declaration (decl
);
15747 cp_parser_check_access_in_redeclaration
15749 decl_spec_token_start
->location
);
15754 /* See if these declarations will be friends. */
15755 friend_p
= cp_parser_friend_p (&decl_specifiers
);
15757 /* Keep going until we hit the `;' at the end of the
15759 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
15761 tree attributes
= NULL_TREE
;
15762 tree first_attribute
;
15764 /* Peek at the next token. */
15765 token
= cp_lexer_peek_token (parser
->lexer
);
15767 /* Check for a bitfield declaration. */
15768 if (token
->type
== CPP_COLON
15769 || (token
->type
== CPP_NAME
15770 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
15776 /* Get the name of the bitfield. Note that we cannot just
15777 check TOKEN here because it may have been invalidated by
15778 the call to cp_lexer_peek_nth_token above. */
15779 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_COLON
)
15780 identifier
= cp_parser_identifier (parser
);
15782 identifier
= NULL_TREE
;
15784 /* Consume the `:' token. */
15785 cp_lexer_consume_token (parser
->lexer
);
15786 /* Get the width of the bitfield. */
15788 = cp_parser_constant_expression (parser
,
15789 /*allow_non_constant=*/false,
15792 /* Look for attributes that apply to the bitfield. */
15793 attributes
= cp_parser_attributes_opt (parser
);
15794 /* Remember which attributes are prefix attributes and
15796 first_attribute
= attributes
;
15797 /* Combine the attributes. */
15798 attributes
= chainon (prefix_attributes
, attributes
);
15800 /* Create the bitfield declaration. */
15801 decl
= grokbitfield (identifier
15802 ? make_id_declarator (NULL_TREE
,
15812 cp_declarator
*declarator
;
15814 tree asm_specification
;
15815 int ctor_dtor_or_conv_p
;
15817 /* Parse the declarator. */
15819 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
15820 &ctor_dtor_or_conv_p
,
15821 /*parenthesized_p=*/NULL
,
15822 /*member_p=*/true);
15824 /* If something went wrong parsing the declarator, make sure
15825 that we at least consume some tokens. */
15826 if (declarator
== cp_error_declarator
)
15828 /* Skip to the end of the statement. */
15829 cp_parser_skip_to_end_of_statement (parser
);
15830 /* If the next token is not a semicolon, that is
15831 probably because we just skipped over the body of
15832 a function. So, we consume a semicolon if
15833 present, but do not issue an error message if it
15835 if (cp_lexer_next_token_is (parser
->lexer
,
15837 cp_lexer_consume_token (parser
->lexer
);
15841 if (declares_class_or_enum
& 2)
15842 cp_parser_check_for_definition_in_return_type
15843 (declarator
, decl_specifiers
.type
,
15844 decl_specifiers
.type_location
);
15846 /* Look for an asm-specification. */
15847 asm_specification
= cp_parser_asm_specification_opt (parser
);
15848 /* Look for attributes that apply to the declaration. */
15849 attributes
= cp_parser_attributes_opt (parser
);
15850 /* Remember which attributes are prefix attributes and
15852 first_attribute
= attributes
;
15853 /* Combine the attributes. */
15854 attributes
= chainon (prefix_attributes
, attributes
);
15856 /* If it's an `=', then we have a constant-initializer or a
15857 pure-specifier. It is not correct to parse the
15858 initializer before registering the member declaration
15859 since the member declaration should be in scope while
15860 its initializer is processed. However, the rest of the
15861 front end does not yet provide an interface that allows
15862 us to handle this correctly. */
15863 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
15867 A pure-specifier shall be used only in the declaration of
15868 a virtual function.
15870 A member-declarator can contain a constant-initializer
15871 only if it declares a static member of integral or
15874 Therefore, if the DECLARATOR is for a function, we look
15875 for a pure-specifier; otherwise, we look for a
15876 constant-initializer. When we call `grokfield', it will
15877 perform more stringent semantics checks. */
15878 initializer_token_start
= cp_lexer_peek_token (parser
->lexer
);
15879 if (function_declarator_p (declarator
))
15880 initializer
= cp_parser_pure_specifier (parser
);
15882 /* Parse the initializer. */
15883 initializer
= cp_parser_constant_initializer (parser
);
15885 /* Otherwise, there is no initializer. */
15887 initializer
= NULL_TREE
;
15889 /* See if we are probably looking at a function
15890 definition. We are certainly not looking at a
15891 member-declarator. Calling `grokfield' has
15892 side-effects, so we must not do it unless we are sure
15893 that we are looking at a member-declarator. */
15894 if (cp_parser_token_starts_function_definition_p
15895 (cp_lexer_peek_token (parser
->lexer
)))
15897 /* The grammar does not allow a pure-specifier to be
15898 used when a member function is defined. (It is
15899 possible that this fact is an oversight in the
15900 standard, since a pure function may be defined
15901 outside of the class-specifier. */
15903 error ("%Hpure-specifier on function-definition",
15904 &initializer_token_start
->location
);
15905 decl
= cp_parser_save_member_function_body (parser
,
15909 /* If the member was not a friend, declare it here. */
15911 finish_member_declaration (decl
);
15912 /* Peek at the next token. */
15913 token
= cp_lexer_peek_token (parser
->lexer
);
15914 /* If the next token is a semicolon, consume it. */
15915 if (token
->type
== CPP_SEMICOLON
)
15916 cp_lexer_consume_token (parser
->lexer
);
15920 if (declarator
->kind
== cdk_function
)
15921 declarator
->id_loc
= token
->location
;
15922 /* Create the declaration. */
15923 decl
= grokfield (declarator
, &decl_specifiers
,
15924 initializer
, /*init_const_expr_p=*/true,
15929 /* Reset PREFIX_ATTRIBUTES. */
15930 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
15931 attributes
= TREE_CHAIN (attributes
);
15933 TREE_CHAIN (attributes
) = NULL_TREE
;
15935 /* If there is any qualification still in effect, clear it
15936 now; we will be starting fresh with the next declarator. */
15937 parser
->scope
= NULL_TREE
;
15938 parser
->qualifying_scope
= NULL_TREE
;
15939 parser
->object_scope
= NULL_TREE
;
15940 /* If it's a `,', then there are more declarators. */
15941 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
15942 cp_lexer_consume_token (parser
->lexer
);
15943 /* If the next token isn't a `;', then we have a parse error. */
15944 else if (cp_lexer_next_token_is_not (parser
->lexer
,
15947 cp_parser_error (parser
, "expected %<;%>");
15948 /* Skip tokens until we find a `;'. */
15949 cp_parser_skip_to_end_of_statement (parser
);
15956 /* Add DECL to the list of members. */
15958 finish_member_declaration (decl
);
15960 if (TREE_CODE (decl
) == FUNCTION_DECL
)
15961 cp_parser_save_default_args (parser
, decl
);
15966 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
15969 /* Parse a pure-specifier.
15974 Returns INTEGER_ZERO_NODE if a pure specifier is found.
15975 Otherwise, ERROR_MARK_NODE is returned. */
15978 cp_parser_pure_specifier (cp_parser
* parser
)
15982 /* Look for the `=' token. */
15983 if (!cp_parser_require (parser
, CPP_EQ
, "%<=%>"))
15984 return error_mark_node
;
15985 /* Look for the `0' token. */
15986 token
= cp_lexer_consume_token (parser
->lexer
);
15988 /* Accept = default or = delete in c++0x mode. */
15989 if (token
->keyword
== RID_DEFAULT
15990 || token
->keyword
== RID_DELETE
)
15992 maybe_warn_cpp0x ("defaulted and deleted functions");
15993 return token
->u
.value
;
15996 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
15997 if (token
->type
!= CPP_NUMBER
|| !(token
->flags
& PURE_ZERO
))
15999 cp_parser_error (parser
,
16000 "invalid pure specifier (only %<= 0%> is allowed)");
16001 cp_parser_skip_to_end_of_statement (parser
);
16002 return error_mark_node
;
16004 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
16006 error ("%Htemplates may not be %<virtual%>", &token
->location
);
16007 return error_mark_node
;
16010 return integer_zero_node
;
16013 /* Parse a constant-initializer.
16015 constant-initializer:
16016 = constant-expression
16018 Returns a representation of the constant-expression. */
16021 cp_parser_constant_initializer (cp_parser
* parser
)
16023 /* Look for the `=' token. */
16024 if (!cp_parser_require (parser
, CPP_EQ
, "%<=%>"))
16025 return error_mark_node
;
16027 /* It is invalid to write:
16029 struct S { static const int i = { 7 }; };
16032 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
16034 cp_parser_error (parser
,
16035 "a brace-enclosed initializer is not allowed here");
16036 /* Consume the opening brace. */
16037 cp_lexer_consume_token (parser
->lexer
);
16038 /* Skip the initializer. */
16039 cp_parser_skip_to_closing_brace (parser
);
16040 /* Look for the trailing `}'. */
16041 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
16043 return error_mark_node
;
16046 return cp_parser_constant_expression (parser
,
16047 /*allow_non_constant=*/false,
16051 /* Derived classes [gram.class.derived] */
16053 /* Parse a base-clause.
16056 : base-specifier-list
16058 base-specifier-list:
16059 base-specifier ... [opt]
16060 base-specifier-list , base-specifier ... [opt]
16062 Returns a TREE_LIST representing the base-classes, in the order in
16063 which they were declared. The representation of each node is as
16064 described by cp_parser_base_specifier.
16066 In the case that no bases are specified, this function will return
16067 NULL_TREE, not ERROR_MARK_NODE. */
16070 cp_parser_base_clause (cp_parser
* parser
)
16072 tree bases
= NULL_TREE
;
16074 /* Look for the `:' that begins the list. */
16075 cp_parser_require (parser
, CPP_COLON
, "%<:%>");
16077 /* Scan the base-specifier-list. */
16082 bool pack_expansion_p
= false;
16084 /* Look for the base-specifier. */
16085 base
= cp_parser_base_specifier (parser
);
16086 /* Look for the (optional) ellipsis. */
16087 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
16089 /* Consume the `...'. */
16090 cp_lexer_consume_token (parser
->lexer
);
16092 pack_expansion_p
= true;
16095 /* Add BASE to the front of the list. */
16096 if (base
!= error_mark_node
)
16098 if (pack_expansion_p
)
16099 /* Make this a pack expansion type. */
16100 TREE_VALUE (base
) = make_pack_expansion (TREE_VALUE (base
));
16103 if (!check_for_bare_parameter_packs (TREE_VALUE (base
)))
16105 TREE_CHAIN (base
) = bases
;
16109 /* Peek at the next token. */
16110 token
= cp_lexer_peek_token (parser
->lexer
);
16111 /* If it's not a comma, then the list is complete. */
16112 if (token
->type
!= CPP_COMMA
)
16114 /* Consume the `,'. */
16115 cp_lexer_consume_token (parser
->lexer
);
16118 /* PARSER->SCOPE may still be non-NULL at this point, if the last
16119 base class had a qualified name. However, the next name that
16120 appears is certainly not qualified. */
16121 parser
->scope
= NULL_TREE
;
16122 parser
->qualifying_scope
= NULL_TREE
;
16123 parser
->object_scope
= NULL_TREE
;
16125 return nreverse (bases
);
16128 /* Parse a base-specifier.
16131 :: [opt] nested-name-specifier [opt] class-name
16132 virtual access-specifier [opt] :: [opt] nested-name-specifier
16134 access-specifier virtual [opt] :: [opt] nested-name-specifier
16137 Returns a TREE_LIST. The TREE_PURPOSE will be one of
16138 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
16139 indicate the specifiers provided. The TREE_VALUE will be a TYPE
16140 (or the ERROR_MARK_NODE) indicating the type that was specified. */
16143 cp_parser_base_specifier (cp_parser
* parser
)
16147 bool virtual_p
= false;
16148 bool duplicate_virtual_error_issued_p
= false;
16149 bool duplicate_access_error_issued_p
= false;
16150 bool class_scope_p
, template_p
;
16151 tree access
= access_default_node
;
16154 /* Process the optional `virtual' and `access-specifier'. */
16157 /* Peek at the next token. */
16158 token
= cp_lexer_peek_token (parser
->lexer
);
16159 /* Process `virtual'. */
16160 switch (token
->keyword
)
16163 /* If `virtual' appears more than once, issue an error. */
16164 if (virtual_p
&& !duplicate_virtual_error_issued_p
)
16166 cp_parser_error (parser
,
16167 "%<virtual%> specified more than once in base-specified");
16168 duplicate_virtual_error_issued_p
= true;
16173 /* Consume the `virtual' token. */
16174 cp_lexer_consume_token (parser
->lexer
);
16179 case RID_PROTECTED
:
16181 /* If more than one access specifier appears, issue an
16183 if (access
!= access_default_node
16184 && !duplicate_access_error_issued_p
)
16186 cp_parser_error (parser
,
16187 "more than one access specifier in base-specified");
16188 duplicate_access_error_issued_p
= true;
16191 access
= ridpointers
[(int) token
->keyword
];
16193 /* Consume the access-specifier. */
16194 cp_lexer_consume_token (parser
->lexer
);
16203 /* It is not uncommon to see programs mechanically, erroneously, use
16204 the 'typename' keyword to denote (dependent) qualified types
16205 as base classes. */
16206 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TYPENAME
))
16208 token
= cp_lexer_peek_token (parser
->lexer
);
16209 if (!processing_template_decl
)
16210 error ("%Hkeyword %<typename%> not allowed outside of templates",
16213 error ("%Hkeyword %<typename%> not allowed in this context "
16214 "(the base class is implicitly a type)",
16216 cp_lexer_consume_token (parser
->lexer
);
16219 /* Look for the optional `::' operator. */
16220 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false);
16221 /* Look for the nested-name-specifier. The simplest way to
16226 The keyword `typename' is not permitted in a base-specifier or
16227 mem-initializer; in these contexts a qualified name that
16228 depends on a template-parameter is implicitly assumed to be a
16231 is to pretend that we have seen the `typename' keyword at this
16233 cp_parser_nested_name_specifier_opt (parser
,
16234 /*typename_keyword_p=*/true,
16235 /*check_dependency_p=*/true,
16237 /*is_declaration=*/true);
16238 /* If the base class is given by a qualified name, assume that names
16239 we see are type names or templates, as appropriate. */
16240 class_scope_p
= (parser
->scope
&& TYPE_P (parser
->scope
));
16241 template_p
= class_scope_p
&& cp_parser_optional_template_keyword (parser
);
16243 /* Finally, look for the class-name. */
16244 type
= cp_parser_class_name (parser
,
16248 /*check_dependency_p=*/true,
16249 /*class_head_p=*/false,
16250 /*is_declaration=*/true);
16252 if (type
== error_mark_node
)
16253 return error_mark_node
;
16255 return finish_base_specifier (TREE_TYPE (type
), access
, virtual_p
);
16258 /* Exception handling [gram.exception] */
16260 /* Parse an (optional) exception-specification.
16262 exception-specification:
16263 throw ( type-id-list [opt] )
16265 Returns a TREE_LIST representing the exception-specification. The
16266 TREE_VALUE of each node is a type. */
16269 cp_parser_exception_specification_opt (cp_parser
* parser
)
16274 /* Peek at the next token. */
16275 token
= cp_lexer_peek_token (parser
->lexer
);
16276 /* If it's not `throw', then there's no exception-specification. */
16277 if (!cp_parser_is_keyword (token
, RID_THROW
))
16280 /* Consume the `throw'. */
16281 cp_lexer_consume_token (parser
->lexer
);
16283 /* Look for the `('. */
16284 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
16286 /* Peek at the next token. */
16287 token
= cp_lexer_peek_token (parser
->lexer
);
16288 /* If it's not a `)', then there is a type-id-list. */
16289 if (token
->type
!= CPP_CLOSE_PAREN
)
16291 const char *saved_message
;
16293 /* Types may not be defined in an exception-specification. */
16294 saved_message
= parser
->type_definition_forbidden_message
;
16295 parser
->type_definition_forbidden_message
16296 = "types may not be defined in an exception-specification";
16297 /* Parse the type-id-list. */
16298 type_id_list
= cp_parser_type_id_list (parser
);
16299 /* Restore the saved message. */
16300 parser
->type_definition_forbidden_message
= saved_message
;
16303 type_id_list
= empty_except_spec
;
16305 /* Look for the `)'. */
16306 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
16308 return type_id_list
;
16311 /* Parse an (optional) type-id-list.
16315 type-id-list , type-id ... [opt]
16317 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
16318 in the order that the types were presented. */
16321 cp_parser_type_id_list (cp_parser
* parser
)
16323 tree types
= NULL_TREE
;
16330 /* Get the next type-id. */
16331 type
= cp_parser_type_id (parser
);
16332 /* Parse the optional ellipsis. */
16333 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
16335 /* Consume the `...'. */
16336 cp_lexer_consume_token (parser
->lexer
);
16338 /* Turn the type into a pack expansion expression. */
16339 type
= make_pack_expansion (type
);
16341 /* Add it to the list. */
16342 types
= add_exception_specifier (types
, type
, /*complain=*/1);
16343 /* Peek at the next token. */
16344 token
= cp_lexer_peek_token (parser
->lexer
);
16345 /* If it is not a `,', we are done. */
16346 if (token
->type
!= CPP_COMMA
)
16348 /* Consume the `,'. */
16349 cp_lexer_consume_token (parser
->lexer
);
16352 return nreverse (types
);
16355 /* Parse a try-block.
16358 try compound-statement handler-seq */
16361 cp_parser_try_block (cp_parser
* parser
)
16365 cp_parser_require_keyword (parser
, RID_TRY
, "%<try%>");
16366 try_block
= begin_try_block ();
16367 cp_parser_compound_statement (parser
, NULL
, true);
16368 finish_try_block (try_block
);
16369 cp_parser_handler_seq (parser
);
16370 finish_handler_sequence (try_block
);
16375 /* Parse a function-try-block.
16377 function-try-block:
16378 try ctor-initializer [opt] function-body handler-seq */
16381 cp_parser_function_try_block (cp_parser
* parser
)
16383 tree compound_stmt
;
16385 bool ctor_initializer_p
;
16387 /* Look for the `try' keyword. */
16388 if (!cp_parser_require_keyword (parser
, RID_TRY
, "%<try%>"))
16390 /* Let the rest of the front end know where we are. */
16391 try_block
= begin_function_try_block (&compound_stmt
);
16392 /* Parse the function-body. */
16394 = cp_parser_ctor_initializer_opt_and_function_body (parser
);
16395 /* We're done with the `try' part. */
16396 finish_function_try_block (try_block
);
16397 /* Parse the handlers. */
16398 cp_parser_handler_seq (parser
);
16399 /* We're done with the handlers. */
16400 finish_function_handler_sequence (try_block
, compound_stmt
);
16402 return ctor_initializer_p
;
16405 /* Parse a handler-seq.
16408 handler handler-seq [opt] */
16411 cp_parser_handler_seq (cp_parser
* parser
)
16417 /* Parse the handler. */
16418 cp_parser_handler (parser
);
16419 /* Peek at the next token. */
16420 token
= cp_lexer_peek_token (parser
->lexer
);
16421 /* If it's not `catch' then there are no more handlers. */
16422 if (!cp_parser_is_keyword (token
, RID_CATCH
))
16427 /* Parse a handler.
16430 catch ( exception-declaration ) compound-statement */
16433 cp_parser_handler (cp_parser
* parser
)
16438 cp_parser_require_keyword (parser
, RID_CATCH
, "%<catch%>");
16439 handler
= begin_handler ();
16440 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
16441 declaration
= cp_parser_exception_declaration (parser
);
16442 finish_handler_parms (declaration
, handler
);
16443 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
16444 cp_parser_compound_statement (parser
, NULL
, false);
16445 finish_handler (handler
);
16448 /* Parse an exception-declaration.
16450 exception-declaration:
16451 type-specifier-seq declarator
16452 type-specifier-seq abstract-declarator
16456 Returns a VAR_DECL for the declaration, or NULL_TREE if the
16457 ellipsis variant is used. */
16460 cp_parser_exception_declaration (cp_parser
* parser
)
16462 cp_decl_specifier_seq type_specifiers
;
16463 cp_declarator
*declarator
;
16464 const char *saved_message
;
16466 /* If it's an ellipsis, it's easy to handle. */
16467 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
16469 /* Consume the `...' token. */
16470 cp_lexer_consume_token (parser
->lexer
);
16474 /* Types may not be defined in exception-declarations. */
16475 saved_message
= parser
->type_definition_forbidden_message
;
16476 parser
->type_definition_forbidden_message
16477 = "types may not be defined in exception-declarations";
16479 /* Parse the type-specifier-seq. */
16480 cp_parser_type_specifier_seq (parser
, /*is_condition=*/false,
16482 /* If it's a `)', then there is no declarator. */
16483 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
16486 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_EITHER
,
16487 /*ctor_dtor_or_conv_p=*/NULL
,
16488 /*parenthesized_p=*/NULL
,
16489 /*member_p=*/false);
16491 /* Restore the saved message. */
16492 parser
->type_definition_forbidden_message
= saved_message
;
16494 if (!type_specifiers
.any_specifiers_p
)
16495 return error_mark_node
;
16497 return grokdeclarator (declarator
, &type_specifiers
, CATCHPARM
, 1, NULL
);
16500 /* Parse a throw-expression.
16503 throw assignment-expression [opt]
16505 Returns a THROW_EXPR representing the throw-expression. */
16508 cp_parser_throw_expression (cp_parser
* parser
)
16513 cp_parser_require_keyword (parser
, RID_THROW
, "%<throw%>");
16514 token
= cp_lexer_peek_token (parser
->lexer
);
16515 /* Figure out whether or not there is an assignment-expression
16516 following the "throw" keyword. */
16517 if (token
->type
== CPP_COMMA
16518 || token
->type
== CPP_SEMICOLON
16519 || token
->type
== CPP_CLOSE_PAREN
16520 || token
->type
== CPP_CLOSE_SQUARE
16521 || token
->type
== CPP_CLOSE_BRACE
16522 || token
->type
== CPP_COLON
)
16523 expression
= NULL_TREE
;
16525 expression
= cp_parser_assignment_expression (parser
,
16526 /*cast_p=*/false, NULL
);
16528 return build_throw (expression
);
16531 /* GNU Extensions */
16533 /* Parse an (optional) asm-specification.
16536 asm ( string-literal )
16538 If the asm-specification is present, returns a STRING_CST
16539 corresponding to the string-literal. Otherwise, returns
16543 cp_parser_asm_specification_opt (cp_parser
* parser
)
16546 tree asm_specification
;
16548 /* Peek at the next token. */
16549 token
= cp_lexer_peek_token (parser
->lexer
);
16550 /* If the next token isn't the `asm' keyword, then there's no
16551 asm-specification. */
16552 if (!cp_parser_is_keyword (token
, RID_ASM
))
16555 /* Consume the `asm' token. */
16556 cp_lexer_consume_token (parser
->lexer
);
16557 /* Look for the `('. */
16558 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
16560 /* Look for the string-literal. */
16561 asm_specification
= cp_parser_string_literal (parser
, false, false);
16563 /* Look for the `)'. */
16564 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
16566 return asm_specification
;
16569 /* Parse an asm-operand-list.
16573 asm-operand-list , asm-operand
16576 string-literal ( expression )
16577 [ string-literal ] string-literal ( expression )
16579 Returns a TREE_LIST representing the operands. The TREE_VALUE of
16580 each node is the expression. The TREE_PURPOSE is itself a
16581 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
16582 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
16583 is a STRING_CST for the string literal before the parenthesis. Returns
16584 ERROR_MARK_NODE if any of the operands are invalid. */
16587 cp_parser_asm_operand_list (cp_parser
* parser
)
16589 tree asm_operands
= NULL_TREE
;
16590 bool invalid_operands
= false;
16594 tree string_literal
;
16598 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
16600 /* Consume the `[' token. */
16601 cp_lexer_consume_token (parser
->lexer
);
16602 /* Read the operand name. */
16603 name
= cp_parser_identifier (parser
);
16604 if (name
!= error_mark_node
)
16605 name
= build_string (IDENTIFIER_LENGTH (name
),
16606 IDENTIFIER_POINTER (name
));
16607 /* Look for the closing `]'. */
16608 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>");
16612 /* Look for the string-literal. */
16613 string_literal
= cp_parser_string_literal (parser
, false, false);
16615 /* Look for the `('. */
16616 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
16617 /* Parse the expression. */
16618 expression
= cp_parser_expression (parser
, /*cast_p=*/false, NULL
);
16619 /* Look for the `)'. */
16620 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
16622 if (name
== error_mark_node
16623 || string_literal
== error_mark_node
16624 || expression
== error_mark_node
)
16625 invalid_operands
= true;
16627 /* Add this operand to the list. */
16628 asm_operands
= tree_cons (build_tree_list (name
, string_literal
),
16631 /* If the next token is not a `,', there are no more
16633 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
16635 /* Consume the `,'. */
16636 cp_lexer_consume_token (parser
->lexer
);
16639 return invalid_operands
? error_mark_node
: nreverse (asm_operands
);
16642 /* Parse an asm-clobber-list.
16646 asm-clobber-list , string-literal
16648 Returns a TREE_LIST, indicating the clobbers in the order that they
16649 appeared. The TREE_VALUE of each node is a STRING_CST. */
16652 cp_parser_asm_clobber_list (cp_parser
* parser
)
16654 tree clobbers
= NULL_TREE
;
16658 tree string_literal
;
16660 /* Look for the string literal. */
16661 string_literal
= cp_parser_string_literal (parser
, false, false);
16662 /* Add it to the list. */
16663 clobbers
= tree_cons (NULL_TREE
, string_literal
, clobbers
);
16664 /* If the next token is not a `,', then the list is
16666 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
16668 /* Consume the `,' token. */
16669 cp_lexer_consume_token (parser
->lexer
);
16675 /* Parse an (optional) series of attributes.
16678 attributes attribute
16681 __attribute__ (( attribute-list [opt] ))
16683 The return value is as for cp_parser_attribute_list. */
16686 cp_parser_attributes_opt (cp_parser
* parser
)
16688 tree attributes
= NULL_TREE
;
16693 tree attribute_list
;
16695 /* Peek at the next token. */
16696 token
= cp_lexer_peek_token (parser
->lexer
);
16697 /* If it's not `__attribute__', then we're done. */
16698 if (token
->keyword
!= RID_ATTRIBUTE
)
16701 /* Consume the `__attribute__' keyword. */
16702 cp_lexer_consume_token (parser
->lexer
);
16703 /* Look for the two `(' tokens. */
16704 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
16705 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
16707 /* Peek at the next token. */
16708 token
= cp_lexer_peek_token (parser
->lexer
);
16709 if (token
->type
!= CPP_CLOSE_PAREN
)
16710 /* Parse the attribute-list. */
16711 attribute_list
= cp_parser_attribute_list (parser
);
16713 /* If the next token is a `)', then there is no attribute
16715 attribute_list
= NULL
;
16717 /* Look for the two `)' tokens. */
16718 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
16719 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
16721 /* Add these new attributes to the list. */
16722 attributes
= chainon (attributes
, attribute_list
);
16728 /* Parse an attribute-list.
16732 attribute-list , attribute
16736 identifier ( identifier )
16737 identifier ( identifier , expression-list )
16738 identifier ( expression-list )
16740 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
16741 to an attribute. The TREE_PURPOSE of each node is the identifier
16742 indicating which attribute is in use. The TREE_VALUE represents
16743 the arguments, if any. */
16746 cp_parser_attribute_list (cp_parser
* parser
)
16748 tree attribute_list
= NULL_TREE
;
16749 bool save_translate_strings_p
= parser
->translate_strings_p
;
16751 parser
->translate_strings_p
= false;
16758 /* Look for the identifier. We also allow keywords here; for
16759 example `__attribute__ ((const))' is legal. */
16760 token
= cp_lexer_peek_token (parser
->lexer
);
16761 if (token
->type
== CPP_NAME
16762 || token
->type
== CPP_KEYWORD
)
16764 tree arguments
= NULL_TREE
;
16766 /* Consume the token. */
16767 token
= cp_lexer_consume_token (parser
->lexer
);
16769 /* Save away the identifier that indicates which attribute
16771 identifier
= token
->u
.value
;
16772 attribute
= build_tree_list (identifier
, NULL_TREE
);
16774 /* Peek at the next token. */
16775 token
= cp_lexer_peek_token (parser
->lexer
);
16776 /* If it's an `(', then parse the attribute arguments. */
16777 if (token
->type
== CPP_OPEN_PAREN
)
16779 arguments
= cp_parser_parenthesized_expression_list
16780 (parser
, true, /*cast_p=*/false,
16781 /*allow_expansion_p=*/false,
16782 /*non_constant_p=*/NULL
);
16783 /* Save the arguments away. */
16784 TREE_VALUE (attribute
) = arguments
;
16787 if (arguments
!= error_mark_node
)
16789 /* Add this attribute to the list. */
16790 TREE_CHAIN (attribute
) = attribute_list
;
16791 attribute_list
= attribute
;
16794 token
= cp_lexer_peek_token (parser
->lexer
);
16796 /* Now, look for more attributes. If the next token isn't a
16797 `,', we're done. */
16798 if (token
->type
!= CPP_COMMA
)
16801 /* Consume the comma and keep going. */
16802 cp_lexer_consume_token (parser
->lexer
);
16804 parser
->translate_strings_p
= save_translate_strings_p
;
16806 /* We built up the list in reverse order. */
16807 return nreverse (attribute_list
);
16810 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
16811 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
16812 current value of the PEDANTIC flag, regardless of whether or not
16813 the `__extension__' keyword is present. The caller is responsible
16814 for restoring the value of the PEDANTIC flag. */
16817 cp_parser_extension_opt (cp_parser
* parser
, int* saved_pedantic
)
16819 /* Save the old value of the PEDANTIC flag. */
16820 *saved_pedantic
= pedantic
;
16822 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_EXTENSION
))
16824 /* Consume the `__extension__' token. */
16825 cp_lexer_consume_token (parser
->lexer
);
16826 /* We're not being pedantic while the `__extension__' keyword is
16836 /* Parse a label declaration.
16839 __label__ label-declarator-seq ;
16841 label-declarator-seq:
16842 identifier , label-declarator-seq
16846 cp_parser_label_declaration (cp_parser
* parser
)
16848 /* Look for the `__label__' keyword. */
16849 cp_parser_require_keyword (parser
, RID_LABEL
, "%<__label__%>");
16855 /* Look for an identifier. */
16856 identifier
= cp_parser_identifier (parser
);
16857 /* If we failed, stop. */
16858 if (identifier
== error_mark_node
)
16860 /* Declare it as a label. */
16861 finish_label_decl (identifier
);
16862 /* If the next token is a `;', stop. */
16863 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
16865 /* Look for the `,' separating the label declarations. */
16866 cp_parser_require (parser
, CPP_COMMA
, "%<,%>");
16869 /* Look for the final `;'. */
16870 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
16873 /* Support Functions */
16875 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
16876 NAME should have one of the representations used for an
16877 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
16878 is returned. If PARSER->SCOPE is a dependent type, then a
16879 SCOPE_REF is returned.
16881 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
16882 returned; the name was already resolved when the TEMPLATE_ID_EXPR
16883 was formed. Abstractly, such entities should not be passed to this
16884 function, because they do not need to be looked up, but it is
16885 simpler to check for this special case here, rather than at the
16888 In cases not explicitly covered above, this function returns a
16889 DECL, OVERLOAD, or baselink representing the result of the lookup.
16890 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
16893 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
16894 (e.g., "struct") that was used. In that case bindings that do not
16895 refer to types are ignored.
16897 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
16900 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
16903 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
16906 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
16907 TREE_LIST of candidates if name-lookup results in an ambiguity, and
16908 NULL_TREE otherwise. */
16911 cp_parser_lookup_name (cp_parser
*parser
, tree name
,
16912 enum tag_types tag_type
,
16915 bool check_dependency
,
16916 tree
*ambiguous_decls
,
16917 location_t name_location
)
16921 tree object_type
= parser
->context
->object_type
;
16923 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
16924 flags
|= LOOKUP_COMPLAIN
;
16926 /* Assume that the lookup will be unambiguous. */
16927 if (ambiguous_decls
)
16928 *ambiguous_decls
= NULL_TREE
;
16930 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
16931 no longer valid. Note that if we are parsing tentatively, and
16932 the parse fails, OBJECT_TYPE will be automatically restored. */
16933 parser
->context
->object_type
= NULL_TREE
;
16935 if (name
== error_mark_node
)
16936 return error_mark_node
;
16938 /* A template-id has already been resolved; there is no lookup to
16940 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
16942 if (BASELINK_P (name
))
16944 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name
))
16945 == TEMPLATE_ID_EXPR
);
16949 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
16950 it should already have been checked to make sure that the name
16951 used matches the type being destroyed. */
16952 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
16956 /* Figure out to which type this destructor applies. */
16958 type
= parser
->scope
;
16959 else if (object_type
)
16960 type
= object_type
;
16962 type
= current_class_type
;
16963 /* If that's not a class type, there is no destructor. */
16964 if (!type
|| !CLASS_TYPE_P (type
))
16965 return error_mark_node
;
16966 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
16967 lazily_declare_fn (sfk_destructor
, type
);
16968 if (!CLASSTYPE_DESTRUCTORS (type
))
16969 return error_mark_node
;
16970 /* If it was a class type, return the destructor. */
16971 return CLASSTYPE_DESTRUCTORS (type
);
16974 /* By this point, the NAME should be an ordinary identifier. If
16975 the id-expression was a qualified name, the qualifying scope is
16976 stored in PARSER->SCOPE at this point. */
16977 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
16979 /* Perform the lookup. */
16984 if (parser
->scope
== error_mark_node
)
16985 return error_mark_node
;
16987 /* If the SCOPE is dependent, the lookup must be deferred until
16988 the template is instantiated -- unless we are explicitly
16989 looking up names in uninstantiated templates. Even then, we
16990 cannot look up the name if the scope is not a class type; it
16991 might, for example, be a template type parameter. */
16992 dependent_p
= (TYPE_P (parser
->scope
)
16993 && !(parser
->in_declarator_p
16994 && currently_open_class (parser
->scope
))
16995 && dependent_type_p (parser
->scope
));
16996 if ((check_dependency
|| !CLASS_TYPE_P (parser
->scope
))
17003 /* The resolution to Core Issue 180 says that `struct
17004 A::B' should be considered a type-name, even if `A'
17006 type
= make_typename_type (parser
->scope
, name
, tag_type
,
17007 /*complain=*/tf_error
);
17008 decl
= TYPE_NAME (type
);
17010 else if (is_template
17011 && (cp_parser_next_token_ends_template_argument_p (parser
)
17012 || cp_lexer_next_token_is (parser
->lexer
,
17014 decl
= make_unbound_class_template (parser
->scope
,
17016 /*complain=*/tf_error
);
17018 decl
= build_qualified_name (/*type=*/NULL_TREE
,
17019 parser
->scope
, name
,
17024 tree pushed_scope
= NULL_TREE
;
17026 /* If PARSER->SCOPE is a dependent type, then it must be a
17027 class type, and we must not be checking dependencies;
17028 otherwise, we would have processed this lookup above. So
17029 that PARSER->SCOPE is not considered a dependent base by
17030 lookup_member, we must enter the scope here. */
17032 pushed_scope
= push_scope (parser
->scope
);
17033 /* If the PARSER->SCOPE is a template specialization, it
17034 may be instantiated during name lookup. In that case,
17035 errors may be issued. Even if we rollback the current
17036 tentative parse, those errors are valid. */
17037 decl
= lookup_qualified_name (parser
->scope
, name
,
17038 tag_type
!= none_type
,
17039 /*complain=*/true);
17041 /* If we have a single function from a using decl, pull it out. */
17043 && TREE_CODE (decl
) == OVERLOAD
17044 && !really_overloaded_fn (decl
))
17045 decl
= OVL_FUNCTION (decl
);
17048 pop_scope (pushed_scope
);
17050 parser
->qualifying_scope
= parser
->scope
;
17051 parser
->object_scope
= NULL_TREE
;
17053 else if (object_type
)
17055 tree object_decl
= NULL_TREE
;
17056 /* Look up the name in the scope of the OBJECT_TYPE, unless the
17057 OBJECT_TYPE is not a class. */
17058 if (CLASS_TYPE_P (object_type
))
17059 /* If the OBJECT_TYPE is a template specialization, it may
17060 be instantiated during name lookup. In that case, errors
17061 may be issued. Even if we rollback the current tentative
17062 parse, those errors are valid. */
17063 object_decl
= lookup_member (object_type
,
17066 tag_type
!= none_type
);
17067 /* Look it up in the enclosing context, too. */
17068 decl
= lookup_name_real (name
, tag_type
!= none_type
,
17070 /*block_p=*/true, is_namespace
, flags
);
17071 parser
->object_scope
= object_type
;
17072 parser
->qualifying_scope
= NULL_TREE
;
17074 decl
= object_decl
;
17078 decl
= lookup_name_real (name
, tag_type
!= none_type
,
17080 /*block_p=*/true, is_namespace
, flags
);
17081 parser
->qualifying_scope
= NULL_TREE
;
17082 parser
->object_scope
= NULL_TREE
;
17085 /* If the lookup failed, let our caller know. */
17086 if (!decl
|| decl
== error_mark_node
)
17087 return error_mark_node
;
17089 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
17090 if (TREE_CODE (decl
) == TREE_LIST
)
17092 if (ambiguous_decls
)
17093 *ambiguous_decls
= decl
;
17094 /* The error message we have to print is too complicated for
17095 cp_parser_error, so we incorporate its actions directly. */
17096 if (!cp_parser_simulate_error (parser
))
17098 error ("%Hreference to %qD is ambiguous",
17099 &name_location
, name
);
17100 print_candidates (decl
);
17102 return error_mark_node
;
17105 gcc_assert (DECL_P (decl
)
17106 || TREE_CODE (decl
) == OVERLOAD
17107 || TREE_CODE (decl
) == SCOPE_REF
17108 || TREE_CODE (decl
) == UNBOUND_CLASS_TEMPLATE
17109 || BASELINK_P (decl
));
17111 /* If we have resolved the name of a member declaration, check to
17112 see if the declaration is accessible. When the name resolves to
17113 set of overloaded functions, accessibility is checked when
17114 overload resolution is done.
17116 During an explicit instantiation, access is not checked at all,
17117 as per [temp.explicit]. */
17119 check_accessibility_of_qualified_id (decl
, object_type
, parser
->scope
);
17124 /* Like cp_parser_lookup_name, but for use in the typical case where
17125 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
17126 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
17129 cp_parser_lookup_name_simple (cp_parser
* parser
, tree name
, location_t location
)
17131 return cp_parser_lookup_name (parser
, name
,
17133 /*is_template=*/false,
17134 /*is_namespace=*/false,
17135 /*check_dependency=*/true,
17136 /*ambiguous_decls=*/NULL
,
17140 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
17141 the current context, return the TYPE_DECL. If TAG_NAME_P is
17142 true, the DECL indicates the class being defined in a class-head,
17143 or declared in an elaborated-type-specifier.
17145 Otherwise, return DECL. */
17148 cp_parser_maybe_treat_template_as_class (tree decl
, bool tag_name_p
)
17150 /* If the TEMPLATE_DECL is being declared as part of a class-head,
17151 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
17154 template <typename T> struct B;
17157 template <typename T> struct A::B {};
17159 Similarly, in an elaborated-type-specifier:
17161 namespace N { struct X{}; }
17164 template <typename T> friend struct N::X;
17167 However, if the DECL refers to a class type, and we are in
17168 the scope of the class, then the name lookup automatically
17169 finds the TYPE_DECL created by build_self_reference rather
17170 than a TEMPLATE_DECL. For example, in:
17172 template <class T> struct S {
17176 there is no need to handle such case. */
17178 if (DECL_CLASS_TEMPLATE_P (decl
) && tag_name_p
)
17179 return DECL_TEMPLATE_RESULT (decl
);
17184 /* If too many, or too few, template-parameter lists apply to the
17185 declarator, issue an error message. Returns TRUE if all went well,
17186 and FALSE otherwise. */
17189 cp_parser_check_declarator_template_parameters (cp_parser
* parser
,
17190 cp_declarator
*declarator
,
17191 location_t declarator_location
)
17193 unsigned num_templates
;
17195 /* We haven't seen any classes that involve template parameters yet. */
17198 switch (declarator
->kind
)
17201 if (declarator
->u
.id
.qualifying_scope
)
17206 scope
= declarator
->u
.id
.qualifying_scope
;
17207 member
= declarator
->u
.id
.unqualified_name
;
17209 while (scope
&& CLASS_TYPE_P (scope
))
17211 /* You're supposed to have one `template <...>'
17212 for every template class, but you don't need one
17213 for a full specialization. For example:
17215 template <class T> struct S{};
17216 template <> struct S<int> { void f(); };
17217 void S<int>::f () {}
17219 is correct; there shouldn't be a `template <>' for
17220 the definition of `S<int>::f'. */
17221 if (!CLASSTYPE_TEMPLATE_INFO (scope
))
17222 /* If SCOPE does not have template information of any
17223 kind, then it is not a template, nor is it nested
17224 within a template. */
17226 if (explicit_class_specialization_p (scope
))
17228 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope
)))
17231 scope
= TYPE_CONTEXT (scope
);
17234 else if (TREE_CODE (declarator
->u
.id
.unqualified_name
)
17235 == TEMPLATE_ID_EXPR
)
17236 /* If the DECLARATOR has the form `X<y>' then it uses one
17237 additional level of template parameters. */
17240 return cp_parser_check_template_parameters (parser
,
17242 declarator_location
);
17247 case cdk_reference
:
17249 return (cp_parser_check_declarator_template_parameters
17250 (parser
, declarator
->declarator
, declarator_location
));
17256 gcc_unreachable ();
17261 /* NUM_TEMPLATES were used in the current declaration. If that is
17262 invalid, return FALSE and issue an error messages. Otherwise,
17266 cp_parser_check_template_parameters (cp_parser
* parser
,
17267 unsigned num_templates
,
17268 location_t location
)
17270 /* If there are more template classes than parameter lists, we have
17273 template <class T> void S<T>::R<T>::f (); */
17274 if (parser
->num_template_parameter_lists
< num_templates
)
17276 error ("%Htoo few template-parameter-lists", &location
);
17279 /* If there are the same number of template classes and parameter
17280 lists, that's OK. */
17281 if (parser
->num_template_parameter_lists
== num_templates
)
17283 /* If there are more, but only one more, then we are referring to a
17284 member template. That's OK too. */
17285 if (parser
->num_template_parameter_lists
== num_templates
+ 1)
17287 /* Otherwise, there are too many template parameter lists. We have
17290 template <class T> template <class U> void S::f(); */
17291 error ("%Htoo many template-parameter-lists", &location
);
17295 /* Parse an optional `::' token indicating that the following name is
17296 from the global namespace. If so, PARSER->SCOPE is set to the
17297 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
17298 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
17299 Returns the new value of PARSER->SCOPE, if the `::' token is
17300 present, and NULL_TREE otherwise. */
17303 cp_parser_global_scope_opt (cp_parser
* parser
, bool current_scope_valid_p
)
17307 /* Peek at the next token. */
17308 token
= cp_lexer_peek_token (parser
->lexer
);
17309 /* If we're looking at a `::' token then we're starting from the
17310 global namespace, not our current location. */
17311 if (token
->type
== CPP_SCOPE
)
17313 /* Consume the `::' token. */
17314 cp_lexer_consume_token (parser
->lexer
);
17315 /* Set the SCOPE so that we know where to start the lookup. */
17316 parser
->scope
= global_namespace
;
17317 parser
->qualifying_scope
= global_namespace
;
17318 parser
->object_scope
= NULL_TREE
;
17320 return parser
->scope
;
17322 else if (!current_scope_valid_p
)
17324 parser
->scope
= NULL_TREE
;
17325 parser
->qualifying_scope
= NULL_TREE
;
17326 parser
->object_scope
= NULL_TREE
;
17332 /* Returns TRUE if the upcoming token sequence is the start of a
17333 constructor declarator. If FRIEND_P is true, the declarator is
17334 preceded by the `friend' specifier. */
17337 cp_parser_constructor_declarator_p (cp_parser
*parser
, bool friend_p
)
17339 bool constructor_p
;
17340 tree type_decl
= NULL_TREE
;
17341 bool nested_name_p
;
17342 cp_token
*next_token
;
17344 /* The common case is that this is not a constructor declarator, so
17345 try to avoid doing lots of work if at all possible. It's not
17346 valid declare a constructor at function scope. */
17347 if (parser
->in_function_body
)
17349 /* And only certain tokens can begin a constructor declarator. */
17350 next_token
= cp_lexer_peek_token (parser
->lexer
);
17351 if (next_token
->type
!= CPP_NAME
17352 && next_token
->type
!= CPP_SCOPE
17353 && next_token
->type
!= CPP_NESTED_NAME_SPECIFIER
17354 && next_token
->type
!= CPP_TEMPLATE_ID
)
17357 /* Parse tentatively; we are going to roll back all of the tokens
17359 cp_parser_parse_tentatively (parser
);
17360 /* Assume that we are looking at a constructor declarator. */
17361 constructor_p
= true;
17363 /* Look for the optional `::' operator. */
17364 cp_parser_global_scope_opt (parser
,
17365 /*current_scope_valid_p=*/false);
17366 /* Look for the nested-name-specifier. */
17368 = (cp_parser_nested_name_specifier_opt (parser
,
17369 /*typename_keyword_p=*/false,
17370 /*check_dependency_p=*/false,
17372 /*is_declaration=*/false)
17374 /* Outside of a class-specifier, there must be a
17375 nested-name-specifier. */
17376 if (!nested_name_p
&&
17377 (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type
)
17379 constructor_p
= false;
17380 /* If we still think that this might be a constructor-declarator,
17381 look for a class-name. */
17386 template <typename T> struct S { S(); };
17387 template <typename T> S<T>::S ();
17389 we must recognize that the nested `S' names a class.
17392 template <typename T> S<T>::S<T> ();
17394 we must recognize that the nested `S' names a template. */
17395 type_decl
= cp_parser_class_name (parser
,
17396 /*typename_keyword_p=*/false,
17397 /*template_keyword_p=*/false,
17399 /*check_dependency_p=*/false,
17400 /*class_head_p=*/false,
17401 /*is_declaration=*/false);
17402 /* If there was no class-name, then this is not a constructor. */
17403 constructor_p
= !cp_parser_error_occurred (parser
);
17406 /* If we're still considering a constructor, we have to see a `(',
17407 to begin the parameter-declaration-clause, followed by either a
17408 `)', an `...', or a decl-specifier. We need to check for a
17409 type-specifier to avoid being fooled into thinking that:
17413 is a constructor. (It is actually a function named `f' that
17414 takes one parameter (of type `int') and returns a value of type
17417 && cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
17419 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
)
17420 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_ELLIPSIS
)
17421 /* A parameter declaration begins with a decl-specifier,
17422 which is either the "attribute" keyword, a storage class
17423 specifier, or (usually) a type-specifier. */
17424 && !cp_lexer_next_token_is_decl_specifier_keyword (parser
->lexer
))
17427 tree pushed_scope
= NULL_TREE
;
17428 unsigned saved_num_template_parameter_lists
;
17430 /* Names appearing in the type-specifier should be looked up
17431 in the scope of the class. */
17432 if (current_class_type
)
17436 type
= TREE_TYPE (type_decl
);
17437 if (TREE_CODE (type
) == TYPENAME_TYPE
)
17439 type
= resolve_typename_type (type
,
17440 /*only_current_p=*/false);
17441 if (TREE_CODE (type
) == TYPENAME_TYPE
)
17443 cp_parser_abort_tentative_parse (parser
);
17447 pushed_scope
= push_scope (type
);
17450 /* Inside the constructor parameter list, surrounding
17451 template-parameter-lists do not apply. */
17452 saved_num_template_parameter_lists
17453 = parser
->num_template_parameter_lists
;
17454 parser
->num_template_parameter_lists
= 0;
17456 /* Look for the type-specifier. */
17457 cp_parser_type_specifier (parser
,
17458 CP_PARSER_FLAGS_NONE
,
17459 /*decl_specs=*/NULL
,
17460 /*is_declarator=*/true,
17461 /*declares_class_or_enum=*/NULL
,
17462 /*is_cv_qualifier=*/NULL
);
17464 parser
->num_template_parameter_lists
17465 = saved_num_template_parameter_lists
;
17467 /* Leave the scope of the class. */
17469 pop_scope (pushed_scope
);
17471 constructor_p
= !cp_parser_error_occurred (parser
);
17475 constructor_p
= false;
17476 /* We did not really want to consume any tokens. */
17477 cp_parser_abort_tentative_parse (parser
);
17479 return constructor_p
;
17482 /* Parse the definition of the function given by the DECL_SPECIFIERS,
17483 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
17484 they must be performed once we are in the scope of the function.
17486 Returns the function defined. */
17489 cp_parser_function_definition_from_specifiers_and_declarator
17490 (cp_parser
* parser
,
17491 cp_decl_specifier_seq
*decl_specifiers
,
17493 const cp_declarator
*declarator
)
17498 /* Begin the function-definition. */
17499 success_p
= start_function (decl_specifiers
, declarator
, attributes
);
17501 /* The things we're about to see are not directly qualified by any
17502 template headers we've seen thus far. */
17503 reset_specialization ();
17505 /* If there were names looked up in the decl-specifier-seq that we
17506 did not check, check them now. We must wait until we are in the
17507 scope of the function to perform the checks, since the function
17508 might be a friend. */
17509 perform_deferred_access_checks ();
17513 /* Skip the entire function. */
17514 cp_parser_skip_to_end_of_block_or_statement (parser
);
17515 fn
= error_mark_node
;
17517 else if (DECL_INITIAL (current_function_decl
) != error_mark_node
)
17519 /* Seen already, skip it. An error message has already been output. */
17520 cp_parser_skip_to_end_of_block_or_statement (parser
);
17521 fn
= current_function_decl
;
17522 current_function_decl
= NULL_TREE
;
17523 /* If this is a function from a class, pop the nested class. */
17524 if (current_class_name
)
17525 pop_nested_class ();
17528 fn
= cp_parser_function_definition_after_declarator (parser
,
17529 /*inline_p=*/false);
17534 /* Parse the part of a function-definition that follows the
17535 declarator. INLINE_P is TRUE iff this function is an inline
17536 function defined with a class-specifier.
17538 Returns the function defined. */
17541 cp_parser_function_definition_after_declarator (cp_parser
* parser
,
17545 bool ctor_initializer_p
= false;
17546 bool saved_in_unbraced_linkage_specification_p
;
17547 bool saved_in_function_body
;
17548 unsigned saved_num_template_parameter_lists
;
17551 saved_in_function_body
= parser
->in_function_body
;
17552 parser
->in_function_body
= true;
17553 /* If the next token is `return', then the code may be trying to
17554 make use of the "named return value" extension that G++ used to
17556 token
= cp_lexer_peek_token (parser
->lexer
);
17557 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_RETURN
))
17559 /* Consume the `return' keyword. */
17560 cp_lexer_consume_token (parser
->lexer
);
17561 /* Look for the identifier that indicates what value is to be
17563 cp_parser_identifier (parser
);
17564 /* Issue an error message. */
17565 error ("%Hnamed return values are no longer supported",
17567 /* Skip tokens until we reach the start of the function body. */
17570 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
17571 if (token
->type
== CPP_OPEN_BRACE
17572 || token
->type
== CPP_EOF
17573 || token
->type
== CPP_PRAGMA_EOL
)
17575 cp_lexer_consume_token (parser
->lexer
);
17578 /* The `extern' in `extern "C" void f () { ... }' does not apply to
17579 anything declared inside `f'. */
17580 saved_in_unbraced_linkage_specification_p
17581 = parser
->in_unbraced_linkage_specification_p
;
17582 parser
->in_unbraced_linkage_specification_p
= false;
17583 /* Inside the function, surrounding template-parameter-lists do not
17585 saved_num_template_parameter_lists
17586 = parser
->num_template_parameter_lists
;
17587 parser
->num_template_parameter_lists
= 0;
17588 /* If the next token is `try', then we are looking at a
17589 function-try-block. */
17590 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRY
))
17591 ctor_initializer_p
= cp_parser_function_try_block (parser
);
17592 /* A function-try-block includes the function-body, so we only do
17593 this next part if we're not processing a function-try-block. */
17596 = cp_parser_ctor_initializer_opt_and_function_body (parser
);
17598 /* Finish the function. */
17599 fn
= finish_function ((ctor_initializer_p
? 1 : 0) |
17600 (inline_p
? 2 : 0));
17601 /* Generate code for it, if necessary. */
17602 expand_or_defer_fn (fn
);
17603 /* Restore the saved values. */
17604 parser
->in_unbraced_linkage_specification_p
17605 = saved_in_unbraced_linkage_specification_p
;
17606 parser
->num_template_parameter_lists
17607 = saved_num_template_parameter_lists
;
17608 parser
->in_function_body
= saved_in_function_body
;
17613 /* Parse a template-declaration, assuming that the `export' (and
17614 `extern') keywords, if present, has already been scanned. MEMBER_P
17615 is as for cp_parser_template_declaration. */
17618 cp_parser_template_declaration_after_export (cp_parser
* parser
, bool member_p
)
17620 tree decl
= NULL_TREE
;
17621 VEC (deferred_access_check
,gc
) *checks
;
17622 tree parameter_list
;
17623 bool friend_p
= false;
17624 bool need_lang_pop
;
17627 /* Look for the `template' keyword. */
17628 token
= cp_lexer_peek_token (parser
->lexer
);
17629 if (!cp_parser_require_keyword (parser
, RID_TEMPLATE
, "%<template%>"))
17633 if (!cp_parser_require (parser
, CPP_LESS
, "%<<%>"))
17635 if (at_class_scope_p () && current_function_decl
)
17637 /* 14.5.2.2 [temp.mem]
17639 A local class shall not have member templates. */
17640 error ("%Hinvalid declaration of member template in local class",
17642 cp_parser_skip_to_end_of_block_or_statement (parser
);
17647 A template ... shall not have C linkage. */
17648 if (current_lang_name
== lang_name_c
)
17650 error ("%Htemplate with C linkage", &token
->location
);
17651 /* Give it C++ linkage to avoid confusing other parts of the
17653 push_lang_context (lang_name_cplusplus
);
17654 need_lang_pop
= true;
17657 need_lang_pop
= false;
17659 /* We cannot perform access checks on the template parameter
17660 declarations until we know what is being declared, just as we
17661 cannot check the decl-specifier list. */
17662 push_deferring_access_checks (dk_deferred
);
17664 /* If the next token is `>', then we have an invalid
17665 specialization. Rather than complain about an invalid template
17666 parameter, issue an error message here. */
17667 if (cp_lexer_next_token_is (parser
->lexer
, CPP_GREATER
))
17669 cp_parser_error (parser
, "invalid explicit specialization");
17670 begin_specialization ();
17671 parameter_list
= NULL_TREE
;
17674 /* Parse the template parameters. */
17675 parameter_list
= cp_parser_template_parameter_list (parser
);
17677 /* Get the deferred access checks from the parameter list. These
17678 will be checked once we know what is being declared, as for a
17679 member template the checks must be performed in the scope of the
17680 class containing the member. */
17681 checks
= get_deferred_access_checks ();
17683 /* Look for the `>'. */
17684 cp_parser_skip_to_end_of_template_parameter_list (parser
);
17685 /* We just processed one more parameter list. */
17686 ++parser
->num_template_parameter_lists
;
17687 /* If the next token is `template', there are more template
17689 if (cp_lexer_next_token_is_keyword (parser
->lexer
,
17691 cp_parser_template_declaration_after_export (parser
, member_p
);
17694 /* There are no access checks when parsing a template, as we do not
17695 know if a specialization will be a friend. */
17696 push_deferring_access_checks (dk_no_check
);
17697 token
= cp_lexer_peek_token (parser
->lexer
);
17698 decl
= cp_parser_single_declaration (parser
,
17701 /*explicit_specialization_p=*/false,
17703 pop_deferring_access_checks ();
17705 /* If this is a member template declaration, let the front
17707 if (member_p
&& !friend_p
&& decl
)
17709 if (TREE_CODE (decl
) == TYPE_DECL
)
17710 cp_parser_check_access_in_redeclaration (decl
, token
->location
);
17712 decl
= finish_member_template_decl (decl
);
17714 else if (friend_p
&& decl
&& TREE_CODE (decl
) == TYPE_DECL
)
17715 make_friend_class (current_class_type
, TREE_TYPE (decl
),
17716 /*complain=*/true);
17718 /* We are done with the current parameter list. */
17719 --parser
->num_template_parameter_lists
;
17721 pop_deferring_access_checks ();
17724 finish_template_decl (parameter_list
);
17726 /* Register member declarations. */
17727 if (member_p
&& !friend_p
&& decl
&& !DECL_CLASS_TEMPLATE_P (decl
))
17728 finish_member_declaration (decl
);
17729 /* For the erroneous case of a template with C linkage, we pushed an
17730 implicit C++ linkage scope; exit that scope now. */
17732 pop_lang_context ();
17733 /* If DECL is a function template, we must return to parse it later.
17734 (Even though there is no definition, there might be default
17735 arguments that need handling.) */
17736 if (member_p
&& decl
17737 && (TREE_CODE (decl
) == FUNCTION_DECL
17738 || DECL_FUNCTION_TEMPLATE_P (decl
)))
17739 TREE_VALUE (parser
->unparsed_functions_queues
)
17740 = tree_cons (NULL_TREE
, decl
,
17741 TREE_VALUE (parser
->unparsed_functions_queues
));
17744 /* Perform the deferred access checks from a template-parameter-list.
17745 CHECKS is a TREE_LIST of access checks, as returned by
17746 get_deferred_access_checks. */
17749 cp_parser_perform_template_parameter_access_checks (VEC (deferred_access_check
,gc
)* checks
)
17751 ++processing_template_parmlist
;
17752 perform_access_checks (checks
);
17753 --processing_template_parmlist
;
17756 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
17757 `function-definition' sequence. MEMBER_P is true, this declaration
17758 appears in a class scope.
17760 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
17761 *FRIEND_P is set to TRUE iff the declaration is a friend. */
17764 cp_parser_single_declaration (cp_parser
* parser
,
17765 VEC (deferred_access_check
,gc
)* checks
,
17767 bool explicit_specialization_p
,
17770 int declares_class_or_enum
;
17771 tree decl
= NULL_TREE
;
17772 cp_decl_specifier_seq decl_specifiers
;
17773 bool function_definition_p
= false;
17774 cp_token
*decl_spec_token_start
;
17776 /* This function is only used when processing a template
17778 gcc_assert (innermost_scope_kind () == sk_template_parms
17779 || innermost_scope_kind () == sk_template_spec
);
17781 /* Defer access checks until we know what is being declared. */
17782 push_deferring_access_checks (dk_deferred
);
17784 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
17786 decl_spec_token_start
= cp_lexer_peek_token (parser
->lexer
);
17787 cp_parser_decl_specifier_seq (parser
,
17788 CP_PARSER_FLAGS_OPTIONAL
,
17790 &declares_class_or_enum
);
17792 *friend_p
= cp_parser_friend_p (&decl_specifiers
);
17794 /* There are no template typedefs. */
17795 if (decl_specifiers
.specs
[(int) ds_typedef
])
17797 error ("%Htemplate declaration of %qs",
17798 &decl_spec_token_start
->location
, "typedef");
17799 decl
= error_mark_node
;
17802 /* Gather up the access checks that occurred the
17803 decl-specifier-seq. */
17804 stop_deferring_access_checks ();
17806 /* Check for the declaration of a template class. */
17807 if (declares_class_or_enum
)
17809 if (cp_parser_declares_only_class_p (parser
))
17811 decl
= shadow_tag (&decl_specifiers
);
17816 friend template <typename T> struct A<T>::B;
17819 A<T>::B will be represented by a TYPENAME_TYPE, and
17820 therefore not recognized by shadow_tag. */
17821 if (friend_p
&& *friend_p
17823 && decl_specifiers
.type
17824 && TYPE_P (decl_specifiers
.type
))
17825 decl
= decl_specifiers
.type
;
17827 if (decl
&& decl
!= error_mark_node
)
17828 decl
= TYPE_NAME (decl
);
17830 decl
= error_mark_node
;
17832 /* Perform access checks for template parameters. */
17833 cp_parser_perform_template_parameter_access_checks (checks
);
17836 /* If it's not a template class, try for a template function. If
17837 the next token is a `;', then this declaration does not declare
17838 anything. But, if there were errors in the decl-specifiers, then
17839 the error might well have come from an attempted class-specifier.
17840 In that case, there's no need to warn about a missing declarator. */
17842 && (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
)
17843 || decl_specifiers
.type
!= error_mark_node
))
17845 decl
= cp_parser_init_declarator (parser
,
17848 /*function_definition_allowed_p=*/true,
17850 declares_class_or_enum
,
17851 &function_definition_p
);
17853 /* 7.1.1-1 [dcl.stc]
17855 A storage-class-specifier shall not be specified in an explicit
17856 specialization... */
17858 && explicit_specialization_p
17859 && decl_specifiers
.storage_class
!= sc_none
)
17861 error ("%Hexplicit template specialization cannot have a storage class",
17862 &decl_spec_token_start
->location
);
17863 decl
= error_mark_node
;
17867 pop_deferring_access_checks ();
17869 /* Clear any current qualification; whatever comes next is the start
17870 of something new. */
17871 parser
->scope
= NULL_TREE
;
17872 parser
->qualifying_scope
= NULL_TREE
;
17873 parser
->object_scope
= NULL_TREE
;
17874 /* Look for a trailing `;' after the declaration. */
17875 if (!function_definition_p
17876 && (decl
== error_mark_node
17877 || !cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>")))
17878 cp_parser_skip_to_end_of_block_or_statement (parser
);
17883 /* Parse a cast-expression that is not the operand of a unary "&". */
17886 cp_parser_simple_cast_expression (cp_parser
*parser
)
17888 return cp_parser_cast_expression (parser
, /*address_p=*/false,
17889 /*cast_p=*/false, NULL
);
17892 /* Parse a functional cast to TYPE. Returns an expression
17893 representing the cast. */
17896 cp_parser_functional_cast (cp_parser
* parser
, tree type
)
17898 tree expression_list
;
17902 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
17904 maybe_warn_cpp0x ("extended initializer lists");
17905 expression_list
= cp_parser_braced_list (parser
, &nonconst_p
);
17906 CONSTRUCTOR_IS_DIRECT_INIT (expression_list
) = 1;
17907 if (TREE_CODE (type
) == TYPE_DECL
)
17908 type
= TREE_TYPE (type
);
17909 return finish_compound_literal (type
, expression_list
);
17913 = cp_parser_parenthesized_expression_list (parser
, false,
17915 /*allow_expansion_p=*/true,
17916 /*non_constant_p=*/NULL
);
17918 cast
= build_functional_cast (type
, expression_list
,
17919 tf_warning_or_error
);
17920 /* [expr.const]/1: In an integral constant expression "only type
17921 conversions to integral or enumeration type can be used". */
17922 if (TREE_CODE (type
) == TYPE_DECL
)
17923 type
= TREE_TYPE (type
);
17924 if (cast
!= error_mark_node
17925 && !cast_valid_in_integral_constant_expression_p (type
)
17926 && (cp_parser_non_integral_constant_expression
17927 (parser
, "a call to a constructor")))
17928 return error_mark_node
;
17932 /* Save the tokens that make up the body of a member function defined
17933 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
17934 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
17935 specifiers applied to the declaration. Returns the FUNCTION_DECL
17936 for the member function. */
17939 cp_parser_save_member_function_body (cp_parser
* parser
,
17940 cp_decl_specifier_seq
*decl_specifiers
,
17941 cp_declarator
*declarator
,
17948 /* Create the function-declaration. */
17949 fn
= start_method (decl_specifiers
, declarator
, attributes
);
17950 /* If something went badly wrong, bail out now. */
17951 if (fn
== error_mark_node
)
17953 /* If there's a function-body, skip it. */
17954 if (cp_parser_token_starts_function_definition_p
17955 (cp_lexer_peek_token (parser
->lexer
)))
17956 cp_parser_skip_to_end_of_block_or_statement (parser
);
17957 return error_mark_node
;
17960 /* Remember it, if there default args to post process. */
17961 cp_parser_save_default_args (parser
, fn
);
17963 /* Save away the tokens that make up the body of the
17965 first
= parser
->lexer
->next_token
;
17966 /* We can have braced-init-list mem-initializers before the fn body. */
17967 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
17969 cp_lexer_consume_token (parser
->lexer
);
17970 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
)
17971 && cp_lexer_next_token_is_not_keyword (parser
->lexer
, RID_TRY
))
17973 /* cache_group will stop after an un-nested { } pair, too. */
17974 if (cp_parser_cache_group (parser
, CPP_CLOSE_PAREN
, /*depth=*/0))
17977 /* variadic mem-inits have ... after the ')'. */
17978 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
17979 cp_lexer_consume_token (parser
->lexer
);
17982 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
17983 /* Handle function try blocks. */
17984 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CATCH
))
17985 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
17986 last
= parser
->lexer
->next_token
;
17988 /* Save away the inline definition; we will process it when the
17989 class is complete. */
17990 DECL_PENDING_INLINE_INFO (fn
) = cp_token_cache_new (first
, last
);
17991 DECL_PENDING_INLINE_P (fn
) = 1;
17993 /* We need to know that this was defined in the class, so that
17994 friend templates are handled correctly. */
17995 DECL_INITIALIZED_IN_CLASS_P (fn
) = 1;
17997 /* We're done with the inline definition. */
17998 finish_method (fn
);
18000 /* Add FN to the queue of functions to be parsed later. */
18001 TREE_VALUE (parser
->unparsed_functions_queues
)
18002 = tree_cons (NULL_TREE
, fn
,
18003 TREE_VALUE (parser
->unparsed_functions_queues
));
18008 /* Parse a template-argument-list, as well as the trailing ">" (but
18009 not the opening ">"). See cp_parser_template_argument_list for the
18013 cp_parser_enclosed_template_argument_list (cp_parser
* parser
)
18017 tree saved_qualifying_scope
;
18018 tree saved_object_scope
;
18019 bool saved_greater_than_is_operator_p
;
18020 bool saved_skip_evaluation
;
18024 When parsing a template-id, the first non-nested `>' is taken as
18025 the end of the template-argument-list rather than a greater-than
18027 saved_greater_than_is_operator_p
18028 = parser
->greater_than_is_operator_p
;
18029 parser
->greater_than_is_operator_p
= false;
18030 /* Parsing the argument list may modify SCOPE, so we save it
18032 saved_scope
= parser
->scope
;
18033 saved_qualifying_scope
= parser
->qualifying_scope
;
18034 saved_object_scope
= parser
->object_scope
;
18035 /* We need to evaluate the template arguments, even though this
18036 template-id may be nested within a "sizeof". */
18037 saved_skip_evaluation
= skip_evaluation
;
18038 skip_evaluation
= false;
18039 /* Parse the template-argument-list itself. */
18040 if (cp_lexer_next_token_is (parser
->lexer
, CPP_GREATER
)
18041 || cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
18042 arguments
= NULL_TREE
;
18044 arguments
= cp_parser_template_argument_list (parser
);
18045 /* Look for the `>' that ends the template-argument-list. If we find
18046 a '>>' instead, it's probably just a typo. */
18047 if (cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
18049 if (cxx_dialect
!= cxx98
)
18051 /* In C++0x, a `>>' in a template argument list or cast
18052 expression is considered to be two separate `>'
18053 tokens. So, change the current token to a `>', but don't
18054 consume it: it will be consumed later when the outer
18055 template argument list (or cast expression) is parsed.
18056 Note that this replacement of `>' for `>>' is necessary
18057 even if we are parsing tentatively: in the tentative
18058 case, after calling
18059 cp_parser_enclosed_template_argument_list we will always
18060 throw away all of the template arguments and the first
18061 closing `>', either because the template argument list
18062 was erroneous or because we are replacing those tokens
18063 with a CPP_TEMPLATE_ID token. The second `>' (which will
18064 not have been thrown away) is needed either to close an
18065 outer template argument list or to complete a new-style
18067 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
18068 token
->type
= CPP_GREATER
;
18070 else if (!saved_greater_than_is_operator_p
)
18072 /* If we're in a nested template argument list, the '>>' has
18073 to be a typo for '> >'. We emit the error message, but we
18074 continue parsing and we push a '>' as next token, so that
18075 the argument list will be parsed correctly. Note that the
18076 global source location is still on the token before the
18077 '>>', so we need to say explicitly where we want it. */
18078 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
18079 error ("%H%<>>%> should be %<> >%> "
18080 "within a nested template argument list",
18083 token
->type
= CPP_GREATER
;
18087 /* If this is not a nested template argument list, the '>>'
18088 is a typo for '>'. Emit an error message and continue.
18089 Same deal about the token location, but here we can get it
18090 right by consuming the '>>' before issuing the diagnostic. */
18091 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
18092 error ("%Hspurious %<>>%>, use %<>%> to terminate "
18093 "a template argument list", &token
->location
);
18097 cp_parser_skip_to_end_of_template_parameter_list (parser
);
18098 /* The `>' token might be a greater-than operator again now. */
18099 parser
->greater_than_is_operator_p
18100 = saved_greater_than_is_operator_p
;
18101 /* Restore the SAVED_SCOPE. */
18102 parser
->scope
= saved_scope
;
18103 parser
->qualifying_scope
= saved_qualifying_scope
;
18104 parser
->object_scope
= saved_object_scope
;
18105 skip_evaluation
= saved_skip_evaluation
;
18110 /* MEMBER_FUNCTION is a member function, or a friend. If default
18111 arguments, or the body of the function have not yet been parsed,
18115 cp_parser_late_parsing_for_member (cp_parser
* parser
, tree member_function
)
18117 /* If this member is a template, get the underlying
18119 if (DECL_FUNCTION_TEMPLATE_P (member_function
))
18120 member_function
= DECL_TEMPLATE_RESULT (member_function
);
18122 /* There should not be any class definitions in progress at this
18123 point; the bodies of members are only parsed outside of all class
18125 gcc_assert (parser
->num_classes_being_defined
== 0);
18126 /* While we're parsing the member functions we might encounter more
18127 classes. We want to handle them right away, but we don't want
18128 them getting mixed up with functions that are currently in the
18130 parser
->unparsed_functions_queues
18131 = tree_cons (NULL_TREE
, NULL_TREE
, parser
->unparsed_functions_queues
);
18133 /* Make sure that any template parameters are in scope. */
18134 maybe_begin_member_template_processing (member_function
);
18136 /* If the body of the function has not yet been parsed, parse it
18138 if (DECL_PENDING_INLINE_P (member_function
))
18140 tree function_scope
;
18141 cp_token_cache
*tokens
;
18143 /* The function is no longer pending; we are processing it. */
18144 tokens
= DECL_PENDING_INLINE_INFO (member_function
);
18145 DECL_PENDING_INLINE_INFO (member_function
) = NULL
;
18146 DECL_PENDING_INLINE_P (member_function
) = 0;
18148 /* If this is a local class, enter the scope of the containing
18150 function_scope
= current_function_decl
;
18151 if (function_scope
)
18152 push_function_context ();
18154 /* Push the body of the function onto the lexer stack. */
18155 cp_parser_push_lexer_for_tokens (parser
, tokens
);
18157 /* Let the front end know that we going to be defining this
18159 start_preparsed_function (member_function
, NULL_TREE
,
18160 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
18162 /* Don't do access checking if it is a templated function. */
18163 if (processing_template_decl
)
18164 push_deferring_access_checks (dk_no_check
);
18166 /* Now, parse the body of the function. */
18167 cp_parser_function_definition_after_declarator (parser
,
18168 /*inline_p=*/true);
18170 if (processing_template_decl
)
18171 pop_deferring_access_checks ();
18173 /* Leave the scope of the containing function. */
18174 if (function_scope
)
18175 pop_function_context ();
18176 cp_parser_pop_lexer (parser
);
18179 /* Remove any template parameters from the symbol table. */
18180 maybe_end_member_template_processing ();
18182 /* Restore the queue. */
18183 parser
->unparsed_functions_queues
18184 = TREE_CHAIN (parser
->unparsed_functions_queues
);
18187 /* If DECL contains any default args, remember it on the unparsed
18188 functions queue. */
18191 cp_parser_save_default_args (cp_parser
* parser
, tree decl
)
18195 for (probe
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
18197 probe
= TREE_CHAIN (probe
))
18198 if (TREE_PURPOSE (probe
))
18200 TREE_PURPOSE (parser
->unparsed_functions_queues
)
18201 = tree_cons (current_class_type
, decl
,
18202 TREE_PURPOSE (parser
->unparsed_functions_queues
));
18207 /* FN is a FUNCTION_DECL which may contains a parameter with an
18208 unparsed DEFAULT_ARG. Parse the default args now. This function
18209 assumes that the current scope is the scope in which the default
18210 argument should be processed. */
18213 cp_parser_late_parsing_default_args (cp_parser
*parser
, tree fn
)
18215 bool saved_local_variables_forbidden_p
;
18218 /* While we're parsing the default args, we might (due to the
18219 statement expression extension) encounter more classes. We want
18220 to handle them right away, but we don't want them getting mixed
18221 up with default args that are currently in the queue. */
18222 parser
->unparsed_functions_queues
18223 = tree_cons (NULL_TREE
, NULL_TREE
, parser
->unparsed_functions_queues
);
18225 /* Local variable names (and the `this' keyword) may not appear
18226 in a default argument. */
18227 saved_local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
18228 parser
->local_variables_forbidden_p
= true;
18230 for (parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
18232 parm
= TREE_CHAIN (parm
))
18234 cp_token_cache
*tokens
;
18235 tree default_arg
= TREE_PURPOSE (parm
);
18237 VEC(tree
,gc
) *insts
;
18244 if (TREE_CODE (default_arg
) != DEFAULT_ARG
)
18245 /* This can happen for a friend declaration for a function
18246 already declared with default arguments. */
18249 /* Push the saved tokens for the default argument onto the parser's
18251 tokens
= DEFARG_TOKENS (default_arg
);
18252 cp_parser_push_lexer_for_tokens (parser
, tokens
);
18254 /* Parse the assignment-expression. */
18255 parsed_arg
= cp_parser_assignment_expression (parser
, /*cast_p=*/false, NULL
);
18257 if (!processing_template_decl
)
18258 parsed_arg
= check_default_argument (TREE_VALUE (parm
), parsed_arg
);
18260 TREE_PURPOSE (parm
) = parsed_arg
;
18262 /* Update any instantiations we've already created. */
18263 for (insts
= DEFARG_INSTANTIATIONS (default_arg
), ix
= 0;
18264 VEC_iterate (tree
, insts
, ix
, copy
); ix
++)
18265 TREE_PURPOSE (copy
) = parsed_arg
;
18267 /* If the token stream has not been completely used up, then
18268 there was extra junk after the end of the default
18270 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
18271 cp_parser_error (parser
, "expected %<,%>");
18273 /* Revert to the main lexer. */
18274 cp_parser_pop_lexer (parser
);
18277 /* Make sure no default arg is missing. */
18278 check_default_args (fn
);
18280 /* Restore the state of local_variables_forbidden_p. */
18281 parser
->local_variables_forbidden_p
= saved_local_variables_forbidden_p
;
18283 /* Restore the queue. */
18284 parser
->unparsed_functions_queues
18285 = TREE_CHAIN (parser
->unparsed_functions_queues
);
18288 /* Parse the operand of `sizeof' (or a similar operator). Returns
18289 either a TYPE or an expression, depending on the form of the
18290 input. The KEYWORD indicates which kind of expression we have
18294 cp_parser_sizeof_operand (cp_parser
* parser
, enum rid keyword
)
18296 tree expr
= NULL_TREE
;
18297 const char *saved_message
;
18299 bool saved_integral_constant_expression_p
;
18300 bool saved_non_integral_constant_expression_p
;
18301 bool pack_expansion_p
= false;
18303 /* Types cannot be defined in a `sizeof' expression. Save away the
18305 saved_message
= parser
->type_definition_forbidden_message
;
18306 /* And create the new one. */
18307 tmp
= concat ("types may not be defined in %<",
18308 IDENTIFIER_POINTER (ridpointers
[keyword
]),
18309 "%> expressions", NULL
);
18310 parser
->type_definition_forbidden_message
= tmp
;
18312 /* The restrictions on constant-expressions do not apply inside
18313 sizeof expressions. */
18314 saved_integral_constant_expression_p
18315 = parser
->integral_constant_expression_p
;
18316 saved_non_integral_constant_expression_p
18317 = parser
->non_integral_constant_expression_p
;
18318 parser
->integral_constant_expression_p
= false;
18320 /* If it's a `...', then we are computing the length of a parameter
18322 if (keyword
== RID_SIZEOF
18323 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
18325 /* Consume the `...'. */
18326 cp_lexer_consume_token (parser
->lexer
);
18327 maybe_warn_variadic_templates ();
18329 /* Note that this is an expansion. */
18330 pack_expansion_p
= true;
18333 /* Do not actually evaluate the expression. */
18335 /* If it's a `(', then we might be looking at the type-id
18337 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
18340 bool saved_in_type_id_in_expr_p
;
18342 /* We can't be sure yet whether we're looking at a type-id or an
18344 cp_parser_parse_tentatively (parser
);
18345 /* Consume the `('. */
18346 cp_lexer_consume_token (parser
->lexer
);
18347 /* Parse the type-id. */
18348 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
18349 parser
->in_type_id_in_expr_p
= true;
18350 type
= cp_parser_type_id (parser
);
18351 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
18352 /* Now, look for the trailing `)'. */
18353 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
18354 /* If all went well, then we're done. */
18355 if (cp_parser_parse_definitely (parser
))
18357 cp_decl_specifier_seq decl_specs
;
18359 /* Build a trivial decl-specifier-seq. */
18360 clear_decl_specs (&decl_specs
);
18361 decl_specs
.type
= type
;
18363 /* Call grokdeclarator to figure out what type this is. */
18364 expr
= grokdeclarator (NULL
,
18368 /*attrlist=*/NULL
);
18372 /* If the type-id production did not work out, then we must be
18373 looking at the unary-expression production. */
18375 expr
= cp_parser_unary_expression (parser
, /*address_p=*/false,
18376 /*cast_p=*/false, NULL
);
18378 if (pack_expansion_p
)
18379 /* Build a pack expansion. */
18380 expr
= make_pack_expansion (expr
);
18382 /* Go back to evaluating expressions. */
18385 /* Free the message we created. */
18387 /* And restore the old one. */
18388 parser
->type_definition_forbidden_message
= saved_message
;
18389 parser
->integral_constant_expression_p
18390 = saved_integral_constant_expression_p
;
18391 parser
->non_integral_constant_expression_p
18392 = saved_non_integral_constant_expression_p
;
18397 /* If the current declaration has no declarator, return true. */
18400 cp_parser_declares_only_class_p (cp_parser
*parser
)
18402 /* If the next token is a `;' or a `,' then there is no
18404 return (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
18405 || cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
));
18408 /* Update the DECL_SPECS to reflect the storage class indicated by
18412 cp_parser_set_storage_class (cp_parser
*parser
,
18413 cp_decl_specifier_seq
*decl_specs
,
18415 location_t location
)
18417 cp_storage_class storage_class
;
18419 if (parser
->in_unbraced_linkage_specification_p
)
18421 error ("%Hinvalid use of %qD in linkage specification",
18422 &location
, ridpointers
[keyword
]);
18425 else if (decl_specs
->storage_class
!= sc_none
)
18427 decl_specs
->conflicting_specifiers_p
= true;
18431 if ((keyword
== RID_EXTERN
|| keyword
== RID_STATIC
)
18432 && decl_specs
->specs
[(int) ds_thread
])
18434 error ("%H%<__thread%> before %qD", &location
, ridpointers
[keyword
]);
18435 decl_specs
->specs
[(int) ds_thread
] = 0;
18441 storage_class
= sc_auto
;
18444 storage_class
= sc_register
;
18447 storage_class
= sc_static
;
18450 storage_class
= sc_extern
;
18453 storage_class
= sc_mutable
;
18456 gcc_unreachable ();
18458 decl_specs
->storage_class
= storage_class
;
18460 /* A storage class specifier cannot be applied alongside a typedef
18461 specifier. If there is a typedef specifier present then set
18462 conflicting_specifiers_p which will trigger an error later
18463 on in grokdeclarator. */
18464 if (decl_specs
->specs
[(int)ds_typedef
])
18465 decl_specs
->conflicting_specifiers_p
= true;
18468 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If USER_DEFINED_P
18469 is true, the type is a user-defined type; otherwise it is a
18470 built-in type specified by a keyword. */
18473 cp_parser_set_decl_spec_type (cp_decl_specifier_seq
*decl_specs
,
18475 location_t location
,
18476 bool user_defined_p
)
18478 decl_specs
->any_specifiers_p
= true;
18480 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
18481 (with, for example, in "typedef int wchar_t;") we remember that
18482 this is what happened. In system headers, we ignore these
18483 declarations so that G++ can work with system headers that are not
18485 if (decl_specs
->specs
[(int) ds_typedef
]
18487 && (type_spec
== boolean_type_node
18488 || type_spec
== char16_type_node
18489 || type_spec
== char32_type_node
18490 || type_spec
== wchar_type_node
)
18491 && (decl_specs
->type
18492 || decl_specs
->specs
[(int) ds_long
]
18493 || decl_specs
->specs
[(int) ds_short
]
18494 || decl_specs
->specs
[(int) ds_unsigned
]
18495 || decl_specs
->specs
[(int) ds_signed
]))
18497 decl_specs
->redefined_builtin_type
= type_spec
;
18498 if (!decl_specs
->type
)
18500 decl_specs
->type
= type_spec
;
18501 decl_specs
->user_defined_type_p
= false;
18502 decl_specs
->type_location
= location
;
18505 else if (decl_specs
->type
)
18506 decl_specs
->multiple_types_p
= true;
18509 decl_specs
->type
= type_spec
;
18510 decl_specs
->user_defined_type_p
= user_defined_p
;
18511 decl_specs
->redefined_builtin_type
= NULL_TREE
;
18512 decl_specs
->type_location
= location
;
18516 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
18517 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
18520 cp_parser_friend_p (const cp_decl_specifier_seq
*decl_specifiers
)
18522 return decl_specifiers
->specs
[(int) ds_friend
] != 0;
18525 /* If the next token is of the indicated TYPE, consume it. Otherwise,
18526 issue an error message indicating that TOKEN_DESC was expected.
18528 Returns the token consumed, if the token had the appropriate type.
18529 Otherwise, returns NULL. */
18532 cp_parser_require (cp_parser
* parser
,
18533 enum cpp_ttype type
,
18534 const char* token_desc
)
18536 if (cp_lexer_next_token_is (parser
->lexer
, type
))
18537 return cp_lexer_consume_token (parser
->lexer
);
18540 /* Output the MESSAGE -- unless we're parsing tentatively. */
18541 if (!cp_parser_simulate_error (parser
))
18543 char *message
= concat ("expected ", token_desc
, NULL
);
18544 cp_parser_error (parser
, message
);
18551 /* An error message is produced if the next token is not '>'.
18552 All further tokens are skipped until the desired token is
18553 found or '{', '}', ';' or an unbalanced ')' or ']'. */
18556 cp_parser_skip_to_end_of_template_parameter_list (cp_parser
* parser
)
18558 /* Current level of '< ... >'. */
18559 unsigned level
= 0;
18560 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
18561 unsigned nesting_depth
= 0;
18563 /* Are we ready, yet? If not, issue error message. */
18564 if (cp_parser_require (parser
, CPP_GREATER
, "%<>%>"))
18567 /* Skip tokens until the desired token is found. */
18570 /* Peek at the next token. */
18571 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
18574 if (!nesting_depth
)
18579 if (cxx_dialect
== cxx98
)
18580 /* C++0x views the `>>' operator as two `>' tokens, but
18583 else if (!nesting_depth
&& level
-- == 0)
18585 /* We've hit a `>>' where the first `>' closes the
18586 template argument list, and the second `>' is
18587 spurious. Just consume the `>>' and stop; we've
18588 already produced at least one error. */
18589 cp_lexer_consume_token (parser
->lexer
);
18592 /* Fall through for C++0x, so we handle the second `>' in
18596 if (!nesting_depth
&& level
-- == 0)
18598 /* We've reached the token we want, consume it and stop. */
18599 cp_lexer_consume_token (parser
->lexer
);
18604 case CPP_OPEN_PAREN
:
18605 case CPP_OPEN_SQUARE
:
18609 case CPP_CLOSE_PAREN
:
18610 case CPP_CLOSE_SQUARE
:
18611 if (nesting_depth
-- == 0)
18616 case CPP_PRAGMA_EOL
:
18617 case CPP_SEMICOLON
:
18618 case CPP_OPEN_BRACE
:
18619 case CPP_CLOSE_BRACE
:
18620 /* The '>' was probably forgotten, don't look further. */
18627 /* Consume this token. */
18628 cp_lexer_consume_token (parser
->lexer
);
18632 /* If the next token is the indicated keyword, consume it. Otherwise,
18633 issue an error message indicating that TOKEN_DESC was expected.
18635 Returns the token consumed, if the token had the appropriate type.
18636 Otherwise, returns NULL. */
18639 cp_parser_require_keyword (cp_parser
* parser
,
18641 const char* token_desc
)
18643 cp_token
*token
= cp_parser_require (parser
, CPP_KEYWORD
, token_desc
);
18645 if (token
&& token
->keyword
!= keyword
)
18647 dyn_string_t error_msg
;
18649 /* Format the error message. */
18650 error_msg
= dyn_string_new (0);
18651 dyn_string_append_cstr (error_msg
, "expected ");
18652 dyn_string_append_cstr (error_msg
, token_desc
);
18653 cp_parser_error (parser
, error_msg
->s
);
18654 dyn_string_delete (error_msg
);
18661 /* Returns TRUE iff TOKEN is a token that can begin the body of a
18662 function-definition. */
18665 cp_parser_token_starts_function_definition_p (cp_token
* token
)
18667 return (/* An ordinary function-body begins with an `{'. */
18668 token
->type
== CPP_OPEN_BRACE
18669 /* A ctor-initializer begins with a `:'. */
18670 || token
->type
== CPP_COLON
18671 /* A function-try-block begins with `try'. */
18672 || token
->keyword
== RID_TRY
18673 /* The named return value extension begins with `return'. */
18674 || token
->keyword
== RID_RETURN
);
18677 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
18681 cp_parser_next_token_starts_class_definition_p (cp_parser
*parser
)
18685 token
= cp_lexer_peek_token (parser
->lexer
);
18686 return (token
->type
== CPP_OPEN_BRACE
|| token
->type
== CPP_COLON
);
18689 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
18690 C++0x) ending a template-argument. */
18693 cp_parser_next_token_ends_template_argument_p (cp_parser
*parser
)
18697 token
= cp_lexer_peek_token (parser
->lexer
);
18698 return (token
->type
== CPP_COMMA
18699 || token
->type
== CPP_GREATER
18700 || token
->type
== CPP_ELLIPSIS
18701 || ((cxx_dialect
!= cxx98
) && token
->type
== CPP_RSHIFT
));
18704 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
18705 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
18708 cp_parser_nth_token_starts_template_argument_list_p (cp_parser
* parser
,
18713 token
= cp_lexer_peek_nth_token (parser
->lexer
, n
);
18714 if (token
->type
== CPP_LESS
)
18716 /* Check for the sequence `<::' in the original code. It would be lexed as
18717 `[:', where `[' is a digraph, and there is no whitespace before
18719 if (token
->type
== CPP_OPEN_SQUARE
&& token
->flags
& DIGRAPH
)
18722 token2
= cp_lexer_peek_nth_token (parser
->lexer
, n
+1);
18723 if (token2
->type
== CPP_COLON
&& !(token2
->flags
& PREV_WHITE
))
18729 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
18730 or none_type otherwise. */
18732 static enum tag_types
18733 cp_parser_token_is_class_key (cp_token
* token
)
18735 switch (token
->keyword
)
18740 return record_type
;
18749 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
18752 cp_parser_check_class_key (enum tag_types class_key
, tree type
)
18754 if ((TREE_CODE (type
) == UNION_TYPE
) != (class_key
== union_type
))
18755 permerror (input_location
, "%qs tag used in naming %q#T",
18756 class_key
== union_type
? "union"
18757 : class_key
== record_type
? "struct" : "class",
18761 /* Issue an error message if DECL is redeclared with different
18762 access than its original declaration [class.access.spec/3].
18763 This applies to nested classes and nested class templates.
18767 cp_parser_check_access_in_redeclaration (tree decl
, location_t location
)
18769 if (!decl
|| !CLASS_TYPE_P (TREE_TYPE (decl
)))
18772 if ((TREE_PRIVATE (decl
)
18773 != (current_access_specifier
== access_private_node
))
18774 || (TREE_PROTECTED (decl
)
18775 != (current_access_specifier
== access_protected_node
)))
18776 error ("%H%qD redeclared with different access", &location
, decl
);
18779 /* Look for the `template' keyword, as a syntactic disambiguator.
18780 Return TRUE iff it is present, in which case it will be
18784 cp_parser_optional_template_keyword (cp_parser
*parser
)
18786 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
18788 /* The `template' keyword can only be used within templates;
18789 outside templates the parser can always figure out what is a
18790 template and what is not. */
18791 if (!processing_template_decl
)
18793 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
18794 error ("%H%<template%> (as a disambiguator) is only allowed "
18795 "within templates", &token
->location
);
18796 /* If this part of the token stream is rescanned, the same
18797 error message would be generated. So, we purge the token
18798 from the stream. */
18799 cp_lexer_purge_token (parser
->lexer
);
18804 /* Consume the `template' keyword. */
18805 cp_lexer_consume_token (parser
->lexer
);
18813 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
18814 set PARSER->SCOPE, and perform other related actions. */
18817 cp_parser_pre_parsed_nested_name_specifier (cp_parser
*parser
)
18820 struct tree_check
*check_value
;
18821 deferred_access_check
*chk
;
18822 VEC (deferred_access_check
,gc
) *checks
;
18824 /* Get the stored value. */
18825 check_value
= cp_lexer_consume_token (parser
->lexer
)->u
.tree_check_value
;
18826 /* Perform any access checks that were deferred. */
18827 checks
= check_value
->checks
;
18831 VEC_iterate (deferred_access_check
, checks
, i
, chk
) ;
18834 perform_or_defer_access_check (chk
->binfo
,
18839 /* Set the scope from the stored value. */
18840 parser
->scope
= check_value
->value
;
18841 parser
->qualifying_scope
= check_value
->qualifying_scope
;
18842 parser
->object_scope
= NULL_TREE
;
18845 /* Consume tokens up through a non-nested END token. Returns TRUE if we
18846 encounter the end of a block before what we were looking for. */
18849 cp_parser_cache_group (cp_parser
*parser
,
18850 enum cpp_ttype end
,
18855 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
18857 /* Abort a parenthesized expression if we encounter a semicolon. */
18858 if ((end
== CPP_CLOSE_PAREN
|| depth
== 0)
18859 && token
->type
== CPP_SEMICOLON
)
18861 /* If we've reached the end of the file, stop. */
18862 if (token
->type
== CPP_EOF
18863 || (end
!= CPP_PRAGMA_EOL
18864 && token
->type
== CPP_PRAGMA_EOL
))
18866 if (token
->type
== CPP_CLOSE_BRACE
&& depth
== 0)
18867 /* We've hit the end of an enclosing block, so there's been some
18868 kind of syntax error. */
18871 /* Consume the token. */
18872 cp_lexer_consume_token (parser
->lexer
);
18873 /* See if it starts a new group. */
18874 if (token
->type
== CPP_OPEN_BRACE
)
18876 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, depth
+ 1);
18877 /* In theory this should probably check end == '}', but
18878 cp_parser_save_member_function_body needs it to exit
18879 after either '}' or ')' when called with ')'. */
18883 else if (token
->type
== CPP_OPEN_PAREN
)
18885 cp_parser_cache_group (parser
, CPP_CLOSE_PAREN
, depth
+ 1);
18886 if (depth
== 0 && end
== CPP_CLOSE_PAREN
)
18889 else if (token
->type
== CPP_PRAGMA
)
18890 cp_parser_cache_group (parser
, CPP_PRAGMA_EOL
, depth
+ 1);
18891 else if (token
->type
== end
)
18896 /* Begin parsing tentatively. We always save tokens while parsing
18897 tentatively so that if the tentative parsing fails we can restore the
18901 cp_parser_parse_tentatively (cp_parser
* parser
)
18903 /* Enter a new parsing context. */
18904 parser
->context
= cp_parser_context_new (parser
->context
);
18905 /* Begin saving tokens. */
18906 cp_lexer_save_tokens (parser
->lexer
);
18907 /* In order to avoid repetitive access control error messages,
18908 access checks are queued up until we are no longer parsing
18910 push_deferring_access_checks (dk_deferred
);
18913 /* Commit to the currently active tentative parse. */
18916 cp_parser_commit_to_tentative_parse (cp_parser
* parser
)
18918 cp_parser_context
*context
;
18921 /* Mark all of the levels as committed. */
18922 lexer
= parser
->lexer
;
18923 for (context
= parser
->context
; context
->next
; context
= context
->next
)
18925 if (context
->status
== CP_PARSER_STATUS_KIND_COMMITTED
)
18927 context
->status
= CP_PARSER_STATUS_KIND_COMMITTED
;
18928 while (!cp_lexer_saving_tokens (lexer
))
18929 lexer
= lexer
->next
;
18930 cp_lexer_commit_tokens (lexer
);
18934 /* Abort the currently active tentative parse. All consumed tokens
18935 will be rolled back, and no diagnostics will be issued. */
18938 cp_parser_abort_tentative_parse (cp_parser
* parser
)
18940 cp_parser_simulate_error (parser
);
18941 /* Now, pretend that we want to see if the construct was
18942 successfully parsed. */
18943 cp_parser_parse_definitely (parser
);
18946 /* Stop parsing tentatively. If a parse error has occurred, restore the
18947 token stream. Otherwise, commit to the tokens we have consumed.
18948 Returns true if no error occurred; false otherwise. */
18951 cp_parser_parse_definitely (cp_parser
* parser
)
18953 bool error_occurred
;
18954 cp_parser_context
*context
;
18956 /* Remember whether or not an error occurred, since we are about to
18957 destroy that information. */
18958 error_occurred
= cp_parser_error_occurred (parser
);
18959 /* Remove the topmost context from the stack. */
18960 context
= parser
->context
;
18961 parser
->context
= context
->next
;
18962 /* If no parse errors occurred, commit to the tentative parse. */
18963 if (!error_occurred
)
18965 /* Commit to the tokens read tentatively, unless that was
18967 if (context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
)
18968 cp_lexer_commit_tokens (parser
->lexer
);
18970 pop_to_parent_deferring_access_checks ();
18972 /* Otherwise, if errors occurred, roll back our state so that things
18973 are just as they were before we began the tentative parse. */
18976 cp_lexer_rollback_tokens (parser
->lexer
);
18977 pop_deferring_access_checks ();
18979 /* Add the context to the front of the free list. */
18980 context
->next
= cp_parser_context_free_list
;
18981 cp_parser_context_free_list
= context
;
18983 return !error_occurred
;
18986 /* Returns true if we are parsing tentatively and are not committed to
18987 this tentative parse. */
18990 cp_parser_uncommitted_to_tentative_parse_p (cp_parser
* parser
)
18992 return (cp_parser_parsing_tentatively (parser
)
18993 && parser
->context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
);
18996 /* Returns nonzero iff an error has occurred during the most recent
18997 tentative parse. */
19000 cp_parser_error_occurred (cp_parser
* parser
)
19002 return (cp_parser_parsing_tentatively (parser
)
19003 && parser
->context
->status
== CP_PARSER_STATUS_KIND_ERROR
);
19006 /* Returns nonzero if GNU extensions are allowed. */
19009 cp_parser_allow_gnu_extensions_p (cp_parser
* parser
)
19011 return parser
->allow_gnu_extensions_p
;
19014 /* Objective-C++ Productions */
19017 /* Parse an Objective-C expression, which feeds into a primary-expression
19021 objc-message-expression
19022 objc-string-literal
19023 objc-encode-expression
19024 objc-protocol-expression
19025 objc-selector-expression
19027 Returns a tree representation of the expression. */
19030 cp_parser_objc_expression (cp_parser
* parser
)
19032 /* Try to figure out what kind of declaration is present. */
19033 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
19037 case CPP_OPEN_SQUARE
:
19038 return cp_parser_objc_message_expression (parser
);
19040 case CPP_OBJC_STRING
:
19041 kwd
= cp_lexer_consume_token (parser
->lexer
);
19042 return objc_build_string_object (kwd
->u
.value
);
19045 switch (kwd
->keyword
)
19047 case RID_AT_ENCODE
:
19048 return cp_parser_objc_encode_expression (parser
);
19050 case RID_AT_PROTOCOL
:
19051 return cp_parser_objc_protocol_expression (parser
);
19053 case RID_AT_SELECTOR
:
19054 return cp_parser_objc_selector_expression (parser
);
19060 error ("%Hmisplaced %<@%D%> Objective-C++ construct",
19061 &kwd
->location
, kwd
->u
.value
);
19062 cp_parser_skip_to_end_of_block_or_statement (parser
);
19065 return error_mark_node
;
19068 /* Parse an Objective-C message expression.
19070 objc-message-expression:
19071 [ objc-message-receiver objc-message-args ]
19073 Returns a representation of an Objective-C message. */
19076 cp_parser_objc_message_expression (cp_parser
* parser
)
19078 tree receiver
, messageargs
;
19080 cp_lexer_consume_token (parser
->lexer
); /* Eat '['. */
19081 receiver
= cp_parser_objc_message_receiver (parser
);
19082 messageargs
= cp_parser_objc_message_args (parser
);
19083 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, "%<]%>");
19085 return objc_build_message_expr (build_tree_list (receiver
, messageargs
));
19088 /* Parse an objc-message-receiver.
19090 objc-message-receiver:
19092 simple-type-specifier
19094 Returns a representation of the type or expression. */
19097 cp_parser_objc_message_receiver (cp_parser
* parser
)
19101 /* An Objective-C message receiver may be either (1) a type
19102 or (2) an expression. */
19103 cp_parser_parse_tentatively (parser
);
19104 rcv
= cp_parser_expression (parser
, false, NULL
);
19106 if (cp_parser_parse_definitely (parser
))
19109 rcv
= cp_parser_simple_type_specifier (parser
,
19110 /*decl_specs=*/NULL
,
19111 CP_PARSER_FLAGS_NONE
);
19113 return objc_get_class_reference (rcv
);
19116 /* Parse the arguments and selectors comprising an Objective-C message.
19121 objc-selector-args , objc-comma-args
19123 objc-selector-args:
19124 objc-selector [opt] : assignment-expression
19125 objc-selector-args objc-selector [opt] : assignment-expression
19128 assignment-expression
19129 objc-comma-args , assignment-expression
19131 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
19132 selector arguments and TREE_VALUE containing a list of comma
19136 cp_parser_objc_message_args (cp_parser
* parser
)
19138 tree sel_args
= NULL_TREE
, addl_args
= NULL_TREE
;
19139 bool maybe_unary_selector_p
= true;
19140 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19142 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
)
19144 tree selector
= NULL_TREE
, arg
;
19146 if (token
->type
!= CPP_COLON
)
19147 selector
= cp_parser_objc_selector (parser
);
19149 /* Detect if we have a unary selector. */
19150 if (maybe_unary_selector_p
19151 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
19152 return build_tree_list (selector
, NULL_TREE
);
19154 maybe_unary_selector_p
= false;
19155 cp_parser_require (parser
, CPP_COLON
, "%<:%>");
19156 arg
= cp_parser_assignment_expression (parser
, false, NULL
);
19159 = chainon (sel_args
,
19160 build_tree_list (selector
, arg
));
19162 token
= cp_lexer_peek_token (parser
->lexer
);
19165 /* Handle non-selector arguments, if any. */
19166 while (token
->type
== CPP_COMMA
)
19170 cp_lexer_consume_token (parser
->lexer
);
19171 arg
= cp_parser_assignment_expression (parser
, false, NULL
);
19174 = chainon (addl_args
,
19175 build_tree_list (NULL_TREE
, arg
));
19177 token
= cp_lexer_peek_token (parser
->lexer
);
19180 return build_tree_list (sel_args
, addl_args
);
19183 /* Parse an Objective-C encode expression.
19185 objc-encode-expression:
19186 @encode objc-typename
19188 Returns an encoded representation of the type argument. */
19191 cp_parser_objc_encode_expression (cp_parser
* parser
)
19196 cp_lexer_consume_token (parser
->lexer
); /* Eat '@encode'. */
19197 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
19198 token
= cp_lexer_peek_token (parser
->lexer
);
19199 type
= complete_type (cp_parser_type_id (parser
));
19200 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
19204 error ("%H%<@encode%> must specify a type as an argument",
19206 return error_mark_node
;
19209 return objc_build_encode_expr (type
);
19212 /* Parse an Objective-C @defs expression. */
19215 cp_parser_objc_defs_expression (cp_parser
*parser
)
19219 cp_lexer_consume_token (parser
->lexer
); /* Eat '@defs'. */
19220 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
19221 name
= cp_parser_identifier (parser
);
19222 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
19224 return objc_get_class_ivars (name
);
19227 /* Parse an Objective-C protocol expression.
19229 objc-protocol-expression:
19230 @protocol ( identifier )
19232 Returns a representation of the protocol expression. */
19235 cp_parser_objc_protocol_expression (cp_parser
* parser
)
19239 cp_lexer_consume_token (parser
->lexer
); /* Eat '@protocol'. */
19240 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
19241 proto
= cp_parser_identifier (parser
);
19242 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
19244 return objc_build_protocol_expr (proto
);
19247 /* Parse an Objective-C selector expression.
19249 objc-selector-expression:
19250 @selector ( objc-method-signature )
19252 objc-method-signature:
19258 objc-selector-seq objc-selector :
19260 Returns a representation of the method selector. */
19263 cp_parser_objc_selector_expression (cp_parser
* parser
)
19265 tree sel_seq
= NULL_TREE
;
19266 bool maybe_unary_selector_p
= true;
19269 cp_lexer_consume_token (parser
->lexer
); /* Eat '@selector'. */
19270 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
19271 token
= cp_lexer_peek_token (parser
->lexer
);
19273 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
19274 || token
->type
== CPP_SCOPE
)
19276 tree selector
= NULL_TREE
;
19278 if (token
->type
!= CPP_COLON
19279 || token
->type
== CPP_SCOPE
)
19280 selector
= cp_parser_objc_selector (parser
);
19282 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
)
19283 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_SCOPE
))
19285 /* Detect if we have a unary selector. */
19286 if (maybe_unary_selector_p
)
19288 sel_seq
= selector
;
19289 goto finish_selector
;
19293 cp_parser_error (parser
, "expected %<:%>");
19296 maybe_unary_selector_p
= false;
19297 token
= cp_lexer_consume_token (parser
->lexer
);
19299 if (token
->type
== CPP_SCOPE
)
19302 = chainon (sel_seq
,
19303 build_tree_list (selector
, NULL_TREE
));
19305 = chainon (sel_seq
,
19306 build_tree_list (NULL_TREE
, NULL_TREE
));
19310 = chainon (sel_seq
,
19311 build_tree_list (selector
, NULL_TREE
));
19313 token
= cp_lexer_peek_token (parser
->lexer
);
19317 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
19319 return objc_build_selector_expr (sel_seq
);
19322 /* Parse a list of identifiers.
19324 objc-identifier-list:
19326 objc-identifier-list , identifier
19328 Returns a TREE_LIST of identifier nodes. */
19331 cp_parser_objc_identifier_list (cp_parser
* parser
)
19333 tree list
= build_tree_list (NULL_TREE
, cp_parser_identifier (parser
));
19334 cp_token
*sep
= cp_lexer_peek_token (parser
->lexer
);
19336 while (sep
->type
== CPP_COMMA
)
19338 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
19339 list
= chainon (list
,
19340 build_tree_list (NULL_TREE
,
19341 cp_parser_identifier (parser
)));
19342 sep
= cp_lexer_peek_token (parser
->lexer
);
19348 /* Parse an Objective-C alias declaration.
19350 objc-alias-declaration:
19351 @compatibility_alias identifier identifier ;
19353 This function registers the alias mapping with the Objective-C front end.
19354 It returns nothing. */
19357 cp_parser_objc_alias_declaration (cp_parser
* parser
)
19361 cp_lexer_consume_token (parser
->lexer
); /* Eat '@compatibility_alias'. */
19362 alias
= cp_parser_identifier (parser
);
19363 orig
= cp_parser_identifier (parser
);
19364 objc_declare_alias (alias
, orig
);
19365 cp_parser_consume_semicolon_at_end_of_statement (parser
);
19368 /* Parse an Objective-C class forward-declaration.
19370 objc-class-declaration:
19371 @class objc-identifier-list ;
19373 The function registers the forward declarations with the Objective-C
19374 front end. It returns nothing. */
19377 cp_parser_objc_class_declaration (cp_parser
* parser
)
19379 cp_lexer_consume_token (parser
->lexer
); /* Eat '@class'. */
19380 objc_declare_class (cp_parser_objc_identifier_list (parser
));
19381 cp_parser_consume_semicolon_at_end_of_statement (parser
);
19384 /* Parse a list of Objective-C protocol references.
19386 objc-protocol-refs-opt:
19387 objc-protocol-refs [opt]
19389 objc-protocol-refs:
19390 < objc-identifier-list >
19392 Returns a TREE_LIST of identifiers, if any. */
19395 cp_parser_objc_protocol_refs_opt (cp_parser
* parser
)
19397 tree protorefs
= NULL_TREE
;
19399 if(cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
19401 cp_lexer_consume_token (parser
->lexer
); /* Eat '<'. */
19402 protorefs
= cp_parser_objc_identifier_list (parser
);
19403 cp_parser_require (parser
, CPP_GREATER
, "%<>%>");
19409 /* Parse a Objective-C visibility specification. */
19412 cp_parser_objc_visibility_spec (cp_parser
* parser
)
19414 cp_token
*vis
= cp_lexer_peek_token (parser
->lexer
);
19416 switch (vis
->keyword
)
19418 case RID_AT_PRIVATE
:
19419 objc_set_visibility (2);
19421 case RID_AT_PROTECTED
:
19422 objc_set_visibility (0);
19424 case RID_AT_PUBLIC
:
19425 objc_set_visibility (1);
19431 /* Eat '@private'/'@protected'/'@public'. */
19432 cp_lexer_consume_token (parser
->lexer
);
19435 /* Parse an Objective-C method type. */
19438 cp_parser_objc_method_type (cp_parser
* parser
)
19440 objc_set_method_type
19441 (cp_lexer_consume_token (parser
->lexer
)->type
== CPP_PLUS
19446 /* Parse an Objective-C protocol qualifier. */
19449 cp_parser_objc_protocol_qualifiers (cp_parser
* parser
)
19451 tree quals
= NULL_TREE
, node
;
19452 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19454 node
= token
->u
.value
;
19456 while (node
&& TREE_CODE (node
) == IDENTIFIER_NODE
19457 && (node
== ridpointers
[(int) RID_IN
]
19458 || node
== ridpointers
[(int) RID_OUT
]
19459 || node
== ridpointers
[(int) RID_INOUT
]
19460 || node
== ridpointers
[(int) RID_BYCOPY
]
19461 || node
== ridpointers
[(int) RID_BYREF
]
19462 || node
== ridpointers
[(int) RID_ONEWAY
]))
19464 quals
= tree_cons (NULL_TREE
, node
, quals
);
19465 cp_lexer_consume_token (parser
->lexer
);
19466 token
= cp_lexer_peek_token (parser
->lexer
);
19467 node
= token
->u
.value
;
19473 /* Parse an Objective-C typename. */
19476 cp_parser_objc_typename (cp_parser
* parser
)
19478 tree type_name
= NULL_TREE
;
19480 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
19482 tree proto_quals
, cp_type
= NULL_TREE
;
19484 cp_lexer_consume_token (parser
->lexer
); /* Eat '('. */
19485 proto_quals
= cp_parser_objc_protocol_qualifiers (parser
);
19487 /* An ObjC type name may consist of just protocol qualifiers, in which
19488 case the type shall default to 'id'. */
19489 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
19490 cp_type
= cp_parser_type_id (parser
);
19492 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
19493 type_name
= build_tree_list (proto_quals
, cp_type
);
19499 /* Check to see if TYPE refers to an Objective-C selector name. */
19502 cp_parser_objc_selector_p (enum cpp_ttype type
)
19504 return (type
== CPP_NAME
|| type
== CPP_KEYWORD
19505 || type
== CPP_AND_AND
|| type
== CPP_AND_EQ
|| type
== CPP_AND
19506 || type
== CPP_OR
|| type
== CPP_COMPL
|| type
== CPP_NOT
19507 || type
== CPP_NOT_EQ
|| type
== CPP_OR_OR
|| type
== CPP_OR_EQ
19508 || type
== CPP_XOR
|| type
== CPP_XOR_EQ
);
19511 /* Parse an Objective-C selector. */
19514 cp_parser_objc_selector (cp_parser
* parser
)
19516 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
19518 if (!cp_parser_objc_selector_p (token
->type
))
19520 error ("%Hinvalid Objective-C++ selector name", &token
->location
);
19521 return error_mark_node
;
19524 /* C++ operator names are allowed to appear in ObjC selectors. */
19525 switch (token
->type
)
19527 case CPP_AND_AND
: return get_identifier ("and");
19528 case CPP_AND_EQ
: return get_identifier ("and_eq");
19529 case CPP_AND
: return get_identifier ("bitand");
19530 case CPP_OR
: return get_identifier ("bitor");
19531 case CPP_COMPL
: return get_identifier ("compl");
19532 case CPP_NOT
: return get_identifier ("not");
19533 case CPP_NOT_EQ
: return get_identifier ("not_eq");
19534 case CPP_OR_OR
: return get_identifier ("or");
19535 case CPP_OR_EQ
: return get_identifier ("or_eq");
19536 case CPP_XOR
: return get_identifier ("xor");
19537 case CPP_XOR_EQ
: return get_identifier ("xor_eq");
19538 default: return token
->u
.value
;
19542 /* Parse an Objective-C params list. */
19545 cp_parser_objc_method_keyword_params (cp_parser
* parser
)
19547 tree params
= NULL_TREE
;
19548 bool maybe_unary_selector_p
= true;
19549 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19551 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
)
19553 tree selector
= NULL_TREE
, type_name
, identifier
;
19555 if (token
->type
!= CPP_COLON
)
19556 selector
= cp_parser_objc_selector (parser
);
19558 /* Detect if we have a unary selector. */
19559 if (maybe_unary_selector_p
19560 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
19563 maybe_unary_selector_p
= false;
19564 cp_parser_require (parser
, CPP_COLON
, "%<:%>");
19565 type_name
= cp_parser_objc_typename (parser
);
19566 identifier
= cp_parser_identifier (parser
);
19570 objc_build_keyword_decl (selector
,
19574 token
= cp_lexer_peek_token (parser
->lexer
);
19580 /* Parse the non-keyword Objective-C params. */
19583 cp_parser_objc_method_tail_params_opt (cp_parser
* parser
, bool *ellipsisp
)
19585 tree params
= make_node (TREE_LIST
);
19586 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19587 *ellipsisp
= false; /* Initially, assume no ellipsis. */
19589 while (token
->type
== CPP_COMMA
)
19591 cp_parameter_declarator
*parmdecl
;
19594 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
19595 token
= cp_lexer_peek_token (parser
->lexer
);
19597 if (token
->type
== CPP_ELLIPSIS
)
19599 cp_lexer_consume_token (parser
->lexer
); /* Eat '...'. */
19604 parmdecl
= cp_parser_parameter_declaration (parser
, false, NULL
);
19605 parm
= grokdeclarator (parmdecl
->declarator
,
19606 &parmdecl
->decl_specifiers
,
19607 PARM
, /*initialized=*/0,
19608 /*attrlist=*/NULL
);
19610 chainon (params
, build_tree_list (NULL_TREE
, parm
));
19611 token
= cp_lexer_peek_token (parser
->lexer
);
19617 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
19620 cp_parser_objc_interstitial_code (cp_parser
* parser
)
19622 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19624 /* If the next token is `extern' and the following token is a string
19625 literal, then we have a linkage specification. */
19626 if (token
->keyword
== RID_EXTERN
19627 && cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser
->lexer
, 2)))
19628 cp_parser_linkage_specification (parser
);
19629 /* Handle #pragma, if any. */
19630 else if (token
->type
== CPP_PRAGMA
)
19631 cp_parser_pragma (parser
, pragma_external
);
19632 /* Allow stray semicolons. */
19633 else if (token
->type
== CPP_SEMICOLON
)
19634 cp_lexer_consume_token (parser
->lexer
);
19635 /* Finally, try to parse a block-declaration, or a function-definition. */
19637 cp_parser_block_declaration (parser
, /*statement_p=*/false);
19640 /* Parse a method signature. */
19643 cp_parser_objc_method_signature (cp_parser
* parser
)
19645 tree rettype
, kwdparms
, optparms
;
19646 bool ellipsis
= false;
19648 cp_parser_objc_method_type (parser
);
19649 rettype
= cp_parser_objc_typename (parser
);
19650 kwdparms
= cp_parser_objc_method_keyword_params (parser
);
19651 optparms
= cp_parser_objc_method_tail_params_opt (parser
, &ellipsis
);
19653 return objc_build_method_signature (rettype
, kwdparms
, optparms
, ellipsis
);
19656 /* Pars an Objective-C method prototype list. */
19659 cp_parser_objc_method_prototype_list (cp_parser
* parser
)
19661 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19663 while (token
->keyword
!= RID_AT_END
)
19665 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
)
19667 objc_add_method_declaration
19668 (cp_parser_objc_method_signature (parser
));
19669 cp_parser_consume_semicolon_at_end_of_statement (parser
);
19672 /* Allow for interspersed non-ObjC++ code. */
19673 cp_parser_objc_interstitial_code (parser
);
19675 token
= cp_lexer_peek_token (parser
->lexer
);
19678 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
19679 objc_finish_interface ();
19682 /* Parse an Objective-C method definition list. */
19685 cp_parser_objc_method_definition_list (cp_parser
* parser
)
19687 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19689 while (token
->keyword
!= RID_AT_END
)
19693 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
)
19695 push_deferring_access_checks (dk_deferred
);
19696 objc_start_method_definition
19697 (cp_parser_objc_method_signature (parser
));
19699 /* For historical reasons, we accept an optional semicolon. */
19700 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
19701 cp_lexer_consume_token (parser
->lexer
);
19703 perform_deferred_access_checks ();
19704 stop_deferring_access_checks ();
19705 meth
= cp_parser_function_definition_after_declarator (parser
,
19707 pop_deferring_access_checks ();
19708 objc_finish_method_definition (meth
);
19711 /* Allow for interspersed non-ObjC++ code. */
19712 cp_parser_objc_interstitial_code (parser
);
19714 token
= cp_lexer_peek_token (parser
->lexer
);
19717 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
19718 objc_finish_implementation ();
19721 /* Parse Objective-C ivars. */
19724 cp_parser_objc_class_ivars (cp_parser
* parser
)
19726 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19728 if (token
->type
!= CPP_OPEN_BRACE
)
19729 return; /* No ivars specified. */
19731 cp_lexer_consume_token (parser
->lexer
); /* Eat '{'. */
19732 token
= cp_lexer_peek_token (parser
->lexer
);
19734 while (token
->type
!= CPP_CLOSE_BRACE
)
19736 cp_decl_specifier_seq declspecs
;
19737 int decl_class_or_enum_p
;
19738 tree prefix_attributes
;
19740 cp_parser_objc_visibility_spec (parser
);
19742 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
19745 cp_parser_decl_specifier_seq (parser
,
19746 CP_PARSER_FLAGS_OPTIONAL
,
19748 &decl_class_or_enum_p
);
19749 prefix_attributes
= declspecs
.attributes
;
19750 declspecs
.attributes
= NULL_TREE
;
19752 /* Keep going until we hit the `;' at the end of the
19754 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
19756 tree width
= NULL_TREE
, attributes
, first_attribute
, decl
;
19757 cp_declarator
*declarator
= NULL
;
19758 int ctor_dtor_or_conv_p
;
19760 /* Check for a (possibly unnamed) bitfield declaration. */
19761 token
= cp_lexer_peek_token (parser
->lexer
);
19762 if (token
->type
== CPP_COLON
)
19765 if (token
->type
== CPP_NAME
19766 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
19769 /* Get the name of the bitfield. */
19770 declarator
= make_id_declarator (NULL_TREE
,
19771 cp_parser_identifier (parser
),
19775 cp_lexer_consume_token (parser
->lexer
); /* Eat ':'. */
19776 /* Get the width of the bitfield. */
19778 = cp_parser_constant_expression (parser
,
19779 /*allow_non_constant=*/false,
19784 /* Parse the declarator. */
19786 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
19787 &ctor_dtor_or_conv_p
,
19788 /*parenthesized_p=*/NULL
,
19789 /*member_p=*/false);
19792 /* Look for attributes that apply to the ivar. */
19793 attributes
= cp_parser_attributes_opt (parser
);
19794 /* Remember which attributes are prefix attributes and
19796 first_attribute
= attributes
;
19797 /* Combine the attributes. */
19798 attributes
= chainon (prefix_attributes
, attributes
);
19801 /* Create the bitfield declaration. */
19802 decl
= grokbitfield (declarator
, &declspecs
,
19806 decl
= grokfield (declarator
, &declspecs
,
19807 NULL_TREE
, /*init_const_expr_p=*/false,
19808 NULL_TREE
, attributes
);
19810 /* Add the instance variable. */
19811 objc_add_instance_variable (decl
);
19813 /* Reset PREFIX_ATTRIBUTES. */
19814 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
19815 attributes
= TREE_CHAIN (attributes
);
19817 TREE_CHAIN (attributes
) = NULL_TREE
;
19819 token
= cp_lexer_peek_token (parser
->lexer
);
19821 if (token
->type
== CPP_COMMA
)
19823 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
19829 cp_parser_consume_semicolon_at_end_of_statement (parser
);
19830 token
= cp_lexer_peek_token (parser
->lexer
);
19833 cp_lexer_consume_token (parser
->lexer
); /* Eat '}'. */
19834 /* For historical reasons, we accept an optional semicolon. */
19835 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
19836 cp_lexer_consume_token (parser
->lexer
);
19839 /* Parse an Objective-C protocol declaration. */
19842 cp_parser_objc_protocol_declaration (cp_parser
* parser
)
19844 tree proto
, protorefs
;
19847 cp_lexer_consume_token (parser
->lexer
); /* Eat '@protocol'. */
19848 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
19850 tok
= cp_lexer_peek_token (parser
->lexer
);
19851 error ("%Hidentifier expected after %<@protocol%>", &tok
->location
);
19855 /* See if we have a forward declaration or a definition. */
19856 tok
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
19858 /* Try a forward declaration first. */
19859 if (tok
->type
== CPP_COMMA
|| tok
->type
== CPP_SEMICOLON
)
19861 objc_declare_protocols (cp_parser_objc_identifier_list (parser
));
19863 cp_parser_consume_semicolon_at_end_of_statement (parser
);
19866 /* Ok, we got a full-fledged definition (or at least should). */
19869 proto
= cp_parser_identifier (parser
);
19870 protorefs
= cp_parser_objc_protocol_refs_opt (parser
);
19871 objc_start_protocol (proto
, protorefs
);
19872 cp_parser_objc_method_prototype_list (parser
);
19876 /* Parse an Objective-C superclass or category. */
19879 cp_parser_objc_superclass_or_category (cp_parser
*parser
, tree
*super
,
19882 cp_token
*next
= cp_lexer_peek_token (parser
->lexer
);
19884 *super
= *categ
= NULL_TREE
;
19885 if (next
->type
== CPP_COLON
)
19887 cp_lexer_consume_token (parser
->lexer
); /* Eat ':'. */
19888 *super
= cp_parser_identifier (parser
);
19890 else if (next
->type
== CPP_OPEN_PAREN
)
19892 cp_lexer_consume_token (parser
->lexer
); /* Eat '('. */
19893 *categ
= cp_parser_identifier (parser
);
19894 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
19898 /* Parse an Objective-C class interface. */
19901 cp_parser_objc_class_interface (cp_parser
* parser
)
19903 tree name
, super
, categ
, protos
;
19905 cp_lexer_consume_token (parser
->lexer
); /* Eat '@interface'. */
19906 name
= cp_parser_identifier (parser
);
19907 cp_parser_objc_superclass_or_category (parser
, &super
, &categ
);
19908 protos
= cp_parser_objc_protocol_refs_opt (parser
);
19910 /* We have either a class or a category on our hands. */
19912 objc_start_category_interface (name
, categ
, protos
);
19915 objc_start_class_interface (name
, super
, protos
);
19916 /* Handle instance variable declarations, if any. */
19917 cp_parser_objc_class_ivars (parser
);
19918 objc_continue_interface ();
19921 cp_parser_objc_method_prototype_list (parser
);
19924 /* Parse an Objective-C class implementation. */
19927 cp_parser_objc_class_implementation (cp_parser
* parser
)
19929 tree name
, super
, categ
;
19931 cp_lexer_consume_token (parser
->lexer
); /* Eat '@implementation'. */
19932 name
= cp_parser_identifier (parser
);
19933 cp_parser_objc_superclass_or_category (parser
, &super
, &categ
);
19935 /* We have either a class or a category on our hands. */
19937 objc_start_category_implementation (name
, categ
);
19940 objc_start_class_implementation (name
, super
);
19941 /* Handle instance variable declarations, if any. */
19942 cp_parser_objc_class_ivars (parser
);
19943 objc_continue_implementation ();
19946 cp_parser_objc_method_definition_list (parser
);
19949 /* Consume the @end token and finish off the implementation. */
19952 cp_parser_objc_end_implementation (cp_parser
* parser
)
19954 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
19955 objc_finish_implementation ();
19958 /* Parse an Objective-C declaration. */
19961 cp_parser_objc_declaration (cp_parser
* parser
)
19963 /* Try to figure out what kind of declaration is present. */
19964 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
19966 switch (kwd
->keyword
)
19969 cp_parser_objc_alias_declaration (parser
);
19972 cp_parser_objc_class_declaration (parser
);
19974 case RID_AT_PROTOCOL
:
19975 cp_parser_objc_protocol_declaration (parser
);
19977 case RID_AT_INTERFACE
:
19978 cp_parser_objc_class_interface (parser
);
19980 case RID_AT_IMPLEMENTATION
:
19981 cp_parser_objc_class_implementation (parser
);
19984 cp_parser_objc_end_implementation (parser
);
19987 error ("%Hmisplaced %<@%D%> Objective-C++ construct",
19988 &kwd
->location
, kwd
->u
.value
);
19989 cp_parser_skip_to_end_of_block_or_statement (parser
);
19993 /* Parse an Objective-C try-catch-finally statement.
19995 objc-try-catch-finally-stmt:
19996 @try compound-statement objc-catch-clause-seq [opt]
19997 objc-finally-clause [opt]
19999 objc-catch-clause-seq:
20000 objc-catch-clause objc-catch-clause-seq [opt]
20003 @catch ( exception-declaration ) compound-statement
20005 objc-finally-clause
20006 @finally compound-statement
20008 Returns NULL_TREE. */
20011 cp_parser_objc_try_catch_finally_statement (cp_parser
*parser
) {
20012 location_t location
;
20015 cp_parser_require_keyword (parser
, RID_AT_TRY
, "%<@try%>");
20016 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
20017 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
20018 node, lest it get absorbed into the surrounding block. */
20019 stmt
= push_stmt_list ();
20020 cp_parser_compound_statement (parser
, NULL
, false);
20021 objc_begin_try_stmt (location
, pop_stmt_list (stmt
));
20023 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_CATCH
))
20025 cp_parameter_declarator
*parmdecl
;
20028 cp_lexer_consume_token (parser
->lexer
);
20029 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
20030 parmdecl
= cp_parser_parameter_declaration (parser
, false, NULL
);
20031 parm
= grokdeclarator (parmdecl
->declarator
,
20032 &parmdecl
->decl_specifiers
,
20033 PARM
, /*initialized=*/0,
20034 /*attrlist=*/NULL
);
20035 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
20036 objc_begin_catch_clause (parm
);
20037 cp_parser_compound_statement (parser
, NULL
, false);
20038 objc_finish_catch_clause ();
20041 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_FINALLY
))
20043 cp_lexer_consume_token (parser
->lexer
);
20044 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
20045 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
20046 node, lest it get absorbed into the surrounding block. */
20047 stmt
= push_stmt_list ();
20048 cp_parser_compound_statement (parser
, NULL
, false);
20049 objc_build_finally_clause (location
, pop_stmt_list (stmt
));
20052 return objc_finish_try_stmt ();
20055 /* Parse an Objective-C synchronized statement.
20057 objc-synchronized-stmt:
20058 @synchronized ( expression ) compound-statement
20060 Returns NULL_TREE. */
20063 cp_parser_objc_synchronized_statement (cp_parser
*parser
) {
20064 location_t location
;
20067 cp_parser_require_keyword (parser
, RID_AT_SYNCHRONIZED
, "%<@synchronized%>");
20069 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
20070 cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>");
20071 lock
= cp_parser_expression (parser
, false, NULL
);
20072 cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>");
20074 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
20075 node, lest it get absorbed into the surrounding block. */
20076 stmt
= push_stmt_list ();
20077 cp_parser_compound_statement (parser
, NULL
, false);
20079 return objc_build_synchronized (location
, lock
, pop_stmt_list (stmt
));
20082 /* Parse an Objective-C throw statement.
20085 @throw assignment-expression [opt] ;
20087 Returns a constructed '@throw' statement. */
20090 cp_parser_objc_throw_statement (cp_parser
*parser
) {
20091 tree expr
= NULL_TREE
;
20093 cp_parser_require_keyword (parser
, RID_AT_THROW
, "%<@throw%>");
20095 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
20096 expr
= cp_parser_assignment_expression (parser
, false, NULL
);
20098 cp_parser_consume_semicolon_at_end_of_statement (parser
);
20100 return objc_build_throw_stmt (expr
);
20103 /* Parse an Objective-C statement. */
20106 cp_parser_objc_statement (cp_parser
* parser
) {
20107 /* Try to figure out what kind of declaration is present. */
20108 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
20110 switch (kwd
->keyword
)
20113 return cp_parser_objc_try_catch_finally_statement (parser
);
20114 case RID_AT_SYNCHRONIZED
:
20115 return cp_parser_objc_synchronized_statement (parser
);
20117 return cp_parser_objc_throw_statement (parser
);
20119 error ("%Hmisplaced %<@%D%> Objective-C++ construct",
20120 &kwd
->location
, kwd
->u
.value
);
20121 cp_parser_skip_to_end_of_block_or_statement (parser
);
20124 return error_mark_node
;
20127 /* OpenMP 2.5 parsing routines. */
20129 /* Returns name of the next clause.
20130 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
20131 the token is not consumed. Otherwise appropriate pragma_omp_clause is
20132 returned and the token is consumed. */
20134 static pragma_omp_clause
20135 cp_parser_omp_clause_name (cp_parser
*parser
)
20137 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
20139 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_IF
))
20140 result
= PRAGMA_OMP_CLAUSE_IF
;
20141 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_DEFAULT
))
20142 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
20143 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_PRIVATE
))
20144 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
20145 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
20147 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
20148 const char *p
= IDENTIFIER_POINTER (id
);
20153 if (!strcmp ("collapse", p
))
20154 result
= PRAGMA_OMP_CLAUSE_COLLAPSE
;
20155 else if (!strcmp ("copyin", p
))
20156 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
20157 else if (!strcmp ("copyprivate", p
))
20158 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
20161 if (!strcmp ("firstprivate", p
))
20162 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
20165 if (!strcmp ("lastprivate", p
))
20166 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
20169 if (!strcmp ("nowait", p
))
20170 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
20171 else if (!strcmp ("num_threads", p
))
20172 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
20175 if (!strcmp ("ordered", p
))
20176 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
20179 if (!strcmp ("reduction", p
))
20180 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
20183 if (!strcmp ("schedule", p
))
20184 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
20185 else if (!strcmp ("shared", p
))
20186 result
= PRAGMA_OMP_CLAUSE_SHARED
;
20189 if (!strcmp ("untied", p
))
20190 result
= PRAGMA_OMP_CLAUSE_UNTIED
;
20195 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
20196 cp_lexer_consume_token (parser
->lexer
);
20201 /* Validate that a clause of the given type does not already exist. */
20204 check_no_duplicate_clause (tree clauses
, enum omp_clause_code code
,
20205 const char *name
, location_t location
)
20209 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
20210 if (OMP_CLAUSE_CODE (c
) == code
)
20212 error ("%Htoo many %qs clauses", &location
, name
);
20220 variable-list , identifier
20222 In addition, we match a closing parenthesis. An opening parenthesis
20223 will have been consumed by the caller.
20225 If KIND is nonzero, create the appropriate node and install the decl
20226 in OMP_CLAUSE_DECL and add the node to the head of the list.
20228 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
20229 return the list created. */
20232 cp_parser_omp_var_list_no_open (cp_parser
*parser
, enum omp_clause_code kind
,
20240 token
= cp_lexer_peek_token (parser
->lexer
);
20241 name
= cp_parser_id_expression (parser
, /*template_p=*/false,
20242 /*check_dependency_p=*/true,
20243 /*template_p=*/NULL
,
20244 /*declarator_p=*/false,
20245 /*optional_p=*/false);
20246 if (name
== error_mark_node
)
20249 decl
= cp_parser_lookup_name_simple (parser
, name
, token
->location
);
20250 if (decl
== error_mark_node
)
20251 cp_parser_name_lookup_error (parser
, name
, decl
, NULL
, token
->location
);
20252 else if (kind
!= 0)
20254 tree u
= build_omp_clause (kind
);
20255 OMP_CLAUSE_DECL (u
) = decl
;
20256 OMP_CLAUSE_CHAIN (u
) = list
;
20260 list
= tree_cons (decl
, NULL_TREE
, list
);
20263 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
20265 cp_lexer_consume_token (parser
->lexer
);
20268 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
20272 /* Try to resync to an unnested comma. Copied from
20273 cp_parser_parenthesized_expression_list. */
20275 ending
= cp_parser_skip_to_closing_parenthesis (parser
,
20276 /*recovering=*/true,
20278 /*consume_paren=*/true);
20286 /* Similarly, but expect leading and trailing parenthesis. This is a very
20287 common case for omp clauses. */
20290 cp_parser_omp_var_list (cp_parser
*parser
, enum omp_clause_code kind
, tree list
)
20292 if (cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
20293 return cp_parser_omp_var_list_no_open (parser
, kind
, list
);
20298 collapse ( constant-expression ) */
20301 cp_parser_omp_clause_collapse (cp_parser
*parser
, tree list
, location_t location
)
20307 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
20308 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
20311 num
= cp_parser_constant_expression (parser
, false, NULL
);
20313 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
20314 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
20315 /*or_comma=*/false,
20316 /*consume_paren=*/true);
20318 if (num
== error_mark_node
)
20320 num
= fold_non_dependent_expr (num
);
20321 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
20322 || !host_integerp (num
, 0)
20323 || (n
= tree_low_cst (num
, 0)) <= 0
20326 error ("%Hcollapse argument needs positive constant integer expression",
20331 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse", location
);
20332 c
= build_omp_clause (OMP_CLAUSE_COLLAPSE
);
20333 OMP_CLAUSE_CHAIN (c
) = list
;
20334 OMP_CLAUSE_COLLAPSE_EXPR (c
) = num
;
20340 default ( shared | none ) */
20343 cp_parser_omp_clause_default (cp_parser
*parser
, tree list
, location_t location
)
20345 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
20348 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
20350 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
20352 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
20353 const char *p
= IDENTIFIER_POINTER (id
);
20358 if (strcmp ("none", p
) != 0)
20360 kind
= OMP_CLAUSE_DEFAULT_NONE
;
20364 if (strcmp ("shared", p
) != 0)
20366 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
20373 cp_lexer_consume_token (parser
->lexer
);
20378 cp_parser_error (parser
, "expected %<none%> or %<shared%>");
20381 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
20382 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
20383 /*or_comma=*/false,
20384 /*consume_paren=*/true);
20386 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
20389 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default", location
);
20390 c
= build_omp_clause (OMP_CLAUSE_DEFAULT
);
20391 OMP_CLAUSE_CHAIN (c
) = list
;
20392 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
20398 if ( expression ) */
20401 cp_parser_omp_clause_if (cp_parser
*parser
, tree list
, location_t location
)
20405 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
20408 t
= cp_parser_condition (parser
);
20410 if (t
== error_mark_node
20411 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
20412 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
20413 /*or_comma=*/false,
20414 /*consume_paren=*/true);
20416 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if", location
);
20418 c
= build_omp_clause (OMP_CLAUSE_IF
);
20419 OMP_CLAUSE_IF_EXPR (c
) = t
;
20420 OMP_CLAUSE_CHAIN (c
) = list
;
20429 cp_parser_omp_clause_nowait (cp_parser
*parser ATTRIBUTE_UNUSED
,
20430 tree list
, location_t location
)
20434 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait", location
);
20436 c
= build_omp_clause (OMP_CLAUSE_NOWAIT
);
20437 OMP_CLAUSE_CHAIN (c
) = list
;
20442 num_threads ( expression ) */
20445 cp_parser_omp_clause_num_threads (cp_parser
*parser
, tree list
,
20446 location_t location
)
20450 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
20453 t
= cp_parser_expression (parser
, false, NULL
);
20455 if (t
== error_mark_node
20456 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
20457 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
20458 /*or_comma=*/false,
20459 /*consume_paren=*/true);
20461 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
,
20462 "num_threads", location
);
20464 c
= build_omp_clause (OMP_CLAUSE_NUM_THREADS
);
20465 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
20466 OMP_CLAUSE_CHAIN (c
) = list
;
20475 cp_parser_omp_clause_ordered (cp_parser
*parser ATTRIBUTE_UNUSED
,
20476 tree list
, location_t location
)
20480 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
,
20481 "ordered", location
);
20483 c
= build_omp_clause (OMP_CLAUSE_ORDERED
);
20484 OMP_CLAUSE_CHAIN (c
) = list
;
20489 reduction ( reduction-operator : variable-list )
20491 reduction-operator:
20492 One of: + * - & ^ | && || */
20495 cp_parser_omp_clause_reduction (cp_parser
*parser
, tree list
)
20497 enum tree_code code
;
20500 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
20503 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
20515 code
= BIT_AND_EXPR
;
20518 code
= BIT_XOR_EXPR
;
20521 code
= BIT_IOR_EXPR
;
20524 code
= TRUTH_ANDIF_EXPR
;
20527 code
= TRUTH_ORIF_EXPR
;
20530 cp_parser_error (parser
, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
20531 "%<|%>, %<&&%>, or %<||%>");
20533 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
20534 /*or_comma=*/false,
20535 /*consume_paren=*/true);
20538 cp_lexer_consume_token (parser
->lexer
);
20540 if (!cp_parser_require (parser
, CPP_COLON
, "%<:%>"))
20543 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_REDUCTION
, list
);
20544 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
20545 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
20551 schedule ( schedule-kind )
20552 schedule ( schedule-kind , expression )
20555 static | dynamic | guided | runtime | auto */
20558 cp_parser_omp_clause_schedule (cp_parser
*parser
, tree list
, location_t location
)
20562 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
20565 c
= build_omp_clause (OMP_CLAUSE_SCHEDULE
);
20567 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
20569 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
20570 const char *p
= IDENTIFIER_POINTER (id
);
20575 if (strcmp ("dynamic", p
) != 0)
20577 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
20581 if (strcmp ("guided", p
) != 0)
20583 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
20587 if (strcmp ("runtime", p
) != 0)
20589 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
20596 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC
))
20597 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
20598 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AUTO
))
20599 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_AUTO
;
20602 cp_lexer_consume_token (parser
->lexer
);
20604 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
20607 cp_lexer_consume_token (parser
->lexer
);
20609 token
= cp_lexer_peek_token (parser
->lexer
);
20610 t
= cp_parser_assignment_expression (parser
, false, NULL
);
20612 if (t
== error_mark_node
)
20614 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
20615 error ("%Hschedule %<runtime%> does not take "
20616 "a %<chunk_size%> parameter", &token
->location
);
20617 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_AUTO
)
20618 error ("%Hschedule %<auto%> does not take "
20619 "a %<chunk_size%> parameter", &token
->location
);
20621 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
20623 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
20626 else if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<,%> or %<)%>"))
20629 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule", location
);
20630 OMP_CLAUSE_CHAIN (c
) = list
;
20634 cp_parser_error (parser
, "invalid schedule kind");
20636 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
20637 /*or_comma=*/false,
20638 /*consume_paren=*/true);
20646 cp_parser_omp_clause_untied (cp_parser
*parser ATTRIBUTE_UNUSED
,
20647 tree list
, location_t location
)
20651 check_no_duplicate_clause (list
, OMP_CLAUSE_UNTIED
, "untied", location
);
20653 c
= build_omp_clause (OMP_CLAUSE_UNTIED
);
20654 OMP_CLAUSE_CHAIN (c
) = list
;
20658 /* Parse all OpenMP clauses. The set clauses allowed by the directive
20659 is a bitmask in MASK. Return the list of clauses found; the result
20660 of clause default goes in *pdefault. */
20663 cp_parser_omp_all_clauses (cp_parser
*parser
, unsigned int mask
,
20664 const char *where
, cp_token
*pragma_tok
)
20666 tree clauses
= NULL
;
20668 cp_token
*token
= NULL
;
20670 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
20672 pragma_omp_clause c_kind
;
20673 const char *c_name
;
20674 tree prev
= clauses
;
20676 if (!first
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
20677 cp_lexer_consume_token (parser
->lexer
);
20679 token
= cp_lexer_peek_token (parser
->lexer
);
20680 c_kind
= cp_parser_omp_clause_name (parser
);
20685 case PRAGMA_OMP_CLAUSE_COLLAPSE
:
20686 clauses
= cp_parser_omp_clause_collapse (parser
, clauses
,
20688 c_name
= "collapse";
20690 case PRAGMA_OMP_CLAUSE_COPYIN
:
20691 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_COPYIN
, clauses
);
20694 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
20695 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_COPYPRIVATE
,
20697 c_name
= "copyprivate";
20699 case PRAGMA_OMP_CLAUSE_DEFAULT
:
20700 clauses
= cp_parser_omp_clause_default (parser
, clauses
,
20702 c_name
= "default";
20704 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
20705 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_FIRSTPRIVATE
,
20707 c_name
= "firstprivate";
20709 case PRAGMA_OMP_CLAUSE_IF
:
20710 clauses
= cp_parser_omp_clause_if (parser
, clauses
, token
->location
);
20713 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
20714 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_LASTPRIVATE
,
20716 c_name
= "lastprivate";
20718 case PRAGMA_OMP_CLAUSE_NOWAIT
:
20719 clauses
= cp_parser_omp_clause_nowait (parser
, clauses
, token
->location
);
20722 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
20723 clauses
= cp_parser_omp_clause_num_threads (parser
, clauses
,
20725 c_name
= "num_threads";
20727 case PRAGMA_OMP_CLAUSE_ORDERED
:
20728 clauses
= cp_parser_omp_clause_ordered (parser
, clauses
,
20730 c_name
= "ordered";
20732 case PRAGMA_OMP_CLAUSE_PRIVATE
:
20733 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_PRIVATE
,
20735 c_name
= "private";
20737 case PRAGMA_OMP_CLAUSE_REDUCTION
:
20738 clauses
= cp_parser_omp_clause_reduction (parser
, clauses
);
20739 c_name
= "reduction";
20741 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
20742 clauses
= cp_parser_omp_clause_schedule (parser
, clauses
,
20744 c_name
= "schedule";
20746 case PRAGMA_OMP_CLAUSE_SHARED
:
20747 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_SHARED
,
20751 case PRAGMA_OMP_CLAUSE_UNTIED
:
20752 clauses
= cp_parser_omp_clause_untied (parser
, clauses
,
20757 cp_parser_error (parser
, "expected %<#pragma omp%> clause");
20761 if (((mask
>> c_kind
) & 1) == 0)
20763 /* Remove the invalid clause(s) from the list to avoid
20764 confusing the rest of the compiler. */
20766 error ("%H%qs is not valid for %qs", &token
->location
, c_name
, where
);
20770 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
20771 return finish_omp_clauses (clauses
);
20778 In practice, we're also interested in adding the statement to an
20779 outer node. So it is convenient if we work around the fact that
20780 cp_parser_statement calls add_stmt. */
20783 cp_parser_begin_omp_structured_block (cp_parser
*parser
)
20785 unsigned save
= parser
->in_statement
;
20787 /* Only move the values to IN_OMP_BLOCK if they weren't false.
20788 This preserves the "not within loop or switch" style error messages
20789 for nonsense cases like
20795 if (parser
->in_statement
)
20796 parser
->in_statement
= IN_OMP_BLOCK
;
20802 cp_parser_end_omp_structured_block (cp_parser
*parser
, unsigned save
)
20804 parser
->in_statement
= save
;
20808 cp_parser_omp_structured_block (cp_parser
*parser
)
20810 tree stmt
= begin_omp_structured_block ();
20811 unsigned int save
= cp_parser_begin_omp_structured_block (parser
);
20813 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
20815 cp_parser_end_omp_structured_block (parser
, save
);
20816 return finish_omp_structured_block (stmt
);
20820 # pragma omp atomic new-line
20824 x binop= expr | x++ | ++x | x-- | --x
20826 +, *, -, /, &, ^, |, <<, >>
20828 where x is an lvalue expression with scalar type. */
20831 cp_parser_omp_atomic (cp_parser
*parser
, cp_token
*pragma_tok
)
20834 enum tree_code code
;
20836 cp_parser_require_pragma_eol (parser
, pragma_tok
);
20838 lhs
= cp_parser_unary_expression (parser
, /*address_p=*/false,
20839 /*cast_p=*/false, NULL
);
20840 switch (TREE_CODE (lhs
))
20845 case PREINCREMENT_EXPR
:
20846 case POSTINCREMENT_EXPR
:
20847 lhs
= TREE_OPERAND (lhs
, 0);
20849 rhs
= integer_one_node
;
20852 case PREDECREMENT_EXPR
:
20853 case POSTDECREMENT_EXPR
:
20854 lhs
= TREE_OPERAND (lhs
, 0);
20856 rhs
= integer_one_node
;
20860 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
20866 code
= TRUNC_DIV_EXPR
;
20874 case CPP_LSHIFT_EQ
:
20875 code
= LSHIFT_EXPR
;
20877 case CPP_RSHIFT_EQ
:
20878 code
= RSHIFT_EXPR
;
20881 code
= BIT_AND_EXPR
;
20884 code
= BIT_IOR_EXPR
;
20887 code
= BIT_XOR_EXPR
;
20890 cp_parser_error (parser
,
20891 "invalid operator for %<#pragma omp atomic%>");
20894 cp_lexer_consume_token (parser
->lexer
);
20896 rhs
= cp_parser_expression (parser
, false, NULL
);
20897 if (rhs
== error_mark_node
)
20901 finish_omp_atomic (code
, lhs
, rhs
);
20902 cp_parser_consume_semicolon_at_end_of_statement (parser
);
20906 cp_parser_skip_to_end_of_block_or_statement (parser
);
20911 # pragma omp barrier new-line */
20914 cp_parser_omp_barrier (cp_parser
*parser
, cp_token
*pragma_tok
)
20916 cp_parser_require_pragma_eol (parser
, pragma_tok
);
20917 finish_omp_barrier ();
20921 # pragma omp critical [(name)] new-line
20922 structured-block */
20925 cp_parser_omp_critical (cp_parser
*parser
, cp_token
*pragma_tok
)
20927 tree stmt
, name
= NULL
;
20929 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
20931 cp_lexer_consume_token (parser
->lexer
);
20933 name
= cp_parser_identifier (parser
);
20935 if (name
== error_mark_node
20936 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
20937 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
20938 /*or_comma=*/false,
20939 /*consume_paren=*/true);
20940 if (name
== error_mark_node
)
20943 cp_parser_require_pragma_eol (parser
, pragma_tok
);
20945 stmt
= cp_parser_omp_structured_block (parser
);
20946 return c_finish_omp_critical (stmt
, name
);
20950 # pragma omp flush flush-vars[opt] new-line
20953 ( variable-list ) */
20956 cp_parser_omp_flush (cp_parser
*parser
, cp_token
*pragma_tok
)
20958 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
20959 (void) cp_parser_omp_var_list (parser
, 0, NULL
);
20960 cp_parser_require_pragma_eol (parser
, pragma_tok
);
20962 finish_omp_flush ();
20965 /* Helper function, to parse omp for increment expression. */
20968 cp_parser_omp_for_cond (cp_parser
*parser
, tree decl
)
20970 tree lhs
= cp_parser_cast_expression (parser
, false, false, NULL
), rhs
;
20976 cp_parser_skip_to_end_of_statement (parser
);
20977 return error_mark_node
;
20980 token
= cp_lexer_peek_token (parser
->lexer
);
20981 op
= binops_by_token
[token
->type
].tree_type
;
20990 cp_parser_skip_to_end_of_statement (parser
);
20991 return error_mark_node
;
20994 cp_lexer_consume_token (parser
->lexer
);
20995 rhs
= cp_parser_binary_expression (parser
, false,
20996 PREC_RELATIONAL_EXPRESSION
, NULL
);
20997 if (rhs
== error_mark_node
20998 || cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
21000 cp_parser_skip_to_end_of_statement (parser
);
21001 return error_mark_node
;
21004 return build2 (op
, boolean_type_node
, lhs
, rhs
);
21007 /* Helper function, to parse omp for increment expression. */
21010 cp_parser_omp_for_incr (cp_parser
*parser
, tree decl
)
21012 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
21018 if (token
->type
== CPP_PLUS_PLUS
|| token
->type
== CPP_MINUS_MINUS
)
21020 op
= (token
->type
== CPP_PLUS_PLUS
21021 ? PREINCREMENT_EXPR
: PREDECREMENT_EXPR
);
21022 cp_lexer_consume_token (parser
->lexer
);
21023 lhs
= cp_parser_cast_expression (parser
, false, false, NULL
);
21025 return error_mark_node
;
21026 return build2 (op
, TREE_TYPE (decl
), decl
, NULL_TREE
);
21029 lhs
= cp_parser_primary_expression (parser
, false, false, false, &idk
);
21031 return error_mark_node
;
21033 token
= cp_lexer_peek_token (parser
->lexer
);
21034 if (token
->type
== CPP_PLUS_PLUS
|| token
->type
== CPP_MINUS_MINUS
)
21036 op
= (token
->type
== CPP_PLUS_PLUS
21037 ? POSTINCREMENT_EXPR
: POSTDECREMENT_EXPR
);
21038 cp_lexer_consume_token (parser
->lexer
);
21039 return build2 (op
, TREE_TYPE (decl
), decl
, NULL_TREE
);
21042 op
= cp_parser_assignment_operator_opt (parser
);
21043 if (op
== ERROR_MARK
)
21044 return error_mark_node
;
21046 if (op
!= NOP_EXPR
)
21048 rhs
= cp_parser_assignment_expression (parser
, false, NULL
);
21049 rhs
= build2 (op
, TREE_TYPE (decl
), decl
, rhs
);
21050 return build2 (MODIFY_EXPR
, TREE_TYPE (decl
), decl
, rhs
);
21053 lhs
= cp_parser_binary_expression (parser
, false,
21054 PREC_ADDITIVE_EXPRESSION
, NULL
);
21055 token
= cp_lexer_peek_token (parser
->lexer
);
21056 decl_first
= lhs
== decl
;
21059 if (token
->type
!= CPP_PLUS
21060 && token
->type
!= CPP_MINUS
)
21061 return error_mark_node
;
21065 op
= token
->type
== CPP_PLUS
? PLUS_EXPR
: MINUS_EXPR
;
21066 cp_lexer_consume_token (parser
->lexer
);
21067 rhs
= cp_parser_binary_expression (parser
, false,
21068 PREC_ADDITIVE_EXPRESSION
, NULL
);
21069 token
= cp_lexer_peek_token (parser
->lexer
);
21070 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
|| decl_first
)
21072 if (lhs
== NULL_TREE
)
21074 if (op
== PLUS_EXPR
)
21077 lhs
= build_x_unary_op (NEGATE_EXPR
, rhs
, tf_warning_or_error
);
21080 lhs
= build_x_binary_op (op
, lhs
, ERROR_MARK
, rhs
, ERROR_MARK
,
21081 NULL
, tf_warning_or_error
);
21084 while (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
);
21088 if (rhs
!= decl
|| op
== MINUS_EXPR
)
21089 return error_mark_node
;
21090 rhs
= build2 (op
, TREE_TYPE (decl
), lhs
, decl
);
21093 rhs
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), decl
, lhs
);
21095 return build2 (MODIFY_EXPR
, TREE_TYPE (decl
), decl
, rhs
);
21098 /* Parse the restricted form of the for statement allowed by OpenMP. */
21101 cp_parser_omp_for_loop (cp_parser
*parser
, tree clauses
, tree
*par_clauses
)
21103 tree init
, cond
, incr
, body
, decl
, pre_body
= NULL_TREE
, ret
;
21104 tree for_block
= NULL_TREE
, real_decl
, initv
, condv
, incrv
, declv
;
21105 tree this_pre_body
, cl
;
21106 location_t loc_first
;
21107 bool collapse_err
= false;
21108 int i
, collapse
= 1, nbraces
= 0;
21110 for (cl
= clauses
; cl
; cl
= OMP_CLAUSE_CHAIN (cl
))
21111 if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_COLLAPSE
)
21112 collapse
= tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl
), 0);
21114 gcc_assert (collapse
>= 1);
21116 declv
= make_tree_vec (collapse
);
21117 initv
= make_tree_vec (collapse
);
21118 condv
= make_tree_vec (collapse
);
21119 incrv
= make_tree_vec (collapse
);
21121 loc_first
= cp_lexer_peek_token (parser
->lexer
)->location
;
21123 for (i
= 0; i
< collapse
; i
++)
21125 int bracecount
= 0;
21126 bool add_private_clause
= false;
21129 if (!cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
21131 cp_parser_error (parser
, "for statement expected");
21134 loc
= cp_lexer_consume_token (parser
->lexer
)->location
;
21136 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, "%<(%>"))
21139 init
= decl
= real_decl
= NULL
;
21140 this_pre_body
= push_stmt_list ();
21141 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
21143 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
21147 integer-type var = lb
21148 random-access-iterator-type var = lb
21149 pointer-type var = lb
21151 cp_decl_specifier_seq type_specifiers
;
21153 /* First, try to parse as an initialized declaration. See
21154 cp_parser_condition, from whence the bulk of this is copied. */
21156 cp_parser_parse_tentatively (parser
);
21157 cp_parser_type_specifier_seq (parser
, /*is_condition=*/false,
21159 if (cp_parser_parse_definitely (parser
))
21161 /* If parsing a type specifier seq succeeded, then this
21162 MUST be a initialized declaration. */
21163 tree asm_specification
, attributes
;
21164 cp_declarator
*declarator
;
21166 declarator
= cp_parser_declarator (parser
,
21167 CP_PARSER_DECLARATOR_NAMED
,
21168 /*ctor_dtor_or_conv_p=*/NULL
,
21169 /*parenthesized_p=*/NULL
,
21170 /*member_p=*/false);
21171 attributes
= cp_parser_attributes_opt (parser
);
21172 asm_specification
= cp_parser_asm_specification_opt (parser
);
21174 if (declarator
== cp_error_declarator
)
21175 cp_parser_skip_to_end_of_statement (parser
);
21179 tree pushed_scope
, auto_node
;
21181 decl
= start_decl (declarator
, &type_specifiers
,
21182 SD_INITIALIZED
, attributes
,
21183 /*prefix_attributes=*/NULL_TREE
,
21186 auto_node
= type_uses_auto (TREE_TYPE (decl
));
21187 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
))
21189 if (cp_lexer_next_token_is (parser
->lexer
,
21191 error ("parenthesized initialization is not allowed in "
21192 "OpenMP %<for%> loop");
21194 /* Trigger an error. */
21195 cp_parser_require (parser
, CPP_EQ
, "%<=%>");
21197 init
= error_mark_node
;
21198 cp_parser_skip_to_end_of_statement (parser
);
21200 else if (CLASS_TYPE_P (TREE_TYPE (decl
))
21201 || type_dependent_expression_p (decl
)
21204 bool is_direct_init
, is_non_constant_init
;
21206 init
= cp_parser_initializer (parser
,
21208 &is_non_constant_init
);
21210 if (auto_node
&& describable_type (init
))
21213 = do_auto_deduction (TREE_TYPE (decl
), init
,
21216 if (!CLASS_TYPE_P (TREE_TYPE (decl
))
21217 && !type_dependent_expression_p (decl
))
21221 cp_finish_decl (decl
, init
, !is_non_constant_init
,
21223 LOOKUP_ONLYCONVERTING
);
21224 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
21227 = tree_cons (NULL
, this_pre_body
, for_block
);
21231 init
= pop_stmt_list (this_pre_body
);
21232 this_pre_body
= NULL_TREE
;
21237 cp_lexer_consume_token (parser
->lexer
);
21238 init
= cp_parser_assignment_expression (parser
, false, NULL
);
21241 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
)
21242 init
= error_mark_node
;
21244 cp_finish_decl (decl
, NULL_TREE
,
21245 /*init_const_expr_p=*/false,
21247 LOOKUP_ONLYCONVERTING
);
21251 pop_scope (pushed_scope
);
21257 /* If parsing a type specifier sequence failed, then
21258 this MUST be a simple expression. */
21259 cp_parser_parse_tentatively (parser
);
21260 decl
= cp_parser_primary_expression (parser
, false, false,
21262 if (!cp_parser_error_occurred (parser
)
21265 && CLASS_TYPE_P (TREE_TYPE (decl
)))
21269 cp_parser_parse_definitely (parser
);
21270 cp_parser_require (parser
, CPP_EQ
, "%<=%>");
21271 rhs
= cp_parser_assignment_expression (parser
, false, NULL
);
21272 finish_expr_stmt (build_x_modify_expr (decl
, NOP_EXPR
,
21274 tf_warning_or_error
));
21275 add_private_clause
= true;
21280 cp_parser_abort_tentative_parse (parser
);
21281 init
= cp_parser_expression (parser
, false, NULL
);
21284 if (TREE_CODE (init
) == MODIFY_EXPR
21285 || TREE_CODE (init
) == MODOP_EXPR
)
21286 real_decl
= TREE_OPERAND (init
, 0);
21291 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
21294 this_pre_body
= pop_stmt_list (this_pre_body
);
21298 pre_body
= push_stmt_list ();
21300 add_stmt (this_pre_body
);
21301 pre_body
= pop_stmt_list (pre_body
);
21304 pre_body
= this_pre_body
;
21309 if (par_clauses
!= NULL
&& real_decl
!= NULL_TREE
)
21312 for (c
= par_clauses
; *c
; )
21313 if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_FIRSTPRIVATE
21314 && OMP_CLAUSE_DECL (*c
) == real_decl
)
21316 error ("%Hiteration variable %qD should not be firstprivate",
21318 *c
= OMP_CLAUSE_CHAIN (*c
);
21320 else if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_LASTPRIVATE
21321 && OMP_CLAUSE_DECL (*c
) == real_decl
)
21323 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
21324 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
21325 tree l
= build_omp_clause (OMP_CLAUSE_LASTPRIVATE
);
21326 OMP_CLAUSE_DECL (l
) = real_decl
;
21327 OMP_CLAUSE_CHAIN (l
) = clauses
;
21328 CP_OMP_CLAUSE_INFO (l
) = CP_OMP_CLAUSE_INFO (*c
);
21330 OMP_CLAUSE_SET_CODE (*c
, OMP_CLAUSE_SHARED
);
21331 CP_OMP_CLAUSE_INFO (*c
) = NULL
;
21332 add_private_clause
= false;
21336 if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_PRIVATE
21337 && OMP_CLAUSE_DECL (*c
) == real_decl
)
21338 add_private_clause
= false;
21339 c
= &OMP_CLAUSE_CHAIN (*c
);
21343 if (add_private_clause
)
21346 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
21348 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
21349 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
21350 && OMP_CLAUSE_DECL (c
) == decl
)
21352 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
21353 && OMP_CLAUSE_DECL (c
) == decl
)
21354 error ("%Hiteration variable %qD should not be firstprivate",
21356 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
21357 && OMP_CLAUSE_DECL (c
) == decl
)
21358 error ("%Hiteration variable %qD should not be reduction",
21363 c
= build_omp_clause (OMP_CLAUSE_PRIVATE
);
21364 OMP_CLAUSE_DECL (c
) = decl
;
21365 c
= finish_omp_clauses (c
);
21368 OMP_CLAUSE_CHAIN (c
) = clauses
;
21375 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
21377 /* If decl is an iterator, preserve LHS and RHS of the relational
21378 expr until finish_omp_for. */
21380 && (type_dependent_expression_p (decl
)
21381 || CLASS_TYPE_P (TREE_TYPE (decl
))))
21382 cond
= cp_parser_omp_for_cond (parser
, decl
);
21384 cond
= cp_parser_condition (parser
);
21386 cp_parser_require (parser
, CPP_SEMICOLON
, "%<;%>");
21389 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
21391 /* If decl is an iterator, preserve the operator on decl
21392 until finish_omp_for. */
21394 && (type_dependent_expression_p (decl
)
21395 || CLASS_TYPE_P (TREE_TYPE (decl
))))
21396 incr
= cp_parser_omp_for_incr (parser
, decl
);
21398 incr
= cp_parser_expression (parser
, false, NULL
);
21401 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, "%<)%>"))
21402 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
21403 /*or_comma=*/false,
21404 /*consume_paren=*/true);
21406 TREE_VEC_ELT (declv
, i
) = decl
;
21407 TREE_VEC_ELT (initv
, i
) = init
;
21408 TREE_VEC_ELT (condv
, i
) = cond
;
21409 TREE_VEC_ELT (incrv
, i
) = incr
;
21411 if (i
== collapse
- 1)
21414 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
21415 in between the collapsed for loops to be still considered perfectly
21416 nested. Hopefully the final version clarifies this.
21417 For now handle (multiple) {'s and empty statements. */
21418 cp_parser_parse_tentatively (parser
);
21421 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
21423 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
21425 cp_lexer_consume_token (parser
->lexer
);
21428 else if (bracecount
21429 && cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
21430 cp_lexer_consume_token (parser
->lexer
);
21433 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
21434 error ("%Hnot enough collapsed for loops", &loc
);
21435 collapse_err
= true;
21436 cp_parser_abort_tentative_parse (parser
);
21445 cp_parser_parse_definitely (parser
);
21446 nbraces
+= bracecount
;
21450 /* Note that we saved the original contents of this flag when we entered
21451 the structured block, and so we don't need to re-save it here. */
21452 parser
->in_statement
= IN_OMP_FOR
;
21454 /* Note that the grammar doesn't call for a structured block here,
21455 though the loop as a whole is a structured block. */
21456 body
= push_stmt_list ();
21457 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
21458 body
= pop_stmt_list (body
);
21460 if (declv
== NULL_TREE
)
21463 ret
= finish_omp_for (loc_first
, declv
, initv
, condv
, incrv
, body
,
21464 pre_body
, clauses
);
21468 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
21470 cp_lexer_consume_token (parser
->lexer
);
21473 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
21474 cp_lexer_consume_token (parser
->lexer
);
21479 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
21480 error ("%Hcollapsed loops not perfectly nested", &loc
);
21482 collapse_err
= true;
21483 cp_parser_statement_seq_opt (parser
, NULL
);
21484 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
21490 add_stmt (pop_stmt_list (TREE_VALUE (for_block
)));
21491 for_block
= TREE_CHAIN (for_block
);
21498 #pragma omp for for-clause[optseq] new-line
21501 #define OMP_FOR_CLAUSE_MASK \
21502 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
21503 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
21504 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
21505 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
21506 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
21507 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
21508 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT) \
21509 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE))
21512 cp_parser_omp_for (cp_parser
*parser
, cp_token
*pragma_tok
)
21514 tree clauses
, sb
, ret
;
21517 clauses
= cp_parser_omp_all_clauses (parser
, OMP_FOR_CLAUSE_MASK
,
21518 "#pragma omp for", pragma_tok
);
21520 sb
= begin_omp_structured_block ();
21521 save
= cp_parser_begin_omp_structured_block (parser
);
21523 ret
= cp_parser_omp_for_loop (parser
, clauses
, NULL
);
21525 cp_parser_end_omp_structured_block (parser
, save
);
21526 add_stmt (finish_omp_structured_block (sb
));
21532 # pragma omp master new-line
21533 structured-block */
21536 cp_parser_omp_master (cp_parser
*parser
, cp_token
*pragma_tok
)
21538 cp_parser_require_pragma_eol (parser
, pragma_tok
);
21539 return c_finish_omp_master (cp_parser_omp_structured_block (parser
));
21543 # pragma omp ordered new-line
21544 structured-block */
21547 cp_parser_omp_ordered (cp_parser
*parser
, cp_token
*pragma_tok
)
21549 cp_parser_require_pragma_eol (parser
, pragma_tok
);
21550 return c_finish_omp_ordered (cp_parser_omp_structured_block (parser
));
21556 { section-sequence }
21559 section-directive[opt] structured-block
21560 section-sequence section-directive structured-block */
21563 cp_parser_omp_sections_scope (cp_parser
*parser
)
21565 tree stmt
, substmt
;
21566 bool error_suppress
= false;
21569 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, "%<{%>"))
21572 stmt
= push_stmt_list ();
21574 if (cp_lexer_peek_token (parser
->lexer
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
21578 substmt
= begin_omp_structured_block ();
21579 save
= cp_parser_begin_omp_structured_block (parser
);
21583 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
21585 tok
= cp_lexer_peek_token (parser
->lexer
);
21586 if (tok
->pragma_kind
== PRAGMA_OMP_SECTION
)
21588 if (tok
->type
== CPP_CLOSE_BRACE
)
21590 if (tok
->type
== CPP_EOF
)
21594 cp_parser_end_omp_structured_block (parser
, save
);
21595 substmt
= finish_omp_structured_block (substmt
);
21596 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
21597 add_stmt (substmt
);
21602 tok
= cp_lexer_peek_token (parser
->lexer
);
21603 if (tok
->type
== CPP_CLOSE_BRACE
)
21605 if (tok
->type
== CPP_EOF
)
21608 if (tok
->pragma_kind
== PRAGMA_OMP_SECTION
)
21610 cp_lexer_consume_token (parser
->lexer
);
21611 cp_parser_require_pragma_eol (parser
, tok
);
21612 error_suppress
= false;
21614 else if (!error_suppress
)
21616 cp_parser_error (parser
, "expected %<#pragma omp section%> or %<}%>");
21617 error_suppress
= true;
21620 substmt
= cp_parser_omp_structured_block (parser
);
21621 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
21622 add_stmt (substmt
);
21624 cp_parser_require (parser
, CPP_CLOSE_BRACE
, "%<}%>");
21626 substmt
= pop_stmt_list (stmt
);
21628 stmt
= make_node (OMP_SECTIONS
);
21629 TREE_TYPE (stmt
) = void_type_node
;
21630 OMP_SECTIONS_BODY (stmt
) = substmt
;
21637 # pragma omp sections sections-clause[optseq] newline
21640 #define OMP_SECTIONS_CLAUSE_MASK \
21641 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
21642 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
21643 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
21644 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
21645 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
21648 cp_parser_omp_sections (cp_parser
*parser
, cp_token
*pragma_tok
)
21652 clauses
= cp_parser_omp_all_clauses (parser
, OMP_SECTIONS_CLAUSE_MASK
,
21653 "#pragma omp sections", pragma_tok
);
21655 ret
= cp_parser_omp_sections_scope (parser
);
21657 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
21663 # pragma parallel parallel-clause new-line
21664 # pragma parallel for parallel-for-clause new-line
21665 # pragma parallel sections parallel-sections-clause new-line */
21667 #define OMP_PARALLEL_CLAUSE_MASK \
21668 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
21669 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
21670 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
21671 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
21672 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
21673 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
21674 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
21675 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
21678 cp_parser_omp_parallel (cp_parser
*parser
, cp_token
*pragma_tok
)
21680 enum pragma_kind p_kind
= PRAGMA_OMP_PARALLEL
;
21681 const char *p_name
= "#pragma omp parallel";
21682 tree stmt
, clauses
, par_clause
, ws_clause
, block
;
21683 unsigned int mask
= OMP_PARALLEL_CLAUSE_MASK
;
21686 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
21688 cp_lexer_consume_token (parser
->lexer
);
21689 p_kind
= PRAGMA_OMP_PARALLEL_FOR
;
21690 p_name
= "#pragma omp parallel for";
21691 mask
|= OMP_FOR_CLAUSE_MASK
;
21692 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
21694 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
21696 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
21697 const char *p
= IDENTIFIER_POINTER (id
);
21698 if (strcmp (p
, "sections") == 0)
21700 cp_lexer_consume_token (parser
->lexer
);
21701 p_kind
= PRAGMA_OMP_PARALLEL_SECTIONS
;
21702 p_name
= "#pragma omp parallel sections";
21703 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
21704 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
21708 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
);
21709 block
= begin_omp_parallel ();
21710 save
= cp_parser_begin_omp_structured_block (parser
);
21714 case PRAGMA_OMP_PARALLEL
:
21715 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
21716 par_clause
= clauses
;
21719 case PRAGMA_OMP_PARALLEL_FOR
:
21720 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
21721 cp_parser_omp_for_loop (parser
, ws_clause
, &par_clause
);
21724 case PRAGMA_OMP_PARALLEL_SECTIONS
:
21725 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
21726 stmt
= cp_parser_omp_sections_scope (parser
);
21728 OMP_SECTIONS_CLAUSES (stmt
) = ws_clause
;
21732 gcc_unreachable ();
21735 cp_parser_end_omp_structured_block (parser
, save
);
21736 stmt
= finish_omp_parallel (par_clause
, block
);
21737 if (p_kind
!= PRAGMA_OMP_PARALLEL
)
21738 OMP_PARALLEL_COMBINED (stmt
) = 1;
21743 # pragma omp single single-clause[optseq] new-line
21744 structured-block */
21746 #define OMP_SINGLE_CLAUSE_MASK \
21747 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
21748 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
21749 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
21750 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
21753 cp_parser_omp_single (cp_parser
*parser
, cp_token
*pragma_tok
)
21755 tree stmt
= make_node (OMP_SINGLE
);
21756 TREE_TYPE (stmt
) = void_type_node
;
21758 OMP_SINGLE_CLAUSES (stmt
)
21759 = cp_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
21760 "#pragma omp single", pragma_tok
);
21761 OMP_SINGLE_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
21763 return add_stmt (stmt
);
21767 # pragma omp task task-clause[optseq] new-line
21768 structured-block */
21770 #define OMP_TASK_CLAUSE_MASK \
21771 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
21772 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
21773 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
21774 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
21775 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
21776 | (1u << PRAGMA_OMP_CLAUSE_SHARED))
21779 cp_parser_omp_task (cp_parser
*parser
, cp_token
*pragma_tok
)
21781 tree clauses
, block
;
21784 clauses
= cp_parser_omp_all_clauses (parser
, OMP_TASK_CLAUSE_MASK
,
21785 "#pragma omp task", pragma_tok
);
21786 block
= begin_omp_task ();
21787 save
= cp_parser_begin_omp_structured_block (parser
);
21788 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
21789 cp_parser_end_omp_structured_block (parser
, save
);
21790 return finish_omp_task (clauses
, block
);
21794 # pragma omp taskwait new-line */
21797 cp_parser_omp_taskwait (cp_parser
*parser
, cp_token
*pragma_tok
)
21799 cp_parser_require_pragma_eol (parser
, pragma_tok
);
21800 finish_omp_taskwait ();
21804 # pragma omp threadprivate (variable-list) */
21807 cp_parser_omp_threadprivate (cp_parser
*parser
, cp_token
*pragma_tok
)
21811 vars
= cp_parser_omp_var_list (parser
, 0, NULL
);
21812 cp_parser_require_pragma_eol (parser
, pragma_tok
);
21814 finish_omp_threadprivate (vars
);
21817 /* Main entry point to OpenMP statement pragmas. */
21820 cp_parser_omp_construct (cp_parser
*parser
, cp_token
*pragma_tok
)
21824 switch (pragma_tok
->pragma_kind
)
21826 case PRAGMA_OMP_ATOMIC
:
21827 cp_parser_omp_atomic (parser
, pragma_tok
);
21829 case PRAGMA_OMP_CRITICAL
:
21830 stmt
= cp_parser_omp_critical (parser
, pragma_tok
);
21832 case PRAGMA_OMP_FOR
:
21833 stmt
= cp_parser_omp_for (parser
, pragma_tok
);
21835 case PRAGMA_OMP_MASTER
:
21836 stmt
= cp_parser_omp_master (parser
, pragma_tok
);
21838 case PRAGMA_OMP_ORDERED
:
21839 stmt
= cp_parser_omp_ordered (parser
, pragma_tok
);
21841 case PRAGMA_OMP_PARALLEL
:
21842 stmt
= cp_parser_omp_parallel (parser
, pragma_tok
);
21844 case PRAGMA_OMP_SECTIONS
:
21845 stmt
= cp_parser_omp_sections (parser
, pragma_tok
);
21847 case PRAGMA_OMP_SINGLE
:
21848 stmt
= cp_parser_omp_single (parser
, pragma_tok
);
21850 case PRAGMA_OMP_TASK
:
21851 stmt
= cp_parser_omp_task (parser
, pragma_tok
);
21854 gcc_unreachable ();
21858 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
21863 static GTY (()) cp_parser
*the_parser
;
21866 /* Special handling for the first token or line in the file. The first
21867 thing in the file might be #pragma GCC pch_preprocess, which loads a
21868 PCH file, which is a GC collection point. So we need to handle this
21869 first pragma without benefit of an existing lexer structure.
21871 Always returns one token to the caller in *FIRST_TOKEN. This is
21872 either the true first token of the file, or the first token after
21873 the initial pragma. */
21876 cp_parser_initial_pragma (cp_token
*first_token
)
21880 cp_lexer_get_preprocessor_token (NULL
, first_token
);
21881 if (first_token
->pragma_kind
!= PRAGMA_GCC_PCH_PREPROCESS
)
21884 cp_lexer_get_preprocessor_token (NULL
, first_token
);
21885 if (first_token
->type
== CPP_STRING
)
21887 name
= first_token
->u
.value
;
21889 cp_lexer_get_preprocessor_token (NULL
, first_token
);
21890 if (first_token
->type
!= CPP_PRAGMA_EOL
)
21891 error ("%Hjunk at end of %<#pragma GCC pch_preprocess%>",
21892 &first_token
->location
);
21895 error ("%Hexpected string literal", &first_token
->location
);
21897 /* Skip to the end of the pragma. */
21898 while (first_token
->type
!= CPP_PRAGMA_EOL
&& first_token
->type
!= CPP_EOF
)
21899 cp_lexer_get_preprocessor_token (NULL
, first_token
);
21901 /* Now actually load the PCH file. */
21903 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
21905 /* Read one more token to return to our caller. We have to do this
21906 after reading the PCH file in, since its pointers have to be
21908 cp_lexer_get_preprocessor_token (NULL
, first_token
);
21911 /* Normal parsing of a pragma token. Here we can (and must) use the
21915 cp_parser_pragma (cp_parser
*parser
, enum pragma_context context
)
21917 cp_token
*pragma_tok
;
21920 pragma_tok
= cp_lexer_consume_token (parser
->lexer
);
21921 gcc_assert (pragma_tok
->type
== CPP_PRAGMA
);
21922 parser
->lexer
->in_pragma
= true;
21924 id
= pragma_tok
->pragma_kind
;
21927 case PRAGMA_GCC_PCH_PREPROCESS
:
21928 error ("%H%<#pragma GCC pch_preprocess%> must be first",
21929 &pragma_tok
->location
);
21932 case PRAGMA_OMP_BARRIER
:
21935 case pragma_compound
:
21936 cp_parser_omp_barrier (parser
, pragma_tok
);
21939 error ("%H%<#pragma omp barrier%> may only be "
21940 "used in compound statements", &pragma_tok
->location
);
21947 case PRAGMA_OMP_FLUSH
:
21950 case pragma_compound
:
21951 cp_parser_omp_flush (parser
, pragma_tok
);
21954 error ("%H%<#pragma omp flush%> may only be "
21955 "used in compound statements", &pragma_tok
->location
);
21962 case PRAGMA_OMP_TASKWAIT
:
21965 case pragma_compound
:
21966 cp_parser_omp_taskwait (parser
, pragma_tok
);
21969 error ("%H%<#pragma omp taskwait%> may only be "
21970 "used in compound statements",
21971 &pragma_tok
->location
);
21978 case PRAGMA_OMP_THREADPRIVATE
:
21979 cp_parser_omp_threadprivate (parser
, pragma_tok
);
21982 case PRAGMA_OMP_ATOMIC
:
21983 case PRAGMA_OMP_CRITICAL
:
21984 case PRAGMA_OMP_FOR
:
21985 case PRAGMA_OMP_MASTER
:
21986 case PRAGMA_OMP_ORDERED
:
21987 case PRAGMA_OMP_PARALLEL
:
21988 case PRAGMA_OMP_SECTIONS
:
21989 case PRAGMA_OMP_SINGLE
:
21990 case PRAGMA_OMP_TASK
:
21991 if (context
== pragma_external
)
21993 cp_parser_omp_construct (parser
, pragma_tok
);
21996 case PRAGMA_OMP_SECTION
:
21997 error ("%H%<#pragma omp section%> may only be used in "
21998 "%<#pragma omp sections%> construct", &pragma_tok
->location
);
22002 gcc_assert (id
>= PRAGMA_FIRST_EXTERNAL
);
22003 c_invoke_pragma_handler (id
);
22007 cp_parser_error (parser
, "expected declaration specifiers");
22011 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
22015 /* The interface the pragma parsers have to the lexer. */
22018 pragma_lex (tree
*value
)
22021 enum cpp_ttype ret
;
22023 tok
= cp_lexer_peek_token (the_parser
->lexer
);
22026 *value
= tok
->u
.value
;
22028 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
22030 else if (ret
== CPP_STRING
)
22031 *value
= cp_parser_string_literal (the_parser
, false, false);
22034 cp_lexer_consume_token (the_parser
->lexer
);
22035 if (ret
== CPP_KEYWORD
)
22043 /* External interface. */
22045 /* Parse one entire translation unit. */
22048 c_parse_file (void)
22050 bool error_occurred
;
22051 static bool already_called
= false;
22053 if (already_called
)
22055 sorry ("inter-module optimizations not implemented for C++");
22058 already_called
= true;
22060 the_parser
= cp_parser_new ();
22061 push_deferring_access_checks (flag_access_control
22062 ? dk_no_deferred
: dk_no_check
);
22063 error_occurred
= cp_parser_translation_unit (the_parser
);
22067 #include "gt-cp-parser.h"