2 Copyright (C) 2000-2015 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "double-int.h"
37 #include "print-tree.h"
38 #include "stringpool.h"
40 #include "trans-mem.h"
43 #include "c-family/c-pragma.h"
46 #include "diagnostic-core.h"
50 #include "plugin-api.h"
51 #include "hard-reg-set.h"
56 #include "c-family/c-common.h"
57 #include "c-family/c-objc.h"
59 #include "tree-pretty-print.h"
61 #include "type-utils.h"
63 #include "gomp-constants.h"
68 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
69 and c-lex.c) and the C++ parser. */
71 static cp_token eof_token
=
73 CPP_EOF
, RID_MAX
, 0, PRAGMA_NONE
, false, false, false, 0, { NULL
}
76 /* The various kinds of non integral constant we encounter. */
77 typedef enum non_integral_constant
{
79 /* floating-point literal */
83 /* %<__FUNCTION__%> */
85 /* %<__PRETTY_FUNCTION__%> */
93 /* %<typeid%> operator */
95 /* non-constant compound literals */
103 /* an array reference */
109 /* the address of a label */
123 /* calls to overloaded operators */
127 /* a comma operator */
129 /* a call to a constructor */
131 /* a transaction expression */
133 } non_integral_constant
;
135 /* The various kinds of errors about name-lookup failing. */
136 typedef enum name_lookup_error
{
141 /* is not a class or namespace */
143 /* is not a class, namespace, or enumeration */
147 /* The various kinds of required token */
148 typedef enum required_token
{
150 RT_SEMICOLON
, /* ';' */
151 RT_OPEN_PAREN
, /* '(' */
152 RT_CLOSE_BRACE
, /* '}' */
153 RT_OPEN_BRACE
, /* '{' */
154 RT_CLOSE_SQUARE
, /* ']' */
155 RT_OPEN_SQUARE
, /* '[' */
159 RT_GREATER
, /* '>' */
161 RT_ELLIPSIS
, /* '...' */
165 RT_COLON_SCOPE
, /* ':' or '::' */
166 RT_CLOSE_PAREN
, /* ')' */
167 RT_COMMA_CLOSE_PAREN
, /* ',' or ')' */
168 RT_PRAGMA_EOL
, /* end of line */
169 RT_NAME
, /* identifier */
171 /* The type is CPP_KEYWORD */
173 RT_DELETE
, /* delete */
174 RT_RETURN
, /* return */
175 RT_WHILE
, /* while */
176 RT_EXTERN
, /* extern */
177 RT_STATIC_ASSERT
, /* static_assert */
178 RT_DECLTYPE
, /* decltype */
179 RT_OPERATOR
, /* operator */
180 RT_CLASS
, /* class */
181 RT_TEMPLATE
, /* template */
182 RT_NAMESPACE
, /* namespace */
183 RT_USING
, /* using */
186 RT_CATCH
, /* catch */
187 RT_THROW
, /* throw */
188 RT_LABEL
, /* __label__ */
189 RT_AT_TRY
, /* @try */
190 RT_AT_SYNCHRONIZED
, /* @synchronized */
191 RT_AT_THROW
, /* @throw */
193 RT_SELECT
, /* selection-statement */
194 RT_INTERATION
, /* iteration-statement */
195 RT_JUMP
, /* jump-statement */
196 RT_CLASS_KEY
, /* class-key */
197 RT_CLASS_TYPENAME_TEMPLATE
, /* class, typename, or template */
198 RT_TRANSACTION_ATOMIC
, /* __transaction_atomic */
199 RT_TRANSACTION_RELAXED
, /* __transaction_relaxed */
200 RT_TRANSACTION_CANCEL
/* __transaction_cancel */
205 static cp_lexer
*cp_lexer_new_main
207 static cp_lexer
*cp_lexer_new_from_tokens
208 (cp_token_cache
*tokens
);
209 static void cp_lexer_destroy
211 static int cp_lexer_saving_tokens
213 static cp_token
*cp_lexer_token_at
214 (cp_lexer
*, cp_token_position
);
215 static void cp_lexer_get_preprocessor_token
216 (cp_lexer
*, cp_token
*);
217 static inline cp_token
*cp_lexer_peek_token
219 static cp_token
*cp_lexer_peek_nth_token
220 (cp_lexer
*, size_t);
221 static inline bool cp_lexer_next_token_is
222 (cp_lexer
*, enum cpp_ttype
);
223 static bool cp_lexer_next_token_is_not
224 (cp_lexer
*, enum cpp_ttype
);
225 static bool cp_lexer_next_token_is_keyword
226 (cp_lexer
*, enum rid
);
227 static cp_token
*cp_lexer_consume_token
229 static void cp_lexer_purge_token
231 static void cp_lexer_purge_tokens_after
232 (cp_lexer
*, cp_token_position
);
233 static void cp_lexer_save_tokens
235 static void cp_lexer_commit_tokens
237 static void cp_lexer_rollback_tokens
239 static void cp_lexer_print_token
240 (FILE *, cp_token
*);
241 static inline bool cp_lexer_debugging_p
243 static void cp_lexer_start_debugging
244 (cp_lexer
*) ATTRIBUTE_UNUSED
;
245 static void cp_lexer_stop_debugging
246 (cp_lexer
*) ATTRIBUTE_UNUSED
;
248 static cp_token_cache
*cp_token_cache_new
249 (cp_token
*, cp_token
*);
251 static void cp_parser_initial_pragma
254 static tree cp_literal_operator_id
257 static void cp_parser_cilk_simd
258 (cp_parser
*, cp_token
*);
259 static tree cp_parser_cilk_for
261 static bool cp_parser_omp_declare_reduction_exprs
263 static tree cp_parser_cilk_simd_vectorlength
264 (cp_parser
*, tree
, bool);
266 /* Manifest constants. */
267 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
268 #define CP_SAVED_TOKEN_STACK 5
272 /* The stream to which debugging output should be written. */
273 static FILE *cp_lexer_debug_stream
;
275 /* Nonzero if we are parsing an unevaluated operand: an operand to
276 sizeof, typeof, or alignof. */
277 int cp_unevaluated_operand
;
279 /* Dump up to NUM tokens in BUFFER to FILE starting with token
280 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
281 first token in BUFFER. If NUM is 0, dump all the tokens. If
282 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
283 highlighted by surrounding it in [[ ]]. */
286 cp_lexer_dump_tokens (FILE *file
, vec
<cp_token
, va_gc
> *buffer
,
287 cp_token
*start_token
, unsigned num
,
288 cp_token
*curr_token
)
290 unsigned i
, nprinted
;
294 fprintf (file
, "%u tokens\n", vec_safe_length (buffer
));
300 num
= buffer
->length ();
302 if (start_token
== NULL
)
303 start_token
= buffer
->address ();
305 if (start_token
> buffer
->address ())
307 cp_lexer_print_token (file
, &(*buffer
)[0]);
308 fprintf (file
, " ... ");
313 for (i
= 0; buffer
->iterate (i
, &token
) && nprinted
< num
; i
++)
315 if (token
== start_token
)
322 if (token
== curr_token
)
323 fprintf (file
, "[[");
325 cp_lexer_print_token (file
, token
);
327 if (token
== curr_token
)
328 fprintf (file
, "]]");
334 case CPP_CLOSE_BRACE
:
344 if (i
== num
&& i
< buffer
->length ())
346 fprintf (file
, " ... ");
347 cp_lexer_print_token (file
, &buffer
->last ());
350 fprintf (file
, "\n");
354 /* Dump all tokens in BUFFER to stderr. */
357 cp_lexer_debug_tokens (vec
<cp_token
, va_gc
> *buffer
)
359 cp_lexer_dump_tokens (stderr
, buffer
, NULL
, 0, NULL
);
363 debug (vec
<cp_token
, va_gc
> &ref
)
365 cp_lexer_dump_tokens (stderr
, &ref
, NULL
, 0, NULL
);
369 debug (vec
<cp_token
, va_gc
> *ptr
)
374 fprintf (stderr
, "<nil>\n");
378 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
379 description for T. */
382 cp_debug_print_tree_if_set (FILE *file
, const char *desc
, tree t
)
386 fprintf (file
, "%s: ", desc
);
387 print_node_brief (file
, "", t
, 0);
392 /* Dump parser context C to FILE. */
395 cp_debug_print_context (FILE *file
, cp_parser_context
*c
)
397 const char *status_s
[] = { "OK", "ERROR", "COMMITTED" };
398 fprintf (file
, "{ status = %s, scope = ", status_s
[c
->status
]);
399 print_node_brief (file
, "", c
->object_type
, 0);
400 fprintf (file
, "}\n");
404 /* Print the stack of parsing contexts to FILE starting with FIRST. */
407 cp_debug_print_context_stack (FILE *file
, cp_parser_context
*first
)
410 cp_parser_context
*c
;
412 fprintf (file
, "Parsing context stack:\n");
413 for (i
= 0, c
= first
; c
; c
= c
->next
, i
++)
415 fprintf (file
, "\t#%u: ", i
);
416 cp_debug_print_context (file
, c
);
421 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
424 cp_debug_print_flag (FILE *file
, const char *desc
, bool flag
)
427 fprintf (file
, "%s: true\n", desc
);
431 /* Print an unparsed function entry UF to FILE. */
434 cp_debug_print_unparsed_function (FILE *file
, cp_unparsed_functions_entry
*uf
)
437 cp_default_arg_entry
*default_arg_fn
;
440 fprintf (file
, "\tFunctions with default args:\n");
442 vec_safe_iterate (uf
->funs_with_default_args
, i
, &default_arg_fn
);
445 fprintf (file
, "\t\tClass type: ");
446 print_node_brief (file
, "", default_arg_fn
->class_type
, 0);
447 fprintf (file
, "\t\tDeclaration: ");
448 print_node_brief (file
, "", default_arg_fn
->decl
, 0);
449 fprintf (file
, "\n");
452 fprintf (file
, "\n\tFunctions with definitions that require "
453 "post-processing\n\t\t");
454 for (i
= 0; vec_safe_iterate (uf
->funs_with_definitions
, i
, &fn
); i
++)
456 print_node_brief (file
, "", fn
, 0);
459 fprintf (file
, "\n");
461 fprintf (file
, "\n\tNon-static data members with initializers that require "
462 "post-processing\n\t\t");
463 for (i
= 0; vec_safe_iterate (uf
->nsdmis
, i
, &fn
); i
++)
465 print_node_brief (file
, "", fn
, 0);
468 fprintf (file
, "\n");
472 /* Print the stack of unparsed member functions S to FILE. */
475 cp_debug_print_unparsed_queues (FILE *file
,
476 vec
<cp_unparsed_functions_entry
, va_gc
> *s
)
479 cp_unparsed_functions_entry
*uf
;
481 fprintf (file
, "Unparsed functions\n");
482 for (i
= 0; vec_safe_iterate (s
, i
, &uf
); i
++)
484 fprintf (file
, "#%u:\n", i
);
485 cp_debug_print_unparsed_function (file
, uf
);
490 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
491 the given PARSER. If FILE is NULL, the output is printed on stderr. */
494 cp_debug_parser_tokens (FILE *file
, cp_parser
*parser
, int window_size
)
496 cp_token
*next_token
, *first_token
, *start_token
;
501 next_token
= parser
->lexer
->next_token
;
502 first_token
= parser
->lexer
->buffer
->address ();
503 start_token
= (next_token
> first_token
+ window_size
/ 2)
504 ? next_token
- window_size
/ 2
506 cp_lexer_dump_tokens (file
, parser
->lexer
->buffer
, start_token
, window_size
,
511 /* Dump debugging information for the given PARSER. If FILE is NULL,
512 the output is printed on stderr. */
515 cp_debug_parser (FILE *file
, cp_parser
*parser
)
517 const size_t window_size
= 20;
519 expanded_location eloc
;
524 fprintf (file
, "Parser state\n\n");
525 fprintf (file
, "Number of tokens: %u\n",
526 vec_safe_length (parser
->lexer
->buffer
));
527 cp_debug_print_tree_if_set (file
, "Lookup scope", parser
->scope
);
528 cp_debug_print_tree_if_set (file
, "Object scope",
529 parser
->object_scope
);
530 cp_debug_print_tree_if_set (file
, "Qualifying scope",
531 parser
->qualifying_scope
);
532 cp_debug_print_context_stack (file
, parser
->context
);
533 cp_debug_print_flag (file
, "Allow GNU extensions",
534 parser
->allow_gnu_extensions_p
);
535 cp_debug_print_flag (file
, "'>' token is greater-than",
536 parser
->greater_than_is_operator_p
);
537 cp_debug_print_flag (file
, "Default args allowed in current "
538 "parameter list", parser
->default_arg_ok_p
);
539 cp_debug_print_flag (file
, "Parsing integral constant-expression",
540 parser
->integral_constant_expression_p
);
541 cp_debug_print_flag (file
, "Allow non-constant expression in current "
542 "constant-expression",
543 parser
->allow_non_integral_constant_expression_p
);
544 cp_debug_print_flag (file
, "Seen non-constant expression",
545 parser
->non_integral_constant_expression_p
);
546 cp_debug_print_flag (file
, "Local names and 'this' forbidden in "
548 parser
->local_variables_forbidden_p
);
549 cp_debug_print_flag (file
, "In unbraced linkage specification",
550 parser
->in_unbraced_linkage_specification_p
);
551 cp_debug_print_flag (file
, "Parsing a declarator",
552 parser
->in_declarator_p
);
553 cp_debug_print_flag (file
, "In template argument list",
554 parser
->in_template_argument_list_p
);
555 cp_debug_print_flag (file
, "Parsing an iteration statement",
556 parser
->in_statement
& IN_ITERATION_STMT
);
557 cp_debug_print_flag (file
, "Parsing a switch statement",
558 parser
->in_statement
& IN_SWITCH_STMT
);
559 cp_debug_print_flag (file
, "Parsing a structured OpenMP block",
560 parser
->in_statement
& IN_OMP_BLOCK
);
561 cp_debug_print_flag (file
, "Parsing a Cilk Plus for loop",
562 parser
->in_statement
& IN_CILK_SIMD_FOR
);
563 cp_debug_print_flag (file
, "Parsing a an OpenMP loop",
564 parser
->in_statement
& IN_OMP_FOR
);
565 cp_debug_print_flag (file
, "Parsing an if statement",
566 parser
->in_statement
& IN_IF_STMT
);
567 cp_debug_print_flag (file
, "Parsing a type-id in an expression "
568 "context", parser
->in_type_id_in_expr_p
);
569 cp_debug_print_flag (file
, "Declarations are implicitly extern \"C\"",
570 parser
->implicit_extern_c
);
571 cp_debug_print_flag (file
, "String expressions should be translated "
572 "to execution character set",
573 parser
->translate_strings_p
);
574 cp_debug_print_flag (file
, "Parsing function body outside of a "
575 "local class", parser
->in_function_body
);
576 cp_debug_print_flag (file
, "Auto correct a colon to a scope operator",
577 parser
->colon_corrects_to_scope_p
);
578 cp_debug_print_flag (file
, "Colon doesn't start a class definition",
579 parser
->colon_doesnt_start_class_def_p
);
580 if (parser
->type_definition_forbidden_message
)
581 fprintf (file
, "Error message for forbidden type definitions: %s\n",
582 parser
->type_definition_forbidden_message
);
583 cp_debug_print_unparsed_queues (file
, parser
->unparsed_queues
);
584 fprintf (file
, "Number of class definitions in progress: %u\n",
585 parser
->num_classes_being_defined
);
586 fprintf (file
, "Number of template parameter lists for the current "
587 "declaration: %u\n", parser
->num_template_parameter_lists
);
588 cp_debug_parser_tokens (file
, parser
, window_size
);
589 token
= parser
->lexer
->next_token
;
590 fprintf (file
, "Next token to parse:\n");
591 fprintf (file
, "\tToken: ");
592 cp_lexer_print_token (file
, token
);
593 eloc
= expand_location (token
->location
);
594 fprintf (file
, "\n\tFile: %s\n", eloc
.file
);
595 fprintf (file
, "\tLine: %d\n", eloc
.line
);
596 fprintf (file
, "\tColumn: %d\n", eloc
.column
);
600 debug (cp_parser
&ref
)
602 cp_debug_parser (stderr
, &ref
);
606 debug (cp_parser
*ptr
)
611 fprintf (stderr
, "<nil>\n");
614 /* Allocate memory for a new lexer object and return it. */
617 cp_lexer_alloc (void)
621 c_common_no_more_pch ();
623 /* Allocate the memory. */
624 lexer
= ggc_cleared_alloc
<cp_lexer
> ();
626 /* Initially we are not debugging. */
627 lexer
->debugging_p
= false;
629 lexer
->saved_tokens
.create (CP_SAVED_TOKEN_STACK
);
631 /* Create the buffer. */
632 vec_alloc (lexer
->buffer
, CP_LEXER_BUFFER_SIZE
);
638 /* Create a new main C++ lexer, the lexer that gets tokens from the
642 cp_lexer_new_main (void)
647 /* It's possible that parsing the first pragma will load a PCH file,
648 which is a GC collection point. So we have to do that before
649 allocating any memory. */
650 cp_parser_initial_pragma (&token
);
652 lexer
= cp_lexer_alloc ();
654 /* Put the first token in the buffer. */
655 lexer
->buffer
->quick_push (token
);
657 /* Get the remaining tokens from the preprocessor. */
658 while (token
.type
!= CPP_EOF
)
660 cp_lexer_get_preprocessor_token (lexer
, &token
);
661 vec_safe_push (lexer
->buffer
, token
);
664 lexer
->last_token
= lexer
->buffer
->address ()
665 + lexer
->buffer
->length ()
667 lexer
->next_token
= lexer
->buffer
->length ()
668 ? lexer
->buffer
->address ()
671 /* Subsequent preprocessor diagnostics should use compiler
672 diagnostic functions to get the compiler source location. */
675 gcc_assert (!lexer
->next_token
->purged_p
);
679 /* Create a new lexer whose token stream is primed with the tokens in
680 CACHE. When these tokens are exhausted, no new tokens will be read. */
683 cp_lexer_new_from_tokens (cp_token_cache
*cache
)
685 cp_token
*first
= cache
->first
;
686 cp_token
*last
= cache
->last
;
687 cp_lexer
*lexer
= ggc_cleared_alloc
<cp_lexer
> ();
689 /* We do not own the buffer. */
690 lexer
->buffer
= NULL
;
691 lexer
->next_token
= first
== last
? &eof_token
: first
;
692 lexer
->last_token
= last
;
694 lexer
->saved_tokens
.create (CP_SAVED_TOKEN_STACK
);
696 /* Initially we are not debugging. */
697 lexer
->debugging_p
= false;
699 gcc_assert (!lexer
->next_token
->purged_p
);
703 /* Frees all resources associated with LEXER. */
706 cp_lexer_destroy (cp_lexer
*lexer
)
708 vec_free (lexer
->buffer
);
709 lexer
->saved_tokens
.release ();
713 /* Returns nonzero if debugging information should be output. */
716 cp_lexer_debugging_p (cp_lexer
*lexer
)
718 return lexer
->debugging_p
;
722 static inline cp_token_position
723 cp_lexer_token_position (cp_lexer
*lexer
, bool previous_p
)
725 gcc_assert (!previous_p
|| lexer
->next_token
!= &eof_token
);
727 return lexer
->next_token
- previous_p
;
730 static inline cp_token
*
731 cp_lexer_token_at (cp_lexer
* /*lexer*/, cp_token_position pos
)
737 cp_lexer_set_token_position (cp_lexer
*lexer
, cp_token_position pos
)
739 lexer
->next_token
= cp_lexer_token_at (lexer
, pos
);
742 static inline cp_token_position
743 cp_lexer_previous_token_position (cp_lexer
*lexer
)
745 if (lexer
->next_token
== &eof_token
)
746 return lexer
->last_token
- 1;
748 return cp_lexer_token_position (lexer
, true);
751 static inline cp_token
*
752 cp_lexer_previous_token (cp_lexer
*lexer
)
754 cp_token_position tp
= cp_lexer_previous_token_position (lexer
);
756 return cp_lexer_token_at (lexer
, tp
);
759 /* nonzero if we are presently saving tokens. */
762 cp_lexer_saving_tokens (const cp_lexer
* lexer
)
764 return lexer
->saved_tokens
.length () != 0;
767 /* Store the next token from the preprocessor in *TOKEN. Return true
768 if we reach EOF. If LEXER is NULL, assume we are handling an
769 initial #pragma pch_preprocess, and thus want the lexer to return
770 processed strings. */
773 cp_lexer_get_preprocessor_token (cp_lexer
*lexer
, cp_token
*token
)
775 static int is_extern_c
= 0;
777 /* Get a new token from the preprocessor. */
779 = c_lex_with_flags (&token
->u
.value
, &token
->location
, &token
->flags
,
780 lexer
== NULL
? 0 : C_LEX_STRING_NO_JOIN
);
781 token
->keyword
= RID_MAX
;
782 token
->pragma_kind
= PRAGMA_NONE
;
783 token
->purged_p
= false;
784 token
->error_reported
= false;
786 /* On some systems, some header files are surrounded by an
787 implicit extern "C" block. Set a flag in the token if it
788 comes from such a header. */
789 is_extern_c
+= pending_lang_change
;
790 pending_lang_change
= 0;
791 token
->implicit_extern_c
= is_extern_c
> 0;
793 /* Check to see if this token is a keyword. */
794 if (token
->type
== CPP_NAME
)
796 if (C_IS_RESERVED_WORD (token
->u
.value
))
798 /* Mark this token as a keyword. */
799 token
->type
= CPP_KEYWORD
;
800 /* Record which keyword. */
801 token
->keyword
= C_RID_CODE (token
->u
.value
);
805 if (warn_cxx0x_compat
806 && C_RID_CODE (token
->u
.value
) >= RID_FIRST_CXX0X
807 && C_RID_CODE (token
->u
.value
) <= RID_LAST_CXX0X
)
809 /* Warn about the C++0x keyword (but still treat it as
811 warning (OPT_Wc__0x_compat
,
812 "identifier %qE is a keyword in C++11",
815 /* Clear out the C_RID_CODE so we don't warn about this
816 particular identifier-turned-keyword again. */
817 C_SET_RID_CODE (token
->u
.value
, RID_MAX
);
820 token
->keyword
= RID_MAX
;
823 else if (token
->type
== CPP_AT_NAME
)
825 /* This only happens in Objective-C++; it must be a keyword. */
826 token
->type
= CPP_KEYWORD
;
827 switch (C_RID_CODE (token
->u
.value
))
829 /* Replace 'class' with '@class', 'private' with '@private',
830 etc. This prevents confusion with the C++ keyword
831 'class', and makes the tokens consistent with other
832 Objective-C 'AT' keywords. For example '@class' is
833 reported as RID_AT_CLASS which is consistent with
834 '@synchronized', which is reported as
837 case RID_CLASS
: token
->keyword
= RID_AT_CLASS
; break;
838 case RID_PRIVATE
: token
->keyword
= RID_AT_PRIVATE
; break;
839 case RID_PROTECTED
: token
->keyword
= RID_AT_PROTECTED
; break;
840 case RID_PUBLIC
: token
->keyword
= RID_AT_PUBLIC
; break;
841 case RID_THROW
: token
->keyword
= RID_AT_THROW
; break;
842 case RID_TRY
: token
->keyword
= RID_AT_TRY
; break;
843 case RID_CATCH
: token
->keyword
= RID_AT_CATCH
; break;
844 default: token
->keyword
= C_RID_CODE (token
->u
.value
);
847 else if (token
->type
== CPP_PRAGMA
)
849 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
850 token
->pragma_kind
= ((enum pragma_kind
)
851 TREE_INT_CST_LOW (token
->u
.value
));
852 token
->u
.value
= NULL_TREE
;
856 /* Update the globals input_location and the input file stack from TOKEN. */
858 cp_lexer_set_source_position_from_token (cp_token
*token
)
860 if (token
->type
!= CPP_EOF
)
862 input_location
= token
->location
;
866 /* Update the globals input_location and the input file stack from LEXER. */
868 cp_lexer_set_source_position (cp_lexer
*lexer
)
870 cp_token
*token
= cp_lexer_peek_token (lexer
);
871 cp_lexer_set_source_position_from_token (token
);
874 /* Return a pointer to the next token in the token stream, but do not
877 static inline cp_token
*
878 cp_lexer_peek_token (cp_lexer
*lexer
)
880 if (cp_lexer_debugging_p (lexer
))
882 fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream
);
883 cp_lexer_print_token (cp_lexer_debug_stream
, lexer
->next_token
);
884 putc ('\n', cp_lexer_debug_stream
);
886 return lexer
->next_token
;
889 /* Return true if the next token has the indicated TYPE. */
892 cp_lexer_next_token_is (cp_lexer
* lexer
, enum cpp_ttype type
)
894 return cp_lexer_peek_token (lexer
)->type
== type
;
897 /* Return true if the next token does not have the indicated TYPE. */
900 cp_lexer_next_token_is_not (cp_lexer
* lexer
, enum cpp_ttype type
)
902 return !cp_lexer_next_token_is (lexer
, type
);
905 /* Return true if the next token is the indicated KEYWORD. */
908 cp_lexer_next_token_is_keyword (cp_lexer
* lexer
, enum rid keyword
)
910 return cp_lexer_peek_token (lexer
)->keyword
== keyword
;
914 cp_lexer_nth_token_is (cp_lexer
* lexer
, size_t n
, enum cpp_ttype type
)
916 return cp_lexer_peek_nth_token (lexer
, n
)->type
== type
;
920 cp_lexer_nth_token_is_keyword (cp_lexer
* lexer
, size_t n
, enum rid keyword
)
922 return cp_lexer_peek_nth_token (lexer
, n
)->keyword
== keyword
;
925 /* Return true if the next token is not the indicated KEYWORD. */
928 cp_lexer_next_token_is_not_keyword (cp_lexer
* lexer
, enum rid keyword
)
930 return cp_lexer_peek_token (lexer
)->keyword
!= keyword
;
933 /* Return true if the next token is a keyword for a decl-specifier. */
936 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer
*lexer
)
940 token
= cp_lexer_peek_token (lexer
);
941 switch (token
->keyword
)
943 /* auto specifier: storage-class-specifier in C++,
944 simple-type-specifier in C++0x. */
946 /* Storage classes. */
952 /* Elaborated type specifiers. */
958 /* Simple type specifiers. */
972 /* GNU extensions. */
975 /* C++0x extensions. */
977 case RID_UNDERLYING_TYPE
:
981 if (token
->keyword
>= RID_FIRST_INT_N
982 && token
->keyword
< RID_FIRST_INT_N
+ NUM_INT_N_ENTS
983 && int_n_enabled_p
[token
->keyword
- RID_FIRST_INT_N
])
989 /* Returns TRUE iff the token T begins a decltype type. */
992 token_is_decltype (cp_token
*t
)
994 return (t
->keyword
== RID_DECLTYPE
995 || t
->type
== CPP_DECLTYPE
);
998 /* Returns TRUE iff the next token begins a decltype type. */
1001 cp_lexer_next_token_is_decltype (cp_lexer
*lexer
)
1003 cp_token
*t
= cp_lexer_peek_token (lexer
);
1004 return token_is_decltype (t
);
1007 /* Return a pointer to the Nth token in the token stream. If N is 1,
1008 then this is precisely equivalent to cp_lexer_peek_token (except
1009 that it is not inline). One would like to disallow that case, but
1010 there is one case (cp_parser_nth_token_starts_template_id) where
1011 the caller passes a variable for N and it might be 1. */
1014 cp_lexer_peek_nth_token (cp_lexer
* lexer
, size_t n
)
1018 /* N is 1-based, not zero-based. */
1021 if (cp_lexer_debugging_p (lexer
))
1022 fprintf (cp_lexer_debug_stream
,
1023 "cp_lexer: peeking ahead %ld at token: ", (long)n
);
1026 token
= lexer
->next_token
;
1027 gcc_assert (!n
|| token
!= &eof_token
);
1031 if (token
== lexer
->last_token
)
1037 if (!token
->purged_p
)
1041 if (cp_lexer_debugging_p (lexer
))
1043 cp_lexer_print_token (cp_lexer_debug_stream
, token
);
1044 putc ('\n', cp_lexer_debug_stream
);
1050 /* Return the next token, and advance the lexer's next_token pointer
1051 to point to the next non-purged token. */
1054 cp_lexer_consume_token (cp_lexer
* lexer
)
1056 cp_token
*token
= lexer
->next_token
;
1058 gcc_assert (token
!= &eof_token
);
1059 gcc_assert (!lexer
->in_pragma
|| token
->type
!= CPP_PRAGMA_EOL
);
1063 lexer
->next_token
++;
1064 if (lexer
->next_token
== lexer
->last_token
)
1066 lexer
->next_token
= &eof_token
;
1071 while (lexer
->next_token
->purged_p
);
1073 cp_lexer_set_source_position_from_token (token
);
1075 /* Provide debugging output. */
1076 if (cp_lexer_debugging_p (lexer
))
1078 fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream
);
1079 cp_lexer_print_token (cp_lexer_debug_stream
, token
);
1080 putc ('\n', cp_lexer_debug_stream
);
1086 /* Permanently remove the next token from the token stream, and
1087 advance the next_token pointer to refer to the next non-purged
1091 cp_lexer_purge_token (cp_lexer
*lexer
)
1093 cp_token
*tok
= lexer
->next_token
;
1095 gcc_assert (tok
!= &eof_token
);
1096 tok
->purged_p
= true;
1097 tok
->location
= UNKNOWN_LOCATION
;
1098 tok
->u
.value
= NULL_TREE
;
1099 tok
->keyword
= RID_MAX
;
1104 if (tok
== lexer
->last_token
)
1110 while (tok
->purged_p
);
1111 lexer
->next_token
= tok
;
1114 /* Permanently remove all tokens after TOK, up to, but not
1115 including, the token that will be returned next by
1116 cp_lexer_peek_token. */
1119 cp_lexer_purge_tokens_after (cp_lexer
*lexer
, cp_token
*tok
)
1121 cp_token
*peek
= lexer
->next_token
;
1123 if (peek
== &eof_token
)
1124 peek
= lexer
->last_token
;
1126 gcc_assert (tok
< peek
);
1128 for ( tok
+= 1; tok
!= peek
; tok
+= 1)
1130 tok
->purged_p
= true;
1131 tok
->location
= UNKNOWN_LOCATION
;
1132 tok
->u
.value
= NULL_TREE
;
1133 tok
->keyword
= RID_MAX
;
1137 /* Begin saving tokens. All tokens consumed after this point will be
1141 cp_lexer_save_tokens (cp_lexer
* lexer
)
1143 /* Provide debugging output. */
1144 if (cp_lexer_debugging_p (lexer
))
1145 fprintf (cp_lexer_debug_stream
, "cp_lexer: saving tokens\n");
1147 lexer
->saved_tokens
.safe_push (lexer
->next_token
);
1150 /* Commit to the portion of the token stream most recently saved. */
1153 cp_lexer_commit_tokens (cp_lexer
* lexer
)
1155 /* Provide debugging output. */
1156 if (cp_lexer_debugging_p (lexer
))
1157 fprintf (cp_lexer_debug_stream
, "cp_lexer: committing tokens\n");
1159 lexer
->saved_tokens
.pop ();
1162 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1163 to the token stream. Stop saving tokens. */
1166 cp_lexer_rollback_tokens (cp_lexer
* lexer
)
1168 /* Provide debugging output. */
1169 if (cp_lexer_debugging_p (lexer
))
1170 fprintf (cp_lexer_debug_stream
, "cp_lexer: restoring tokens\n");
1172 lexer
->next_token
= lexer
->saved_tokens
.pop ();
1175 /* RAII wrapper around the above functions, with sanity checking. Creating
1176 a variable saves tokens, which are committed when the variable is
1177 destroyed unless they are explicitly rolled back by calling the rollback
1180 struct saved_token_sentinel
1185 saved_token_sentinel(cp_lexer
*lexer
): lexer(lexer
), commit(true)
1187 len
= lexer
->saved_tokens
.length ();
1188 cp_lexer_save_tokens (lexer
);
1192 cp_lexer_rollback_tokens (lexer
);
1195 ~saved_token_sentinel()
1198 cp_lexer_commit_tokens (lexer
);
1199 gcc_assert (lexer
->saved_tokens
.length () == len
);
1203 /* Print a representation of the TOKEN on the STREAM. */
1206 cp_lexer_print_token (FILE * stream
, cp_token
*token
)
1208 /* We don't use cpp_type2name here because the parser defines
1209 a few tokens of its own. */
1210 static const char *const token_names
[] = {
1211 /* cpplib-defined token types */
1212 #define OP(e, s) #e,
1213 #define TK(e, s) #e,
1217 /* C++ parser token types - see "Manifest constants", above. */
1220 "NESTED_NAME_SPECIFIER",
1223 /* For some tokens, print the associated data. */
1224 switch (token
->type
)
1227 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1228 For example, `struct' is mapped to an INTEGER_CST. */
1229 if (!identifier_p (token
->u
.value
))
1231 /* else fall through */
1233 fputs (IDENTIFIER_POINTER (token
->u
.value
), stream
);
1240 case CPP_UTF8STRING
:
1241 fprintf (stream
, " \"%s\"", TREE_STRING_POINTER (token
->u
.value
));
1245 print_generic_expr (stream
, token
->u
.value
, 0);
1249 /* If we have a name for the token, print it out. Otherwise, we
1250 simply give the numeric code. */
1251 if (token
->type
< ARRAY_SIZE(token_names
))
1252 fputs (token_names
[token
->type
], stream
);
1254 fprintf (stream
, "[%d]", token
->type
);
1260 debug (cp_token
&ref
)
1262 cp_lexer_print_token (stderr
, &ref
);
1263 fprintf (stderr
, "\n");
1267 debug (cp_token
*ptr
)
1272 fprintf (stderr
, "<nil>\n");
1276 /* Start emitting debugging information. */
1279 cp_lexer_start_debugging (cp_lexer
* lexer
)
1281 lexer
->debugging_p
= true;
1282 cp_lexer_debug_stream
= stderr
;
1285 /* Stop emitting debugging information. */
1288 cp_lexer_stop_debugging (cp_lexer
* lexer
)
1290 lexer
->debugging_p
= false;
1291 cp_lexer_debug_stream
= NULL
;
1294 /* Create a new cp_token_cache, representing a range of tokens. */
1296 static cp_token_cache
*
1297 cp_token_cache_new (cp_token
*first
, cp_token
*last
)
1299 cp_token_cache
*cache
= ggc_alloc
<cp_token_cache
> ();
1300 cache
->first
= first
;
1305 /* Diagnose if #pragma omp declare simd isn't followed immediately
1306 by function declaration or definition. */
1309 cp_ensure_no_omp_declare_simd (cp_parser
*parser
)
1311 if (parser
->omp_declare_simd
&& !parser
->omp_declare_simd
->error_seen
)
1313 error ("%<#pragma omp declare simd%> not immediately followed by "
1314 "function declaration or definition");
1315 parser
->omp_declare_simd
= NULL
;
1319 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1320 and put that into "omp declare simd" attribute. */
1323 cp_finalize_omp_declare_simd (cp_parser
*parser
, tree fndecl
)
1325 if (__builtin_expect (parser
->omp_declare_simd
!= NULL
, 0))
1327 if (fndecl
== error_mark_node
)
1329 parser
->omp_declare_simd
= NULL
;
1332 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1334 cp_ensure_no_omp_declare_simd (parser
);
1340 /* Decl-specifiers. */
1342 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1345 clear_decl_specs (cp_decl_specifier_seq
*decl_specs
)
1347 memset (decl_specs
, 0, sizeof (cp_decl_specifier_seq
));
1352 /* Nothing other than the parser should be creating declarators;
1353 declarators are a semi-syntactic representation of C++ entities.
1354 Other parts of the front end that need to create entities (like
1355 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1357 static cp_declarator
*make_call_declarator
1358 (cp_declarator
*, tree
, cp_cv_quals
, cp_virt_specifiers
, cp_ref_qualifier
, tree
, tree
);
1359 static cp_declarator
*make_array_declarator
1360 (cp_declarator
*, tree
);
1361 static cp_declarator
*make_pointer_declarator
1362 (cp_cv_quals
, cp_declarator
*, tree
);
1363 static cp_declarator
*make_reference_declarator
1364 (cp_cv_quals
, cp_declarator
*, bool, tree
);
1365 static cp_parameter_declarator
*make_parameter_declarator
1366 (cp_decl_specifier_seq
*, cp_declarator
*, tree
);
1367 static cp_declarator
*make_ptrmem_declarator
1368 (cp_cv_quals
, tree
, cp_declarator
*, tree
);
1370 /* An erroneous declarator. */
1371 static cp_declarator
*cp_error_declarator
;
1373 /* The obstack on which declarators and related data structures are
1375 static struct obstack declarator_obstack
;
1377 /* Alloc BYTES from the declarator memory pool. */
1379 static inline void *
1380 alloc_declarator (size_t bytes
)
1382 return obstack_alloc (&declarator_obstack
, bytes
);
1385 /* Allocate a declarator of the indicated KIND. Clear fields that are
1386 common to all declarators. */
1388 static cp_declarator
*
1389 make_declarator (cp_declarator_kind kind
)
1391 cp_declarator
*declarator
;
1393 declarator
= (cp_declarator
*) alloc_declarator (sizeof (cp_declarator
));
1394 declarator
->kind
= kind
;
1395 declarator
->attributes
= NULL_TREE
;
1396 declarator
->std_attributes
= NULL_TREE
;
1397 declarator
->declarator
= NULL
;
1398 declarator
->parameter_pack_p
= false;
1399 declarator
->id_loc
= UNKNOWN_LOCATION
;
1404 /* Make a declarator for a generalized identifier. If
1405 QUALIFYING_SCOPE is non-NULL, the identifier is
1406 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1407 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1410 static cp_declarator
*
1411 make_id_declarator (tree qualifying_scope
, tree unqualified_name
,
1412 special_function_kind sfk
)
1414 cp_declarator
*declarator
;
1416 /* It is valid to write:
1418 class C { void f(); };
1422 The standard is not clear about whether `typedef const C D' is
1423 legal; as of 2002-09-15 the committee is considering that
1424 question. EDG 3.0 allows that syntax. Therefore, we do as
1426 if (qualifying_scope
&& TYPE_P (qualifying_scope
))
1427 qualifying_scope
= TYPE_MAIN_VARIANT (qualifying_scope
);
1429 gcc_assert (identifier_p (unqualified_name
)
1430 || TREE_CODE (unqualified_name
) == BIT_NOT_EXPR
1431 || TREE_CODE (unqualified_name
) == TEMPLATE_ID_EXPR
);
1433 declarator
= make_declarator (cdk_id
);
1434 declarator
->u
.id
.qualifying_scope
= qualifying_scope
;
1435 declarator
->u
.id
.unqualified_name
= unqualified_name
;
1436 declarator
->u
.id
.sfk
= sfk
;
1441 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1442 of modifiers such as const or volatile to apply to the pointer
1443 type, represented as identifiers. ATTRIBUTES represent the attributes that
1444 appertain to the pointer or reference. */
1447 make_pointer_declarator (cp_cv_quals cv_qualifiers
, cp_declarator
*target
,
1450 cp_declarator
*declarator
;
1452 declarator
= make_declarator (cdk_pointer
);
1453 declarator
->declarator
= target
;
1454 declarator
->u
.pointer
.qualifiers
= cv_qualifiers
;
1455 declarator
->u
.pointer
.class_type
= NULL_TREE
;
1458 declarator
->id_loc
= target
->id_loc
;
1459 declarator
->parameter_pack_p
= target
->parameter_pack_p
;
1460 target
->parameter_pack_p
= false;
1463 declarator
->parameter_pack_p
= false;
1465 declarator
->std_attributes
= attributes
;
1470 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1471 represent the attributes that appertain to the pointer or
1475 make_reference_declarator (cp_cv_quals cv_qualifiers
, cp_declarator
*target
,
1476 bool rvalue_ref
, tree attributes
)
1478 cp_declarator
*declarator
;
1480 declarator
= make_declarator (cdk_reference
);
1481 declarator
->declarator
= target
;
1482 declarator
->u
.reference
.qualifiers
= cv_qualifiers
;
1483 declarator
->u
.reference
.rvalue_ref
= rvalue_ref
;
1486 declarator
->id_loc
= target
->id_loc
;
1487 declarator
->parameter_pack_p
= target
->parameter_pack_p
;
1488 target
->parameter_pack_p
= false;
1491 declarator
->parameter_pack_p
= false;
1493 declarator
->std_attributes
= attributes
;
1498 /* Like make_pointer_declarator -- but for a pointer to a non-static
1499 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1500 appertain to the pointer or reference. */
1503 make_ptrmem_declarator (cp_cv_quals cv_qualifiers
, tree class_type
,
1504 cp_declarator
*pointee
,
1507 cp_declarator
*declarator
;
1509 declarator
= make_declarator (cdk_ptrmem
);
1510 declarator
->declarator
= pointee
;
1511 declarator
->u
.pointer
.qualifiers
= cv_qualifiers
;
1512 declarator
->u
.pointer
.class_type
= class_type
;
1516 declarator
->parameter_pack_p
= pointee
->parameter_pack_p
;
1517 pointee
->parameter_pack_p
= false;
1520 declarator
->parameter_pack_p
= false;
1522 declarator
->std_attributes
= attributes
;
1527 /* Make a declarator for the function given by TARGET, with the
1528 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1529 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1530 indicates what exceptions can be thrown. */
1533 make_call_declarator (cp_declarator
*target
,
1535 cp_cv_quals cv_qualifiers
,
1536 cp_virt_specifiers virt_specifiers
,
1537 cp_ref_qualifier ref_qualifier
,
1538 tree exception_specification
,
1539 tree late_return_type
)
1541 cp_declarator
*declarator
;
1543 declarator
= make_declarator (cdk_function
);
1544 declarator
->declarator
= target
;
1545 declarator
->u
.function
.parameters
= parms
;
1546 declarator
->u
.function
.qualifiers
= cv_qualifiers
;
1547 declarator
->u
.function
.virt_specifiers
= virt_specifiers
;
1548 declarator
->u
.function
.ref_qualifier
= ref_qualifier
;
1549 declarator
->u
.function
.exception_specification
= exception_specification
;
1550 declarator
->u
.function
.late_return_type
= late_return_type
;
1553 declarator
->id_loc
= target
->id_loc
;
1554 declarator
->parameter_pack_p
= target
->parameter_pack_p
;
1555 target
->parameter_pack_p
= false;
1558 declarator
->parameter_pack_p
= false;
1563 /* Make a declarator for an array of BOUNDS elements, each of which is
1564 defined by ELEMENT. */
1567 make_array_declarator (cp_declarator
*element
, tree bounds
)
1569 cp_declarator
*declarator
;
1571 declarator
= make_declarator (cdk_array
);
1572 declarator
->declarator
= element
;
1573 declarator
->u
.array
.bounds
= bounds
;
1576 declarator
->id_loc
= element
->id_loc
;
1577 declarator
->parameter_pack_p
= element
->parameter_pack_p
;
1578 element
->parameter_pack_p
= false;
1581 declarator
->parameter_pack_p
= false;
1586 /* Determine whether the declarator we've seen so far can be a
1587 parameter pack, when followed by an ellipsis. */
1589 declarator_can_be_parameter_pack (cp_declarator
*declarator
)
1591 /* Search for a declarator name, or any other declarator that goes
1592 after the point where the ellipsis could appear in a parameter
1593 pack. If we find any of these, then this declarator can not be
1594 made into a parameter pack. */
1596 while (declarator
&& !found
)
1598 switch ((int)declarator
->kind
)
1609 declarator
= declarator
->declarator
;
1617 cp_parameter_declarator
*no_parameters
;
1619 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1620 DECLARATOR and DEFAULT_ARGUMENT. */
1622 cp_parameter_declarator
*
1623 make_parameter_declarator (cp_decl_specifier_seq
*decl_specifiers
,
1624 cp_declarator
*declarator
,
1625 tree default_argument
)
1627 cp_parameter_declarator
*parameter
;
1629 parameter
= ((cp_parameter_declarator
*)
1630 alloc_declarator (sizeof (cp_parameter_declarator
)));
1631 parameter
->next
= NULL
;
1632 if (decl_specifiers
)
1633 parameter
->decl_specifiers
= *decl_specifiers
;
1635 clear_decl_specs (¶meter
->decl_specifiers
);
1636 parameter
->declarator
= declarator
;
1637 parameter
->default_argument
= default_argument
;
1638 parameter
->ellipsis_p
= false;
1643 /* Returns true iff DECLARATOR is a declaration for a function. */
1646 function_declarator_p (const cp_declarator
*declarator
)
1650 if (declarator
->kind
== cdk_function
1651 && declarator
->declarator
->kind
== cdk_id
)
1653 if (declarator
->kind
== cdk_id
1654 || declarator
->kind
== cdk_error
)
1656 declarator
= declarator
->declarator
;
1666 A cp_parser parses the token stream as specified by the C++
1667 grammar. Its job is purely parsing, not semantic analysis. For
1668 example, the parser breaks the token stream into declarators,
1669 expressions, statements, and other similar syntactic constructs.
1670 It does not check that the types of the expressions on either side
1671 of an assignment-statement are compatible, or that a function is
1672 not declared with a parameter of type `void'.
1674 The parser invokes routines elsewhere in the compiler to perform
1675 semantic analysis and to build up the abstract syntax tree for the
1678 The parser (and the template instantiation code, which is, in a
1679 way, a close relative of parsing) are the only parts of the
1680 compiler that should be calling push_scope and pop_scope, or
1681 related functions. The parser (and template instantiation code)
1682 keeps track of what scope is presently active; everything else
1683 should simply honor that. (The code that generates static
1684 initializers may also need to set the scope, in order to check
1685 access control correctly when emitting the initializers.)
1690 The parser is of the standard recursive-descent variety. Upcoming
1691 tokens in the token stream are examined in order to determine which
1692 production to use when parsing a non-terminal. Some C++ constructs
1693 require arbitrary look ahead to disambiguate. For example, it is
1694 impossible, in the general case, to tell whether a statement is an
1695 expression or declaration without scanning the entire statement.
1696 Therefore, the parser is capable of "parsing tentatively." When the
1697 parser is not sure what construct comes next, it enters this mode.
1698 Then, while we attempt to parse the construct, the parser queues up
1699 error messages, rather than issuing them immediately, and saves the
1700 tokens it consumes. If the construct is parsed successfully, the
1701 parser "commits", i.e., it issues any queued error messages and
1702 the tokens that were being preserved are permanently discarded.
1703 If, however, the construct is not parsed successfully, the parser
1704 rolls back its state completely so that it can resume parsing using
1705 a different alternative.
1710 The performance of the parser could probably be improved substantially.
1711 We could often eliminate the need to parse tentatively by looking ahead
1712 a little bit. In some places, this approach might not entirely eliminate
1713 the need to parse tentatively, but it might still speed up the average
1716 /* Flags that are passed to some parsing functions. These values can
1717 be bitwise-ored together. */
1722 CP_PARSER_FLAGS_NONE
= 0x0,
1723 /* The construct is optional. If it is not present, then no error
1724 should be issued. */
1725 CP_PARSER_FLAGS_OPTIONAL
= 0x1,
1726 /* When parsing a type-specifier, treat user-defined type-names
1727 as non-type identifiers. */
1728 CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
= 0x2,
1729 /* When parsing a type-specifier, do not try to parse a class-specifier
1730 or enum-specifier. */
1731 CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS
= 0x4,
1732 /* When parsing a decl-specifier-seq, only allow type-specifier or
1734 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR
= 0x8
1737 /* This type is used for parameters and variables which hold
1738 combinations of the above flags. */
1739 typedef int cp_parser_flags
;
1741 /* The different kinds of declarators we want to parse. */
1743 typedef enum cp_parser_declarator_kind
1745 /* We want an abstract declarator. */
1746 CP_PARSER_DECLARATOR_ABSTRACT
,
1747 /* We want a named declarator. */
1748 CP_PARSER_DECLARATOR_NAMED
,
1749 /* We don't mind, but the name must be an unqualified-id. */
1750 CP_PARSER_DECLARATOR_EITHER
1751 } cp_parser_declarator_kind
;
1753 /* The precedence values used to parse binary expressions. The minimum value
1754 of PREC must be 1, because zero is reserved to quickly discriminate
1755 binary operators from other tokens. */
1760 PREC_LOGICAL_OR_EXPRESSION
,
1761 PREC_LOGICAL_AND_EXPRESSION
,
1762 PREC_INCLUSIVE_OR_EXPRESSION
,
1763 PREC_EXCLUSIVE_OR_EXPRESSION
,
1764 PREC_AND_EXPRESSION
,
1765 PREC_EQUALITY_EXPRESSION
,
1766 PREC_RELATIONAL_EXPRESSION
,
1767 PREC_SHIFT_EXPRESSION
,
1768 PREC_ADDITIVE_EXPRESSION
,
1769 PREC_MULTIPLICATIVE_EXPRESSION
,
1771 NUM_PREC_VALUES
= PREC_PM_EXPRESSION
1774 /* A mapping from a token type to a corresponding tree node type, with a
1775 precedence value. */
1777 typedef struct cp_parser_binary_operations_map_node
1779 /* The token type. */
1780 enum cpp_ttype token_type
;
1781 /* The corresponding tree code. */
1782 enum tree_code tree_type
;
1783 /* The precedence of this operator. */
1784 enum cp_parser_prec prec
;
1785 } cp_parser_binary_operations_map_node
;
1787 typedef struct cp_parser_expression_stack_entry
1789 /* Left hand side of the binary operation we are currently
1792 /* Original tree code for left hand side, if it was a binary
1793 expression itself (used for -Wparentheses). */
1794 enum tree_code lhs_type
;
1795 /* Tree code for the binary operation we are parsing. */
1796 enum tree_code tree_type
;
1797 /* Precedence of the binary operation we are parsing. */
1798 enum cp_parser_prec prec
;
1799 /* Location of the binary operation we are parsing. */
1801 } cp_parser_expression_stack_entry
;
1803 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1804 entries because precedence levels on the stack are monotonically
1806 typedef struct cp_parser_expression_stack_entry
1807 cp_parser_expression_stack
[NUM_PREC_VALUES
];
1811 /* Constructors and destructors. */
1813 static cp_parser_context
*cp_parser_context_new
1814 (cp_parser_context
*);
1816 /* Class variables. */
1818 static GTY((deletable
)) cp_parser_context
* cp_parser_context_free_list
;
1820 /* The operator-precedence table used by cp_parser_binary_expression.
1821 Transformed into an associative array (binops_by_token) by
1824 static const cp_parser_binary_operations_map_node binops
[] = {
1825 { CPP_DEREF_STAR
, MEMBER_REF
, PREC_PM_EXPRESSION
},
1826 { CPP_DOT_STAR
, DOTSTAR_EXPR
, PREC_PM_EXPRESSION
},
1828 { CPP_MULT
, MULT_EXPR
, PREC_MULTIPLICATIVE_EXPRESSION
},
1829 { CPP_DIV
, TRUNC_DIV_EXPR
, PREC_MULTIPLICATIVE_EXPRESSION
},
1830 { CPP_MOD
, TRUNC_MOD_EXPR
, PREC_MULTIPLICATIVE_EXPRESSION
},
1832 { CPP_PLUS
, PLUS_EXPR
, PREC_ADDITIVE_EXPRESSION
},
1833 { CPP_MINUS
, MINUS_EXPR
, PREC_ADDITIVE_EXPRESSION
},
1835 { CPP_LSHIFT
, LSHIFT_EXPR
, PREC_SHIFT_EXPRESSION
},
1836 { CPP_RSHIFT
, RSHIFT_EXPR
, PREC_SHIFT_EXPRESSION
},
1838 { CPP_LESS
, LT_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1839 { CPP_GREATER
, GT_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1840 { CPP_LESS_EQ
, LE_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1841 { CPP_GREATER_EQ
, GE_EXPR
, PREC_RELATIONAL_EXPRESSION
},
1843 { CPP_EQ_EQ
, EQ_EXPR
, PREC_EQUALITY_EXPRESSION
},
1844 { CPP_NOT_EQ
, NE_EXPR
, PREC_EQUALITY_EXPRESSION
},
1846 { CPP_AND
, BIT_AND_EXPR
, PREC_AND_EXPRESSION
},
1848 { CPP_XOR
, BIT_XOR_EXPR
, PREC_EXCLUSIVE_OR_EXPRESSION
},
1850 { CPP_OR
, BIT_IOR_EXPR
, PREC_INCLUSIVE_OR_EXPRESSION
},
1852 { CPP_AND_AND
, TRUTH_ANDIF_EXPR
, PREC_LOGICAL_AND_EXPRESSION
},
1854 { CPP_OR_OR
, TRUTH_ORIF_EXPR
, PREC_LOGICAL_OR_EXPRESSION
}
1857 /* The same as binops, but initialized by cp_parser_new so that
1858 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1860 static cp_parser_binary_operations_map_node binops_by_token
[N_CP_TTYPES
];
1862 /* Constructors and destructors. */
1864 /* Construct a new context. The context below this one on the stack
1865 is given by NEXT. */
1867 static cp_parser_context
*
1868 cp_parser_context_new (cp_parser_context
* next
)
1870 cp_parser_context
*context
;
1872 /* Allocate the storage. */
1873 if (cp_parser_context_free_list
!= NULL
)
1875 /* Pull the first entry from the free list. */
1876 context
= cp_parser_context_free_list
;
1877 cp_parser_context_free_list
= context
->next
;
1878 memset (context
, 0, sizeof (*context
));
1881 context
= ggc_cleared_alloc
<cp_parser_context
> ();
1883 /* No errors have occurred yet in this context. */
1884 context
->status
= CP_PARSER_STATUS_KIND_NO_ERROR
;
1885 /* If this is not the bottommost context, copy information that we
1886 need from the previous context. */
1889 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1890 expression, then we are parsing one in this context, too. */
1891 context
->object_type
= next
->object_type
;
1892 /* Thread the stack. */
1893 context
->next
= next
;
1899 /* Managing the unparsed function queues. */
1901 #define unparsed_funs_with_default_args \
1902 parser->unparsed_queues->last ().funs_with_default_args
1903 #define unparsed_funs_with_definitions \
1904 parser->unparsed_queues->last ().funs_with_definitions
1905 #define unparsed_nsdmis \
1906 parser->unparsed_queues->last ().nsdmis
1907 #define unparsed_classes \
1908 parser->unparsed_queues->last ().classes
1911 push_unparsed_function_queues (cp_parser
*parser
)
1913 cp_unparsed_functions_entry e
= {NULL
, make_tree_vector (), NULL
, NULL
};
1914 vec_safe_push (parser
->unparsed_queues
, e
);
1918 pop_unparsed_function_queues (cp_parser
*parser
)
1920 release_tree_vector (unparsed_funs_with_definitions
);
1921 parser
->unparsed_queues
->pop ();
1926 /* Constructors and destructors. */
1928 static cp_parser
*cp_parser_new
1931 /* Routines to parse various constructs.
1933 Those that return `tree' will return the error_mark_node (rather
1934 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1935 Sometimes, they will return an ordinary node if error-recovery was
1936 attempted, even though a parse error occurred. So, to check
1937 whether or not a parse error occurred, you should always use
1938 cp_parser_error_occurred. If the construct is optional (indicated
1939 either by an `_opt' in the name of the function that does the
1940 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1941 the construct is not present. */
1943 /* Lexical conventions [gram.lex] */
1945 static tree cp_parser_identifier
1947 static tree cp_parser_string_literal
1948 (cp_parser
*, bool, bool, bool);
1949 static tree cp_parser_userdef_char_literal
1951 static tree cp_parser_userdef_string_literal
1953 static tree cp_parser_userdef_numeric_literal
1956 /* Basic concepts [gram.basic] */
1958 static bool cp_parser_translation_unit
1961 /* Expressions [gram.expr] */
1963 static tree cp_parser_primary_expression
1964 (cp_parser
*, bool, bool, bool, cp_id_kind
*);
1965 static tree cp_parser_id_expression
1966 (cp_parser
*, bool, bool, bool *, bool, bool);
1967 static tree cp_parser_unqualified_id
1968 (cp_parser
*, bool, bool, bool, bool);
1969 static tree cp_parser_nested_name_specifier_opt
1970 (cp_parser
*, bool, bool, bool, bool);
1971 static tree cp_parser_nested_name_specifier
1972 (cp_parser
*, bool, bool, bool, bool);
1973 static tree cp_parser_qualifying_entity
1974 (cp_parser
*, bool, bool, bool, bool, bool);
1975 static tree cp_parser_postfix_expression
1976 (cp_parser
*, bool, bool, bool, bool, cp_id_kind
*);
1977 static tree cp_parser_postfix_open_square_expression
1978 (cp_parser
*, tree
, bool, bool);
1979 static tree cp_parser_postfix_dot_deref_expression
1980 (cp_parser
*, enum cpp_ttype
, tree
, bool, cp_id_kind
*, location_t
);
1981 static vec
<tree
, va_gc
> *cp_parser_parenthesized_expression_list
1982 (cp_parser
*, int, bool, bool, bool *, bool = false);
1983 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1984 enum { non_attr
= 0, normal_attr
= 1, id_attr
= 2 };
1985 static void cp_parser_pseudo_destructor_name
1986 (cp_parser
*, tree
, tree
*, tree
*);
1987 static tree cp_parser_unary_expression
1988 (cp_parser
*, cp_id_kind
* = NULL
, bool = false, bool = false, bool = false);
1989 static enum tree_code cp_parser_unary_operator
1991 static tree cp_parser_new_expression
1993 static vec
<tree
, va_gc
> *cp_parser_new_placement
1995 static tree cp_parser_new_type_id
1996 (cp_parser
*, tree
*);
1997 static cp_declarator
*cp_parser_new_declarator_opt
1999 static cp_declarator
*cp_parser_direct_new_declarator
2001 static vec
<tree
, va_gc
> *cp_parser_new_initializer
2003 static tree cp_parser_delete_expression
2005 static tree cp_parser_cast_expression
2006 (cp_parser
*, bool, bool, bool, cp_id_kind
*);
2007 static tree cp_parser_binary_expression
2008 (cp_parser
*, bool, bool, enum cp_parser_prec
, cp_id_kind
*);
2009 static tree cp_parser_question_colon_clause
2010 (cp_parser
*, tree
);
2011 static tree cp_parser_assignment_expression
2012 (cp_parser
*, cp_id_kind
* = NULL
, bool = false, bool = false);
2013 static enum tree_code cp_parser_assignment_operator_opt
2015 static tree cp_parser_expression
2016 (cp_parser
*, cp_id_kind
* = NULL
, bool = false, bool = false);
2017 static tree cp_parser_constant_expression
2018 (cp_parser
*, bool = false, bool * = NULL
);
2019 static tree cp_parser_builtin_offsetof
2021 static tree cp_parser_lambda_expression
2023 static void cp_parser_lambda_introducer
2024 (cp_parser
*, tree
);
2025 static bool cp_parser_lambda_declarator_opt
2026 (cp_parser
*, tree
);
2027 static void cp_parser_lambda_body
2028 (cp_parser
*, tree
);
2030 /* Statements [gram.stmt.stmt] */
2032 static void cp_parser_statement
2033 (cp_parser
*, tree
, bool, bool *);
2034 static void cp_parser_label_for_labeled_statement
2035 (cp_parser
*, tree
);
2036 static tree cp_parser_expression_statement
2037 (cp_parser
*, tree
);
2038 static tree cp_parser_compound_statement
2039 (cp_parser
*, tree
, bool, bool);
2040 static void cp_parser_statement_seq_opt
2041 (cp_parser
*, tree
);
2042 static tree cp_parser_selection_statement
2043 (cp_parser
*, bool *);
2044 static tree cp_parser_condition
2046 static tree cp_parser_iteration_statement
2047 (cp_parser
*, bool);
2048 static bool cp_parser_for_init_statement
2049 (cp_parser
*, tree
*decl
);
2050 static tree cp_parser_for
2051 (cp_parser
*, bool);
2052 static tree cp_parser_c_for
2053 (cp_parser
*, tree
, tree
, bool);
2054 static tree cp_parser_range_for
2055 (cp_parser
*, tree
, tree
, tree
, bool);
2056 static void do_range_for_auto_deduction
2058 static tree cp_parser_perform_range_for_lookup
2059 (tree
, tree
*, tree
*);
2060 static tree cp_parser_range_for_member_function
2062 static tree cp_parser_jump_statement
2064 static void cp_parser_declaration_statement
2067 static tree cp_parser_implicitly_scoped_statement
2068 (cp_parser
*, bool *);
2069 static void cp_parser_already_scoped_statement
2072 /* Declarations [gram.dcl.dcl] */
2074 static void cp_parser_declaration_seq_opt
2076 static void cp_parser_declaration
2078 static void cp_parser_block_declaration
2079 (cp_parser
*, bool);
2080 static void cp_parser_simple_declaration
2081 (cp_parser
*, bool, tree
*);
2082 static void cp_parser_decl_specifier_seq
2083 (cp_parser
*, cp_parser_flags
, cp_decl_specifier_seq
*, int *);
2084 static tree cp_parser_storage_class_specifier_opt
2086 static tree cp_parser_function_specifier_opt
2087 (cp_parser
*, cp_decl_specifier_seq
*);
2088 static tree cp_parser_type_specifier
2089 (cp_parser
*, cp_parser_flags
, cp_decl_specifier_seq
*, bool,
2091 static tree cp_parser_simple_type_specifier
2092 (cp_parser
*, cp_decl_specifier_seq
*, cp_parser_flags
);
2093 static tree cp_parser_type_name
2095 static tree cp_parser_nonclass_name
2096 (cp_parser
* parser
);
2097 static tree cp_parser_elaborated_type_specifier
2098 (cp_parser
*, bool, bool);
2099 static tree cp_parser_enum_specifier
2101 static void cp_parser_enumerator_list
2102 (cp_parser
*, tree
);
2103 static void cp_parser_enumerator_definition
2104 (cp_parser
*, tree
);
2105 static tree cp_parser_namespace_name
2107 static void cp_parser_namespace_definition
2109 static void cp_parser_namespace_body
2111 static tree cp_parser_qualified_namespace_specifier
2113 static void cp_parser_namespace_alias_definition
2115 static bool cp_parser_using_declaration
2116 (cp_parser
*, bool);
2117 static void cp_parser_using_directive
2119 static tree cp_parser_alias_declaration
2121 static void cp_parser_asm_definition
2123 static void cp_parser_linkage_specification
2125 static void cp_parser_static_assert
2126 (cp_parser
*, bool);
2127 static tree cp_parser_decltype
2130 /* Declarators [gram.dcl.decl] */
2132 static tree cp_parser_init_declarator
2133 (cp_parser
*, cp_decl_specifier_seq
*, vec
<deferred_access_check
, va_gc
> *,
2134 bool, bool, int, bool *, tree
*, location_t
*);
2135 static cp_declarator
*cp_parser_declarator
2136 (cp_parser
*, cp_parser_declarator_kind
, int *, bool *, bool, bool);
2137 static cp_declarator
*cp_parser_direct_declarator
2138 (cp_parser
*, cp_parser_declarator_kind
, int *, bool, bool);
2139 static enum tree_code cp_parser_ptr_operator
2140 (cp_parser
*, tree
*, cp_cv_quals
*, tree
*);
2141 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2143 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2145 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2147 static tree cp_parser_late_return_type_opt
2148 (cp_parser
*, cp_declarator
*, cp_cv_quals
);
2149 static tree cp_parser_declarator_id
2150 (cp_parser
*, bool);
2151 static tree cp_parser_type_id
2153 static tree cp_parser_template_type_arg
2155 static tree
cp_parser_trailing_type_id (cp_parser
*);
2156 static tree cp_parser_type_id_1
2157 (cp_parser
*, bool, bool);
2158 static void cp_parser_type_specifier_seq
2159 (cp_parser
*, bool, bool, cp_decl_specifier_seq
*);
2160 static tree cp_parser_parameter_declaration_clause
2162 static tree cp_parser_parameter_declaration_list
2163 (cp_parser
*, bool *);
2164 static cp_parameter_declarator
*cp_parser_parameter_declaration
2165 (cp_parser
*, bool, bool *);
2166 static tree cp_parser_default_argument
2167 (cp_parser
*, bool);
2168 static void cp_parser_function_body
2169 (cp_parser
*, bool);
2170 static tree cp_parser_initializer
2171 (cp_parser
*, bool *, bool *);
2172 static tree cp_parser_initializer_clause
2173 (cp_parser
*, bool *);
2174 static tree cp_parser_braced_list
2175 (cp_parser
*, bool*);
2176 static vec
<constructor_elt
, va_gc
> *cp_parser_initializer_list
2177 (cp_parser
*, bool *);
2179 static bool cp_parser_ctor_initializer_opt_and_function_body
2180 (cp_parser
*, bool);
2182 static tree cp_parser_late_parsing_omp_declare_simd
2183 (cp_parser
*, tree
);
2185 static tree cp_parser_late_parsing_cilk_simd_fn_info
2186 (cp_parser
*, tree
);
2188 static tree synthesize_implicit_template_parm
2190 static tree finish_fully_implicit_template
2191 (cp_parser
*, tree
);
2193 /* Classes [gram.class] */
2195 static tree cp_parser_class_name
2196 (cp_parser
*, bool, bool, enum tag_types
, bool, bool, bool, bool = false);
2197 static tree cp_parser_class_specifier
2199 static tree cp_parser_class_head
2200 (cp_parser
*, bool *);
2201 static enum tag_types cp_parser_class_key
2203 static void cp_parser_type_parameter_key
2204 (cp_parser
* parser
);
2205 static void cp_parser_member_specification_opt
2207 static void cp_parser_member_declaration
2209 static tree cp_parser_pure_specifier
2211 static tree cp_parser_constant_initializer
2214 /* Derived classes [gram.class.derived] */
2216 static tree cp_parser_base_clause
2218 static tree cp_parser_base_specifier
2221 /* Special member functions [gram.special] */
2223 static tree cp_parser_conversion_function_id
2225 static tree cp_parser_conversion_type_id
2227 static cp_declarator
*cp_parser_conversion_declarator_opt
2229 static bool cp_parser_ctor_initializer_opt
2231 static void cp_parser_mem_initializer_list
2233 static tree cp_parser_mem_initializer
2235 static tree cp_parser_mem_initializer_id
2238 /* Overloading [gram.over] */
2240 static tree cp_parser_operator_function_id
2242 static tree cp_parser_operator
2245 /* Templates [gram.temp] */
2247 static void cp_parser_template_declaration
2248 (cp_parser
*, bool);
2249 static tree cp_parser_template_parameter_list
2251 static tree cp_parser_template_parameter
2252 (cp_parser
*, bool *, bool *);
2253 static tree cp_parser_type_parameter
2254 (cp_parser
*, bool *);
2255 static tree cp_parser_template_id
2256 (cp_parser
*, bool, bool, enum tag_types
, bool);
2257 static tree cp_parser_template_name
2258 (cp_parser
*, bool, bool, bool, enum tag_types
, bool *);
2259 static tree cp_parser_template_argument_list
2261 static tree cp_parser_template_argument
2263 static void cp_parser_explicit_instantiation
2265 static void cp_parser_explicit_specialization
2268 /* Exception handling [gram.exception] */
2270 static tree cp_parser_try_block
2272 static bool cp_parser_function_try_block
2274 static void cp_parser_handler_seq
2276 static void cp_parser_handler
2278 static tree cp_parser_exception_declaration
2280 static tree cp_parser_throw_expression
2282 static tree cp_parser_exception_specification_opt
2284 static tree cp_parser_type_id_list
2287 /* GNU Extensions */
2289 static tree cp_parser_asm_specification_opt
2291 static tree cp_parser_asm_operand_list
2293 static tree cp_parser_asm_clobber_list
2295 static tree cp_parser_asm_label_list
2297 static bool cp_next_tokens_can_be_attribute_p
2299 static bool cp_next_tokens_can_be_gnu_attribute_p
2301 static bool cp_next_tokens_can_be_std_attribute_p
2303 static bool cp_nth_tokens_can_be_std_attribute_p
2304 (cp_parser
*, size_t);
2305 static bool cp_nth_tokens_can_be_gnu_attribute_p
2306 (cp_parser
*, size_t);
2307 static bool cp_nth_tokens_can_be_attribute_p
2308 (cp_parser
*, size_t);
2309 static tree cp_parser_attributes_opt
2311 static tree cp_parser_gnu_attributes_opt
2313 static tree cp_parser_gnu_attribute_list
2315 static tree cp_parser_std_attribute
2317 static tree cp_parser_std_attribute_spec
2319 static tree cp_parser_std_attribute_spec_seq
2321 static bool cp_parser_extension_opt
2322 (cp_parser
*, int *);
2323 static void cp_parser_label_declaration
2326 /* Transactional Memory Extensions */
2328 static tree cp_parser_transaction
2329 (cp_parser
*, enum rid
);
2330 static tree cp_parser_transaction_expression
2331 (cp_parser
*, enum rid
);
2332 static bool cp_parser_function_transaction
2333 (cp_parser
*, enum rid
);
2334 static tree cp_parser_transaction_cancel
2337 enum pragma_context
{
2344 static bool cp_parser_pragma
2345 (cp_parser
*, enum pragma_context
);
2347 /* Objective-C++ Productions */
2349 static tree cp_parser_objc_message_receiver
2351 static tree cp_parser_objc_message_args
2353 static tree cp_parser_objc_message_expression
2355 static tree cp_parser_objc_encode_expression
2357 static tree cp_parser_objc_defs_expression
2359 static tree cp_parser_objc_protocol_expression
2361 static tree cp_parser_objc_selector_expression
2363 static tree cp_parser_objc_expression
2365 static bool cp_parser_objc_selector_p
2367 static tree cp_parser_objc_selector
2369 static tree cp_parser_objc_protocol_refs_opt
2371 static void cp_parser_objc_declaration
2372 (cp_parser
*, tree
);
2373 static tree cp_parser_objc_statement
2375 static bool cp_parser_objc_valid_prefix_attributes
2376 (cp_parser
*, tree
*);
2377 static void cp_parser_objc_at_property_declaration
2379 static void cp_parser_objc_at_synthesize_declaration
2381 static void cp_parser_objc_at_dynamic_declaration
2383 static tree cp_parser_objc_struct_declaration
2386 /* Utility Routines */
2388 static tree cp_parser_lookup_name
2389 (cp_parser
*, tree
, enum tag_types
, bool, bool, bool, tree
*, location_t
);
2390 static tree cp_parser_lookup_name_simple
2391 (cp_parser
*, tree
, location_t
);
2392 static tree cp_parser_maybe_treat_template_as_class
2394 static bool cp_parser_check_declarator_template_parameters
2395 (cp_parser
*, cp_declarator
*, location_t
);
2396 static bool cp_parser_check_template_parameters
2397 (cp_parser
*, unsigned, location_t
, cp_declarator
*);
2398 static tree cp_parser_simple_cast_expression
2400 static tree cp_parser_global_scope_opt
2401 (cp_parser
*, bool);
2402 static bool cp_parser_constructor_declarator_p
2403 (cp_parser
*, bool);
2404 static tree cp_parser_function_definition_from_specifiers_and_declarator
2405 (cp_parser
*, cp_decl_specifier_seq
*, tree
, const cp_declarator
*);
2406 static tree cp_parser_function_definition_after_declarator
2407 (cp_parser
*, bool);
2408 static void cp_parser_template_declaration_after_export
2409 (cp_parser
*, bool);
2410 static void cp_parser_perform_template_parameter_access_checks
2411 (vec
<deferred_access_check
, va_gc
> *);
2412 static tree cp_parser_single_declaration
2413 (cp_parser
*, vec
<deferred_access_check
, va_gc
> *, bool, bool, bool *);
2414 static tree cp_parser_functional_cast
2415 (cp_parser
*, tree
);
2416 static tree cp_parser_save_member_function_body
2417 (cp_parser
*, cp_decl_specifier_seq
*, cp_declarator
*, tree
);
2418 static tree cp_parser_save_nsdmi
2420 static tree cp_parser_enclosed_template_argument_list
2422 static void cp_parser_save_default_args
2423 (cp_parser
*, tree
);
2424 static void cp_parser_late_parsing_for_member
2425 (cp_parser
*, tree
);
2426 static tree cp_parser_late_parse_one_default_arg
2427 (cp_parser
*, tree
, tree
, tree
);
2428 static void cp_parser_late_parsing_nsdmi
2429 (cp_parser
*, tree
);
2430 static void cp_parser_late_parsing_default_args
2431 (cp_parser
*, tree
);
2432 static tree cp_parser_sizeof_operand
2433 (cp_parser
*, enum rid
);
2434 static tree cp_parser_trait_expr
2435 (cp_parser
*, enum rid
);
2436 static bool cp_parser_declares_only_class_p
2438 static void cp_parser_set_storage_class
2439 (cp_parser
*, cp_decl_specifier_seq
*, enum rid
, cp_token
*);
2440 static void cp_parser_set_decl_spec_type
2441 (cp_decl_specifier_seq
*, tree
, cp_token
*, bool);
2442 static void set_and_check_decl_spec_loc
2443 (cp_decl_specifier_seq
*decl_specs
,
2444 cp_decl_spec ds
, cp_token
*);
2445 static bool cp_parser_friend_p
2446 (const cp_decl_specifier_seq
*);
2447 static void cp_parser_required_error
2448 (cp_parser
*, required_token
, bool);
2449 static cp_token
*cp_parser_require
2450 (cp_parser
*, enum cpp_ttype
, required_token
);
2451 static cp_token
*cp_parser_require_keyword
2452 (cp_parser
*, enum rid
, required_token
);
2453 static bool cp_parser_token_starts_function_definition_p
2455 static bool cp_parser_next_token_starts_class_definition_p
2457 static bool cp_parser_next_token_ends_template_argument_p
2459 static bool cp_parser_nth_token_starts_template_argument_list_p
2460 (cp_parser
*, size_t);
2461 static enum tag_types cp_parser_token_is_class_key
2463 static enum tag_types cp_parser_token_is_type_parameter_key
2465 static void cp_parser_check_class_key
2466 (enum tag_types
, tree type
);
2467 static void cp_parser_check_access_in_redeclaration
2468 (tree type
, location_t location
);
2469 static bool cp_parser_optional_template_keyword
2471 static void cp_parser_pre_parsed_nested_name_specifier
2473 static bool cp_parser_cache_group
2474 (cp_parser
*, enum cpp_ttype
, unsigned);
2475 static tree cp_parser_cache_defarg
2476 (cp_parser
*parser
, bool nsdmi
);
2477 static void cp_parser_parse_tentatively
2479 static void cp_parser_commit_to_tentative_parse
2481 static void cp_parser_commit_to_topmost_tentative_parse
2483 static void cp_parser_abort_tentative_parse
2485 static bool cp_parser_parse_definitely
2487 static inline bool cp_parser_parsing_tentatively
2489 static bool cp_parser_uncommitted_to_tentative_parse_p
2491 static void cp_parser_error
2492 (cp_parser
*, const char *);
2493 static void cp_parser_name_lookup_error
2494 (cp_parser
*, tree
, tree
, name_lookup_error
, location_t
);
2495 static bool cp_parser_simulate_error
2497 static bool cp_parser_check_type_definition
2499 static void cp_parser_check_for_definition_in_return_type
2500 (cp_declarator
*, tree
, location_t type_location
);
2501 static void cp_parser_check_for_invalid_template_id
2502 (cp_parser
*, tree
, enum tag_types
, location_t location
);
2503 static bool cp_parser_non_integral_constant_expression
2504 (cp_parser
*, non_integral_constant
);
2505 static void cp_parser_diagnose_invalid_type_name
2506 (cp_parser
*, tree
, location_t
);
2507 static bool cp_parser_parse_and_diagnose_invalid_type_name
2509 static int cp_parser_skip_to_closing_parenthesis
2510 (cp_parser
*, bool, bool, bool);
2511 static void cp_parser_skip_to_end_of_statement
2513 static void cp_parser_consume_semicolon_at_end_of_statement
2515 static void cp_parser_skip_to_end_of_block_or_statement
2517 static bool cp_parser_skip_to_closing_brace
2519 static void cp_parser_skip_to_end_of_template_parameter_list
2521 static void cp_parser_skip_to_pragma_eol
2522 (cp_parser
*, cp_token
*);
2523 static bool cp_parser_error_occurred
2525 static bool cp_parser_allow_gnu_extensions_p
2527 static bool cp_parser_is_pure_string_literal
2529 static bool cp_parser_is_string_literal
2531 static bool cp_parser_is_keyword
2532 (cp_token
*, enum rid
);
2533 static tree cp_parser_make_typename_type
2534 (cp_parser
*, tree
, location_t location
);
2535 static cp_declarator
* cp_parser_make_indirect_declarator
2536 (enum tree_code
, tree
, cp_cv_quals
, cp_declarator
*, tree
);
2537 static bool cp_parser_compound_literal_p
2539 static bool cp_parser_array_designator_p
2541 static bool cp_parser_skip_to_closing_square_bracket
2544 /* Returns nonzero if we are parsing tentatively. */
2547 cp_parser_parsing_tentatively (cp_parser
* parser
)
2549 return parser
->context
->next
!= NULL
;
2552 /* Returns nonzero if TOKEN is a string literal. */
2555 cp_parser_is_pure_string_literal (cp_token
* token
)
2557 return (token
->type
== CPP_STRING
||
2558 token
->type
== CPP_STRING16
||
2559 token
->type
== CPP_STRING32
||
2560 token
->type
== CPP_WSTRING
||
2561 token
->type
== CPP_UTF8STRING
);
2564 /* Returns nonzero if TOKEN is a string literal
2565 of a user-defined string literal. */
2568 cp_parser_is_string_literal (cp_token
* token
)
2570 return (cp_parser_is_pure_string_literal (token
) ||
2571 token
->type
== CPP_STRING_USERDEF
||
2572 token
->type
== CPP_STRING16_USERDEF
||
2573 token
->type
== CPP_STRING32_USERDEF
||
2574 token
->type
== CPP_WSTRING_USERDEF
||
2575 token
->type
== CPP_UTF8STRING_USERDEF
);
2578 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2581 cp_parser_is_keyword (cp_token
* token
, enum rid keyword
)
2583 return token
->keyword
== keyword
;
2586 /* If not parsing tentatively, issue a diagnostic of the form
2587 FILE:LINE: MESSAGE before TOKEN
2588 where TOKEN is the next token in the input stream. MESSAGE
2589 (specified by the caller) is usually of the form "expected
2593 cp_parser_error (cp_parser
* parser
, const char* gmsgid
)
2595 if (!cp_parser_simulate_error (parser
))
2597 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
2598 /* This diagnostic makes more sense if it is tagged to the line
2599 of the token we just peeked at. */
2600 cp_lexer_set_source_position_from_token (token
);
2602 if (token
->type
== CPP_PRAGMA
)
2604 error_at (token
->location
,
2605 "%<#pragma%> is not allowed here");
2606 cp_parser_skip_to_pragma_eol (parser
, token
);
2610 c_parse_error (gmsgid
,
2611 /* Because c_parser_error does not understand
2612 CPP_KEYWORD, keywords are treated like
2614 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
2615 token
->u
.value
, token
->flags
);
2619 /* Issue an error about name-lookup failing. NAME is the
2620 IDENTIFIER_NODE DECL is the result of
2621 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2622 the thing that we hoped to find. */
2625 cp_parser_name_lookup_error (cp_parser
* parser
,
2628 name_lookup_error desired
,
2629 location_t location
)
2631 /* If name lookup completely failed, tell the user that NAME was not
2633 if (decl
== error_mark_node
)
2635 if (parser
->scope
&& parser
->scope
!= global_namespace
)
2636 error_at (location
, "%<%E::%E%> has not been declared",
2637 parser
->scope
, name
);
2638 else if (parser
->scope
== global_namespace
)
2639 error_at (location
, "%<::%E%> has not been declared", name
);
2640 else if (parser
->object_scope
2641 && !CLASS_TYPE_P (parser
->object_scope
))
2642 error_at (location
, "request for member %qE in non-class type %qT",
2643 name
, parser
->object_scope
);
2644 else if (parser
->object_scope
)
2645 error_at (location
, "%<%T::%E%> has not been declared",
2646 parser
->object_scope
, name
);
2648 error_at (location
, "%qE has not been declared", name
);
2650 else if (parser
->scope
&& parser
->scope
!= global_namespace
)
2655 error_at (location
, "%<%E::%E%> is not a type",
2656 parser
->scope
, name
);
2659 error_at (location
, "%<%E::%E%> is not a class or namespace",
2660 parser
->scope
, name
);
2664 "%<%E::%E%> is not a class, namespace, or enumeration",
2665 parser
->scope
, name
);
2672 else if (parser
->scope
== global_namespace
)
2677 error_at (location
, "%<::%E%> is not a type", name
);
2680 error_at (location
, "%<::%E%> is not a class or namespace", name
);
2684 "%<::%E%> is not a class, namespace, or enumeration",
2696 error_at (location
, "%qE is not a type", name
);
2699 error_at (location
, "%qE is not a class or namespace", name
);
2703 "%qE is not a class, namespace, or enumeration", name
);
2711 /* If we are parsing tentatively, remember that an error has occurred
2712 during this tentative parse. Returns true if the error was
2713 simulated; false if a message should be issued by the caller. */
2716 cp_parser_simulate_error (cp_parser
* parser
)
2718 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
2720 parser
->context
->status
= CP_PARSER_STATUS_KIND_ERROR
;
2726 /* This function is called when a type is defined. If type
2727 definitions are forbidden at this point, an error message is
2731 cp_parser_check_type_definition (cp_parser
* parser
)
2733 /* If types are forbidden here, issue a message. */
2734 if (parser
->type_definition_forbidden_message
)
2736 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2737 in the message need to be interpreted. */
2738 error (parser
->type_definition_forbidden_message
);
2744 /* This function is called when the DECLARATOR is processed. The TYPE
2745 was a type defined in the decl-specifiers. If it is invalid to
2746 define a type in the decl-specifiers for DECLARATOR, an error is
2747 issued. TYPE_LOCATION is the location of TYPE and is used
2748 for error reporting. */
2751 cp_parser_check_for_definition_in_return_type (cp_declarator
*declarator
,
2752 tree type
, location_t type_location
)
2754 /* [dcl.fct] forbids type definitions in return types.
2755 Unfortunately, it's not easy to know whether or not we are
2756 processing a return type until after the fact. */
2758 && (declarator
->kind
== cdk_pointer
2759 || declarator
->kind
== cdk_reference
2760 || declarator
->kind
== cdk_ptrmem
))
2761 declarator
= declarator
->declarator
;
2763 && declarator
->kind
== cdk_function
)
2765 error_at (type_location
,
2766 "new types may not be defined in a return type");
2767 inform (type_location
,
2768 "(perhaps a semicolon is missing after the definition of %qT)",
2773 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2774 "<" in any valid C++ program. If the next token is indeed "<",
2775 issue a message warning the user about what appears to be an
2776 invalid attempt to form a template-id. LOCATION is the location
2777 of the type-specifier (TYPE) */
2780 cp_parser_check_for_invalid_template_id (cp_parser
* parser
,
2782 enum tag_types tag_type
,
2783 location_t location
)
2785 cp_token_position start
= 0;
2787 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
2790 error_at (location
, "%qT is not a template", type
);
2791 else if (identifier_p (type
))
2793 if (tag_type
!= none_type
)
2794 error_at (location
, "%qE is not a class template", type
);
2796 error_at (location
, "%qE is not a template", type
);
2799 error_at (location
, "invalid template-id");
2800 /* Remember the location of the invalid "<". */
2801 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
2802 start
= cp_lexer_token_position (parser
->lexer
, true);
2803 /* Consume the "<". */
2804 cp_lexer_consume_token (parser
->lexer
);
2805 /* Parse the template arguments. */
2806 cp_parser_enclosed_template_argument_list (parser
);
2807 /* Permanently remove the invalid template arguments so that
2808 this error message is not issued again. */
2810 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
2814 /* If parsing an integral constant-expression, issue an error message
2815 about the fact that THING appeared and return true. Otherwise,
2816 return false. In either case, set
2817 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2820 cp_parser_non_integral_constant_expression (cp_parser
*parser
,
2821 non_integral_constant thing
)
2823 parser
->non_integral_constant_expression_p
= true;
2824 if (parser
->integral_constant_expression_p
)
2826 if (!parser
->allow_non_integral_constant_expression_p
)
2828 const char *msg
= NULL
;
2832 error ("floating-point literal "
2833 "cannot appear in a constant-expression");
2836 error ("a cast to a type other than an integral or "
2837 "enumeration type cannot appear in a "
2838 "constant-expression");
2841 error ("%<typeid%> operator "
2842 "cannot appear in a constant-expression");
2845 error ("non-constant compound literals "
2846 "cannot appear in a constant-expression");
2849 error ("a function call "
2850 "cannot appear in a constant-expression");
2853 error ("an increment "
2854 "cannot appear in a constant-expression");
2857 error ("an decrement "
2858 "cannot appear in a constant-expression");
2861 error ("an array reference "
2862 "cannot appear in a constant-expression");
2864 case NIC_ADDR_LABEL
:
2865 error ("the address of a label "
2866 "cannot appear in a constant-expression");
2868 case NIC_OVERLOADED
:
2869 error ("calls to overloaded operators "
2870 "cannot appear in a constant-expression");
2872 case NIC_ASSIGNMENT
:
2873 error ("an assignment cannot appear in a constant-expression");
2876 error ("a comma operator "
2877 "cannot appear in a constant-expression");
2879 case NIC_CONSTRUCTOR
:
2880 error ("a call to a constructor "
2881 "cannot appear in a constant-expression");
2883 case NIC_TRANSACTION
:
2884 error ("a transaction expression "
2885 "cannot appear in a constant-expression");
2891 msg
= "__FUNCTION__";
2893 case NIC_PRETTY_FUNC
:
2894 msg
= "__PRETTY_FUNCTION__";
2914 case NIC_PREINCREMENT
:
2917 case NIC_PREDECREMENT
:
2930 error ("%qs cannot appear in a constant-expression", msg
);
2937 /* Emit a diagnostic for an invalid type name. This function commits
2938 to the current active tentative parse, if any. (Otherwise, the
2939 problematic construct might be encountered again later, resulting
2940 in duplicate error messages.) LOCATION is the location of ID. */
2943 cp_parser_diagnose_invalid_type_name (cp_parser
*parser
, tree id
,
2944 location_t location
)
2946 tree decl
, ambiguous_decls
;
2947 cp_parser_commit_to_tentative_parse (parser
);
2948 /* Try to lookup the identifier. */
2949 decl
= cp_parser_lookup_name (parser
, id
, none_type
,
2950 /*is_template=*/false,
2951 /*is_namespace=*/false,
2952 /*check_dependency=*/true,
2953 &ambiguous_decls
, location
);
2954 if (ambiguous_decls
)
2955 /* If the lookup was ambiguous, an error will already have
2958 /* If the lookup found a template-name, it means that the user forgot
2959 to specify an argument list. Emit a useful error message. */
2960 if (DECL_TYPE_TEMPLATE_P (decl
))
2963 "invalid use of template-name %qE without an argument list",
2965 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
2967 else if (TREE_CODE (id
) == BIT_NOT_EXPR
)
2968 error_at (location
, "invalid use of destructor %qD as a type", id
);
2969 else if (TREE_CODE (decl
) == TYPE_DECL
)
2970 /* Something like 'unsigned A a;' */
2971 error_at (location
, "invalid combination of multiple type-specifiers");
2972 else if (!parser
->scope
)
2974 /* Issue an error message. */
2975 error_at (location
, "%qE does not name a type", id
);
2976 /* If we're in a template class, it's possible that the user was
2977 referring to a type from a base class. For example:
2979 template <typename T> struct A { typedef T X; };
2980 template <typename T> struct B : public A<T> { X x; };
2982 The user should have said "typename A<T>::X". */
2983 if (cxx_dialect
< cxx11
&& id
== ridpointers
[(int)RID_CONSTEXPR
])
2984 inform (location
, "C++11 %<constexpr%> only available with "
2985 "-std=c++11 or -std=gnu++11");
2986 else if (cxx_dialect
< cxx11
&& id
== ridpointers
[(int)RID_NOEXCEPT
])
2987 inform (location
, "C++11 %<noexcept%> only available with "
2988 "-std=c++11 or -std=gnu++11");
2989 else if (cxx_dialect
< cxx11
2990 && TREE_CODE (id
) == IDENTIFIER_NODE
2991 && !strcmp (IDENTIFIER_POINTER (id
), "thread_local"))
2992 inform (location
, "C++11 %<thread_local%> only available with "
2993 "-std=c++11 or -std=gnu++11");
2994 else if (processing_template_decl
&& current_class_type
2995 && TYPE_BINFO (current_class_type
))
2999 for (b
= TREE_CHAIN (TYPE_BINFO (current_class_type
));
3003 tree base_type
= BINFO_TYPE (b
);
3004 if (CLASS_TYPE_P (base_type
)
3005 && dependent_type_p (base_type
))
3008 /* Go from a particular instantiation of the
3009 template (which will have an empty TYPE_FIELDs),
3010 to the main version. */
3011 base_type
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type
);
3012 for (field
= TYPE_FIELDS (base_type
);
3014 field
= DECL_CHAIN (field
))
3015 if (TREE_CODE (field
) == TYPE_DECL
3016 && DECL_NAME (field
) == id
)
3019 "(perhaps %<typename %T::%E%> was intended)",
3020 BINFO_TYPE (b
), id
);
3029 /* Here we diagnose qualified-ids where the scope is actually correct,
3030 but the identifier does not resolve to a valid type name. */
3031 else if (parser
->scope
!= error_mark_node
)
3033 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
3035 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
3036 error_at (location_of (id
),
3037 "%qE in namespace %qE does not name a template type",
3040 error_at (location_of (id
),
3041 "%qE in namespace %qE does not name a type",
3044 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3046 else if (CLASS_TYPE_P (parser
->scope
)
3047 && constructor_name_p (id
, parser
->scope
))
3050 error_at (location
, "%<%T::%E%> names the constructor, not"
3051 " the type", parser
->scope
, id
);
3052 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
3053 error_at (location
, "and %qT has no template constructors",
3056 else if (TYPE_P (parser
->scope
)
3057 && dependent_scope_p (parser
->scope
))
3058 error_at (location
, "need %<typename%> before %<%T::%E%> because "
3059 "%qT is a dependent scope",
3060 parser
->scope
, id
, parser
->scope
);
3061 else if (TYPE_P (parser
->scope
))
3063 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
3064 error_at (location_of (id
),
3065 "%qE in %q#T does not name a template type",
3068 error_at (location_of (id
),
3069 "%qE in %q#T does not name a type",
3072 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3079 /* Check for a common situation where a type-name should be present,
3080 but is not, and issue a sensible error message. Returns true if an
3081 invalid type-name was detected.
3083 The situation handled by this function are variable declarations of the
3084 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3085 Usually, `ID' should name a type, but if we got here it means that it
3086 does not. We try to emit the best possible error message depending on
3087 how exactly the id-expression looks like. */
3090 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser
*parser
)
3093 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3095 /* Avoid duplicate error about ambiguous lookup. */
3096 if (token
->type
== CPP_NESTED_NAME_SPECIFIER
)
3098 cp_token
*next
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
3099 if (next
->type
== CPP_NAME
&& next
->error_reported
)
3103 cp_parser_parse_tentatively (parser
);
3104 id
= cp_parser_id_expression (parser
,
3105 /*template_keyword_p=*/false,
3106 /*check_dependency_p=*/true,
3107 /*template_p=*/NULL
,
3108 /*declarator_p=*/true,
3109 /*optional_p=*/false);
3110 /* If the next token is a (, this is a function with no explicit return
3111 type, i.e. constructor, destructor or conversion op. */
3112 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
3113 || TREE_CODE (id
) == TYPE_DECL
)
3115 cp_parser_abort_tentative_parse (parser
);
3118 if (!cp_parser_parse_definitely (parser
))
3121 /* Emit a diagnostic for the invalid type. */
3122 cp_parser_diagnose_invalid_type_name (parser
, id
, token
->location
);
3124 /* If we aren't in the middle of a declarator (i.e. in a
3125 parameter-declaration-clause), skip to the end of the declaration;
3126 there's no point in trying to process it. */
3127 if (!parser
->in_declarator_p
)
3128 cp_parser_skip_to_end_of_block_or_statement (parser
);
3132 /* Consume tokens up to, and including, the next non-nested closing `)'.
3133 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3134 are doing error recovery. Returns -1 if OR_COMMA is true and we
3135 found an unnested comma. */
3138 cp_parser_skip_to_closing_parenthesis (cp_parser
*parser
,
3143 unsigned paren_depth
= 0;
3144 unsigned brace_depth
= 0;
3145 unsigned square_depth
= 0;
3147 if (recovering
&& !or_comma
3148 && cp_parser_uncommitted_to_tentative_parse_p (parser
))
3153 cp_token
* token
= cp_lexer_peek_token (parser
->lexer
);
3155 switch (token
->type
)
3158 case CPP_PRAGMA_EOL
:
3159 /* If we've run out of tokens, then there is no closing `)'. */
3162 /* This is good for lambda expression capture-lists. */
3163 case CPP_OPEN_SQUARE
:
3166 case CPP_CLOSE_SQUARE
:
3167 if (!square_depth
--)
3172 /* This matches the processing in skip_to_end_of_statement. */
3177 case CPP_OPEN_BRACE
:
3180 case CPP_CLOSE_BRACE
:
3186 if (recovering
&& or_comma
&& !brace_depth
&& !paren_depth
3191 case CPP_OPEN_PAREN
:
3196 case CPP_CLOSE_PAREN
:
3197 if (!brace_depth
&& !paren_depth
--)
3200 cp_lexer_consume_token (parser
->lexer
);
3209 /* Consume the token. */
3210 cp_lexer_consume_token (parser
->lexer
);
3214 /* Consume tokens until we reach the end of the current statement.
3215 Normally, that will be just before consuming a `;'. However, if a
3216 non-nested `}' comes first, then we stop before consuming that. */
3219 cp_parser_skip_to_end_of_statement (cp_parser
* parser
)
3221 unsigned nesting_depth
= 0;
3223 /* Unwind generic function template scope if necessary. */
3224 if (parser
->fully_implicit_function_template_p
)
3225 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
3229 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3231 switch (token
->type
)
3234 case CPP_PRAGMA_EOL
:
3235 /* If we've run out of tokens, stop. */
3239 /* If the next token is a `;', we have reached the end of the
3245 case CPP_CLOSE_BRACE
:
3246 /* If this is a non-nested '}', stop before consuming it.
3247 That way, when confronted with something like:
3251 we stop before consuming the closing '}', even though we
3252 have not yet reached a `;'. */
3253 if (nesting_depth
== 0)
3256 /* If it is the closing '}' for a block that we have
3257 scanned, stop -- but only after consuming the token.
3263 we will stop after the body of the erroneously declared
3264 function, but before consuming the following `typedef'
3266 if (--nesting_depth
== 0)
3268 cp_lexer_consume_token (parser
->lexer
);
3272 case CPP_OPEN_BRACE
:
3280 /* Consume the token. */
3281 cp_lexer_consume_token (parser
->lexer
);
3285 /* This function is called at the end of a statement or declaration.
3286 If the next token is a semicolon, it is consumed; otherwise, error
3287 recovery is attempted. */
3290 cp_parser_consume_semicolon_at_end_of_statement (cp_parser
*parser
)
3292 /* Look for the trailing `;'. */
3293 if (!cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
))
3295 /* If there is additional (erroneous) input, skip to the end of
3297 cp_parser_skip_to_end_of_statement (parser
);
3298 /* If the next token is now a `;', consume it. */
3299 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
3300 cp_lexer_consume_token (parser
->lexer
);
3304 /* Skip tokens until we have consumed an entire block, or until we
3305 have consumed a non-nested `;'. */
3308 cp_parser_skip_to_end_of_block_or_statement (cp_parser
* parser
)
3310 int nesting_depth
= 0;
3312 /* Unwind generic function template scope if necessary. */
3313 if (parser
->fully_implicit_function_template_p
)
3314 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
3316 while (nesting_depth
>= 0)
3318 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3320 switch (token
->type
)
3323 case CPP_PRAGMA_EOL
:
3324 /* If we've run out of tokens, stop. */
3328 /* Stop if this is an unnested ';'. */
3333 case CPP_CLOSE_BRACE
:
3334 /* Stop if this is an unnested '}', or closes the outermost
3337 if (nesting_depth
< 0)
3343 case CPP_OPEN_BRACE
:
3352 /* Consume the token. */
3353 cp_lexer_consume_token (parser
->lexer
);
3357 /* Skip tokens until a non-nested closing curly brace is the next
3358 token, or there are no more tokens. Return true in the first case,
3362 cp_parser_skip_to_closing_brace (cp_parser
*parser
)
3364 unsigned nesting_depth
= 0;
3368 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3370 switch (token
->type
)
3373 case CPP_PRAGMA_EOL
:
3374 /* If we've run out of tokens, stop. */
3377 case CPP_CLOSE_BRACE
:
3378 /* If the next token is a non-nested `}', then we have reached
3379 the end of the current block. */
3380 if (nesting_depth
-- == 0)
3384 case CPP_OPEN_BRACE
:
3385 /* If it the next token is a `{', then we are entering a new
3386 block. Consume the entire block. */
3394 /* Consume the token. */
3395 cp_lexer_consume_token (parser
->lexer
);
3399 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3400 parameter is the PRAGMA token, allowing us to purge the entire pragma
3404 cp_parser_skip_to_pragma_eol (cp_parser
* parser
, cp_token
*pragma_tok
)
3408 parser
->lexer
->in_pragma
= false;
3411 token
= cp_lexer_consume_token (parser
->lexer
);
3412 while (token
->type
!= CPP_PRAGMA_EOL
&& token
->type
!= CPP_EOF
);
3414 /* Ensure that the pragma is not parsed again. */
3415 cp_lexer_purge_tokens_after (parser
->lexer
, pragma_tok
);
3418 /* Require pragma end of line, resyncing with it as necessary. The
3419 arguments are as for cp_parser_skip_to_pragma_eol. */
3422 cp_parser_require_pragma_eol (cp_parser
*parser
, cp_token
*pragma_tok
)
3424 parser
->lexer
->in_pragma
= false;
3425 if (!cp_parser_require (parser
, CPP_PRAGMA_EOL
, RT_PRAGMA_EOL
))
3426 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
3429 /* This is a simple wrapper around make_typename_type. When the id is
3430 an unresolved identifier node, we can provide a superior diagnostic
3431 using cp_parser_diagnose_invalid_type_name. */
3434 cp_parser_make_typename_type (cp_parser
*parser
, tree id
,
3435 location_t id_location
)
3438 if (identifier_p (id
))
3440 result
= make_typename_type (parser
->scope
, id
, typename_type
,
3441 /*complain=*/tf_none
);
3442 if (result
== error_mark_node
)
3443 cp_parser_diagnose_invalid_type_name (parser
, id
, id_location
);
3446 return make_typename_type (parser
->scope
, id
, typename_type
, tf_error
);
3449 /* This is a wrapper around the
3450 make_{pointer,ptrmem,reference}_declarator functions that decides
3451 which one to call based on the CODE and CLASS_TYPE arguments. The
3452 CODE argument should be one of the values returned by
3453 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3454 appertain to the pointer or reference. */
3456 static cp_declarator
*
3457 cp_parser_make_indirect_declarator (enum tree_code code
, tree class_type
,
3458 cp_cv_quals cv_qualifiers
,
3459 cp_declarator
*target
,
3462 if (code
== ERROR_MARK
)
3463 return cp_error_declarator
;
3465 if (code
== INDIRECT_REF
)
3466 if (class_type
== NULL_TREE
)
3467 return make_pointer_declarator (cv_qualifiers
, target
, attributes
);
3469 return make_ptrmem_declarator (cv_qualifiers
, class_type
,
3470 target
, attributes
);
3471 else if (code
== ADDR_EXPR
&& class_type
== NULL_TREE
)
3472 return make_reference_declarator (cv_qualifiers
, target
,
3474 else if (code
== NON_LVALUE_EXPR
&& class_type
== NULL_TREE
)
3475 return make_reference_declarator (cv_qualifiers
, target
,
3480 /* Create a new C++ parser. */
3483 cp_parser_new (void)
3489 /* cp_lexer_new_main is called before doing GC allocation because
3490 cp_lexer_new_main might load a PCH file. */
3491 lexer
= cp_lexer_new_main ();
3493 /* Initialize the binops_by_token so that we can get the tree
3494 directly from the token. */
3495 for (i
= 0; i
< sizeof (binops
) / sizeof (binops
[0]); i
++)
3496 binops_by_token
[binops
[i
].token_type
] = binops
[i
];
3498 parser
= ggc_cleared_alloc
<cp_parser
> ();
3499 parser
->lexer
= lexer
;
3500 parser
->context
= cp_parser_context_new (NULL
);
3502 /* For now, we always accept GNU extensions. */
3503 parser
->allow_gnu_extensions_p
= 1;
3505 /* The `>' token is a greater-than operator, not the end of a
3507 parser
->greater_than_is_operator_p
= true;
3509 parser
->default_arg_ok_p
= true;
3511 /* We are not parsing a constant-expression. */
3512 parser
->integral_constant_expression_p
= false;
3513 parser
->allow_non_integral_constant_expression_p
= false;
3514 parser
->non_integral_constant_expression_p
= false;
3516 /* Local variable names are not forbidden. */
3517 parser
->local_variables_forbidden_p
= false;
3519 /* We are not processing an `extern "C"' declaration. */
3520 parser
->in_unbraced_linkage_specification_p
= false;
3522 /* We are not processing a declarator. */
3523 parser
->in_declarator_p
= false;
3525 /* We are not processing a template-argument-list. */
3526 parser
->in_template_argument_list_p
= false;
3528 /* We are not in an iteration statement. */
3529 parser
->in_statement
= 0;
3531 /* We are not in a switch statement. */
3532 parser
->in_switch_statement_p
= false;
3534 /* We are not parsing a type-id inside an expression. */
3535 parser
->in_type_id_in_expr_p
= false;
3537 /* Declarations aren't implicitly extern "C". */
3538 parser
->implicit_extern_c
= false;
3540 /* String literals should be translated to the execution character set. */
3541 parser
->translate_strings_p
= true;
3543 /* We are not parsing a function body. */
3544 parser
->in_function_body
= false;
3546 /* We can correct until told otherwise. */
3547 parser
->colon_corrects_to_scope_p
= true;
3549 /* The unparsed function queue is empty. */
3550 push_unparsed_function_queues (parser
);
3552 /* There are no classes being defined. */
3553 parser
->num_classes_being_defined
= 0;
3555 /* No template parameters apply. */
3556 parser
->num_template_parameter_lists
= 0;
3558 /* Not declaring an implicit function template. */
3559 parser
->auto_is_implicit_function_template_parm_p
= false;
3560 parser
->fully_implicit_function_template_p
= false;
3561 parser
->implicit_template_parms
= 0;
3562 parser
->implicit_template_scope
= 0;
3567 /* Create a cp_lexer structure which will emit the tokens in CACHE
3568 and push it onto the parser's lexer stack. This is used for delayed
3569 parsing of in-class method bodies and default arguments, and should
3570 not be confused with tentative parsing. */
3572 cp_parser_push_lexer_for_tokens (cp_parser
*parser
, cp_token_cache
*cache
)
3574 cp_lexer
*lexer
= cp_lexer_new_from_tokens (cache
);
3575 lexer
->next
= parser
->lexer
;
3576 parser
->lexer
= lexer
;
3578 /* Move the current source position to that of the first token in the
3580 cp_lexer_set_source_position_from_token (lexer
->next_token
);
3583 /* Pop the top lexer off the parser stack. This is never used for the
3584 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3586 cp_parser_pop_lexer (cp_parser
*parser
)
3588 cp_lexer
*lexer
= parser
->lexer
;
3589 parser
->lexer
= lexer
->next
;
3590 cp_lexer_destroy (lexer
);
3592 /* Put the current source position back where it was before this
3593 lexer was pushed. */
3594 cp_lexer_set_source_position_from_token (parser
->lexer
->next_token
);
3597 /* Lexical conventions [gram.lex] */
3599 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3603 cp_parser_identifier (cp_parser
* parser
)
3607 /* Look for the identifier. */
3608 token
= cp_parser_require (parser
, CPP_NAME
, RT_NAME
);
3609 /* Return the value. */
3610 return token
? token
->u
.value
: error_mark_node
;
3613 /* Parse a sequence of adjacent string constants. Returns a
3614 TREE_STRING representing the combined, nul-terminated string
3615 constant. If TRANSLATE is true, translate the string to the
3616 execution character set. If WIDE_OK is true, a wide string is
3619 C++98 [lex.string] says that if a narrow string literal token is
3620 adjacent to a wide string literal token, the behavior is undefined.
3621 However, C99 6.4.5p4 says that this results in a wide string literal.
3622 We follow C99 here, for consistency with the C front end.
3624 This code is largely lifted from lex_string() in c-lex.c.
3626 FUTURE: ObjC++ will need to handle @-strings here. */
3628 cp_parser_string_literal (cp_parser
*parser
, bool translate
, bool wide_ok
,
3629 bool lookup_udlit
= true)
3633 struct obstack str_ob
;
3634 cpp_string str
, istr
, *strs
;
3636 enum cpp_ttype type
, curr_type
;
3637 int have_suffix_p
= 0;
3639 tree suffix_id
= NULL_TREE
;
3640 bool curr_tok_is_userdef_p
= false;
3642 tok
= cp_lexer_peek_token (parser
->lexer
);
3643 if (!cp_parser_is_string_literal (tok
))
3645 cp_parser_error (parser
, "expected string-literal");
3646 return error_mark_node
;
3649 if (cpp_userdef_string_p (tok
->type
))
3651 string_tree
= USERDEF_LITERAL_VALUE (tok
->u
.value
);
3652 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3653 curr_tok_is_userdef_p
= true;
3657 string_tree
= tok
->u
.value
;
3658 curr_type
= tok
->type
;
3662 /* Try to avoid the overhead of creating and destroying an obstack
3663 for the common case of just one string. */
3664 if (!cp_parser_is_string_literal
3665 (cp_lexer_peek_nth_token (parser
->lexer
, 2)))
3667 cp_lexer_consume_token (parser
->lexer
);
3669 str
.text
= (const unsigned char *)TREE_STRING_POINTER (string_tree
);
3670 str
.len
= TREE_STRING_LENGTH (string_tree
);
3673 if (curr_tok_is_userdef_p
)
3675 suffix_id
= USERDEF_LITERAL_SUFFIX_ID (tok
->u
.value
);
3677 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3680 curr_type
= tok
->type
;
3686 gcc_obstack_init (&str_ob
);
3691 cp_lexer_consume_token (parser
->lexer
);
3693 str
.text
= (const unsigned char *)TREE_STRING_POINTER (string_tree
);
3694 str
.len
= TREE_STRING_LENGTH (string_tree
);
3696 if (curr_tok_is_userdef_p
)
3698 tree curr_suffix_id
= USERDEF_LITERAL_SUFFIX_ID (tok
->u
.value
);
3699 if (have_suffix_p
== 0)
3701 suffix_id
= curr_suffix_id
;
3704 else if (have_suffix_p
== 1
3705 && curr_suffix_id
!= suffix_id
)
3707 error ("inconsistent user-defined literal suffixes"
3708 " %qD and %qD in string literal",
3709 suffix_id
, curr_suffix_id
);
3712 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3715 curr_type
= tok
->type
;
3717 if (type
!= curr_type
)
3719 if (type
== CPP_STRING
)
3721 else if (curr_type
!= CPP_STRING
)
3722 error_at (tok
->location
,
3723 "unsupported non-standard concatenation "
3724 "of string literals");
3727 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
3729 tok
= cp_lexer_peek_token (parser
->lexer
);
3730 if (cpp_userdef_string_p (tok
->type
))
3732 string_tree
= USERDEF_LITERAL_VALUE (tok
->u
.value
);
3733 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3734 curr_tok_is_userdef_p
= true;
3738 string_tree
= tok
->u
.value
;
3739 curr_type
= tok
->type
;
3740 curr_tok_is_userdef_p
= false;
3743 while (cp_parser_is_string_literal (tok
));
3745 strs
= (cpp_string
*) obstack_finish (&str_ob
);
3748 if (type
!= CPP_STRING
&& !wide_ok
)
3750 cp_parser_error (parser
, "a wide string is invalid in this context");
3754 if ((translate
? cpp_interpret_string
: cpp_interpret_string_notranslate
)
3755 (parse_in
, strs
, count
, &istr
, type
))
3757 value
= build_string (istr
.len
, (const char *)istr
.text
);
3758 free (CONST_CAST (unsigned char *, istr
.text
));
3764 case CPP_UTF8STRING
:
3765 TREE_TYPE (value
) = char_array_type_node
;
3768 TREE_TYPE (value
) = char16_array_type_node
;
3771 TREE_TYPE (value
) = char32_array_type_node
;
3774 TREE_TYPE (value
) = wchar_array_type_node
;
3778 value
= fix_string_type (value
);
3782 tree literal
= build_userdef_literal (suffix_id
, value
,
3783 OT_NONE
, NULL_TREE
);
3785 value
= cp_parser_userdef_string_literal (literal
);
3791 /* cpp_interpret_string has issued an error. */
3792 value
= error_mark_node
;
3795 obstack_free (&str_ob
, 0);
3800 /* Look up a literal operator with the name and the exact arguments. */
3803 lookup_literal_operator (tree name
, vec
<tree
, va_gc
> *args
)
3806 decl
= lookup_name (name
);
3807 if (!decl
|| !is_overloaded_fn (decl
))
3808 return error_mark_node
;
3810 for (fns
= decl
; fns
; fns
= OVL_NEXT (fns
))
3814 tree fn
= OVL_CURRENT (fns
);
3815 tree parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
3816 if (parmtypes
!= NULL_TREE
)
3818 for (ix
= 0; ix
< vec_safe_length (args
) && parmtypes
!= NULL_TREE
;
3819 ++ix
, parmtypes
= TREE_CHAIN (parmtypes
))
3821 tree tparm
= TREE_VALUE (parmtypes
);
3822 tree targ
= TREE_TYPE ((*args
)[ix
]);
3823 bool ptr
= TYPE_PTR_P (tparm
);
3824 bool arr
= TREE_CODE (targ
) == ARRAY_TYPE
;
3825 if ((ptr
|| arr
|| !same_type_p (tparm
, targ
))
3827 || !same_type_p (TREE_TYPE (tparm
),
3832 && ix
== vec_safe_length (args
)
3833 /* May be this should be sufficient_parms_p instead,
3834 depending on how exactly should user-defined literals
3835 work in presence of default arguments on the literal
3836 operator parameters. */
3837 && parmtypes
== void_list_node
)
3842 return error_mark_node
;
3845 /* Parse a user-defined char constant. Returns a call to a user-defined
3846 literal operator taking the character as an argument. */
3849 cp_parser_userdef_char_literal (cp_parser
*parser
)
3851 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
3852 tree literal
= token
->u
.value
;
3853 tree suffix_id
= USERDEF_LITERAL_SUFFIX_ID (literal
);
3854 tree value
= USERDEF_LITERAL_VALUE (literal
);
3855 tree name
= cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id
));
3858 /* Build up a call to the user-defined operator */
3859 /* Lookup the name we got back from the id-expression. */
3860 vec
<tree
, va_gc
> *args
= make_tree_vector ();
3861 vec_safe_push (args
, value
);
3862 decl
= lookup_literal_operator (name
, args
);
3863 if (!decl
|| decl
== error_mark_node
)
3865 error ("unable to find character literal operator %qD with %qT argument",
3866 name
, TREE_TYPE (value
));
3867 release_tree_vector (args
);
3868 return error_mark_node
;
3870 result
= finish_call_expr (decl
, &args
, false, true, tf_warning_or_error
);
3871 release_tree_vector (args
);
3875 /* A subroutine of cp_parser_userdef_numeric_literal to
3876 create a char... template parameter pack from a string node. */
3879 make_char_string_pack (tree value
)
3882 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
3883 const char *str
= TREE_STRING_POINTER (value
);
3884 int i
, len
= TREE_STRING_LENGTH (value
) - 1;
3885 tree argvec
= make_tree_vec (1);
3887 /* Fill in CHARVEC with all of the parameters. */
3888 charvec
= make_tree_vec (len
);
3889 for (i
= 0; i
< len
; ++i
)
3890 TREE_VEC_ELT (charvec
, i
) = build_int_cst (char_type_node
, str
[i
]);
3892 /* Build the argument packs. */
3893 SET_ARGUMENT_PACK_ARGS (argpack
, charvec
);
3894 TREE_TYPE (argpack
) = char_type_node
;
3896 TREE_VEC_ELT (argvec
, 0) = argpack
;
3901 /* A subroutine of cp_parser_userdef_numeric_literal to
3902 create a char... template parameter pack from a string node. */
3905 make_string_pack (tree value
)
3908 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
3909 const unsigned char *str
3910 = (const unsigned char *) TREE_STRING_POINTER (value
);
3911 int sz
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value
))));
3912 int len
= TREE_STRING_LENGTH (value
) / sz
- 1;
3913 tree argvec
= make_tree_vec (2);
3915 tree str_char_type_node
= TREE_TYPE (TREE_TYPE (value
));
3916 str_char_type_node
= TYPE_MAIN_VARIANT (str_char_type_node
);
3918 /* First template parm is character type. */
3919 TREE_VEC_ELT (argvec
, 0) = str_char_type_node
;
3921 /* Fill in CHARVEC with all of the parameters. */
3922 charvec
= make_tree_vec (len
);
3923 for (int i
= 0; i
< len
; ++i
)
3924 TREE_VEC_ELT (charvec
, i
)
3925 = double_int_to_tree (str_char_type_node
,
3926 double_int::from_buffer (str
+ i
* sz
, sz
));
3928 /* Build the argument packs. */
3929 SET_ARGUMENT_PACK_ARGS (argpack
, charvec
);
3930 TREE_TYPE (argpack
) = str_char_type_node
;
3932 TREE_VEC_ELT (argvec
, 1) = argpack
;
3937 /* Parse a user-defined numeric constant. returns a call to a user-defined
3938 literal operator. */
3941 cp_parser_userdef_numeric_literal (cp_parser
*parser
)
3943 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
3944 tree literal
= token
->u
.value
;
3945 tree suffix_id
= USERDEF_LITERAL_SUFFIX_ID (literal
);
3946 tree value
= USERDEF_LITERAL_VALUE (literal
);
3947 int overflow
= USERDEF_LITERAL_OVERFLOW (literal
);
3948 tree num_string
= USERDEF_LITERAL_NUM_STRING (literal
);
3949 tree name
= cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id
));
3951 vec
<tree
, va_gc
> *args
;
3953 /* Look for a literal operator taking the exact type of numeric argument
3954 as the literal value. */
3955 args
= make_tree_vector ();
3956 vec_safe_push (args
, value
);
3957 decl
= lookup_literal_operator (name
, args
);
3958 if (decl
&& decl
!= error_mark_node
)
3960 result
= finish_call_expr (decl
, &args
, false, true,
3961 tf_warning_or_error
);
3963 if (TREE_CODE (TREE_TYPE (value
)) == INTEGER_TYPE
&& overflow
> 0)
3965 warning_at (token
->location
, OPT_Woverflow
,
3966 "integer literal exceeds range of %qT type",
3967 long_long_unsigned_type_node
);
3972 warning_at (token
->location
, OPT_Woverflow
,
3973 "floating literal exceeds range of %qT type",
3974 long_double_type_node
);
3975 else if (overflow
< 0)
3976 warning_at (token
->location
, OPT_Woverflow
,
3977 "floating literal truncated to zero");
3980 release_tree_vector (args
);
3983 release_tree_vector (args
);
3985 /* If the numeric argument didn't work, look for a raw literal
3986 operator taking a const char* argument consisting of the number
3987 in string format. */
3988 args
= make_tree_vector ();
3989 vec_safe_push (args
, num_string
);
3990 decl
= lookup_literal_operator (name
, args
);
3991 if (decl
&& decl
!= error_mark_node
)
3993 result
= finish_call_expr (decl
, &args
, false, true,
3994 tf_warning_or_error
);
3995 release_tree_vector (args
);
3998 release_tree_vector (args
);
4000 /* If the raw literal didn't work, look for a non-type template
4001 function with parameter pack char.... Call the function with
4002 template parameter characters representing the number. */
4003 args
= make_tree_vector ();
4004 decl
= lookup_literal_operator (name
, args
);
4005 if (decl
&& decl
!= error_mark_node
)
4007 tree tmpl_args
= make_char_string_pack (num_string
);
4008 decl
= lookup_template_function (decl
, tmpl_args
);
4009 result
= finish_call_expr (decl
, &args
, false, true,
4010 tf_warning_or_error
);
4011 release_tree_vector (args
);
4015 release_tree_vector (args
);
4017 error ("unable to find numeric literal operator %qD", name
);
4018 if (!cpp_get_options (parse_in
)->ext_numeric_literals
)
4019 inform (token
->location
, "use -std=gnu++11 or -fext-numeric-literals "
4020 "to enable more built-in suffixes");
4021 return error_mark_node
;
4024 /* Parse a user-defined string constant. Returns a call to a user-defined
4025 literal operator taking a character pointer and the length of the string
4029 cp_parser_userdef_string_literal (tree literal
)
4031 tree suffix_id
= USERDEF_LITERAL_SUFFIX_ID (literal
);
4032 tree name
= cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id
));
4033 tree value
= USERDEF_LITERAL_VALUE (literal
);
4034 int len
= TREE_STRING_LENGTH (value
)
4035 / TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value
)))) - 1;
4037 vec
<tree
, va_gc
> *args
;
4039 /* Build up a call to the user-defined operator. */
4040 /* Lookup the name we got back from the id-expression. */
4041 args
= make_tree_vector ();
4042 vec_safe_push (args
, value
);
4043 vec_safe_push (args
, build_int_cst (size_type_node
, len
));
4044 decl
= lookup_literal_operator (name
, args
);
4046 if (decl
&& decl
!= error_mark_node
)
4048 result
= finish_call_expr (decl
, &args
, false, true,
4049 tf_warning_or_error
);
4050 release_tree_vector (args
);
4053 release_tree_vector (args
);
4055 /* Look for a template function with typename parameter CharT
4056 and parameter pack CharT... Call the function with
4057 template parameter characters representing the string. */
4058 args
= make_tree_vector ();
4059 decl
= lookup_literal_operator (name
, args
);
4060 if (decl
&& decl
!= error_mark_node
)
4062 tree tmpl_args
= make_string_pack (value
);
4063 decl
= lookup_template_function (decl
, tmpl_args
);
4064 result
= finish_call_expr (decl
, &args
, false, true,
4065 tf_warning_or_error
);
4066 release_tree_vector (args
);
4069 release_tree_vector (args
);
4071 error ("unable to find string literal operator %qD with %qT, %qT arguments",
4072 name
, TREE_TYPE (value
), size_type_node
);
4073 return error_mark_node
;
4077 /* Basic concepts [gram.basic] */
4079 /* Parse a translation-unit.
4082 declaration-seq [opt]
4084 Returns TRUE if all went well. */
4087 cp_parser_translation_unit (cp_parser
* parser
)
4089 /* The address of the first non-permanent object on the declarator
4091 static void *declarator_obstack_base
;
4095 /* Create the declarator obstack, if necessary. */
4096 if (!cp_error_declarator
)
4098 gcc_obstack_init (&declarator_obstack
);
4099 /* Create the error declarator. */
4100 cp_error_declarator
= make_declarator (cdk_error
);
4101 /* Create the empty parameter list. */
4102 no_parameters
= make_parameter_declarator (NULL
, NULL
, NULL_TREE
);
4103 /* Remember where the base of the declarator obstack lies. */
4104 declarator_obstack_base
= obstack_next_free (&declarator_obstack
);
4107 cp_parser_declaration_seq_opt (parser
);
4109 /* If there are no tokens left then all went well. */
4110 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
4112 /* Get rid of the token array; we don't need it any more. */
4113 cp_lexer_destroy (parser
->lexer
);
4114 parser
->lexer
= NULL
;
4116 /* This file might have been a context that's implicitly extern
4117 "C". If so, pop the lang context. (Only relevant for PCH.) */
4118 if (parser
->implicit_extern_c
)
4120 pop_lang_context ();
4121 parser
->implicit_extern_c
= false;
4125 finish_translation_unit ();
4131 cp_parser_error (parser
, "expected declaration");
4135 /* Make sure the declarator obstack was fully cleaned up. */
4136 gcc_assert (obstack_next_free (&declarator_obstack
)
4137 == declarator_obstack_base
);
4139 /* All went well. */
4143 /* Return the appropriate tsubst flags for parsing, possibly in N3276
4144 decltype context. */
4146 static inline tsubst_flags_t
4147 complain_flags (bool decltype_p
)
4149 tsubst_flags_t complain
= tf_warning_or_error
;
4151 complain
|= tf_decltype
;
4155 /* We're about to parse a collection of statements. If we're currently
4156 parsing tentatively, set up a firewall so that any nested
4157 cp_parser_commit_to_tentative_parse won't affect the current context. */
4159 static cp_token_position
4160 cp_parser_start_tentative_firewall (cp_parser
*parser
)
4162 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
4165 cp_parser_parse_tentatively (parser
);
4166 cp_parser_commit_to_topmost_tentative_parse (parser
);
4167 return cp_lexer_token_position (parser
->lexer
, false);
4170 /* We've finished parsing the collection of statements. Wrap up the
4171 firewall and replace the relevant tokens with the parsed form. */
4174 cp_parser_end_tentative_firewall (cp_parser
*parser
, cp_token_position start
,
4180 /* Finish the firewall level. */
4181 cp_parser_parse_definitely (parser
);
4182 /* And remember the result of the parse for when we try again. */
4183 cp_token
*token
= cp_lexer_token_at (parser
->lexer
, start
);
4184 token
->type
= CPP_PREPARSED_EXPR
;
4185 token
->u
.value
= expr
;
4186 token
->keyword
= RID_MAX
;
4187 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
4190 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
4191 enclosing parentheses. */
4194 cp_parser_statement_expr (cp_parser
*parser
)
4196 cp_token_position start
= cp_parser_start_tentative_firewall (parser
);
4198 /* Consume the '('. */
4199 cp_lexer_consume_token (parser
->lexer
);
4200 /* Start the statement-expression. */
4201 tree expr
= begin_stmt_expr ();
4202 /* Parse the compound-statement. */
4203 cp_parser_compound_statement (parser
, expr
, false, false);
4205 expr
= finish_stmt_expr (expr
, false);
4206 /* Consume the ')'. */
4207 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
4208 cp_parser_skip_to_end_of_statement (parser
);
4210 cp_parser_end_tentative_firewall (parser
, start
, expr
);
4214 /* Expressions [gram.expr] */
4216 /* Parse a primary-expression.
4223 lambda-expression (C++11)
4228 ( compound-statement )
4229 __builtin_va_arg ( assignment-expression , type-id )
4230 __builtin_offsetof ( type-id , offsetof-expression )
4233 __has_nothrow_assign ( type-id )
4234 __has_nothrow_constructor ( type-id )
4235 __has_nothrow_copy ( type-id )
4236 __has_trivial_assign ( type-id )
4237 __has_trivial_constructor ( type-id )
4238 __has_trivial_copy ( type-id )
4239 __has_trivial_destructor ( type-id )
4240 __has_virtual_destructor ( type-id )
4241 __is_abstract ( type-id )
4242 __is_base_of ( type-id , type-id )
4243 __is_class ( type-id )
4244 __is_empty ( type-id )
4245 __is_enum ( type-id )
4246 __is_final ( type-id )
4247 __is_literal_type ( type-id )
4248 __is_pod ( type-id )
4249 __is_polymorphic ( type-id )
4250 __is_std_layout ( type-id )
4251 __is_trivial ( type-id )
4252 __is_union ( type-id )
4254 Objective-C++ Extension:
4262 ADDRESS_P is true iff this expression was immediately preceded by
4263 "&" and therefore might denote a pointer-to-member. CAST_P is true
4264 iff this expression is the target of a cast. TEMPLATE_ARG_P is
4265 true iff this expression is a template argument.
4267 Returns a representation of the expression. Upon return, *IDK
4268 indicates what kind of id-expression (if any) was present. */
4271 cp_parser_primary_expression (cp_parser
*parser
,
4274 bool template_arg_p
,
4278 cp_token
*token
= NULL
;
4280 /* Assume the primary expression is not an id-expression. */
4281 *idk
= CP_ID_KIND_NONE
;
4283 /* Peek at the next token. */
4284 token
= cp_lexer_peek_token (parser
->lexer
);
4285 switch ((int) token
->type
)
4294 user-defined-literal */
4300 case CPP_PREPARSED_EXPR
:
4301 if (TREE_CODE (token
->u
.value
) == USERDEF_LITERAL
)
4302 return cp_parser_userdef_numeric_literal (parser
);
4303 token
= cp_lexer_consume_token (parser
->lexer
);
4304 if (TREE_CODE (token
->u
.value
) == FIXED_CST
)
4306 error_at (token
->location
,
4307 "fixed-point types not supported in C++");
4308 return error_mark_node
;
4310 /* Floating-point literals are only allowed in an integral
4311 constant expression if they are cast to an integral or
4312 enumeration type. */
4313 if (TREE_CODE (token
->u
.value
) == REAL_CST
4314 && parser
->integral_constant_expression_p
4317 /* CAST_P will be set even in invalid code like "int(2.7 +
4318 ...)". Therefore, we have to check that the next token
4319 is sure to end the cast. */
4322 cp_token
*next_token
;
4324 next_token
= cp_lexer_peek_token (parser
->lexer
);
4325 if (/* The comma at the end of an
4326 enumerator-definition. */
4327 next_token
->type
!= CPP_COMMA
4328 /* The curly brace at the end of an enum-specifier. */
4329 && next_token
->type
!= CPP_CLOSE_BRACE
4330 /* The end of a statement. */
4331 && next_token
->type
!= CPP_SEMICOLON
4332 /* The end of the cast-expression. */
4333 && next_token
->type
!= CPP_CLOSE_PAREN
4334 /* The end of an array bound. */
4335 && next_token
->type
!= CPP_CLOSE_SQUARE
4336 /* The closing ">" in a template-argument-list. */
4337 && (next_token
->type
!= CPP_GREATER
4338 || parser
->greater_than_is_operator_p
)
4339 /* C++0x only: A ">>" treated like two ">" tokens,
4340 in a template-argument-list. */
4341 && (next_token
->type
!= CPP_RSHIFT
4342 || (cxx_dialect
== cxx98
)
4343 || parser
->greater_than_is_operator_p
))
4347 /* If we are within a cast, then the constraint that the
4348 cast is to an integral or enumeration type will be
4349 checked at that point. If we are not within a cast, then
4350 this code is invalid. */
4352 cp_parser_non_integral_constant_expression (parser
, NIC_FLOAT
);
4354 return token
->u
.value
;
4356 case CPP_CHAR_USERDEF
:
4357 case CPP_CHAR16_USERDEF
:
4358 case CPP_CHAR32_USERDEF
:
4359 case CPP_WCHAR_USERDEF
:
4360 return cp_parser_userdef_char_literal (parser
);
4366 case CPP_UTF8STRING
:
4367 case CPP_STRING_USERDEF
:
4368 case CPP_STRING16_USERDEF
:
4369 case CPP_STRING32_USERDEF
:
4370 case CPP_WSTRING_USERDEF
:
4371 case CPP_UTF8STRING_USERDEF
:
4372 /* ??? Should wide strings be allowed when parser->translate_strings_p
4373 is false (i.e. in attributes)? If not, we can kill the third
4374 argument to cp_parser_string_literal. */
4375 return cp_parser_string_literal (parser
,
4376 parser
->translate_strings_p
,
4379 case CPP_OPEN_PAREN
:
4380 /* If we see `( { ' then we are looking at the beginning of
4381 a GNU statement-expression. */
4382 if (cp_parser_allow_gnu_extensions_p (parser
)
4383 && cp_lexer_nth_token_is (parser
->lexer
, 2, CPP_OPEN_BRACE
))
4385 /* Statement-expressions are not allowed by the standard. */
4386 pedwarn (token
->location
, OPT_Wpedantic
,
4387 "ISO C++ forbids braced-groups within expressions");
4389 /* And they're not allowed outside of a function-body; you
4390 cannot, for example, write:
4392 int i = ({ int j = 3; j + 1; });
4394 at class or namespace scope. */
4395 if (!parser
->in_function_body
4396 || parser
->in_template_argument_list_p
)
4398 error_at (token
->location
,
4399 "statement-expressions are not allowed outside "
4400 "functions nor in template-argument lists");
4401 cp_parser_skip_to_end_of_block_or_statement (parser
);
4402 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
4403 cp_lexer_consume_token (parser
->lexer
);
4404 return error_mark_node
;
4407 return cp_parser_statement_expr (parser
);
4409 /* Otherwise it's a normal parenthesized expression. */
4412 bool saved_greater_than_is_operator_p
;
4414 /* Consume the `('. */
4415 cp_lexer_consume_token (parser
->lexer
);
4416 /* Within a parenthesized expression, a `>' token is always
4417 the greater-than operator. */
4418 saved_greater_than_is_operator_p
4419 = parser
->greater_than_is_operator_p
;
4420 parser
->greater_than_is_operator_p
= true;
4422 /* Parse the parenthesized expression. */
4423 expr
= cp_parser_expression (parser
, idk
, cast_p
, decltype_p
);
4424 /* Let the front end know that this expression was
4425 enclosed in parentheses. This matters in case, for
4426 example, the expression is of the form `A::B', since
4427 `&A::B' might be a pointer-to-member, but `&(A::B)' is
4429 expr
= finish_parenthesized_expr (expr
);
4430 /* DR 705: Wrapping an unqualified name in parentheses
4431 suppresses arg-dependent lookup. We want to pass back
4432 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4433 (c++/37862), but none of the others. */
4434 if (*idk
!= CP_ID_KIND_QUALIFIED
)
4435 *idk
= CP_ID_KIND_NONE
;
4437 /* The `>' token might be the end of a template-id or
4438 template-parameter-list now. */
4439 parser
->greater_than_is_operator_p
4440 = saved_greater_than_is_operator_p
;
4441 /* Consume the `)'. */
4442 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
4443 cp_parser_skip_to_end_of_statement (parser
);
4448 case CPP_OPEN_SQUARE
:
4450 if (c_dialect_objc ())
4452 /* We might have an Objective-C++ message. */
4453 cp_parser_parse_tentatively (parser
);
4454 tree msg
= cp_parser_objc_message_expression (parser
);
4455 /* If that works out, we're done ... */
4456 if (cp_parser_parse_definitely (parser
))
4458 /* ... else, fall though to see if it's a lambda. */
4460 tree lam
= cp_parser_lambda_expression (parser
);
4461 /* Don't warn about a failed tentative parse. */
4462 if (cp_parser_error_occurred (parser
))
4463 return error_mark_node
;
4464 maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR
);
4468 case CPP_OBJC_STRING
:
4469 if (c_dialect_objc ())
4470 /* We have an Objective-C++ string literal. */
4471 return cp_parser_objc_expression (parser
);
4472 cp_parser_error (parser
, "expected primary-expression");
4473 return error_mark_node
;
4476 switch (token
->keyword
)
4478 /* These two are the boolean literals. */
4480 cp_lexer_consume_token (parser
->lexer
);
4481 return boolean_true_node
;
4483 cp_lexer_consume_token (parser
->lexer
);
4484 return boolean_false_node
;
4486 /* The `__null' literal. */
4488 cp_lexer_consume_token (parser
->lexer
);
4491 /* The `nullptr' literal. */
4493 cp_lexer_consume_token (parser
->lexer
);
4494 return nullptr_node
;
4496 /* Recognize the `this' keyword. */
4498 cp_lexer_consume_token (parser
->lexer
);
4499 if (parser
->local_variables_forbidden_p
)
4501 error_at (token
->location
,
4502 "%<this%> may not be used in this context");
4503 return error_mark_node
;
4505 /* Pointers cannot appear in constant-expressions. */
4506 if (cp_parser_non_integral_constant_expression (parser
, NIC_THIS
))
4507 return error_mark_node
;
4508 return finish_this_expr ();
4510 /* The `operator' keyword can be the beginning of an
4515 case RID_FUNCTION_NAME
:
4516 case RID_PRETTY_FUNCTION_NAME
:
4517 case RID_C99_FUNCTION_NAME
:
4519 non_integral_constant name
;
4521 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4522 __func__ are the names of variables -- but they are
4523 treated specially. Therefore, they are handled here,
4524 rather than relying on the generic id-expression logic
4525 below. Grammatically, these names are id-expressions.
4527 Consume the token. */
4528 token
= cp_lexer_consume_token (parser
->lexer
);
4530 switch (token
->keyword
)
4532 case RID_FUNCTION_NAME
:
4533 name
= NIC_FUNC_NAME
;
4535 case RID_PRETTY_FUNCTION_NAME
:
4536 name
= NIC_PRETTY_FUNC
;
4538 case RID_C99_FUNCTION_NAME
:
4539 name
= NIC_C99_FUNC
;
4545 if (cp_parser_non_integral_constant_expression (parser
, name
))
4546 return error_mark_node
;
4548 /* Look up the name. */
4549 return finish_fname (token
->u
.value
);
4556 source_location type_location
;
4558 /* The `__builtin_va_arg' construct is used to handle
4559 `va_arg'. Consume the `__builtin_va_arg' token. */
4560 cp_lexer_consume_token (parser
->lexer
);
4561 /* Look for the opening `('. */
4562 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
4563 /* Now, parse the assignment-expression. */
4564 expression
= cp_parser_assignment_expression (parser
);
4565 /* Look for the `,'. */
4566 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
4567 type_location
= cp_lexer_peek_token (parser
->lexer
)->location
;
4568 /* Parse the type-id. */
4569 type
= cp_parser_type_id (parser
);
4570 /* Look for the closing `)'. */
4571 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
4572 /* Using `va_arg' in a constant-expression is not
4574 if (cp_parser_non_integral_constant_expression (parser
,
4576 return error_mark_node
;
4577 return build_x_va_arg (type_location
, expression
, type
);
4581 return cp_parser_builtin_offsetof (parser
);
4583 case RID_HAS_NOTHROW_ASSIGN
:
4584 case RID_HAS_NOTHROW_CONSTRUCTOR
:
4585 case RID_HAS_NOTHROW_COPY
:
4586 case RID_HAS_TRIVIAL_ASSIGN
:
4587 case RID_HAS_TRIVIAL_CONSTRUCTOR
:
4588 case RID_HAS_TRIVIAL_COPY
:
4589 case RID_HAS_TRIVIAL_DESTRUCTOR
:
4590 case RID_HAS_VIRTUAL_DESTRUCTOR
:
4591 case RID_IS_ABSTRACT
:
4592 case RID_IS_BASE_OF
:
4597 case RID_IS_LITERAL_TYPE
:
4599 case RID_IS_POLYMORPHIC
:
4600 case RID_IS_STD_LAYOUT
:
4601 case RID_IS_TRIVIAL
:
4602 case RID_IS_TRIVIALLY_ASSIGNABLE
:
4603 case RID_IS_TRIVIALLY_CONSTRUCTIBLE
:
4604 case RID_IS_TRIVIALLY_COPYABLE
:
4606 return cp_parser_trait_expr (parser
, token
->keyword
);
4608 /* Objective-C++ expressions. */
4610 case RID_AT_PROTOCOL
:
4611 case RID_AT_SELECTOR
:
4612 return cp_parser_objc_expression (parser
);
4615 if (parser
->in_function_body
4616 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
4619 error_at (token
->location
,
4620 "a template declaration cannot appear at block scope");
4621 cp_parser_skip_to_end_of_block_or_statement (parser
);
4622 return error_mark_node
;
4625 cp_parser_error (parser
, "expected primary-expression");
4626 return error_mark_node
;
4629 /* An id-expression can start with either an identifier, a
4630 `::' as the beginning of a qualified-id, or the "operator"
4634 case CPP_TEMPLATE_ID
:
4635 case CPP_NESTED_NAME_SPECIFIER
:
4639 const char *error_msg
;
4642 cp_token
*id_expr_token
;
4645 /* Parse the id-expression. */
4647 = cp_parser_id_expression (parser
,
4648 /*template_keyword_p=*/false,
4649 /*check_dependency_p=*/true,
4651 /*declarator_p=*/false,
4652 /*optional_p=*/false);
4653 if (id_expression
== error_mark_node
)
4654 return error_mark_node
;
4655 id_expr_token
= token
;
4656 token
= cp_lexer_peek_token (parser
->lexer
);
4657 done
= (token
->type
!= CPP_OPEN_SQUARE
4658 && token
->type
!= CPP_OPEN_PAREN
4659 && token
->type
!= CPP_DOT
4660 && token
->type
!= CPP_DEREF
4661 && token
->type
!= CPP_PLUS_PLUS
4662 && token
->type
!= CPP_MINUS_MINUS
);
4663 /* If we have a template-id, then no further lookup is
4664 required. If the template-id was for a template-class, we
4665 will sometimes have a TYPE_DECL at this point. */
4666 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
4667 || TREE_CODE (id_expression
) == TYPE_DECL
)
4668 decl
= id_expression
;
4669 /* Look up the name. */
4672 tree ambiguous_decls
;
4674 /* If we already know that this lookup is ambiguous, then
4675 we've already issued an error message; there's no reason
4677 if (id_expr_token
->type
== CPP_NAME
4678 && id_expr_token
->error_reported
)
4680 cp_parser_simulate_error (parser
);
4681 return error_mark_node
;
4684 decl
= cp_parser_lookup_name (parser
, id_expression
,
4687 /*is_namespace=*/false,
4688 /*check_dependency=*/true,
4690 id_expr_token
->location
);
4691 /* If the lookup was ambiguous, an error will already have
4693 if (ambiguous_decls
)
4694 return error_mark_node
;
4696 /* In Objective-C++, we may have an Objective-C 2.0
4697 dot-syntax for classes here. */
4698 if (c_dialect_objc ()
4699 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_DOT
4700 && TREE_CODE (decl
) == TYPE_DECL
4701 && objc_is_class_name (decl
))
4704 cp_lexer_consume_token (parser
->lexer
);
4705 component
= cp_parser_identifier (parser
);
4706 if (component
== error_mark_node
)
4707 return error_mark_node
;
4709 return objc_build_class_component_ref (id_expression
, component
);
4712 /* In Objective-C++, an instance variable (ivar) may be preferred
4713 to whatever cp_parser_lookup_name() found. */
4714 decl
= objc_lookup_ivar (decl
, id_expression
);
4716 /* If name lookup gives us a SCOPE_REF, then the
4717 qualifying scope was dependent. */
4718 if (TREE_CODE (decl
) == SCOPE_REF
)
4720 /* At this point, we do not know if DECL is a valid
4721 integral constant expression. We assume that it is
4722 in fact such an expression, so that code like:
4724 template <int N> struct A {
4728 is accepted. At template-instantiation time, we
4729 will check that B<N>::i is actually a constant. */
4732 /* Check to see if DECL is a local variable in a context
4733 where that is forbidden. */
4734 if (parser
->local_variables_forbidden_p
4735 && local_variable_p (decl
))
4737 /* It might be that we only found DECL because we are
4738 trying to be generous with pre-ISO scoping rules.
4739 For example, consider:
4743 for (int i = 0; i < 10; ++i) {}
4744 extern void f(int j = i);
4747 Here, name look up will originally find the out
4748 of scope `i'. We need to issue a warning message,
4749 but then use the global `i'. */
4750 decl
= check_for_out_of_scope_variable (decl
);
4751 if (local_variable_p (decl
))
4753 error_at (id_expr_token
->location
,
4754 "local variable %qD may not appear in this context",
4756 return error_mark_node
;
4761 decl
= (finish_id_expression
4762 (id_expression
, decl
, parser
->scope
,
4764 parser
->integral_constant_expression_p
,
4765 parser
->allow_non_integral_constant_expression_p
,
4766 &parser
->non_integral_constant_expression_p
,
4767 template_p
, done
, address_p
,
4770 id_expr_token
->location
));
4772 cp_parser_error (parser
, error_msg
);
4776 /* Anything else is an error. */
4778 cp_parser_error (parser
, "expected primary-expression");
4779 return error_mark_node
;
4784 cp_parser_primary_expression (cp_parser
*parser
,
4787 bool template_arg_p
,
4790 return cp_parser_primary_expression (parser
, address_p
, cast_p
, template_arg_p
,
4791 /*decltype*/false, idk
);
4794 /* Parse an id-expression.
4801 :: [opt] nested-name-specifier template [opt] unqualified-id
4803 :: operator-function-id
4806 Return a representation of the unqualified portion of the
4807 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
4808 a `::' or nested-name-specifier.
4810 Often, if the id-expression was a qualified-id, the caller will
4811 want to make a SCOPE_REF to represent the qualified-id. This
4812 function does not do this in order to avoid wastefully creating
4813 SCOPE_REFs when they are not required.
4815 If TEMPLATE_KEYWORD_P is true, then we have just seen the
4818 If CHECK_DEPENDENCY_P is false, then names are looked up inside
4819 uninstantiated templates.
4821 If *TEMPLATE_P is non-NULL, it is set to true iff the
4822 `template' keyword is used to explicitly indicate that the entity
4823 named is a template.
4825 If DECLARATOR_P is true, the id-expression is appearing as part of
4826 a declarator, rather than as part of an expression. */
4829 cp_parser_id_expression (cp_parser
*parser
,
4830 bool template_keyword_p
,
4831 bool check_dependency_p
,
4836 bool global_scope_p
;
4837 bool nested_name_specifier_p
;
4839 /* Assume the `template' keyword was not used. */
4841 *template_p
= template_keyword_p
;
4843 /* Look for the optional `::' operator. */
4845 = (cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false)
4847 /* Look for the optional nested-name-specifier. */
4848 nested_name_specifier_p
4849 = (cp_parser_nested_name_specifier_opt (parser
,
4850 /*typename_keyword_p=*/false,
4855 /* If there is a nested-name-specifier, then we are looking at
4856 the first qualified-id production. */
4857 if (nested_name_specifier_p
)
4860 tree saved_object_scope
;
4861 tree saved_qualifying_scope
;
4862 tree unqualified_id
;
4865 /* See if the next token is the `template' keyword. */
4867 template_p
= &is_template
;
4868 *template_p
= cp_parser_optional_template_keyword (parser
);
4869 /* Name lookup we do during the processing of the
4870 unqualified-id might obliterate SCOPE. */
4871 saved_scope
= parser
->scope
;
4872 saved_object_scope
= parser
->object_scope
;
4873 saved_qualifying_scope
= parser
->qualifying_scope
;
4874 /* Process the final unqualified-id. */
4875 unqualified_id
= cp_parser_unqualified_id (parser
, *template_p
,
4878 /*optional_p=*/false);
4879 /* Restore the SAVED_SCOPE for our caller. */
4880 parser
->scope
= saved_scope
;
4881 parser
->object_scope
= saved_object_scope
;
4882 parser
->qualifying_scope
= saved_qualifying_scope
;
4884 return unqualified_id
;
4886 /* Otherwise, if we are in global scope, then we are looking at one
4887 of the other qualified-id productions. */
4888 else if (global_scope_p
)
4893 /* Peek at the next token. */
4894 token
= cp_lexer_peek_token (parser
->lexer
);
4896 /* If it's an identifier, and the next token is not a "<", then
4897 we can avoid the template-id case. This is an optimization
4898 for this common case. */
4899 if (token
->type
== CPP_NAME
4900 && !cp_parser_nth_token_starts_template_argument_list_p
4902 return cp_parser_identifier (parser
);
4904 cp_parser_parse_tentatively (parser
);
4905 /* Try a template-id. */
4906 id
= cp_parser_template_id (parser
,
4907 /*template_keyword_p=*/false,
4908 /*check_dependency_p=*/true,
4911 /* If that worked, we're done. */
4912 if (cp_parser_parse_definitely (parser
))
4915 /* Peek at the next token. (Changes in the token buffer may
4916 have invalidated the pointer obtained above.) */
4917 token
= cp_lexer_peek_token (parser
->lexer
);
4919 switch (token
->type
)
4922 return cp_parser_identifier (parser
);
4925 if (token
->keyword
== RID_OPERATOR
)
4926 return cp_parser_operator_function_id (parser
);
4930 cp_parser_error (parser
, "expected id-expression");
4931 return error_mark_node
;
4935 return cp_parser_unqualified_id (parser
, template_keyword_p
,
4936 /*check_dependency_p=*/true,
4941 /* Parse an unqualified-id.
4945 operator-function-id
4946 conversion-function-id
4950 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
4951 keyword, in a construct like `A::template ...'.
4953 Returns a representation of unqualified-id. For the `identifier'
4954 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
4955 production a BIT_NOT_EXPR is returned; the operand of the
4956 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
4957 other productions, see the documentation accompanying the
4958 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
4959 names are looked up in uninstantiated templates. If DECLARATOR_P
4960 is true, the unqualified-id is appearing as part of a declarator,
4961 rather than as part of an expression. */
4964 cp_parser_unqualified_id (cp_parser
* parser
,
4965 bool template_keyword_p
,
4966 bool check_dependency_p
,
4972 /* Peek at the next token. */
4973 token
= cp_lexer_peek_token (parser
->lexer
);
4975 switch ((int) token
->type
)
4981 /* We don't know yet whether or not this will be a
4983 cp_parser_parse_tentatively (parser
);
4984 /* Try a template-id. */
4985 id
= cp_parser_template_id (parser
, template_keyword_p
,
4989 /* If it worked, we're done. */
4990 if (cp_parser_parse_definitely (parser
))
4992 /* Otherwise, it's an ordinary identifier. */
4993 return cp_parser_identifier (parser
);
4996 case CPP_TEMPLATE_ID
:
4997 return cp_parser_template_id (parser
, template_keyword_p
,
5005 tree qualifying_scope
;
5010 /* Consume the `~' token. */
5011 cp_lexer_consume_token (parser
->lexer
);
5012 /* Parse the class-name. The standard, as written, seems to
5015 template <typename T> struct S { ~S (); };
5016 template <typename T> S<T>::~S() {}
5018 is invalid, since `~' must be followed by a class-name, but
5019 `S<T>' is dependent, and so not known to be a class.
5020 That's not right; we need to look in uninstantiated
5021 templates. A further complication arises from:
5023 template <typename T> void f(T t) {
5027 Here, it is not possible to look up `T' in the scope of `T'
5028 itself. We must look in both the current scope, and the
5029 scope of the containing complete expression.
5031 Yet another issue is:
5040 The standard does not seem to say that the `S' in `~S'
5041 should refer to the type `S' and not the data member
5044 /* DR 244 says that we look up the name after the "~" in the
5045 same scope as we looked up the qualifying name. That idea
5046 isn't fully worked out; it's more complicated than that. */
5047 scope
= parser
->scope
;
5048 object_scope
= parser
->object_scope
;
5049 qualifying_scope
= parser
->qualifying_scope
;
5051 /* Check for invalid scopes. */
5052 if (scope
== error_mark_node
)
5054 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
5055 cp_lexer_consume_token (parser
->lexer
);
5056 return error_mark_node
;
5058 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
5060 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
5061 error_at (token
->location
,
5062 "scope %qT before %<~%> is not a class-name",
5064 cp_parser_simulate_error (parser
);
5065 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
5066 cp_lexer_consume_token (parser
->lexer
);
5067 return error_mark_node
;
5069 gcc_assert (!scope
|| TYPE_P (scope
));
5071 /* If the name is of the form "X::~X" it's OK even if X is a
5073 token
= cp_lexer_peek_token (parser
->lexer
);
5075 && token
->type
== CPP_NAME
5076 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
5078 && (token
->u
.value
== TYPE_IDENTIFIER (scope
)
5079 || (CLASS_TYPE_P (scope
)
5080 && constructor_name_p (token
->u
.value
, scope
))))
5082 cp_lexer_consume_token (parser
->lexer
);
5083 return build_nt (BIT_NOT_EXPR
, scope
);
5086 /* ~auto means the destructor of whatever the object is. */
5087 if (cp_parser_is_keyword (token
, RID_AUTO
))
5089 if (cxx_dialect
< cxx14
)
5090 pedwarn (input_location
, 0,
5091 "%<~auto%> only available with "
5092 "-std=c++14 or -std=gnu++14");
5093 cp_lexer_consume_token (parser
->lexer
);
5094 return build_nt (BIT_NOT_EXPR
, make_auto ());
5097 /* If there was an explicit qualification (S::~T), first look
5098 in the scope given by the qualification (i.e., S).
5100 Note: in the calls to cp_parser_class_name below we pass
5101 typename_type so that lookup finds the injected-class-name
5102 rather than the constructor. */
5104 type_decl
= NULL_TREE
;
5107 cp_parser_parse_tentatively (parser
);
5108 type_decl
= cp_parser_class_name (parser
,
5109 /*typename_keyword_p=*/false,
5110 /*template_keyword_p=*/false,
5112 /*check_dependency=*/false,
5113 /*class_head_p=*/false,
5115 if (cp_parser_parse_definitely (parser
))
5118 /* In "N::S::~S", look in "N" as well. */
5119 if (!done
&& scope
&& qualifying_scope
)
5121 cp_parser_parse_tentatively (parser
);
5122 parser
->scope
= qualifying_scope
;
5123 parser
->object_scope
= NULL_TREE
;
5124 parser
->qualifying_scope
= NULL_TREE
;
5126 = cp_parser_class_name (parser
,
5127 /*typename_keyword_p=*/false,
5128 /*template_keyword_p=*/false,
5130 /*check_dependency=*/false,
5131 /*class_head_p=*/false,
5133 if (cp_parser_parse_definitely (parser
))
5136 /* In "p->S::~T", look in the scope given by "*p" as well. */
5137 else if (!done
&& object_scope
)
5139 cp_parser_parse_tentatively (parser
);
5140 parser
->scope
= object_scope
;
5141 parser
->object_scope
= NULL_TREE
;
5142 parser
->qualifying_scope
= NULL_TREE
;
5144 = cp_parser_class_name (parser
,
5145 /*typename_keyword_p=*/false,
5146 /*template_keyword_p=*/false,
5148 /*check_dependency=*/false,
5149 /*class_head_p=*/false,
5151 if (cp_parser_parse_definitely (parser
))
5154 /* Look in the surrounding context. */
5157 parser
->scope
= NULL_TREE
;
5158 parser
->object_scope
= NULL_TREE
;
5159 parser
->qualifying_scope
= NULL_TREE
;
5160 if (processing_template_decl
)
5161 cp_parser_parse_tentatively (parser
);
5163 = cp_parser_class_name (parser
,
5164 /*typename_keyword_p=*/false,
5165 /*template_keyword_p=*/false,
5167 /*check_dependency=*/false,
5168 /*class_head_p=*/false,
5170 if (processing_template_decl
5171 && ! cp_parser_parse_definitely (parser
))
5173 /* We couldn't find a type with this name, so just accept
5174 it and check for a match at instantiation time. */
5175 type_decl
= cp_parser_identifier (parser
);
5176 if (type_decl
!= error_mark_node
)
5177 type_decl
= build_nt (BIT_NOT_EXPR
, type_decl
);
5181 /* If an error occurred, assume that the name of the
5182 destructor is the same as the name of the qualifying
5183 class. That allows us to keep parsing after running
5184 into ill-formed destructor names. */
5185 if (type_decl
== error_mark_node
&& scope
)
5186 return build_nt (BIT_NOT_EXPR
, scope
);
5187 else if (type_decl
== error_mark_node
)
5188 return error_mark_node
;
5190 /* Check that destructor name and scope match. */
5191 if (declarator_p
&& scope
&& !check_dtor_name (scope
, type_decl
))
5193 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
5194 error_at (token
->location
,
5195 "declaration of %<~%T%> as member of %qT",
5197 cp_parser_simulate_error (parser
);
5198 return error_mark_node
;
5203 A typedef-name that names a class shall not be used as the
5204 identifier in the declarator for a destructor declaration. */
5206 && !DECL_IMPLICIT_TYPEDEF_P (type_decl
)
5207 && !DECL_SELF_REFERENCE_P (type_decl
)
5208 && !cp_parser_uncommitted_to_tentative_parse_p (parser
))
5209 error_at (token
->location
,
5210 "typedef-name %qD used as destructor declarator",
5213 return build_nt (BIT_NOT_EXPR
, TREE_TYPE (type_decl
));
5217 if (token
->keyword
== RID_OPERATOR
)
5221 /* This could be a template-id, so we try that first. */
5222 cp_parser_parse_tentatively (parser
);
5223 /* Try a template-id. */
5224 id
= cp_parser_template_id (parser
, template_keyword_p
,
5225 /*check_dependency_p=*/true,
5228 /* If that worked, we're done. */
5229 if (cp_parser_parse_definitely (parser
))
5231 /* We still don't know whether we're looking at an
5232 operator-function-id or a conversion-function-id. */
5233 cp_parser_parse_tentatively (parser
);
5234 /* Try an operator-function-id. */
5235 id
= cp_parser_operator_function_id (parser
);
5236 /* If that didn't work, try a conversion-function-id. */
5237 if (!cp_parser_parse_definitely (parser
))
5238 id
= cp_parser_conversion_function_id (parser
);
5239 else if (UDLIT_OPER_P (id
))
5242 const char *name
= UDLIT_OP_SUFFIX (id
);
5243 if (name
[0] != '_' && !in_system_header_at (input_location
)
5245 warning (0, "literal operator suffixes not preceded by %<_%>"
5246 " are reserved for future standardization");
5256 cp_parser_error (parser
, "expected unqualified-id");
5257 return error_mark_node
;
5261 /* Parse an (optional) nested-name-specifier.
5263 nested-name-specifier: [C++98]
5264 class-or-namespace-name :: nested-name-specifier [opt]
5265 class-or-namespace-name :: template nested-name-specifier [opt]
5267 nested-name-specifier: [C++0x]
5270 nested-name-specifier identifier ::
5271 nested-name-specifier template [opt] simple-template-id ::
5273 PARSER->SCOPE should be set appropriately before this function is
5274 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
5275 effect. TYPE_P is TRUE if we non-type bindings should be ignored
5278 Sets PARSER->SCOPE to the class (TYPE) or namespace
5279 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
5280 it unchanged if there is no nested-name-specifier. Returns the new
5281 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
5283 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
5284 part of a declaration and/or decl-specifier. */
5287 cp_parser_nested_name_specifier_opt (cp_parser
*parser
,
5288 bool typename_keyword_p
,
5289 bool check_dependency_p
,
5291 bool is_declaration
)
5293 bool success
= false;
5294 cp_token_position start
= 0;
5297 /* Remember where the nested-name-specifier starts. */
5298 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
5300 start
= cp_lexer_token_position (parser
->lexer
, false);
5301 push_deferring_access_checks (dk_deferred
);
5308 tree saved_qualifying_scope
;
5309 bool template_keyword_p
;
5311 /* Spot cases that cannot be the beginning of a
5312 nested-name-specifier. */
5313 token
= cp_lexer_peek_token (parser
->lexer
);
5315 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
5316 the already parsed nested-name-specifier. */
5317 if (token
->type
== CPP_NESTED_NAME_SPECIFIER
)
5319 /* Grab the nested-name-specifier and continue the loop. */
5320 cp_parser_pre_parsed_nested_name_specifier (parser
);
5321 /* If we originally encountered this nested-name-specifier
5322 with IS_DECLARATION set to false, we will not have
5323 resolved TYPENAME_TYPEs, so we must do so here. */
5325 && TREE_CODE (parser
->scope
) == TYPENAME_TYPE
)
5327 new_scope
= resolve_typename_type (parser
->scope
,
5328 /*only_current_p=*/false);
5329 if (TREE_CODE (new_scope
) != TYPENAME_TYPE
)
5330 parser
->scope
= new_scope
;
5336 /* Spot cases that cannot be the beginning of a
5337 nested-name-specifier. On the second and subsequent times
5338 through the loop, we look for the `template' keyword. */
5339 if (success
&& token
->keyword
== RID_TEMPLATE
)
5341 /* A template-id can start a nested-name-specifier. */
5342 else if (token
->type
== CPP_TEMPLATE_ID
)
5344 /* DR 743: decltype can be used in a nested-name-specifier. */
5345 else if (token_is_decltype (token
))
5349 /* If the next token is not an identifier, then it is
5350 definitely not a type-name or namespace-name. */
5351 if (token
->type
!= CPP_NAME
)
5353 /* If the following token is neither a `<' (to begin a
5354 template-id), nor a `::', then we are not looking at a
5355 nested-name-specifier. */
5356 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
5358 if (token
->type
== CPP_COLON
5359 && parser
->colon_corrects_to_scope_p
5360 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_NAME
)
5362 error_at (token
->location
,
5363 "found %<:%> in nested-name-specifier, expected %<::%>");
5364 token
->type
= CPP_SCOPE
;
5367 if (token
->type
!= CPP_SCOPE
5368 && !cp_parser_nth_token_starts_template_argument_list_p
5373 /* The nested-name-specifier is optional, so we parse
5375 cp_parser_parse_tentatively (parser
);
5377 /* Look for the optional `template' keyword, if this isn't the
5378 first time through the loop. */
5380 template_keyword_p
= cp_parser_optional_template_keyword (parser
);
5382 template_keyword_p
= false;
5384 /* Save the old scope since the name lookup we are about to do
5385 might destroy it. */
5386 old_scope
= parser
->scope
;
5387 saved_qualifying_scope
= parser
->qualifying_scope
;
5388 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
5389 look up names in "X<T>::I" in order to determine that "Y" is
5390 a template. So, if we have a typename at this point, we make
5391 an effort to look through it. */
5393 && !typename_keyword_p
5395 && TREE_CODE (parser
->scope
) == TYPENAME_TYPE
)
5396 parser
->scope
= resolve_typename_type (parser
->scope
,
5397 /*only_current_p=*/false);
5398 /* Parse the qualifying entity. */
5400 = cp_parser_qualifying_entity (parser
,
5406 /* Look for the `::' token. */
5407 cp_parser_require (parser
, CPP_SCOPE
, RT_SCOPE
);
5409 /* If we found what we wanted, we keep going; otherwise, we're
5411 if (!cp_parser_parse_definitely (parser
))
5413 bool error_p
= false;
5415 /* Restore the OLD_SCOPE since it was valid before the
5416 failed attempt at finding the last
5417 class-or-namespace-name. */
5418 parser
->scope
= old_scope
;
5419 parser
->qualifying_scope
= saved_qualifying_scope
;
5421 /* If the next token is a decltype, and the one after that is a
5422 `::', then the decltype has failed to resolve to a class or
5423 enumeration type. Give this error even when parsing
5424 tentatively since it can't possibly be valid--and we're going
5425 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
5426 won't get another chance.*/
5427 if (cp_lexer_next_token_is (parser
->lexer
, CPP_DECLTYPE
)
5428 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
5431 token
= cp_lexer_consume_token (parser
->lexer
);
5432 error_at (token
->location
, "decltype evaluates to %qT, "
5433 "which is not a class or enumeration type",
5435 parser
->scope
= error_mark_node
;
5439 cp_lexer_consume_token (parser
->lexer
);
5442 if (cp_lexer_next_token_is (parser
->lexer
, CPP_TEMPLATE_ID
)
5443 && cp_lexer_nth_token_is (parser
->lexer
, 2, CPP_SCOPE
))
5445 /* If we have a non-type template-id followed by ::, it can't
5446 possibly be valid. */
5447 token
= cp_lexer_peek_token (parser
->lexer
);
5448 tree tid
= token
->u
.tree_check_value
->value
;
5449 if (TREE_CODE (tid
) == TEMPLATE_ID_EXPR
5450 && TREE_CODE (TREE_OPERAND (tid
, 0)) != IDENTIFIER_NODE
)
5452 tree tmpl
= NULL_TREE
;
5453 if (is_overloaded_fn (tid
))
5455 tree fns
= get_fns (tid
);
5456 if (!OVL_CHAIN (fns
))
5457 tmpl
= OVL_CURRENT (fns
);
5458 error_at (token
->location
, "function template-id %qD "
5459 "in nested-name-specifier", tid
);
5463 /* Variable template. */
5464 tmpl
= TREE_OPERAND (tid
, 0);
5465 gcc_assert (variable_template_p (tmpl
));
5466 error_at (token
->location
, "variable template-id %qD "
5467 "in nested-name-specifier", tid
);
5470 inform (DECL_SOURCE_LOCATION (tmpl
),
5471 "%qD declared here", tmpl
);
5473 parser
->scope
= error_mark_node
;
5477 cp_lexer_consume_token (parser
->lexer
);
5478 cp_lexer_consume_token (parser
->lexer
);
5482 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
5484 /* If the next token is an identifier, and the one after
5485 that is a `::', then any valid interpretation would have
5486 found a class-or-namespace-name. */
5487 while (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
5488 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
5490 && (cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
5493 token
= cp_lexer_consume_token (parser
->lexer
);
5496 if (!token
->error_reported
)
5499 tree ambiguous_decls
;
5501 decl
= cp_parser_lookup_name (parser
, token
->u
.value
,
5503 /*is_template=*/false,
5504 /*is_namespace=*/false,
5505 /*check_dependency=*/true,
5508 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
5509 error_at (token
->location
,
5510 "%qD used without template parameters",
5512 else if (ambiguous_decls
)
5514 // cp_parser_lookup_name has the same diagnostic,
5515 // thus make sure to emit it at most once.
5516 if (cp_parser_uncommitted_to_tentative_parse_p
5519 error_at (token
->location
,
5520 "reference to %qD is ambiguous",
5522 print_candidates (ambiguous_decls
);
5524 decl
= error_mark_node
;
5528 if (cxx_dialect
!= cxx98
)
5529 cp_parser_name_lookup_error
5530 (parser
, token
->u
.value
, decl
, NLE_NOT_CXX98
,
5533 cp_parser_name_lookup_error
5534 (parser
, token
->u
.value
, decl
, NLE_CXX98
,
5538 parser
->scope
= error_mark_node
;
5540 /* Treat this as a successful nested-name-specifier
5545 If the name found is not a class-name (clause
5546 _class_) or namespace-name (_namespace.def_), the
5547 program is ill-formed. */
5550 cp_lexer_consume_token (parser
->lexer
);
5554 /* We've found one valid nested-name-specifier. */
5556 /* Name lookup always gives us a DECL. */
5557 if (TREE_CODE (new_scope
) == TYPE_DECL
)
5558 new_scope
= TREE_TYPE (new_scope
);
5559 /* Uses of "template" must be followed by actual templates. */
5560 if (template_keyword_p
5561 && !(CLASS_TYPE_P (new_scope
)
5562 && ((CLASSTYPE_USE_TEMPLATE (new_scope
)
5563 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope
)))
5564 || CLASSTYPE_IS_TEMPLATE (new_scope
)))
5565 && !(TREE_CODE (new_scope
) == TYPENAME_TYPE
5566 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope
))
5567 == TEMPLATE_ID_EXPR
)))
5568 permerror (input_location
, TYPE_P (new_scope
)
5569 ? G_("%qT is not a template")
5570 : G_("%qD is not a template"),
5572 /* If it is a class scope, try to complete it; we are about to
5573 be looking up names inside the class. */
5574 if (TYPE_P (new_scope
)
5575 /* Since checking types for dependency can be expensive,
5576 avoid doing it if the type is already complete. */
5577 && !COMPLETE_TYPE_P (new_scope
)
5578 /* Do not try to complete dependent types. */
5579 && !dependent_type_p (new_scope
))
5581 new_scope
= complete_type (new_scope
);
5582 /* If it is a typedef to current class, use the current
5583 class instead, as the typedef won't have any names inside
5585 if (!COMPLETE_TYPE_P (new_scope
)
5586 && currently_open_class (new_scope
))
5587 new_scope
= TYPE_MAIN_VARIANT (new_scope
);
5589 /* Make sure we look in the right scope the next time through
5591 parser
->scope
= new_scope
;
5594 /* If parsing tentatively, replace the sequence of tokens that makes
5595 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
5596 token. That way, should we re-parse the token stream, we will
5597 not have to repeat the effort required to do the parse, nor will
5598 we issue duplicate error messages. */
5599 if (success
&& start
)
5603 token
= cp_lexer_token_at (parser
->lexer
, start
);
5604 /* Reset the contents of the START token. */
5605 token
->type
= CPP_NESTED_NAME_SPECIFIER
;
5606 /* Retrieve any deferred checks. Do not pop this access checks yet
5607 so the memory will not be reclaimed during token replacing below. */
5608 token
->u
.tree_check_value
= ggc_cleared_alloc
<struct tree_check
> ();
5609 token
->u
.tree_check_value
->value
= parser
->scope
;
5610 token
->u
.tree_check_value
->checks
= get_deferred_access_checks ();
5611 token
->u
.tree_check_value
->qualifying_scope
=
5612 parser
->qualifying_scope
;
5613 token
->keyword
= RID_MAX
;
5615 /* Purge all subsequent tokens. */
5616 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
5620 pop_to_parent_deferring_access_checks ();
5622 return success
? parser
->scope
: NULL_TREE
;
5625 /* Parse a nested-name-specifier. See
5626 cp_parser_nested_name_specifier_opt for details. This function
5627 behaves identically, except that it will an issue an error if no
5628 nested-name-specifier is present. */
5631 cp_parser_nested_name_specifier (cp_parser
*parser
,
5632 bool typename_keyword_p
,
5633 bool check_dependency_p
,
5635 bool is_declaration
)
5639 /* Look for the nested-name-specifier. */
5640 scope
= cp_parser_nested_name_specifier_opt (parser
,
5645 /* If it was not present, issue an error message. */
5648 cp_parser_error (parser
, "expected nested-name-specifier");
5649 parser
->scope
= NULL_TREE
;
5655 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
5656 this is either a class-name or a namespace-name (which corresponds
5657 to the class-or-namespace-name production in the grammar). For
5658 C++0x, it can also be a type-name that refers to an enumeration
5659 type or a simple-template-id.
5661 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
5662 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
5663 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
5664 TYPE_P is TRUE iff the next name should be taken as a class-name,
5665 even the same name is declared to be another entity in the same
5668 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
5669 specified by the class-or-namespace-name. If neither is found the
5670 ERROR_MARK_NODE is returned. */
5673 cp_parser_qualifying_entity (cp_parser
*parser
,
5674 bool typename_keyword_p
,
5675 bool template_keyword_p
,
5676 bool check_dependency_p
,
5678 bool is_declaration
)
5681 tree saved_qualifying_scope
;
5682 tree saved_object_scope
;
5685 bool successful_parse_p
;
5687 /* DR 743: decltype can appear in a nested-name-specifier. */
5688 if (cp_lexer_next_token_is_decltype (parser
->lexer
))
5690 scope
= cp_parser_decltype (parser
);
5691 if (TREE_CODE (scope
) != ENUMERAL_TYPE
5692 && !MAYBE_CLASS_TYPE_P (scope
))
5694 cp_parser_simulate_error (parser
);
5695 return error_mark_node
;
5697 if (TYPE_NAME (scope
))
5698 scope
= TYPE_NAME (scope
);
5702 /* Before we try to parse the class-name, we must save away the
5703 current PARSER->SCOPE since cp_parser_class_name will destroy
5705 saved_scope
= parser
->scope
;
5706 saved_qualifying_scope
= parser
->qualifying_scope
;
5707 saved_object_scope
= parser
->object_scope
;
5708 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
5709 there is no need to look for a namespace-name. */
5710 only_class_p
= template_keyword_p
5711 || (saved_scope
&& TYPE_P (saved_scope
) && cxx_dialect
== cxx98
);
5713 cp_parser_parse_tentatively (parser
);
5714 scope
= cp_parser_class_name (parser
,
5717 type_p
? class_type
: none_type
,
5719 /*class_head_p=*/false,
5721 /*enum_ok=*/cxx_dialect
> cxx98
);
5722 successful_parse_p
= only_class_p
|| cp_parser_parse_definitely (parser
);
5723 /* If that didn't work, try for a namespace-name. */
5724 if (!only_class_p
&& !successful_parse_p
)
5726 /* Restore the saved scope. */
5727 parser
->scope
= saved_scope
;
5728 parser
->qualifying_scope
= saved_qualifying_scope
;
5729 parser
->object_scope
= saved_object_scope
;
5730 /* If we are not looking at an identifier followed by the scope
5731 resolution operator, then this is not part of a
5732 nested-name-specifier. (Note that this function is only used
5733 to parse the components of a nested-name-specifier.) */
5734 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
)
5735 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
)
5736 return error_mark_node
;
5737 scope
= cp_parser_namespace_name (parser
);
5743 /* Return true if we are looking at a compound-literal, false otherwise. */
5746 cp_parser_compound_literal_p (cp_parser
*parser
)
5748 /* Consume the `('. */
5749 cp_lexer_consume_token (parser
->lexer
);
5751 cp_lexer_save_tokens (parser
->lexer
);
5753 /* Skip tokens until the next token is a closing parenthesis.
5754 If we find the closing `)', and the next token is a `{', then
5755 we are looking at a compound-literal. */
5756 bool compound_literal_p
5757 = (cp_parser_skip_to_closing_parenthesis (parser
, false, false,
5758 /*consume_paren=*/true)
5759 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
));
5761 /* Roll back the tokens we skipped. */
5762 cp_lexer_rollback_tokens (parser
->lexer
);
5764 return compound_literal_p
;
5767 /* Parse a postfix-expression.
5771 postfix-expression [ expression ]
5772 postfix-expression ( expression-list [opt] )
5773 simple-type-specifier ( expression-list [opt] )
5774 typename :: [opt] nested-name-specifier identifier
5775 ( expression-list [opt] )
5776 typename :: [opt] nested-name-specifier template [opt] template-id
5777 ( expression-list [opt] )
5778 postfix-expression . template [opt] id-expression
5779 postfix-expression -> template [opt] id-expression
5780 postfix-expression . pseudo-destructor-name
5781 postfix-expression -> pseudo-destructor-name
5782 postfix-expression ++
5783 postfix-expression --
5784 dynamic_cast < type-id > ( expression )
5785 static_cast < type-id > ( expression )
5786 reinterpret_cast < type-id > ( expression )
5787 const_cast < type-id > ( expression )
5788 typeid ( expression )
5794 ( type-id ) { initializer-list , [opt] }
5796 This extension is a GNU version of the C99 compound-literal
5797 construct. (The C99 grammar uses `type-name' instead of `type-id',
5798 but they are essentially the same concept.)
5800 If ADDRESS_P is true, the postfix expression is the operand of the
5801 `&' operator. CAST_P is true if this expression is the target of a
5804 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
5805 class member access expressions [expr.ref].
5807 Returns a representation of the expression. */
5810 cp_parser_postfix_expression (cp_parser
*parser
, bool address_p
, bool cast_p
,
5811 bool member_access_only_p
, bool decltype_p
,
5812 cp_id_kind
* pidk_return
)
5817 cp_id_kind idk
= CP_ID_KIND_NONE
;
5818 tree postfix_expression
= NULL_TREE
;
5819 bool is_member_access
= false;
5820 int saved_in_statement
= -1;
5822 /* Peek at the next token. */
5823 token
= cp_lexer_peek_token (parser
->lexer
);
5824 loc
= token
->location
;
5825 /* Some of the productions are determined by keywords. */
5826 keyword
= token
->keyword
;
5836 const char *saved_message
;
5837 bool saved_in_type_id_in_expr_p
;
5839 /* All of these can be handled in the same way from the point
5840 of view of parsing. Begin by consuming the token
5841 identifying the cast. */
5842 cp_lexer_consume_token (parser
->lexer
);
5844 /* New types cannot be defined in the cast. */
5845 saved_message
= parser
->type_definition_forbidden_message
;
5846 parser
->type_definition_forbidden_message
5847 = G_("types may not be defined in casts");
5849 /* Look for the opening `<'. */
5850 cp_parser_require (parser
, CPP_LESS
, RT_LESS
);
5851 /* Parse the type to which we are casting. */
5852 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
5853 parser
->in_type_id_in_expr_p
= true;
5854 type
= cp_parser_type_id (parser
);
5855 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
5856 /* Look for the closing `>'. */
5857 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
5858 /* Restore the old message. */
5859 parser
->type_definition_forbidden_message
= saved_message
;
5861 bool saved_greater_than_is_operator_p
5862 = parser
->greater_than_is_operator_p
;
5863 parser
->greater_than_is_operator_p
= true;
5865 /* And the expression which is being cast. */
5866 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
5867 expression
= cp_parser_expression (parser
, & idk
, /*cast_p=*/true);
5868 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
5870 parser
->greater_than_is_operator_p
5871 = saved_greater_than_is_operator_p
;
5873 /* Only type conversions to integral or enumeration types
5874 can be used in constant-expressions. */
5875 if (!cast_valid_in_integral_constant_expression_p (type
)
5876 && cp_parser_non_integral_constant_expression (parser
, NIC_CAST
))
5877 return error_mark_node
;
5883 = build_dynamic_cast (type
, expression
, tf_warning_or_error
);
5887 = build_static_cast (type
, expression
, tf_warning_or_error
);
5891 = build_reinterpret_cast (type
, expression
,
5892 tf_warning_or_error
);
5896 = build_const_cast (type
, expression
, tf_warning_or_error
);
5907 const char *saved_message
;
5908 bool saved_in_type_id_in_expr_p
;
5910 /* Consume the `typeid' token. */
5911 cp_lexer_consume_token (parser
->lexer
);
5912 /* Look for the `(' token. */
5913 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
5914 /* Types cannot be defined in a `typeid' expression. */
5915 saved_message
= parser
->type_definition_forbidden_message
;
5916 parser
->type_definition_forbidden_message
5917 = G_("types may not be defined in a %<typeid%> expression");
5918 /* We can't be sure yet whether we're looking at a type-id or an
5920 cp_parser_parse_tentatively (parser
);
5921 /* Try a type-id first. */
5922 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
5923 parser
->in_type_id_in_expr_p
= true;
5924 type
= cp_parser_type_id (parser
);
5925 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
5926 /* Look for the `)' token. Otherwise, we can't be sure that
5927 we're not looking at an expression: consider `typeid (int
5928 (3))', for example. */
5929 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
5930 /* If all went well, simply lookup the type-id. */
5931 if (cp_parser_parse_definitely (parser
))
5932 postfix_expression
= get_typeid (type
, tf_warning_or_error
);
5933 /* Otherwise, fall back to the expression variant. */
5938 /* Look for an expression. */
5939 expression
= cp_parser_expression (parser
, & idk
);
5940 /* Compute its typeid. */
5941 postfix_expression
= build_typeid (expression
, tf_warning_or_error
);
5942 /* Look for the `)' token. */
5943 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
5945 /* Restore the saved message. */
5946 parser
->type_definition_forbidden_message
= saved_message
;
5947 /* `typeid' may not appear in an integral constant expression. */
5948 if (cp_parser_non_integral_constant_expression (parser
, NIC_TYPEID
))
5949 return error_mark_node
;
5956 /* The syntax permitted here is the same permitted for an
5957 elaborated-type-specifier. */
5958 type
= cp_parser_elaborated_type_specifier (parser
,
5959 /*is_friend=*/false,
5960 /*is_declaration=*/false);
5961 postfix_expression
= cp_parser_functional_cast (parser
, type
);
5965 case RID_CILK_SPAWN
:
5967 cp_lexer_consume_token (parser
->lexer
);
5968 token
= cp_lexer_peek_token (parser
->lexer
);
5969 if (token
->type
== CPP_SEMICOLON
)
5971 error_at (token
->location
, "%<_Cilk_spawn%> must be followed by "
5973 postfix_expression
= error_mark_node
;
5976 else if (!current_function_decl
)
5978 error_at (token
->location
, "%<_Cilk_spawn%> may only be used "
5979 "inside a function");
5980 postfix_expression
= error_mark_node
;
5985 /* Consecutive _Cilk_spawns are not allowed in a statement. */
5986 saved_in_statement
= parser
->in_statement
;
5987 parser
->in_statement
|= IN_CILK_SPAWN
;
5989 cfun
->calls_cilk_spawn
= 1;
5990 postfix_expression
=
5991 cp_parser_postfix_expression (parser
, false, false,
5992 false, false, &idk
);
5995 error_at (token
->location
, "-fcilkplus must be enabled to use"
5996 " %<_Cilk_spawn%>");
5997 cfun
->calls_cilk_spawn
= 0;
5999 else if (saved_in_statement
& IN_CILK_SPAWN
)
6001 error_at (token
->location
, "consecutive %<_Cilk_spawn%> keywords "
6002 "are not permitted");
6003 postfix_expression
= error_mark_node
;
6004 cfun
->calls_cilk_spawn
= 0;
6008 postfix_expression
= build_cilk_spawn (token
->location
,
6009 postfix_expression
);
6010 if (postfix_expression
!= error_mark_node
)
6011 SET_EXPR_LOCATION (postfix_expression
, input_location
);
6012 parser
->in_statement
= parser
->in_statement
& ~IN_CILK_SPAWN
;
6017 case RID_BUILTIN_SHUFFLE
:
6019 vec
<tree
, va_gc
> *vec
;
6023 cp_lexer_consume_token (parser
->lexer
);
6024 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
6025 /*cast_p=*/false, /*allow_expansion_p=*/true,
6026 /*non_constant_p=*/NULL
);
6028 return error_mark_node
;
6030 FOR_EACH_VEC_ELT (*vec
, i
, p
)
6033 if (vec
->length () == 2)
6034 return build_x_vec_perm_expr (loc
, (*vec
)[0], NULL_TREE
, (*vec
)[1],
6035 tf_warning_or_error
);
6036 else if (vec
->length () == 3)
6037 return build_x_vec_perm_expr (loc
, (*vec
)[0], (*vec
)[1], (*vec
)[2],
6038 tf_warning_or_error
);
6041 error_at (loc
, "wrong number of arguments to "
6042 "%<__builtin_shuffle%>");
6043 return error_mark_node
;
6052 /* If the next thing is a simple-type-specifier, we may be
6053 looking at a functional cast. We could also be looking at
6054 an id-expression. So, we try the functional cast, and if
6055 that doesn't work we fall back to the primary-expression. */
6056 cp_parser_parse_tentatively (parser
);
6057 /* Look for the simple-type-specifier. */
6058 type
= cp_parser_simple_type_specifier (parser
,
6059 /*decl_specs=*/NULL
,
6060 CP_PARSER_FLAGS_NONE
);
6061 /* Parse the cast itself. */
6062 if (!cp_parser_error_occurred (parser
))
6064 = cp_parser_functional_cast (parser
, type
);
6065 /* If that worked, we're done. */
6066 if (cp_parser_parse_definitely (parser
))
6069 /* If the functional-cast didn't work out, try a
6070 compound-literal. */
6071 if (cp_parser_allow_gnu_extensions_p (parser
)
6072 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
6074 tree initializer
= NULL_TREE
;
6076 cp_parser_parse_tentatively (parser
);
6078 /* Avoid calling cp_parser_type_id pointlessly, see comment
6079 in cp_parser_cast_expression about c++/29234. */
6080 if (!cp_parser_compound_literal_p (parser
))
6081 cp_parser_simulate_error (parser
);
6084 /* Parse the type. */
6085 bool saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
6086 parser
->in_type_id_in_expr_p
= true;
6087 type
= cp_parser_type_id (parser
);
6088 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
6089 /* Look for the `)'. */
6090 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
6093 /* If things aren't going well, there's no need to
6095 if (!cp_parser_error_occurred (parser
))
6097 bool non_constant_p
;
6098 /* Parse the brace-enclosed initializer list. */
6099 initializer
= cp_parser_braced_list (parser
,
6102 /* If that worked, we're definitely looking at a
6103 compound-literal expression. */
6104 if (cp_parser_parse_definitely (parser
))
6106 /* Warn the user that a compound literal is not
6107 allowed in standard C++. */
6108 pedwarn (input_location
, OPT_Wpedantic
,
6109 "ISO C++ forbids compound-literals");
6110 /* For simplicity, we disallow compound literals in
6111 constant-expressions. We could
6112 allow compound literals of integer type, whose
6113 initializer was a constant, in constant
6114 expressions. Permitting that usage, as a further
6115 extension, would not change the meaning of any
6116 currently accepted programs. (Of course, as
6117 compound literals are not part of ISO C++, the
6118 standard has nothing to say.) */
6119 if (cp_parser_non_integral_constant_expression (parser
,
6122 postfix_expression
= error_mark_node
;
6125 /* Form the representation of the compound-literal. */
6127 = finish_compound_literal (type
, initializer
,
6128 tf_warning_or_error
);
6133 /* It must be a primary-expression. */
6135 = cp_parser_primary_expression (parser
, address_p
, cast_p
,
6136 /*template_arg_p=*/false,
6143 /* Note that we don't need to worry about calling build_cplus_new on a
6144 class-valued CALL_EXPR in decltype when it isn't the end of the
6145 postfix-expression; unary_complex_lvalue will take care of that for
6148 /* Keep looping until the postfix-expression is complete. */
6151 if (idk
== CP_ID_KIND_UNQUALIFIED
6152 && identifier_p (postfix_expression
)
6153 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
))
6154 /* It is not a Koenig lookup function call. */
6156 = unqualified_name_lookup_error (postfix_expression
);
6158 /* Peek at the next token. */
6159 token
= cp_lexer_peek_token (parser
->lexer
);
6161 switch (token
->type
)
6163 case CPP_OPEN_SQUARE
:
6164 if (cp_next_tokens_can_be_std_attribute_p (parser
))
6166 cp_parser_error (parser
,
6167 "two consecutive %<[%> shall "
6168 "only introduce an attribute");
6169 return error_mark_node
;
6172 = cp_parser_postfix_open_square_expression (parser
,
6176 idk
= CP_ID_KIND_NONE
;
6177 is_member_access
= false;
6180 case CPP_OPEN_PAREN
:
6181 /* postfix-expression ( expression-list [opt] ) */
6184 bool is_builtin_constant_p
;
6185 bool saved_integral_constant_expression_p
= false;
6186 bool saved_non_integral_constant_expression_p
= false;
6187 tsubst_flags_t complain
= complain_flags (decltype_p
);
6188 vec
<tree
, va_gc
> *args
;
6190 is_member_access
= false;
6192 is_builtin_constant_p
6193 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression
);
6194 if (is_builtin_constant_p
)
6196 /* The whole point of __builtin_constant_p is to allow
6197 non-constant expressions to appear as arguments. */
6198 saved_integral_constant_expression_p
6199 = parser
->integral_constant_expression_p
;
6200 saved_non_integral_constant_expression_p
6201 = parser
->non_integral_constant_expression_p
;
6202 parser
->integral_constant_expression_p
= false;
6204 args
= (cp_parser_parenthesized_expression_list
6206 /*cast_p=*/false, /*allow_expansion_p=*/true,
6207 /*non_constant_p=*/NULL
,
6208 /*want_literal_zero_p=*/warn_memset_transposed_args
));
6209 if (is_builtin_constant_p
)
6211 parser
->integral_constant_expression_p
6212 = saved_integral_constant_expression_p
;
6213 parser
->non_integral_constant_expression_p
6214 = saved_non_integral_constant_expression_p
;
6219 postfix_expression
= error_mark_node
;
6223 /* Function calls are not permitted in
6224 constant-expressions. */
6225 if (! builtin_valid_in_constant_expr_p (postfix_expression
)
6226 && cp_parser_non_integral_constant_expression (parser
,
6229 postfix_expression
= error_mark_node
;
6230 release_tree_vector (args
);
6235 if (idk
== CP_ID_KIND_UNQUALIFIED
6236 || idk
== CP_ID_KIND_TEMPLATE_ID
)
6238 if (identifier_p (postfix_expression
))
6240 if (!args
->is_empty ())
6243 if (!any_type_dependent_arguments_p (args
))
6245 = perform_koenig_lookup (postfix_expression
, args
,
6250 = unqualified_fn_lookup_error (postfix_expression
);
6252 /* We do not perform argument-dependent lookup if
6253 normal lookup finds a non-function, in accordance
6254 with the expected resolution of DR 218. */
6255 else if (!args
->is_empty ()
6256 && is_overloaded_fn (postfix_expression
))
6258 tree fn
= get_first_fn (postfix_expression
);
6259 fn
= STRIP_TEMPLATE (fn
);
6261 /* Do not do argument dependent lookup if regular
6262 lookup finds a member function or a block-scope
6263 function declaration. [basic.lookup.argdep]/3 */
6264 if (!DECL_FUNCTION_MEMBER_P (fn
)
6265 && !DECL_LOCAL_FUNCTION_P (fn
))
6268 if (!any_type_dependent_arguments_p (args
))
6270 = perform_koenig_lookup (postfix_expression
, args
,
6276 if (warn_memset_transposed_args
)
6278 if (TREE_CODE (postfix_expression
) == FUNCTION_DECL
6279 && DECL_BUILT_IN_CLASS (postfix_expression
) == BUILT_IN_NORMAL
6280 && DECL_FUNCTION_CODE (postfix_expression
) == BUILT_IN_MEMSET
6281 && vec_safe_length (args
) == 3
6282 && integer_zerop ((*args
)[2])
6283 && LITERAL_ZERO_P ((*args
)[2])
6284 && !(integer_zerop ((*args
)[1])
6285 && LITERAL_ZERO_P ((*args
)[1])))
6286 warning (OPT_Wmemset_transposed_args
,
6287 "%<memset%> used with constant zero length "
6288 "parameter; this could be due to transposed "
6291 /* Replace LITERAL_ZERO_P INTEGER_CSTs with normal ones
6292 to avoid leaking those into folder and middle-end. */
6295 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
6296 if (TREE_CODE (arg
) == INTEGER_CST
&& LITERAL_ZERO_P (arg
))
6297 (*args
)[i
] = build_int_cst (TREE_TYPE (arg
), 0);
6300 if (TREE_CODE (postfix_expression
) == COMPONENT_REF
)
6302 tree instance
= TREE_OPERAND (postfix_expression
, 0);
6303 tree fn
= TREE_OPERAND (postfix_expression
, 1);
6305 if (processing_template_decl
6306 && (type_dependent_expression_p (instance
)
6307 || (!BASELINK_P (fn
)
6308 && TREE_CODE (fn
) != FIELD_DECL
)
6309 || type_dependent_expression_p (fn
)
6310 || any_type_dependent_arguments_p (args
)))
6313 = build_nt_call_vec (postfix_expression
, args
);
6314 release_tree_vector (args
);
6318 if (BASELINK_P (fn
))
6321 = (build_new_method_call
6322 (instance
, fn
, &args
, NULL_TREE
,
6323 (idk
== CP_ID_KIND_QUALIFIED
6324 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
6331 = finish_call_expr (postfix_expression
, &args
,
6332 /*disallow_virtual=*/false,
6336 else if (TREE_CODE (postfix_expression
) == OFFSET_REF
6337 || TREE_CODE (postfix_expression
) == MEMBER_REF
6338 || TREE_CODE (postfix_expression
) == DOTSTAR_EXPR
)
6339 postfix_expression
= (build_offset_ref_call_from_tree
6340 (postfix_expression
, &args
,
6342 else if (idk
== CP_ID_KIND_QUALIFIED
)
6343 /* A call to a static class member, or a namespace-scope
6346 = finish_call_expr (postfix_expression
, &args
,
6347 /*disallow_virtual=*/true,
6351 /* All other function calls. */
6353 = finish_call_expr (postfix_expression
, &args
,
6354 /*disallow_virtual=*/false,
6358 protected_set_expr_location (postfix_expression
, token
->location
);
6360 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
6361 idk
= CP_ID_KIND_NONE
;
6363 release_tree_vector (args
);
6369 /* postfix-expression . template [opt] id-expression
6370 postfix-expression . pseudo-destructor-name
6371 postfix-expression -> template [opt] id-expression
6372 postfix-expression -> pseudo-destructor-name */
6374 /* Consume the `.' or `->' operator. */
6375 cp_lexer_consume_token (parser
->lexer
);
6378 = cp_parser_postfix_dot_deref_expression (parser
, token
->type
,
6382 is_member_access
= true;
6386 /* postfix-expression ++ */
6387 /* Consume the `++' token. */
6388 cp_lexer_consume_token (parser
->lexer
);
6389 /* Generate a representation for the complete expression. */
6391 = finish_increment_expr (postfix_expression
,
6392 POSTINCREMENT_EXPR
);
6393 /* Increments may not appear in constant-expressions. */
6394 if (cp_parser_non_integral_constant_expression (parser
, NIC_INC
))
6395 postfix_expression
= error_mark_node
;
6396 idk
= CP_ID_KIND_NONE
;
6397 is_member_access
= false;
6400 case CPP_MINUS_MINUS
:
6401 /* postfix-expression -- */
6402 /* Consume the `--' token. */
6403 cp_lexer_consume_token (parser
->lexer
);
6404 /* Generate a representation for the complete expression. */
6406 = finish_increment_expr (postfix_expression
,
6407 POSTDECREMENT_EXPR
);
6408 /* Decrements may not appear in constant-expressions. */
6409 if (cp_parser_non_integral_constant_expression (parser
, NIC_DEC
))
6410 postfix_expression
= error_mark_node
;
6411 idk
= CP_ID_KIND_NONE
;
6412 is_member_access
= false;
6416 if (pidk_return
!= NULL
)
6417 * pidk_return
= idk
;
6418 if (member_access_only_p
)
6419 return is_member_access
? postfix_expression
: error_mark_node
;
6421 return postfix_expression
;
6425 /* We should never get here. */
6427 return error_mark_node
;
6430 /* This function parses Cilk Plus array notations. If a normal array expr. is
6431 parsed then the array index is passed back to the caller through *INIT_INDEX
6432 and the function returns a NULL_TREE. If array notation expr. is parsed,
6433 then *INIT_INDEX is ignored by the caller and the function returns
6434 a tree of type ARRAY_NOTATION_REF. If some error occurred it returns
6438 cp_parser_array_notation (location_t loc
, cp_parser
*parser
, tree
*init_index
,
6441 cp_token
*token
= NULL
;
6442 tree length_index
, stride
= NULL_TREE
, value_tree
, array_type
;
6443 if (!array_value
|| array_value
== error_mark_node
)
6445 cp_parser_skip_to_end_of_statement (parser
);
6446 return error_mark_node
;
6449 array_type
= TREE_TYPE (array_value
);
6451 bool saved_colon_corrects
= parser
->colon_corrects_to_scope_p
;
6452 parser
->colon_corrects_to_scope_p
= false;
6453 token
= cp_lexer_peek_token (parser
->lexer
);
6457 cp_parser_error (parser
, "expected %<:%> or numeral");
6458 return error_mark_node
;
6460 else if (token
->type
== CPP_COLON
)
6462 /* Consume the ':'. */
6463 cp_lexer_consume_token (parser
->lexer
);
6465 /* If we are here, then we have a case like this A[:]. */
6466 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_CLOSE_SQUARE
)
6468 cp_parser_error (parser
, "expected %<]%>");
6469 cp_parser_skip_to_end_of_statement (parser
);
6470 return error_mark_node
;
6472 *init_index
= NULL_TREE
;
6474 length_index
= NULL_TREE
;
6478 /* If we are here, then there are three valid possibilities:
6480 2. ARRAY [ EXP : EXP ]
6481 3. ARRAY [ EXP : EXP : EXP ] */
6483 *init_index
= cp_parser_expression (parser
);
6484 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_COLON
)
6486 /* This indicates that we have a normal array expression. */
6487 parser
->colon_corrects_to_scope_p
= saved_colon_corrects
;
6491 /* Consume the ':'. */
6492 cp_lexer_consume_token (parser
->lexer
);
6493 length_index
= cp_parser_expression (parser
);
6494 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_COLON
)
6496 cp_lexer_consume_token (parser
->lexer
);
6497 stride
= cp_parser_expression (parser
);
6500 parser
->colon_corrects_to_scope_p
= saved_colon_corrects
;
6502 if (*init_index
== error_mark_node
|| length_index
== error_mark_node
6503 || stride
== error_mark_node
|| array_type
== error_mark_node
)
6505 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_SQUARE
)
6506 cp_lexer_consume_token (parser
->lexer
);
6507 return error_mark_node
;
6509 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
6511 value_tree
= build_array_notation_ref (loc
, array_value
, *init_index
,
6512 length_index
, stride
, array_type
);
6516 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6517 by cp_parser_builtin_offsetof. We're looking for
6519 postfix-expression [ expression ]
6520 postfix-expression [ braced-init-list ] (C++11)
6522 FOR_OFFSETOF is set if we're being called in that context, which
6523 changes how we deal with integer constant expressions. */
6526 cp_parser_postfix_open_square_expression (cp_parser
*parser
,
6527 tree postfix_expression
,
6531 tree index
= NULL_TREE
;
6532 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
6533 bool saved_greater_than_is_operator_p
;
6535 /* Consume the `[' token. */
6536 cp_lexer_consume_token (parser
->lexer
);
6538 saved_greater_than_is_operator_p
= parser
->greater_than_is_operator_p
;
6539 parser
->greater_than_is_operator_p
= true;
6541 /* Parse the index expression. */
6542 /* ??? For offsetof, there is a question of what to allow here. If
6543 offsetof is not being used in an integral constant expression context,
6544 then we *could* get the right answer by computing the value at runtime.
6545 If we are in an integral constant expression context, then we might
6546 could accept any constant expression; hard to say without analysis.
6547 Rather than open the barn door too wide right away, allow only integer
6548 constant expressions here. */
6550 index
= cp_parser_constant_expression (parser
);
6553 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
6555 bool expr_nonconst_p
;
6556 cp_lexer_set_source_position (parser
->lexer
);
6557 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6558 index
= cp_parser_braced_list (parser
, &expr_nonconst_p
);
6560 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_COLON
)
6562 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
6563 "braced list index is not allowed with array "
6565 cp_parser_skip_to_end_of_statement (parser
);
6566 return error_mark_node
;
6569 else if (flag_cilkplus
)
6571 /* Here are have these two options:
6572 ARRAY[EXP : EXP] - Array notation expr with default
6574 ARRAY[EXP : EXP : EXP] - Array Notation with user-defined
6576 tree an_exp
= cp_parser_array_notation (loc
, parser
, &index
,
6577 postfix_expression
);
6582 index
= cp_parser_expression (parser
);
6585 parser
->greater_than_is_operator_p
= saved_greater_than_is_operator_p
;
6587 /* Look for the closing `]'. */
6588 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
6590 /* Build the ARRAY_REF. */
6591 postfix_expression
= grok_array_decl (loc
, postfix_expression
,
6594 /* When not doing offsetof, array references are not permitted in
6595 constant-expressions. */
6597 && (cp_parser_non_integral_constant_expression (parser
, NIC_ARRAY_REF
)))
6598 postfix_expression
= error_mark_node
;
6600 return postfix_expression
;
6603 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6604 by cp_parser_builtin_offsetof. We're looking for
6606 postfix-expression . template [opt] id-expression
6607 postfix-expression . pseudo-destructor-name
6608 postfix-expression -> template [opt] id-expression
6609 postfix-expression -> pseudo-destructor-name
6611 FOR_OFFSETOF is set if we're being called in that context. That sorta
6612 limits what of the above we'll actually accept, but nevermind.
6613 TOKEN_TYPE is the "." or "->" token, which will already have been
6614 removed from the stream. */
6617 cp_parser_postfix_dot_deref_expression (cp_parser
*parser
,
6618 enum cpp_ttype token_type
,
6619 tree postfix_expression
,
6620 bool for_offsetof
, cp_id_kind
*idk
,
6621 location_t location
)
6625 bool pseudo_destructor_p
;
6626 tree scope
= NULL_TREE
;
6628 /* If this is a `->' operator, dereference the pointer. */
6629 if (token_type
== CPP_DEREF
)
6630 postfix_expression
= build_x_arrow (location
, postfix_expression
,
6631 tf_warning_or_error
);
6632 /* Check to see whether or not the expression is type-dependent. */
6633 dependent_p
= type_dependent_expression_p (postfix_expression
);
6634 /* The identifier following the `->' or `.' is not qualified. */
6635 parser
->scope
= NULL_TREE
;
6636 parser
->qualifying_scope
= NULL_TREE
;
6637 parser
->object_scope
= NULL_TREE
;
6638 *idk
= CP_ID_KIND_NONE
;
6640 /* Enter the scope corresponding to the type of the object
6641 given by the POSTFIX_EXPRESSION. */
6642 if (!dependent_p
&& TREE_TYPE (postfix_expression
) != NULL_TREE
)
6644 scope
= TREE_TYPE (postfix_expression
);
6645 /* According to the standard, no expression should ever have
6646 reference type. Unfortunately, we do not currently match
6647 the standard in this respect in that our internal representation
6648 of an expression may have reference type even when the standard
6649 says it does not. Therefore, we have to manually obtain the
6650 underlying type here. */
6651 scope
= non_reference (scope
);
6652 /* The type of the POSTFIX_EXPRESSION must be complete. */
6653 if (scope
== unknown_type_node
)
6655 error_at (location
, "%qE does not have class type",
6656 postfix_expression
);
6659 /* Unlike the object expression in other contexts, *this is not
6660 required to be of complete type for purposes of class member
6661 access (5.2.5) outside the member function body. */
6662 else if (postfix_expression
!= current_class_ref
6663 && !(processing_template_decl
&& scope
== current_class_type
))
6664 scope
= complete_type_or_else (scope
, NULL_TREE
);
6665 /* Let the name lookup machinery know that we are processing a
6666 class member access expression. */
6667 parser
->context
->object_type
= scope
;
6668 /* If something went wrong, we want to be able to discern that case,
6669 as opposed to the case where there was no SCOPE due to the type
6670 of expression being dependent. */
6672 scope
= error_mark_node
;
6673 /* If the SCOPE was erroneous, make the various semantic analysis
6674 functions exit quickly -- and without issuing additional error
6676 if (scope
== error_mark_node
)
6677 postfix_expression
= error_mark_node
;
6680 /* Assume this expression is not a pseudo-destructor access. */
6681 pseudo_destructor_p
= false;
6683 /* If the SCOPE is a scalar type, then, if this is a valid program,
6684 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
6685 is type dependent, it can be pseudo-destructor-name or something else.
6686 Try to parse it as pseudo-destructor-name first. */
6687 if ((scope
&& SCALAR_TYPE_P (scope
)) || dependent_p
)
6692 cp_parser_parse_tentatively (parser
);
6693 /* Parse the pseudo-destructor-name. */
6695 cp_parser_pseudo_destructor_name (parser
, postfix_expression
,
6698 && (cp_parser_error_occurred (parser
)
6699 || !SCALAR_TYPE_P (type
)))
6700 cp_parser_abort_tentative_parse (parser
);
6701 else if (cp_parser_parse_definitely (parser
))
6703 pseudo_destructor_p
= true;
6705 = finish_pseudo_destructor_expr (postfix_expression
,
6710 if (!pseudo_destructor_p
)
6712 /* If the SCOPE is not a scalar type, we are looking at an
6713 ordinary class member access expression, rather than a
6714 pseudo-destructor-name. */
6716 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
6717 /* Parse the id-expression. */
6718 name
= (cp_parser_id_expression
6720 cp_parser_optional_template_keyword (parser
),
6721 /*check_dependency_p=*/true,
6723 /*declarator_p=*/false,
6724 /*optional_p=*/false));
6725 /* In general, build a SCOPE_REF if the member name is qualified.
6726 However, if the name was not dependent and has already been
6727 resolved; there is no need to build the SCOPE_REF. For example;
6729 struct X { void f(); };
6730 template <typename T> void f(T* t) { t->X::f(); }
6732 Even though "t" is dependent, "X::f" is not and has been resolved
6733 to a BASELINK; there is no need to include scope information. */
6735 /* But we do need to remember that there was an explicit scope for
6736 virtual function calls. */
6738 *idk
= CP_ID_KIND_QUALIFIED
;
6740 /* If the name is a template-id that names a type, we will get a
6741 TYPE_DECL here. That is invalid code. */
6742 if (TREE_CODE (name
) == TYPE_DECL
)
6744 error_at (token
->location
, "invalid use of %qD", name
);
6745 postfix_expression
= error_mark_node
;
6749 if (name
!= error_mark_node
&& !BASELINK_P (name
) && parser
->scope
)
6751 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
6753 error_at (token
->location
, "%<%D::%D%> is not a class member",
6754 parser
->scope
, name
);
6755 postfix_expression
= error_mark_node
;
6758 name
= build_qualified_name (/*type=*/NULL_TREE
,
6762 parser
->scope
= NULL_TREE
;
6763 parser
->qualifying_scope
= NULL_TREE
;
6764 parser
->object_scope
= NULL_TREE
;
6766 if (parser
->scope
&& name
&& BASELINK_P (name
))
6767 adjust_result_of_qualified_name_lookup
6768 (name
, parser
->scope
, scope
);
6770 = finish_class_member_access_expr (postfix_expression
, name
,
6772 tf_warning_or_error
);
6776 /* We no longer need to look up names in the scope of the object on
6777 the left-hand side of the `.' or `->' operator. */
6778 parser
->context
->object_type
= NULL_TREE
;
6780 /* Outside of offsetof, these operators may not appear in
6781 constant-expressions. */
6783 && (cp_parser_non_integral_constant_expression
6784 (parser
, token_type
== CPP_DEREF
? NIC_ARROW
: NIC_POINT
)))
6785 postfix_expression
= error_mark_node
;
6787 return postfix_expression
;
6790 /* Cache of LITERAL_ZERO_P constants. */
6792 static GTY(()) tree literal_zeros
[itk_none
];
6794 /* Parse a parenthesized expression-list.
6797 assignment-expression
6798 expression-list, assignment-expression
6803 identifier, expression-list
6805 CAST_P is true if this expression is the target of a cast.
6807 ALLOW_EXPANSION_P is true if this expression allows expansion of an
6810 Returns a vector of trees. Each element is a representation of an
6811 assignment-expression. NULL is returned if the ( and or ) are
6812 missing. An empty, but allocated, vector is returned on no
6813 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
6814 if we are parsing an attribute list for an attribute that wants a
6815 plain identifier argument, normal_attr for an attribute that wants
6816 an expression, or non_attr if we aren't parsing an attribute list. If
6817 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
6818 not all of the expressions in the list were constant.
6819 WANT_LITERAL_ZERO_P is true if the caller is interested in
6820 LITERAL_ZERO_P INTEGER_CSTs. FIXME: once we don't fold everything
6821 immediately, this can be removed. */
6823 static vec
<tree
, va_gc
> *
6824 cp_parser_parenthesized_expression_list (cp_parser
* parser
,
6825 int is_attribute_list
,
6827 bool allow_expansion_p
,
6828 bool *non_constant_p
,
6829 bool want_literal_zero_p
)
6831 vec
<tree
, va_gc
> *expression_list
;
6832 bool fold_expr_p
= is_attribute_list
!= non_attr
;
6833 tree identifier
= NULL_TREE
;
6834 bool saved_greater_than_is_operator_p
;
6836 /* Assume all the expressions will be constant. */
6838 *non_constant_p
= false;
6840 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
6843 expression_list
= make_tree_vector ();
6845 /* Within a parenthesized expression, a `>' token is always
6846 the greater-than operator. */
6847 saved_greater_than_is_operator_p
6848 = parser
->greater_than_is_operator_p
;
6849 parser
->greater_than_is_operator_p
= true;
6851 /* Consume expressions until there are no more. */
6852 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
6857 /* At the beginning of attribute lists, check to see if the
6858 next token is an identifier. */
6859 if (is_attribute_list
== id_attr
6860 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_NAME
)
6864 /* Consume the identifier. */
6865 token
= cp_lexer_consume_token (parser
->lexer
);
6866 /* Save the identifier. */
6867 identifier
= token
->u
.value
;
6871 bool expr_non_constant_p
;
6873 /* Parse the next assignment-expression. */
6874 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
6876 /* A braced-init-list. */
6877 cp_lexer_set_source_position (parser
->lexer
);
6878 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6879 expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
6880 if (non_constant_p
&& expr_non_constant_p
)
6881 *non_constant_p
= true;
6883 else if (non_constant_p
)
6885 expr
= (cp_parser_constant_expression
6886 (parser
, /*allow_non_constant_p=*/true,
6887 &expr_non_constant_p
));
6888 if (expr_non_constant_p
)
6889 *non_constant_p
= true;
6894 cp_token
*tok
= cp_lexer_peek_token (parser
->lexer
);
6902 /* If a parameter is literal zero alone, remember it
6903 for -Wmemset-transposed-args warning. */
6904 if (integer_zerop (tok
->u
.value
)
6905 && !TREE_OVERFLOW (tok
->u
.value
)
6906 && want_literal_zero_p
6907 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
6909 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
6910 == CPP_CLOSE_PAREN
))
6913 for (i
= 0; i
< itk_none
; ++i
)
6914 if (TREE_TYPE (tok
->u
.value
) == integer_types
[i
])
6916 if (i
< itk_none
&& literal_zeros
[i
])
6917 expr
= literal_zeros
[i
];
6920 expr
= copy_node (tok
->u
.value
);
6921 LITERAL_ZERO_P (expr
) = 1;
6923 literal_zeros
[i
] = expr
;
6925 /* Consume the 0 token (or '\0', 0LL etc.). */
6926 cp_lexer_consume_token (parser
->lexer
);
6932 if (expr
== NULL_TREE
)
6933 expr
= cp_parser_assignment_expression (parser
, /*pidk=*/NULL
,
6938 expr
= instantiate_non_dependent_expr (expr
);
6940 /* If we have an ellipsis, then this is an expression
6942 if (allow_expansion_p
6943 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
6945 /* Consume the `...'. */
6946 cp_lexer_consume_token (parser
->lexer
);
6948 /* Build the argument pack. */
6949 expr
= make_pack_expansion (expr
);
6952 /* Add it to the list. We add error_mark_node
6953 expressions to the list, so that we can still tell if
6954 the correct form for a parenthesized expression-list
6955 is found. That gives better errors. */
6956 vec_safe_push (expression_list
, expr
);
6958 if (expr
== error_mark_node
)
6962 /* After the first item, attribute lists look the same as
6963 expression lists. */
6964 is_attribute_list
= non_attr
;
6967 /* If the next token isn't a `,', then we are done. */
6968 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
6971 /* Otherwise, consume the `,' and keep going. */
6972 cp_lexer_consume_token (parser
->lexer
);
6975 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
6980 /* We try and resync to an unnested comma, as that will give the
6981 user better diagnostics. */
6982 ending
= cp_parser_skip_to_closing_parenthesis (parser
,
6983 /*recovering=*/true,
6985 /*consume_paren=*/true);
6990 parser
->greater_than_is_operator_p
6991 = saved_greater_than_is_operator_p
;
6996 parser
->greater_than_is_operator_p
6997 = saved_greater_than_is_operator_p
;
7000 vec_safe_insert (expression_list
, 0, identifier
);
7002 return expression_list
;
7005 /* Parse a pseudo-destructor-name.
7007 pseudo-destructor-name:
7008 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
7009 :: [opt] nested-name-specifier template template-id :: ~ type-name
7010 :: [opt] nested-name-specifier [opt] ~ type-name
7012 If either of the first two productions is used, sets *SCOPE to the
7013 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
7014 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
7015 or ERROR_MARK_NODE if the parse fails. */
7018 cp_parser_pseudo_destructor_name (cp_parser
* parser
,
7023 bool nested_name_specifier_p
;
7026 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMPL
)
7027 && cp_lexer_nth_token_is_keyword (parser
->lexer
, 2, RID_AUTO
)
7028 && !type_dependent_expression_p (object
))
7030 if (cxx_dialect
< cxx14
)
7031 pedwarn (input_location
, 0,
7032 "%<~auto%> only available with "
7033 "-std=c++14 or -std=gnu++14");
7034 cp_lexer_consume_token (parser
->lexer
);
7035 cp_lexer_consume_token (parser
->lexer
);
7037 *type
= TREE_TYPE (object
);
7041 /* Assume that things will not work out. */
7042 *type
= error_mark_node
;
7044 /* Look for the optional `::' operator. */
7045 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/true);
7046 /* Look for the optional nested-name-specifier. */
7047 nested_name_specifier_p
7048 = (cp_parser_nested_name_specifier_opt (parser
,
7049 /*typename_keyword_p=*/false,
7050 /*check_dependency_p=*/true,
7052 /*is_declaration=*/false)
7054 /* Now, if we saw a nested-name-specifier, we might be doing the
7055 second production. */
7056 if (nested_name_specifier_p
7057 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
7059 /* Consume the `template' keyword. */
7060 cp_lexer_consume_token (parser
->lexer
);
7061 /* Parse the template-id. */
7062 cp_parser_template_id (parser
,
7063 /*template_keyword_p=*/true,
7064 /*check_dependency_p=*/false,
7066 /*is_declaration=*/true);
7067 /* Look for the `::' token. */
7068 cp_parser_require (parser
, CPP_SCOPE
, RT_SCOPE
);
7070 /* If the next token is not a `~', then there might be some
7071 additional qualification. */
7072 else if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMPL
))
7074 /* At this point, we're looking for "type-name :: ~". The type-name
7075 must not be a class-name, since this is a pseudo-destructor. So,
7076 it must be either an enum-name, or a typedef-name -- both of which
7077 are just identifiers. So, we peek ahead to check that the "::"
7078 and "~" tokens are present; if they are not, then we can avoid
7079 calling type_name. */
7080 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_NAME
7081 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
7082 || cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
!= CPP_COMPL
)
7084 cp_parser_error (parser
, "non-scalar type");
7088 /* Look for the type-name. */
7089 *scope
= TREE_TYPE (cp_parser_nonclass_name (parser
));
7090 if (*scope
== error_mark_node
)
7093 /* Look for the `::' token. */
7094 cp_parser_require (parser
, CPP_SCOPE
, RT_SCOPE
);
7099 /* Look for the `~'. */
7100 cp_parser_require (parser
, CPP_COMPL
, RT_COMPL
);
7102 /* Once we see the ~, this has to be a pseudo-destructor. */
7103 if (!processing_template_decl
&& !cp_parser_error_occurred (parser
))
7104 cp_parser_commit_to_topmost_tentative_parse (parser
);
7106 /* Look for the type-name again. We are not responsible for
7107 checking that it matches the first type-name. */
7108 *type
= TREE_TYPE (cp_parser_nonclass_name (parser
));
7111 /* Parse a unary-expression.
7117 unary-operator cast-expression
7118 sizeof unary-expression
7120 alignof ( type-id ) [C++0x]
7127 __extension__ cast-expression
7128 __alignof__ unary-expression
7129 __alignof__ ( type-id )
7130 alignof unary-expression [C++0x]
7131 __real__ cast-expression
7132 __imag__ cast-expression
7134 sizeof ( type-id ) { initializer-list , [opt] }
7135 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
7136 __alignof__ ( type-id ) { initializer-list , [opt] }
7138 ADDRESS_P is true iff the unary-expression is appearing as the
7139 operand of the `&' operator. CAST_P is true if this expression is
7140 the target of a cast.
7142 Returns a representation of the expression. */
7145 cp_parser_unary_expression (cp_parser
*parser
, cp_id_kind
* pidk
,
7146 bool address_p
, bool cast_p
, bool decltype_p
)
7149 enum tree_code unary_operator
;
7151 /* Peek at the next token. */
7152 token
= cp_lexer_peek_token (parser
->lexer
);
7153 /* Some keywords give away the kind of expression. */
7154 if (token
->type
== CPP_KEYWORD
)
7156 enum rid keyword
= token
->keyword
;
7165 location_t first_loc
;
7167 op
= keyword
== RID_ALIGNOF
? ALIGNOF_EXPR
: SIZEOF_EXPR
;
7168 /* Consume the token. */
7169 cp_lexer_consume_token (parser
->lexer
);
7170 first_loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
7171 /* Parse the operand. */
7172 operand
= cp_parser_sizeof_operand (parser
, keyword
);
7174 if (TYPE_P (operand
))
7175 ret
= cxx_sizeof_or_alignof_type (operand
, op
, true);
7178 /* ISO C++ defines alignof only with types, not with
7179 expressions. So pedwarn if alignof is used with a non-
7180 type expression. However, __alignof__ is ok. */
7181 if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "alignof"))
7182 pedwarn (token
->location
, OPT_Wpedantic
,
7183 "ISO C++ does not allow %<alignof%> "
7186 ret
= cxx_sizeof_or_alignof_expr (operand
, op
, true);
7188 /* For SIZEOF_EXPR, just issue diagnostics, but keep
7189 SIZEOF_EXPR with the original operand. */
7190 if (op
== SIZEOF_EXPR
&& ret
!= error_mark_node
)
7192 if (TREE_CODE (ret
) != SIZEOF_EXPR
|| TYPE_P (operand
))
7194 if (!processing_template_decl
&& TYPE_P (operand
))
7196 ret
= build_min (SIZEOF_EXPR
, size_type_node
,
7197 build1 (NOP_EXPR
, operand
,
7199 SIZEOF_EXPR_TYPE_P (ret
) = 1;
7202 ret
= build_min (SIZEOF_EXPR
, size_type_node
, operand
);
7203 TREE_SIDE_EFFECTS (ret
) = 0;
7204 TREE_READONLY (ret
) = 1;
7206 SET_EXPR_LOCATION (ret
, first_loc
);
7212 return cp_parser_new_expression (parser
);
7215 return cp_parser_delete_expression (parser
);
7219 /* The saved value of the PEDANTIC flag. */
7223 /* Save away the PEDANTIC flag. */
7224 cp_parser_extension_opt (parser
, &saved_pedantic
);
7225 /* Parse the cast-expression. */
7226 expr
= cp_parser_simple_cast_expression (parser
);
7227 /* Restore the PEDANTIC flag. */
7228 pedantic
= saved_pedantic
;
7238 /* Consume the `__real__' or `__imag__' token. */
7239 cp_lexer_consume_token (parser
->lexer
);
7240 /* Parse the cast-expression. */
7241 expression
= cp_parser_simple_cast_expression (parser
);
7242 /* Create the complete representation. */
7243 return build_x_unary_op (token
->location
,
7244 (keyword
== RID_REALPART
7245 ? REALPART_EXPR
: IMAGPART_EXPR
),
7247 tf_warning_or_error
);
7251 case RID_TRANSACTION_ATOMIC
:
7252 case RID_TRANSACTION_RELAXED
:
7253 return cp_parser_transaction_expression (parser
, keyword
);
7258 const char *saved_message
;
7259 bool saved_integral_constant_expression_p
;
7260 bool saved_non_integral_constant_expression_p
;
7261 bool saved_greater_than_is_operator_p
;
7263 cp_lexer_consume_token (parser
->lexer
);
7264 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
7266 saved_message
= parser
->type_definition_forbidden_message
;
7267 parser
->type_definition_forbidden_message
7268 = G_("types may not be defined in %<noexcept%> expressions");
7270 saved_integral_constant_expression_p
7271 = parser
->integral_constant_expression_p
;
7272 saved_non_integral_constant_expression_p
7273 = parser
->non_integral_constant_expression_p
;
7274 parser
->integral_constant_expression_p
= false;
7276 saved_greater_than_is_operator_p
7277 = parser
->greater_than_is_operator_p
;
7278 parser
->greater_than_is_operator_p
= true;
7280 ++cp_unevaluated_operand
;
7281 ++c_inhibit_evaluation_warnings
;
7282 ++cp_noexcept_operand
;
7283 expr
= cp_parser_expression (parser
);
7284 --cp_noexcept_operand
;
7285 --c_inhibit_evaluation_warnings
;
7286 --cp_unevaluated_operand
;
7288 parser
->greater_than_is_operator_p
7289 = saved_greater_than_is_operator_p
;
7291 parser
->integral_constant_expression_p
7292 = saved_integral_constant_expression_p
;
7293 parser
->non_integral_constant_expression_p
7294 = saved_non_integral_constant_expression_p
;
7296 parser
->type_definition_forbidden_message
= saved_message
;
7298 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
7299 return finish_noexcept_expr (expr
, tf_warning_or_error
);
7307 /* Look for the `:: new' and `:: delete', which also signal the
7308 beginning of a new-expression, or delete-expression,
7309 respectively. If the next token is `::', then it might be one of
7311 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
7315 /* See if the token after the `::' is one of the keywords in
7316 which we're interested. */
7317 keyword
= cp_lexer_peek_nth_token (parser
->lexer
, 2)->keyword
;
7318 /* If it's `new', we have a new-expression. */
7319 if (keyword
== RID_NEW
)
7320 return cp_parser_new_expression (parser
);
7321 /* Similarly, for `delete'. */
7322 else if (keyword
== RID_DELETE
)
7323 return cp_parser_delete_expression (parser
);
7326 /* Look for a unary operator. */
7327 unary_operator
= cp_parser_unary_operator (token
);
7328 /* The `++' and `--' operators can be handled similarly, even though
7329 they are not technically unary-operators in the grammar. */
7330 if (unary_operator
== ERROR_MARK
)
7332 if (token
->type
== CPP_PLUS_PLUS
)
7333 unary_operator
= PREINCREMENT_EXPR
;
7334 else if (token
->type
== CPP_MINUS_MINUS
)
7335 unary_operator
= PREDECREMENT_EXPR
;
7336 /* Handle the GNU address-of-label extension. */
7337 else if (cp_parser_allow_gnu_extensions_p (parser
)
7338 && token
->type
== CPP_AND_AND
)
7342 location_t loc
= token
->location
;
7344 /* Consume the '&&' token. */
7345 cp_lexer_consume_token (parser
->lexer
);
7346 /* Look for the identifier. */
7347 identifier
= cp_parser_identifier (parser
);
7348 /* Create an expression representing the address. */
7349 expression
= finish_label_address_expr (identifier
, loc
);
7350 if (cp_parser_non_integral_constant_expression (parser
,
7352 expression
= error_mark_node
;
7356 if (unary_operator
!= ERROR_MARK
)
7358 tree cast_expression
;
7359 tree expression
= error_mark_node
;
7360 non_integral_constant non_constant_p
= NIC_NONE
;
7361 location_t loc
= token
->location
;
7362 tsubst_flags_t complain
= complain_flags (decltype_p
);
7364 /* Consume the operator token. */
7365 token
= cp_lexer_consume_token (parser
->lexer
);
7366 /* Parse the cast-expression. */
7368 = cp_parser_cast_expression (parser
,
7369 unary_operator
== ADDR_EXPR
,
7373 /* Now, build an appropriate representation. */
7374 switch (unary_operator
)
7377 non_constant_p
= NIC_STAR
;
7378 expression
= build_x_indirect_ref (loc
, cast_expression
,
7384 non_constant_p
= NIC_ADDR
;
7387 expression
= build_x_unary_op (loc
, unary_operator
,
7392 case PREINCREMENT_EXPR
:
7393 case PREDECREMENT_EXPR
:
7394 non_constant_p
= unary_operator
== PREINCREMENT_EXPR
7395 ? NIC_PREINCREMENT
: NIC_PREDECREMENT
;
7397 case UNARY_PLUS_EXPR
:
7399 case TRUTH_NOT_EXPR
:
7400 expression
= finish_unary_op_expr (loc
, unary_operator
,
7401 cast_expression
, complain
);
7408 if (non_constant_p
!= NIC_NONE
7409 && cp_parser_non_integral_constant_expression (parser
,
7411 expression
= error_mark_node
;
7416 return cp_parser_postfix_expression (parser
, address_p
, cast_p
,
7417 /*member_access_only_p=*/false,
7422 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
7423 unary-operator, the corresponding tree code is returned. */
7425 static enum tree_code
7426 cp_parser_unary_operator (cp_token
* token
)
7428 switch (token
->type
)
7431 return INDIRECT_REF
;
7437 return UNARY_PLUS_EXPR
;
7443 return TRUTH_NOT_EXPR
;
7446 return BIT_NOT_EXPR
;
7453 /* Parse a new-expression.
7456 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
7457 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
7459 Returns a representation of the expression. */
7462 cp_parser_new_expression (cp_parser
* parser
)
7464 bool global_scope_p
;
7465 vec
<tree
, va_gc
> *placement
;
7467 vec
<tree
, va_gc
> *initializer
;
7468 tree nelts
= NULL_TREE
;
7471 /* Look for the optional `::' operator. */
7473 = (cp_parser_global_scope_opt (parser
,
7474 /*current_scope_valid_p=*/false)
7476 /* Look for the `new' operator. */
7477 cp_parser_require_keyword (parser
, RID_NEW
, RT_NEW
);
7478 /* There's no easy way to tell a new-placement from the
7479 `( type-id )' construct. */
7480 cp_parser_parse_tentatively (parser
);
7481 /* Look for a new-placement. */
7482 placement
= cp_parser_new_placement (parser
);
7483 /* If that didn't work out, there's no new-placement. */
7484 if (!cp_parser_parse_definitely (parser
))
7486 if (placement
!= NULL
)
7487 release_tree_vector (placement
);
7491 /* If the next token is a `(', then we have a parenthesized
7493 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
7496 const char *saved_message
= parser
->type_definition_forbidden_message
;
7498 /* Consume the `('. */
7499 cp_lexer_consume_token (parser
->lexer
);
7501 /* Parse the type-id. */
7502 parser
->type_definition_forbidden_message
7503 = G_("types may not be defined in a new-expression");
7504 type
= cp_parser_type_id (parser
);
7505 parser
->type_definition_forbidden_message
= saved_message
;
7507 /* Look for the closing `)'. */
7508 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
7509 token
= cp_lexer_peek_token (parser
->lexer
);
7510 /* There should not be a direct-new-declarator in this production,
7511 but GCC used to allowed this, so we check and emit a sensible error
7512 message for this case. */
7513 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
7515 error_at (token
->location
,
7516 "array bound forbidden after parenthesized type-id");
7517 inform (token
->location
,
7518 "try removing the parentheses around the type-id");
7519 cp_parser_direct_new_declarator (parser
);
7522 /* Otherwise, there must be a new-type-id. */
7524 type
= cp_parser_new_type_id (parser
, &nelts
);
7526 /* If the next token is a `(' or '{', then we have a new-initializer. */
7527 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
7528 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
7529 initializer
= cp_parser_new_initializer (parser
);
7533 /* A new-expression may not appear in an integral constant
7535 if (cp_parser_non_integral_constant_expression (parser
, NIC_NEW
))
7536 ret
= error_mark_node
;
7539 /* Create a representation of the new-expression. */
7540 ret
= build_new (&placement
, type
, nelts
, &initializer
, global_scope_p
,
7541 tf_warning_or_error
);
7544 if (placement
!= NULL
)
7545 release_tree_vector (placement
);
7546 if (initializer
!= NULL
)
7547 release_tree_vector (initializer
);
7552 /* Parse a new-placement.
7557 Returns the same representation as for an expression-list. */
7559 static vec
<tree
, va_gc
> *
7560 cp_parser_new_placement (cp_parser
* parser
)
7562 vec
<tree
, va_gc
> *expression_list
;
7564 /* Parse the expression-list. */
7565 expression_list
= (cp_parser_parenthesized_expression_list
7566 (parser
, non_attr
, /*cast_p=*/false,
7567 /*allow_expansion_p=*/true,
7568 /*non_constant_p=*/NULL
));
7570 return expression_list
;
7573 /* Parse a new-type-id.
7576 type-specifier-seq new-declarator [opt]
7578 Returns the TYPE allocated. If the new-type-id indicates an array
7579 type, *NELTS is set to the number of elements in the last array
7580 bound; the TYPE will not include the last array bound. */
7583 cp_parser_new_type_id (cp_parser
* parser
, tree
*nelts
)
7585 cp_decl_specifier_seq type_specifier_seq
;
7586 cp_declarator
*new_declarator
;
7587 cp_declarator
*declarator
;
7588 cp_declarator
*outer_declarator
;
7589 const char *saved_message
;
7591 /* The type-specifier sequence must not contain type definitions.
7592 (It cannot contain declarations of new types either, but if they
7593 are not definitions we will catch that because they are not
7595 saved_message
= parser
->type_definition_forbidden_message
;
7596 parser
->type_definition_forbidden_message
7597 = G_("types may not be defined in a new-type-id");
7598 /* Parse the type-specifier-seq. */
7599 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
7600 /*is_trailing_return=*/false,
7601 &type_specifier_seq
);
7602 /* Restore the old message. */
7603 parser
->type_definition_forbidden_message
= saved_message
;
7605 if (type_specifier_seq
.type
== error_mark_node
)
7606 return error_mark_node
;
7608 /* Parse the new-declarator. */
7609 new_declarator
= cp_parser_new_declarator_opt (parser
);
7611 /* Determine the number of elements in the last array dimension, if
7614 /* Skip down to the last array dimension. */
7615 declarator
= new_declarator
;
7616 outer_declarator
= NULL
;
7617 while (declarator
&& (declarator
->kind
== cdk_pointer
7618 || declarator
->kind
== cdk_ptrmem
))
7620 outer_declarator
= declarator
;
7621 declarator
= declarator
->declarator
;
7624 && declarator
->kind
== cdk_array
7625 && declarator
->declarator
7626 && declarator
->declarator
->kind
== cdk_array
)
7628 outer_declarator
= declarator
;
7629 declarator
= declarator
->declarator
;
7632 if (declarator
&& declarator
->kind
== cdk_array
)
7634 *nelts
= declarator
->u
.array
.bounds
;
7635 if (*nelts
== error_mark_node
)
7636 *nelts
= integer_one_node
;
7638 if (outer_declarator
)
7639 outer_declarator
->declarator
= declarator
->declarator
;
7641 new_declarator
= NULL
;
7644 return groktypename (&type_specifier_seq
, new_declarator
, false);
7647 /* Parse an (optional) new-declarator.
7650 ptr-operator new-declarator [opt]
7651 direct-new-declarator
7653 Returns the declarator. */
7655 static cp_declarator
*
7656 cp_parser_new_declarator_opt (cp_parser
* parser
)
7658 enum tree_code code
;
7659 tree type
, std_attributes
= NULL_TREE
;
7660 cp_cv_quals cv_quals
;
7662 /* We don't know if there's a ptr-operator next, or not. */
7663 cp_parser_parse_tentatively (parser
);
7664 /* Look for a ptr-operator. */
7665 code
= cp_parser_ptr_operator (parser
, &type
, &cv_quals
, &std_attributes
);
7666 /* If that worked, look for more new-declarators. */
7667 if (cp_parser_parse_definitely (parser
))
7669 cp_declarator
*declarator
;
7671 /* Parse another optional declarator. */
7672 declarator
= cp_parser_new_declarator_opt (parser
);
7674 declarator
= cp_parser_make_indirect_declarator
7675 (code
, type
, cv_quals
, declarator
, std_attributes
);
7680 /* If the next token is a `[', there is a direct-new-declarator. */
7681 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
7682 return cp_parser_direct_new_declarator (parser
);
7687 /* Parse a direct-new-declarator.
7689 direct-new-declarator:
7691 direct-new-declarator [constant-expression]
7695 static cp_declarator
*
7696 cp_parser_direct_new_declarator (cp_parser
* parser
)
7698 cp_declarator
*declarator
= NULL
;
7705 /* Look for the opening `['. */
7706 cp_parser_require (parser
, CPP_OPEN_SQUARE
, RT_OPEN_SQUARE
);
7708 token
= cp_lexer_peek_token (parser
->lexer
);
7709 expression
= cp_parser_expression (parser
);
7710 /* The standard requires that the expression have integral
7711 type. DR 74 adds enumeration types. We believe that the
7712 real intent is that these expressions be handled like the
7713 expression in a `switch' condition, which also allows
7714 classes with a single conversion to integral or
7715 enumeration type. */
7716 if (!processing_template_decl
)
7719 = build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
7724 error_at (token
->location
,
7725 "expression in new-declarator must have integral "
7726 "or enumeration type");
7727 expression
= error_mark_node
;
7731 /* Look for the closing `]'. */
7732 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
7734 /* Add this bound to the declarator. */
7735 declarator
= make_array_declarator (declarator
, expression
);
7737 /* If the next token is not a `[', then there are no more
7739 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_SQUARE
))
7746 /* Parse a new-initializer.
7749 ( expression-list [opt] )
7752 Returns a representation of the expression-list. */
7754 static vec
<tree
, va_gc
> *
7755 cp_parser_new_initializer (cp_parser
* parser
)
7757 vec
<tree
, va_gc
> *expression_list
;
7759 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
7762 bool expr_non_constant_p
;
7763 cp_lexer_set_source_position (parser
->lexer
);
7764 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
7765 t
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
7766 CONSTRUCTOR_IS_DIRECT_INIT (t
) = 1;
7767 expression_list
= make_tree_vector_single (t
);
7770 expression_list
= (cp_parser_parenthesized_expression_list
7771 (parser
, non_attr
, /*cast_p=*/false,
7772 /*allow_expansion_p=*/true,
7773 /*non_constant_p=*/NULL
));
7775 return expression_list
;
7778 /* Parse a delete-expression.
7781 :: [opt] delete cast-expression
7782 :: [opt] delete [ ] cast-expression
7784 Returns a representation of the expression. */
7787 cp_parser_delete_expression (cp_parser
* parser
)
7789 bool global_scope_p
;
7793 /* Look for the optional `::' operator. */
7795 = (cp_parser_global_scope_opt (parser
,
7796 /*current_scope_valid_p=*/false)
7798 /* Look for the `delete' keyword. */
7799 cp_parser_require_keyword (parser
, RID_DELETE
, RT_DELETE
);
7800 /* See if the array syntax is in use. */
7801 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
7803 /* Consume the `[' token. */
7804 cp_lexer_consume_token (parser
->lexer
);
7805 /* Look for the `]' token. */
7806 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
7807 /* Remember that this is the `[]' construct. */
7813 /* Parse the cast-expression. */
7814 expression
= cp_parser_simple_cast_expression (parser
);
7816 /* A delete-expression may not appear in an integral constant
7818 if (cp_parser_non_integral_constant_expression (parser
, NIC_DEL
))
7819 return error_mark_node
;
7821 return delete_sanity (expression
, NULL_TREE
, array_p
, global_scope_p
,
7822 tf_warning_or_error
);
7825 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
7826 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
7830 cp_parser_tokens_start_cast_expression (cp_parser
*parser
)
7832 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
7833 switch (token
->type
)
7839 case CPP_CLOSE_SQUARE
:
7840 case CPP_CLOSE_PAREN
:
7841 case CPP_CLOSE_BRACE
:
7842 case CPP_OPEN_BRACE
:
7846 case CPP_DEREF_STAR
:
7854 case CPP_GREATER_EQ
:
7875 case CPP_OPEN_PAREN
:
7876 /* In ((type ()) () the last () isn't a valid cast-expression,
7877 so the whole must be parsed as postfix-expression. */
7878 return cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
7881 case CPP_OPEN_SQUARE
:
7882 /* '[' may start a primary-expression in obj-c++ and in C++11,
7883 as a lambda-expression, eg, '(void)[]{}'. */
7884 if (cxx_dialect
>= cxx11
)
7886 return c_dialect_objc ();
7889 case CPP_MINUS_MINUS
:
7890 /* '++' and '--' may or may not start a cast-expression:
7892 struct T { void operator++(int); };
7893 void f() { (T())++; }
7906 /* Parse a cast-expression.
7910 ( type-id ) cast-expression
7912 ADDRESS_P is true iff the unary-expression is appearing as the
7913 operand of the `&' operator. CAST_P is true if this expression is
7914 the target of a cast.
7916 Returns a representation of the expression. */
7919 cp_parser_cast_expression (cp_parser
*parser
, bool address_p
, bool cast_p
,
7920 bool decltype_p
, cp_id_kind
* pidk
)
7922 /* If it's a `(', then we might be looking at a cast. */
7923 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
7925 tree type
= NULL_TREE
;
7926 tree expr
= NULL_TREE
;
7927 int cast_expression
= 0;
7928 const char *saved_message
;
7930 /* There's no way to know yet whether or not this is a cast.
7931 For example, `(int (3))' is a unary-expression, while `(int)
7932 3' is a cast. So, we resort to parsing tentatively. */
7933 cp_parser_parse_tentatively (parser
);
7934 /* Types may not be defined in a cast. */
7935 saved_message
= parser
->type_definition_forbidden_message
;
7936 parser
->type_definition_forbidden_message
7937 = G_("types may not be defined in casts");
7938 /* Consume the `('. */
7939 cp_lexer_consume_token (parser
->lexer
);
7940 /* A very tricky bit is that `(struct S) { 3 }' is a
7941 compound-literal (which we permit in C++ as an extension).
7942 But, that construct is not a cast-expression -- it is a
7943 postfix-expression. (The reason is that `(struct S) { 3 }.i'
7944 is legal; if the compound-literal were a cast-expression,
7945 you'd need an extra set of parentheses.) But, if we parse
7946 the type-id, and it happens to be a class-specifier, then we
7947 will commit to the parse at that point, because we cannot
7948 undo the action that is done when creating a new class. So,
7949 then we cannot back up and do a postfix-expression.
7951 Another tricky case is the following (c++/29234):
7953 struct S { void operator () (); };
7960 As a type-id we parse the parenthesized S()() as a function
7961 returning a function, groktypename complains and we cannot
7962 back up in this case either.
7964 Therefore, we scan ahead to the closing `)', and check to see
7965 if the tokens after the `)' can start a cast-expression. Otherwise
7966 we are dealing with an unary-expression, a postfix-expression
7969 Yet another tricky case, in C++11, is the following (c++/54891):
7973 The issue is that usually, besides the case of lambda-expressions,
7974 the parenthesized type-id cannot be followed by '[', and, eg, we
7975 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
7976 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
7977 we don't commit, we try a cast-expression, then an unary-expression.
7979 Save tokens so that we can put them back. */
7980 cp_lexer_save_tokens (parser
->lexer
);
7982 /* We may be looking at a cast-expression. */
7983 if (cp_parser_skip_to_closing_parenthesis (parser
, false, false,
7984 /*consume_paren=*/true))
7986 = cp_parser_tokens_start_cast_expression (parser
);
7988 /* Roll back the tokens we skipped. */
7989 cp_lexer_rollback_tokens (parser
->lexer
);
7990 /* If we aren't looking at a cast-expression, simulate an error so
7991 that the call to cp_parser_error_occurred below returns true. */
7992 if (!cast_expression
)
7993 cp_parser_simulate_error (parser
);
7996 bool saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
7997 parser
->in_type_id_in_expr_p
= true;
7998 /* Look for the type-id. */
7999 type
= cp_parser_type_id (parser
);
8000 /* Look for the closing `)'. */
8001 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
8002 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
8005 /* Restore the saved message. */
8006 parser
->type_definition_forbidden_message
= saved_message
;
8008 /* At this point this can only be either a cast or a
8009 parenthesized ctor such as `(T ())' that looks like a cast to
8010 function returning T. */
8011 if (!cp_parser_error_occurred (parser
))
8013 /* Only commit if the cast-expression doesn't start with
8014 '++', '--', or '[' in C++11. */
8015 if (cast_expression
> 0)
8016 cp_parser_commit_to_topmost_tentative_parse (parser
);
8018 expr
= cp_parser_cast_expression (parser
,
8019 /*address_p=*/false,
8021 /*decltype_p=*/false,
8024 if (cp_parser_parse_definitely (parser
))
8026 /* Warn about old-style casts, if so requested. */
8027 if (warn_old_style_cast
8028 && !in_system_header_at (input_location
)
8029 && !VOID_TYPE_P (type
)
8030 && current_lang_name
!= lang_name_c
)
8031 warning (OPT_Wold_style_cast
, "use of old-style cast");
8033 /* Only type conversions to integral or enumeration types
8034 can be used in constant-expressions. */
8035 if (!cast_valid_in_integral_constant_expression_p (type
)
8036 && cp_parser_non_integral_constant_expression (parser
,
8038 return error_mark_node
;
8040 /* Perform the cast. */
8041 expr
= build_c_cast (input_location
, type
, expr
);
8046 cp_parser_abort_tentative_parse (parser
);
8049 /* If we get here, then it's not a cast, so it must be a
8050 unary-expression. */
8051 return cp_parser_unary_expression (parser
, pidk
, address_p
,
8052 cast_p
, decltype_p
);
8055 /* Parse a binary expression of the general form:
8059 pm-expression .* cast-expression
8060 pm-expression ->* cast-expression
8062 multiplicative-expression:
8064 multiplicative-expression * pm-expression
8065 multiplicative-expression / pm-expression
8066 multiplicative-expression % pm-expression
8068 additive-expression:
8069 multiplicative-expression
8070 additive-expression + multiplicative-expression
8071 additive-expression - multiplicative-expression
8075 shift-expression << additive-expression
8076 shift-expression >> additive-expression
8078 relational-expression:
8080 relational-expression < shift-expression
8081 relational-expression > shift-expression
8082 relational-expression <= shift-expression
8083 relational-expression >= shift-expression
8087 relational-expression:
8088 relational-expression <? shift-expression
8089 relational-expression >? shift-expression
8091 equality-expression:
8092 relational-expression
8093 equality-expression == relational-expression
8094 equality-expression != relational-expression
8098 and-expression & equality-expression
8100 exclusive-or-expression:
8102 exclusive-or-expression ^ and-expression
8104 inclusive-or-expression:
8105 exclusive-or-expression
8106 inclusive-or-expression | exclusive-or-expression
8108 logical-and-expression:
8109 inclusive-or-expression
8110 logical-and-expression && inclusive-or-expression
8112 logical-or-expression:
8113 logical-and-expression
8114 logical-or-expression || logical-and-expression
8116 All these are implemented with a single function like:
8119 simple-cast-expression
8120 binary-expression <token> binary-expression
8122 CAST_P is true if this expression is the target of a cast.
8124 The binops_by_token map is used to get the tree codes for each <token> type.
8125 binary-expressions are associated according to a precedence table. */
8127 #define TOKEN_PRECEDENCE(token) \
8128 (((token->type == CPP_GREATER \
8129 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
8130 && !parser->greater_than_is_operator_p) \
8131 ? PREC_NOT_OPERATOR \
8132 : binops_by_token[token->type].prec)
8135 cp_parser_binary_expression (cp_parser
* parser
, bool cast_p
,
8136 bool no_toplevel_fold_p
,
8138 enum cp_parser_prec prec
,
8141 cp_parser_expression_stack stack
;
8142 cp_parser_expression_stack_entry
*sp
= &stack
[0];
8143 cp_parser_expression_stack_entry current
;
8146 enum tree_code rhs_type
;
8147 enum cp_parser_prec new_prec
, lookahead_prec
;
8150 /* Parse the first expression. */
8151 current
.lhs_type
= (cp_lexer_next_token_is (parser
->lexer
, CPP_NOT
)
8152 ? TRUTH_NOT_EXPR
: ERROR_MARK
);
8153 current
.lhs
= cp_parser_cast_expression (parser
, /*address_p=*/false,
8154 cast_p
, decltype_p
, pidk
);
8155 current
.prec
= prec
;
8157 if (cp_parser_error_occurred (parser
))
8158 return error_mark_node
;
8162 /* Get an operator token. */
8163 token
= cp_lexer_peek_token (parser
->lexer
);
8165 if (warn_cxx0x_compat
8166 && token
->type
== CPP_RSHIFT
8167 && !parser
->greater_than_is_operator_p
)
8169 if (warning_at (token
->location
, OPT_Wc__0x_compat
,
8170 "%<>>%> operator is treated"
8171 " as two right angle brackets in C++11"))
8172 inform (token
->location
,
8173 "suggest parentheses around %<>>%> expression");
8176 new_prec
= TOKEN_PRECEDENCE (token
);
8178 /* Popping an entry off the stack means we completed a subexpression:
8179 - either we found a token which is not an operator (`>' where it is not
8180 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
8181 will happen repeatedly;
8182 - or, we found an operator which has lower priority. This is the case
8183 where the recursive descent *ascends*, as in `3 * 4 + 5' after
8185 if (new_prec
<= current
.prec
)
8194 current
.tree_type
= binops_by_token
[token
->type
].tree_type
;
8195 current
.loc
= token
->location
;
8197 /* We used the operator token. */
8198 cp_lexer_consume_token (parser
->lexer
);
8200 /* For "false && x" or "true || x", x will never be executed;
8201 disable warnings while evaluating it. */
8202 if (current
.tree_type
== TRUTH_ANDIF_EXPR
)
8203 c_inhibit_evaluation_warnings
+= current
.lhs
== truthvalue_false_node
;
8204 else if (current
.tree_type
== TRUTH_ORIF_EXPR
)
8205 c_inhibit_evaluation_warnings
+= current
.lhs
== truthvalue_true_node
;
8207 /* Extract another operand. It may be the RHS of this expression
8208 or the LHS of a new, higher priority expression. */
8209 rhs_type
= (cp_lexer_next_token_is (parser
->lexer
, CPP_NOT
)
8210 ? TRUTH_NOT_EXPR
: ERROR_MARK
);
8211 rhs
= cp_parser_simple_cast_expression (parser
);
8213 /* Get another operator token. Look up its precedence to avoid
8214 building a useless (immediately popped) stack entry for common
8215 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
8216 token
= cp_lexer_peek_token (parser
->lexer
);
8217 lookahead_prec
= TOKEN_PRECEDENCE (token
);
8218 if (lookahead_prec
> new_prec
)
8220 /* ... and prepare to parse the RHS of the new, higher priority
8221 expression. Since precedence levels on the stack are
8222 monotonically increasing, we do not have to care about
8227 current
.lhs_type
= rhs_type
;
8228 current
.prec
= new_prec
;
8229 new_prec
= lookahead_prec
;
8233 lookahead_prec
= new_prec
;
8234 /* If the stack is not empty, we have parsed into LHS the right side
8235 (`4' in the example above) of an expression we had suspended.
8236 We can use the information on the stack to recover the LHS (`3')
8237 from the stack together with the tree code (`MULT_EXPR'), and
8238 the precedence of the higher level subexpression
8239 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
8240 which will be used to actually build the additive expression. */
8242 rhs_type
= current
.lhs_type
;
8247 /* Undo the disabling of warnings done above. */
8248 if (current
.tree_type
== TRUTH_ANDIF_EXPR
)
8249 c_inhibit_evaluation_warnings
-= current
.lhs
== truthvalue_false_node
;
8250 else if (current
.tree_type
== TRUTH_ORIF_EXPR
)
8251 c_inhibit_evaluation_warnings
-= current
.lhs
== truthvalue_true_node
;
8253 if (warn_logical_not_paren
8254 && TREE_CODE_CLASS (current
.tree_type
) == tcc_comparison
8255 && current
.lhs_type
== TRUTH_NOT_EXPR
8256 /* Avoid warning for !!x == y. */
8257 && (TREE_CODE (current
.lhs
) != NE_EXPR
8258 || !integer_zerop (TREE_OPERAND (current
.lhs
, 1)))
8259 && (TREE_CODE (current
.lhs
) != TRUTH_NOT_EXPR
8260 || (TREE_CODE (TREE_OPERAND (current
.lhs
, 0)) != TRUTH_NOT_EXPR
8261 /* Avoid warning for !b == y where b is boolean. */
8262 && (TREE_TYPE (TREE_OPERAND (current
.lhs
, 0)) == NULL_TREE
8263 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (current
.lhs
, 0)))
8265 /* Avoid warning for !!b == y where b is boolean. */
8266 && (!DECL_P (current
.lhs
)
8267 || TREE_TYPE (current
.lhs
) == NULL_TREE
8268 || TREE_CODE (TREE_TYPE (current
.lhs
)) != BOOLEAN_TYPE
))
8269 warn_logical_not_parentheses (current
.loc
, current
.tree_type
,
8270 maybe_constant_value (rhs
));
8273 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
8274 ERROR_MARK for everything that is not a binary expression.
8275 This makes warn_about_parentheses miss some warnings that
8276 involve unary operators. For unary expressions we should
8277 pass the correct tree_code unless the unary expression was
8278 surrounded by parentheses.
8280 if (no_toplevel_fold_p
8281 && lookahead_prec
<= current
.prec
8283 current
.lhs
= build2 (current
.tree_type
,
8284 TREE_CODE_CLASS (current
.tree_type
)
8286 ? boolean_type_node
: TREE_TYPE (current
.lhs
),
8289 current
.lhs
= build_x_binary_op (current
.loc
, current
.tree_type
,
8290 current
.lhs
, current
.lhs_type
,
8291 rhs
, rhs_type
, &overload
,
8292 complain_flags (decltype_p
));
8293 current
.lhs_type
= current
.tree_type
;
8294 if (EXPR_P (current
.lhs
))
8295 SET_EXPR_LOCATION (current
.lhs
, current
.loc
);
8297 /* If the binary operator required the use of an overloaded operator,
8298 then this expression cannot be an integral constant-expression.
8299 An overloaded operator can be used even if both operands are
8300 otherwise permissible in an integral constant-expression if at
8301 least one of the operands is of enumeration type. */
8304 && cp_parser_non_integral_constant_expression (parser
,
8306 return error_mark_node
;
8313 cp_parser_binary_expression (cp_parser
* parser
, bool cast_p
,
8314 bool no_toplevel_fold_p
,
8315 enum cp_parser_prec prec
,
8318 return cp_parser_binary_expression (parser
, cast_p
, no_toplevel_fold_p
,
8319 /*decltype*/false, prec
, pidk
);
8322 /* Parse the `? expression : assignment-expression' part of a
8323 conditional-expression. The LOGICAL_OR_EXPR is the
8324 logical-or-expression that started the conditional-expression.
8325 Returns a representation of the entire conditional-expression.
8327 This routine is used by cp_parser_assignment_expression.
8329 ? expression : assignment-expression
8333 ? : assignment-expression */
8336 cp_parser_question_colon_clause (cp_parser
* parser
, tree logical_or_expr
)
8339 tree assignment_expr
;
8340 struct cp_token
*token
;
8341 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8343 /* Consume the `?' token. */
8344 cp_lexer_consume_token (parser
->lexer
);
8345 token
= cp_lexer_peek_token (parser
->lexer
);
8346 if (cp_parser_allow_gnu_extensions_p (parser
)
8347 && token
->type
== CPP_COLON
)
8349 pedwarn (token
->location
, OPT_Wpedantic
,
8350 "ISO C++ does not allow ?: with omitted middle operand");
8351 /* Implicit true clause. */
8353 c_inhibit_evaluation_warnings
+= logical_or_expr
== truthvalue_true_node
;
8354 warn_for_omitted_condop (token
->location
, logical_or_expr
);
8358 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
8359 parser
->colon_corrects_to_scope_p
= false;
8360 /* Parse the expression. */
8361 c_inhibit_evaluation_warnings
+= logical_or_expr
== truthvalue_false_node
;
8362 expr
= cp_parser_expression (parser
);
8363 c_inhibit_evaluation_warnings
+=
8364 ((logical_or_expr
== truthvalue_true_node
)
8365 - (logical_or_expr
== truthvalue_false_node
));
8366 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
8369 /* The next token should be a `:'. */
8370 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
8371 /* Parse the assignment-expression. */
8372 assignment_expr
= cp_parser_assignment_expression (parser
);
8373 c_inhibit_evaluation_warnings
-= logical_or_expr
== truthvalue_true_node
;
8375 /* Build the conditional-expression. */
8376 return build_x_conditional_expr (loc
, logical_or_expr
,
8379 tf_warning_or_error
);
8382 /* Parse an assignment-expression.
8384 assignment-expression:
8385 conditional-expression
8386 logical-or-expression assignment-operator assignment_expression
8389 CAST_P is true if this expression is the target of a cast.
8390 DECLTYPE_P is true if this expression is the operand of decltype.
8392 Returns a representation for the expression. */
8395 cp_parser_assignment_expression (cp_parser
* parser
, cp_id_kind
* pidk
,
8396 bool cast_p
, bool decltype_p
)
8400 /* If the next token is the `throw' keyword, then we're looking at
8401 a throw-expression. */
8402 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_THROW
))
8403 expr
= cp_parser_throw_expression (parser
);
8404 /* Otherwise, it must be that we are looking at a
8405 logical-or-expression. */
8408 /* Parse the binary expressions (logical-or-expression). */
8409 expr
= cp_parser_binary_expression (parser
, cast_p
, false,
8411 PREC_NOT_OPERATOR
, pidk
);
8412 /* If the next token is a `?' then we're actually looking at a
8413 conditional-expression. */
8414 if (cp_lexer_next_token_is (parser
->lexer
, CPP_QUERY
))
8415 return cp_parser_question_colon_clause (parser
, expr
);
8418 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8420 /* If it's an assignment-operator, we're using the second
8422 enum tree_code assignment_operator
8423 = cp_parser_assignment_operator_opt (parser
);
8424 if (assignment_operator
!= ERROR_MARK
)
8426 bool non_constant_p
;
8427 location_t saved_input_location
;
8429 /* Parse the right-hand side of the assignment. */
8430 tree rhs
= cp_parser_initializer_clause (parser
, &non_constant_p
);
8432 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
8433 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
8435 /* An assignment may not appear in a
8436 constant-expression. */
8437 if (cp_parser_non_integral_constant_expression (parser
,
8439 return error_mark_node
;
8440 /* Build the assignment expression. Its default
8441 location is the location of the '=' token. */
8442 saved_input_location
= input_location
;
8443 input_location
= loc
;
8444 expr
= build_x_modify_expr (loc
, expr
,
8445 assignment_operator
,
8447 complain_flags (decltype_p
));
8448 input_location
= saved_input_location
;
8456 /* Parse an (optional) assignment-operator.
8458 assignment-operator: one of
8459 = *= /= %= += -= >>= <<= &= ^= |=
8463 assignment-operator: one of
8466 If the next token is an assignment operator, the corresponding tree
8467 code is returned, and the token is consumed. For example, for
8468 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
8469 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
8470 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
8471 operator, ERROR_MARK is returned. */
8473 static enum tree_code
8474 cp_parser_assignment_operator_opt (cp_parser
* parser
)
8479 /* Peek at the next token. */
8480 token
= cp_lexer_peek_token (parser
->lexer
);
8482 switch (token
->type
)
8493 op
= TRUNC_DIV_EXPR
;
8497 op
= TRUNC_MOD_EXPR
;
8529 /* Nothing else is an assignment operator. */
8533 /* If it was an assignment operator, consume it. */
8534 if (op
!= ERROR_MARK
)
8535 cp_lexer_consume_token (parser
->lexer
);
8540 /* Parse an expression.
8543 assignment-expression
8544 expression , assignment-expression
8546 CAST_P is true if this expression is the target of a cast.
8547 DECLTYPE_P is true if this expression is the immediate operand of decltype,
8548 except possibly parenthesized or on the RHS of a comma (N3276).
8550 Returns a representation of the expression. */
8553 cp_parser_expression (cp_parser
* parser
, cp_id_kind
* pidk
,
8554 bool cast_p
, bool decltype_p
)
8556 tree expression
= NULL_TREE
;
8557 location_t loc
= UNKNOWN_LOCATION
;
8561 tree assignment_expression
;
8563 /* Parse the next assignment-expression. */
8564 assignment_expression
8565 = cp_parser_assignment_expression (parser
, pidk
, cast_p
, decltype_p
);
8567 /* We don't create a temporary for a call that is the immediate operand
8568 of decltype or on the RHS of a comma. But when we see a comma, we
8569 need to create a temporary for a call on the LHS. */
8570 if (decltype_p
&& !processing_template_decl
8571 && TREE_CODE (assignment_expression
) == CALL_EXPR
8572 && CLASS_TYPE_P (TREE_TYPE (assignment_expression
))
8573 && cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
8574 assignment_expression
8575 = build_cplus_new (TREE_TYPE (assignment_expression
),
8576 assignment_expression
, tf_warning_or_error
);
8578 /* If this is the first assignment-expression, we can just
8581 expression
= assignment_expression
;
8583 expression
= build_x_compound_expr (loc
, expression
,
8584 assignment_expression
,
8585 complain_flags (decltype_p
));
8586 /* If the next token is not a comma, then we are done with the
8588 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
8590 /* Consume the `,'. */
8591 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8592 cp_lexer_consume_token (parser
->lexer
);
8593 /* A comma operator cannot appear in a constant-expression. */
8594 if (cp_parser_non_integral_constant_expression (parser
, NIC_COMMA
))
8595 expression
= error_mark_node
;
8601 /* Parse a constant-expression.
8603 constant-expression:
8604 conditional-expression
8606 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
8607 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
8608 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
8609 is false, NON_CONSTANT_P should be NULL. */
8612 cp_parser_constant_expression (cp_parser
* parser
,
8613 bool allow_non_constant_p
,
8614 bool *non_constant_p
)
8616 bool saved_integral_constant_expression_p
;
8617 bool saved_allow_non_integral_constant_expression_p
;
8618 bool saved_non_integral_constant_expression_p
;
8621 /* It might seem that we could simply parse the
8622 conditional-expression, and then check to see if it were
8623 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
8624 one that the compiler can figure out is constant, possibly after
8625 doing some simplifications or optimizations. The standard has a
8626 precise definition of constant-expression, and we must honor
8627 that, even though it is somewhat more restrictive.
8633 is not a legal declaration, because `(2, 3)' is not a
8634 constant-expression. The `,' operator is forbidden in a
8635 constant-expression. However, GCC's constant-folding machinery
8636 will fold this operation to an INTEGER_CST for `3'. */
8638 /* Save the old settings. */
8639 saved_integral_constant_expression_p
= parser
->integral_constant_expression_p
;
8640 saved_allow_non_integral_constant_expression_p
8641 = parser
->allow_non_integral_constant_expression_p
;
8642 saved_non_integral_constant_expression_p
= parser
->non_integral_constant_expression_p
;
8643 /* We are now parsing a constant-expression. */
8644 parser
->integral_constant_expression_p
= true;
8645 parser
->allow_non_integral_constant_expression_p
8646 = (allow_non_constant_p
|| cxx_dialect
>= cxx11
);
8647 parser
->non_integral_constant_expression_p
= false;
8648 /* Although the grammar says "conditional-expression", we parse an
8649 "assignment-expression", which also permits "throw-expression"
8650 and the use of assignment operators. In the case that
8651 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
8652 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
8653 actually essential that we look for an assignment-expression.
8654 For example, cp_parser_initializer_clauses uses this function to
8655 determine whether a particular assignment-expression is in fact
8657 expression
= cp_parser_assignment_expression (parser
);
8658 /* Restore the old settings. */
8659 parser
->integral_constant_expression_p
8660 = saved_integral_constant_expression_p
;
8661 parser
->allow_non_integral_constant_expression_p
8662 = saved_allow_non_integral_constant_expression_p
;
8663 if (cxx_dialect
>= cxx11
)
8665 /* Require an rvalue constant expression here; that's what our
8666 callers expect. Reference constant expressions are handled
8667 separately in e.g. cp_parser_template_argument. */
8668 bool is_const
= potential_rvalue_constant_expression (expression
);
8669 parser
->non_integral_constant_expression_p
= !is_const
;
8670 if (!is_const
&& !allow_non_constant_p
)
8671 require_potential_rvalue_constant_expression (expression
);
8673 if (allow_non_constant_p
)
8674 *non_constant_p
= parser
->non_integral_constant_expression_p
;
8675 parser
->non_integral_constant_expression_p
8676 = saved_non_integral_constant_expression_p
;
8681 /* Parse __builtin_offsetof.
8683 offsetof-expression:
8684 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
8686 offsetof-member-designator:
8688 | offsetof-member-designator "." id-expression
8689 | offsetof-member-designator "[" expression "]"
8690 | offsetof-member-designator "->" id-expression */
8693 cp_parser_builtin_offsetof (cp_parser
*parser
)
8695 int save_ice_p
, save_non_ice_p
;
8700 /* We're about to accept non-integral-constant things, but will
8701 definitely yield an integral constant expression. Save and
8702 restore these values around our local parsing. */
8703 save_ice_p
= parser
->integral_constant_expression_p
;
8704 save_non_ice_p
= parser
->non_integral_constant_expression_p
;
8706 /* Consume the "__builtin_offsetof" token. */
8707 cp_lexer_consume_token (parser
->lexer
);
8708 /* Consume the opening `('. */
8709 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
8710 /* Parse the type-id. */
8711 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8712 type
= cp_parser_type_id (parser
);
8713 /* Look for the `,'. */
8714 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
8715 token
= cp_lexer_peek_token (parser
->lexer
);
8717 /* Build the (type *)null that begins the traditional offsetof macro. */
8718 expr
= build_static_cast (build_pointer_type (type
), null_pointer_node
,
8719 tf_warning_or_error
);
8721 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
8722 expr
= cp_parser_postfix_dot_deref_expression (parser
, CPP_DEREF
, expr
,
8723 true, &dummy
, token
->location
);
8726 token
= cp_lexer_peek_token (parser
->lexer
);
8727 switch (token
->type
)
8729 case CPP_OPEN_SQUARE
:
8730 /* offsetof-member-designator "[" expression "]" */
8731 expr
= cp_parser_postfix_open_square_expression (parser
, expr
,
8736 /* offsetof-member-designator "->" identifier */
8737 expr
= grok_array_decl (token
->location
, expr
,
8738 integer_zero_node
, false);
8742 /* offsetof-member-designator "." identifier */
8743 cp_lexer_consume_token (parser
->lexer
);
8744 expr
= cp_parser_postfix_dot_deref_expression (parser
, CPP_DOT
,
8749 case CPP_CLOSE_PAREN
:
8750 /* Consume the ")" token. */
8751 cp_lexer_consume_token (parser
->lexer
);
8755 /* Error. We know the following require will fail, but
8756 that gives the proper error message. */
8757 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
8758 cp_parser_skip_to_closing_parenthesis (parser
, true, false, true);
8759 expr
= error_mark_node
;
8765 expr
= finish_offsetof (expr
, loc
);
8768 parser
->integral_constant_expression_p
= save_ice_p
;
8769 parser
->non_integral_constant_expression_p
= save_non_ice_p
;
8774 /* Parse a trait expression.
8776 Returns a representation of the expression, the underlying type
8777 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
8780 cp_parser_trait_expr (cp_parser
* parser
, enum rid keyword
)
8783 tree type1
, type2
= NULL_TREE
;
8784 bool binary
= false;
8785 bool variadic
= false;
8789 case RID_HAS_NOTHROW_ASSIGN
:
8790 kind
= CPTK_HAS_NOTHROW_ASSIGN
;
8792 case RID_HAS_NOTHROW_CONSTRUCTOR
:
8793 kind
= CPTK_HAS_NOTHROW_CONSTRUCTOR
;
8795 case RID_HAS_NOTHROW_COPY
:
8796 kind
= CPTK_HAS_NOTHROW_COPY
;
8798 case RID_HAS_TRIVIAL_ASSIGN
:
8799 kind
= CPTK_HAS_TRIVIAL_ASSIGN
;
8801 case RID_HAS_TRIVIAL_CONSTRUCTOR
:
8802 kind
= CPTK_HAS_TRIVIAL_CONSTRUCTOR
;
8804 case RID_HAS_TRIVIAL_COPY
:
8805 kind
= CPTK_HAS_TRIVIAL_COPY
;
8807 case RID_HAS_TRIVIAL_DESTRUCTOR
:
8808 kind
= CPTK_HAS_TRIVIAL_DESTRUCTOR
;
8810 case RID_HAS_VIRTUAL_DESTRUCTOR
:
8811 kind
= CPTK_HAS_VIRTUAL_DESTRUCTOR
;
8813 case RID_IS_ABSTRACT
:
8814 kind
= CPTK_IS_ABSTRACT
;
8816 case RID_IS_BASE_OF
:
8817 kind
= CPTK_IS_BASE_OF
;
8821 kind
= CPTK_IS_CLASS
;
8824 kind
= CPTK_IS_EMPTY
;
8827 kind
= CPTK_IS_ENUM
;
8830 kind
= CPTK_IS_FINAL
;
8832 case RID_IS_LITERAL_TYPE
:
8833 kind
= CPTK_IS_LITERAL_TYPE
;
8838 case RID_IS_POLYMORPHIC
:
8839 kind
= CPTK_IS_POLYMORPHIC
;
8841 case RID_IS_STD_LAYOUT
:
8842 kind
= CPTK_IS_STD_LAYOUT
;
8844 case RID_IS_TRIVIAL
:
8845 kind
= CPTK_IS_TRIVIAL
;
8847 case RID_IS_TRIVIALLY_ASSIGNABLE
:
8848 kind
= CPTK_IS_TRIVIALLY_ASSIGNABLE
;
8851 case RID_IS_TRIVIALLY_CONSTRUCTIBLE
:
8852 kind
= CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
;
8855 case RID_IS_TRIVIALLY_COPYABLE
:
8856 kind
= CPTK_IS_TRIVIALLY_COPYABLE
;
8859 kind
= CPTK_IS_UNION
;
8861 case RID_UNDERLYING_TYPE
:
8862 kind
= CPTK_UNDERLYING_TYPE
;
8867 case RID_DIRECT_BASES
:
8868 kind
= CPTK_DIRECT_BASES
;
8874 /* Consume the token. */
8875 cp_lexer_consume_token (parser
->lexer
);
8877 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
8879 type1
= cp_parser_type_id (parser
);
8881 if (type1
== error_mark_node
)
8882 return error_mark_node
;
8886 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
8888 type2
= cp_parser_type_id (parser
);
8890 if (type2
== error_mark_node
)
8891 return error_mark_node
;
8895 while (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
8897 cp_lexer_consume_token (parser
->lexer
);
8898 tree elt
= cp_parser_type_id (parser
);
8899 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
8901 cp_lexer_consume_token (parser
->lexer
);
8902 elt
= make_pack_expansion (elt
);
8904 if (elt
== error_mark_node
)
8905 return error_mark_node
;
8906 type2
= tree_cons (NULL_TREE
, elt
, type2
);
8910 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
8912 /* Complete the trait expression, which may mean either processing
8913 the trait expr now or saving it for template instantiation. */
8916 case CPTK_UNDERLYING_TYPE
:
8917 return finish_underlying_type (type1
);
8919 return finish_bases (type1
, false);
8920 case CPTK_DIRECT_BASES
:
8921 return finish_bases (type1
, true);
8923 return finish_trait_expr (kind
, type1
, type2
);
8927 /* Lambdas that appear in variable initializer or default argument scope
8928 get that in their mangling, so we need to record it. We might as well
8929 use the count for function and namespace scopes as well. */
8930 static GTY(()) tree lambda_scope
;
8931 static GTY(()) int lambda_count
;
8932 typedef struct GTY(()) tree_int
8937 static GTY(()) vec
<tree_int
, va_gc
> *lambda_scope_stack
;
8940 start_lambda_scope (tree decl
)
8944 /* Once we're inside a function, we ignore other scopes and just push
8945 the function again so that popping works properly. */
8946 if (current_function_decl
&& TREE_CODE (decl
) != FUNCTION_DECL
)
8947 decl
= current_function_decl
;
8948 ti
.t
= lambda_scope
;
8949 ti
.i
= lambda_count
;
8950 vec_safe_push (lambda_scope_stack
, ti
);
8951 if (lambda_scope
!= decl
)
8953 /* Don't reset the count if we're still in the same function. */
8954 lambda_scope
= decl
;
8960 record_lambda_scope (tree lambda
)
8962 LAMBDA_EXPR_EXTRA_SCOPE (lambda
) = lambda_scope
;
8963 LAMBDA_EXPR_DISCRIMINATOR (lambda
) = lambda_count
++;
8967 finish_lambda_scope (void)
8969 tree_int
*p
= &lambda_scope_stack
->last ();
8970 if (lambda_scope
!= p
->t
)
8972 lambda_scope
= p
->t
;
8973 lambda_count
= p
->i
;
8975 lambda_scope_stack
->pop ();
8978 /* Parse a lambda expression.
8981 lambda-introducer lambda-declarator [opt] compound-statement
8983 Returns a representation of the expression. */
8986 cp_parser_lambda_expression (cp_parser
* parser
)
8988 tree lambda_expr
= build_lambda_expr ();
8991 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
8992 cp_token_position start
= 0;
8994 LAMBDA_EXPR_LOCATION (lambda_expr
) = token
->location
;
8996 if (cp_unevaluated_operand
)
8998 if (!token
->error_reported
)
9000 error_at (LAMBDA_EXPR_LOCATION (lambda_expr
),
9001 "lambda-expression in unevaluated context");
9002 token
->error_reported
= true;
9006 else if (parser
->in_template_argument_list_p
)
9008 if (!token
->error_reported
)
9010 error_at (token
->location
, "lambda-expression in template-argument");
9011 token
->error_reported
= true;
9016 /* We may be in the middle of deferred access check. Disable
9018 push_deferring_access_checks (dk_no_deferred
);
9020 cp_parser_lambda_introducer (parser
, lambda_expr
);
9022 type
= begin_lambda_type (lambda_expr
);
9023 if (type
== error_mark_node
)
9024 return error_mark_node
;
9026 record_lambda_scope (lambda_expr
);
9028 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
9029 determine_visibility (TYPE_NAME (type
));
9031 /* Now that we've started the type, add the capture fields for any
9032 explicit captures. */
9033 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
));
9036 /* Inside the class, surrounding template-parameter-lists do not apply. */
9037 unsigned int saved_num_template_parameter_lists
9038 = parser
->num_template_parameter_lists
;
9039 unsigned char in_statement
= parser
->in_statement
;
9040 bool in_switch_statement_p
= parser
->in_switch_statement_p
;
9041 bool fully_implicit_function_template_p
9042 = parser
->fully_implicit_function_template_p
;
9043 tree implicit_template_parms
= parser
->implicit_template_parms
;
9044 cp_binding_level
* implicit_template_scope
= parser
->implicit_template_scope
;
9045 bool auto_is_implicit_function_template_parm_p
9046 = parser
->auto_is_implicit_function_template_parm_p
;
9048 parser
->num_template_parameter_lists
= 0;
9049 parser
->in_statement
= 0;
9050 parser
->in_switch_statement_p
= false;
9051 parser
->fully_implicit_function_template_p
= false;
9052 parser
->implicit_template_parms
= 0;
9053 parser
->implicit_template_scope
= 0;
9054 parser
->auto_is_implicit_function_template_parm_p
= false;
9056 /* By virtue of defining a local class, a lambda expression has access to
9057 the private variables of enclosing classes. */
9059 ok
&= cp_parser_lambda_declarator_opt (parser
, lambda_expr
);
9063 if (!cp_parser_error_occurred (parser
)
9064 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
)
9065 && cp_parser_start_tentative_firewall (parser
))
9067 cp_parser_lambda_body (parser
, lambda_expr
);
9069 else if (cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
9071 if (cp_parser_skip_to_closing_brace (parser
))
9072 cp_lexer_consume_token (parser
->lexer
);
9075 /* The capture list was built up in reverse order; fix that now. */
9076 LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
)
9077 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
));
9080 maybe_add_lambda_conv_op (type
);
9082 type
= finish_struct (type
, /*attributes=*/NULL_TREE
);
9084 parser
->num_template_parameter_lists
= saved_num_template_parameter_lists
;
9085 parser
->in_statement
= in_statement
;
9086 parser
->in_switch_statement_p
= in_switch_statement_p
;
9087 parser
->fully_implicit_function_template_p
9088 = fully_implicit_function_template_p
;
9089 parser
->implicit_template_parms
= implicit_template_parms
;
9090 parser
->implicit_template_scope
= implicit_template_scope
;
9091 parser
->auto_is_implicit_function_template_parm_p
9092 = auto_is_implicit_function_template_parm_p
;
9095 pop_deferring_access_checks ();
9097 /* This field is only used during parsing of the lambda. */
9098 LAMBDA_EXPR_THIS_CAPTURE (lambda_expr
) = NULL_TREE
;
9100 /* This lambda shouldn't have any proxies left at this point. */
9101 gcc_assert (LAMBDA_EXPR_PENDING_PROXIES (lambda_expr
) == NULL
);
9102 /* And now that we're done, push proxies for an enclosing lambda. */
9103 insert_pending_capture_proxies ();
9106 lambda_expr
= build_lambda_object (lambda_expr
);
9108 lambda_expr
= error_mark_node
;
9110 cp_parser_end_tentative_firewall (parser
, start
, lambda_expr
);
9115 /* Parse the beginning of a lambda expression.
9118 [ lambda-capture [opt] ]
9120 LAMBDA_EXPR is the current representation of the lambda expression. */
9123 cp_parser_lambda_introducer (cp_parser
* parser
, tree lambda_expr
)
9125 /* Need commas after the first capture. */
9128 /* Eat the leading `['. */
9129 cp_parser_require (parser
, CPP_OPEN_SQUARE
, RT_OPEN_SQUARE
);
9131 /* Record default capture mode. "[&" "[=" "[&," "[=," */
9132 if (cp_lexer_next_token_is (parser
->lexer
, CPP_AND
)
9133 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_NAME
)
9134 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) = CPLD_REFERENCE
;
9135 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
9136 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) = CPLD_COPY
;
9138 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) != CPLD_NONE
)
9140 cp_lexer_consume_token (parser
->lexer
);
9144 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_SQUARE
))
9146 cp_token
* capture_token
;
9148 tree capture_init_expr
;
9149 cp_id_kind idk
= CP_ID_KIND_NONE
;
9150 bool explicit_init_p
= false;
9152 enum capture_kind_type
9157 enum capture_kind_type capture_kind
= BY_COPY
;
9159 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
9161 error ("expected end of capture-list");
9168 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
9170 /* Possibly capture `this'. */
9171 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_THIS
))
9173 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
9174 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_COPY
)
9175 pedwarn (loc
, 0, "explicit by-copy capture of %<this%> redundant "
9176 "with by-copy capture default");
9177 cp_lexer_consume_token (parser
->lexer
);
9178 add_capture (lambda_expr
,
9179 /*id=*/this_identifier
,
9180 /*initializer=*/finish_this_expr(),
9181 /*by_reference_p=*/false,
9186 /* Remember whether we want to capture as a reference or not. */
9187 if (cp_lexer_next_token_is (parser
->lexer
, CPP_AND
))
9189 capture_kind
= BY_REFERENCE
;
9190 cp_lexer_consume_token (parser
->lexer
);
9193 /* Get the identifier. */
9194 capture_token
= cp_lexer_peek_token (parser
->lexer
);
9195 capture_id
= cp_parser_identifier (parser
);
9197 if (capture_id
== error_mark_node
)
9198 /* Would be nice to have a cp_parser_skip_to_closing_x for general
9199 delimiters, but I modified this to stop on unnested ']' as well. It
9200 was already changed to stop on unnested '}', so the
9201 "closing_parenthesis" name is no more misleading with my change. */
9203 cp_parser_skip_to_closing_parenthesis (parser
,
9204 /*recovering=*/true,
9206 /*consume_paren=*/true);
9210 /* Find the initializer for this capture. */
9211 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
)
9212 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
9213 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
9215 bool direct
, non_constant
;
9216 /* An explicit initializer exists. */
9217 if (cxx_dialect
< cxx14
)
9218 pedwarn (input_location
, 0,
9219 "lambda capture initializers "
9220 "only available with -std=c++14 or -std=gnu++14");
9221 capture_init_expr
= cp_parser_initializer (parser
, &direct
,
9223 explicit_init_p
= true;
9224 if (capture_init_expr
== NULL_TREE
)
9226 error ("empty initializer for lambda init-capture");
9227 capture_init_expr
= error_mark_node
;
9232 const char* error_msg
;
9234 /* Turn the identifier into an id-expression. */
9236 = cp_parser_lookup_name_simple (parser
, capture_id
,
9237 capture_token
->location
);
9239 if (capture_init_expr
== error_mark_node
)
9241 unqualified_name_lookup_error (capture_id
);
9244 else if (DECL_P (capture_init_expr
)
9245 && (!VAR_P (capture_init_expr
)
9246 && TREE_CODE (capture_init_expr
) != PARM_DECL
))
9248 error_at (capture_token
->location
,
9249 "capture of non-variable %qD ",
9251 inform (0, "%q+#D declared here", capture_init_expr
);
9254 if (VAR_P (capture_init_expr
)
9255 && decl_storage_duration (capture_init_expr
) != dk_auto
)
9257 if (pedwarn (capture_token
->location
, 0, "capture of variable "
9258 "%qD with non-automatic storage duration",
9260 inform (0, "%q+#D declared here", capture_init_expr
);
9265 = finish_id_expression
9270 /*integral_constant_expression_p=*/false,
9271 /*allow_non_integral_constant_expression_p=*/false,
9272 /*non_integral_constant_expression_p=*/NULL
,
9273 /*template_p=*/false,
9275 /*address_p=*/false,
9276 /*template_arg_p=*/false,
9278 capture_token
->location
);
9280 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
9282 cp_lexer_consume_token (parser
->lexer
);
9283 capture_init_expr
= make_pack_expansion (capture_init_expr
);
9286 check_for_bare_parameter_packs (capture_init_expr
);
9289 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) != CPLD_NONE
9290 && !explicit_init_p
)
9292 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_COPY
9293 && capture_kind
== BY_COPY
)
9294 pedwarn (capture_token
->location
, 0, "explicit by-copy capture "
9295 "of %qD redundant with by-copy capture default",
9297 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_REFERENCE
9298 && capture_kind
== BY_REFERENCE
)
9299 pedwarn (capture_token
->location
, 0, "explicit by-reference "
9300 "capture of %qD redundant with by-reference capture "
9301 "default", capture_id
);
9304 add_capture (lambda_expr
,
9307 /*by_reference_p=*/capture_kind
== BY_REFERENCE
,
9311 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
9314 /* Parse the (optional) middle of a lambda expression.
9317 < template-parameter-list [opt] >
9318 ( parameter-declaration-clause [opt] )
9319 attribute-specifier [opt]
9321 exception-specification [opt]
9322 lambda-return-type-clause [opt]
9324 LAMBDA_EXPR is the current representation of the lambda expression. */
9327 cp_parser_lambda_declarator_opt (cp_parser
* parser
, tree lambda_expr
)
9329 /* 5.1.1.4 of the standard says:
9330 If a lambda-expression does not include a lambda-declarator, it is as if
9331 the lambda-declarator were ().
9332 This means an empty parameter list, no attributes, and no exception
9334 tree param_list
= void_list_node
;
9335 tree attributes
= NULL_TREE
;
9336 tree exception_spec
= NULL_TREE
;
9337 tree template_param_list
= NULL_TREE
;
9339 /* The template-parameter-list is optional, but must begin with
9340 an opening angle if present. */
9341 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
9343 if (cxx_dialect
< cxx14
)
9344 pedwarn (parser
->lexer
->next_token
->location
, 0,
9345 "lambda templates are only available with "
9346 "-std=c++14 or -std=gnu++14");
9348 cp_lexer_consume_token (parser
->lexer
);
9350 template_param_list
= cp_parser_template_parameter_list (parser
);
9352 cp_parser_skip_to_end_of_template_parameter_list (parser
);
9354 /* We just processed one more parameter list. */
9355 ++parser
->num_template_parameter_lists
;
9358 /* The parameter-declaration-clause is optional (unless
9359 template-parameter-list was given), but must begin with an
9360 opening parenthesis if present. */
9361 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
9363 cp_lexer_consume_token (parser
->lexer
);
9365 begin_scope (sk_function_parms
, /*entity=*/NULL_TREE
);
9367 /* Parse parameters. */
9368 param_list
= cp_parser_parameter_declaration_clause (parser
);
9370 /* Default arguments shall not be specified in the
9371 parameter-declaration-clause of a lambda-declarator. */
9372 for (tree t
= param_list
; t
; t
= TREE_CHAIN (t
))
9373 if (TREE_PURPOSE (t
) && cxx_dialect
< cxx14
)
9374 pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t
)), OPT_Wpedantic
,
9375 "default argument specified for lambda parameter");
9377 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
9379 attributes
= cp_parser_attributes_opt (parser
);
9381 /* Parse optional `mutable' keyword. */
9382 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_MUTABLE
))
9384 cp_lexer_consume_token (parser
->lexer
);
9385 LAMBDA_EXPR_MUTABLE_P (lambda_expr
) = 1;
9388 /* Parse optional exception specification. */
9389 exception_spec
= cp_parser_exception_specification_opt (parser
);
9391 /* Parse optional trailing return type. */
9392 if (cp_lexer_next_token_is (parser
->lexer
, CPP_DEREF
))
9394 cp_lexer_consume_token (parser
->lexer
);
9395 LAMBDA_EXPR_RETURN_TYPE (lambda_expr
)
9396 = cp_parser_trailing_type_id (parser
);
9399 /* The function parameters must be in scope all the way until after the
9400 trailing-return-type in case of decltype. */
9401 pop_bindings_and_leave_scope ();
9403 else if (template_param_list
!= NULL_TREE
) // generate diagnostic
9404 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
9406 /* Create the function call operator.
9408 Messing with declarators like this is no uglier than building up the
9409 FUNCTION_DECL by hand, and this is less likely to get out of sync with
9412 cp_decl_specifier_seq return_type_specs
;
9413 cp_declarator
* declarator
;
9418 clear_decl_specs (&return_type_specs
);
9419 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr
))
9420 return_type_specs
.type
= LAMBDA_EXPR_RETURN_TYPE (lambda_expr
);
9422 /* Maybe we will deduce the return type later. */
9423 return_type_specs
.type
= make_auto ();
9425 p
= obstack_alloc (&declarator_obstack
, 0);
9427 declarator
= make_id_declarator (NULL_TREE
, ansi_opname (CALL_EXPR
),
9430 quals
= (LAMBDA_EXPR_MUTABLE_P (lambda_expr
)
9431 ? TYPE_UNQUALIFIED
: TYPE_QUAL_CONST
);
9432 declarator
= make_call_declarator (declarator
, param_list
, quals
,
9433 VIRT_SPEC_UNSPECIFIED
,
9436 /*late_return_type=*/NULL_TREE
);
9437 declarator
->id_loc
= LAMBDA_EXPR_LOCATION (lambda_expr
);
9439 fco
= grokmethod (&return_type_specs
,
9442 if (fco
!= error_mark_node
)
9444 DECL_INITIALIZED_IN_CLASS_P (fco
) = 1;
9445 DECL_ARTIFICIAL (fco
) = 1;
9446 /* Give the object parameter a different name. */
9447 DECL_NAME (DECL_ARGUMENTS (fco
)) = get_identifier ("__closure");
9448 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr
))
9449 TYPE_HAS_LATE_RETURN_TYPE (TREE_TYPE (fco
)) = 1;
9451 if (template_param_list
)
9453 fco
= finish_member_template_decl (fco
);
9454 finish_template_decl (template_param_list
);
9455 --parser
->num_template_parameter_lists
;
9457 else if (parser
->fully_implicit_function_template_p
)
9458 fco
= finish_fully_implicit_template (parser
, fco
);
9460 finish_member_declaration (fco
);
9462 obstack_free (&declarator_obstack
, p
);
9464 return (fco
!= error_mark_node
);
9468 /* Parse the body of a lambda expression, which is simply
9472 but which requires special handling.
9473 LAMBDA_EXPR is the current representation of the lambda expression. */
9476 cp_parser_lambda_body (cp_parser
* parser
, tree lambda_expr
)
9478 bool nested
= (current_function_decl
!= NULL_TREE
);
9479 bool local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
9481 push_function_context ();
9483 /* Still increment function_depth so that we don't GC in the
9484 middle of an expression. */
9486 /* Clear this in case we're in the middle of a default argument. */
9487 parser
->local_variables_forbidden_p
= false;
9489 /* Finish the function call operator
9491 + late_parsing_for_member
9492 + function_definition_after_declarator
9493 + ctor_initializer_opt_and_function_body */
9495 tree fco
= lambda_function (lambda_expr
);
9501 /* Let the front end know that we are going to be defining this
9503 start_preparsed_function (fco
,
9505 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9507 start_lambda_scope (fco
);
9508 body
= begin_function_body ();
9510 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
9513 /* Push the proxies for any explicit captures. */
9514 for (cap
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
); cap
;
9515 cap
= TREE_CHAIN (cap
))
9516 build_capture_proxy (TREE_PURPOSE (cap
));
9518 compound_stmt
= begin_compound_stmt (0);
9520 /* 5.1.1.4 of the standard says:
9521 If a lambda-expression does not include a trailing-return-type, it
9522 is as if the trailing-return-type denotes the following type:
9523 * if the compound-statement is of the form
9524 { return attribute-specifier [opt] expression ; }
9525 the type of the returned expression after lvalue-to-rvalue
9526 conversion (_conv.lval_ 4.1), array-to-pointer conversion
9527 (_conv.array_ 4.2), and function-to-pointer conversion
9529 * otherwise, void. */
9531 /* In a lambda that has neither a lambda-return-type-clause
9532 nor a deducible form, errors should be reported for return statements
9533 in the body. Since we used void as the placeholder return type, parsing
9534 the body as usual will give such desired behavior. */
9535 if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr
)
9536 && cp_lexer_peek_nth_token (parser
->lexer
, 1)->keyword
== RID_RETURN
9537 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SEMICOLON
)
9539 tree expr
= NULL_TREE
;
9540 cp_id_kind idk
= CP_ID_KIND_NONE
;
9542 /* Parse tentatively in case there's more after the initial return
9544 cp_parser_parse_tentatively (parser
);
9546 cp_parser_require_keyword (parser
, RID_RETURN
, RT_RETURN
);
9548 expr
= cp_parser_expression (parser
, &idk
);
9550 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
9551 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
9553 if (cp_parser_parse_definitely (parser
))
9555 if (!processing_template_decl
)
9556 apply_deduced_return_type (fco
, lambda_return_type (expr
));
9558 /* Will get error here if type not deduced yet. */
9559 finish_return_stmt (expr
);
9567 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_LABEL
))
9568 cp_parser_label_declaration (parser
);
9569 cp_parser_statement_seq_opt (parser
, NULL_TREE
);
9570 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
9573 finish_compound_stmt (compound_stmt
);
9576 finish_function_body (body
);
9577 finish_lambda_scope ();
9579 /* Finish the function and generate code for it if necessary. */
9580 tree fn
= finish_function (/*inline*/2);
9582 /* Only expand if the call op is not a template. */
9583 if (!DECL_TEMPLATE_INFO (fco
))
9584 expand_or_defer_fn (fn
);
9587 parser
->local_variables_forbidden_p
= local_variables_forbidden_p
;
9589 pop_function_context();
9594 /* Statements [gram.stmt.stmt] */
9596 /* Parse a statement.
9600 expression-statement
9605 declaration-statement
9612 attribute-specifier-seq (opt) expression-statement
9613 attribute-specifier-seq (opt) compound-statement
9614 attribute-specifier-seq (opt) selection-statement
9615 attribute-specifier-seq (opt) iteration-statement
9616 attribute-specifier-seq (opt) jump-statement
9617 declaration-statement
9618 attribute-specifier-seq (opt) try-block
9625 IN_COMPOUND is true when the statement is nested inside a
9626 cp_parser_compound_statement; this matters for certain pragmas.
9628 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9629 is a (possibly labeled) if statement which is not enclosed in braces
9630 and has an else clause. This is used to implement -Wparentheses. */
9633 cp_parser_statement (cp_parser
* parser
, tree in_statement_expr
,
9634 bool in_compound
, bool *if_p
)
9636 tree statement
, std_attrs
= NULL_TREE
;
9638 location_t statement_location
, attrs_location
;
9643 /* There is no statement yet. */
9644 statement
= NULL_TREE
;
9646 saved_token_sentinel
saved_tokens (parser
->lexer
);
9647 attrs_location
= cp_lexer_peek_token (parser
->lexer
)->location
;
9648 if (c_dialect_objc ())
9649 /* In obj-c++, seeing '[[' might be the either the beginning of
9650 c++11 attributes, or a nested objc-message-expression. So
9651 let's parse the c++11 attributes tentatively. */
9652 cp_parser_parse_tentatively (parser
);
9653 std_attrs
= cp_parser_std_attribute_spec_seq (parser
);
9654 if (c_dialect_objc ())
9656 if (!cp_parser_parse_definitely (parser
))
9657 std_attrs
= NULL_TREE
;
9660 /* Peek at the next token. */
9661 token
= cp_lexer_peek_token (parser
->lexer
);
9662 /* Remember the location of the first token in the statement. */
9663 statement_location
= token
->location
;
9664 /* If this is a keyword, then that will often determine what kind of
9665 statement we have. */
9666 if (token
->type
== CPP_KEYWORD
)
9668 enum rid keyword
= token
->keyword
;
9674 /* Looks like a labeled-statement with a case label.
9675 Parse the label, and then use tail recursion to parse
9677 cp_parser_label_for_labeled_statement (parser
, std_attrs
);
9682 statement
= cp_parser_selection_statement (parser
, if_p
);
9688 statement
= cp_parser_iteration_statement (parser
, false);
9694 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
9695 "-fcilkplus must be enabled to use %<_Cilk_for%>");
9696 cp_lexer_consume_token (parser
->lexer
);
9697 statement
= error_mark_node
;
9700 statement
= cp_parser_cilk_for (parser
, integer_zero_node
);
9707 statement
= cp_parser_jump_statement (parser
);
9711 cp_lexer_consume_token (parser
->lexer
);
9714 tree sync_expr
= build_cilk_sync ();
9715 SET_EXPR_LOCATION (sync_expr
,
9717 statement
= finish_expr_stmt (sync_expr
);
9721 error_at (token
->location
, "-fcilkplus must be enabled to use"
9723 statement
= error_mark_node
;
9725 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
9728 /* Objective-C++ exception-handling constructs. */
9731 case RID_AT_FINALLY
:
9732 case RID_AT_SYNCHRONIZED
:
9734 statement
= cp_parser_objc_statement (parser
);
9738 statement
= cp_parser_try_block (parser
);
9742 /* This must be a namespace alias definition. */
9743 cp_parser_declaration_statement (parser
);
9746 case RID_TRANSACTION_ATOMIC
:
9747 case RID_TRANSACTION_RELAXED
:
9748 statement
= cp_parser_transaction (parser
, keyword
);
9750 case RID_TRANSACTION_CANCEL
:
9751 statement
= cp_parser_transaction_cancel (parser
);
9755 /* It might be a keyword like `int' that can start a
9756 declaration-statement. */
9760 else if (token
->type
== CPP_NAME
)
9762 /* If the next token is a `:', then we are looking at a
9763 labeled-statement. */
9764 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
9765 if (token
->type
== CPP_COLON
)
9767 /* Looks like a labeled-statement with an ordinary label.
9768 Parse the label, and then use tail recursion to parse
9771 cp_parser_label_for_labeled_statement (parser
, std_attrs
);
9775 /* Anything that starts with a `{' must be a compound-statement. */
9776 else if (token
->type
== CPP_OPEN_BRACE
)
9777 statement
= cp_parser_compound_statement (parser
, NULL
, false, false);
9778 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
9779 a statement all its own. */
9780 else if (token
->type
== CPP_PRAGMA
)
9782 /* Only certain OpenMP pragmas are attached to statements, and thus
9783 are considered statements themselves. All others are not. In
9784 the context of a compound, accept the pragma as a "statement" and
9785 return so that we can check for a close brace. Otherwise we
9786 require a real statement and must go back and read one. */
9788 cp_parser_pragma (parser
, pragma_compound
);
9789 else if (!cp_parser_pragma (parser
, pragma_stmt
))
9793 else if (token
->type
== CPP_EOF
)
9795 cp_parser_error (parser
, "expected statement");
9799 /* Everything else must be a declaration-statement or an
9800 expression-statement. Try for the declaration-statement
9801 first, unless we are looking at a `;', in which case we know that
9802 we have an expression-statement. */
9805 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
9807 if (std_attrs
!= NULL_TREE
)
9809 /* Attributes should be parsed as part of the the
9810 declaration, so let's un-parse them. */
9811 saved_tokens
.rollback();
9812 std_attrs
= NULL_TREE
;
9815 cp_parser_parse_tentatively (parser
);
9816 /* Try to parse the declaration-statement. */
9817 cp_parser_declaration_statement (parser
);
9818 /* If that worked, we're done. */
9819 if (cp_parser_parse_definitely (parser
))
9822 /* Look for an expression-statement instead. */
9823 statement
= cp_parser_expression_statement (parser
, in_statement_expr
);
9826 /* Set the line number for the statement. */
9827 if (statement
&& STATEMENT_CODE_P (TREE_CODE (statement
)))
9828 SET_EXPR_LOCATION (statement
, statement_location
);
9830 /* Note that for now, we don't do anything with c++11 statements
9831 parsed at this level. */
9832 if (std_attrs
!= NULL_TREE
)
9833 warning_at (attrs_location
,
9835 "attributes at the beginning of statement are ignored");
9838 /* Parse the label for a labeled-statement, i.e.
9841 case constant-expression :
9845 case constant-expression ... constant-expression : statement
9847 When a label is parsed without errors, the label is added to the
9848 parse tree by the finish_* functions, so this function doesn't
9849 have to return the label. */
9852 cp_parser_label_for_labeled_statement (cp_parser
* parser
, tree attributes
)
9855 tree label
= NULL_TREE
;
9856 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
9858 /* The next token should be an identifier. */
9859 token
= cp_lexer_peek_token (parser
->lexer
);
9860 if (token
->type
!= CPP_NAME
9861 && token
->type
!= CPP_KEYWORD
)
9863 cp_parser_error (parser
, "expected labeled-statement");
9867 parser
->colon_corrects_to_scope_p
= false;
9868 switch (token
->keyword
)
9875 /* Consume the `case' token. */
9876 cp_lexer_consume_token (parser
->lexer
);
9877 /* Parse the constant-expression. */
9878 expr
= cp_parser_constant_expression (parser
);
9879 if (check_for_bare_parameter_packs (expr
))
9880 expr
= error_mark_node
;
9882 ellipsis
= cp_lexer_peek_token (parser
->lexer
);
9883 if (ellipsis
->type
== CPP_ELLIPSIS
)
9885 /* Consume the `...' token. */
9886 cp_lexer_consume_token (parser
->lexer
);
9887 expr_hi
= cp_parser_constant_expression (parser
);
9888 if (check_for_bare_parameter_packs (expr_hi
))
9889 expr_hi
= error_mark_node
;
9891 /* We don't need to emit warnings here, as the common code
9892 will do this for us. */
9895 expr_hi
= NULL_TREE
;
9897 if (parser
->in_switch_statement_p
)
9898 finish_case_label (token
->location
, expr
, expr_hi
);
9900 error_at (token
->location
,
9901 "case label %qE not within a switch statement",
9907 /* Consume the `default' token. */
9908 cp_lexer_consume_token (parser
->lexer
);
9910 if (parser
->in_switch_statement_p
)
9911 finish_case_label (token
->location
, NULL_TREE
, NULL_TREE
);
9913 error_at (token
->location
, "case label not within a switch statement");
9917 /* Anything else must be an ordinary label. */
9918 label
= finish_label_stmt (cp_parser_identifier (parser
));
9922 /* Require the `:' token. */
9923 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
9925 /* An ordinary label may optionally be followed by attributes.
9926 However, this is only permitted if the attributes are then
9927 followed by a semicolon. This is because, for backward
9928 compatibility, when parsing
9929 lab: __attribute__ ((unused)) int i;
9930 we want the attribute to attach to "i", not "lab". */
9931 if (label
!= NULL_TREE
9932 && cp_next_tokens_can_be_gnu_attribute_p (parser
))
9935 cp_parser_parse_tentatively (parser
);
9936 attrs
= cp_parser_gnu_attributes_opt (parser
);
9937 if (attrs
== NULL_TREE
9938 || cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
9939 cp_parser_abort_tentative_parse (parser
);
9940 else if (!cp_parser_parse_definitely (parser
))
9943 attributes
= chainon (attributes
, attrs
);
9946 if (attributes
!= NULL_TREE
)
9947 cplus_decl_attributes (&label
, attributes
, 0);
9949 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
9952 /* Parse an expression-statement.
9954 expression-statement:
9957 Returns the new EXPR_STMT -- or NULL_TREE if the expression
9958 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
9959 indicates whether this expression-statement is part of an
9960 expression statement. */
9963 cp_parser_expression_statement (cp_parser
* parser
, tree in_statement_expr
)
9965 tree statement
= NULL_TREE
;
9966 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
9968 /* If the next token is a ';', then there is no expression
9970 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
9972 statement
= cp_parser_expression (parser
);
9973 if (statement
== error_mark_node
9974 && !cp_parser_uncommitted_to_tentative_parse_p (parser
))
9976 cp_parser_skip_to_end_of_block_or_statement (parser
);
9977 return error_mark_node
;
9981 /* Give a helpful message for "A<T>::type t;" and the like. */
9982 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
)
9983 && !cp_parser_uncommitted_to_tentative_parse_p (parser
))
9985 if (TREE_CODE (statement
) == SCOPE_REF
)
9986 error_at (token
->location
, "need %<typename%> before %qE because "
9987 "%qT is a dependent scope",
9988 statement
, TREE_OPERAND (statement
, 0));
9989 else if (is_overloaded_fn (statement
)
9990 && DECL_CONSTRUCTOR_P (get_first_fn (statement
)))
9993 tree fn
= get_first_fn (statement
);
9994 error_at (token
->location
,
9995 "%<%T::%D%> names the constructor, not the type",
9996 DECL_CONTEXT (fn
), DECL_NAME (fn
));
10000 /* Consume the final `;'. */
10001 cp_parser_consume_semicolon_at_end_of_statement (parser
);
10003 if (in_statement_expr
10004 && cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
10005 /* This is the final expression statement of a statement
10007 statement
= finish_stmt_expr_expr (statement
, in_statement_expr
);
10008 else if (statement
)
10009 statement
= finish_expr_stmt (statement
);
10014 /* Parse a compound-statement.
10016 compound-statement:
10017 { statement-seq [opt] }
10021 compound-statement:
10022 { label-declaration-seq [opt] statement-seq [opt] }
10024 label-declaration-seq:
10026 label-declaration-seq label-declaration
10028 Returns a tree representing the statement. */
10031 cp_parser_compound_statement (cp_parser
*parser
, tree in_statement_expr
,
10032 bool in_try
, bool function_body
)
10034 tree compound_stmt
;
10036 /* Consume the `{'. */
10037 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
10038 return error_mark_node
;
10039 if (DECL_DECLARED_CONSTEXPR_P (current_function_decl
)
10040 && !function_body
&& cxx_dialect
< cxx14
)
10041 pedwarn (input_location
, OPT_Wpedantic
,
10042 "compound-statement in constexpr function");
10043 /* Begin the compound-statement. */
10044 compound_stmt
= begin_compound_stmt (in_try
? BCS_TRY_BLOCK
: 0);
10045 /* If the next keyword is `__label__' we have a label declaration. */
10046 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_LABEL
))
10047 cp_parser_label_declaration (parser
);
10048 /* Parse an (optional) statement-seq. */
10049 cp_parser_statement_seq_opt (parser
, in_statement_expr
);
10050 /* Finish the compound-statement. */
10051 finish_compound_stmt (compound_stmt
);
10052 /* Consume the `}'. */
10053 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
10055 return compound_stmt
;
10058 /* Parse an (optional) statement-seq.
10062 statement-seq [opt] statement */
10065 cp_parser_statement_seq_opt (cp_parser
* parser
, tree in_statement_expr
)
10067 /* Scan statements until there aren't any more. */
10070 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
10072 /* If we are looking at a `}', then we have run out of
10073 statements; the same is true if we have reached the end
10074 of file, or have stumbled upon a stray '@end'. */
10075 if (token
->type
== CPP_CLOSE_BRACE
10076 || token
->type
== CPP_EOF
10077 || token
->type
== CPP_PRAGMA_EOL
10078 || (token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_AT_END
))
10081 /* If we are in a compound statement and find 'else' then
10082 something went wrong. */
10083 else if (token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_ELSE
)
10085 if (parser
->in_statement
& IN_IF_STMT
)
10089 token
= cp_lexer_consume_token (parser
->lexer
);
10090 error_at (token
->location
, "%<else%> without a previous %<if%>");
10094 /* Parse the statement. */
10095 cp_parser_statement (parser
, in_statement_expr
, true, NULL
);
10099 /* Parse a selection-statement.
10101 selection-statement:
10102 if ( condition ) statement
10103 if ( condition ) statement else statement
10104 switch ( condition ) statement
10106 Returns the new IF_STMT or SWITCH_STMT.
10108 If IF_P is not NULL, *IF_P is set to indicate whether the statement
10109 is a (possibly labeled) if statement which is not enclosed in
10110 braces and has an else clause. This is used to implement
10114 cp_parser_selection_statement (cp_parser
* parser
, bool *if_p
)
10122 /* Peek at the next token. */
10123 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_SELECT
);
10125 /* See what kind of keyword it is. */
10126 keyword
= token
->keyword
;
10135 /* Look for the `('. */
10136 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
10138 cp_parser_skip_to_end_of_statement (parser
);
10139 return error_mark_node
;
10142 /* Begin the selection-statement. */
10143 if (keyword
== RID_IF
)
10144 statement
= begin_if_stmt ();
10146 statement
= begin_switch_stmt ();
10148 /* Parse the condition. */
10149 condition
= cp_parser_condition (parser
);
10150 /* Look for the `)'. */
10151 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
10152 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
10153 /*consume_paren=*/true);
10155 if (keyword
== RID_IF
)
10158 unsigned char in_statement
;
10160 /* Add the condition. */
10161 finish_if_stmt_cond (condition
, statement
);
10163 /* Parse the then-clause. */
10164 in_statement
= parser
->in_statement
;
10165 parser
->in_statement
|= IN_IF_STMT
;
10166 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
10168 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
10169 add_stmt (build_empty_stmt (loc
));
10170 cp_lexer_consume_token (parser
->lexer
);
10171 if (!cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ELSE
))
10172 warning_at (loc
, OPT_Wempty_body
, "suggest braces around "
10173 "empty body in an %<if%> statement");
10177 cp_parser_implicitly_scoped_statement (parser
, &nested_if
);
10178 parser
->in_statement
= in_statement
;
10180 finish_then_clause (statement
);
10182 /* If the next token is `else', parse the else-clause. */
10183 if (cp_lexer_next_token_is_keyword (parser
->lexer
,
10186 /* Consume the `else' keyword. */
10187 cp_lexer_consume_token (parser
->lexer
);
10188 begin_else_clause (statement
);
10189 /* Parse the else-clause. */
10190 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
10193 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
10195 OPT_Wempty_body
, "suggest braces around "
10196 "empty body in an %<else%> statement");
10197 add_stmt (build_empty_stmt (loc
));
10198 cp_lexer_consume_token (parser
->lexer
);
10201 cp_parser_implicitly_scoped_statement (parser
, NULL
);
10203 finish_else_clause (statement
);
10205 /* If we are currently parsing a then-clause, then
10206 IF_P will not be NULL. We set it to true to
10207 indicate that this if statement has an else clause.
10208 This may trigger the Wparentheses warning below
10209 when we get back up to the parent if statement. */
10215 /* This if statement does not have an else clause. If
10216 NESTED_IF is true, then the then-clause is an if
10217 statement which does have an else clause. We warn
10218 about the potential ambiguity. */
10220 warning_at (EXPR_LOCATION (statement
), OPT_Wparentheses
,
10221 "suggest explicit braces to avoid ambiguous"
10225 /* Now we're all done with the if-statement. */
10226 finish_if_stmt (statement
);
10230 bool in_switch_statement_p
;
10231 unsigned char in_statement
;
10233 /* Add the condition. */
10234 finish_switch_cond (condition
, statement
);
10236 /* Parse the body of the switch-statement. */
10237 in_switch_statement_p
= parser
->in_switch_statement_p
;
10238 in_statement
= parser
->in_statement
;
10239 parser
->in_switch_statement_p
= true;
10240 parser
->in_statement
|= IN_SWITCH_STMT
;
10241 cp_parser_implicitly_scoped_statement (parser
, NULL
);
10242 parser
->in_switch_statement_p
= in_switch_statement_p
;
10243 parser
->in_statement
= in_statement
;
10245 /* Now we're all done with the switch-statement. */
10246 finish_switch_stmt (statement
);
10254 cp_parser_error (parser
, "expected selection-statement");
10255 return error_mark_node
;
10259 /* Parse a condition.
10263 type-specifier-seq declarator = initializer-clause
10264 type-specifier-seq declarator braced-init-list
10269 type-specifier-seq declarator asm-specification [opt]
10270 attributes [opt] = assignment-expression
10272 Returns the expression that should be tested. */
10275 cp_parser_condition (cp_parser
* parser
)
10277 cp_decl_specifier_seq type_specifiers
;
10278 const char *saved_message
;
10279 int declares_class_or_enum
;
10281 /* Try the declaration first. */
10282 cp_parser_parse_tentatively (parser
);
10283 /* New types are not allowed in the type-specifier-seq for a
10285 saved_message
= parser
->type_definition_forbidden_message
;
10286 parser
->type_definition_forbidden_message
10287 = G_("types may not be defined in conditions");
10288 /* Parse the type-specifier-seq. */
10289 cp_parser_decl_specifier_seq (parser
,
10290 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR
,
10292 &declares_class_or_enum
);
10293 /* Restore the saved message. */
10294 parser
->type_definition_forbidden_message
= saved_message
;
10295 /* If all is well, we might be looking at a declaration. */
10296 if (!cp_parser_error_occurred (parser
))
10299 tree asm_specification
;
10301 cp_declarator
*declarator
;
10302 tree initializer
= NULL_TREE
;
10304 /* Parse the declarator. */
10305 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
10306 /*ctor_dtor_or_conv_p=*/NULL
,
10307 /*parenthesized_p=*/NULL
,
10308 /*member_p=*/false,
10309 /*friend_p=*/false);
10310 /* Parse the attributes. */
10311 attributes
= cp_parser_attributes_opt (parser
);
10312 /* Parse the asm-specification. */
10313 asm_specification
= cp_parser_asm_specification_opt (parser
);
10314 /* If the next token is not an `=' or '{', then we might still be
10315 looking at an expression. For example:
10319 looks like a decl-specifier-seq and a declarator -- but then
10320 there is no `=', so this is an expression. */
10321 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
)
10322 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
10323 cp_parser_simulate_error (parser
);
10325 /* If we did see an `=' or '{', then we are looking at a declaration
10327 if (cp_parser_parse_definitely (parser
))
10330 bool non_constant_p
;
10331 bool flags
= LOOKUP_ONLYCONVERTING
;
10333 /* Create the declaration. */
10334 decl
= start_decl (declarator
, &type_specifiers
,
10335 /*initialized_p=*/true,
10336 attributes
, /*prefix_attributes=*/NULL_TREE
,
10339 /* Parse the initializer. */
10340 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
10342 initializer
= cp_parser_braced_list (parser
, &non_constant_p
);
10343 CONSTRUCTOR_IS_DIRECT_INIT (initializer
) = 1;
10348 /* Consume the `='. */
10349 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
10350 initializer
= cp_parser_initializer_clause (parser
, &non_constant_p
);
10352 if (BRACE_ENCLOSED_INITIALIZER_P (initializer
))
10353 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
10355 /* Process the initializer. */
10356 cp_finish_decl (decl
,
10357 initializer
, !non_constant_p
,
10362 pop_scope (pushed_scope
);
10364 return convert_from_reference (decl
);
10367 /* If we didn't even get past the declarator successfully, we are
10368 definitely not looking at a declaration. */
10370 cp_parser_abort_tentative_parse (parser
);
10372 /* Otherwise, we are looking at an expression. */
10373 return cp_parser_expression (parser
);
10376 /* Parses a for-statement or range-for-statement until the closing ')',
10380 cp_parser_for (cp_parser
*parser
, bool ivdep
)
10382 tree init
, scope
, decl
;
10385 /* Begin the for-statement. */
10386 scope
= begin_for_scope (&init
);
10388 /* Parse the initialization. */
10389 is_range_for
= cp_parser_for_init_statement (parser
, &decl
);
10392 return cp_parser_range_for (parser
, scope
, init
, decl
, ivdep
);
10394 return cp_parser_c_for (parser
, scope
, init
, ivdep
);
10398 cp_parser_c_for (cp_parser
*parser
, tree scope
, tree init
, bool ivdep
)
10400 /* Normal for loop */
10401 tree condition
= NULL_TREE
;
10402 tree expression
= NULL_TREE
;
10405 stmt
= begin_for_stmt (scope
, init
);
10406 /* The for-init-statement has already been parsed in
10407 cp_parser_for_init_statement, so no work is needed here. */
10408 finish_for_init_stmt (stmt
);
10410 /* If there's a condition, process it. */
10411 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
10412 condition
= cp_parser_condition (parser
);
10415 cp_parser_error (parser
, "missing loop condition in loop with "
10416 "%<GCC ivdep%> pragma");
10417 condition
= error_mark_node
;
10419 finish_for_cond (condition
, stmt
, ivdep
);
10420 /* Look for the `;'. */
10421 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
10423 /* If there's an expression, process it. */
10424 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
10425 expression
= cp_parser_expression (parser
);
10426 finish_for_expr (expression
, stmt
);
10431 /* Tries to parse a range-based for-statement:
10434 decl-specifier-seq declarator : expression
10436 The decl-specifier-seq declarator and the `:' are already parsed by
10437 cp_parser_for_init_statement. If processing_template_decl it returns a
10438 newly created RANGE_FOR_STMT; if not, it is converted to a
10439 regular FOR_STMT. */
10442 cp_parser_range_for (cp_parser
*parser
, tree scope
, tree init
, tree range_decl
,
10445 tree stmt
, range_expr
;
10447 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
10449 bool expr_non_constant_p
;
10450 range_expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
10453 range_expr
= cp_parser_expression (parser
);
10455 /* If in template, STMT is converted to a normal for-statement
10456 at instantiation. If not, it is done just ahead. */
10457 if (processing_template_decl
)
10459 if (check_for_bare_parameter_packs (range_expr
))
10460 range_expr
= error_mark_node
;
10461 stmt
= begin_range_for_stmt (scope
, init
);
10463 RANGE_FOR_IVDEP (stmt
) = 1;
10464 finish_range_for_decl (stmt
, range_decl
, range_expr
);
10465 if (!type_dependent_expression_p (range_expr
)
10466 /* do_auto_deduction doesn't mess with template init-lists. */
10467 && !BRACE_ENCLOSED_INITIALIZER_P (range_expr
))
10468 do_range_for_auto_deduction (range_decl
, range_expr
);
10472 stmt
= begin_for_stmt (scope
, init
);
10473 stmt
= cp_convert_range_for (stmt
, range_decl
, range_expr
, ivdep
);
10478 /* Subroutine of cp_convert_range_for: given the initializer expression,
10479 builds up the range temporary. */
10482 build_range_temp (tree range_expr
)
10484 tree range_type
, range_temp
;
10486 /* Find out the type deduced by the declaration
10487 `auto &&__range = range_expr'. */
10488 range_type
= cp_build_reference_type (make_auto (), true);
10489 range_type
= do_auto_deduction (range_type
, range_expr
,
10490 type_uses_auto (range_type
));
10492 /* Create the __range variable. */
10493 range_temp
= build_decl (input_location
, VAR_DECL
,
10494 get_identifier ("__for_range"), range_type
);
10495 TREE_USED (range_temp
) = 1;
10496 DECL_ARTIFICIAL (range_temp
) = 1;
10501 /* Used by cp_parser_range_for in template context: we aren't going to
10502 do a full conversion yet, but we still need to resolve auto in the
10503 type of the for-range-declaration if present. This is basically
10504 a shortcut version of cp_convert_range_for. */
10507 do_range_for_auto_deduction (tree decl
, tree range_expr
)
10509 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
10512 tree begin_dummy
, end_dummy
, range_temp
, iter_type
, iter_decl
;
10513 range_temp
= convert_from_reference (build_range_temp (range_expr
));
10514 iter_type
= (cp_parser_perform_range_for_lookup
10515 (range_temp
, &begin_dummy
, &end_dummy
));
10518 iter_decl
= build_decl (input_location
, VAR_DECL
, NULL_TREE
,
10520 iter_decl
= build_x_indirect_ref (input_location
, iter_decl
, RO_NULL
,
10521 tf_warning_or_error
);
10522 TREE_TYPE (decl
) = do_auto_deduction (TREE_TYPE (decl
),
10523 iter_decl
, auto_node
);
10528 /* Converts a range-based for-statement into a normal
10529 for-statement, as per the definition.
10531 for (RANGE_DECL : RANGE_EXPR)
10534 should be equivalent to:
10537 auto &&__range = RANGE_EXPR;
10538 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
10542 RANGE_DECL = *__begin;
10547 If RANGE_EXPR is an array:
10548 BEGIN_EXPR = __range
10549 END_EXPR = __range + ARRAY_SIZE(__range)
10550 Else if RANGE_EXPR has a member 'begin' or 'end':
10551 BEGIN_EXPR = __range.begin()
10552 END_EXPR = __range.end()
10554 BEGIN_EXPR = begin(__range)
10555 END_EXPR = end(__range);
10557 If __range has a member 'begin' but not 'end', or vice versa, we must
10558 still use the second alternative (it will surely fail, however).
10559 When calling begin()/end() in the third alternative we must use
10560 argument dependent lookup, but always considering 'std' as an associated
10564 cp_convert_range_for (tree statement
, tree range_decl
, tree range_expr
,
10568 tree iter_type
, begin_expr
, end_expr
;
10569 tree condition
, expression
;
10571 if (range_decl
== error_mark_node
|| range_expr
== error_mark_node
)
10572 /* If an error happened previously do nothing or else a lot of
10573 unhelpful errors would be issued. */
10574 begin_expr
= end_expr
= iter_type
= error_mark_node
;
10579 if (TREE_CODE (range_expr
) == VAR_DECL
10580 && array_of_runtime_bound_p (TREE_TYPE (range_expr
)))
10581 /* Can't bind a reference to an array of runtime bound. */
10582 range_temp
= range_expr
;
10585 range_temp
= build_range_temp (range_expr
);
10586 pushdecl (range_temp
);
10587 cp_finish_decl (range_temp
, range_expr
,
10588 /*is_constant_init*/false, NULL_TREE
,
10589 LOOKUP_ONLYCONVERTING
);
10590 range_temp
= convert_from_reference (range_temp
);
10592 iter_type
= cp_parser_perform_range_for_lookup (range_temp
,
10593 &begin_expr
, &end_expr
);
10596 /* The new for initialization statement. */
10597 begin
= build_decl (input_location
, VAR_DECL
,
10598 get_identifier ("__for_begin"), iter_type
);
10599 TREE_USED (begin
) = 1;
10600 DECL_ARTIFICIAL (begin
) = 1;
10602 cp_finish_decl (begin
, begin_expr
,
10603 /*is_constant_init*/false, NULL_TREE
,
10604 LOOKUP_ONLYCONVERTING
);
10606 end
= build_decl (input_location
, VAR_DECL
,
10607 get_identifier ("__for_end"), iter_type
);
10608 TREE_USED (end
) = 1;
10609 DECL_ARTIFICIAL (end
) = 1;
10611 cp_finish_decl (end
, end_expr
,
10612 /*is_constant_init*/false, NULL_TREE
,
10613 LOOKUP_ONLYCONVERTING
);
10615 finish_for_init_stmt (statement
);
10617 /* The new for condition. */
10618 condition
= build_x_binary_op (input_location
, NE_EXPR
,
10621 NULL
, tf_warning_or_error
);
10622 finish_for_cond (condition
, statement
, ivdep
);
10624 /* The new increment expression. */
10625 expression
= finish_unary_op_expr (input_location
,
10626 PREINCREMENT_EXPR
, begin
,
10627 tf_warning_or_error
);
10628 finish_for_expr (expression
, statement
);
10630 /* The declaration is initialized with *__begin inside the loop body. */
10631 cp_finish_decl (range_decl
,
10632 build_x_indirect_ref (input_location
, begin
, RO_NULL
,
10633 tf_warning_or_error
),
10634 /*is_constant_init*/false, NULL_TREE
,
10635 LOOKUP_ONLYCONVERTING
);
10640 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
10641 We need to solve both at the same time because the method used
10642 depends on the existence of members begin or end.
10643 Returns the type deduced for the iterator expression. */
10646 cp_parser_perform_range_for_lookup (tree range
, tree
*begin
, tree
*end
)
10648 if (error_operand_p (range
))
10650 *begin
= *end
= error_mark_node
;
10651 return error_mark_node
;
10654 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (range
))))
10656 error ("range-based %<for%> expression of type %qT "
10657 "has incomplete type", TREE_TYPE (range
));
10658 *begin
= *end
= error_mark_node
;
10659 return error_mark_node
;
10661 if (TREE_CODE (TREE_TYPE (range
)) == ARRAY_TYPE
)
10663 /* If RANGE is an array, we will use pointer arithmetic. */
10665 *end
= build_binary_op (input_location
, PLUS_EXPR
,
10667 array_type_nelts_top (TREE_TYPE (range
)),
10669 return build_pointer_type (TREE_TYPE (TREE_TYPE (range
)));
10673 /* If it is not an array, we must do a bit of magic. */
10674 tree id_begin
, id_end
;
10675 tree member_begin
, member_end
;
10677 *begin
= *end
= error_mark_node
;
10679 id_begin
= get_identifier ("begin");
10680 id_end
= get_identifier ("end");
10681 member_begin
= lookup_member (TREE_TYPE (range
), id_begin
,
10682 /*protect=*/2, /*want_type=*/false,
10683 tf_warning_or_error
);
10684 member_end
= lookup_member (TREE_TYPE (range
), id_end
,
10685 /*protect=*/2, /*want_type=*/false,
10686 tf_warning_or_error
);
10688 if (member_begin
!= NULL_TREE
|| member_end
!= NULL_TREE
)
10690 /* Use the member functions. */
10691 if (member_begin
!= NULL_TREE
)
10692 *begin
= cp_parser_range_for_member_function (range
, id_begin
);
10694 error ("range-based %<for%> expression of type %qT has an "
10695 "%<end%> member but not a %<begin%>", TREE_TYPE (range
));
10697 if (member_end
!= NULL_TREE
)
10698 *end
= cp_parser_range_for_member_function (range
, id_end
);
10700 error ("range-based %<for%> expression of type %qT has a "
10701 "%<begin%> member but not an %<end%>", TREE_TYPE (range
));
10705 /* Use global functions with ADL. */
10706 vec
<tree
, va_gc
> *vec
;
10707 vec
= make_tree_vector ();
10709 vec_safe_push (vec
, range
);
10711 member_begin
= perform_koenig_lookup (id_begin
, vec
,
10712 tf_warning_or_error
);
10713 *begin
= finish_call_expr (member_begin
, &vec
, false, true,
10714 tf_warning_or_error
);
10715 member_end
= perform_koenig_lookup (id_end
, vec
,
10716 tf_warning_or_error
);
10717 *end
= finish_call_expr (member_end
, &vec
, false, true,
10718 tf_warning_or_error
);
10720 release_tree_vector (vec
);
10723 /* Last common checks. */
10724 if (*begin
== error_mark_node
|| *end
== error_mark_node
)
10726 /* If one of the expressions is an error do no more checks. */
10727 *begin
= *end
= error_mark_node
;
10728 return error_mark_node
;
10730 else if (type_dependent_expression_p (*begin
)
10731 || type_dependent_expression_p (*end
))
10732 /* Can happen, when, eg, in a template context, Koenig lookup
10733 can't resolve begin/end (c++/58503). */
10737 tree iter_type
= cv_unqualified (TREE_TYPE (*begin
));
10738 /* The unqualified type of the __begin and __end temporaries should
10739 be the same, as required by the multiple auto declaration. */
10740 if (!same_type_p (iter_type
, cv_unqualified (TREE_TYPE (*end
))))
10741 error ("inconsistent begin/end types in range-based %<for%> "
10742 "statement: %qT and %qT",
10743 TREE_TYPE (*begin
), TREE_TYPE (*end
));
10749 /* Helper function for cp_parser_perform_range_for_lookup.
10750 Builds a tree for RANGE.IDENTIFIER(). */
10753 cp_parser_range_for_member_function (tree range
, tree identifier
)
10756 vec
<tree
, va_gc
> *vec
;
10758 member
= finish_class_member_access_expr (range
, identifier
,
10759 false, tf_warning_or_error
);
10760 if (member
== error_mark_node
)
10761 return error_mark_node
;
10763 vec
= make_tree_vector ();
10764 res
= finish_call_expr (member
, &vec
,
10765 /*disallow_virtual=*/false,
10766 /*koenig_p=*/false,
10767 tf_warning_or_error
);
10768 release_tree_vector (vec
);
10772 /* Parse an iteration-statement.
10774 iteration-statement:
10775 while ( condition ) statement
10776 do statement while ( expression ) ;
10777 for ( for-init-statement condition [opt] ; expression [opt] )
10780 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
10783 cp_parser_iteration_statement (cp_parser
* parser
, bool ivdep
)
10788 unsigned char in_statement
;
10790 /* Peek at the next token. */
10791 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_INTERATION
);
10793 return error_mark_node
;
10795 /* Remember whether or not we are already within an iteration
10797 in_statement
= parser
->in_statement
;
10799 /* See what kind of keyword it is. */
10800 keyword
= token
->keyword
;
10807 /* Begin the while-statement. */
10808 statement
= begin_while_stmt ();
10809 /* Look for the `('. */
10810 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
10811 /* Parse the condition. */
10812 condition
= cp_parser_condition (parser
);
10813 finish_while_stmt_cond (condition
, statement
, ivdep
);
10814 /* Look for the `)'. */
10815 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
10816 /* Parse the dependent statement. */
10817 parser
->in_statement
= IN_ITERATION_STMT
;
10818 cp_parser_already_scoped_statement (parser
);
10819 parser
->in_statement
= in_statement
;
10820 /* We're done with the while-statement. */
10821 finish_while_stmt (statement
);
10829 /* Begin the do-statement. */
10830 statement
= begin_do_stmt ();
10831 /* Parse the body of the do-statement. */
10832 parser
->in_statement
= IN_ITERATION_STMT
;
10833 cp_parser_implicitly_scoped_statement (parser
, NULL
);
10834 parser
->in_statement
= in_statement
;
10835 finish_do_body (statement
);
10836 /* Look for the `while' keyword. */
10837 cp_parser_require_keyword (parser
, RID_WHILE
, RT_WHILE
);
10838 /* Look for the `('. */
10839 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
10840 /* Parse the expression. */
10841 expression
= cp_parser_expression (parser
);
10842 /* We're done with the do-statement. */
10843 finish_do_stmt (expression
, statement
, ivdep
);
10844 /* Look for the `)'. */
10845 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
10846 /* Look for the `;'. */
10847 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
10853 /* Look for the `('. */
10854 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
10856 statement
= cp_parser_for (parser
, ivdep
);
10858 /* Look for the `)'. */
10859 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
10861 /* Parse the body of the for-statement. */
10862 parser
->in_statement
= IN_ITERATION_STMT
;
10863 cp_parser_already_scoped_statement (parser
);
10864 parser
->in_statement
= in_statement
;
10866 /* We're done with the for-statement. */
10867 finish_for_stmt (statement
);
10872 cp_parser_error (parser
, "expected iteration-statement");
10873 statement
= error_mark_node
;
10880 /* Parse a for-init-statement or the declarator of a range-based-for.
10881 Returns true if a range-based-for declaration is seen.
10883 for-init-statement:
10884 expression-statement
10885 simple-declaration */
10888 cp_parser_for_init_statement (cp_parser
* parser
, tree
*decl
)
10890 /* If the next token is a `;', then we have an empty
10891 expression-statement. Grammatically, this is also a
10892 simple-declaration, but an invalid one, because it does not
10893 declare anything. Therefore, if we did not handle this case
10894 specially, we would issue an error message about an invalid
10896 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
10898 bool is_range_for
= false;
10899 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
10901 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
10902 && cp_lexer_nth_token_is (parser
->lexer
, 2, CPP_COLON
))
10904 /* N3994 -- for (id : init) ... */
10905 if (cxx_dialect
< cxx1z
)
10906 pedwarn (input_location
, 0, "range-based for loop without a "
10907 "type-specifier only available with "
10908 "-std=c++1z or -std=gnu++1z");
10909 tree name
= cp_parser_identifier (parser
);
10910 tree type
= cp_build_reference_type (make_auto (), /*rval*/true);
10911 *decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
10913 cp_lexer_consume_token (parser
->lexer
);
10917 /* A colon is used in range-based for. */
10918 parser
->colon_corrects_to_scope_p
= false;
10920 /* We're going to speculatively look for a declaration, falling back
10921 to an expression, if necessary. */
10922 cp_parser_parse_tentatively (parser
);
10923 /* Parse the declaration. */
10924 cp_parser_simple_declaration (parser
,
10925 /*function_definition_allowed_p=*/false,
10927 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
10928 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
10930 /* It is a range-for, consume the ':' */
10931 cp_lexer_consume_token (parser
->lexer
);
10932 is_range_for
= true;
10933 if (cxx_dialect
< cxx11
)
10935 pedwarn (cp_lexer_peek_token (parser
->lexer
)->location
, 0,
10936 "range-based %<for%> loops only available with "
10937 "-std=c++11 or -std=gnu++11");
10938 *decl
= error_mark_node
;
10942 /* The ';' is not consumed yet because we told
10943 cp_parser_simple_declaration not to. */
10944 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
10946 if (cp_parser_parse_definitely (parser
))
10947 return is_range_for
;
10948 /* If the tentative parse failed, then we shall need to look for an
10949 expression-statement. */
10951 /* If we are here, it is an expression-statement. */
10952 cp_parser_expression_statement (parser
, NULL_TREE
);
10956 /* Parse a jump-statement.
10961 return expression [opt] ;
10962 return braced-init-list ;
10968 goto * expression ;
10970 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
10973 cp_parser_jump_statement (cp_parser
* parser
)
10975 tree statement
= error_mark_node
;
10978 unsigned char in_statement
;
10980 /* Peek at the next token. */
10981 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_JUMP
);
10983 return error_mark_node
;
10985 /* See what kind of keyword it is. */
10986 keyword
= token
->keyword
;
10990 in_statement
= parser
->in_statement
& ~IN_IF_STMT
;
10991 switch (in_statement
)
10994 error_at (token
->location
, "break statement not within loop or switch");
10997 gcc_assert ((in_statement
& IN_SWITCH_STMT
)
10998 || in_statement
== IN_ITERATION_STMT
);
10999 statement
= finish_break_stmt ();
11000 if (in_statement
== IN_ITERATION_STMT
)
11001 break_maybe_infinite_loop ();
11004 error_at (token
->location
, "invalid exit from OpenMP structured block");
11007 error_at (token
->location
, "break statement used with OpenMP for loop");
11009 case IN_CILK_SIMD_FOR
:
11010 error_at (token
->location
, "break statement used with Cilk Plus for loop");
11013 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11017 switch (parser
->in_statement
& ~(IN_SWITCH_STMT
| IN_IF_STMT
))
11020 error_at (token
->location
, "continue statement not within a loop");
11022 case IN_CILK_SIMD_FOR
:
11023 error_at (token
->location
,
11024 "continue statement within %<#pragma simd%> loop body");
11025 /* Fall through. */
11026 case IN_ITERATION_STMT
:
11028 statement
= finish_continue_stmt ();
11031 error_at (token
->location
, "invalid exit from OpenMP structured block");
11034 gcc_unreachable ();
11036 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11042 bool expr_non_constant_p
;
11044 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
11046 cp_lexer_set_source_position (parser
->lexer
);
11047 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
11048 expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
11050 else if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
11051 expr
= cp_parser_expression (parser
);
11053 /* If the next token is a `;', then there is no
11056 /* Build the return-statement. */
11057 statement
= finish_return_stmt (expr
);
11058 /* Look for the final `;'. */
11059 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11064 if (parser
->in_function_body
11065 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
11067 error ("%<goto%> in %<constexpr%> function");
11068 cp_function_chain
->invalid_constexpr
= true;
11071 /* Create the goto-statement. */
11072 if (cp_lexer_next_token_is (parser
->lexer
, CPP_MULT
))
11074 /* Issue a warning about this use of a GNU extension. */
11075 pedwarn (token
->location
, OPT_Wpedantic
, "ISO C++ forbids computed gotos");
11076 /* Consume the '*' token. */
11077 cp_lexer_consume_token (parser
->lexer
);
11078 /* Parse the dependent expression. */
11079 finish_goto_stmt (cp_parser_expression (parser
));
11082 finish_goto_stmt (cp_parser_identifier (parser
));
11083 /* Look for the final `;'. */
11084 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11088 cp_parser_error (parser
, "expected jump-statement");
11095 /* Parse a declaration-statement.
11097 declaration-statement:
11098 block-declaration */
11101 cp_parser_declaration_statement (cp_parser
* parser
)
11105 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
11106 p
= obstack_alloc (&declarator_obstack
, 0);
11108 /* Parse the block-declaration. */
11109 cp_parser_block_declaration (parser
, /*statement_p=*/true);
11111 /* Free any declarators allocated. */
11112 obstack_free (&declarator_obstack
, p
);
11115 /* Some dependent statements (like `if (cond) statement'), are
11116 implicitly in their own scope. In other words, if the statement is
11117 a single statement (as opposed to a compound-statement), it is
11118 none-the-less treated as if it were enclosed in braces. Any
11119 declarations appearing in the dependent statement are out of scope
11120 after control passes that point. This function parses a statement,
11121 but ensures that is in its own scope, even if it is not a
11122 compound-statement.
11124 If IF_P is not NULL, *IF_P is set to indicate whether the statement
11125 is a (possibly labeled) if statement which is not enclosed in
11126 braces and has an else clause. This is used to implement
11129 Returns the new statement. */
11132 cp_parser_implicitly_scoped_statement (cp_parser
* parser
, bool *if_p
)
11139 /* Mark if () ; with a special NOP_EXPR. */
11140 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
11142 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
11143 cp_lexer_consume_token (parser
->lexer
);
11144 statement
= add_stmt (build_empty_stmt (loc
));
11146 /* if a compound is opened, we simply parse the statement directly. */
11147 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
11148 statement
= cp_parser_compound_statement (parser
, NULL
, false, false);
11149 /* If the token is not a `{', then we must take special action. */
11152 /* Create a compound-statement. */
11153 statement
= begin_compound_stmt (0);
11154 /* Parse the dependent-statement. */
11155 cp_parser_statement (parser
, NULL_TREE
, false, if_p
);
11156 /* Finish the dummy compound-statement. */
11157 finish_compound_stmt (statement
);
11160 /* Return the statement. */
11164 /* For some dependent statements (like `while (cond) statement'), we
11165 have already created a scope. Therefore, even if the dependent
11166 statement is a compound-statement, we do not want to create another
11170 cp_parser_already_scoped_statement (cp_parser
* parser
)
11172 /* If the token is a `{', then we must take special action. */
11173 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
11174 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
11177 /* Avoid calling cp_parser_compound_statement, so that we
11178 don't create a new scope. Do everything else by hand. */
11179 cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
);
11180 /* If the next keyword is `__label__' we have a label declaration. */
11181 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_LABEL
))
11182 cp_parser_label_declaration (parser
);
11183 /* Parse an (optional) statement-seq. */
11184 cp_parser_statement_seq_opt (parser
, NULL_TREE
);
11185 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
11189 /* Declarations [gram.dcl.dcl] */
11191 /* Parse an optional declaration-sequence.
11195 declaration-seq declaration */
11198 cp_parser_declaration_seq_opt (cp_parser
* parser
)
11204 token
= cp_lexer_peek_token (parser
->lexer
);
11206 if (token
->type
== CPP_CLOSE_BRACE
11207 || token
->type
== CPP_EOF
11208 || token
->type
== CPP_PRAGMA_EOL
)
11211 if (token
->type
== CPP_SEMICOLON
)
11213 /* A declaration consisting of a single semicolon is
11214 invalid. Allow it unless we're being pedantic. */
11215 cp_lexer_consume_token (parser
->lexer
);
11216 if (!in_system_header_at (input_location
))
11217 pedwarn (input_location
, OPT_Wpedantic
, "extra %<;%>");
11221 /* If we're entering or exiting a region that's implicitly
11222 extern "C", modify the lang context appropriately. */
11223 if (!parser
->implicit_extern_c
&& token
->implicit_extern_c
)
11225 push_lang_context (lang_name_c
);
11226 parser
->implicit_extern_c
= true;
11228 else if (parser
->implicit_extern_c
&& !token
->implicit_extern_c
)
11230 pop_lang_context ();
11231 parser
->implicit_extern_c
= false;
11234 if (token
->type
== CPP_PRAGMA
)
11236 /* A top-level declaration can consist solely of a #pragma.
11237 A nested declaration cannot, so this is done here and not
11238 in cp_parser_declaration. (A #pragma at block scope is
11239 handled in cp_parser_statement.) */
11240 cp_parser_pragma (parser
, pragma_external
);
11244 /* Parse the declaration itself. */
11245 cp_parser_declaration (parser
);
11249 /* Parse a declaration.
11253 function-definition
11254 template-declaration
11255 explicit-instantiation
11256 explicit-specialization
11257 linkage-specification
11258 namespace-definition
11263 __extension__ declaration */
11266 cp_parser_declaration (cp_parser
* parser
)
11270 int saved_pedantic
;
11272 tree attributes
= NULL_TREE
;
11274 /* Check for the `__extension__' keyword. */
11275 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
11277 /* Parse the qualified declaration. */
11278 cp_parser_declaration (parser
);
11279 /* Restore the PEDANTIC flag. */
11280 pedantic
= saved_pedantic
;
11285 /* Try to figure out what kind of declaration is present. */
11286 token1
= *cp_lexer_peek_token (parser
->lexer
);
11288 if (token1
.type
!= CPP_EOF
)
11289 token2
= *cp_lexer_peek_nth_token (parser
->lexer
, 2);
11292 token2
.type
= CPP_EOF
;
11293 token2
.keyword
= RID_MAX
;
11296 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
11297 p
= obstack_alloc (&declarator_obstack
, 0);
11299 /* If the next token is `extern' and the following token is a string
11300 literal, then we have a linkage specification. */
11301 if (token1
.keyword
== RID_EXTERN
11302 && cp_parser_is_pure_string_literal (&token2
))
11303 cp_parser_linkage_specification (parser
);
11304 /* If the next token is `template', then we have either a template
11305 declaration, an explicit instantiation, or an explicit
11307 else if (token1
.keyword
== RID_TEMPLATE
)
11309 /* `template <>' indicates a template specialization. */
11310 if (token2
.type
== CPP_LESS
11311 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_GREATER
)
11312 cp_parser_explicit_specialization (parser
);
11313 /* `template <' indicates a template declaration. */
11314 else if (token2
.type
== CPP_LESS
)
11315 cp_parser_template_declaration (parser
, /*member_p=*/false);
11316 /* Anything else must be an explicit instantiation. */
11318 cp_parser_explicit_instantiation (parser
);
11320 /* If the next token is `export', then we have a template
11322 else if (token1
.keyword
== RID_EXPORT
)
11323 cp_parser_template_declaration (parser
, /*member_p=*/false);
11324 /* If the next token is `extern', 'static' or 'inline' and the one
11325 after that is `template', we have a GNU extended explicit
11326 instantiation directive. */
11327 else if (cp_parser_allow_gnu_extensions_p (parser
)
11328 && (token1
.keyword
== RID_EXTERN
11329 || token1
.keyword
== RID_STATIC
11330 || token1
.keyword
== RID_INLINE
)
11331 && token2
.keyword
== RID_TEMPLATE
)
11332 cp_parser_explicit_instantiation (parser
);
11333 /* If the next token is `namespace', check for a named or unnamed
11334 namespace definition. */
11335 else if (token1
.keyword
== RID_NAMESPACE
11336 && (/* A named namespace definition. */
11337 (token2
.type
== CPP_NAME
11338 && (cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
11340 /* An unnamed namespace definition. */
11341 || token2
.type
== CPP_OPEN_BRACE
11342 || token2
.keyword
== RID_ATTRIBUTE
))
11343 cp_parser_namespace_definition (parser
);
11344 /* An inline (associated) namespace definition. */
11345 else if (token1
.keyword
== RID_INLINE
11346 && token2
.keyword
== RID_NAMESPACE
)
11347 cp_parser_namespace_definition (parser
);
11348 /* Objective-C++ declaration/definition. */
11349 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1
.keyword
))
11350 cp_parser_objc_declaration (parser
, NULL_TREE
);
11351 else if (c_dialect_objc ()
11352 && token1
.keyword
== RID_ATTRIBUTE
11353 && cp_parser_objc_valid_prefix_attributes (parser
, &attributes
))
11354 cp_parser_objc_declaration (parser
, attributes
);
11355 /* We must have either a block declaration or a function
11358 /* Try to parse a block-declaration, or a function-definition. */
11359 cp_parser_block_declaration (parser
, /*statement_p=*/false);
11361 /* Free any declarators allocated. */
11362 obstack_free (&declarator_obstack
, p
);
11365 /* Parse a block-declaration.
11370 namespace-alias-definition
11377 __extension__ block-declaration
11382 static_assert-declaration
11384 If STATEMENT_P is TRUE, then this block-declaration is occurring as
11385 part of a declaration-statement. */
11388 cp_parser_block_declaration (cp_parser
*parser
,
11392 int saved_pedantic
;
11394 /* Check for the `__extension__' keyword. */
11395 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
11397 /* Parse the qualified declaration. */
11398 cp_parser_block_declaration (parser
, statement_p
);
11399 /* Restore the PEDANTIC flag. */
11400 pedantic
= saved_pedantic
;
11405 /* Peek at the next token to figure out which kind of declaration is
11407 token1
= cp_lexer_peek_token (parser
->lexer
);
11409 /* If the next keyword is `asm', we have an asm-definition. */
11410 if (token1
->keyword
== RID_ASM
)
11413 cp_parser_commit_to_tentative_parse (parser
);
11414 cp_parser_asm_definition (parser
);
11416 /* If the next keyword is `namespace', we have a
11417 namespace-alias-definition. */
11418 else if (token1
->keyword
== RID_NAMESPACE
)
11419 cp_parser_namespace_alias_definition (parser
);
11420 /* If the next keyword is `using', we have a
11421 using-declaration, a using-directive, or an alias-declaration. */
11422 else if (token1
->keyword
== RID_USING
)
11427 cp_parser_commit_to_tentative_parse (parser
);
11428 /* If the token after `using' is `namespace', then we have a
11429 using-directive. */
11430 token2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
11431 if (token2
->keyword
== RID_NAMESPACE
)
11432 cp_parser_using_directive (parser
);
11433 /* If the second token after 'using' is '=', then we have an
11434 alias-declaration. */
11435 else if (cxx_dialect
>= cxx11
11436 && token2
->type
== CPP_NAME
11437 && ((cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_EQ
)
11438 || (cp_nth_tokens_can_be_attribute_p (parser
, 3))))
11439 cp_parser_alias_declaration (parser
);
11440 /* Otherwise, it's a using-declaration. */
11442 cp_parser_using_declaration (parser
,
11443 /*access_declaration_p=*/false);
11445 /* If the next keyword is `__label__' we have a misplaced label
11447 else if (token1
->keyword
== RID_LABEL
)
11449 cp_lexer_consume_token (parser
->lexer
);
11450 error_at (token1
->location
, "%<__label__%> not at the beginning of a block");
11451 cp_parser_skip_to_end_of_statement (parser
);
11452 /* If the next token is now a `;', consume it. */
11453 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
11454 cp_lexer_consume_token (parser
->lexer
);
11456 /* If the next token is `static_assert' we have a static assertion. */
11457 else if (token1
->keyword
== RID_STATIC_ASSERT
)
11458 cp_parser_static_assert (parser
, /*member_p=*/false);
11459 /* Anything else must be a simple-declaration. */
11461 cp_parser_simple_declaration (parser
, !statement_p
,
11462 /*maybe_range_for_decl*/NULL
);
11465 /* Parse a simple-declaration.
11467 simple-declaration:
11468 decl-specifier-seq [opt] init-declarator-list [opt] ;
11470 init-declarator-list:
11472 init-declarator-list , init-declarator
11474 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
11475 function-definition as a simple-declaration.
11477 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
11478 parsed declaration if it is an uninitialized single declarator not followed
11479 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
11480 if present, will not be consumed. */
11483 cp_parser_simple_declaration (cp_parser
* parser
,
11484 bool function_definition_allowed_p
,
11485 tree
*maybe_range_for_decl
)
11487 cp_decl_specifier_seq decl_specifiers
;
11488 int declares_class_or_enum
;
11489 bool saw_declarator
;
11490 location_t comma_loc
= UNKNOWN_LOCATION
;
11491 location_t init_loc
= UNKNOWN_LOCATION
;
11493 if (maybe_range_for_decl
)
11494 *maybe_range_for_decl
= NULL_TREE
;
11496 /* Defer access checks until we know what is being declared; the
11497 checks for names appearing in the decl-specifier-seq should be
11498 done as if we were in the scope of the thing being declared. */
11499 push_deferring_access_checks (dk_deferred
);
11501 /* Parse the decl-specifier-seq. We have to keep track of whether
11502 or not the decl-specifier-seq declares a named class or
11503 enumeration type, since that is the only case in which the
11504 init-declarator-list is allowed to be empty.
11508 In a simple-declaration, the optional init-declarator-list can be
11509 omitted only when declaring a class or enumeration, that is when
11510 the decl-specifier-seq contains either a class-specifier, an
11511 elaborated-type-specifier, or an enum-specifier. */
11512 cp_parser_decl_specifier_seq (parser
,
11513 CP_PARSER_FLAGS_OPTIONAL
,
11515 &declares_class_or_enum
);
11516 /* We no longer need to defer access checks. */
11517 stop_deferring_access_checks ();
11519 /* In a block scope, a valid declaration must always have a
11520 decl-specifier-seq. By not trying to parse declarators, we can
11521 resolve the declaration/expression ambiguity more quickly. */
11522 if (!function_definition_allowed_p
11523 && !decl_specifiers
.any_specifiers_p
)
11525 cp_parser_error (parser
, "expected declaration");
11529 /* If the next two tokens are both identifiers, the code is
11530 erroneous. The usual cause of this situation is code like:
11534 where "T" should name a type -- but does not. */
11535 if (!decl_specifiers
.any_type_specifiers_p
11536 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
11538 /* If parsing tentatively, we should commit; we really are
11539 looking at a declaration. */
11540 cp_parser_commit_to_tentative_parse (parser
);
11545 /* If we have seen at least one decl-specifier, and the next token
11546 is not a parenthesis, then we must be looking at a declaration.
11547 (After "int (" we might be looking at a functional cast.) */
11548 if (decl_specifiers
.any_specifiers_p
11549 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
)
11550 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
)
11551 && !cp_parser_error_occurred (parser
))
11552 cp_parser_commit_to_tentative_parse (parser
);
11554 /* Keep going until we hit the `;' at the end of the simple
11556 saw_declarator
= false;
11557 while (cp_lexer_next_token_is_not (parser
->lexer
,
11561 bool function_definition_p
;
11564 if (saw_declarator
)
11566 /* If we are processing next declarator, comma is expected */
11567 token
= cp_lexer_peek_token (parser
->lexer
);
11568 gcc_assert (token
->type
== CPP_COMMA
);
11569 cp_lexer_consume_token (parser
->lexer
);
11570 if (maybe_range_for_decl
)
11572 *maybe_range_for_decl
= error_mark_node
;
11573 if (comma_loc
== UNKNOWN_LOCATION
)
11574 comma_loc
= token
->location
;
11578 saw_declarator
= true;
11580 /* Parse the init-declarator. */
11581 decl
= cp_parser_init_declarator (parser
, &decl_specifiers
,
11583 function_definition_allowed_p
,
11584 /*member_p=*/false,
11585 declares_class_or_enum
,
11586 &function_definition_p
,
11587 maybe_range_for_decl
,
11589 /* If an error occurred while parsing tentatively, exit quickly.
11590 (That usually happens when in the body of a function; each
11591 statement is treated as a declaration-statement until proven
11593 if (cp_parser_error_occurred (parser
))
11595 /* Handle function definitions specially. */
11596 if (function_definition_p
)
11598 /* If the next token is a `,', then we are probably
11599 processing something like:
11603 which is erroneous. */
11604 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
11606 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
11607 error_at (token
->location
,
11609 " declarations and function-definitions is forbidden");
11611 /* Otherwise, we're done with the list of declarators. */
11614 pop_deferring_access_checks ();
11618 if (maybe_range_for_decl
&& *maybe_range_for_decl
== NULL_TREE
)
11619 *maybe_range_for_decl
= decl
;
11620 /* The next token should be either a `,' or a `;'. */
11621 token
= cp_lexer_peek_token (parser
->lexer
);
11622 /* If it's a `,', there are more declarators to come. */
11623 if (token
->type
== CPP_COMMA
)
11624 /* will be consumed next time around */;
11625 /* If it's a `;', we are done. */
11626 else if (token
->type
== CPP_SEMICOLON
|| maybe_range_for_decl
)
11628 /* Anything else is an error. */
11631 /* If we have already issued an error message we don't need
11632 to issue another one. */
11633 if (decl
!= error_mark_node
11634 || cp_parser_uncommitted_to_tentative_parse_p (parser
))
11635 cp_parser_error (parser
, "expected %<,%> or %<;%>");
11636 /* Skip tokens until we reach the end of the statement. */
11637 cp_parser_skip_to_end_of_statement (parser
);
11638 /* If the next token is now a `;', consume it. */
11639 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
11640 cp_lexer_consume_token (parser
->lexer
);
11643 /* After the first time around, a function-definition is not
11644 allowed -- even if it was OK at first. For example:
11649 function_definition_allowed_p
= false;
11652 /* Issue an error message if no declarators are present, and the
11653 decl-specifier-seq does not itself declare a class or
11654 enumeration: [dcl.dcl]/3. */
11655 if (!saw_declarator
)
11657 if (cp_parser_declares_only_class_p (parser
))
11659 if (!declares_class_or_enum
11660 && decl_specifiers
.type
11661 && OVERLOAD_TYPE_P (decl_specifiers
.type
))
11662 /* Ensure an error is issued anyway when finish_decltype_type,
11663 called via cp_parser_decl_specifier_seq, returns a class or
11664 an enumeration (c++/51786). */
11665 decl_specifiers
.type
= NULL_TREE
;
11666 shadow_tag (&decl_specifiers
);
11668 /* Perform any deferred access checks. */
11669 perform_deferred_access_checks (tf_warning_or_error
);
11672 /* Consume the `;'. */
11673 if (!maybe_range_for_decl
)
11674 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11675 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
11677 if (init_loc
!= UNKNOWN_LOCATION
)
11678 error_at (init_loc
, "initializer in range-based %<for%> loop");
11679 if (comma_loc
!= UNKNOWN_LOCATION
)
11680 error_at (comma_loc
,
11681 "multiple declarations in range-based %<for%> loop");
11685 pop_deferring_access_checks ();
11688 /* Parse a decl-specifier-seq.
11690 decl-specifier-seq:
11691 decl-specifier-seq [opt] decl-specifier
11692 decl-specifier attribute-specifier-seq [opt] (C++11)
11695 storage-class-specifier
11706 Set *DECL_SPECS to a representation of the decl-specifier-seq.
11708 The parser flags FLAGS is used to control type-specifier parsing.
11710 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
11713 1: one of the decl-specifiers is an elaborated-type-specifier
11714 (i.e., a type declaration)
11715 2: one of the decl-specifiers is an enum-specifier or a
11716 class-specifier (i.e., a type definition)
11721 cp_parser_decl_specifier_seq (cp_parser
* parser
,
11722 cp_parser_flags flags
,
11723 cp_decl_specifier_seq
*decl_specs
,
11724 int* declares_class_or_enum
)
11726 bool constructor_possible_p
= !parser
->in_declarator_p
;
11727 bool found_decl_spec
= false;
11728 cp_token
*start_token
= NULL
;
11731 /* Clear DECL_SPECS. */
11732 clear_decl_specs (decl_specs
);
11734 /* Assume no class or enumeration type is declared. */
11735 *declares_class_or_enum
= 0;
11737 /* Keep reading specifiers until there are no more to read. */
11740 bool constructor_p
;
11744 /* Peek at the next token. */
11745 token
= cp_lexer_peek_token (parser
->lexer
);
11747 /* Save the first token of the decl spec list for error
11750 start_token
= token
;
11751 /* Handle attributes. */
11752 if (cp_next_tokens_can_be_attribute_p (parser
))
11754 /* Parse the attributes. */
11755 tree attrs
= cp_parser_attributes_opt (parser
);
11757 /* In a sequence of declaration specifiers, c++11 attributes
11758 appertain to the type that precede them. In that case
11761 The attribute-specifier-seq affects the type only for
11762 the declaration it appears in, not other declarations
11763 involving the same type.
11765 But for now let's force the user to position the
11766 attribute either at the beginning of the declaration or
11767 after the declarator-id, which would clearly mean that it
11768 applies to the declarator. */
11769 if (cxx11_attribute_p (attrs
))
11771 if (!found_decl_spec
)
11772 /* The c++11 attribute is at the beginning of the
11773 declaration. It appertains to the entity being
11777 if (decl_specs
->type
&& CLASS_TYPE_P (decl_specs
->type
))
11779 /* This is an attribute following a
11780 class-specifier. */
11781 if (decl_specs
->type_definition_p
)
11782 warn_misplaced_attr_for_class_type (token
->location
,
11788 decl_specs
->std_attributes
11789 = chainon (decl_specs
->std_attributes
,
11791 if (decl_specs
->locations
[ds_std_attribute
] == 0)
11792 decl_specs
->locations
[ds_std_attribute
] = token
->location
;
11798 decl_specs
->attributes
11799 = chainon (decl_specs
->attributes
,
11801 if (decl_specs
->locations
[ds_attribute
] == 0)
11802 decl_specs
->locations
[ds_attribute
] = token
->location
;
11805 /* Assume we will find a decl-specifier keyword. */
11806 found_decl_spec
= true;
11807 /* If the next token is an appropriate keyword, we can simply
11808 add it to the list. */
11809 switch (token
->keyword
)
11815 if (!at_class_scope_p ())
11817 error_at (token
->location
, "%<friend%> used outside of class");
11818 cp_lexer_purge_token (parser
->lexer
);
11823 /* Consume the token. */
11824 cp_lexer_consume_token (parser
->lexer
);
11828 case RID_CONSTEXPR
:
11830 cp_lexer_consume_token (parser
->lexer
);
11833 /* function-specifier:
11840 cp_parser_function_specifier_opt (parser
, decl_specs
);
11847 /* Consume the token. */
11848 cp_lexer_consume_token (parser
->lexer
);
11849 /* A constructor declarator cannot appear in a typedef. */
11850 constructor_possible_p
= false;
11851 /* The "typedef" keyword can only occur in a declaration; we
11852 may as well commit at this point. */
11853 cp_parser_commit_to_tentative_parse (parser
);
11855 if (decl_specs
->storage_class
!= sc_none
)
11856 decl_specs
->conflicting_specifiers_p
= true;
11859 /* storage-class-specifier:
11869 if (cxx_dialect
== cxx98
)
11871 /* Consume the token. */
11872 cp_lexer_consume_token (parser
->lexer
);
11874 /* Complain about `auto' as a storage specifier, if
11875 we're complaining about C++0x compatibility. */
11876 warning_at (token
->location
, OPT_Wc__0x_compat
, "%<auto%>"
11877 " changes meaning in C++11; please remove it");
11879 /* Set the storage class anyway. */
11880 cp_parser_set_storage_class (parser
, decl_specs
, RID_AUTO
,
11884 /* C++0x auto type-specifier. */
11885 found_decl_spec
= false;
11892 /* Consume the token. */
11893 cp_lexer_consume_token (parser
->lexer
);
11894 cp_parser_set_storage_class (parser
, decl_specs
, token
->keyword
,
11898 /* Consume the token. */
11900 cp_lexer_consume_token (parser
->lexer
);
11904 /* We did not yet find a decl-specifier yet. */
11905 found_decl_spec
= false;
11909 if (found_decl_spec
11910 && (flags
& CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR
)
11911 && token
->keyword
!= RID_CONSTEXPR
)
11912 error ("decl-specifier invalid in condition");
11915 set_and_check_decl_spec_loc (decl_specs
, ds
, token
);
11917 /* Constructors are a special case. The `S' in `S()' is not a
11918 decl-specifier; it is the beginning of the declarator. */
11920 = (!found_decl_spec
11921 && constructor_possible_p
11922 && (cp_parser_constructor_declarator_p
11923 (parser
, decl_spec_seq_has_spec_p (decl_specs
, ds_friend
))));
11925 /* If we don't have a DECL_SPEC yet, then we must be looking at
11926 a type-specifier. */
11927 if (!found_decl_spec
&& !constructor_p
)
11929 int decl_spec_declares_class_or_enum
;
11930 bool is_cv_qualifier
;
11934 = cp_parser_type_specifier (parser
, flags
,
11936 /*is_declaration=*/true,
11937 &decl_spec_declares_class_or_enum
,
11939 *declares_class_or_enum
|= decl_spec_declares_class_or_enum
;
11941 /* If this type-specifier referenced a user-defined type
11942 (a typedef, class-name, etc.), then we can't allow any
11943 more such type-specifiers henceforth.
11947 The longest sequence of decl-specifiers that could
11948 possibly be a type name is taken as the
11949 decl-specifier-seq of a declaration. The sequence shall
11950 be self-consistent as described below.
11954 As a general rule, at most one type-specifier is allowed
11955 in the complete decl-specifier-seq of a declaration. The
11956 only exceptions are the following:
11958 -- const or volatile can be combined with any other
11961 -- signed or unsigned can be combined with char, long,
11969 void g (const int Pc);
11971 Here, Pc is *not* part of the decl-specifier seq; it's
11972 the declarator. Therefore, once we see a type-specifier
11973 (other than a cv-qualifier), we forbid any additional
11974 user-defined types. We *do* still allow things like `int
11975 int' to be considered a decl-specifier-seq, and issue the
11976 error message later. */
11977 if (type_spec
&& !is_cv_qualifier
)
11978 flags
|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
;
11979 /* A constructor declarator cannot follow a type-specifier. */
11982 constructor_possible_p
= false;
11983 found_decl_spec
= true;
11984 if (!is_cv_qualifier
)
11985 decl_specs
->any_type_specifiers_p
= true;
11989 /* If we still do not have a DECL_SPEC, then there are no more
11990 decl-specifiers. */
11991 if (!found_decl_spec
)
11994 decl_specs
->any_specifiers_p
= true;
11995 /* After we see one decl-specifier, further decl-specifiers are
11996 always optional. */
11997 flags
|= CP_PARSER_FLAGS_OPTIONAL
;
12000 /* Don't allow a friend specifier with a class definition. */
12001 if (decl_spec_seq_has_spec_p (decl_specs
, ds_friend
)
12002 && (*declares_class_or_enum
& 2))
12003 error_at (decl_specs
->locations
[ds_friend
],
12004 "class definition may not be declared a friend");
12007 /* Parse an (optional) storage-class-specifier.
12009 storage-class-specifier:
12018 storage-class-specifier:
12021 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
12024 cp_parser_storage_class_specifier_opt (cp_parser
* parser
)
12026 switch (cp_lexer_peek_token (parser
->lexer
)->keyword
)
12029 if (cxx_dialect
!= cxx98
)
12031 /* Fall through for C++98. */
12038 /* Consume the token. */
12039 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
12046 /* Parse an (optional) function-specifier.
12048 function-specifier:
12053 Returns an IDENTIFIER_NODE corresponding to the keyword used.
12054 Updates DECL_SPECS, if it is non-NULL. */
12057 cp_parser_function_specifier_opt (cp_parser
* parser
,
12058 cp_decl_specifier_seq
*decl_specs
)
12060 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12061 switch (token
->keyword
)
12064 set_and_check_decl_spec_loc (decl_specs
, ds_inline
, token
);
12068 /* 14.5.2.3 [temp.mem]
12070 A member function template shall not be virtual. */
12071 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
12072 error_at (token
->location
, "templates may not be %<virtual%>");
12074 set_and_check_decl_spec_loc (decl_specs
, ds_virtual
, token
);
12078 set_and_check_decl_spec_loc (decl_specs
, ds_explicit
, token
);
12085 /* Consume the token. */
12086 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
12089 /* Parse a linkage-specification.
12091 linkage-specification:
12092 extern string-literal { declaration-seq [opt] }
12093 extern string-literal declaration */
12096 cp_parser_linkage_specification (cp_parser
* parser
)
12100 /* Look for the `extern' keyword. */
12101 cp_parser_require_keyword (parser
, RID_EXTERN
, RT_EXTERN
);
12103 /* Look for the string-literal. */
12104 linkage
= cp_parser_string_literal (parser
, false, false);
12106 /* Transform the literal into an identifier. If the literal is a
12107 wide-character string, or contains embedded NULs, then we can't
12108 handle it as the user wants. */
12109 if (strlen (TREE_STRING_POINTER (linkage
))
12110 != (size_t) (TREE_STRING_LENGTH (linkage
) - 1))
12112 cp_parser_error (parser
, "invalid linkage-specification");
12113 /* Assume C++ linkage. */
12114 linkage
= lang_name_cplusplus
;
12117 linkage
= get_identifier (TREE_STRING_POINTER (linkage
));
12119 /* We're now using the new linkage. */
12120 push_lang_context (linkage
);
12122 /* If the next token is a `{', then we're using the first
12124 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
12126 cp_ensure_no_omp_declare_simd (parser
);
12128 /* Consume the `{' token. */
12129 cp_lexer_consume_token (parser
->lexer
);
12130 /* Parse the declarations. */
12131 cp_parser_declaration_seq_opt (parser
);
12132 /* Look for the closing `}'. */
12133 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
12135 /* Otherwise, there's just one declaration. */
12138 bool saved_in_unbraced_linkage_specification_p
;
12140 saved_in_unbraced_linkage_specification_p
12141 = parser
->in_unbraced_linkage_specification_p
;
12142 parser
->in_unbraced_linkage_specification_p
= true;
12143 cp_parser_declaration (parser
);
12144 parser
->in_unbraced_linkage_specification_p
12145 = saved_in_unbraced_linkage_specification_p
;
12148 /* We're done with the linkage-specification. */
12149 pop_lang_context ();
12152 /* Parse a static_assert-declaration.
12154 static_assert-declaration:
12155 static_assert ( constant-expression , string-literal ) ;
12157 If MEMBER_P, this static_assert is a class member. */
12160 cp_parser_static_assert(cp_parser
*parser
, bool member_p
)
12165 location_t saved_loc
;
12168 /* Peek at the `static_assert' token so we can keep track of exactly
12169 where the static assertion started. */
12170 token
= cp_lexer_peek_token (parser
->lexer
);
12171 saved_loc
= token
->location
;
12173 /* Look for the `static_assert' keyword. */
12174 if (!cp_parser_require_keyword (parser
, RID_STATIC_ASSERT
,
12178 /* We know we are in a static assertion; commit to any tentative
12180 if (cp_parser_parsing_tentatively (parser
))
12181 cp_parser_commit_to_tentative_parse (parser
);
12183 /* Parse the `(' starting the static assertion condition. */
12184 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
12186 /* Parse the constant-expression. Allow a non-constant expression
12187 here in order to give better diagnostics in finish_static_assert. */
12189 cp_parser_constant_expression (parser
,
12190 /*allow_non_constant_p=*/true,
12191 /*non_constant_p=*/&dummy
);
12193 /* Parse the separating `,'. */
12194 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
12196 /* Parse the string-literal message. */
12197 message
= cp_parser_string_literal (parser
,
12198 /*translate=*/false,
12201 /* A `)' completes the static assertion. */
12202 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
12203 cp_parser_skip_to_closing_parenthesis (parser
,
12204 /*recovering=*/true,
12205 /*or_comma=*/false,
12206 /*consume_paren=*/true);
12208 /* A semicolon terminates the declaration. */
12209 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
12211 /* Complete the static assertion, which may mean either processing
12212 the static assert now or saving it for template instantiation. */
12213 finish_static_assert (condition
, message
, saved_loc
, member_p
);
12216 /* Parse the expression in decltype ( expression ). */
12219 cp_parser_decltype_expr (cp_parser
*parser
,
12220 bool &id_expression_or_member_access_p
)
12222 cp_token
*id_expr_start_token
;
12225 /* First, try parsing an id-expression. */
12226 id_expr_start_token
= cp_lexer_peek_token (parser
->lexer
);
12227 cp_parser_parse_tentatively (parser
);
12228 expr
= cp_parser_id_expression (parser
,
12229 /*template_keyword_p=*/false,
12230 /*check_dependency_p=*/true,
12231 /*template_p=*/NULL
,
12232 /*declarator_p=*/false,
12233 /*optional_p=*/false);
12235 if (!cp_parser_error_occurred (parser
) && expr
!= error_mark_node
)
12237 bool non_integral_constant_expression_p
= false;
12238 tree id_expression
= expr
;
12240 const char *error_msg
;
12242 if (identifier_p (expr
))
12243 /* Lookup the name we got back from the id-expression. */
12244 expr
= cp_parser_lookup_name_simple (parser
, expr
,
12245 id_expr_start_token
->location
);
12248 && expr
!= error_mark_node
12249 && TREE_CODE (expr
) != TYPE_DECL
12250 && (TREE_CODE (expr
) != BIT_NOT_EXPR
12251 || !TYPE_P (TREE_OPERAND (expr
, 0)))
12252 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
12254 /* Complete lookup of the id-expression. */
12255 expr
= (finish_id_expression
12256 (id_expression
, expr
, parser
->scope
, &idk
,
12257 /*integral_constant_expression_p=*/false,
12258 /*allow_non_integral_constant_expression_p=*/true,
12259 &non_integral_constant_expression_p
,
12260 /*template_p=*/false,
12262 /*address_p=*/false,
12263 /*template_arg_p=*/false,
12265 id_expr_start_token
->location
));
12267 if (expr
== error_mark_node
)
12268 /* We found an id-expression, but it was something that we
12269 should not have found. This is an error, not something
12270 we can recover from, so note that we found an
12271 id-expression and we'll recover as gracefully as
12273 id_expression_or_member_access_p
= true;
12277 && expr
!= error_mark_node
12278 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
12279 /* We have an id-expression. */
12280 id_expression_or_member_access_p
= true;
12283 if (!id_expression_or_member_access_p
)
12285 /* Abort the id-expression parse. */
12286 cp_parser_abort_tentative_parse (parser
);
12288 /* Parsing tentatively, again. */
12289 cp_parser_parse_tentatively (parser
);
12291 /* Parse a class member access. */
12292 expr
= cp_parser_postfix_expression (parser
, /*address_p=*/false,
12293 /*cast_p=*/false, /*decltype*/true,
12294 /*member_access_only_p=*/true, NULL
);
12297 && expr
!= error_mark_node
12298 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
12299 /* We have an id-expression. */
12300 id_expression_or_member_access_p
= true;
12303 if (id_expression_or_member_access_p
)
12304 /* We have parsed the complete id-expression or member access. */
12305 cp_parser_parse_definitely (parser
);
12308 /* Abort our attempt to parse an id-expression or member access
12310 cp_parser_abort_tentative_parse (parser
);
12312 /* Parse a full expression. */
12313 expr
= cp_parser_expression (parser
, /*pidk=*/NULL
, /*cast_p=*/false,
12314 /*decltype_p=*/true);
12320 /* Parse a `decltype' type. Returns the type.
12322 simple-type-specifier:
12323 decltype ( expression )
12325 decltype ( auto ) */
12328 cp_parser_decltype (cp_parser
*parser
)
12331 bool id_expression_or_member_access_p
= false;
12332 const char *saved_message
;
12333 bool saved_integral_constant_expression_p
;
12334 bool saved_non_integral_constant_expression_p
;
12335 bool saved_greater_than_is_operator_p
;
12336 cp_token
*start_token
= cp_lexer_peek_token (parser
->lexer
);
12338 if (start_token
->type
== CPP_DECLTYPE
)
12340 /* Already parsed. */
12341 cp_lexer_consume_token (parser
->lexer
);
12342 return start_token
->u
.value
;
12345 /* Look for the `decltype' token. */
12346 if (!cp_parser_require_keyword (parser
, RID_DECLTYPE
, RT_DECLTYPE
))
12347 return error_mark_node
;
12349 /* Parse the opening `('. */
12350 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
12351 return error_mark_node
;
12353 /* decltype (auto) */
12354 if (cxx_dialect
>= cxx14
12355 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AUTO
))
12357 cp_lexer_consume_token (parser
->lexer
);
12358 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
12359 return error_mark_node
;
12360 expr
= make_decltype_auto ();
12361 AUTO_IS_DECLTYPE (expr
) = true;
12365 /* Types cannot be defined in a `decltype' expression. Save away the
12367 saved_message
= parser
->type_definition_forbidden_message
;
12369 /* And create the new one. */
12370 parser
->type_definition_forbidden_message
12371 = G_("types may not be defined in %<decltype%> expressions");
12373 /* The restrictions on constant-expressions do not apply inside
12374 decltype expressions. */
12375 saved_integral_constant_expression_p
12376 = parser
->integral_constant_expression_p
;
12377 saved_non_integral_constant_expression_p
12378 = parser
->non_integral_constant_expression_p
;
12379 parser
->integral_constant_expression_p
= false;
12381 /* Within a parenthesized expression, a `>' token is always
12382 the greater-than operator. */
12383 saved_greater_than_is_operator_p
12384 = parser
->greater_than_is_operator_p
;
12385 parser
->greater_than_is_operator_p
= true;
12387 /* Do not actually evaluate the expression. */
12388 ++cp_unevaluated_operand
;
12390 /* Do not warn about problems with the expression. */
12391 ++c_inhibit_evaluation_warnings
;
12393 expr
= cp_parser_decltype_expr (parser
, id_expression_or_member_access_p
);
12395 /* Go back to evaluating expressions. */
12396 --cp_unevaluated_operand
;
12397 --c_inhibit_evaluation_warnings
;
12399 /* The `>' token might be the end of a template-id or
12400 template-parameter-list now. */
12401 parser
->greater_than_is_operator_p
12402 = saved_greater_than_is_operator_p
;
12404 /* Restore the old message and the integral constant expression
12406 parser
->type_definition_forbidden_message
= saved_message
;
12407 parser
->integral_constant_expression_p
12408 = saved_integral_constant_expression_p
;
12409 parser
->non_integral_constant_expression_p
12410 = saved_non_integral_constant_expression_p
;
12412 /* Parse to the closing `)'. */
12413 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
12415 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
12416 /*consume_paren=*/true);
12417 return error_mark_node
;
12420 expr
= finish_decltype_type (expr
, id_expression_or_member_access_p
,
12421 tf_warning_or_error
);
12424 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
12426 start_token
->type
= CPP_DECLTYPE
;
12427 start_token
->u
.value
= expr
;
12428 start_token
->keyword
= RID_MAX
;
12429 cp_lexer_purge_tokens_after (parser
->lexer
, start_token
);
12434 /* Special member functions [gram.special] */
12436 /* Parse a conversion-function-id.
12438 conversion-function-id:
12439 operator conversion-type-id
12441 Returns an IDENTIFIER_NODE representing the operator. */
12444 cp_parser_conversion_function_id (cp_parser
* parser
)
12448 tree saved_qualifying_scope
;
12449 tree saved_object_scope
;
12450 tree pushed_scope
= NULL_TREE
;
12452 /* Look for the `operator' token. */
12453 if (!cp_parser_require_keyword (parser
, RID_OPERATOR
, RT_OPERATOR
))
12454 return error_mark_node
;
12455 /* When we parse the conversion-type-id, the current scope will be
12456 reset. However, we need that information in able to look up the
12457 conversion function later, so we save it here. */
12458 saved_scope
= parser
->scope
;
12459 saved_qualifying_scope
= parser
->qualifying_scope
;
12460 saved_object_scope
= parser
->object_scope
;
12461 /* We must enter the scope of the class so that the names of
12462 entities declared within the class are available in the
12463 conversion-type-id. For example, consider:
12470 S::operator I() { ... }
12472 In order to see that `I' is a type-name in the definition, we
12473 must be in the scope of `S'. */
12475 pushed_scope
= push_scope (saved_scope
);
12476 /* Parse the conversion-type-id. */
12477 type
= cp_parser_conversion_type_id (parser
);
12478 /* Leave the scope of the class, if any. */
12480 pop_scope (pushed_scope
);
12481 /* Restore the saved scope. */
12482 parser
->scope
= saved_scope
;
12483 parser
->qualifying_scope
= saved_qualifying_scope
;
12484 parser
->object_scope
= saved_object_scope
;
12485 /* If the TYPE is invalid, indicate failure. */
12486 if (type
== error_mark_node
)
12487 return error_mark_node
;
12488 return mangle_conv_op_name_for_type (type
);
12491 /* Parse a conversion-type-id:
12493 conversion-type-id:
12494 type-specifier-seq conversion-declarator [opt]
12496 Returns the TYPE specified. */
12499 cp_parser_conversion_type_id (cp_parser
* parser
)
12502 cp_decl_specifier_seq type_specifiers
;
12503 cp_declarator
*declarator
;
12504 tree type_specified
;
12505 const char *saved_message
;
12507 /* Parse the attributes. */
12508 attributes
= cp_parser_attributes_opt (parser
);
12510 saved_message
= parser
->type_definition_forbidden_message
;
12511 parser
->type_definition_forbidden_message
12512 = G_("types may not be defined in a conversion-type-id");
12514 /* Parse the type-specifiers. */
12515 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
12516 /*is_trailing_return=*/false,
12519 parser
->type_definition_forbidden_message
= saved_message
;
12521 /* If that didn't work, stop. */
12522 if (type_specifiers
.type
== error_mark_node
)
12523 return error_mark_node
;
12524 /* Parse the conversion-declarator. */
12525 declarator
= cp_parser_conversion_declarator_opt (parser
);
12527 type_specified
= grokdeclarator (declarator
, &type_specifiers
, TYPENAME
,
12528 /*initialized=*/0, &attributes
);
12530 cplus_decl_attributes (&type_specified
, attributes
, /*flags=*/0);
12532 /* Don't give this error when parsing tentatively. This happens to
12533 work because we always parse this definitively once. */
12534 if (! cp_parser_uncommitted_to_tentative_parse_p (parser
)
12535 && type_uses_auto (type_specified
))
12537 if (cxx_dialect
< cxx14
)
12539 error ("invalid use of %<auto%> in conversion operator");
12540 return error_mark_node
;
12542 else if (template_parm_scope_p ())
12543 warning (0, "use of %<auto%> in member template "
12544 "conversion operator can never be deduced");
12547 return type_specified
;
12550 /* Parse an (optional) conversion-declarator.
12552 conversion-declarator:
12553 ptr-operator conversion-declarator [opt]
12557 static cp_declarator
*
12558 cp_parser_conversion_declarator_opt (cp_parser
* parser
)
12560 enum tree_code code
;
12561 tree class_type
, std_attributes
= NULL_TREE
;
12562 cp_cv_quals cv_quals
;
12564 /* We don't know if there's a ptr-operator next, or not. */
12565 cp_parser_parse_tentatively (parser
);
12566 /* Try the ptr-operator. */
12567 code
= cp_parser_ptr_operator (parser
, &class_type
, &cv_quals
,
12569 /* If it worked, look for more conversion-declarators. */
12570 if (cp_parser_parse_definitely (parser
))
12572 cp_declarator
*declarator
;
12574 /* Parse another optional declarator. */
12575 declarator
= cp_parser_conversion_declarator_opt (parser
);
12577 declarator
= cp_parser_make_indirect_declarator
12578 (code
, class_type
, cv_quals
, declarator
, std_attributes
);
12586 /* Parse an (optional) ctor-initializer.
12589 : mem-initializer-list
12591 Returns TRUE iff the ctor-initializer was actually present. */
12594 cp_parser_ctor_initializer_opt (cp_parser
* parser
)
12596 /* If the next token is not a `:', then there is no
12597 ctor-initializer. */
12598 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
12600 /* Do default initialization of any bases and members. */
12601 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12602 finish_mem_initializers (NULL_TREE
);
12607 /* Consume the `:' token. */
12608 cp_lexer_consume_token (parser
->lexer
);
12609 /* And the mem-initializer-list. */
12610 cp_parser_mem_initializer_list (parser
);
12615 /* Parse a mem-initializer-list.
12617 mem-initializer-list:
12618 mem-initializer ... [opt]
12619 mem-initializer ... [opt] , mem-initializer-list */
12622 cp_parser_mem_initializer_list (cp_parser
* parser
)
12624 tree mem_initializer_list
= NULL_TREE
;
12625 tree target_ctor
= error_mark_node
;
12626 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12628 /* Let the semantic analysis code know that we are starting the
12629 mem-initializer-list. */
12630 if (!DECL_CONSTRUCTOR_P (current_function_decl
))
12631 error_at (token
->location
,
12632 "only constructors take member initializers");
12634 /* Loop through the list. */
12637 tree mem_initializer
;
12639 token
= cp_lexer_peek_token (parser
->lexer
);
12640 /* Parse the mem-initializer. */
12641 mem_initializer
= cp_parser_mem_initializer (parser
);
12642 /* If the next token is a `...', we're expanding member initializers. */
12643 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
12645 /* Consume the `...'. */
12646 cp_lexer_consume_token (parser
->lexer
);
12648 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
12649 can be expanded but members cannot. */
12650 if (mem_initializer
!= error_mark_node
12651 && !TYPE_P (TREE_PURPOSE (mem_initializer
)))
12653 error_at (token
->location
,
12654 "cannot expand initializer for member %<%D%>",
12655 TREE_PURPOSE (mem_initializer
));
12656 mem_initializer
= error_mark_node
;
12659 /* Construct the pack expansion type. */
12660 if (mem_initializer
!= error_mark_node
)
12661 mem_initializer
= make_pack_expansion (mem_initializer
);
12663 if (target_ctor
!= error_mark_node
12664 && mem_initializer
!= error_mark_node
)
12666 error ("mem-initializer for %qD follows constructor delegation",
12667 TREE_PURPOSE (mem_initializer
));
12668 mem_initializer
= error_mark_node
;
12670 /* Look for a target constructor. */
12671 if (mem_initializer
!= error_mark_node
12672 && CLASS_TYPE_P (TREE_PURPOSE (mem_initializer
))
12673 && same_type_p (TREE_PURPOSE (mem_initializer
), current_class_type
))
12675 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS
);
12676 if (mem_initializer_list
)
12678 error ("constructor delegation follows mem-initializer for %qD",
12679 TREE_PURPOSE (mem_initializer_list
));
12680 mem_initializer
= error_mark_node
;
12682 target_ctor
= mem_initializer
;
12684 /* Add it to the list, unless it was erroneous. */
12685 if (mem_initializer
!= error_mark_node
)
12687 TREE_CHAIN (mem_initializer
) = mem_initializer_list
;
12688 mem_initializer_list
= mem_initializer
;
12690 /* If the next token is not a `,', we're done. */
12691 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
12693 /* Consume the `,' token. */
12694 cp_lexer_consume_token (parser
->lexer
);
12697 /* Perform semantic analysis. */
12698 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12699 finish_mem_initializers (mem_initializer_list
);
12702 /* Parse a mem-initializer.
12705 mem-initializer-id ( expression-list [opt] )
12706 mem-initializer-id braced-init-list
12711 ( expression-list [opt] )
12713 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
12714 class) or FIELD_DECL (for a non-static data member) to initialize;
12715 the TREE_VALUE is the expression-list. An empty initialization
12716 list is represented by void_list_node. */
12719 cp_parser_mem_initializer (cp_parser
* parser
)
12721 tree mem_initializer_id
;
12722 tree expression_list
;
12724 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12726 /* Find out what is being initialized. */
12727 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
12729 permerror (token
->location
,
12730 "anachronistic old-style base class initializer");
12731 mem_initializer_id
= NULL_TREE
;
12735 mem_initializer_id
= cp_parser_mem_initializer_id (parser
);
12736 if (mem_initializer_id
== error_mark_node
)
12737 return mem_initializer_id
;
12739 member
= expand_member_init (mem_initializer_id
);
12740 if (member
&& !DECL_P (member
))
12741 in_base_initializer
= 1;
12743 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
12745 bool expr_non_constant_p
;
12746 cp_lexer_set_source_position (parser
->lexer
);
12747 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
12748 expression_list
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
12749 CONSTRUCTOR_IS_DIRECT_INIT (expression_list
) = 1;
12750 expression_list
= build_tree_list (NULL_TREE
, expression_list
);
12754 vec
<tree
, va_gc
> *vec
;
12755 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
12757 /*allow_expansion_p=*/true,
12758 /*non_constant_p=*/NULL
);
12760 return error_mark_node
;
12761 expression_list
= build_tree_list_vec (vec
);
12762 release_tree_vector (vec
);
12765 if (expression_list
== error_mark_node
)
12766 return error_mark_node
;
12767 if (!expression_list
)
12768 expression_list
= void_type_node
;
12770 in_base_initializer
= 0;
12772 return member
? build_tree_list (member
, expression_list
) : error_mark_node
;
12775 /* Parse a mem-initializer-id.
12777 mem-initializer-id:
12778 :: [opt] nested-name-specifier [opt] class-name
12781 Returns a TYPE indicating the class to be initializer for the first
12782 production. Returns an IDENTIFIER_NODE indicating the data member
12783 to be initialized for the second production. */
12786 cp_parser_mem_initializer_id (cp_parser
* parser
)
12788 bool global_scope_p
;
12789 bool nested_name_specifier_p
;
12790 bool template_p
= false;
12793 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12795 /* `typename' is not allowed in this context ([temp.res]). */
12796 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TYPENAME
))
12798 error_at (token
->location
,
12799 "keyword %<typename%> not allowed in this context (a qualified "
12800 "member initializer is implicitly a type)");
12801 cp_lexer_consume_token (parser
->lexer
);
12803 /* Look for the optional `::' operator. */
12805 = (cp_parser_global_scope_opt (parser
,
12806 /*current_scope_valid_p=*/false)
12808 /* Look for the optional nested-name-specifier. The simplest way to
12813 The keyword `typename' is not permitted in a base-specifier or
12814 mem-initializer; in these contexts a qualified name that
12815 depends on a template-parameter is implicitly assumed to be a
12818 is to assume that we have seen the `typename' keyword at this
12820 nested_name_specifier_p
12821 = (cp_parser_nested_name_specifier_opt (parser
,
12822 /*typename_keyword_p=*/true,
12823 /*check_dependency_p=*/true,
12825 /*is_declaration=*/true)
12827 if (nested_name_specifier_p
)
12828 template_p
= cp_parser_optional_template_keyword (parser
);
12829 /* If there is a `::' operator or a nested-name-specifier, then we
12830 are definitely looking for a class-name. */
12831 if (global_scope_p
|| nested_name_specifier_p
)
12832 return cp_parser_class_name (parser
,
12833 /*typename_keyword_p=*/true,
12834 /*template_keyword_p=*/template_p
,
12836 /*check_dependency_p=*/true,
12837 /*class_head_p=*/false,
12838 /*is_declaration=*/true);
12839 /* Otherwise, we could also be looking for an ordinary identifier. */
12840 cp_parser_parse_tentatively (parser
);
12841 /* Try a class-name. */
12842 id
= cp_parser_class_name (parser
,
12843 /*typename_keyword_p=*/true,
12844 /*template_keyword_p=*/false,
12846 /*check_dependency_p=*/true,
12847 /*class_head_p=*/false,
12848 /*is_declaration=*/true);
12849 /* If we found one, we're done. */
12850 if (cp_parser_parse_definitely (parser
))
12852 /* Otherwise, look for an ordinary identifier. */
12853 return cp_parser_identifier (parser
);
12856 /* Overloading [gram.over] */
12858 /* Parse an operator-function-id.
12860 operator-function-id:
12863 Returns an IDENTIFIER_NODE for the operator which is a
12864 human-readable spelling of the identifier, e.g., `operator +'. */
12867 cp_parser_operator_function_id (cp_parser
* parser
)
12869 /* Look for the `operator' keyword. */
12870 if (!cp_parser_require_keyword (parser
, RID_OPERATOR
, RT_OPERATOR
))
12871 return error_mark_node
;
12872 /* And then the name of the operator itself. */
12873 return cp_parser_operator (parser
);
12876 /* Return an identifier node for a user-defined literal operator.
12877 The suffix identifier is chained to the operator name identifier. */
12880 cp_literal_operator_id (const char* name
)
12883 char *buffer
= XNEWVEC (char, strlen (UDLIT_OP_ANSI_PREFIX
)
12884 + strlen (name
) + 10);
12885 sprintf (buffer
, UDLIT_OP_ANSI_FORMAT
, name
);
12886 identifier
= get_identifier (buffer
);
12891 /* Parse an operator.
12894 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
12895 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
12896 || ++ -- , ->* -> () []
12903 Returns an IDENTIFIER_NODE for the operator which is a
12904 human-readable spelling of the identifier, e.g., `operator +'. */
12907 cp_parser_operator (cp_parser
* parser
)
12909 tree id
= NULL_TREE
;
12913 /* Peek at the next token. */
12914 token
= cp_lexer_peek_token (parser
->lexer
);
12915 /* Figure out which operator we have. */
12916 switch (token
->type
)
12922 /* The keyword should be either `new' or `delete'. */
12923 if (token
->keyword
== RID_NEW
)
12925 else if (token
->keyword
== RID_DELETE
)
12930 /* Consume the `new' or `delete' token. */
12931 cp_lexer_consume_token (parser
->lexer
);
12933 /* Peek at the next token. */
12934 token
= cp_lexer_peek_token (parser
->lexer
);
12935 /* If it's a `[' token then this is the array variant of the
12937 if (token
->type
== CPP_OPEN_SQUARE
)
12939 /* Consume the `[' token. */
12940 cp_lexer_consume_token (parser
->lexer
);
12941 /* Look for the `]' token. */
12942 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
12943 id
= ansi_opname (op
== NEW_EXPR
12944 ? VEC_NEW_EXPR
: VEC_DELETE_EXPR
);
12946 /* Otherwise, we have the non-array variant. */
12948 id
= ansi_opname (op
);
12954 id
= ansi_opname (PLUS_EXPR
);
12958 id
= ansi_opname (MINUS_EXPR
);
12962 id
= ansi_opname (MULT_EXPR
);
12966 id
= ansi_opname (TRUNC_DIV_EXPR
);
12970 id
= ansi_opname (TRUNC_MOD_EXPR
);
12974 id
= ansi_opname (BIT_XOR_EXPR
);
12978 id
= ansi_opname (BIT_AND_EXPR
);
12982 id
= ansi_opname (BIT_IOR_EXPR
);
12986 id
= ansi_opname (BIT_NOT_EXPR
);
12990 id
= ansi_opname (TRUTH_NOT_EXPR
);
12994 id
= ansi_assopname (NOP_EXPR
);
12998 id
= ansi_opname (LT_EXPR
);
13002 id
= ansi_opname (GT_EXPR
);
13006 id
= ansi_assopname (PLUS_EXPR
);
13010 id
= ansi_assopname (MINUS_EXPR
);
13014 id
= ansi_assopname (MULT_EXPR
);
13018 id
= ansi_assopname (TRUNC_DIV_EXPR
);
13022 id
= ansi_assopname (TRUNC_MOD_EXPR
);
13026 id
= ansi_assopname (BIT_XOR_EXPR
);
13030 id
= ansi_assopname (BIT_AND_EXPR
);
13034 id
= ansi_assopname (BIT_IOR_EXPR
);
13038 id
= ansi_opname (LSHIFT_EXPR
);
13042 id
= ansi_opname (RSHIFT_EXPR
);
13045 case CPP_LSHIFT_EQ
:
13046 id
= ansi_assopname (LSHIFT_EXPR
);
13049 case CPP_RSHIFT_EQ
:
13050 id
= ansi_assopname (RSHIFT_EXPR
);
13054 id
= ansi_opname (EQ_EXPR
);
13058 id
= ansi_opname (NE_EXPR
);
13062 id
= ansi_opname (LE_EXPR
);
13065 case CPP_GREATER_EQ
:
13066 id
= ansi_opname (GE_EXPR
);
13070 id
= ansi_opname (TRUTH_ANDIF_EXPR
);
13074 id
= ansi_opname (TRUTH_ORIF_EXPR
);
13077 case CPP_PLUS_PLUS
:
13078 id
= ansi_opname (POSTINCREMENT_EXPR
);
13081 case CPP_MINUS_MINUS
:
13082 id
= ansi_opname (PREDECREMENT_EXPR
);
13086 id
= ansi_opname (COMPOUND_EXPR
);
13089 case CPP_DEREF_STAR
:
13090 id
= ansi_opname (MEMBER_REF
);
13094 id
= ansi_opname (COMPONENT_REF
);
13097 case CPP_OPEN_PAREN
:
13098 /* Consume the `('. */
13099 cp_lexer_consume_token (parser
->lexer
);
13100 /* Look for the matching `)'. */
13101 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
13102 return ansi_opname (CALL_EXPR
);
13104 case CPP_OPEN_SQUARE
:
13105 /* Consume the `['. */
13106 cp_lexer_consume_token (parser
->lexer
);
13107 /* Look for the matching `]'. */
13108 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
13109 return ansi_opname (ARRAY_REF
);
13111 case CPP_UTF8STRING
:
13112 case CPP_UTF8STRING_USERDEF
:
13118 case CPP_STRING_USERDEF
:
13119 case CPP_WSTRING_USERDEF
:
13120 case CPP_STRING16_USERDEF
:
13121 case CPP_STRING32_USERDEF
:
13123 tree str
, string_tree
;
13126 if (cxx_dialect
== cxx98
)
13127 maybe_warn_cpp0x (CPP0X_USER_DEFINED_LITERALS
);
13129 /* Consume the string. */
13130 str
= cp_parser_string_literal (parser
, /*translate=*/true,
13131 /*wide_ok=*/true, /*lookup_udlit=*/false);
13132 if (str
== error_mark_node
)
13133 return error_mark_node
;
13134 else if (TREE_CODE (str
) == USERDEF_LITERAL
)
13136 string_tree
= USERDEF_LITERAL_VALUE (str
);
13137 id
= USERDEF_LITERAL_SUFFIX_ID (str
);
13142 /* Look for the suffix identifier. */
13143 token
= cp_lexer_peek_token (parser
->lexer
);
13144 if (token
->type
== CPP_NAME
)
13145 id
= cp_parser_identifier (parser
);
13146 else if (token
->type
== CPP_KEYWORD
)
13148 error ("unexpected keyword;"
13149 " remove space between quotes and suffix identifier");
13150 return error_mark_node
;
13154 error ("expected suffix identifier");
13155 return error_mark_node
;
13158 sz
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT
13159 (TREE_TYPE (TREE_TYPE (string_tree
))));
13160 len
= TREE_STRING_LENGTH (string_tree
) / sz
- 1;
13163 error ("expected empty string after %<operator%> keyword");
13164 return error_mark_node
;
13166 if (utf8
|| TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string_tree
)))
13169 error ("invalid encoding prefix in literal operator");
13170 return error_mark_node
;
13172 if (id
!= error_mark_node
)
13174 const char *name
= IDENTIFIER_POINTER (id
);
13175 id
= cp_literal_operator_id (name
);
13181 /* Anything else is an error. */
13185 /* If we have selected an identifier, we need to consume the
13188 cp_lexer_consume_token (parser
->lexer
);
13189 /* Otherwise, no valid operator name was present. */
13192 cp_parser_error (parser
, "expected operator");
13193 id
= error_mark_node
;
13199 /* Parse a template-declaration.
13201 template-declaration:
13202 export [opt] template < template-parameter-list > declaration
13204 If MEMBER_P is TRUE, this template-declaration occurs within a
13207 The grammar rule given by the standard isn't correct. What
13208 is really meant is:
13210 template-declaration:
13211 export [opt] template-parameter-list-seq
13212 decl-specifier-seq [opt] init-declarator [opt] ;
13213 export [opt] template-parameter-list-seq
13214 function-definition
13216 template-parameter-list-seq:
13217 template-parameter-list-seq [opt]
13218 template < template-parameter-list > */
13221 cp_parser_template_declaration (cp_parser
* parser
, bool member_p
)
13223 /* Check for `export'. */
13224 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_EXPORT
))
13226 /* Consume the `export' token. */
13227 cp_lexer_consume_token (parser
->lexer
);
13228 /* Warn that we do not support `export'. */
13229 warning (0, "keyword %<export%> not implemented, and will be ignored");
13232 cp_parser_template_declaration_after_export (parser
, member_p
);
13235 /* Parse a template-parameter-list.
13237 template-parameter-list:
13239 template-parameter-list , template-parameter
13241 Returns a TREE_LIST. Each node represents a template parameter.
13242 The nodes are connected via their TREE_CHAINs. */
13245 cp_parser_template_parameter_list (cp_parser
* parser
)
13247 tree parameter_list
= NULL_TREE
;
13249 begin_template_parm_list ();
13251 /* The loop below parses the template parms. We first need to know
13252 the total number of template parms to be able to compute proper
13253 canonical types of each dependent type. So after the loop, when
13254 we know the total number of template parms,
13255 end_template_parm_list computes the proper canonical types and
13256 fixes up the dependent types accordingly. */
13261 bool is_parameter_pack
;
13262 location_t parm_loc
;
13264 /* Parse the template-parameter. */
13265 parm_loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
13266 parameter
= cp_parser_template_parameter (parser
,
13268 &is_parameter_pack
);
13269 /* Add it to the list. */
13270 if (parameter
!= error_mark_node
)
13271 parameter_list
= process_template_parm (parameter_list
,
13275 is_parameter_pack
);
13278 tree err_parm
= build_tree_list (parameter
, parameter
);
13279 parameter_list
= chainon (parameter_list
, err_parm
);
13282 /* If the next token is not a `,', we're done. */
13283 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
13285 /* Otherwise, consume the `,' token. */
13286 cp_lexer_consume_token (parser
->lexer
);
13289 return end_template_parm_list (parameter_list
);
13292 /* Parse a template-parameter.
13294 template-parameter:
13296 parameter-declaration
13298 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
13299 the parameter. The TREE_PURPOSE is the default value, if any.
13300 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
13301 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
13302 set to true iff this parameter is a parameter pack. */
13305 cp_parser_template_parameter (cp_parser
* parser
, bool *is_non_type
,
13306 bool *is_parameter_pack
)
13309 cp_parameter_declarator
*parameter_declarator
;
13310 cp_declarator
*id_declarator
;
13313 /* Assume it is a type parameter or a template parameter. */
13314 *is_non_type
= false;
13315 /* Assume it not a parameter pack. */
13316 *is_parameter_pack
= false;
13317 /* Peek at the next token. */
13318 token
= cp_lexer_peek_token (parser
->lexer
);
13319 /* If it is `class' or `template', we have a type-parameter. */
13320 if (token
->keyword
== RID_TEMPLATE
)
13321 return cp_parser_type_parameter (parser
, is_parameter_pack
);
13322 /* If it is `class' or `typename' we do not know yet whether it is a
13323 type parameter or a non-type parameter. Consider:
13325 template <typename T, typename T::X X> ...
13329 template <class C, class D*> ...
13331 Here, the first parameter is a type parameter, and the second is
13332 a non-type parameter. We can tell by looking at the token after
13333 the identifier -- if it is a `,', `=', or `>' then we have a type
13335 if (token
->keyword
== RID_TYPENAME
|| token
->keyword
== RID_CLASS
)
13337 /* Peek at the token after `class' or `typename'. */
13338 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
13339 /* If it's an ellipsis, we have a template type parameter
13341 if (token
->type
== CPP_ELLIPSIS
)
13342 return cp_parser_type_parameter (parser
, is_parameter_pack
);
13343 /* If it's an identifier, skip it. */
13344 if (token
->type
== CPP_NAME
)
13345 token
= cp_lexer_peek_nth_token (parser
->lexer
, 3);
13346 /* Now, see if the token looks like the end of a template
13348 if (token
->type
== CPP_COMMA
13349 || token
->type
== CPP_EQ
13350 || token
->type
== CPP_GREATER
)
13351 return cp_parser_type_parameter (parser
, is_parameter_pack
);
13354 /* Otherwise, it is a non-type parameter.
13358 When parsing a default template-argument for a non-type
13359 template-parameter, the first non-nested `>' is taken as the end
13360 of the template parameter-list rather than a greater-than
13362 *is_non_type
= true;
13363 parameter_declarator
13364 = cp_parser_parameter_declaration (parser
, /*template_parm_p=*/true,
13365 /*parenthesized_p=*/NULL
);
13367 if (!parameter_declarator
)
13368 return error_mark_node
;
13370 /* If the parameter declaration is marked as a parameter pack, set
13371 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
13372 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
13374 if (parameter_declarator
->declarator
13375 && parameter_declarator
->declarator
->parameter_pack_p
)
13377 *is_parameter_pack
= true;
13378 parameter_declarator
->declarator
->parameter_pack_p
= false;
13381 if (parameter_declarator
->default_argument
)
13383 /* Can happen in some cases of erroneous input (c++/34892). */
13384 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
13385 /* Consume the `...' for better error recovery. */
13386 cp_lexer_consume_token (parser
->lexer
);
13388 /* If the next token is an ellipsis, and we don't already have it
13389 marked as a parameter pack, then we have a parameter pack (that
13390 has no declarator). */
13391 else if (!*is_parameter_pack
13392 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
)
13393 && (declarator_can_be_parameter_pack
13394 (parameter_declarator
->declarator
)))
13396 /* Consume the `...'. */
13397 cp_lexer_consume_token (parser
->lexer
);
13398 maybe_warn_variadic_templates ();
13400 *is_parameter_pack
= true;
13402 /* We might end up with a pack expansion as the type of the non-type
13403 template parameter, in which case this is a non-type template
13405 else if (parameter_declarator
->decl_specifiers
.type
13406 && PACK_EXPANSION_P (parameter_declarator
->decl_specifiers
.type
))
13408 *is_parameter_pack
= true;
13409 parameter_declarator
->decl_specifiers
.type
=
13410 PACK_EXPANSION_PATTERN (parameter_declarator
->decl_specifiers
.type
);
13413 if (*is_parameter_pack
&& cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
13415 /* Parameter packs cannot have default arguments. However, a
13416 user may try to do so, so we'll parse them and give an
13417 appropriate diagnostic here. */
13419 cp_token
*start_token
= cp_lexer_peek_token (parser
->lexer
);
13421 /* Find the name of the parameter pack. */
13422 id_declarator
= parameter_declarator
->declarator
;
13423 while (id_declarator
&& id_declarator
->kind
!= cdk_id
)
13424 id_declarator
= id_declarator
->declarator
;
13426 if (id_declarator
&& id_declarator
->kind
== cdk_id
)
13427 error_at (start_token
->location
,
13428 "template parameter pack %qD cannot have a default argument",
13429 id_declarator
->u
.id
.unqualified_name
);
13431 error_at (start_token
->location
,
13432 "template parameter pack cannot have a default argument");
13434 /* Parse the default argument, but throw away the result. */
13435 cp_parser_default_argument (parser
, /*template_parm_p=*/true);
13438 parm
= grokdeclarator (parameter_declarator
->declarator
,
13439 ¶meter_declarator
->decl_specifiers
,
13440 TPARM
, /*initialized=*/0,
13441 /*attrlist=*/NULL
);
13442 if (parm
== error_mark_node
)
13443 return error_mark_node
;
13445 return build_tree_list (parameter_declarator
->default_argument
, parm
);
13448 /* Parse a type-parameter.
13451 class identifier [opt]
13452 class identifier [opt] = type-id
13453 typename identifier [opt]
13454 typename identifier [opt] = type-id
13455 template < template-parameter-list > class identifier [opt]
13456 template < template-parameter-list > class identifier [opt]
13459 GNU Extension (variadic templates):
13462 class ... identifier [opt]
13463 typename ... identifier [opt]
13465 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
13466 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
13467 the declaration of the parameter.
13469 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
13472 cp_parser_type_parameter (cp_parser
* parser
, bool *is_parameter_pack
)
13477 /* Look for a keyword to tell us what kind of parameter this is. */
13478 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_CLASS_TYPENAME_TEMPLATE
);
13480 return error_mark_node
;
13482 switch (token
->keyword
)
13488 tree default_argument
;
13490 /* If the next token is an ellipsis, we have a template
13492 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
13494 /* Consume the `...' token. */
13495 cp_lexer_consume_token (parser
->lexer
);
13496 maybe_warn_variadic_templates ();
13498 *is_parameter_pack
= true;
13501 /* If the next token is an identifier, then it names the
13503 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
13504 identifier
= cp_parser_identifier (parser
);
13506 identifier
= NULL_TREE
;
13508 /* Create the parameter. */
13509 parameter
= finish_template_type_parm (class_type_node
, identifier
);
13511 /* If the next token is an `=', we have a default argument. */
13512 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
13514 /* Consume the `=' token. */
13515 cp_lexer_consume_token (parser
->lexer
);
13516 /* Parse the default-argument. */
13517 push_deferring_access_checks (dk_no_deferred
);
13518 default_argument
= cp_parser_type_id (parser
);
13520 /* Template parameter packs cannot have default
13522 if (*is_parameter_pack
)
13525 error_at (token
->location
,
13526 "template parameter pack %qD cannot have a "
13527 "default argument", identifier
);
13529 error_at (token
->location
,
13530 "template parameter packs cannot have "
13531 "default arguments");
13532 default_argument
= NULL_TREE
;
13534 else if (check_for_bare_parameter_packs (default_argument
))
13535 default_argument
= error_mark_node
;
13536 pop_deferring_access_checks ();
13539 default_argument
= NULL_TREE
;
13541 /* Create the combined representation of the parameter and the
13542 default argument. */
13543 parameter
= build_tree_list (default_argument
, parameter
);
13550 tree default_argument
;
13552 /* Look for the `<'. */
13553 cp_parser_require (parser
, CPP_LESS
, RT_LESS
);
13554 /* Parse the template-parameter-list. */
13555 cp_parser_template_parameter_list (parser
);
13556 /* Look for the `>'. */
13557 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
13558 /* Look for the `class' or 'typename' keywords. */
13559 cp_parser_type_parameter_key (parser
);
13560 /* If the next token is an ellipsis, we have a template
13562 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
13564 /* Consume the `...' token. */
13565 cp_lexer_consume_token (parser
->lexer
);
13566 maybe_warn_variadic_templates ();
13568 *is_parameter_pack
= true;
13570 /* If the next token is an `=', then there is a
13571 default-argument. If the next token is a `>', we are at
13572 the end of the parameter-list. If the next token is a `,',
13573 then we are at the end of this parameter. */
13574 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
)
13575 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_GREATER
)
13576 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
13578 identifier
= cp_parser_identifier (parser
);
13579 /* Treat invalid names as if the parameter were nameless. */
13580 if (identifier
== error_mark_node
)
13581 identifier
= NULL_TREE
;
13584 identifier
= NULL_TREE
;
13586 /* Create the template parameter. */
13587 parameter
= finish_template_template_parm (class_type_node
,
13590 /* If the next token is an `=', then there is a
13591 default-argument. */
13592 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
13596 /* Consume the `='. */
13597 cp_lexer_consume_token (parser
->lexer
);
13598 /* Parse the id-expression. */
13599 push_deferring_access_checks (dk_no_deferred
);
13600 /* save token before parsing the id-expression, for error
13602 token
= cp_lexer_peek_token (parser
->lexer
);
13604 = cp_parser_id_expression (parser
,
13605 /*template_keyword_p=*/false,
13606 /*check_dependency_p=*/true,
13607 /*template_p=*/&is_template
,
13608 /*declarator_p=*/false,
13609 /*optional_p=*/false);
13610 if (TREE_CODE (default_argument
) == TYPE_DECL
)
13611 /* If the id-expression was a template-id that refers to
13612 a template-class, we already have the declaration here,
13613 so no further lookup is needed. */
13616 /* Look up the name. */
13618 = cp_parser_lookup_name (parser
, default_argument
,
13620 /*is_template=*/is_template
,
13621 /*is_namespace=*/false,
13622 /*check_dependency=*/true,
13623 /*ambiguous_decls=*/NULL
,
13625 /* See if the default argument is valid. */
13627 = check_template_template_default_arg (default_argument
);
13629 /* Template parameter packs cannot have default
13631 if (*is_parameter_pack
)
13634 error_at (token
->location
,
13635 "template parameter pack %qD cannot "
13636 "have a default argument",
13639 error_at (token
->location
, "template parameter packs cannot "
13640 "have default arguments");
13641 default_argument
= NULL_TREE
;
13643 pop_deferring_access_checks ();
13646 default_argument
= NULL_TREE
;
13648 /* Create the combined representation of the parameter and the
13649 default argument. */
13650 parameter
= build_tree_list (default_argument
, parameter
);
13655 gcc_unreachable ();
13662 /* Parse a template-id.
13665 template-name < template-argument-list [opt] >
13667 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
13668 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
13669 returned. Otherwise, if the template-name names a function, or set
13670 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
13671 names a class, returns a TYPE_DECL for the specialization.
13673 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
13674 uninstantiated templates. */
13677 cp_parser_template_id (cp_parser
*parser
,
13678 bool template_keyword_p
,
13679 bool check_dependency_p
,
13680 enum tag_types tag_type
,
13681 bool is_declaration
)
13687 cp_token_position start_of_id
= 0;
13688 deferred_access_check
*chk
;
13689 vec
<deferred_access_check
, va_gc
> *access_check
;
13690 cp_token
*next_token
= NULL
, *next_token_2
= NULL
;
13691 bool is_identifier
;
13693 /* If the next token corresponds to a template-id, there is no need
13695 next_token
= cp_lexer_peek_token (parser
->lexer
);
13696 if (next_token
->type
== CPP_TEMPLATE_ID
)
13698 struct tree_check
*check_value
;
13700 /* Get the stored value. */
13701 check_value
= cp_lexer_consume_token (parser
->lexer
)->u
.tree_check_value
;
13702 /* Perform any access checks that were deferred. */
13703 access_check
= check_value
->checks
;
13706 FOR_EACH_VEC_ELT (*access_check
, i
, chk
)
13707 perform_or_defer_access_check (chk
->binfo
,
13710 tf_warning_or_error
);
13712 /* Return the stored value. */
13713 return check_value
->value
;
13716 /* Avoid performing name lookup if there is no possibility of
13717 finding a template-id. */
13718 if ((next_token
->type
!= CPP_NAME
&& next_token
->keyword
!= RID_OPERATOR
)
13719 || (next_token
->type
== CPP_NAME
13720 && !cp_parser_nth_token_starts_template_argument_list_p
13723 cp_parser_error (parser
, "expected template-id");
13724 return error_mark_node
;
13727 /* Remember where the template-id starts. */
13728 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
13729 start_of_id
= cp_lexer_token_position (parser
->lexer
, false);
13731 push_deferring_access_checks (dk_deferred
);
13733 /* Parse the template-name. */
13734 is_identifier
= false;
13735 templ
= cp_parser_template_name (parser
, template_keyword_p
,
13736 check_dependency_p
,
13740 if (templ
== error_mark_node
|| is_identifier
)
13742 pop_deferring_access_checks ();
13746 /* If we find the sequence `[:' after a template-name, it's probably
13747 a digraph-typo for `< ::'. Substitute the tokens and check if we can
13748 parse correctly the argument list. */
13749 next_token
= cp_lexer_peek_token (parser
->lexer
);
13750 next_token_2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
13751 if (next_token
->type
== CPP_OPEN_SQUARE
13752 && next_token
->flags
& DIGRAPH
13753 && next_token_2
->type
== CPP_COLON
13754 && !(next_token_2
->flags
& PREV_WHITE
))
13756 cp_parser_parse_tentatively (parser
);
13757 /* Change `:' into `::'. */
13758 next_token_2
->type
= CPP_SCOPE
;
13759 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
13761 cp_lexer_consume_token (parser
->lexer
);
13763 /* Parse the arguments. */
13764 arguments
= cp_parser_enclosed_template_argument_list (parser
);
13765 if (!cp_parser_parse_definitely (parser
))
13767 /* If we couldn't parse an argument list, then we revert our changes
13768 and return simply an error. Maybe this is not a template-id
13770 next_token_2
->type
= CPP_COLON
;
13771 cp_parser_error (parser
, "expected %<<%>");
13772 pop_deferring_access_checks ();
13773 return error_mark_node
;
13775 /* Otherwise, emit an error about the invalid digraph, but continue
13776 parsing because we got our argument list. */
13777 if (permerror (next_token
->location
,
13778 "%<<::%> cannot begin a template-argument list"))
13780 static bool hint
= false;
13781 inform (next_token
->location
,
13782 "%<<:%> is an alternate spelling for %<[%>."
13783 " Insert whitespace between %<<%> and %<::%>");
13784 if (!hint
&& !flag_permissive
)
13786 inform (next_token
->location
, "(if you use %<-fpermissive%> "
13787 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
13788 "accept your code)");
13795 /* Look for the `<' that starts the template-argument-list. */
13796 if (!cp_parser_require (parser
, CPP_LESS
, RT_LESS
))
13798 pop_deferring_access_checks ();
13799 return error_mark_node
;
13801 /* Parse the arguments. */
13802 arguments
= cp_parser_enclosed_template_argument_list (parser
);
13805 /* Build a representation of the specialization. */
13806 if (identifier_p (templ
))
13807 template_id
= build_min_nt_loc (next_token
->location
,
13810 else if (DECL_TYPE_TEMPLATE_P (templ
)
13811 || DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
13813 bool entering_scope
;
13814 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
13815 template (rather than some instantiation thereof) only if
13816 is not nested within some other construct. For example, in
13817 "template <typename T> void f(T) { A<T>::", A<T> is just an
13818 instantiation of A. */
13819 entering_scope
= (template_parm_scope_p ()
13820 && cp_lexer_next_token_is (parser
->lexer
,
13823 = finish_template_type (templ
, arguments
, entering_scope
);
13825 else if (variable_template_p (templ
))
13827 template_id
= lookup_template_variable (templ
, arguments
);
13831 /* If it's not a class-template or a template-template, it should be
13832 a function-template. */
13833 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ
)
13834 || TREE_CODE (templ
) == OVERLOAD
13835 || BASELINK_P (templ
)));
13837 template_id
= lookup_template_function (templ
, arguments
);
13840 /* If parsing tentatively, replace the sequence of tokens that makes
13841 up the template-id with a CPP_TEMPLATE_ID token. That way,
13842 should we re-parse the token stream, we will not have to repeat
13843 the effort required to do the parse, nor will we issue duplicate
13844 error messages about problems during instantiation of the
13847 /* Don't do this if we had a parse error in a declarator; re-parsing
13848 might succeed if a name changes meaning (60361). */
13849 && !(cp_parser_error_occurred (parser
)
13850 && cp_parser_parsing_tentatively (parser
)
13851 && parser
->in_declarator_p
))
13853 cp_token
*token
= cp_lexer_token_at (parser
->lexer
, start_of_id
);
13855 /* Reset the contents of the START_OF_ID token. */
13856 token
->type
= CPP_TEMPLATE_ID
;
13857 /* Retrieve any deferred checks. Do not pop this access checks yet
13858 so the memory will not be reclaimed during token replacing below. */
13859 token
->u
.tree_check_value
= ggc_cleared_alloc
<struct tree_check
> ();
13860 token
->u
.tree_check_value
->value
= template_id
;
13861 token
->u
.tree_check_value
->checks
= get_deferred_access_checks ();
13862 token
->keyword
= RID_MAX
;
13864 /* Purge all subsequent tokens. */
13865 cp_lexer_purge_tokens_after (parser
->lexer
, start_of_id
);
13867 /* ??? Can we actually assume that, if template_id ==
13868 error_mark_node, we will have issued a diagnostic to the
13869 user, as opposed to simply marking the tentative parse as
13871 if (cp_parser_error_occurred (parser
) && template_id
!= error_mark_node
)
13872 error_at (token
->location
, "parse error in template argument list");
13875 pop_to_parent_deferring_access_checks ();
13876 return template_id
;
13879 /* Parse a template-name.
13884 The standard should actually say:
13888 operator-function-id
13890 A defect report has been filed about this issue.
13892 A conversion-function-id cannot be a template name because they cannot
13893 be part of a template-id. In fact, looking at this code:
13895 a.operator K<int>()
13897 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
13898 It is impossible to call a templated conversion-function-id with an
13899 explicit argument list, since the only allowed template parameter is
13900 the type to which it is converting.
13902 If TEMPLATE_KEYWORD_P is true, then we have just seen the
13903 `template' keyword, in a construction like:
13907 In that case `f' is taken to be a template-name, even though there
13908 is no way of knowing for sure.
13910 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
13911 name refers to a set of overloaded functions, at least one of which
13912 is a template, or an IDENTIFIER_NODE with the name of the template,
13913 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
13914 names are looked up inside uninstantiated templates. */
13917 cp_parser_template_name (cp_parser
* parser
,
13918 bool template_keyword_p
,
13919 bool check_dependency_p
,
13920 bool is_declaration
,
13921 enum tag_types tag_type
,
13922 bool *is_identifier
)
13927 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
13929 /* If the next token is `operator', then we have either an
13930 operator-function-id or a conversion-function-id. */
13931 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_OPERATOR
))
13933 /* We don't know whether we're looking at an
13934 operator-function-id or a conversion-function-id. */
13935 cp_parser_parse_tentatively (parser
);
13936 /* Try an operator-function-id. */
13937 identifier
= cp_parser_operator_function_id (parser
);
13938 /* If that didn't work, try a conversion-function-id. */
13939 if (!cp_parser_parse_definitely (parser
))
13941 cp_parser_error (parser
, "expected template-name");
13942 return error_mark_node
;
13945 /* Look for the identifier. */
13947 identifier
= cp_parser_identifier (parser
);
13949 /* If we didn't find an identifier, we don't have a template-id. */
13950 if (identifier
== error_mark_node
)
13951 return error_mark_node
;
13953 /* If the name immediately followed the `template' keyword, then it
13954 is a template-name. However, if the next token is not `<', then
13955 we do not treat it as a template-name, since it is not being used
13956 as part of a template-id. This enables us to handle constructs
13959 template <typename T> struct S { S(); };
13960 template <typename T> S<T>::S();
13962 correctly. We would treat `S' as a template -- if it were `S<T>'
13963 -- but we do not if there is no `<'. */
13965 if (processing_template_decl
13966 && cp_parser_nth_token_starts_template_argument_list_p (parser
, 1))
13968 /* In a declaration, in a dependent context, we pretend that the
13969 "template" keyword was present in order to improve error
13970 recovery. For example, given:
13972 template <typename T> void f(T::X<int>);
13974 we want to treat "X<int>" as a template-id. */
13976 && !template_keyword_p
13977 && parser
->scope
&& TYPE_P (parser
->scope
)
13978 && check_dependency_p
13979 && dependent_scope_p (parser
->scope
)
13980 /* Do not do this for dtors (or ctors), since they never
13981 need the template keyword before their name. */
13982 && !constructor_name_p (identifier
, parser
->scope
))
13984 cp_token_position start
= 0;
13986 /* Explain what went wrong. */
13987 error_at (token
->location
, "non-template %qD used as template",
13989 inform (token
->location
, "use %<%T::template %D%> to indicate that it is a template",
13990 parser
->scope
, identifier
);
13991 /* If parsing tentatively, find the location of the "<" token. */
13992 if (cp_parser_simulate_error (parser
))
13993 start
= cp_lexer_token_position (parser
->lexer
, true);
13994 /* Parse the template arguments so that we can issue error
13995 messages about them. */
13996 cp_lexer_consume_token (parser
->lexer
);
13997 cp_parser_enclosed_template_argument_list (parser
);
13998 /* Skip tokens until we find a good place from which to
13999 continue parsing. */
14000 cp_parser_skip_to_closing_parenthesis (parser
,
14001 /*recovering=*/true,
14003 /*consume_paren=*/false);
14004 /* If parsing tentatively, permanently remove the
14005 template argument list. That will prevent duplicate
14006 error messages from being issued about the missing
14007 "template" keyword. */
14009 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
14011 *is_identifier
= true;
14015 /* If the "template" keyword is present, then there is generally
14016 no point in doing name-lookup, so we just return IDENTIFIER.
14017 But, if the qualifying scope is non-dependent then we can
14018 (and must) do name-lookup normally. */
14019 if (template_keyword_p
14021 || (TYPE_P (parser
->scope
)
14022 && dependent_type_p (parser
->scope
))))
14026 /* Look up the name. */
14027 decl
= cp_parser_lookup_name (parser
, identifier
,
14029 /*is_template=*/true,
14030 /*is_namespace=*/false,
14031 check_dependency_p
,
14032 /*ambiguous_decls=*/NULL
,
14035 decl
= strip_using_decl (decl
);
14037 /* If DECL is a template, then the name was a template-name. */
14038 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
14040 if (TREE_DEPRECATED (decl
)
14041 && deprecated_state
!= DEPRECATED_SUPPRESS
)
14042 warn_deprecated_use (decl
, NULL_TREE
);
14046 tree fn
= NULL_TREE
;
14048 /* The standard does not explicitly indicate whether a name that
14049 names a set of overloaded declarations, some of which are
14050 templates, is a template-name. However, such a name should
14051 be a template-name; otherwise, there is no way to form a
14052 template-id for the overloaded templates. */
14053 fns
= BASELINK_P (decl
) ? BASELINK_FUNCTIONS (decl
) : decl
;
14054 if (TREE_CODE (fns
) == OVERLOAD
)
14055 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
14056 if (TREE_CODE (OVL_CURRENT (fn
)) == TEMPLATE_DECL
)
14061 /* The name does not name a template. */
14062 cp_parser_error (parser
, "expected template-name");
14063 return error_mark_node
;
14067 /* If DECL is dependent, and refers to a function, then just return
14068 its name; we will look it up again during template instantiation. */
14069 if (DECL_FUNCTION_TEMPLATE_P (decl
) || !DECL_P (decl
))
14071 tree scope
= ovl_scope (decl
);
14072 if (TYPE_P (scope
) && dependent_type_p (scope
))
14079 /* Parse a template-argument-list.
14081 template-argument-list:
14082 template-argument ... [opt]
14083 template-argument-list , template-argument ... [opt]
14085 Returns a TREE_VEC containing the arguments. */
14088 cp_parser_template_argument_list (cp_parser
* parser
)
14090 tree fixed_args
[10];
14091 unsigned n_args
= 0;
14092 unsigned alloced
= 10;
14093 tree
*arg_ary
= fixed_args
;
14095 bool saved_in_template_argument_list_p
;
14097 bool saved_non_ice_p
;
14099 saved_in_template_argument_list_p
= parser
->in_template_argument_list_p
;
14100 parser
->in_template_argument_list_p
= true;
14101 /* Even if the template-id appears in an integral
14102 constant-expression, the contents of the argument list do
14104 saved_ice_p
= parser
->integral_constant_expression_p
;
14105 parser
->integral_constant_expression_p
= false;
14106 saved_non_ice_p
= parser
->non_integral_constant_expression_p
;
14107 parser
->non_integral_constant_expression_p
= false;
14109 /* Parse the arguments. */
14115 /* Consume the comma. */
14116 cp_lexer_consume_token (parser
->lexer
);
14118 /* Parse the template-argument. */
14119 argument
= cp_parser_template_argument (parser
);
14121 /* If the next token is an ellipsis, we're expanding a template
14123 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
14125 if (argument
== error_mark_node
)
14127 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
14128 error_at (token
->location
,
14129 "expected parameter pack before %<...%>");
14131 /* Consume the `...' token. */
14132 cp_lexer_consume_token (parser
->lexer
);
14134 /* Make the argument into a TYPE_PACK_EXPANSION or
14135 EXPR_PACK_EXPANSION. */
14136 argument
= make_pack_expansion (argument
);
14139 if (n_args
== alloced
)
14143 if (arg_ary
== fixed_args
)
14145 arg_ary
= XNEWVEC (tree
, alloced
);
14146 memcpy (arg_ary
, fixed_args
, sizeof (tree
) * n_args
);
14149 arg_ary
= XRESIZEVEC (tree
, arg_ary
, alloced
);
14151 arg_ary
[n_args
++] = argument
;
14153 while (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
));
14155 vec
= make_tree_vec (n_args
);
14158 TREE_VEC_ELT (vec
, n_args
) = arg_ary
[n_args
];
14160 if (arg_ary
!= fixed_args
)
14162 parser
->non_integral_constant_expression_p
= saved_non_ice_p
;
14163 parser
->integral_constant_expression_p
= saved_ice_p
;
14164 parser
->in_template_argument_list_p
= saved_in_template_argument_list_p
;
14165 #ifdef ENABLE_CHECKING
14166 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
14171 /* Parse a template-argument.
14174 assignment-expression
14178 The representation is that of an assignment-expression, type-id, or
14179 id-expression -- except that the qualified id-expression is
14180 evaluated, so that the value returned is either a DECL or an
14183 Although the standard says "assignment-expression", it forbids
14184 throw-expressions or assignments in the template argument.
14185 Therefore, we use "conditional-expression" instead. */
14188 cp_parser_template_argument (cp_parser
* parser
)
14193 bool maybe_type_id
= false;
14194 cp_token
*token
= NULL
, *argument_start_token
= NULL
;
14195 location_t loc
= 0;
14198 /* There's really no way to know what we're looking at, so we just
14199 try each alternative in order.
14203 In a template-argument, an ambiguity between a type-id and an
14204 expression is resolved to a type-id, regardless of the form of
14205 the corresponding template-parameter.
14207 Therefore, we try a type-id first. */
14208 cp_parser_parse_tentatively (parser
);
14209 argument
= cp_parser_template_type_arg (parser
);
14210 /* If there was no error parsing the type-id but the next token is a
14211 '>>', our behavior depends on which dialect of C++ we're
14212 parsing. In C++98, we probably found a typo for '> >'. But there
14213 are type-id which are also valid expressions. For instance:
14215 struct X { int operator >> (int); };
14216 template <int V> struct Foo {};
14219 Here 'X()' is a valid type-id of a function type, but the user just
14220 wanted to write the expression "X() >> 5". Thus, we remember that we
14221 found a valid type-id, but we still try to parse the argument as an
14222 expression to see what happens.
14224 In C++0x, the '>>' will be considered two separate '>'
14226 if (!cp_parser_error_occurred (parser
)
14227 && cxx_dialect
== cxx98
14228 && cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
14230 maybe_type_id
= true;
14231 cp_parser_abort_tentative_parse (parser
);
14235 /* If the next token isn't a `,' or a `>', then this argument wasn't
14236 really finished. This means that the argument is not a valid
14238 if (!cp_parser_next_token_ends_template_argument_p (parser
))
14239 cp_parser_error (parser
, "expected template-argument");
14240 /* If that worked, we're done. */
14241 if (cp_parser_parse_definitely (parser
))
14244 /* We're still not sure what the argument will be. */
14245 cp_parser_parse_tentatively (parser
);
14246 /* Try a template. */
14247 argument_start_token
= cp_lexer_peek_token (parser
->lexer
);
14248 argument
= cp_parser_id_expression (parser
,
14249 /*template_keyword_p=*/false,
14250 /*check_dependency_p=*/true,
14252 /*declarator_p=*/false,
14253 /*optional_p=*/false);
14254 /* If the next token isn't a `,' or a `>', then this argument wasn't
14255 really finished. */
14256 if (!cp_parser_next_token_ends_template_argument_p (parser
))
14257 cp_parser_error (parser
, "expected template-argument");
14258 if (!cp_parser_error_occurred (parser
))
14260 /* Figure out what is being referred to. If the id-expression
14261 was for a class template specialization, then we will have a
14262 TYPE_DECL at this point. There is no need to do name lookup
14263 at this point in that case. */
14264 if (TREE_CODE (argument
) != TYPE_DECL
)
14265 argument
= cp_parser_lookup_name (parser
, argument
,
14267 /*is_template=*/template_p
,
14268 /*is_namespace=*/false,
14269 /*check_dependency=*/true,
14270 /*ambiguous_decls=*/NULL
,
14271 argument_start_token
->location
);
14272 if (TREE_CODE (argument
) != TEMPLATE_DECL
14273 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
14274 cp_parser_error (parser
, "expected template-name");
14276 if (cp_parser_parse_definitely (parser
))
14278 if (TREE_DEPRECATED (argument
))
14279 warn_deprecated_use (argument
, NULL_TREE
);
14282 /* It must be a non-type argument. There permitted cases are given
14283 in [temp.arg.nontype]:
14285 -- an integral constant-expression of integral or enumeration
14288 -- the name of a non-type template-parameter; or
14290 -- the name of an object or function with external linkage...
14292 -- the address of an object or function with external linkage...
14294 -- a pointer to member... */
14295 /* Look for a non-type template parameter. */
14296 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
14298 cp_parser_parse_tentatively (parser
);
14299 argument
= cp_parser_primary_expression (parser
,
14300 /*address_p=*/false,
14302 /*template_arg_p=*/true,
14304 if (TREE_CODE (argument
) != TEMPLATE_PARM_INDEX
14305 || !cp_parser_next_token_ends_template_argument_p (parser
))
14306 cp_parser_simulate_error (parser
);
14307 if (cp_parser_parse_definitely (parser
))
14311 /* If the next token is "&", the argument must be the address of an
14312 object or function with external linkage. */
14313 address_p
= cp_lexer_next_token_is (parser
->lexer
, CPP_AND
);
14316 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
14317 cp_lexer_consume_token (parser
->lexer
);
14319 /* See if we might have an id-expression. */
14320 token
= cp_lexer_peek_token (parser
->lexer
);
14321 if (token
->type
== CPP_NAME
14322 || token
->keyword
== RID_OPERATOR
14323 || token
->type
== CPP_SCOPE
14324 || token
->type
== CPP_TEMPLATE_ID
14325 || token
->type
== CPP_NESTED_NAME_SPECIFIER
)
14327 cp_parser_parse_tentatively (parser
);
14328 argument
= cp_parser_primary_expression (parser
,
14331 /*template_arg_p=*/true,
14333 if (cp_parser_error_occurred (parser
)
14334 || !cp_parser_next_token_ends_template_argument_p (parser
))
14335 cp_parser_abort_tentative_parse (parser
);
14340 if (INDIRECT_REF_P (argument
))
14342 /* Strip the dereference temporarily. */
14343 gcc_assert (REFERENCE_REF_P (argument
));
14344 argument
= TREE_OPERAND (argument
, 0);
14347 /* If we're in a template, we represent a qualified-id referring
14348 to a static data member as a SCOPE_REF even if the scope isn't
14349 dependent so that we can check access control later. */
14351 if (TREE_CODE (probe
) == SCOPE_REF
)
14352 probe
= TREE_OPERAND (probe
, 1);
14355 /* A variable without external linkage might still be a
14356 valid constant-expression, so no error is issued here
14357 if the external-linkage check fails. */
14358 if (!address_p
&& !DECL_EXTERNAL_LINKAGE_P (probe
))
14359 cp_parser_simulate_error (parser
);
14361 else if (is_overloaded_fn (argument
))
14362 /* All overloaded functions are allowed; if the external
14363 linkage test does not pass, an error will be issued
14367 && (TREE_CODE (argument
) == OFFSET_REF
14368 || TREE_CODE (argument
) == SCOPE_REF
))
14369 /* A pointer-to-member. */
14371 else if (TREE_CODE (argument
) == TEMPLATE_PARM_INDEX
)
14374 cp_parser_simulate_error (parser
);
14376 if (cp_parser_parse_definitely (parser
))
14379 argument
= build_x_unary_op (loc
, ADDR_EXPR
, argument
,
14380 tf_warning_or_error
);
14382 argument
= convert_from_reference (argument
);
14387 /* If the argument started with "&", there are no other valid
14388 alternatives at this point. */
14391 cp_parser_error (parser
, "invalid non-type template argument");
14392 return error_mark_node
;
14395 /* If the argument wasn't successfully parsed as a type-id followed
14396 by '>>', the argument can only be a constant expression now.
14397 Otherwise, we try parsing the constant-expression tentatively,
14398 because the argument could really be a type-id. */
14400 cp_parser_parse_tentatively (parser
);
14401 argument
= cp_parser_constant_expression (parser
);
14403 if (!maybe_type_id
)
14405 if (!cp_parser_next_token_ends_template_argument_p (parser
))
14406 cp_parser_error (parser
, "expected template-argument");
14407 if (cp_parser_parse_definitely (parser
))
14409 /* We did our best to parse the argument as a non type-id, but that
14410 was the only alternative that matched (albeit with a '>' after
14411 it). We can assume it's just a typo from the user, and a
14412 diagnostic will then be issued. */
14413 return cp_parser_template_type_arg (parser
);
14416 /* Parse an explicit-instantiation.
14418 explicit-instantiation:
14419 template declaration
14421 Although the standard says `declaration', what it really means is:
14423 explicit-instantiation:
14424 template decl-specifier-seq [opt] declarator [opt] ;
14426 Things like `template int S<int>::i = 5, int S<double>::j;' are not
14427 supposed to be allowed. A defect report has been filed about this
14432 explicit-instantiation:
14433 storage-class-specifier template
14434 decl-specifier-seq [opt] declarator [opt] ;
14435 function-specifier template
14436 decl-specifier-seq [opt] declarator [opt] ; */
14439 cp_parser_explicit_instantiation (cp_parser
* parser
)
14441 int declares_class_or_enum
;
14442 cp_decl_specifier_seq decl_specifiers
;
14443 tree extension_specifier
= NULL_TREE
;
14445 timevar_push (TV_TEMPLATE_INST
);
14447 /* Look for an (optional) storage-class-specifier or
14448 function-specifier. */
14449 if (cp_parser_allow_gnu_extensions_p (parser
))
14451 extension_specifier
14452 = cp_parser_storage_class_specifier_opt (parser
);
14453 if (!extension_specifier
)
14454 extension_specifier
14455 = cp_parser_function_specifier_opt (parser
,
14456 /*decl_specs=*/NULL
);
14459 /* Look for the `template' keyword. */
14460 cp_parser_require_keyword (parser
, RID_TEMPLATE
, RT_TEMPLATE
);
14461 /* Let the front end know that we are processing an explicit
14463 begin_explicit_instantiation ();
14464 /* [temp.explicit] says that we are supposed to ignore access
14465 control while processing explicit instantiation directives. */
14466 push_deferring_access_checks (dk_no_check
);
14467 /* Parse a decl-specifier-seq. */
14468 cp_parser_decl_specifier_seq (parser
,
14469 CP_PARSER_FLAGS_OPTIONAL
,
14471 &declares_class_or_enum
);
14472 /* If there was exactly one decl-specifier, and it declared a class,
14473 and there's no declarator, then we have an explicit type
14475 if (declares_class_or_enum
&& cp_parser_declares_only_class_p (parser
))
14479 type
= check_tag_decl (&decl_specifiers
,
14480 /*explicit_type_instantiation_p=*/true);
14481 /* Turn access control back on for names used during
14482 template instantiation. */
14483 pop_deferring_access_checks ();
14485 do_type_instantiation (type
, extension_specifier
,
14486 /*complain=*/tf_error
);
14490 cp_declarator
*declarator
;
14493 /* Parse the declarator. */
14495 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
14496 /*ctor_dtor_or_conv_p=*/NULL
,
14497 /*parenthesized_p=*/NULL
,
14498 /*member_p=*/false,
14499 /*friend_p=*/false);
14500 if (declares_class_or_enum
& 2)
14501 cp_parser_check_for_definition_in_return_type (declarator
,
14502 decl_specifiers
.type
,
14503 decl_specifiers
.locations
[ds_type_spec
]);
14504 if (declarator
!= cp_error_declarator
)
14506 if (decl_spec_seq_has_spec_p (&decl_specifiers
, ds_inline
))
14507 permerror (decl_specifiers
.locations
[ds_inline
],
14508 "explicit instantiation shall not use"
14509 " %<inline%> specifier");
14510 if (decl_spec_seq_has_spec_p (&decl_specifiers
, ds_constexpr
))
14511 permerror (decl_specifiers
.locations
[ds_constexpr
],
14512 "explicit instantiation shall not use"
14513 " %<constexpr%> specifier");
14515 decl
= grokdeclarator (declarator
, &decl_specifiers
,
14516 NORMAL
, 0, &decl_specifiers
.attributes
);
14517 /* Turn access control back on for names used during
14518 template instantiation. */
14519 pop_deferring_access_checks ();
14520 /* Do the explicit instantiation. */
14521 do_decl_instantiation (decl
, extension_specifier
);
14525 pop_deferring_access_checks ();
14526 /* Skip the body of the explicit instantiation. */
14527 cp_parser_skip_to_end_of_statement (parser
);
14530 /* We're done with the instantiation. */
14531 end_explicit_instantiation ();
14533 cp_parser_consume_semicolon_at_end_of_statement (parser
);
14535 timevar_pop (TV_TEMPLATE_INST
);
14538 /* Parse an explicit-specialization.
14540 explicit-specialization:
14541 template < > declaration
14543 Although the standard says `declaration', what it really means is:
14545 explicit-specialization:
14546 template <> decl-specifier [opt] init-declarator [opt] ;
14547 template <> function-definition
14548 template <> explicit-specialization
14549 template <> template-declaration */
14552 cp_parser_explicit_specialization (cp_parser
* parser
)
14554 bool need_lang_pop
;
14555 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
14557 /* Look for the `template' keyword. */
14558 cp_parser_require_keyword (parser
, RID_TEMPLATE
, RT_TEMPLATE
);
14559 /* Look for the `<'. */
14560 cp_parser_require (parser
, CPP_LESS
, RT_LESS
);
14561 /* Look for the `>'. */
14562 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
14563 /* We have processed another parameter list. */
14564 ++parser
->num_template_parameter_lists
;
14567 A template ... explicit specialization ... shall not have C
14569 if (current_lang_name
== lang_name_c
)
14571 error_at (token
->location
, "template specialization with C linkage");
14572 /* Give it C++ linkage to avoid confusing other parts of the
14574 push_lang_context (lang_name_cplusplus
);
14575 need_lang_pop
= true;
14578 need_lang_pop
= false;
14579 /* Let the front end know that we are beginning a specialization. */
14580 if (!begin_specialization ())
14582 end_specialization ();
14586 /* If the next keyword is `template', we need to figure out whether
14587 or not we're looking a template-declaration. */
14588 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
14590 if (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_LESS
14591 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
!= CPP_GREATER
)
14592 cp_parser_template_declaration_after_export (parser
,
14593 /*member_p=*/false);
14595 cp_parser_explicit_specialization (parser
);
14598 /* Parse the dependent declaration. */
14599 cp_parser_single_declaration (parser
,
14601 /*member_p=*/false,
14602 /*explicit_specialization_p=*/true,
14603 /*friend_p=*/NULL
);
14604 /* We're done with the specialization. */
14605 end_specialization ();
14606 /* For the erroneous case of a template with C linkage, we pushed an
14607 implicit C++ linkage scope; exit that scope now. */
14609 pop_lang_context ();
14610 /* We're done with this parameter list. */
14611 --parser
->num_template_parameter_lists
;
14614 /* Parse a type-specifier.
14617 simple-type-specifier
14620 elaborated-type-specifier
14628 Returns a representation of the type-specifier. For a
14629 class-specifier, enum-specifier, or elaborated-type-specifier, a
14630 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
14632 The parser flags FLAGS is used to control type-specifier parsing.
14634 If IS_DECLARATION is TRUE, then this type-specifier is appearing
14635 in a decl-specifier-seq.
14637 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
14638 class-specifier, enum-specifier, or elaborated-type-specifier, then
14639 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
14640 if a type is declared; 2 if it is defined. Otherwise, it is set to
14643 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
14644 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
14645 is set to FALSE. */
14648 cp_parser_type_specifier (cp_parser
* parser
,
14649 cp_parser_flags flags
,
14650 cp_decl_specifier_seq
*decl_specs
,
14651 bool is_declaration
,
14652 int* declares_class_or_enum
,
14653 bool* is_cv_qualifier
)
14655 tree type_spec
= NULL_TREE
;
14658 cp_decl_spec ds
= ds_last
;
14660 /* Assume this type-specifier does not declare a new type. */
14661 if (declares_class_or_enum
)
14662 *declares_class_or_enum
= 0;
14663 /* And that it does not specify a cv-qualifier. */
14664 if (is_cv_qualifier
)
14665 *is_cv_qualifier
= false;
14666 /* Peek at the next token. */
14667 token
= cp_lexer_peek_token (parser
->lexer
);
14669 /* If we're looking at a keyword, we can use that to guide the
14670 production we choose. */
14671 keyword
= token
->keyword
;
14675 if ((flags
& CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS
))
14676 goto elaborated_type_specifier
;
14678 /* Look for the enum-specifier. */
14679 type_spec
= cp_parser_enum_specifier (parser
);
14680 /* If that worked, we're done. */
14683 if (declares_class_or_enum
)
14684 *declares_class_or_enum
= 2;
14686 cp_parser_set_decl_spec_type (decl_specs
,
14689 /*type_definition_p=*/true);
14693 goto elaborated_type_specifier
;
14695 /* Any of these indicate either a class-specifier, or an
14696 elaborated-type-specifier. */
14700 if ((flags
& CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS
))
14701 goto elaborated_type_specifier
;
14703 /* Parse tentatively so that we can back up if we don't find a
14704 class-specifier. */
14705 cp_parser_parse_tentatively (parser
);
14706 /* Look for the class-specifier. */
14707 type_spec
= cp_parser_class_specifier (parser
);
14708 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE
, type_spec
);
14709 /* If that worked, we're done. */
14710 if (cp_parser_parse_definitely (parser
))
14712 if (declares_class_or_enum
)
14713 *declares_class_or_enum
= 2;
14715 cp_parser_set_decl_spec_type (decl_specs
,
14718 /*type_definition_p=*/true);
14722 /* Fall through. */
14723 elaborated_type_specifier
:
14724 /* We're declaring (not defining) a class or enum. */
14725 if (declares_class_or_enum
)
14726 *declares_class_or_enum
= 1;
14728 /* Fall through. */
14730 /* Look for an elaborated-type-specifier. */
14732 = (cp_parser_elaborated_type_specifier
14734 decl_spec_seq_has_spec_p (decl_specs
, ds_friend
),
14737 cp_parser_set_decl_spec_type (decl_specs
,
14740 /*type_definition_p=*/false);
14745 if (is_cv_qualifier
)
14746 *is_cv_qualifier
= true;
14751 if (is_cv_qualifier
)
14752 *is_cv_qualifier
= true;
14757 if (is_cv_qualifier
)
14758 *is_cv_qualifier
= true;
14762 /* The `__complex__' keyword is a GNU extension. */
14770 /* Handle simple keywords. */
14775 set_and_check_decl_spec_loc (decl_specs
, ds
, token
);
14776 decl_specs
->any_specifiers_p
= true;
14778 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
14781 /* If we do not already have a type-specifier, assume we are looking
14782 at a simple-type-specifier. */
14783 type_spec
= cp_parser_simple_type_specifier (parser
,
14787 /* If we didn't find a type-specifier, and a type-specifier was not
14788 optional in this context, issue an error message. */
14789 if (!type_spec
&& !(flags
& CP_PARSER_FLAGS_OPTIONAL
))
14791 cp_parser_error (parser
, "expected type specifier");
14792 return error_mark_node
;
14798 /* Parse a simple-type-specifier.
14800 simple-type-specifier:
14801 :: [opt] nested-name-specifier [opt] type-name
14802 :: [opt] nested-name-specifier template template-id
14817 simple-type-specifier:
14819 decltype ( expression )
14822 __underlying_type ( type-id )
14826 simple-type-specifier:
14828 __typeof__ unary-expression
14829 __typeof__ ( type-id )
14830 __typeof__ ( type-id ) { initializer-list , [opt] }
14832 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
14833 appropriately updated. */
14836 cp_parser_simple_type_specifier (cp_parser
* parser
,
14837 cp_decl_specifier_seq
*decl_specs
,
14838 cp_parser_flags flags
)
14840 tree type
= NULL_TREE
;
14844 /* Peek at the next token. */
14845 token
= cp_lexer_peek_token (parser
->lexer
);
14847 /* If we're looking at a keyword, things are easy. */
14848 switch (token
->keyword
)
14852 decl_specs
->explicit_char_p
= true;
14853 type
= char_type_node
;
14856 type
= char16_type_node
;
14859 type
= char32_type_node
;
14862 type
= wchar_type_node
;
14865 type
= boolean_type_node
;
14868 set_and_check_decl_spec_loc (decl_specs
, ds_short
, token
);
14869 type
= short_integer_type_node
;
14873 decl_specs
->explicit_int_p
= true;
14874 type
= integer_type_node
;
14880 idx
= token
->keyword
- RID_INT_N_0
;
14881 if (! int_n_enabled_p
[idx
])
14885 decl_specs
->explicit_intN_p
= true;
14886 decl_specs
->int_n_idx
= idx
;
14888 type
= int_n_trees
[idx
].signed_type
;
14892 set_and_check_decl_spec_loc (decl_specs
, ds_long
, token
);
14893 type
= long_integer_type_node
;
14896 set_and_check_decl_spec_loc (decl_specs
, ds_signed
, token
);
14897 type
= integer_type_node
;
14900 set_and_check_decl_spec_loc (decl_specs
, ds_unsigned
, token
);
14901 type
= unsigned_type_node
;
14904 type
= float_type_node
;
14907 type
= double_type_node
;
14910 type
= void_type_node
;
14914 maybe_warn_cpp0x (CPP0X_AUTO
);
14915 if (parser
->auto_is_implicit_function_template_parm_p
)
14917 if (cxx_dialect
>= cxx14
)
14918 type
= synthesize_implicit_template_parm (parser
);
14920 type
= error_mark_node
;
14922 if (current_class_type
&& LAMBDA_TYPE_P (current_class_type
))
14924 if (cxx_dialect
< cxx14
)
14925 error_at (token
->location
,
14926 "use of %<auto%> in lambda parameter declaration "
14927 "only available with "
14928 "-std=c++14 or -std=gnu++14");
14930 else if (cxx_dialect
< cxx14
)
14931 error_at (token
->location
,
14932 "use of %<auto%> in parameter declaration "
14933 "only available with "
14934 "-std=c++14 or -std=gnu++14");
14936 pedwarn (token
->location
, OPT_Wpedantic
,
14937 "ISO C++ forbids use of %<auto%> in parameter "
14941 type
= make_auto ();
14945 /* Since DR 743, decltype can either be a simple-type-specifier by
14946 itself or begin a nested-name-specifier. Parsing it will replace
14947 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
14948 handling below decide what to do. */
14949 cp_parser_decltype (parser
);
14950 cp_lexer_set_token_position (parser
->lexer
, token
);
14954 /* Consume the `typeof' token. */
14955 cp_lexer_consume_token (parser
->lexer
);
14956 /* Parse the operand to `typeof'. */
14957 type
= cp_parser_sizeof_operand (parser
, RID_TYPEOF
);
14958 /* If it is not already a TYPE, take its type. */
14959 if (!TYPE_P (type
))
14960 type
= finish_typeof (type
);
14963 cp_parser_set_decl_spec_type (decl_specs
, type
,
14965 /*type_definition_p=*/false);
14969 case RID_UNDERLYING_TYPE
:
14970 type
= cp_parser_trait_expr (parser
, RID_UNDERLYING_TYPE
);
14972 cp_parser_set_decl_spec_type (decl_specs
, type
,
14974 /*type_definition_p=*/false);
14979 case RID_DIRECT_BASES
:
14980 type
= cp_parser_trait_expr (parser
, token
->keyword
);
14982 cp_parser_set_decl_spec_type (decl_specs
, type
,
14984 /*type_definition_p=*/false);
14990 /* If token is an already-parsed decltype not followed by ::,
14991 it's a simple-type-specifier. */
14992 if (token
->type
== CPP_DECLTYPE
14993 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
)
14995 type
= token
->u
.value
;
14998 cp_parser_set_decl_spec_type (decl_specs
, type
,
15000 /*type_definition_p=*/false);
15001 /* Remember that we are handling a decltype in order to
15002 implement the resolution of DR 1510 when the argument
15003 isn't instantiation dependent. */
15004 decl_specs
->decltype_p
= true;
15006 cp_lexer_consume_token (parser
->lexer
);
15010 /* If the type-specifier was for a built-in type, we're done. */
15013 /* Record the type. */
15015 && (token
->keyword
!= RID_SIGNED
15016 && token
->keyword
!= RID_UNSIGNED
15017 && token
->keyword
!= RID_SHORT
15018 && token
->keyword
!= RID_LONG
))
15019 cp_parser_set_decl_spec_type (decl_specs
,
15022 /*type_definition_p=*/false);
15024 decl_specs
->any_specifiers_p
= true;
15026 /* Consume the token. */
15027 cp_lexer_consume_token (parser
->lexer
);
15029 if (type
== error_mark_node
)
15030 return error_mark_node
;
15032 /* There is no valid C++ program where a non-template type is
15033 followed by a "<". That usually indicates that the user thought
15034 that the type was a template. */
15035 cp_parser_check_for_invalid_template_id (parser
, type
, none_type
,
15038 return TYPE_NAME (type
);
15041 /* The type-specifier must be a user-defined type. */
15042 if (!(flags
& CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
))
15047 /* Don't gobble tokens or issue error messages if this is an
15048 optional type-specifier. */
15049 if (flags
& CP_PARSER_FLAGS_OPTIONAL
)
15050 cp_parser_parse_tentatively (parser
);
15052 /* Look for the optional `::' operator. */
15054 = (cp_parser_global_scope_opt (parser
,
15055 /*current_scope_valid_p=*/false)
15057 /* Look for the nested-name specifier. */
15059 = (cp_parser_nested_name_specifier_opt (parser
,
15060 /*typename_keyword_p=*/false,
15061 /*check_dependency_p=*/true,
15063 /*is_declaration=*/false)
15065 token
= cp_lexer_peek_token (parser
->lexer
);
15066 /* If we have seen a nested-name-specifier, and the next token
15067 is `template', then we are using the template-id production. */
15069 && cp_parser_optional_template_keyword (parser
))
15071 /* Look for the template-id. */
15072 type
= cp_parser_template_id (parser
,
15073 /*template_keyword_p=*/true,
15074 /*check_dependency_p=*/true,
15076 /*is_declaration=*/false);
15077 /* If the template-id did not name a type, we are out of
15079 if (TREE_CODE (type
) != TYPE_DECL
)
15081 cp_parser_error (parser
, "expected template-id for type");
15085 /* Otherwise, look for a type-name. */
15087 type
= cp_parser_type_name (parser
);
15088 /* Keep track of all name-lookups performed in class scopes. */
15092 && TREE_CODE (type
) == TYPE_DECL
15093 && identifier_p (DECL_NAME (type
)))
15094 maybe_note_name_used_in_class (DECL_NAME (type
), type
);
15095 /* If it didn't work out, we don't have a TYPE. */
15096 if ((flags
& CP_PARSER_FLAGS_OPTIONAL
)
15097 && !cp_parser_parse_definitely (parser
))
15099 if (type
&& decl_specs
)
15100 cp_parser_set_decl_spec_type (decl_specs
, type
,
15102 /*type_definition_p=*/false);
15105 /* If we didn't get a type-name, issue an error message. */
15106 if (!type
&& !(flags
& CP_PARSER_FLAGS_OPTIONAL
))
15108 cp_parser_error (parser
, "expected type-name");
15109 return error_mark_node
;
15112 if (type
&& type
!= error_mark_node
)
15114 /* See if TYPE is an Objective-C type, and if so, parse and
15115 accept any protocol references following it. Do this before
15116 the cp_parser_check_for_invalid_template_id() call, because
15117 Objective-C types can be followed by '<...>' which would
15118 enclose protocol names rather than template arguments, and so
15119 everything is fine. */
15120 if (c_dialect_objc () && !parser
->scope
15121 && (objc_is_id (type
) || objc_is_class_name (type
)))
15123 tree protos
= cp_parser_objc_protocol_refs_opt (parser
);
15124 tree qual_type
= objc_get_protocol_qualified_type (type
, protos
);
15126 /* Clobber the "unqualified" type previously entered into
15127 DECL_SPECS with the new, improved protocol-qualified version. */
15129 decl_specs
->type
= qual_type
;
15134 /* There is no valid C++ program where a non-template type is
15135 followed by a "<". That usually indicates that the user
15136 thought that the type was a template. */
15137 cp_parser_check_for_invalid_template_id (parser
, TREE_TYPE (type
),
15145 /* Parse a type-name.
15151 simple-template-id [in c++0x]
15159 Returns a TYPE_DECL for the type. */
15162 cp_parser_type_name (cp_parser
* parser
)
15166 /* We can't know yet whether it is a class-name or not. */
15167 cp_parser_parse_tentatively (parser
);
15168 /* Try a class-name. */
15169 type_decl
= cp_parser_class_name (parser
,
15170 /*typename_keyword_p=*/false,
15171 /*template_keyword_p=*/false,
15173 /*check_dependency_p=*/true,
15174 /*class_head_p=*/false,
15175 /*is_declaration=*/false);
15176 /* If it's not a class-name, keep looking. */
15177 if (!cp_parser_parse_definitely (parser
))
15179 if (cxx_dialect
< cxx11
)
15180 /* It must be a typedef-name or an enum-name. */
15181 return cp_parser_nonclass_name (parser
);
15183 cp_parser_parse_tentatively (parser
);
15184 /* It is either a simple-template-id representing an
15185 instantiation of an alias template... */
15186 type_decl
= cp_parser_template_id (parser
,
15187 /*template_keyword_p=*/false,
15188 /*check_dependency_p=*/true,
15190 /*is_declaration=*/false);
15191 /* Note that this must be an instantiation of an alias template
15192 because [temp.names]/6 says:
15194 A template-id that names an alias template specialization
15197 Whereas [temp.names]/7 says:
15199 A simple-template-id that names a class template
15200 specialization is a class-name. */
15201 if (type_decl
!= NULL_TREE
15202 && TREE_CODE (type_decl
) == TYPE_DECL
15203 && TYPE_DECL_ALIAS_P (type_decl
))
15204 gcc_assert (DECL_TEMPLATE_INSTANTIATION (type_decl
));
15206 cp_parser_simulate_error (parser
);
15208 if (!cp_parser_parse_definitely (parser
))
15209 /* ... Or a typedef-name or an enum-name. */
15210 return cp_parser_nonclass_name (parser
);
15216 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
15224 Returns a TYPE_DECL for the type. */
15227 cp_parser_nonclass_name (cp_parser
* parser
)
15232 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
15233 identifier
= cp_parser_identifier (parser
);
15234 if (identifier
== error_mark_node
)
15235 return error_mark_node
;
15237 /* Look up the type-name. */
15238 type_decl
= cp_parser_lookup_name_simple (parser
, identifier
, token
->location
);
15240 type_decl
= strip_using_decl (type_decl
);
15242 if (TREE_CODE (type_decl
) != TYPE_DECL
15243 && (objc_is_id (identifier
) || objc_is_class_name (identifier
)))
15245 /* See if this is an Objective-C type. */
15246 tree protos
= cp_parser_objc_protocol_refs_opt (parser
);
15247 tree type
= objc_get_protocol_qualified_type (identifier
, protos
);
15249 type_decl
= TYPE_NAME (type
);
15252 /* Issue an error if we did not find a type-name. */
15253 if (TREE_CODE (type_decl
) != TYPE_DECL
15254 /* In Objective-C, we have the complication that class names are
15255 normally type names and start declarations (eg, the
15256 "NSObject" in "NSObject *object;"), but can be used in an
15257 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
15258 is an expression. So, a classname followed by a dot is not a
15259 valid type-name. */
15260 || (objc_is_class_name (TREE_TYPE (type_decl
))
15261 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_DOT
))
15263 if (!cp_parser_simulate_error (parser
))
15264 cp_parser_name_lookup_error (parser
, identifier
, type_decl
,
15265 NLE_TYPE
, token
->location
);
15266 return error_mark_node
;
15268 /* Remember that the name was used in the definition of the
15269 current class so that we can check later to see if the
15270 meaning would have been different after the class was
15271 entirely defined. */
15272 else if (type_decl
!= error_mark_node
15274 maybe_note_name_used_in_class (identifier
, type_decl
);
15279 /* Parse an elaborated-type-specifier. Note that the grammar given
15280 here incorporates the resolution to DR68.
15282 elaborated-type-specifier:
15283 class-key :: [opt] nested-name-specifier [opt] identifier
15284 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
15285 enum-key :: [opt] nested-name-specifier [opt] identifier
15286 typename :: [opt] nested-name-specifier identifier
15287 typename :: [opt] nested-name-specifier template [opt]
15292 elaborated-type-specifier:
15293 class-key attributes :: [opt] nested-name-specifier [opt] identifier
15294 class-key attributes :: [opt] nested-name-specifier [opt]
15295 template [opt] template-id
15296 enum attributes :: [opt] nested-name-specifier [opt] identifier
15298 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
15299 declared `friend'. If IS_DECLARATION is TRUE, then this
15300 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
15301 something is being declared.
15303 Returns the TYPE specified. */
15306 cp_parser_elaborated_type_specifier (cp_parser
* parser
,
15308 bool is_declaration
)
15310 enum tag_types tag_type
;
15312 tree type
= NULL_TREE
;
15313 tree attributes
= NULL_TREE
;
15315 cp_token
*token
= NULL
;
15317 /* See if we're looking at the `enum' keyword. */
15318 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ENUM
))
15320 /* Consume the `enum' token. */
15321 cp_lexer_consume_token (parser
->lexer
);
15322 /* Remember that it's an enumeration type. */
15323 tag_type
= enum_type
;
15324 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
15325 enums) is used here. */
15326 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CLASS
)
15327 || cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STRUCT
))
15329 pedwarn (input_location
, 0, "elaborated-type-specifier "
15330 "for a scoped enum must not use the %<%D%> keyword",
15331 cp_lexer_peek_token (parser
->lexer
)->u
.value
);
15332 /* Consume the `struct' or `class' and parse it anyway. */
15333 cp_lexer_consume_token (parser
->lexer
);
15335 /* Parse the attributes. */
15336 attributes
= cp_parser_attributes_opt (parser
);
15338 /* Or, it might be `typename'. */
15339 else if (cp_lexer_next_token_is_keyword (parser
->lexer
,
15342 /* Consume the `typename' token. */
15343 cp_lexer_consume_token (parser
->lexer
);
15344 /* Remember that it's a `typename' type. */
15345 tag_type
= typename_type
;
15347 /* Otherwise it must be a class-key. */
15350 tag_type
= cp_parser_class_key (parser
);
15351 if (tag_type
== none_type
)
15352 return error_mark_node
;
15353 /* Parse the attributes. */
15354 attributes
= cp_parser_attributes_opt (parser
);
15357 /* Look for the `::' operator. */
15358 globalscope
= cp_parser_global_scope_opt (parser
,
15359 /*current_scope_valid_p=*/false);
15360 /* Look for the nested-name-specifier. */
15361 if (tag_type
== typename_type
&& !globalscope
)
15363 if (!cp_parser_nested_name_specifier (parser
,
15364 /*typename_keyword_p=*/true,
15365 /*check_dependency_p=*/true,
15368 return error_mark_node
;
15371 /* Even though `typename' is not present, the proposed resolution
15372 to Core Issue 180 says that in `class A<T>::B', `B' should be
15373 considered a type-name, even if `A<T>' is dependent. */
15374 cp_parser_nested_name_specifier_opt (parser
,
15375 /*typename_keyword_p=*/true,
15376 /*check_dependency_p=*/true,
15379 /* For everything but enumeration types, consider a template-id.
15380 For an enumeration type, consider only a plain identifier. */
15381 if (tag_type
!= enum_type
)
15383 bool template_p
= false;
15386 /* Allow the `template' keyword. */
15387 template_p
= cp_parser_optional_template_keyword (parser
);
15388 /* If we didn't see `template', we don't know if there's a
15389 template-id or not. */
15391 cp_parser_parse_tentatively (parser
);
15392 /* Parse the template-id. */
15393 token
= cp_lexer_peek_token (parser
->lexer
);
15394 decl
= cp_parser_template_id (parser
, template_p
,
15395 /*check_dependency_p=*/true,
15398 /* If we didn't find a template-id, look for an ordinary
15400 if (!template_p
&& !cp_parser_parse_definitely (parser
))
15402 /* We can get here when cp_parser_template_id, called by
15403 cp_parser_class_name with tag_type == none_type, succeeds
15404 and caches a BASELINK. Then, when called again here,
15405 instead of failing and returning an error_mark_node
15406 returns it (see template/typename17.C in C++11).
15407 ??? Could we diagnose this earlier? */
15408 else if (tag_type
== typename_type
&& BASELINK_P (decl
))
15410 cp_parser_diagnose_invalid_type_name (parser
, decl
, token
->location
);
15411 type
= error_mark_node
;
15413 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
15414 in effect, then we must assume that, upon instantiation, the
15415 template will correspond to a class. */
15416 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
15417 && tag_type
== typename_type
)
15418 type
= make_typename_type (parser
->scope
, decl
,
15420 /*complain=*/tf_error
);
15421 /* If the `typename' keyword is in effect and DECL is not a type
15422 decl, then type is non existent. */
15423 else if (tag_type
== typename_type
&& TREE_CODE (decl
) != TYPE_DECL
)
15425 else if (TREE_CODE (decl
) == TYPE_DECL
)
15426 type
= check_elaborated_type_specifier (tag_type
, decl
,
15427 /*allow_template_p=*/true);
15428 else if (decl
== error_mark_node
)
15429 type
= error_mark_node
;
15434 token
= cp_lexer_peek_token (parser
->lexer
);
15435 identifier
= cp_parser_identifier (parser
);
15437 if (identifier
== error_mark_node
)
15439 parser
->scope
= NULL_TREE
;
15440 return error_mark_node
;
15443 /* For a `typename', we needn't call xref_tag. */
15444 if (tag_type
== typename_type
15445 && TREE_CODE (parser
->scope
) != NAMESPACE_DECL
)
15446 return cp_parser_make_typename_type (parser
, identifier
,
15449 /* Template parameter lists apply only if we are not within a
15450 function parameter list. */
15451 bool template_parm_lists_apply
15452 = parser
->num_template_parameter_lists
;
15453 if (template_parm_lists_apply
)
15454 for (cp_binding_level
*s
= current_binding_level
;
15455 s
&& s
->kind
!= sk_template_parms
;
15456 s
= s
->level_chain
)
15457 if (s
->kind
== sk_function_parms
)
15458 template_parm_lists_apply
= false;
15460 /* Look up a qualified name in the usual way. */
15464 tree ambiguous_decls
;
15466 decl
= cp_parser_lookup_name (parser
, identifier
,
15468 /*is_template=*/false,
15469 /*is_namespace=*/false,
15470 /*check_dependency=*/true,
15474 /* If the lookup was ambiguous, an error will already have been
15476 if (ambiguous_decls
)
15477 return error_mark_node
;
15479 /* If we are parsing friend declaration, DECL may be a
15480 TEMPLATE_DECL tree node here. However, we need to check
15481 whether this TEMPLATE_DECL results in valid code. Consider
15482 the following example:
15485 template <class T> class C {};
15488 template <class T> friend class N::C; // #1, valid code
15490 template <class T> class Y {
15491 friend class N::C; // #2, invalid code
15494 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
15495 name lookup of `N::C'. We see that friend declaration must
15496 be template for the code to be valid. Note that
15497 processing_template_decl does not work here since it is
15498 always 1 for the above two cases. */
15500 decl
= (cp_parser_maybe_treat_template_as_class
15501 (decl
, /*tag_name_p=*/is_friend
15502 && template_parm_lists_apply
));
15504 if (TREE_CODE (decl
) != TYPE_DECL
)
15506 cp_parser_diagnose_invalid_type_name (parser
,
15509 return error_mark_node
;
15512 if (TREE_CODE (TREE_TYPE (decl
)) != TYPENAME_TYPE
)
15514 bool allow_template
= (template_parm_lists_apply
15515 || DECL_SELF_REFERENCE_P (decl
));
15516 type
= check_elaborated_type_specifier (tag_type
, decl
,
15519 if (type
== error_mark_node
)
15520 return error_mark_node
;
15523 /* Forward declarations of nested types, such as
15528 are invalid unless all components preceding the final '::'
15529 are complete. If all enclosing types are complete, these
15530 declarations become merely pointless.
15532 Invalid forward declarations of nested types are errors
15533 caught elsewhere in parsing. Those that are pointless arrive
15536 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
15537 && !is_friend
&& !processing_explicit_instantiation
)
15538 warning (0, "declaration %qD does not declare anything", decl
);
15540 type
= TREE_TYPE (decl
);
15544 /* An elaborated-type-specifier sometimes introduces a new type and
15545 sometimes names an existing type. Normally, the rule is that it
15546 introduces a new type only if there is not an existing type of
15547 the same name already in scope. For example, given:
15550 void f() { struct S s; }
15552 the `struct S' in the body of `f' is the same `struct S' as in
15553 the global scope; the existing definition is used. However, if
15554 there were no global declaration, this would introduce a new
15555 local class named `S'.
15557 An exception to this rule applies to the following code:
15559 namespace N { struct S; }
15561 Here, the elaborated-type-specifier names a new type
15562 unconditionally; even if there is already an `S' in the
15563 containing scope this declaration names a new type.
15564 This exception only applies if the elaborated-type-specifier
15565 forms the complete declaration:
15569 A declaration consisting solely of `class-key identifier ;' is
15570 either a redeclaration of the name in the current scope or a
15571 forward declaration of the identifier as a class name. It
15572 introduces the name into the current scope.
15574 We are in this situation precisely when the next token is a `;'.
15576 An exception to the exception is that a `friend' declaration does
15577 *not* name a new type; i.e., given:
15579 struct S { friend struct T; };
15581 `T' is not a new type in the scope of `S'.
15583 Also, `new struct S' or `sizeof (struct S)' never results in the
15584 definition of a new type; a new type can only be declared in a
15585 declaration context. */
15591 /* Friends have special name lookup rules. */
15592 ts
= ts_within_enclosing_non_class
;
15593 else if (is_declaration
15594 && cp_lexer_next_token_is (parser
->lexer
,
15596 /* This is a `class-key identifier ;' */
15602 (template_parm_lists_apply
15603 && (cp_parser_next_token_starts_class_definition_p (parser
)
15604 || cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)));
15605 /* An unqualified name was used to reference this type, so
15606 there were no qualifying templates. */
15607 if (template_parm_lists_apply
15608 && !cp_parser_check_template_parameters (parser
,
15609 /*num_templates=*/0,
15611 /*declarator=*/NULL
))
15612 return error_mark_node
;
15613 type
= xref_tag (tag_type
, identifier
, ts
, template_p
);
15617 if (type
== error_mark_node
)
15618 return error_mark_node
;
15620 /* Allow attributes on forward declarations of classes. */
15623 if (TREE_CODE (type
) == TYPENAME_TYPE
)
15624 warning (OPT_Wattributes
,
15625 "attributes ignored on uninstantiated type");
15626 else if (tag_type
!= enum_type
&& CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
15627 && ! processing_explicit_instantiation
)
15628 warning (OPT_Wattributes
,
15629 "attributes ignored on template instantiation");
15630 else if (is_declaration
&& cp_parser_declares_only_class_p (parser
))
15631 cplus_decl_attributes (&type
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
15633 warning (OPT_Wattributes
,
15634 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
15637 if (tag_type
!= enum_type
)
15639 /* Indicate whether this class was declared as a `class' or as a
15641 if (TREE_CODE (type
) == RECORD_TYPE
)
15642 CLASSTYPE_DECLARED_CLASS (type
) = (tag_type
== class_type
);
15643 cp_parser_check_class_key (tag_type
, type
);
15646 /* A "<" cannot follow an elaborated type specifier. If that
15647 happens, the user was probably trying to form a template-id. */
15648 cp_parser_check_for_invalid_template_id (parser
, type
, tag_type
,
15654 /* Parse an enum-specifier.
15657 enum-head { enumerator-list [opt] }
15658 enum-head { enumerator-list , } [C++0x]
15661 enum-key identifier [opt] enum-base [opt]
15662 enum-key nested-name-specifier identifier enum-base [opt]
15667 enum struct [C++0x]
15670 : type-specifier-seq
15672 opaque-enum-specifier:
15673 enum-key identifier enum-base [opt] ;
15676 enum-key attributes[opt] identifier [opt] enum-base [opt]
15677 { enumerator-list [opt] }attributes[opt]
15678 enum-key attributes[opt] identifier [opt] enum-base [opt]
15679 { enumerator-list, }attributes[opt] [C++0x]
15681 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
15682 if the token stream isn't an enum-specifier after all. */
15685 cp_parser_enum_specifier (cp_parser
* parser
)
15688 tree type
= NULL_TREE
;
15690 tree nested_name_specifier
= NULL_TREE
;
15692 bool scoped_enum_p
= false;
15693 bool has_underlying_type
= false;
15694 bool nested_being_defined
= false;
15695 bool new_value_list
= false;
15696 bool is_new_type
= false;
15697 bool is_anonymous
= false;
15698 tree underlying_type
= NULL_TREE
;
15699 cp_token
*type_start_token
= NULL
;
15700 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
15702 parser
->colon_corrects_to_scope_p
= false;
15704 /* Parse tentatively so that we can back up if we don't find a
15706 cp_parser_parse_tentatively (parser
);
15708 /* Caller guarantees that the current token is 'enum', an identifier
15709 possibly follows, and the token after that is an opening brace.
15710 If we don't have an identifier, fabricate an anonymous name for
15711 the enumeration being defined. */
15712 cp_lexer_consume_token (parser
->lexer
);
15714 /* Parse the "class" or "struct", which indicates a scoped
15715 enumeration type in C++0x. */
15716 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CLASS
)
15717 || cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STRUCT
))
15719 if (cxx_dialect
< cxx11
)
15720 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS
);
15722 /* Consume the `struct' or `class' token. */
15723 cp_lexer_consume_token (parser
->lexer
);
15725 scoped_enum_p
= true;
15728 attributes
= cp_parser_attributes_opt (parser
);
15730 /* Clear the qualification. */
15731 parser
->scope
= NULL_TREE
;
15732 parser
->qualifying_scope
= NULL_TREE
;
15733 parser
->object_scope
= NULL_TREE
;
15735 /* Figure out in what scope the declaration is being placed. */
15736 prev_scope
= current_scope ();
15738 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
15740 push_deferring_access_checks (dk_no_check
);
15741 nested_name_specifier
15742 = cp_parser_nested_name_specifier_opt (parser
,
15743 /*typename_keyword_p=*/true,
15744 /*check_dependency_p=*/false,
15746 /*is_declaration=*/false);
15748 if (nested_name_specifier
)
15752 identifier
= cp_parser_identifier (parser
);
15753 name
= cp_parser_lookup_name (parser
, identifier
,
15755 /*is_template=*/false,
15756 /*is_namespace=*/false,
15757 /*check_dependency=*/true,
15758 /*ambiguous_decls=*/NULL
,
15760 if (name
&& name
!= error_mark_node
)
15762 type
= TREE_TYPE (name
);
15763 if (TREE_CODE (type
) == TYPENAME_TYPE
)
15765 /* Are template enums allowed in ISO? */
15766 if (template_parm_scope_p ())
15767 pedwarn (type_start_token
->location
, OPT_Wpedantic
,
15768 "%qD is an enumeration template", name
);
15769 /* ignore a typename reference, for it will be solved by name
15774 else if (nested_name_specifier
== error_mark_node
)
15775 /* We already issued an error. */;
15777 error_at (type_start_token
->location
,
15778 "%qD is not an enumerator-name", identifier
);
15782 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
15783 identifier
= cp_parser_identifier (parser
);
15786 identifier
= make_anon_name ();
15787 is_anonymous
= true;
15789 error_at (type_start_token
->location
,
15790 "anonymous scoped enum is not allowed");
15793 pop_deferring_access_checks ();
15795 /* Check for the `:' that denotes a specified underlying type in C++0x.
15796 Note that a ':' could also indicate a bitfield width, however. */
15797 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
15799 cp_decl_specifier_seq type_specifiers
;
15801 /* Consume the `:'. */
15802 cp_lexer_consume_token (parser
->lexer
);
15804 /* Parse the type-specifier-seq. */
15805 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
15806 /*is_trailing_return=*/false,
15809 /* At this point this is surely not elaborated type specifier. */
15810 if (!cp_parser_parse_definitely (parser
))
15813 if (cxx_dialect
< cxx11
)
15814 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS
);
15816 has_underlying_type
= true;
15818 /* If that didn't work, stop. */
15819 if (type_specifiers
.type
!= error_mark_node
)
15821 underlying_type
= grokdeclarator (NULL
, &type_specifiers
, TYPENAME
,
15822 /*initialized=*/0, NULL
);
15823 if (underlying_type
== error_mark_node
15824 || check_for_bare_parameter_packs (underlying_type
))
15825 underlying_type
= NULL_TREE
;
15829 /* Look for the `{' but don't consume it yet. */
15830 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
15832 if (cxx_dialect
< cxx11
|| (!scoped_enum_p
&& !underlying_type
))
15834 cp_parser_error (parser
, "expected %<{%>");
15835 if (has_underlying_type
)
15841 /* An opaque-enum-specifier must have a ';' here. */
15842 if ((scoped_enum_p
|| underlying_type
)
15843 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
15845 cp_parser_error (parser
, "expected %<;%> or %<{%>");
15846 if (has_underlying_type
)
15854 if (!has_underlying_type
&& !cp_parser_parse_definitely (parser
))
15857 if (nested_name_specifier
)
15859 if (CLASS_TYPE_P (nested_name_specifier
))
15861 nested_being_defined
= TYPE_BEING_DEFINED (nested_name_specifier
);
15862 TYPE_BEING_DEFINED (nested_name_specifier
) = 1;
15863 push_scope (nested_name_specifier
);
15865 else if (TREE_CODE (nested_name_specifier
) == NAMESPACE_DECL
)
15867 push_nested_namespace (nested_name_specifier
);
15871 /* Issue an error message if type-definitions are forbidden here. */
15872 if (!cp_parser_check_type_definition (parser
))
15873 type
= error_mark_node
;
15875 /* Create the new type. We do this before consuming the opening
15876 brace so the enum will be recorded as being on the line of its
15877 tag (or the 'enum' keyword, if there is no tag). */
15878 type
= start_enum (identifier
, type
, underlying_type
,
15879 scoped_enum_p
, &is_new_type
);
15881 /* If the next token is not '{' it is an opaque-enum-specifier or an
15882 elaborated-type-specifier. */
15883 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
15885 timevar_push (TV_PARSE_ENUM
);
15886 if (nested_name_specifier
15887 && nested_name_specifier
!= error_mark_node
)
15889 /* The following catches invalid code such as:
15890 enum class S<int>::E { A, B, C }; */
15891 if (!processing_specialization
15892 && CLASS_TYPE_P (nested_name_specifier
)
15893 && CLASSTYPE_USE_TEMPLATE (nested_name_specifier
))
15894 error_at (type_start_token
->location
, "cannot add an enumerator "
15895 "list to a template instantiation");
15897 if (TREE_CODE (nested_name_specifier
) == TYPENAME_TYPE
)
15899 error_at (type_start_token
->location
,
15900 "%<%T::%E%> has not been declared",
15901 TYPE_CONTEXT (nested_name_specifier
),
15902 nested_name_specifier
);
15903 type
= error_mark_node
;
15905 /* If that scope does not contain the scope in which the
15906 class was originally declared, the program is invalid. */
15907 else if (prev_scope
&& !is_ancestor (prev_scope
,
15908 nested_name_specifier
))
15910 if (at_namespace_scope_p ())
15911 error_at (type_start_token
->location
,
15912 "declaration of %qD in namespace %qD which does not "
15914 type
, prev_scope
, nested_name_specifier
);
15916 error_at (type_start_token
->location
,
15917 "declaration of %qD in %qD which does not "
15919 type
, prev_scope
, nested_name_specifier
);
15920 type
= error_mark_node
;
15925 begin_scope (sk_scoped_enum
, type
);
15927 /* Consume the opening brace. */
15928 cp_lexer_consume_token (parser
->lexer
);
15930 if (type
== error_mark_node
)
15931 ; /* Nothing to add */
15932 else if (OPAQUE_ENUM_P (type
)
15933 || (cxx_dialect
> cxx98
&& processing_specialization
))
15935 new_value_list
= true;
15936 SET_OPAQUE_ENUM_P (type
, false);
15937 DECL_SOURCE_LOCATION (TYPE_NAME (type
)) = type_start_token
->location
;
15941 error_at (type_start_token
->location
,
15942 "multiple definition of %q#T", type
);
15943 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
15944 "previous definition here");
15945 type
= error_mark_node
;
15948 if (type
== error_mark_node
)
15949 cp_parser_skip_to_end_of_block_or_statement (parser
);
15950 /* If the next token is not '}', then there are some enumerators. */
15951 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
15953 if (is_anonymous
&& !scoped_enum_p
)
15954 pedwarn (type_start_token
->location
, OPT_Wpedantic
,
15955 "ISO C++ forbids empty anonymous enum");
15958 cp_parser_enumerator_list (parser
, type
);
15960 /* Consume the final '}'. */
15961 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
15965 timevar_pop (TV_PARSE_ENUM
);
15969 /* If a ';' follows, then it is an opaque-enum-specifier
15970 and additional restrictions apply. */
15971 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
15974 error_at (type_start_token
->location
,
15975 "opaque-enum-specifier without name");
15976 else if (nested_name_specifier
)
15977 error_at (type_start_token
->location
,
15978 "opaque-enum-specifier must use a simple identifier");
15982 /* Look for trailing attributes to apply to this enumeration, and
15983 apply them if appropriate. */
15984 if (cp_parser_allow_gnu_extensions_p (parser
))
15986 tree trailing_attr
= cp_parser_gnu_attributes_opt (parser
);
15987 trailing_attr
= chainon (trailing_attr
, attributes
);
15988 cplus_decl_attributes (&type
,
15990 (int) ATTR_FLAG_TYPE_IN_PLACE
);
15993 /* Finish up the enumeration. */
15994 if (type
!= error_mark_node
)
15996 if (new_value_list
)
15997 finish_enum_value_list (type
);
15999 finish_enum (type
);
16002 if (nested_name_specifier
)
16004 if (CLASS_TYPE_P (nested_name_specifier
))
16006 TYPE_BEING_DEFINED (nested_name_specifier
) = nested_being_defined
;
16007 pop_scope (nested_name_specifier
);
16009 else if (TREE_CODE (nested_name_specifier
) == NAMESPACE_DECL
)
16011 pop_nested_namespace (nested_name_specifier
);
16015 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
16019 /* Parse an enumerator-list. The enumerators all have the indicated
16023 enumerator-definition
16024 enumerator-list , enumerator-definition */
16027 cp_parser_enumerator_list (cp_parser
* parser
, tree type
)
16031 /* Parse an enumerator-definition. */
16032 cp_parser_enumerator_definition (parser
, type
);
16034 /* If the next token is not a ',', we've reached the end of
16036 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
16038 /* Otherwise, consume the `,' and keep going. */
16039 cp_lexer_consume_token (parser
->lexer
);
16040 /* If the next token is a `}', there is a trailing comma. */
16041 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
16043 if (cxx_dialect
< cxx11
&& !in_system_header_at (input_location
))
16044 pedwarn (input_location
, OPT_Wpedantic
,
16045 "comma at end of enumerator list");
16051 /* Parse an enumerator-definition. The enumerator has the indicated
16054 enumerator-definition:
16056 enumerator = constant-expression
16062 cp_parser_enumerator_definition (cp_parser
* parser
, tree type
)
16068 /* Save the input location because we are interested in the location
16069 of the identifier and not the location of the explicit value. */
16070 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
16072 /* Look for the identifier. */
16073 identifier
= cp_parser_identifier (parser
);
16074 if (identifier
== error_mark_node
)
16077 /* If the next token is an '=', then there is an explicit value. */
16078 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
16080 /* Consume the `=' token. */
16081 cp_lexer_consume_token (parser
->lexer
);
16082 /* Parse the value. */
16083 value
= cp_parser_constant_expression (parser
);
16088 /* If we are processing a template, make sure the initializer of the
16089 enumerator doesn't contain any bare template parameter pack. */
16090 if (check_for_bare_parameter_packs (value
))
16091 value
= error_mark_node
;
16093 /* Create the enumerator. */
16094 build_enumerator (identifier
, value
, type
, loc
);
16097 /* Parse a namespace-name.
16100 original-namespace-name
16103 Returns the NAMESPACE_DECL for the namespace. */
16106 cp_parser_namespace_name (cp_parser
* parser
)
16109 tree namespace_decl
;
16111 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
16113 /* Get the name of the namespace. */
16114 identifier
= cp_parser_identifier (parser
);
16115 if (identifier
== error_mark_node
)
16116 return error_mark_node
;
16118 /* Look up the identifier in the currently active scope. Look only
16119 for namespaces, due to:
16121 [basic.lookup.udir]
16123 When looking up a namespace-name in a using-directive or alias
16124 definition, only namespace names are considered.
16128 [basic.lookup.qual]
16130 During the lookup of a name preceding the :: scope resolution
16131 operator, object, function, and enumerator names are ignored.
16133 (Note that cp_parser_qualifying_entity only calls this
16134 function if the token after the name is the scope resolution
16136 namespace_decl
= cp_parser_lookup_name (parser
, identifier
,
16138 /*is_template=*/false,
16139 /*is_namespace=*/true,
16140 /*check_dependency=*/true,
16141 /*ambiguous_decls=*/NULL
,
16143 /* If it's not a namespace, issue an error. */
16144 if (namespace_decl
== error_mark_node
16145 || TREE_CODE (namespace_decl
) != NAMESPACE_DECL
)
16147 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
16148 error_at (token
->location
, "%qD is not a namespace-name", identifier
);
16149 cp_parser_error (parser
, "expected namespace-name");
16150 namespace_decl
= error_mark_node
;
16153 return namespace_decl
;
16156 /* Parse a namespace-definition.
16158 namespace-definition:
16159 named-namespace-definition
16160 unnamed-namespace-definition
16162 named-namespace-definition:
16163 original-namespace-definition
16164 extension-namespace-definition
16166 original-namespace-definition:
16167 namespace identifier { namespace-body }
16169 extension-namespace-definition:
16170 namespace original-namespace-name { namespace-body }
16172 unnamed-namespace-definition:
16173 namespace { namespace-body } */
16176 cp_parser_namespace_definition (cp_parser
* parser
)
16178 tree identifier
, attribs
;
16179 bool has_visibility
;
16182 cp_ensure_no_omp_declare_simd (parser
);
16183 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_INLINE
))
16185 maybe_warn_cpp0x (CPP0X_INLINE_NAMESPACES
);
16187 cp_lexer_consume_token (parser
->lexer
);
16192 /* Look for the `namespace' keyword. */
16193 cp_parser_require_keyword (parser
, RID_NAMESPACE
, RT_NAMESPACE
);
16195 /* Get the name of the namespace. We do not attempt to distinguish
16196 between an original-namespace-definition and an
16197 extension-namespace-definition at this point. The semantic
16198 analysis routines are responsible for that. */
16199 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
16200 identifier
= cp_parser_identifier (parser
);
16202 identifier
= NULL_TREE
;
16204 /* Parse any specified attributes. */
16205 attribs
= cp_parser_attributes_opt (parser
);
16207 /* Look for the `{' to start the namespace. */
16208 cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
);
16209 /* Start the namespace. */
16210 push_namespace (identifier
);
16212 /* "inline namespace" is equivalent to a stub namespace definition
16213 followed by a strong using directive. */
16216 tree name_space
= current_namespace
;
16217 /* Set up namespace association. */
16218 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
16219 = tree_cons (CP_DECL_CONTEXT (name_space
), NULL_TREE
,
16220 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
16221 /* Import the contents of the inline namespace. */
16223 do_using_directive (name_space
);
16224 push_namespace (identifier
);
16227 has_visibility
= handle_namespace_attrs (current_namespace
, attribs
);
16229 /* Parse the body of the namespace. */
16230 cp_parser_namespace_body (parser
);
16232 if (has_visibility
)
16233 pop_visibility (1);
16235 /* Finish the namespace. */
16237 /* Look for the final `}'. */
16238 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
16241 /* Parse a namespace-body.
16244 declaration-seq [opt] */
16247 cp_parser_namespace_body (cp_parser
* parser
)
16249 cp_parser_declaration_seq_opt (parser
);
16252 /* Parse a namespace-alias-definition.
16254 namespace-alias-definition:
16255 namespace identifier = qualified-namespace-specifier ; */
16258 cp_parser_namespace_alias_definition (cp_parser
* parser
)
16261 tree namespace_specifier
;
16263 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
16265 /* Look for the `namespace' keyword. */
16266 cp_parser_require_keyword (parser
, RID_NAMESPACE
, RT_NAMESPACE
);
16267 /* Look for the identifier. */
16268 identifier
= cp_parser_identifier (parser
);
16269 if (identifier
== error_mark_node
)
16271 /* Look for the `=' token. */
16272 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
)
16273 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
16275 error_at (token
->location
, "%<namespace%> definition is not allowed here");
16276 /* Skip the definition. */
16277 cp_lexer_consume_token (parser
->lexer
);
16278 if (cp_parser_skip_to_closing_brace (parser
))
16279 cp_lexer_consume_token (parser
->lexer
);
16282 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
16283 /* Look for the qualified-namespace-specifier. */
16284 namespace_specifier
16285 = cp_parser_qualified_namespace_specifier (parser
);
16286 /* Look for the `;' token. */
16287 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16289 /* Register the alias in the symbol table. */
16290 do_namespace_alias (identifier
, namespace_specifier
);
16293 /* Parse a qualified-namespace-specifier.
16295 qualified-namespace-specifier:
16296 :: [opt] nested-name-specifier [opt] namespace-name
16298 Returns a NAMESPACE_DECL corresponding to the specified
16302 cp_parser_qualified_namespace_specifier (cp_parser
* parser
)
16304 /* Look for the optional `::'. */
16305 cp_parser_global_scope_opt (parser
,
16306 /*current_scope_valid_p=*/false);
16308 /* Look for the optional nested-name-specifier. */
16309 cp_parser_nested_name_specifier_opt (parser
,
16310 /*typename_keyword_p=*/false,
16311 /*check_dependency_p=*/true,
16313 /*is_declaration=*/true);
16315 return cp_parser_namespace_name (parser
);
16318 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
16319 access declaration.
16322 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
16323 using :: unqualified-id ;
16325 access-declaration:
16331 cp_parser_using_declaration (cp_parser
* parser
,
16332 bool access_declaration_p
)
16335 bool typename_p
= false;
16336 bool global_scope_p
;
16340 int oldcount
= errorcount
;
16341 cp_token
*diag_token
= NULL
;
16343 if (access_declaration_p
)
16345 diag_token
= cp_lexer_peek_token (parser
->lexer
);
16346 cp_parser_parse_tentatively (parser
);
16350 /* Look for the `using' keyword. */
16351 cp_parser_require_keyword (parser
, RID_USING
, RT_USING
);
16353 /* Peek at the next token. */
16354 token
= cp_lexer_peek_token (parser
->lexer
);
16355 /* See if it's `typename'. */
16356 if (token
->keyword
== RID_TYPENAME
)
16358 /* Remember that we've seen it. */
16360 /* Consume the `typename' token. */
16361 cp_lexer_consume_token (parser
->lexer
);
16365 /* Look for the optional global scope qualification. */
16367 = (cp_parser_global_scope_opt (parser
,
16368 /*current_scope_valid_p=*/false)
16371 /* If we saw `typename', or didn't see `::', then there must be a
16372 nested-name-specifier present. */
16373 if (typename_p
|| !global_scope_p
)
16375 qscope
= cp_parser_nested_name_specifier (parser
, typename_p
,
16376 /*check_dependency_p=*/true,
16378 /*is_declaration=*/true);
16379 if (!qscope
&& !cp_parser_uncommitted_to_tentative_parse_p (parser
))
16381 cp_parser_skip_to_end_of_block_or_statement (parser
);
16385 /* Otherwise, we could be in either of the two productions. In that
16386 case, treat the nested-name-specifier as optional. */
16388 qscope
= cp_parser_nested_name_specifier_opt (parser
,
16389 /*typename_keyword_p=*/false,
16390 /*check_dependency_p=*/true,
16392 /*is_declaration=*/true);
16394 qscope
= global_namespace
;
16395 else if (UNSCOPED_ENUM_P (qscope
))
16396 qscope
= CP_TYPE_CONTEXT (qscope
);
16398 if (access_declaration_p
&& cp_parser_error_occurred (parser
))
16399 /* Something has already gone wrong; there's no need to parse
16400 further. Since an error has occurred, the return value of
16401 cp_parser_parse_definitely will be false, as required. */
16402 return cp_parser_parse_definitely (parser
);
16404 token
= cp_lexer_peek_token (parser
->lexer
);
16405 /* Parse the unqualified-id. */
16406 identifier
= cp_parser_unqualified_id (parser
,
16407 /*template_keyword_p=*/false,
16408 /*check_dependency_p=*/true,
16409 /*declarator_p=*/true,
16410 /*optional_p=*/false);
16412 if (access_declaration_p
)
16414 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
16415 cp_parser_simulate_error (parser
);
16416 if (!cp_parser_parse_definitely (parser
))
16420 /* The function we call to handle a using-declaration is different
16421 depending on what scope we are in. */
16422 if (qscope
== error_mark_node
|| identifier
== error_mark_node
)
16424 else if (!identifier_p (identifier
)
16425 && TREE_CODE (identifier
) != BIT_NOT_EXPR
)
16426 /* [namespace.udecl]
16428 A using declaration shall not name a template-id. */
16429 error_at (token
->location
,
16430 "a template-id may not appear in a using-declaration");
16433 if (at_class_scope_p ())
16435 /* Create the USING_DECL. */
16436 decl
= do_class_using_decl (parser
->scope
, identifier
);
16438 if (decl
&& typename_p
)
16439 USING_DECL_TYPENAME_P (decl
) = 1;
16441 if (check_for_bare_parameter_packs (decl
))
16443 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16447 /* Add it to the list of members in this class. */
16448 finish_member_declaration (decl
);
16452 decl
= cp_parser_lookup_name_simple (parser
,
16455 if (decl
== error_mark_node
)
16456 cp_parser_name_lookup_error (parser
, identifier
,
16459 else if (check_for_bare_parameter_packs (decl
))
16461 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16464 else if (!at_namespace_scope_p ())
16465 do_local_using_decl (decl
, qscope
, identifier
);
16467 do_toplevel_using_decl (decl
, qscope
, identifier
);
16471 /* Look for the final `;'. */
16472 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16474 if (access_declaration_p
&& errorcount
== oldcount
)
16475 warning_at (diag_token
->location
, OPT_Wdeprecated
,
16476 "access declarations are deprecated "
16477 "in favour of using-declarations; "
16478 "suggestion: add the %<using%> keyword");
16483 /* Parse an alias-declaration.
16486 using identifier attribute-specifier-seq [opt] = type-id */
16489 cp_parser_alias_declaration (cp_parser
* parser
)
16491 tree id
, type
, decl
, pushed_scope
= NULL_TREE
, attributes
;
16492 location_t id_location
;
16493 cp_declarator
*declarator
;
16494 cp_decl_specifier_seq decl_specs
;
16496 const char *saved_message
= NULL
;
16498 /* Look for the `using' keyword. */
16499 cp_token
*using_token
16500 = cp_parser_require_keyword (parser
, RID_USING
, RT_USING
);
16501 if (using_token
== NULL
)
16502 return error_mark_node
;
16504 id_location
= cp_lexer_peek_token (parser
->lexer
)->location
;
16505 id
= cp_parser_identifier (parser
);
16506 if (id
== error_mark_node
)
16507 return error_mark_node
;
16509 cp_token
*attrs_token
= cp_lexer_peek_token (parser
->lexer
);
16510 attributes
= cp_parser_attributes_opt (parser
);
16511 if (attributes
== error_mark_node
)
16512 return error_mark_node
;
16514 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
16516 if (cp_parser_error_occurred (parser
))
16517 return error_mark_node
;
16519 cp_parser_commit_to_tentative_parse (parser
);
16521 /* Now we are going to parse the type-id of the declaration. */
16526 "A type-specifier-seq shall not define a class or enumeration
16527 unless it appears in the type-id of an alias-declaration (7.1.3) that
16528 is not the declaration of a template-declaration."
16530 In other words, if we currently are in an alias template, the
16531 type-id should not define a type.
16533 So let's set parser->type_definition_forbidden_message in that
16534 case; cp_parser_check_type_definition (called by
16535 cp_parser_class_specifier) will then emit an error if a type is
16536 defined in the type-id. */
16537 if (parser
->num_template_parameter_lists
)
16539 saved_message
= parser
->type_definition_forbidden_message
;
16540 parser
->type_definition_forbidden_message
=
16541 G_("types may not be defined in alias template declarations");
16544 type
= cp_parser_type_id (parser
);
16546 /* Restore the error message if need be. */
16547 if (parser
->num_template_parameter_lists
)
16548 parser
->type_definition_forbidden_message
= saved_message
;
16550 if (type
== error_mark_node
16551 || !cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
))
16553 cp_parser_skip_to_end_of_block_or_statement (parser
);
16554 return error_mark_node
;
16557 /* A typedef-name can also be introduced by an alias-declaration. The
16558 identifier following the using keyword becomes a typedef-name. It has
16559 the same semantics as if it were introduced by the typedef
16560 specifier. In particular, it does not define a new type and it shall
16561 not appear in the type-id. */
16563 clear_decl_specs (&decl_specs
);
16564 decl_specs
.type
= type
;
16565 if (attributes
!= NULL_TREE
)
16567 decl_specs
.attributes
= attributes
;
16568 set_and_check_decl_spec_loc (&decl_specs
,
16572 set_and_check_decl_spec_loc (&decl_specs
,
16575 set_and_check_decl_spec_loc (&decl_specs
,
16579 declarator
= make_id_declarator (NULL_TREE
, id
, sfk_none
);
16580 declarator
->id_loc
= id_location
;
16582 member_p
= at_class_scope_p ();
16584 decl
= grokfield (declarator
, &decl_specs
, NULL_TREE
, false,
16585 NULL_TREE
, attributes
);
16587 decl
= start_decl (declarator
, &decl_specs
, 0,
16588 attributes
, NULL_TREE
, &pushed_scope
);
16589 if (decl
== error_mark_node
)
16592 cp_finish_decl (decl
, NULL_TREE
, 0, NULL_TREE
, 0);
16595 pop_scope (pushed_scope
);
16597 /* If decl is a template, return its TEMPLATE_DECL so that it gets
16598 added into the symbol table; otherwise, return the TYPE_DECL. */
16599 if (DECL_LANG_SPECIFIC (decl
)
16600 && DECL_TEMPLATE_INFO (decl
)
16601 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
16603 decl
= DECL_TI_TEMPLATE (decl
);
16605 check_member_template (decl
);
16611 /* Parse a using-directive.
16614 using namespace :: [opt] nested-name-specifier [opt]
16615 namespace-name ; */
16618 cp_parser_using_directive (cp_parser
* parser
)
16620 tree namespace_decl
;
16623 /* Look for the `using' keyword. */
16624 cp_parser_require_keyword (parser
, RID_USING
, RT_USING
);
16625 /* And the `namespace' keyword. */
16626 cp_parser_require_keyword (parser
, RID_NAMESPACE
, RT_NAMESPACE
);
16627 /* Look for the optional `::' operator. */
16628 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false);
16629 /* And the optional nested-name-specifier. */
16630 cp_parser_nested_name_specifier_opt (parser
,
16631 /*typename_keyword_p=*/false,
16632 /*check_dependency_p=*/true,
16634 /*is_declaration=*/true);
16635 /* Get the namespace being used. */
16636 namespace_decl
= cp_parser_namespace_name (parser
);
16637 /* And any specified attributes. */
16638 attribs
= cp_parser_attributes_opt (parser
);
16639 /* Update the symbol table. */
16640 parse_using_directive (namespace_decl
, attribs
);
16641 /* Look for the final `;'. */
16642 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16645 /* Parse an asm-definition.
16648 asm ( string-literal ) ;
16653 asm volatile [opt] ( string-literal ) ;
16654 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
16655 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16656 : asm-operand-list [opt] ) ;
16657 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16658 : asm-operand-list [opt]
16659 : asm-clobber-list [opt] ) ;
16660 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
16661 : asm-clobber-list [opt]
16662 : asm-goto-list ) ; */
16665 cp_parser_asm_definition (cp_parser
* parser
)
16668 tree outputs
= NULL_TREE
;
16669 tree inputs
= NULL_TREE
;
16670 tree clobbers
= NULL_TREE
;
16671 tree labels
= NULL_TREE
;
16673 bool volatile_p
= false;
16674 bool extended_p
= false;
16675 bool invalid_inputs_p
= false;
16676 bool invalid_outputs_p
= false;
16677 bool goto_p
= false;
16678 required_token missing
= RT_NONE
;
16680 /* Look for the `asm' keyword. */
16681 cp_parser_require_keyword (parser
, RID_ASM
, RT_ASM
);
16683 if (parser
->in_function_body
16684 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
16686 error ("%<asm%> in %<constexpr%> function");
16687 cp_function_chain
->invalid_constexpr
= true;
16690 /* See if the next token is `volatile'. */
16691 if (cp_parser_allow_gnu_extensions_p (parser
)
16692 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_VOLATILE
))
16694 /* Remember that we saw the `volatile' keyword. */
16696 /* Consume the token. */
16697 cp_lexer_consume_token (parser
->lexer
);
16699 if (cp_parser_allow_gnu_extensions_p (parser
)
16700 && parser
->in_function_body
16701 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_GOTO
))
16703 /* Remember that we saw the `goto' keyword. */
16705 /* Consume the token. */
16706 cp_lexer_consume_token (parser
->lexer
);
16708 /* Look for the opening `('. */
16709 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
16711 /* Look for the string. */
16712 string
= cp_parser_string_literal (parser
, false, false);
16713 if (string
== error_mark_node
)
16715 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
16716 /*consume_paren=*/true);
16720 /* If we're allowing GNU extensions, check for the extended assembly
16721 syntax. Unfortunately, the `:' tokens need not be separated by
16722 a space in C, and so, for compatibility, we tolerate that here
16723 too. Doing that means that we have to treat the `::' operator as
16725 if (cp_parser_allow_gnu_extensions_p (parser
)
16726 && parser
->in_function_body
16727 && (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
)
16728 || cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
)))
16730 bool inputs_p
= false;
16731 bool clobbers_p
= false;
16732 bool labels_p
= false;
16734 /* The extended syntax was used. */
16737 /* Look for outputs. */
16738 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
16740 /* Consume the `:'. */
16741 cp_lexer_consume_token (parser
->lexer
);
16742 /* Parse the output-operands. */
16743 if (cp_lexer_next_token_is_not (parser
->lexer
,
16745 && cp_lexer_next_token_is_not (parser
->lexer
,
16747 && cp_lexer_next_token_is_not (parser
->lexer
,
16751 outputs
= cp_parser_asm_operand_list (parser
);
16752 if (outputs
== error_mark_node
)
16753 invalid_outputs_p
= true;
16756 /* If the next token is `::', there are no outputs, and the
16757 next token is the beginning of the inputs. */
16758 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
16759 /* The inputs are coming next. */
16762 /* Look for inputs. */
16764 || cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
16766 /* Consume the `:' or `::'. */
16767 cp_lexer_consume_token (parser
->lexer
);
16768 /* Parse the output-operands. */
16769 if (cp_lexer_next_token_is_not (parser
->lexer
,
16771 && cp_lexer_next_token_is_not (parser
->lexer
,
16773 && cp_lexer_next_token_is_not (parser
->lexer
,
16776 inputs
= cp_parser_asm_operand_list (parser
);
16777 if (inputs
== error_mark_node
)
16778 invalid_inputs_p
= true;
16781 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
16782 /* The clobbers are coming next. */
16785 /* Look for clobbers. */
16787 || cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
16790 /* Consume the `:' or `::'. */
16791 cp_lexer_consume_token (parser
->lexer
);
16792 /* Parse the clobbers. */
16793 if (cp_lexer_next_token_is_not (parser
->lexer
,
16795 && cp_lexer_next_token_is_not (parser
->lexer
,
16797 clobbers
= cp_parser_asm_clobber_list (parser
);
16800 && cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
16801 /* The labels are coming next. */
16804 /* Look for labels. */
16806 || (goto_p
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
)))
16809 /* Consume the `:' or `::'. */
16810 cp_lexer_consume_token (parser
->lexer
);
16811 /* Parse the labels. */
16812 labels
= cp_parser_asm_label_list (parser
);
16815 if (goto_p
&& !labels_p
)
16816 missing
= clobbers_p
? RT_COLON
: RT_COLON_SCOPE
;
16819 missing
= RT_COLON_SCOPE
;
16821 /* Look for the closing `)'. */
16822 if (!cp_parser_require (parser
, missing
? CPP_COLON
: CPP_CLOSE_PAREN
,
16823 missing
? missing
: RT_CLOSE_PAREN
))
16824 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
16825 /*consume_paren=*/true);
16826 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16828 if (!invalid_inputs_p
&& !invalid_outputs_p
)
16830 /* Create the ASM_EXPR. */
16831 if (parser
->in_function_body
)
16833 asm_stmt
= finish_asm_stmt (volatile_p
, string
, outputs
,
16834 inputs
, clobbers
, labels
);
16835 /* If the extended syntax was not used, mark the ASM_EXPR. */
16838 tree temp
= asm_stmt
;
16839 if (TREE_CODE (temp
) == CLEANUP_POINT_EXPR
)
16840 temp
= TREE_OPERAND (temp
, 0);
16842 ASM_INPUT_P (temp
) = 1;
16846 symtab
->finalize_toplevel_asm (string
);
16850 /* Declarators [gram.dcl.decl] */
16852 /* Parse an init-declarator.
16855 declarator initializer [opt]
16860 declarator asm-specification [opt] attributes [opt] initializer [opt]
16862 function-definition:
16863 decl-specifier-seq [opt] declarator ctor-initializer [opt]
16865 decl-specifier-seq [opt] declarator function-try-block
16869 function-definition:
16870 __extension__ function-definition
16874 function-definition:
16875 decl-specifier-seq [opt] declarator function-transaction-block
16877 The DECL_SPECIFIERS apply to this declarator. Returns a
16878 representation of the entity declared. If MEMBER_P is TRUE, then
16879 this declarator appears in a class scope. The new DECL created by
16880 this declarator is returned.
16882 The CHECKS are access checks that should be performed once we know
16883 what entity is being declared (and, therefore, what classes have
16886 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
16887 for a function-definition here as well. If the declarator is a
16888 declarator for a function-definition, *FUNCTION_DEFINITION_P will
16889 be TRUE upon return. By that point, the function-definition will
16890 have been completely parsed.
16892 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
16895 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
16896 parsed declaration if it is an uninitialized single declarator not followed
16897 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
16898 if present, will not be consumed. If returned, this declarator will be
16899 created with SD_INITIALIZED but will not call cp_finish_decl.
16901 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
16902 and there is an initializer, the pointed location_t is set to the
16903 location of the '=' or `(', or '{' in C++11 token introducing the
16907 cp_parser_init_declarator (cp_parser
* parser
,
16908 cp_decl_specifier_seq
*decl_specifiers
,
16909 vec
<deferred_access_check
, va_gc
> *checks
,
16910 bool function_definition_allowed_p
,
16912 int declares_class_or_enum
,
16913 bool* function_definition_p
,
16914 tree
* maybe_range_for_decl
,
16915 location_t
* init_loc
)
16917 cp_token
*token
= NULL
, *asm_spec_start_token
= NULL
,
16918 *attributes_start_token
= NULL
;
16919 cp_declarator
*declarator
;
16920 tree prefix_attributes
;
16921 tree attributes
= NULL
;
16922 tree asm_specification
;
16924 tree decl
= NULL_TREE
;
16926 int is_initialized
;
16927 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
16928 initialized with "= ..", CPP_OPEN_PAREN if initialized with
16930 enum cpp_ttype initialization_kind
;
16931 bool is_direct_init
= false;
16932 bool is_non_constant_init
;
16933 int ctor_dtor_or_conv_p
;
16934 bool friend_p
= cp_parser_friend_p (decl_specifiers
);
16935 tree pushed_scope
= NULL_TREE
;
16936 bool range_for_decl_p
= false;
16937 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
16938 location_t tmp_init_loc
= UNKNOWN_LOCATION
;
16940 /* Gather the attributes that were provided with the
16941 decl-specifiers. */
16942 prefix_attributes
= decl_specifiers
->attributes
;
16944 /* Assume that this is not the declarator for a function
16946 if (function_definition_p
)
16947 *function_definition_p
= false;
16949 /* Default arguments are only permitted for function parameters. */
16950 if (decl_spec_seq_has_spec_p (decl_specifiers
, ds_typedef
))
16951 parser
->default_arg_ok_p
= false;
16953 /* Defer access checks while parsing the declarator; we cannot know
16954 what names are accessible until we know what is being
16956 resume_deferring_access_checks ();
16958 /* Parse the declarator. */
16959 token
= cp_lexer_peek_token (parser
->lexer
);
16961 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
16962 &ctor_dtor_or_conv_p
,
16963 /*parenthesized_p=*/NULL
,
16964 member_p
, friend_p
);
16965 /* Gather up the deferred checks. */
16966 stop_deferring_access_checks ();
16968 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
16970 /* If the DECLARATOR was erroneous, there's no need to go
16972 if (declarator
== cp_error_declarator
)
16973 return error_mark_node
;
16975 /* Check that the number of template-parameter-lists is OK. */
16976 if (!cp_parser_check_declarator_template_parameters (parser
, declarator
,
16978 return error_mark_node
;
16980 if (declares_class_or_enum
& 2)
16981 cp_parser_check_for_definition_in_return_type (declarator
,
16982 decl_specifiers
->type
,
16983 decl_specifiers
->locations
[ds_type_spec
]);
16985 /* Figure out what scope the entity declared by the DECLARATOR is
16986 located in. `grokdeclarator' sometimes changes the scope, so
16987 we compute it now. */
16988 scope
= get_scope_of_declarator (declarator
);
16990 /* Perform any lookups in the declared type which were thought to be
16991 dependent, but are not in the scope of the declarator. */
16992 decl_specifiers
->type
16993 = maybe_update_decl_type (decl_specifiers
->type
, scope
);
16995 /* If we're allowing GNU extensions, look for an
16996 asm-specification. */
16997 if (cp_parser_allow_gnu_extensions_p (parser
))
16999 /* Look for an asm-specification. */
17000 asm_spec_start_token
= cp_lexer_peek_token (parser
->lexer
);
17001 asm_specification
= cp_parser_asm_specification_opt (parser
);
17004 asm_specification
= NULL_TREE
;
17006 /* Look for attributes. */
17007 attributes_start_token
= cp_lexer_peek_token (parser
->lexer
);
17008 attributes
= cp_parser_attributes_opt (parser
);
17010 /* Peek at the next token. */
17011 token
= cp_lexer_peek_token (parser
->lexer
);
17013 bool bogus_implicit_tmpl
= false;
17015 if (function_declarator_p (declarator
))
17017 /* Check to see if the token indicates the start of a
17018 function-definition. */
17019 if (cp_parser_token_starts_function_definition_p (token
))
17021 if (!function_definition_allowed_p
)
17023 /* If a function-definition should not appear here, issue an
17025 cp_parser_error (parser
,
17026 "a function-definition is not allowed here");
17027 return error_mark_node
;
17030 location_t func_brace_location
17031 = cp_lexer_peek_token (parser
->lexer
)->location
;
17033 /* Neither attributes nor an asm-specification are allowed
17034 on a function-definition. */
17035 if (asm_specification
)
17036 error_at (asm_spec_start_token
->location
,
17037 "an asm-specification is not allowed "
17038 "on a function-definition");
17040 error_at (attributes_start_token
->location
,
17041 "attributes are not allowed "
17042 "on a function-definition");
17043 /* This is a function-definition. */
17044 *function_definition_p
= true;
17046 /* Parse the function definition. */
17048 decl
= cp_parser_save_member_function_body (parser
,
17051 prefix_attributes
);
17054 (cp_parser_function_definition_from_specifiers_and_declarator
17055 (parser
, decl_specifiers
, prefix_attributes
, declarator
));
17057 if (decl
!= error_mark_node
&& DECL_STRUCT_FUNCTION (decl
))
17059 /* This is where the prologue starts... */
17060 DECL_STRUCT_FUNCTION (decl
)->function_start_locus
17061 = func_brace_location
;
17067 else if (parser
->fully_implicit_function_template_p
)
17069 /* A non-template declaration involving a function parameter list
17070 containing an implicit template parameter will be made into a
17071 template. If the resulting declaration is not going to be an
17072 actual function then finish the template scope here to prevent it.
17073 An error message will be issued once we have a decl to talk about.
17075 FIXME probably we should do type deduction rather than create an
17076 implicit template, but the standard currently doesn't allow it. */
17077 bogus_implicit_tmpl
= true;
17078 finish_fully_implicit_template (parser
, NULL_TREE
);
17083 Only in function declarations for constructors, destructors, and
17084 type conversions can the decl-specifier-seq be omitted.
17086 We explicitly postpone this check past the point where we handle
17087 function-definitions because we tolerate function-definitions
17088 that are missing their return types in some modes. */
17089 if (!decl_specifiers
->any_specifiers_p
&& ctor_dtor_or_conv_p
<= 0)
17091 cp_parser_error (parser
,
17092 "expected constructor, destructor, or type conversion");
17093 return error_mark_node
;
17096 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
17097 if (token
->type
== CPP_EQ
17098 || token
->type
== CPP_OPEN_PAREN
17099 || token
->type
== CPP_OPEN_BRACE
)
17101 is_initialized
= SD_INITIALIZED
;
17102 initialization_kind
= token
->type
;
17103 if (maybe_range_for_decl
)
17104 *maybe_range_for_decl
= error_mark_node
;
17105 tmp_init_loc
= token
->location
;
17106 if (init_loc
&& *init_loc
== UNKNOWN_LOCATION
)
17107 *init_loc
= tmp_init_loc
;
17109 if (token
->type
== CPP_EQ
17110 && function_declarator_p (declarator
))
17112 cp_token
*t2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
17113 if (t2
->keyword
== RID_DEFAULT
)
17114 is_initialized
= SD_DEFAULTED
;
17115 else if (t2
->keyword
== RID_DELETE
)
17116 is_initialized
= SD_DELETED
;
17121 /* If the init-declarator isn't initialized and isn't followed by a
17122 `,' or `;', it's not a valid init-declarator. */
17123 if (token
->type
!= CPP_COMMA
17124 && token
->type
!= CPP_SEMICOLON
)
17126 if (maybe_range_for_decl
&& *maybe_range_for_decl
!= error_mark_node
)
17127 range_for_decl_p
= true;
17130 if (!maybe_range_for_decl
)
17131 cp_parser_error (parser
, "expected initializer");
17132 return error_mark_node
;
17135 is_initialized
= SD_UNINITIALIZED
;
17136 initialization_kind
= CPP_EOF
;
17139 /* Because start_decl has side-effects, we should only call it if we
17140 know we're going ahead. By this point, we know that we cannot
17141 possibly be looking at any other construct. */
17142 cp_parser_commit_to_tentative_parse (parser
);
17144 /* Enter the newly declared entry in the symbol table. If we're
17145 processing a declaration in a class-specifier, we wait until
17146 after processing the initializer. */
17149 if (parser
->in_unbraced_linkage_specification_p
)
17150 decl_specifiers
->storage_class
= sc_extern
;
17151 decl
= start_decl (declarator
, decl_specifiers
,
17152 range_for_decl_p
? SD_INITIALIZED
: is_initialized
,
17153 attributes
, prefix_attributes
, &pushed_scope
);
17154 cp_finalize_omp_declare_simd (parser
, decl
);
17155 /* Adjust location of decl if declarator->id_loc is more appropriate:
17156 set, and decl wasn't merged with another decl, in which case its
17157 location would be different from input_location, and more accurate. */
17159 && declarator
->id_loc
!= UNKNOWN_LOCATION
17160 && DECL_SOURCE_LOCATION (decl
) == input_location
)
17161 DECL_SOURCE_LOCATION (decl
) = declarator
->id_loc
;
17164 /* Enter the SCOPE. That way unqualified names appearing in the
17165 initializer will be looked up in SCOPE. */
17166 pushed_scope
= push_scope (scope
);
17168 /* Perform deferred access control checks, now that we know in which
17169 SCOPE the declared entity resides. */
17170 if (!member_p
&& decl
)
17172 tree saved_current_function_decl
= NULL_TREE
;
17174 /* If the entity being declared is a function, pretend that we
17175 are in its scope. If it is a `friend', it may have access to
17176 things that would not otherwise be accessible. */
17177 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17179 saved_current_function_decl
= current_function_decl
;
17180 current_function_decl
= decl
;
17183 /* Perform access checks for template parameters. */
17184 cp_parser_perform_template_parameter_access_checks (checks
);
17186 /* Perform the access control checks for the declarator and the
17187 decl-specifiers. */
17188 perform_deferred_access_checks (tf_warning_or_error
);
17190 /* Restore the saved value. */
17191 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17192 current_function_decl
= saved_current_function_decl
;
17195 /* Parse the initializer. */
17196 initializer
= NULL_TREE
;
17197 is_direct_init
= false;
17198 is_non_constant_init
= true;
17199 if (is_initialized
)
17201 if (function_declarator_p (declarator
))
17203 if (initialization_kind
== CPP_EQ
)
17204 initializer
= cp_parser_pure_specifier (parser
);
17207 /* If the declaration was erroneous, we don't really
17208 know what the user intended, so just silently
17209 consume the initializer. */
17210 if (decl
!= error_mark_node
)
17211 error_at (tmp_init_loc
, "initializer provided for function");
17212 cp_parser_skip_to_closing_parenthesis (parser
,
17213 /*recovering=*/true,
17214 /*or_comma=*/false,
17215 /*consume_paren=*/true);
17220 /* We want to record the extra mangling scope for in-class
17221 initializers of class members and initializers of static data
17222 member templates. The former involves deferring
17223 parsing of the initializer until end of class as with default
17224 arguments. So right here we only handle the latter. */
17225 if (!member_p
&& processing_template_decl
)
17226 start_lambda_scope (decl
);
17227 initializer
= cp_parser_initializer (parser
,
17229 &is_non_constant_init
);
17230 if (!member_p
&& processing_template_decl
)
17231 finish_lambda_scope ();
17232 if (initializer
== error_mark_node
)
17233 cp_parser_skip_to_end_of_statement (parser
);
17237 /* The old parser allows attributes to appear after a parenthesized
17238 initializer. Mark Mitchell proposed removing this functionality
17239 on the GCC mailing lists on 2002-08-13. This parser accepts the
17240 attributes -- but ignores them. */
17241 if (cp_parser_allow_gnu_extensions_p (parser
)
17242 && initialization_kind
== CPP_OPEN_PAREN
)
17243 if (cp_parser_attributes_opt (parser
))
17244 warning (OPT_Wattributes
,
17245 "attributes after parenthesized initializer ignored");
17247 /* And now complain about a non-function implicit template. */
17248 if (bogus_implicit_tmpl
)
17249 error_at (DECL_SOURCE_LOCATION (decl
),
17250 "non-function %qD declared as implicit template", decl
);
17252 /* For an in-class declaration, use `grokfield' to create the
17258 pop_scope (pushed_scope
);
17259 pushed_scope
= NULL_TREE
;
17261 decl
= grokfield (declarator
, decl_specifiers
,
17262 initializer
, !is_non_constant_init
,
17263 /*asmspec=*/NULL_TREE
,
17264 chainon (attributes
, prefix_attributes
));
17265 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
17266 cp_parser_save_default_args (parser
, decl
);
17267 cp_finalize_omp_declare_simd (parser
, decl
);
17270 /* Finish processing the declaration. But, skip member
17272 if (!member_p
&& decl
&& decl
!= error_mark_node
&& !range_for_decl_p
)
17274 cp_finish_decl (decl
,
17275 initializer
, !is_non_constant_init
,
17277 /* If the initializer is in parentheses, then this is
17278 a direct-initialization, which means that an
17279 `explicit' constructor is OK. Otherwise, an
17280 `explicit' constructor cannot be used. */
17281 ((is_direct_init
|| !is_initialized
)
17282 ? LOOKUP_NORMAL
: LOOKUP_IMPLICIT
));
17284 else if ((cxx_dialect
!= cxx98
) && friend_p
17285 && decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
17286 /* Core issue #226 (C++0x only): A default template-argument
17287 shall not be specified in a friend class template
17289 check_default_tmpl_args (decl
, current_template_parms
, /*is_primary=*/true,
17290 /*is_partial=*/false, /*is_friend_decl=*/1);
17292 if (!friend_p
&& pushed_scope
)
17293 pop_scope (pushed_scope
);
17295 if (function_declarator_p (declarator
)
17296 && parser
->fully_implicit_function_template_p
)
17299 decl
= finish_fully_implicit_template (parser
, decl
);
17301 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
17307 /* Parse a declarator.
17311 ptr-operator declarator
17313 abstract-declarator:
17314 ptr-operator abstract-declarator [opt]
17315 direct-abstract-declarator
17320 attributes [opt] direct-declarator
17321 attributes [opt] ptr-operator declarator
17323 abstract-declarator:
17324 attributes [opt] ptr-operator abstract-declarator [opt]
17325 attributes [opt] direct-abstract-declarator
17327 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
17328 detect constructor, destructor or conversion operators. It is set
17329 to -1 if the declarator is a name, and +1 if it is a
17330 function. Otherwise it is set to zero. Usually you just want to
17331 test for >0, but internally the negative value is used.
17333 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
17334 a decl-specifier-seq unless it declares a constructor, destructor,
17335 or conversion. It might seem that we could check this condition in
17336 semantic analysis, rather than parsing, but that makes it difficult
17337 to handle something like `f()'. We want to notice that there are
17338 no decl-specifiers, and therefore realize that this is an
17339 expression, not a declaration.)
17341 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
17342 the declarator is a direct-declarator of the form "(...)".
17344 MEMBER_P is true iff this declarator is a member-declarator.
17346 FRIEND_P is true iff this declarator is a friend. */
17348 static cp_declarator
*
17349 cp_parser_declarator (cp_parser
* parser
,
17350 cp_parser_declarator_kind dcl_kind
,
17351 int* ctor_dtor_or_conv_p
,
17352 bool* parenthesized_p
,
17353 bool member_p
, bool friend_p
)
17355 cp_declarator
*declarator
;
17356 enum tree_code code
;
17357 cp_cv_quals cv_quals
;
17359 tree gnu_attributes
= NULL_TREE
, std_attributes
= NULL_TREE
;
17361 /* Assume this is not a constructor, destructor, or type-conversion
17363 if (ctor_dtor_or_conv_p
)
17364 *ctor_dtor_or_conv_p
= 0;
17366 if (cp_parser_allow_gnu_extensions_p (parser
))
17367 gnu_attributes
= cp_parser_gnu_attributes_opt (parser
);
17369 /* Check for the ptr-operator production. */
17370 cp_parser_parse_tentatively (parser
);
17371 /* Parse the ptr-operator. */
17372 code
= cp_parser_ptr_operator (parser
,
17377 /* If that worked, then we have a ptr-operator. */
17378 if (cp_parser_parse_definitely (parser
))
17380 /* If a ptr-operator was found, then this declarator was not
17382 if (parenthesized_p
)
17383 *parenthesized_p
= true;
17384 /* The dependent declarator is optional if we are parsing an
17385 abstract-declarator. */
17386 if (dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
17387 cp_parser_parse_tentatively (parser
);
17389 /* Parse the dependent declarator. */
17390 declarator
= cp_parser_declarator (parser
, dcl_kind
,
17391 /*ctor_dtor_or_conv_p=*/NULL
,
17392 /*parenthesized_p=*/NULL
,
17393 /*member_p=*/false,
17396 /* If we are parsing an abstract-declarator, we must handle the
17397 case where the dependent declarator is absent. */
17398 if (dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
17399 && !cp_parser_parse_definitely (parser
))
17402 declarator
= cp_parser_make_indirect_declarator
17403 (code
, class_type
, cv_quals
, declarator
, std_attributes
);
17405 /* Everything else is a direct-declarator. */
17408 if (parenthesized_p
)
17409 *parenthesized_p
= cp_lexer_next_token_is (parser
->lexer
,
17411 declarator
= cp_parser_direct_declarator (parser
, dcl_kind
,
17412 ctor_dtor_or_conv_p
,
17413 member_p
, friend_p
);
17416 if (gnu_attributes
&& declarator
&& declarator
!= cp_error_declarator
)
17417 declarator
->attributes
= gnu_attributes
;
17421 /* Parse a direct-declarator or direct-abstract-declarator.
17425 direct-declarator ( parameter-declaration-clause )
17426 cv-qualifier-seq [opt]
17427 ref-qualifier [opt]
17428 exception-specification [opt]
17429 direct-declarator [ constant-expression [opt] ]
17432 direct-abstract-declarator:
17433 direct-abstract-declarator [opt]
17434 ( parameter-declaration-clause )
17435 cv-qualifier-seq [opt]
17436 ref-qualifier [opt]
17437 exception-specification [opt]
17438 direct-abstract-declarator [opt] [ constant-expression [opt] ]
17439 ( abstract-declarator )
17441 Returns a representation of the declarator. DCL_KIND is
17442 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
17443 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
17444 we are parsing a direct-declarator. It is
17445 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
17446 of ambiguity we prefer an abstract declarator, as per
17447 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P, MEMBER_P, and FRIEND_P are
17448 as for cp_parser_declarator. */
17450 static cp_declarator
*
17451 cp_parser_direct_declarator (cp_parser
* parser
,
17452 cp_parser_declarator_kind dcl_kind
,
17453 int* ctor_dtor_or_conv_p
,
17454 bool member_p
, bool friend_p
)
17457 cp_declarator
*declarator
= NULL
;
17458 tree scope
= NULL_TREE
;
17459 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
17460 bool saved_in_declarator_p
= parser
->in_declarator_p
;
17462 tree pushed_scope
= NULL_TREE
;
17466 /* Peek at the next token. */
17467 token
= cp_lexer_peek_token (parser
->lexer
);
17468 if (token
->type
== CPP_OPEN_PAREN
)
17470 /* This is either a parameter-declaration-clause, or a
17471 parenthesized declarator. When we know we are parsing a
17472 named declarator, it must be a parenthesized declarator
17473 if FIRST is true. For instance, `(int)' is a
17474 parameter-declaration-clause, with an omitted
17475 direct-abstract-declarator. But `((*))', is a
17476 parenthesized abstract declarator. Finally, when T is a
17477 template parameter `(T)' is a
17478 parameter-declaration-clause, and not a parenthesized
17481 We first try and parse a parameter-declaration-clause,
17482 and then try a nested declarator (if FIRST is true).
17484 It is not an error for it not to be a
17485 parameter-declaration-clause, even when FIRST is
17491 The first is the declaration of a function while the
17492 second is the definition of a variable, including its
17495 Having seen only the parenthesis, we cannot know which of
17496 these two alternatives should be selected. Even more
17497 complex are examples like:
17502 The former is a function-declaration; the latter is a
17503 variable initialization.
17505 Thus again, we try a parameter-declaration-clause, and if
17506 that fails, we back out and return. */
17508 if (!first
|| dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
17511 bool is_declarator
= false;
17513 /* In a member-declarator, the only valid interpretation
17514 of a parenthesis is the start of a
17515 parameter-declaration-clause. (It is invalid to
17516 initialize a static data member with a parenthesized
17517 initializer; only the "=" form of initialization is
17520 cp_parser_parse_tentatively (parser
);
17522 /* Consume the `('. */
17523 cp_lexer_consume_token (parser
->lexer
);
17526 /* If this is going to be an abstract declarator, we're
17527 in a declarator and we can't have default args. */
17528 parser
->default_arg_ok_p
= false;
17529 parser
->in_declarator_p
= true;
17532 begin_scope (sk_function_parms
, NULL_TREE
);
17534 /* Parse the parameter-declaration-clause. */
17535 params
= cp_parser_parameter_declaration_clause (parser
);
17537 /* Consume the `)'. */
17538 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
17540 /* If all went well, parse the cv-qualifier-seq,
17541 ref-qualifier and the exception-specification. */
17542 if (member_p
|| cp_parser_parse_definitely (parser
))
17544 cp_cv_quals cv_quals
;
17545 cp_virt_specifiers virt_specifiers
;
17546 cp_ref_qualifier ref_qual
;
17547 tree exception_specification
;
17550 bool memfn
= (member_p
|| (pushed_scope
17551 && CLASS_TYPE_P (pushed_scope
)));
17553 is_declarator
= true;
17555 if (ctor_dtor_or_conv_p
)
17556 *ctor_dtor_or_conv_p
= *ctor_dtor_or_conv_p
< 0;
17559 /* Parse the cv-qualifier-seq. */
17560 cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
17561 /* Parse the ref-qualifier. */
17562 ref_qual
= cp_parser_ref_qualifier_opt (parser
);
17563 /* And the exception-specification. */
17564 exception_specification
17565 = cp_parser_exception_specification_opt (parser
);
17567 attrs
= cp_parser_std_attribute_spec_seq (parser
);
17569 /* In here, we handle cases where attribute is used after
17570 the function declaration. For example:
17571 void func (int x) __attribute__((vector(..))); */
17573 && cp_next_tokens_can_be_gnu_attribute_p (parser
))
17575 cp_parser_parse_tentatively (parser
);
17576 tree attr
= cp_parser_gnu_attributes_opt (parser
);
17577 if (cp_lexer_next_token_is_not (parser
->lexer
,
17579 && cp_lexer_next_token_is_not (parser
->lexer
,
17581 cp_parser_abort_tentative_parse (parser
);
17582 else if (!cp_parser_parse_definitely (parser
))
17585 attrs
= chainon (attr
, attrs
);
17587 late_return
= (cp_parser_late_return_type_opt
17588 (parser
, declarator
,
17589 memfn
? cv_quals
: -1));
17592 /* Parse the virt-specifier-seq. */
17593 virt_specifiers
= cp_parser_virt_specifier_seq_opt (parser
);
17595 /* Create the function-declarator. */
17596 declarator
= make_call_declarator (declarator
,
17601 exception_specification
,
17603 declarator
->std_attributes
= attrs
;
17604 /* Any subsequent parameter lists are to do with
17605 return type, so are not those of the declared
17607 parser
->default_arg_ok_p
= false;
17610 /* Remove the function parms from scope. */
17611 pop_bindings_and_leave_scope ();
17614 /* Repeat the main loop. */
17618 /* If this is the first, we can try a parenthesized
17622 bool saved_in_type_id_in_expr_p
;
17624 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
17625 parser
->in_declarator_p
= saved_in_declarator_p
;
17627 /* Consume the `('. */
17628 cp_lexer_consume_token (parser
->lexer
);
17629 /* Parse the nested declarator. */
17630 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
17631 parser
->in_type_id_in_expr_p
= true;
17633 = cp_parser_declarator (parser
, dcl_kind
, ctor_dtor_or_conv_p
,
17634 /*parenthesized_p=*/NULL
,
17635 member_p
, friend_p
);
17636 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
17638 /* Expect a `)'. */
17639 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
17640 declarator
= cp_error_declarator
;
17641 if (declarator
== cp_error_declarator
)
17644 goto handle_declarator
;
17646 /* Otherwise, we must be done. */
17650 else if ((!first
|| dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
17651 && token
->type
== CPP_OPEN_SQUARE
17652 && !cp_next_tokens_can_be_attribute_p (parser
))
17654 /* Parse an array-declarator. */
17655 tree bounds
, attrs
;
17657 if (ctor_dtor_or_conv_p
)
17658 *ctor_dtor_or_conv_p
= 0;
17661 parser
->default_arg_ok_p
= false;
17662 parser
->in_declarator_p
= true;
17663 /* Consume the `['. */
17664 cp_lexer_consume_token (parser
->lexer
);
17665 /* Peek at the next token. */
17666 token
= cp_lexer_peek_token (parser
->lexer
);
17667 /* If the next token is `]', then there is no
17668 constant-expression. */
17669 if (token
->type
!= CPP_CLOSE_SQUARE
)
17671 bool non_constant_p
;
17673 = cp_parser_constant_expression (parser
,
17674 /*allow_non_constant=*/true,
17676 if (!non_constant_p
)
17678 else if (error_operand_p (bounds
))
17679 /* Already gave an error. */;
17680 else if (!parser
->in_function_body
17681 || current_binding_level
->kind
== sk_function_parms
)
17683 /* Normally, the array bound must be an integral constant
17684 expression. However, as an extension, we allow VLAs
17685 in function scopes as long as they aren't part of a
17686 parameter declaration. */
17687 cp_parser_error (parser
,
17688 "array bound is not an integer constant");
17689 bounds
= error_mark_node
;
17691 else if (processing_template_decl
17692 && !type_dependent_expression_p (bounds
))
17694 /* Remember this wasn't a constant-expression. */
17695 bounds
= build_nop (TREE_TYPE (bounds
), bounds
);
17696 TREE_SIDE_EFFECTS (bounds
) = 1;
17700 bounds
= NULL_TREE
;
17701 /* Look for the closing `]'. */
17702 if (!cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
))
17704 declarator
= cp_error_declarator
;
17708 attrs
= cp_parser_std_attribute_spec_seq (parser
);
17709 declarator
= make_array_declarator (declarator
, bounds
);
17710 declarator
->std_attributes
= attrs
;
17712 else if (first
&& dcl_kind
!= CP_PARSER_DECLARATOR_ABSTRACT
)
17715 tree qualifying_scope
;
17716 tree unqualified_name
;
17718 special_function_kind sfk
;
17720 bool pack_expansion_p
= false;
17721 cp_token
*declarator_id_start_token
;
17723 /* Parse a declarator-id */
17724 abstract_ok
= (dcl_kind
== CP_PARSER_DECLARATOR_EITHER
);
17727 cp_parser_parse_tentatively (parser
);
17729 /* If we see an ellipsis, we should be looking at a
17731 if (token
->type
== CPP_ELLIPSIS
)
17733 /* Consume the `...' */
17734 cp_lexer_consume_token (parser
->lexer
);
17736 pack_expansion_p
= true;
17740 declarator_id_start_token
= cp_lexer_peek_token (parser
->lexer
);
17742 = cp_parser_declarator_id (parser
, /*optional_p=*/abstract_ok
);
17743 qualifying_scope
= parser
->scope
;
17748 if (!unqualified_name
&& pack_expansion_p
)
17750 /* Check whether an error occurred. */
17751 okay
= !cp_parser_error_occurred (parser
);
17753 /* We already consumed the ellipsis to mark a
17754 parameter pack, but we have no way to report it,
17755 so abort the tentative parse. We will be exiting
17756 immediately anyway. */
17757 cp_parser_abort_tentative_parse (parser
);
17760 okay
= cp_parser_parse_definitely (parser
);
17763 unqualified_name
= error_mark_node
;
17764 else if (unqualified_name
17765 && (qualifying_scope
17766 || (!identifier_p (unqualified_name
))))
17768 cp_parser_error (parser
, "expected unqualified-id");
17769 unqualified_name
= error_mark_node
;
17773 if (!unqualified_name
)
17775 if (unqualified_name
== error_mark_node
)
17777 declarator
= cp_error_declarator
;
17778 pack_expansion_p
= false;
17779 declarator
->parameter_pack_p
= false;
17783 attrs
= cp_parser_std_attribute_spec_seq (parser
);
17785 if (qualifying_scope
&& at_namespace_scope_p ()
17786 && TREE_CODE (qualifying_scope
) == TYPENAME_TYPE
)
17788 /* In the declaration of a member of a template class
17789 outside of the class itself, the SCOPE will sometimes
17790 be a TYPENAME_TYPE. For example, given:
17792 template <typename T>
17793 int S<T>::R::i = 3;
17795 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
17796 this context, we must resolve S<T>::R to an ordinary
17797 type, rather than a typename type.
17799 The reason we normally avoid resolving TYPENAME_TYPEs
17800 is that a specialization of `S' might render
17801 `S<T>::R' not a type. However, if `S' is
17802 specialized, then this `i' will not be used, so there
17803 is no harm in resolving the types here. */
17806 /* Resolve the TYPENAME_TYPE. */
17807 type
= resolve_typename_type (qualifying_scope
,
17808 /*only_current_p=*/false);
17809 /* If that failed, the declarator is invalid. */
17810 if (TREE_CODE (type
) == TYPENAME_TYPE
)
17812 if (typedef_variant_p (type
))
17813 error_at (declarator_id_start_token
->location
,
17814 "cannot define member of dependent typedef "
17817 error_at (declarator_id_start_token
->location
,
17818 "%<%T::%E%> is not a type",
17819 TYPE_CONTEXT (qualifying_scope
),
17820 TYPE_IDENTIFIER (qualifying_scope
));
17822 qualifying_scope
= type
;
17827 if (unqualified_name
)
17831 if (qualifying_scope
17832 && CLASS_TYPE_P (qualifying_scope
))
17833 class_type
= qualifying_scope
;
17835 class_type
= current_class_type
;
17837 if (TREE_CODE (unqualified_name
) == TYPE_DECL
)
17839 tree name_type
= TREE_TYPE (unqualified_name
);
17840 if (class_type
&& same_type_p (name_type
, class_type
))
17842 if (qualifying_scope
17843 && CLASSTYPE_USE_TEMPLATE (name_type
))
17845 error_at (declarator_id_start_token
->location
,
17846 "invalid use of constructor as a template");
17847 inform (declarator_id_start_token
->location
,
17848 "use %<%T::%D%> instead of %<%T::%D%> to "
17849 "name the constructor in a qualified name",
17851 DECL_NAME (TYPE_TI_TEMPLATE (class_type
)),
17852 class_type
, name_type
);
17853 declarator
= cp_error_declarator
;
17857 unqualified_name
= constructor_name (class_type
);
17861 /* We do not attempt to print the declarator
17862 here because we do not have enough
17863 information about its original syntactic
17865 cp_parser_error (parser
, "invalid declarator");
17866 declarator
= cp_error_declarator
;
17873 if (TREE_CODE (unqualified_name
) == BIT_NOT_EXPR
)
17874 sfk
= sfk_destructor
;
17875 else if (IDENTIFIER_TYPENAME_P (unqualified_name
))
17876 sfk
= sfk_conversion
;
17877 else if (/* There's no way to declare a constructor
17878 for an anonymous type, even if the type
17879 got a name for linkage purposes. */
17880 !TYPE_WAS_ANONYMOUS (class_type
)
17881 /* Handle correctly (c++/19200):
17895 friend void N::S();
17898 && class_type
!= qualifying_scope
)
17899 && constructor_name_p (unqualified_name
,
17902 unqualified_name
= constructor_name (class_type
);
17903 sfk
= sfk_constructor
;
17905 else if (is_overloaded_fn (unqualified_name
)
17906 && DECL_CONSTRUCTOR_P (get_first_fn
17907 (unqualified_name
)))
17908 sfk
= sfk_constructor
;
17910 if (ctor_dtor_or_conv_p
&& sfk
!= sfk_none
)
17911 *ctor_dtor_or_conv_p
= -1;
17914 declarator
= make_id_declarator (qualifying_scope
,
17917 declarator
->std_attributes
= attrs
;
17918 declarator
->id_loc
= token
->location
;
17919 declarator
->parameter_pack_p
= pack_expansion_p
;
17921 if (pack_expansion_p
)
17922 maybe_warn_variadic_templates ();
17925 handle_declarator
:;
17926 scope
= get_scope_of_declarator (declarator
);
17929 /* Any names that appear after the declarator-id for a
17930 member are looked up in the containing scope. */
17931 if (at_function_scope_p ())
17933 /* But declarations with qualified-ids can't appear in a
17935 cp_parser_error (parser
, "qualified-id in declaration");
17936 declarator
= cp_error_declarator
;
17939 pushed_scope
= push_scope (scope
);
17941 parser
->in_declarator_p
= true;
17942 if ((ctor_dtor_or_conv_p
&& *ctor_dtor_or_conv_p
)
17943 || (declarator
&& declarator
->kind
== cdk_id
))
17944 /* Default args are only allowed on function
17946 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
17948 parser
->default_arg_ok_p
= false;
17957 /* For an abstract declarator, we might wind up with nothing at this
17958 point. That's an error; the declarator is not optional. */
17960 cp_parser_error (parser
, "expected declarator");
17962 /* If we entered a scope, we must exit it now. */
17964 pop_scope (pushed_scope
);
17966 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
17967 parser
->in_declarator_p
= saved_in_declarator_p
;
17972 /* Parse a ptr-operator.
17975 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17976 * cv-qualifier-seq [opt]
17978 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
17979 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17984 & cv-qualifier-seq [opt]
17986 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
17987 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
17988 an rvalue reference. In the case of a pointer-to-member, *TYPE is
17989 filled in with the TYPE containing the member. *CV_QUALS is
17990 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
17991 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
17992 Note that the tree codes returned by this function have nothing
17993 to do with the types of trees that will be eventually be created
17994 to represent the pointer or reference type being parsed. They are
17995 just constants with suggestive names. */
17996 static enum tree_code
17997 cp_parser_ptr_operator (cp_parser
* parser
,
17999 cp_cv_quals
*cv_quals
,
18002 enum tree_code code
= ERROR_MARK
;
18004 tree attrs
= NULL_TREE
;
18006 /* Assume that it's not a pointer-to-member. */
18008 /* And that there are no cv-qualifiers. */
18009 *cv_quals
= TYPE_UNQUALIFIED
;
18011 /* Peek at the next token. */
18012 token
= cp_lexer_peek_token (parser
->lexer
);
18014 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
18015 if (token
->type
== CPP_MULT
)
18016 code
= INDIRECT_REF
;
18017 else if (token
->type
== CPP_AND
)
18019 else if ((cxx_dialect
!= cxx98
) &&
18020 token
->type
== CPP_AND_AND
) /* C++0x only */
18021 code
= NON_LVALUE_EXPR
;
18023 if (code
!= ERROR_MARK
)
18025 /* Consume the `*', `&' or `&&'. */
18026 cp_lexer_consume_token (parser
->lexer
);
18028 /* A `*' can be followed by a cv-qualifier-seq, and so can a
18029 `&', if we are allowing GNU extensions. (The only qualifier
18030 that can legally appear after `&' is `restrict', but that is
18031 enforced during semantic analysis. */
18032 if (code
== INDIRECT_REF
18033 || cp_parser_allow_gnu_extensions_p (parser
))
18034 *cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
18036 attrs
= cp_parser_std_attribute_spec_seq (parser
);
18037 if (attributes
!= NULL
)
18038 *attributes
= attrs
;
18042 /* Try the pointer-to-member case. */
18043 cp_parser_parse_tentatively (parser
);
18044 /* Look for the optional `::' operator. */
18045 cp_parser_global_scope_opt (parser
,
18046 /*current_scope_valid_p=*/false);
18047 /* Look for the nested-name specifier. */
18048 token
= cp_lexer_peek_token (parser
->lexer
);
18049 cp_parser_nested_name_specifier (parser
,
18050 /*typename_keyword_p=*/false,
18051 /*check_dependency_p=*/true,
18053 /*is_declaration=*/false);
18054 /* If we found it, and the next token is a `*', then we are
18055 indeed looking at a pointer-to-member operator. */
18056 if (!cp_parser_error_occurred (parser
)
18057 && cp_parser_require (parser
, CPP_MULT
, RT_MULT
))
18059 /* Indicate that the `*' operator was used. */
18060 code
= INDIRECT_REF
;
18062 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
18063 error_at (token
->location
, "%qD is a namespace", parser
->scope
);
18064 else if (TREE_CODE (parser
->scope
) == ENUMERAL_TYPE
)
18065 error_at (token
->location
, "cannot form pointer to member of "
18066 "non-class %q#T", parser
->scope
);
18069 /* The type of which the member is a member is given by the
18071 *type
= parser
->scope
;
18072 /* The next name will not be qualified. */
18073 parser
->scope
= NULL_TREE
;
18074 parser
->qualifying_scope
= NULL_TREE
;
18075 parser
->object_scope
= NULL_TREE
;
18076 /* Look for optional c++11 attributes. */
18077 attrs
= cp_parser_std_attribute_spec_seq (parser
);
18078 if (attributes
!= NULL
)
18079 *attributes
= attrs
;
18080 /* Look for the optional cv-qualifier-seq. */
18081 *cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
18084 /* If that didn't work we don't have a ptr-operator. */
18085 if (!cp_parser_parse_definitely (parser
))
18086 cp_parser_error (parser
, "expected ptr-operator");
18092 /* Parse an (optional) cv-qualifier-seq.
18095 cv-qualifier cv-qualifier-seq [opt]
18106 Returns a bitmask representing the cv-qualifiers. */
18109 cp_parser_cv_qualifier_seq_opt (cp_parser
* parser
)
18111 cp_cv_quals cv_quals
= TYPE_UNQUALIFIED
;
18116 cp_cv_quals cv_qualifier
;
18118 /* Peek at the next token. */
18119 token
= cp_lexer_peek_token (parser
->lexer
);
18120 /* See if it's a cv-qualifier. */
18121 switch (token
->keyword
)
18124 cv_qualifier
= TYPE_QUAL_CONST
;
18128 cv_qualifier
= TYPE_QUAL_VOLATILE
;
18132 cv_qualifier
= TYPE_QUAL_RESTRICT
;
18136 cv_qualifier
= TYPE_UNQUALIFIED
;
18143 if (cv_quals
& cv_qualifier
)
18145 error_at (token
->location
, "duplicate cv-qualifier");
18146 cp_lexer_purge_token (parser
->lexer
);
18150 cp_lexer_consume_token (parser
->lexer
);
18151 cv_quals
|= cv_qualifier
;
18158 /* Parse an (optional) ref-qualifier
18164 Returns cp_ref_qualifier representing ref-qualifier. */
18166 static cp_ref_qualifier
18167 cp_parser_ref_qualifier_opt (cp_parser
* parser
)
18169 cp_ref_qualifier ref_qual
= REF_QUAL_NONE
;
18171 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
18172 if (cxx_dialect
< cxx11
&& cp_parser_parsing_tentatively (parser
))
18177 cp_ref_qualifier curr_ref_qual
= REF_QUAL_NONE
;
18178 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
18180 switch (token
->type
)
18183 curr_ref_qual
= REF_QUAL_LVALUE
;
18187 curr_ref_qual
= REF_QUAL_RVALUE
;
18191 curr_ref_qual
= REF_QUAL_NONE
;
18195 if (!curr_ref_qual
)
18199 error_at (token
->location
, "multiple ref-qualifiers");
18200 cp_lexer_purge_token (parser
->lexer
);
18204 ref_qual
= curr_ref_qual
;
18205 cp_lexer_consume_token (parser
->lexer
);
18212 /* Parse an (optional) virt-specifier-seq.
18214 virt-specifier-seq:
18215 virt-specifier virt-specifier-seq [opt]
18221 Returns a bitmask representing the virt-specifiers. */
18223 static cp_virt_specifiers
18224 cp_parser_virt_specifier_seq_opt (cp_parser
* parser
)
18226 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
18231 cp_virt_specifiers virt_specifier
;
18233 /* Peek at the next token. */
18234 token
= cp_lexer_peek_token (parser
->lexer
);
18235 /* See if it's a virt-specifier-qualifier. */
18236 if (token
->type
!= CPP_NAME
)
18238 if (!strcmp (IDENTIFIER_POINTER(token
->u
.value
), "override"))
18240 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS
);
18241 virt_specifier
= VIRT_SPEC_OVERRIDE
;
18243 else if (!strcmp (IDENTIFIER_POINTER(token
->u
.value
), "final"))
18245 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS
);
18246 virt_specifier
= VIRT_SPEC_FINAL
;
18248 else if (!strcmp (IDENTIFIER_POINTER(token
->u
.value
), "__final"))
18250 virt_specifier
= VIRT_SPEC_FINAL
;
18255 if (virt_specifiers
& virt_specifier
)
18257 error_at (token
->location
, "duplicate virt-specifier");
18258 cp_lexer_purge_token (parser
->lexer
);
18262 cp_lexer_consume_token (parser
->lexer
);
18263 virt_specifiers
|= virt_specifier
;
18266 return virt_specifiers
;
18269 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
18270 is in scope even though it isn't real. */
18273 inject_this_parameter (tree ctype
, cp_cv_quals quals
)
18277 if (current_class_ptr
)
18279 /* We don't clear this between NSDMIs. Is it already what we want? */
18280 tree type
= TREE_TYPE (TREE_TYPE (current_class_ptr
));
18281 if (same_type_ignoring_top_level_qualifiers_p (ctype
, type
)
18282 && cp_type_quals (type
) == quals
)
18286 this_parm
= build_this_parm (ctype
, quals
);
18287 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
18288 current_class_ptr
= NULL_TREE
;
18290 = cp_build_indirect_ref (this_parm
, RO_NULL
, tf_warning_or_error
);
18291 current_class_ptr
= this_parm
;
18294 /* Return true iff our current scope is a non-static data member
18298 parsing_nsdmi (void)
18300 /* We recognize NSDMI context by the context-less 'this' pointer set up
18301 by the function above. */
18302 if (current_class_ptr
18303 && TREE_CODE (current_class_ptr
) == PARM_DECL
18304 && DECL_CONTEXT (current_class_ptr
) == NULL_TREE
)
18309 /* Parse a late-specified return type, if any. This is not a separate
18310 non-terminal, but part of a function declarator, which looks like
18312 -> trailing-type-specifier-seq abstract-declarator(opt)
18314 Returns the type indicated by the type-id.
18316 In addition to this this parses any queued up omp declare simd
18317 clauses and Cilk Plus SIMD-enabled function's vector attributes.
18319 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
18323 cp_parser_late_return_type_opt (cp_parser
* parser
, cp_declarator
*declarator
,
18327 tree type
= NULL_TREE
;
18328 bool declare_simd_p
= (parser
->omp_declare_simd
18330 && declarator
->kind
== cdk_id
);
18332 bool cilk_simd_fn_vector_p
= (parser
->cilk_simd_fn_info
18333 && declarator
&& declarator
->kind
== cdk_id
);
18335 /* Peek at the next token. */
18336 token
= cp_lexer_peek_token (parser
->lexer
);
18337 /* A late-specified return type is indicated by an initial '->'. */
18338 if (token
->type
!= CPP_DEREF
&& !(declare_simd_p
|| cilk_simd_fn_vector_p
))
18341 tree save_ccp
= current_class_ptr
;
18342 tree save_ccr
= current_class_ref
;
18345 /* DR 1207: 'this' is in scope in the trailing return type. */
18346 inject_this_parameter (current_class_type
, quals
);
18349 if (token
->type
== CPP_DEREF
)
18351 /* Consume the ->. */
18352 cp_lexer_consume_token (parser
->lexer
);
18354 type
= cp_parser_trailing_type_id (parser
);
18357 if (cilk_simd_fn_vector_p
)
18358 declarator
->std_attributes
18359 = cp_parser_late_parsing_cilk_simd_fn_info (parser
,
18360 declarator
->std_attributes
);
18361 if (declare_simd_p
)
18362 declarator
->std_attributes
18363 = cp_parser_late_parsing_omp_declare_simd (parser
,
18364 declarator
->std_attributes
);
18368 current_class_ptr
= save_ccp
;
18369 current_class_ref
= save_ccr
;
18375 /* Parse a declarator-id.
18379 :: [opt] nested-name-specifier [opt] type-name
18381 In the `id-expression' case, the value returned is as for
18382 cp_parser_id_expression if the id-expression was an unqualified-id.
18383 If the id-expression was a qualified-id, then a SCOPE_REF is
18384 returned. The first operand is the scope (either a NAMESPACE_DECL
18385 or TREE_TYPE), but the second is still just a representation of an
18389 cp_parser_declarator_id (cp_parser
* parser
, bool optional_p
)
18392 /* The expression must be an id-expression. Assume that qualified
18393 names are the names of types so that:
18396 int S<T>::R::i = 3;
18398 will work; we must treat `S<T>::R' as the name of a type.
18399 Similarly, assume that qualified names are templates, where
18403 int S<T>::R<T>::i = 3;
18406 id
= cp_parser_id_expression (parser
,
18407 /*template_keyword_p=*/false,
18408 /*check_dependency_p=*/false,
18409 /*template_p=*/NULL
,
18410 /*declarator_p=*/true,
18412 if (id
&& BASELINK_P (id
))
18413 id
= BASELINK_FUNCTIONS (id
);
18417 /* Parse a type-id.
18420 type-specifier-seq abstract-declarator [opt]
18422 Returns the TYPE specified. */
18425 cp_parser_type_id_1 (cp_parser
* parser
, bool is_template_arg
,
18426 bool is_trailing_return
)
18428 cp_decl_specifier_seq type_specifier_seq
;
18429 cp_declarator
*abstract_declarator
;
18431 /* Parse the type-specifier-seq. */
18432 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
18433 is_trailing_return
,
18434 &type_specifier_seq
);
18435 if (type_specifier_seq
.type
== error_mark_node
)
18436 return error_mark_node
;
18438 /* There might or might not be an abstract declarator. */
18439 cp_parser_parse_tentatively (parser
);
18440 /* Look for the declarator. */
18441 abstract_declarator
18442 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_ABSTRACT
, NULL
,
18443 /*parenthesized_p=*/NULL
,
18444 /*member_p=*/false,
18445 /*friend_p=*/false);
18446 /* Check to see if there really was a declarator. */
18447 if (!cp_parser_parse_definitely (parser
))
18448 abstract_declarator
= NULL
;
18450 if (type_specifier_seq
.type
18451 /* None of the valid uses of 'auto' in C++14 involve the type-id
18452 nonterminal, but it is valid in a trailing-return-type. */
18453 && !(cxx_dialect
>= cxx14
&& is_trailing_return
)
18454 && type_uses_auto (type_specifier_seq
.type
))
18456 /* A type-id with type 'auto' is only ok if the abstract declarator
18457 is a function declarator with a late-specified return type. */
18458 if (abstract_declarator
18459 && abstract_declarator
->kind
== cdk_function
18460 && abstract_declarator
->u
.function
.late_return_type
)
18464 error ("invalid use of %<auto%>");
18465 return error_mark_node
;
18469 return groktypename (&type_specifier_seq
, abstract_declarator
,
18473 static tree
cp_parser_type_id (cp_parser
*parser
)
18475 return cp_parser_type_id_1 (parser
, false, false);
18478 static tree
cp_parser_template_type_arg (cp_parser
*parser
)
18481 const char *saved_message
= parser
->type_definition_forbidden_message
;
18482 parser
->type_definition_forbidden_message
18483 = G_("types may not be defined in template arguments");
18484 r
= cp_parser_type_id_1 (parser
, true, false);
18485 parser
->type_definition_forbidden_message
= saved_message
;
18486 if (cxx_dialect
>= cxx14
&& type_uses_auto (r
))
18488 error ("invalid use of %<auto%> in template argument");
18489 r
= error_mark_node
;
18494 static tree
cp_parser_trailing_type_id (cp_parser
*parser
)
18496 return cp_parser_type_id_1 (parser
, false, true);
18499 /* Parse a type-specifier-seq.
18501 type-specifier-seq:
18502 type-specifier type-specifier-seq [opt]
18506 type-specifier-seq:
18507 attributes type-specifier-seq [opt]
18509 If IS_DECLARATION is true, we are at the start of a "condition" or
18510 exception-declaration, so we might be followed by a declarator-id.
18512 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
18513 i.e. we've just seen "->".
18515 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
18518 cp_parser_type_specifier_seq (cp_parser
* parser
,
18519 bool is_declaration
,
18520 bool is_trailing_return
,
18521 cp_decl_specifier_seq
*type_specifier_seq
)
18523 bool seen_type_specifier
= false;
18524 cp_parser_flags flags
= CP_PARSER_FLAGS_OPTIONAL
;
18525 cp_token
*start_token
= NULL
;
18527 /* Clear the TYPE_SPECIFIER_SEQ. */
18528 clear_decl_specs (type_specifier_seq
);
18530 /* In the context of a trailing return type, enum E { } is an
18531 elaborated-type-specifier followed by a function-body, not an
18533 if (is_trailing_return
)
18534 flags
|= CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS
;
18536 /* Parse the type-specifiers and attributes. */
18539 tree type_specifier
;
18540 bool is_cv_qualifier
;
18542 /* Check for attributes first. */
18543 if (cp_next_tokens_can_be_attribute_p (parser
))
18545 type_specifier_seq
->attributes
=
18546 chainon (type_specifier_seq
->attributes
,
18547 cp_parser_attributes_opt (parser
));
18551 /* record the token of the beginning of the type specifier seq,
18552 for error reporting purposes*/
18554 start_token
= cp_lexer_peek_token (parser
->lexer
);
18556 /* Look for the type-specifier. */
18557 type_specifier
= cp_parser_type_specifier (parser
,
18559 type_specifier_seq
,
18560 /*is_declaration=*/false,
18563 if (!type_specifier
)
18565 /* If the first type-specifier could not be found, this is not a
18566 type-specifier-seq at all. */
18567 if (!seen_type_specifier
)
18569 /* Set in_declarator_p to avoid skipping to the semicolon. */
18570 int in_decl
= parser
->in_declarator_p
;
18571 parser
->in_declarator_p
= true;
18573 if (cp_parser_uncommitted_to_tentative_parse_p (parser
)
18574 || !cp_parser_parse_and_diagnose_invalid_type_name (parser
))
18575 cp_parser_error (parser
, "expected type-specifier");
18577 parser
->in_declarator_p
= in_decl
;
18579 type_specifier_seq
->type
= error_mark_node
;
18582 /* If subsequent type-specifiers could not be found, the
18583 type-specifier-seq is complete. */
18587 seen_type_specifier
= true;
18588 /* The standard says that a condition can be:
18590 type-specifier-seq declarator = assignment-expression
18597 we should treat the "S" as a declarator, not as a
18598 type-specifier. The standard doesn't say that explicitly for
18599 type-specifier-seq, but it does say that for
18600 decl-specifier-seq in an ordinary declaration. Perhaps it
18601 would be clearer just to allow a decl-specifier-seq here, and
18602 then add a semantic restriction that if any decl-specifiers
18603 that are not type-specifiers appear, the program is invalid. */
18604 if (is_declaration
&& !is_cv_qualifier
)
18605 flags
|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
;
18609 /* Return whether the function currently being declared has an associated
18610 template parameter list. */
18613 function_being_declared_is_template_p (cp_parser
* parser
)
18615 if (!current_template_parms
|| processing_template_parmlist
)
18618 if (parser
->implicit_template_scope
)
18621 if (at_class_scope_p ()
18622 && TYPE_BEING_DEFINED (current_class_type
))
18623 return parser
->num_template_parameter_lists
!= 0;
18625 return ((int) parser
->num_template_parameter_lists
> template_class_depth
18626 (current_class_type
));
18629 /* Parse a parameter-declaration-clause.
18631 parameter-declaration-clause:
18632 parameter-declaration-list [opt] ... [opt]
18633 parameter-declaration-list , ...
18635 Returns a representation for the parameter declarations. A return
18636 value of NULL indicates a parameter-declaration-clause consisting
18637 only of an ellipsis. */
18640 cp_parser_parameter_declaration_clause (cp_parser
* parser
)
18649 int auto_is_implicit_function_template_parm_p
;
18651 parser
->auto_is_implicit_function_template_parm_p
18652 = auto_is_implicit_function_template_parm_p
;
18654 } cleanup
= { parser
, parser
->auto_is_implicit_function_template_parm_p
};
18658 if (!processing_specialization
18659 && !processing_template_parmlist
18660 && !processing_explicit_instantiation
)
18661 if (!current_function_decl
18662 || (current_class_type
&& LAMBDA_TYPE_P (current_class_type
)))
18663 parser
->auto_is_implicit_function_template_parm_p
= true;
18665 /* Peek at the next token. */
18666 token
= cp_lexer_peek_token (parser
->lexer
);
18667 /* Check for trivial parameter-declaration-clauses. */
18668 if (token
->type
== CPP_ELLIPSIS
)
18670 /* Consume the `...' token. */
18671 cp_lexer_consume_token (parser
->lexer
);
18674 else if (token
->type
== CPP_CLOSE_PAREN
)
18675 /* There are no parameters. */
18677 #ifndef NO_IMPLICIT_EXTERN_C
18678 if (in_system_header_at (input_location
)
18679 && current_class_type
== NULL
18680 && current_lang_name
== lang_name_c
)
18684 return void_list_node
;
18686 /* Check for `(void)', too, which is a special case. */
18687 else if (token
->keyword
== RID_VOID
18688 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
18689 == CPP_CLOSE_PAREN
))
18691 /* Consume the `void' token. */
18692 cp_lexer_consume_token (parser
->lexer
);
18693 /* There are no parameters. */
18694 return void_list_node
;
18697 /* Parse the parameter-declaration-list. */
18698 parameters
= cp_parser_parameter_declaration_list (parser
, &is_error
);
18699 /* If a parse error occurred while parsing the
18700 parameter-declaration-list, then the entire
18701 parameter-declaration-clause is erroneous. */
18705 /* Peek at the next token. */
18706 token
= cp_lexer_peek_token (parser
->lexer
);
18707 /* If it's a `,', the clause should terminate with an ellipsis. */
18708 if (token
->type
== CPP_COMMA
)
18710 /* Consume the `,'. */
18711 cp_lexer_consume_token (parser
->lexer
);
18712 /* Expect an ellipsis. */
18714 = (cp_parser_require (parser
, CPP_ELLIPSIS
, RT_ELLIPSIS
) != NULL
);
18716 /* It might also be `...' if the optional trailing `,' was
18718 else if (token
->type
== CPP_ELLIPSIS
)
18720 /* Consume the `...' token. */
18721 cp_lexer_consume_token (parser
->lexer
);
18722 /* And remember that we saw it. */
18726 ellipsis_p
= false;
18728 /* Finish the parameter list. */
18730 parameters
= chainon (parameters
, void_list_node
);
18735 /* Parse a parameter-declaration-list.
18737 parameter-declaration-list:
18738 parameter-declaration
18739 parameter-declaration-list , parameter-declaration
18741 Returns a representation of the parameter-declaration-list, as for
18742 cp_parser_parameter_declaration_clause. However, the
18743 `void_list_node' is never appended to the list. Upon return,
18744 *IS_ERROR will be true iff an error occurred. */
18747 cp_parser_parameter_declaration_list (cp_parser
* parser
, bool *is_error
)
18749 tree parameters
= NULL_TREE
;
18750 tree
*tail
= ¶meters
;
18751 bool saved_in_unbraced_linkage_specification_p
;
18754 /* Assume all will go well. */
18756 /* The special considerations that apply to a function within an
18757 unbraced linkage specifications do not apply to the parameters
18758 to the function. */
18759 saved_in_unbraced_linkage_specification_p
18760 = parser
->in_unbraced_linkage_specification_p
;
18761 parser
->in_unbraced_linkage_specification_p
= false;
18763 /* Look for more parameters. */
18766 cp_parameter_declarator
*parameter
;
18767 tree decl
= error_mark_node
;
18768 bool parenthesized_p
= false;
18769 int template_parm_idx
= (function_being_declared_is_template_p (parser
)?
18770 TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
18771 (current_template_parms
)) : 0);
18773 /* Parse the parameter. */
18775 = cp_parser_parameter_declaration (parser
,
18776 /*template_parm_p=*/false,
18779 /* We don't know yet if the enclosing context is deprecated, so wait
18780 and warn in grokparms if appropriate. */
18781 deprecated_state
= DEPRECATED_SUPPRESS
;
18785 /* If a function parameter pack was specified and an implicit template
18786 parameter was introduced during cp_parser_parameter_declaration,
18787 change any implicit parameters introduced into packs. */
18788 if (parser
->implicit_template_parms
18789 && parameter
->declarator
18790 && parameter
->declarator
->parameter_pack_p
)
18792 int latest_template_parm_idx
= TREE_VEC_LENGTH
18793 (INNERMOST_TEMPLATE_PARMS (current_template_parms
));
18795 if (latest_template_parm_idx
!= template_parm_idx
)
18796 parameter
->decl_specifiers
.type
= convert_generic_types_to_packs
18797 (parameter
->decl_specifiers
.type
,
18798 template_parm_idx
, latest_template_parm_idx
);
18801 decl
= grokdeclarator (parameter
->declarator
,
18802 ¶meter
->decl_specifiers
,
18804 parameter
->default_argument
!= NULL_TREE
,
18805 ¶meter
->decl_specifiers
.attributes
);
18808 deprecated_state
= DEPRECATED_NORMAL
;
18810 /* If a parse error occurred parsing the parameter declaration,
18811 then the entire parameter-declaration-list is erroneous. */
18812 if (decl
== error_mark_node
)
18815 parameters
= error_mark_node
;
18819 if (parameter
->decl_specifiers
.attributes
)
18820 cplus_decl_attributes (&decl
,
18821 parameter
->decl_specifiers
.attributes
,
18823 if (DECL_NAME (decl
))
18824 decl
= pushdecl (decl
);
18826 if (decl
!= error_mark_node
)
18828 retrofit_lang_decl (decl
);
18829 DECL_PARM_INDEX (decl
) = ++index
;
18830 DECL_PARM_LEVEL (decl
) = function_parm_depth ();
18833 /* Add the new parameter to the list. */
18834 *tail
= build_tree_list (parameter
->default_argument
, decl
);
18835 tail
= &TREE_CHAIN (*tail
);
18837 /* Peek at the next token. */
18838 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
)
18839 || cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
)
18840 /* These are for Objective-C++ */
18841 || cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
18842 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
18843 /* The parameter-declaration-list is complete. */
18845 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
18849 /* Peek at the next token. */
18850 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
18851 /* If it's an ellipsis, then the list is complete. */
18852 if (token
->type
== CPP_ELLIPSIS
)
18854 /* Otherwise, there must be more parameters. Consume the
18856 cp_lexer_consume_token (parser
->lexer
);
18857 /* When parsing something like:
18859 int i(float f, double d)
18861 we can tell after seeing the declaration for "f" that we
18862 are not looking at an initialization of a variable "i",
18863 but rather at the declaration of a function "i".
18865 Due to the fact that the parsing of template arguments
18866 (as specified to a template-id) requires backtracking we
18867 cannot use this technique when inside a template argument
18869 if (!parser
->in_template_argument_list_p
18870 && !parser
->in_type_id_in_expr_p
18871 && cp_parser_uncommitted_to_tentative_parse_p (parser
)
18872 /* However, a parameter-declaration of the form
18873 "float(f)" (which is a valid declaration of a
18874 parameter "f") can also be interpreted as an
18875 expression (the conversion of "f" to "float"). */
18876 && !parenthesized_p
)
18877 cp_parser_commit_to_tentative_parse (parser
);
18881 cp_parser_error (parser
, "expected %<,%> or %<...%>");
18882 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
18883 cp_parser_skip_to_closing_parenthesis (parser
,
18884 /*recovering=*/true,
18885 /*or_comma=*/false,
18886 /*consume_paren=*/false);
18891 parser
->in_unbraced_linkage_specification_p
18892 = saved_in_unbraced_linkage_specification_p
;
18894 /* Reset implicit_template_scope if we are about to leave the function
18895 parameter list that introduced it. Note that for out-of-line member
18896 definitions, there will be one or more class scopes before we get to
18897 the template parameter scope. */
18899 if (cp_binding_level
*its
= parser
->implicit_template_scope
)
18900 if (cp_binding_level
*maybe_its
= current_binding_level
->level_chain
)
18902 while (maybe_its
->kind
== sk_class
)
18903 maybe_its
= maybe_its
->level_chain
;
18904 if (maybe_its
== its
)
18906 parser
->implicit_template_parms
= 0;
18907 parser
->implicit_template_scope
= 0;
18914 /* Parse a parameter declaration.
18916 parameter-declaration:
18917 decl-specifier-seq ... [opt] declarator
18918 decl-specifier-seq declarator = assignment-expression
18919 decl-specifier-seq ... [opt] abstract-declarator [opt]
18920 decl-specifier-seq abstract-declarator [opt] = assignment-expression
18922 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
18923 declares a template parameter. (In that case, a non-nested `>'
18924 token encountered during the parsing of the assignment-expression
18925 is not interpreted as a greater-than operator.)
18927 Returns a representation of the parameter, or NULL if an error
18928 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
18929 true iff the declarator is of the form "(p)". */
18931 static cp_parameter_declarator
*
18932 cp_parser_parameter_declaration (cp_parser
*parser
,
18933 bool template_parm_p
,
18934 bool *parenthesized_p
)
18936 int declares_class_or_enum
;
18937 cp_decl_specifier_seq decl_specifiers
;
18938 cp_declarator
*declarator
;
18939 tree default_argument
;
18940 cp_token
*token
= NULL
, *declarator_token_start
= NULL
;
18941 const char *saved_message
;
18943 /* In a template parameter, `>' is not an operator.
18947 When parsing a default template-argument for a non-type
18948 template-parameter, the first non-nested `>' is taken as the end
18949 of the template parameter-list rather than a greater-than
18952 /* Type definitions may not appear in parameter types. */
18953 saved_message
= parser
->type_definition_forbidden_message
;
18954 parser
->type_definition_forbidden_message
18955 = G_("types may not be defined in parameter types");
18957 /* Parse the declaration-specifiers. */
18958 cp_parser_decl_specifier_seq (parser
,
18959 CP_PARSER_FLAGS_NONE
,
18961 &declares_class_or_enum
);
18963 /* Complain about missing 'typename' or other invalid type names. */
18964 if (!decl_specifiers
.any_type_specifiers_p
18965 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
18966 decl_specifiers
.type
= error_mark_node
;
18968 /* If an error occurred, there's no reason to attempt to parse the
18969 rest of the declaration. */
18970 if (cp_parser_error_occurred (parser
))
18972 parser
->type_definition_forbidden_message
= saved_message
;
18976 /* Peek at the next token. */
18977 token
= cp_lexer_peek_token (parser
->lexer
);
18979 /* If the next token is a `)', `,', `=', `>', or `...', then there
18980 is no declarator. However, when variadic templates are enabled,
18981 there may be a declarator following `...'. */
18982 if (token
->type
== CPP_CLOSE_PAREN
18983 || token
->type
== CPP_COMMA
18984 || token
->type
== CPP_EQ
18985 || token
->type
== CPP_GREATER
)
18988 if (parenthesized_p
)
18989 *parenthesized_p
= false;
18991 /* Otherwise, there should be a declarator. */
18994 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
18995 parser
->default_arg_ok_p
= false;
18997 /* After seeing a decl-specifier-seq, if the next token is not a
18998 "(", there is no possibility that the code is a valid
18999 expression. Therefore, if parsing tentatively, we commit at
19001 if (!parser
->in_template_argument_list_p
19002 /* In an expression context, having seen:
19006 we cannot be sure whether we are looking at a
19007 function-type (taking a "char" as a parameter) or a cast
19008 of some object of type "char" to "int". */
19009 && !parser
->in_type_id_in_expr_p
19010 && cp_parser_uncommitted_to_tentative_parse_p (parser
)
19011 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
)
19012 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
))
19013 cp_parser_commit_to_tentative_parse (parser
);
19014 /* Parse the declarator. */
19015 declarator_token_start
= token
;
19016 declarator
= cp_parser_declarator (parser
,
19017 CP_PARSER_DECLARATOR_EITHER
,
19018 /*ctor_dtor_or_conv_p=*/NULL
,
19020 /*member_p=*/false,
19021 /*friend_p=*/false);
19022 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
19023 /* After the declarator, allow more attributes. */
19024 decl_specifiers
.attributes
19025 = chainon (decl_specifiers
.attributes
,
19026 cp_parser_attributes_opt (parser
));
19029 /* If the next token is an ellipsis, and we have not seen a
19030 declarator name, and the type of the declarator contains parameter
19031 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
19032 a parameter pack expansion expression. Otherwise, leave the
19033 ellipsis for a C-style variadic function. */
19034 token
= cp_lexer_peek_token (parser
->lexer
);
19035 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
19037 tree type
= decl_specifiers
.type
;
19039 if (type
&& DECL_P (type
))
19040 type
= TREE_TYPE (type
);
19043 && TREE_CODE (type
) != TYPE_PACK_EXPANSION
19044 && declarator_can_be_parameter_pack (declarator
)
19045 && (!declarator
|| !declarator
->parameter_pack_p
)
19046 && uses_parameter_packs (type
))
19048 /* Consume the `...'. */
19049 cp_lexer_consume_token (parser
->lexer
);
19050 maybe_warn_variadic_templates ();
19052 /* Build a pack expansion type */
19054 declarator
->parameter_pack_p
= true;
19056 decl_specifiers
.type
= make_pack_expansion (type
);
19060 /* The restriction on defining new types applies only to the type
19061 of the parameter, not to the default argument. */
19062 parser
->type_definition_forbidden_message
= saved_message
;
19064 /* If the next token is `=', then process a default argument. */
19065 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
19067 token
= cp_lexer_peek_token (parser
->lexer
);
19068 /* If we are defining a class, then the tokens that make up the
19069 default argument must be saved and processed later. */
19070 if (!template_parm_p
&& at_class_scope_p ()
19071 && TYPE_BEING_DEFINED (current_class_type
)
19072 && !LAMBDA_TYPE_P (current_class_type
))
19073 default_argument
= cp_parser_cache_defarg (parser
, /*nsdmi=*/false);
19074 /* Outside of a class definition, we can just parse the
19075 assignment-expression. */
19078 = cp_parser_default_argument (parser
, template_parm_p
);
19080 if (!parser
->default_arg_ok_p
)
19082 if (flag_permissive
)
19083 warning (0, "deprecated use of default argument for parameter of non-function");
19086 error_at (token
->location
,
19087 "default arguments are only "
19088 "permitted for function parameters");
19089 default_argument
= NULL_TREE
;
19092 else if ((declarator
&& declarator
->parameter_pack_p
)
19093 || (decl_specifiers
.type
19094 && PACK_EXPANSION_P (decl_specifiers
.type
)))
19096 /* Find the name of the parameter pack. */
19097 cp_declarator
*id_declarator
= declarator
;
19098 while (id_declarator
&& id_declarator
->kind
!= cdk_id
)
19099 id_declarator
= id_declarator
->declarator
;
19101 if (id_declarator
&& id_declarator
->kind
== cdk_id
)
19102 error_at (declarator_token_start
->location
,
19104 ? G_("template parameter pack %qD "
19105 "cannot have a default argument")
19106 : G_("parameter pack %qD cannot have "
19107 "a default argument"),
19108 id_declarator
->u
.id
.unqualified_name
);
19110 error_at (declarator_token_start
->location
,
19112 ? G_("template parameter pack cannot have "
19113 "a default argument")
19114 : G_("parameter pack cannot have a "
19115 "default argument"));
19117 default_argument
= NULL_TREE
;
19121 default_argument
= NULL_TREE
;
19123 return make_parameter_declarator (&decl_specifiers
,
19128 /* Parse a default argument and return it.
19130 TEMPLATE_PARM_P is true if this is a default argument for a
19131 non-type template parameter. */
19133 cp_parser_default_argument (cp_parser
*parser
, bool template_parm_p
)
19135 tree default_argument
= NULL_TREE
;
19136 bool saved_greater_than_is_operator_p
;
19137 bool saved_local_variables_forbidden_p
;
19138 bool non_constant_p
, is_direct_init
;
19140 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
19142 saved_greater_than_is_operator_p
= parser
->greater_than_is_operator_p
;
19143 parser
->greater_than_is_operator_p
= !template_parm_p
;
19144 /* Local variable names (and the `this' keyword) may not
19145 appear in a default argument. */
19146 saved_local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
19147 parser
->local_variables_forbidden_p
= true;
19148 /* Parse the assignment-expression. */
19149 if (template_parm_p
)
19150 push_deferring_access_checks (dk_no_deferred
);
19151 tree saved_class_ptr
= NULL_TREE
;
19152 tree saved_class_ref
= NULL_TREE
;
19153 /* The "this" pointer is not valid in a default argument. */
19156 saved_class_ptr
= current_class_ptr
;
19157 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
19158 saved_class_ref
= current_class_ref
;
19159 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
19162 = cp_parser_initializer (parser
, &is_direct_init
, &non_constant_p
);
19163 /* Restore the "this" pointer. */
19166 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
19167 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
19169 if (BRACE_ENCLOSED_INITIALIZER_P (default_argument
))
19170 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
19171 if (template_parm_p
)
19172 pop_deferring_access_checks ();
19173 parser
->greater_than_is_operator_p
= saved_greater_than_is_operator_p
;
19174 parser
->local_variables_forbidden_p
= saved_local_variables_forbidden_p
;
19176 return default_argument
;
19179 /* Parse a function-body.
19182 compound_statement */
19185 cp_parser_function_body (cp_parser
*parser
, bool in_function_try_block
)
19187 cp_parser_compound_statement (parser
, NULL
, in_function_try_block
, true);
19190 /* Parse a ctor-initializer-opt followed by a function-body. Return
19191 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
19192 is true we are parsing a function-try-block. */
19195 cp_parser_ctor_initializer_opt_and_function_body (cp_parser
*parser
,
19196 bool in_function_try_block
)
19199 bool ctor_initializer_p
;
19200 const bool check_body_p
=
19201 DECL_CONSTRUCTOR_P (current_function_decl
)
19202 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
);
19205 /* Begin the function body. */
19206 body
= begin_function_body ();
19207 /* Parse the optional ctor-initializer. */
19208 ctor_initializer_p
= cp_parser_ctor_initializer_opt (parser
);
19210 /* If we're parsing a constexpr constructor definition, we need
19211 to check that the constructor body is indeed empty. However,
19212 before we get to cp_parser_function_body lot of junk has been
19213 generated, so we can't just check that we have an empty block.
19214 Rather we take a snapshot of the outermost block, and check whether
19215 cp_parser_function_body changed its state. */
19218 list
= cur_stmt_list
;
19219 if (STATEMENT_LIST_TAIL (list
))
19220 last
= STATEMENT_LIST_TAIL (list
)->stmt
;
19222 /* Parse the function-body. */
19223 cp_parser_function_body (parser
, in_function_try_block
);
19225 check_constexpr_ctor_body (last
, list
, /*complain=*/true);
19226 /* Finish the function body. */
19227 finish_function_body (body
);
19229 return ctor_initializer_p
;
19232 /* Parse an initializer.
19235 = initializer-clause
19236 ( expression-list )
19238 Returns an expression representing the initializer. If no
19239 initializer is present, NULL_TREE is returned.
19241 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
19242 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
19243 set to TRUE if there is no initializer present. If there is an
19244 initializer, and it is not a constant-expression, *NON_CONSTANT_P
19245 is set to true; otherwise it is set to false. */
19248 cp_parser_initializer (cp_parser
* parser
, bool* is_direct_init
,
19249 bool* non_constant_p
)
19254 /* Peek at the next token. */
19255 token
= cp_lexer_peek_token (parser
->lexer
);
19257 /* Let our caller know whether or not this initializer was
19259 *is_direct_init
= (token
->type
!= CPP_EQ
);
19260 /* Assume that the initializer is constant. */
19261 *non_constant_p
= false;
19263 if (token
->type
== CPP_EQ
)
19265 /* Consume the `='. */
19266 cp_lexer_consume_token (parser
->lexer
);
19267 /* Parse the initializer-clause. */
19268 init
= cp_parser_initializer_clause (parser
, non_constant_p
);
19270 else if (token
->type
== CPP_OPEN_PAREN
)
19272 vec
<tree
, va_gc
> *vec
;
19273 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
19275 /*allow_expansion_p=*/true,
19278 return error_mark_node
;
19279 init
= build_tree_list_vec (vec
);
19280 release_tree_vector (vec
);
19282 else if (token
->type
== CPP_OPEN_BRACE
)
19284 cp_lexer_set_source_position (parser
->lexer
);
19285 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
19286 init
= cp_parser_braced_list (parser
, non_constant_p
);
19287 CONSTRUCTOR_IS_DIRECT_INIT (init
) = 1;
19291 /* Anything else is an error. */
19292 cp_parser_error (parser
, "expected initializer");
19293 init
= error_mark_node
;
19299 /* Parse an initializer-clause.
19301 initializer-clause:
19302 assignment-expression
19305 Returns an expression representing the initializer.
19307 If the `assignment-expression' production is used the value
19308 returned is simply a representation for the expression.
19310 Otherwise, calls cp_parser_braced_list. */
19313 cp_parser_initializer_clause (cp_parser
* parser
, bool* non_constant_p
)
19317 /* Assume the expression is constant. */
19318 *non_constant_p
= false;
19320 /* If it is not a `{', then we are looking at an
19321 assignment-expression. */
19322 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
19325 = cp_parser_constant_expression (parser
,
19326 /*allow_non_constant_p=*/true,
19330 initializer
= cp_parser_braced_list (parser
, non_constant_p
);
19332 return initializer
;
19335 /* Parse a brace-enclosed initializer list.
19338 { initializer-list , [opt] }
19341 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
19342 the elements of the initializer-list (or NULL, if the last
19343 production is used). The TREE_TYPE for the CONSTRUCTOR will be
19344 NULL_TREE. There is no way to detect whether or not the optional
19345 trailing `,' was provided. NON_CONSTANT_P is as for
19346 cp_parser_initializer. */
19349 cp_parser_braced_list (cp_parser
* parser
, bool* non_constant_p
)
19353 /* Consume the `{' token. */
19354 cp_lexer_consume_token (parser
->lexer
);
19355 /* Create a CONSTRUCTOR to represent the braced-initializer. */
19356 initializer
= make_node (CONSTRUCTOR
);
19357 /* If it's not a `}', then there is a non-trivial initializer. */
19358 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_BRACE
))
19360 /* Parse the initializer list. */
19361 CONSTRUCTOR_ELTS (initializer
)
19362 = cp_parser_initializer_list (parser
, non_constant_p
);
19363 /* A trailing `,' token is allowed. */
19364 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
19365 cp_lexer_consume_token (parser
->lexer
);
19368 *non_constant_p
= false;
19369 /* Now, there should be a trailing `}'. */
19370 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
19371 TREE_TYPE (initializer
) = init_list_type_node
;
19372 return initializer
;
19375 /* Consume tokens up to, and including, the next non-nested closing `]'.
19376 Returns true iff we found a closing `]'. */
19379 cp_parser_skip_to_closing_square_bracket (cp_parser
*parser
)
19381 unsigned square_depth
= 0;
19385 cp_token
* token
= cp_lexer_peek_token (parser
->lexer
);
19387 switch (token
->type
)
19390 case CPP_PRAGMA_EOL
:
19391 /* If we've run out of tokens, then there is no closing `]'. */
19394 case CPP_OPEN_SQUARE
:
19398 case CPP_CLOSE_SQUARE
:
19399 if (!square_depth
--)
19401 cp_lexer_consume_token (parser
->lexer
);
19410 /* Consume the token. */
19411 cp_lexer_consume_token (parser
->lexer
);
19415 /* Return true if we are looking at an array-designator, false otherwise. */
19418 cp_parser_array_designator_p (cp_parser
*parser
)
19420 /* Consume the `['. */
19421 cp_lexer_consume_token (parser
->lexer
);
19423 cp_lexer_save_tokens (parser
->lexer
);
19425 /* Skip tokens until the next token is a closing square bracket.
19426 If we find the closing `]', and the next token is a `=', then
19427 we are looking at an array designator. */
19428 bool array_designator_p
19429 = (cp_parser_skip_to_closing_square_bracket (parser
)
19430 && cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
));
19432 /* Roll back the tokens we skipped. */
19433 cp_lexer_rollback_tokens (parser
->lexer
);
19435 return array_designator_p
;
19438 /* Parse an initializer-list.
19441 initializer-clause ... [opt]
19442 initializer-list , initializer-clause ... [opt]
19447 designation initializer-clause ...[opt]
19448 initializer-list , designation initializer-clause ...[opt]
19453 [ constant-expression ] =
19455 Returns a vec of constructor_elt. The VALUE of each elt is an expression
19456 for the initializer. If the INDEX of the elt is non-NULL, it is the
19457 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
19458 as for cp_parser_initializer. */
19460 static vec
<constructor_elt
, va_gc
> *
19461 cp_parser_initializer_list (cp_parser
* parser
, bool* non_constant_p
)
19463 vec
<constructor_elt
, va_gc
> *v
= NULL
;
19465 /* Assume all of the expressions are constant. */
19466 *non_constant_p
= false;
19468 /* Parse the rest of the list. */
19474 bool clause_non_constant_p
;
19476 /* If the next token is an identifier and the following one is a
19477 colon, we are looking at the GNU designated-initializer
19479 if (cp_parser_allow_gnu_extensions_p (parser
)
19480 && cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
19481 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_COLON
)
19483 /* Warn the user that they are using an extension. */
19484 pedwarn (input_location
, OPT_Wpedantic
,
19485 "ISO C++ does not allow designated initializers");
19486 /* Consume the identifier. */
19487 designator
= cp_lexer_consume_token (parser
->lexer
)->u
.value
;
19488 /* Consume the `:'. */
19489 cp_lexer_consume_token (parser
->lexer
);
19491 /* Also handle the C99 syntax, '. id ='. */
19492 else if (cp_parser_allow_gnu_extensions_p (parser
)
19493 && cp_lexer_next_token_is (parser
->lexer
, CPP_DOT
)
19494 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_NAME
19495 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_EQ
)
19497 /* Warn the user that they are using an extension. */
19498 pedwarn (input_location
, OPT_Wpedantic
,
19499 "ISO C++ does not allow C99 designated initializers");
19500 /* Consume the `.'. */
19501 cp_lexer_consume_token (parser
->lexer
);
19502 /* Consume the identifier. */
19503 designator
= cp_lexer_consume_token (parser
->lexer
)->u
.value
;
19504 /* Consume the `='. */
19505 cp_lexer_consume_token (parser
->lexer
);
19507 /* Also handle C99 array designators, '[ const ] ='. */
19508 else if (cp_parser_allow_gnu_extensions_p (parser
)
19509 && !c_dialect_objc ()
19510 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
19512 /* In C++11, [ could start a lambda-introducer. */
19513 bool non_const
= false;
19515 cp_parser_parse_tentatively (parser
);
19517 if (!cp_parser_array_designator_p (parser
))
19519 cp_parser_simulate_error (parser
);
19520 designator
= NULL_TREE
;
19524 designator
= cp_parser_constant_expression (parser
, true,
19526 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
19527 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
19530 if (!cp_parser_parse_definitely (parser
))
19531 designator
= NULL_TREE
;
19532 else if (non_const
)
19533 require_potential_rvalue_constant_expression (designator
);
19536 designator
= NULL_TREE
;
19538 /* Parse the initializer. */
19539 initializer
= cp_parser_initializer_clause (parser
,
19540 &clause_non_constant_p
);
19541 /* If any clause is non-constant, so is the entire initializer. */
19542 if (clause_non_constant_p
)
19543 *non_constant_p
= true;
19545 /* If we have an ellipsis, this is an initializer pack
19547 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
19549 /* Consume the `...'. */
19550 cp_lexer_consume_token (parser
->lexer
);
19552 /* Turn the initializer into an initializer expansion. */
19553 initializer
= make_pack_expansion (initializer
);
19556 /* Add it to the vector. */
19557 CONSTRUCTOR_APPEND_ELT (v
, designator
, initializer
);
19559 /* If the next token is not a comma, we have reached the end of
19561 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
19564 /* Peek at the next token. */
19565 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
19566 /* If the next token is a `}', then we're still done. An
19567 initializer-clause can have a trailing `,' after the
19568 initializer-list and before the closing `}'. */
19569 if (token
->type
== CPP_CLOSE_BRACE
)
19572 /* Consume the `,' token. */
19573 cp_lexer_consume_token (parser
->lexer
);
19579 /* Classes [gram.class] */
19581 /* Parse a class-name.
19587 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
19588 to indicate that names looked up in dependent types should be
19589 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
19590 keyword has been used to indicate that the name that appears next
19591 is a template. TAG_TYPE indicates the explicit tag given before
19592 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
19593 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
19594 is the class being defined in a class-head. If ENUM_OK is TRUE,
19595 enum-names are also accepted.
19597 Returns the TYPE_DECL representing the class. */
19600 cp_parser_class_name (cp_parser
*parser
,
19601 bool typename_keyword_p
,
19602 bool template_keyword_p
,
19603 enum tag_types tag_type
,
19604 bool check_dependency_p
,
19606 bool is_declaration
,
19613 tree identifier
= NULL_TREE
;
19615 /* All class-names start with an identifier. */
19616 token
= cp_lexer_peek_token (parser
->lexer
);
19617 if (token
->type
!= CPP_NAME
&& token
->type
!= CPP_TEMPLATE_ID
)
19619 cp_parser_error (parser
, "expected class-name");
19620 return error_mark_node
;
19623 /* PARSER->SCOPE can be cleared when parsing the template-arguments
19624 to a template-id, so we save it here. */
19625 scope
= parser
->scope
;
19626 if (scope
== error_mark_node
)
19627 return error_mark_node
;
19629 /* Any name names a type if we're following the `typename' keyword
19630 in a qualified name where the enclosing scope is type-dependent. */
19631 typename_p
= (typename_keyword_p
&& scope
&& TYPE_P (scope
)
19632 && dependent_type_p (scope
));
19633 /* Handle the common case (an identifier, but not a template-id)
19635 if (token
->type
== CPP_NAME
19636 && !cp_parser_nth_token_starts_template_argument_list_p (parser
, 2))
19638 cp_token
*identifier_token
;
19641 /* Look for the identifier. */
19642 identifier_token
= cp_lexer_peek_token (parser
->lexer
);
19643 ambiguous_p
= identifier_token
->error_reported
;
19644 identifier
= cp_parser_identifier (parser
);
19645 /* If the next token isn't an identifier, we are certainly not
19646 looking at a class-name. */
19647 if (identifier
== error_mark_node
)
19648 decl
= error_mark_node
;
19649 /* If we know this is a type-name, there's no need to look it
19651 else if (typename_p
)
19655 tree ambiguous_decls
;
19656 /* If we already know that this lookup is ambiguous, then
19657 we've already issued an error message; there's no reason
19661 cp_parser_simulate_error (parser
);
19662 return error_mark_node
;
19664 /* If the next token is a `::', then the name must be a type
19667 [basic.lookup.qual]
19669 During the lookup for a name preceding the :: scope
19670 resolution operator, object, function, and enumerator
19671 names are ignored. */
19672 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
19673 tag_type
= typename_type
;
19674 /* Look up the name. */
19675 decl
= cp_parser_lookup_name (parser
, identifier
,
19677 /*is_template=*/false,
19678 /*is_namespace=*/false,
19679 check_dependency_p
,
19681 identifier_token
->location
);
19682 if (ambiguous_decls
)
19684 if (cp_parser_parsing_tentatively (parser
))
19685 cp_parser_simulate_error (parser
);
19686 return error_mark_node
;
19692 /* Try a template-id. */
19693 decl
= cp_parser_template_id (parser
, template_keyword_p
,
19694 check_dependency_p
,
19697 if (decl
== error_mark_node
)
19698 return error_mark_node
;
19701 decl
= cp_parser_maybe_treat_template_as_class (decl
, class_head_p
);
19703 /* If this is a typename, create a TYPENAME_TYPE. */
19704 if (typename_p
&& decl
!= error_mark_node
)
19706 decl
= make_typename_type (scope
, decl
, typename_type
,
19707 /*complain=*/tf_error
);
19708 if (decl
!= error_mark_node
)
19709 decl
= TYPE_NAME (decl
);
19712 decl
= strip_using_decl (decl
);
19714 /* Check to see that it is really the name of a class. */
19715 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
19716 && identifier_p (TREE_OPERAND (decl
, 0))
19717 && cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
19718 /* Situations like this:
19720 template <typename T> struct A {
19721 typename T::template X<int>::I i;
19724 are problematic. Is `T::template X<int>' a class-name? The
19725 standard does not seem to be definitive, but there is no other
19726 valid interpretation of the following `::'. Therefore, those
19727 names are considered class-names. */
19729 decl
= make_typename_type (scope
, decl
, tag_type
, tf_error
);
19730 if (decl
!= error_mark_node
)
19731 decl
= TYPE_NAME (decl
);
19733 else if (TREE_CODE (decl
) != TYPE_DECL
19734 || TREE_TYPE (decl
) == error_mark_node
19735 || !(MAYBE_CLASS_TYPE_P (TREE_TYPE (decl
))
19736 || (enum_ok
&& TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
))
19737 /* In Objective-C 2.0, a classname followed by '.' starts a
19738 dot-syntax expression, and it's not a type-name. */
19739 || (c_dialect_objc ()
19740 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_DOT
19741 && objc_is_class_name (decl
)))
19742 decl
= error_mark_node
;
19744 if (decl
== error_mark_node
)
19745 cp_parser_error (parser
, "expected class-name");
19746 else if (identifier
&& !parser
->scope
)
19747 maybe_note_name_used_in_class (identifier
, decl
);
19752 /* Parse a class-specifier.
19755 class-head { member-specification [opt] }
19757 Returns the TREE_TYPE representing the class. */
19760 cp_parser_class_specifier_1 (cp_parser
* parser
)
19763 tree attributes
= NULL_TREE
;
19764 bool nested_name_specifier_p
;
19765 unsigned saved_num_template_parameter_lists
;
19766 bool saved_in_function_body
;
19767 unsigned char in_statement
;
19768 bool in_switch_statement_p
;
19769 bool saved_in_unbraced_linkage_specification_p
;
19770 tree old_scope
= NULL_TREE
;
19771 tree scope
= NULL_TREE
;
19772 cp_token
*closing_brace
;
19774 push_deferring_access_checks (dk_no_deferred
);
19776 /* Parse the class-head. */
19777 type
= cp_parser_class_head (parser
,
19778 &nested_name_specifier_p
);
19779 /* If the class-head was a semantic disaster, skip the entire body
19783 cp_parser_skip_to_end_of_block_or_statement (parser
);
19784 pop_deferring_access_checks ();
19785 return error_mark_node
;
19788 /* Look for the `{'. */
19789 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
19791 pop_deferring_access_checks ();
19792 return error_mark_node
;
19795 cp_ensure_no_omp_declare_simd (parser
);
19797 /* Issue an error message if type-definitions are forbidden here. */
19798 cp_parser_check_type_definition (parser
);
19799 /* Remember that we are defining one more class. */
19800 ++parser
->num_classes_being_defined
;
19801 /* Inside the class, surrounding template-parameter-lists do not
19803 saved_num_template_parameter_lists
19804 = parser
->num_template_parameter_lists
;
19805 parser
->num_template_parameter_lists
= 0;
19806 /* We are not in a function body. */
19807 saved_in_function_body
= parser
->in_function_body
;
19808 parser
->in_function_body
= false;
19809 /* Or in a loop. */
19810 in_statement
= parser
->in_statement
;
19811 parser
->in_statement
= 0;
19812 /* Or in a switch. */
19813 in_switch_statement_p
= parser
->in_switch_statement_p
;
19814 parser
->in_switch_statement_p
= false;
19815 /* We are not immediately inside an extern "lang" block. */
19816 saved_in_unbraced_linkage_specification_p
19817 = parser
->in_unbraced_linkage_specification_p
;
19818 parser
->in_unbraced_linkage_specification_p
= false;
19820 /* Start the class. */
19821 if (nested_name_specifier_p
)
19823 scope
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (type
));
19824 old_scope
= push_inner_scope (scope
);
19826 type
= begin_class_definition (type
);
19828 if (type
== error_mark_node
)
19829 /* If the type is erroneous, skip the entire body of the class. */
19830 cp_parser_skip_to_closing_brace (parser
);
19832 /* Parse the member-specification. */
19833 cp_parser_member_specification_opt (parser
);
19835 /* Look for the trailing `}'. */
19836 closing_brace
= cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
19837 /* Look for trailing attributes to apply to this class. */
19838 if (cp_parser_allow_gnu_extensions_p (parser
))
19839 attributes
= cp_parser_gnu_attributes_opt (parser
);
19840 if (type
!= error_mark_node
)
19841 type
= finish_struct (type
, attributes
);
19842 if (nested_name_specifier_p
)
19843 pop_inner_scope (old_scope
, scope
);
19845 /* We've finished a type definition. Check for the common syntax
19846 error of forgetting a semicolon after the definition. We need to
19847 be careful, as we can't just check for not-a-semicolon and be done
19848 with it; the user might have typed:
19850 class X { } c = ...;
19851 class X { } *p = ...;
19853 and so forth. Instead, enumerate all the possible tokens that
19854 might follow this production; if we don't see one of them, then
19855 complain and silently insert the semicolon. */
19857 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19858 bool want_semicolon
= true;
19860 if (cp_next_tokens_can_be_std_attribute_p (parser
))
19861 /* Don't try to parse c++11 attributes here. As per the
19862 grammar, that should be a task for
19863 cp_parser_decl_specifier_seq. */
19864 want_semicolon
= false;
19866 switch (token
->type
)
19869 case CPP_SEMICOLON
:
19872 case CPP_OPEN_PAREN
:
19873 case CPP_CLOSE_PAREN
:
19875 want_semicolon
= false;
19878 /* While it's legal for type qualifiers and storage class
19879 specifiers to follow type definitions in the grammar, only
19880 compiler testsuites contain code like that. Assume that if
19881 we see such code, then what we're really seeing is a case
19885 const <type> var = ...;
19890 static <type> func (...) ...
19892 i.e. the qualifier or specifier applies to the next
19893 declaration. To do so, however, we need to look ahead one
19894 more token to see if *that* token is a type specifier.
19896 This code could be improved to handle:
19899 static const <type> var = ...; */
19901 if (keyword_is_decl_specifier (token
->keyword
))
19903 cp_token
*lookahead
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
19905 /* Handling user-defined types here would be nice, but very
19908 = (lookahead
->type
== CPP_KEYWORD
19909 && keyword_begins_type_specifier (lookahead
->keyword
));
19916 /* If we don't have a type, then something is very wrong and we
19917 shouldn't try to do anything clever. Likewise for not seeing the
19919 if (closing_brace
&& TYPE_P (type
) && want_semicolon
)
19921 cp_token_position prev
19922 = cp_lexer_previous_token_position (parser
->lexer
);
19923 cp_token
*prev_token
= cp_lexer_token_at (parser
->lexer
, prev
);
19924 location_t loc
= prev_token
->location
;
19926 if (CLASSTYPE_DECLARED_CLASS (type
))
19927 error_at (loc
, "expected %<;%> after class definition");
19928 else if (TREE_CODE (type
) == RECORD_TYPE
)
19929 error_at (loc
, "expected %<;%> after struct definition");
19930 else if (TREE_CODE (type
) == UNION_TYPE
)
19931 error_at (loc
, "expected %<;%> after union definition");
19933 gcc_unreachable ();
19935 /* Unget one token and smash it to look as though we encountered
19936 a semicolon in the input stream. */
19937 cp_lexer_set_token_position (parser
->lexer
, prev
);
19938 token
= cp_lexer_peek_token (parser
->lexer
);
19939 token
->type
= CPP_SEMICOLON
;
19940 token
->keyword
= RID_MAX
;
19944 /* If this class is not itself within the scope of another class,
19945 then we need to parse the bodies of all of the queued function
19946 definitions. Note that the queued functions defined in a class
19947 are not always processed immediately following the
19948 class-specifier for that class. Consider:
19951 struct B { void f() { sizeof (A); } };
19954 If `f' were processed before the processing of `A' were
19955 completed, there would be no way to compute the size of `A'.
19956 Note that the nesting we are interested in here is lexical --
19957 not the semantic nesting given by TYPE_CONTEXT. In particular,
19960 struct A { struct B; };
19961 struct A::B { void f() { } };
19963 there is no need to delay the parsing of `A::B::f'. */
19964 if (--parser
->num_classes_being_defined
== 0)
19967 tree class_type
= NULL_TREE
;
19968 tree pushed_scope
= NULL_TREE
;
19970 cp_default_arg_entry
*e
;
19971 tree save_ccp
, save_ccr
;
19973 /* In a first pass, parse default arguments to the functions.
19974 Then, in a second pass, parse the bodies of the functions.
19975 This two-phased approach handles cases like:
19983 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_default_args
, ix
, e
)
19986 /* If there are default arguments that have not yet been processed,
19987 take care of them now. */
19988 if (class_type
!= e
->class_type
)
19991 pop_scope (pushed_scope
);
19992 class_type
= e
->class_type
;
19993 pushed_scope
= push_scope (class_type
);
19995 /* Make sure that any template parameters are in scope. */
19996 maybe_begin_member_template_processing (decl
);
19997 /* Parse the default argument expressions. */
19998 cp_parser_late_parsing_default_args (parser
, decl
);
19999 /* Remove any template parameters from the symbol table. */
20000 maybe_end_member_template_processing ();
20002 vec_safe_truncate (unparsed_funs_with_default_args
, 0);
20003 /* Now parse any NSDMIs. */
20004 save_ccp
= current_class_ptr
;
20005 save_ccr
= current_class_ref
;
20006 FOR_EACH_VEC_SAFE_ELT (unparsed_nsdmis
, ix
, decl
)
20008 if (class_type
!= DECL_CONTEXT (decl
))
20011 pop_scope (pushed_scope
);
20012 class_type
= DECL_CONTEXT (decl
);
20013 pushed_scope
= push_scope (class_type
);
20015 inject_this_parameter (class_type
, TYPE_UNQUALIFIED
);
20016 cp_parser_late_parsing_nsdmi (parser
, decl
);
20018 vec_safe_truncate (unparsed_nsdmis
, 0);
20019 current_class_ptr
= save_ccp
;
20020 current_class_ref
= save_ccr
;
20022 pop_scope (pushed_scope
);
20024 /* Now do some post-NSDMI bookkeeping. */
20025 FOR_EACH_VEC_SAFE_ELT (unparsed_classes
, ix
, class_type
)
20026 after_nsdmi_defaulted_late_checks (class_type
);
20027 vec_safe_truncate (unparsed_classes
, 0);
20028 after_nsdmi_defaulted_late_checks (type
);
20030 /* Now parse the body of the functions. */
20033 /* OpenMP UDRs need to be parsed before all other functions. */
20034 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions
, ix
, decl
)
20035 if (DECL_OMP_DECLARE_REDUCTION_P (decl
))
20036 cp_parser_late_parsing_for_member (parser
, decl
);
20037 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions
, ix
, decl
)
20038 if (!DECL_OMP_DECLARE_REDUCTION_P (decl
))
20039 cp_parser_late_parsing_for_member (parser
, decl
);
20042 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions
, ix
, decl
)
20043 cp_parser_late_parsing_for_member (parser
, decl
);
20044 vec_safe_truncate (unparsed_funs_with_definitions
, 0);
20047 vec_safe_push (unparsed_classes
, type
);
20049 /* Put back any saved access checks. */
20050 pop_deferring_access_checks ();
20052 /* Restore saved state. */
20053 parser
->in_switch_statement_p
= in_switch_statement_p
;
20054 parser
->in_statement
= in_statement
;
20055 parser
->in_function_body
= saved_in_function_body
;
20056 parser
->num_template_parameter_lists
20057 = saved_num_template_parameter_lists
;
20058 parser
->in_unbraced_linkage_specification_p
20059 = saved_in_unbraced_linkage_specification_p
;
20065 cp_parser_class_specifier (cp_parser
* parser
)
20068 timevar_push (TV_PARSE_STRUCT
);
20069 ret
= cp_parser_class_specifier_1 (parser
);
20070 timevar_pop (TV_PARSE_STRUCT
);
20074 /* Parse a class-head.
20077 class-key identifier [opt] base-clause [opt]
20078 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
20079 class-key nested-name-specifier [opt] template-id
20082 class-virt-specifier:
20086 class-key attributes identifier [opt] base-clause [opt]
20087 class-key attributes nested-name-specifier identifier base-clause [opt]
20088 class-key attributes nested-name-specifier [opt] template-id
20091 Upon return BASES is initialized to the list of base classes (or
20092 NULL, if there are none) in the same form returned by
20093 cp_parser_base_clause.
20095 Returns the TYPE of the indicated class. Sets
20096 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
20097 involving a nested-name-specifier was used, and FALSE otherwise.
20099 Returns error_mark_node if this is not a class-head.
20101 Returns NULL_TREE if the class-head is syntactically valid, but
20102 semantically invalid in a way that means we should skip the entire
20103 body of the class. */
20106 cp_parser_class_head (cp_parser
* parser
,
20107 bool* nested_name_specifier_p
)
20109 tree nested_name_specifier
;
20110 enum tag_types class_key
;
20111 tree id
= NULL_TREE
;
20112 tree type
= NULL_TREE
;
20115 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
20116 bool template_id_p
= false;
20117 bool qualified_p
= false;
20118 bool invalid_nested_name_p
= false;
20119 bool invalid_explicit_specialization_p
= false;
20120 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
20121 tree pushed_scope
= NULL_TREE
;
20122 unsigned num_templates
;
20123 cp_token
*type_start_token
= NULL
, *nested_name_specifier_token_start
= NULL
;
20124 /* Assume no nested-name-specifier will be present. */
20125 *nested_name_specifier_p
= false;
20126 /* Assume no template parameter lists will be used in defining the
20129 parser
->colon_corrects_to_scope_p
= false;
20131 /* Look for the class-key. */
20132 class_key
= cp_parser_class_key (parser
);
20133 if (class_key
== none_type
)
20134 return error_mark_node
;
20136 /* Parse the attributes. */
20137 attributes
= cp_parser_attributes_opt (parser
);
20139 /* If the next token is `::', that is invalid -- but sometimes
20140 people do try to write:
20144 Handle this gracefully by accepting the extra qualifier, and then
20145 issuing an error about it later if this really is a
20146 class-head. If it turns out just to be an elaborated type
20147 specifier, remain silent. */
20148 if (cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false))
20149 qualified_p
= true;
20151 push_deferring_access_checks (dk_no_check
);
20153 /* Determine the name of the class. Begin by looking for an
20154 optional nested-name-specifier. */
20155 nested_name_specifier_token_start
= cp_lexer_peek_token (parser
->lexer
);
20156 nested_name_specifier
20157 = cp_parser_nested_name_specifier_opt (parser
,
20158 /*typename_keyword_p=*/false,
20159 /*check_dependency_p=*/false,
20161 /*is_declaration=*/false);
20162 /* If there was a nested-name-specifier, then there *must* be an
20164 if (nested_name_specifier
)
20166 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20167 /* Although the grammar says `identifier', it really means
20168 `class-name' or `template-name'. You are only allowed to
20169 define a class that has already been declared with this
20172 The proposed resolution for Core Issue 180 says that wherever
20173 you see `class T::X' you should treat `X' as a type-name.
20175 It is OK to define an inaccessible class; for example:
20177 class A { class B; };
20180 We do not know if we will see a class-name, or a
20181 template-name. We look for a class-name first, in case the
20182 class-name is a template-id; if we looked for the
20183 template-name first we would stop after the template-name. */
20184 cp_parser_parse_tentatively (parser
);
20185 type
= cp_parser_class_name (parser
,
20186 /*typename_keyword_p=*/false,
20187 /*template_keyword_p=*/false,
20189 /*check_dependency_p=*/false,
20190 /*class_head_p=*/true,
20191 /*is_declaration=*/false);
20192 /* If that didn't work, ignore the nested-name-specifier. */
20193 if (!cp_parser_parse_definitely (parser
))
20195 invalid_nested_name_p
= true;
20196 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20197 id
= cp_parser_identifier (parser
);
20198 if (id
== error_mark_node
)
20201 /* If we could not find a corresponding TYPE, treat this
20202 declaration like an unqualified declaration. */
20203 if (type
== error_mark_node
)
20204 nested_name_specifier
= NULL_TREE
;
20205 /* Otherwise, count the number of templates used in TYPE and its
20206 containing scopes. */
20211 for (scope
= TREE_TYPE (type
);
20212 scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
;
20213 scope
= get_containing_scope (scope
))
20215 && CLASS_TYPE_P (scope
)
20216 && CLASSTYPE_TEMPLATE_INFO (scope
)
20217 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope
))
20218 && (!CLASSTYPE_TEMPLATE_SPECIALIZATION (scope
)
20219 || uses_template_parms (CLASSTYPE_TI_ARGS (scope
))))
20223 /* Otherwise, the identifier is optional. */
20226 /* We don't know whether what comes next is a template-id,
20227 an identifier, or nothing at all. */
20228 cp_parser_parse_tentatively (parser
);
20229 /* Check for a template-id. */
20230 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20231 id
= cp_parser_template_id (parser
,
20232 /*template_keyword_p=*/false,
20233 /*check_dependency_p=*/true,
20235 /*is_declaration=*/true);
20236 /* If that didn't work, it could still be an identifier. */
20237 if (!cp_parser_parse_definitely (parser
))
20239 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
20241 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20242 id
= cp_parser_identifier (parser
);
20249 template_id_p
= true;
20254 pop_deferring_access_checks ();
20258 cp_parser_check_for_invalid_template_id (parser
, id
,
20260 type_start_token
->location
);
20262 virt_specifiers
= cp_parser_virt_specifier_seq_opt (parser
);
20264 /* If it's not a `:' or a `{' then we can't really be looking at a
20265 class-head, since a class-head only appears as part of a
20266 class-specifier. We have to detect this situation before calling
20267 xref_tag, since that has irreversible side-effects. */
20268 if (!cp_parser_next_token_starts_class_definition_p (parser
))
20270 cp_parser_error (parser
, "expected %<{%> or %<:%>");
20271 type
= error_mark_node
;
20275 /* At this point, we're going ahead with the class-specifier, even
20276 if some other problem occurs. */
20277 cp_parser_commit_to_tentative_parse (parser
);
20278 if (virt_specifiers
& VIRT_SPEC_OVERRIDE
)
20280 cp_parser_error (parser
,
20281 "cannot specify %<override%> for a class");
20282 type
= error_mark_node
;
20285 /* Issue the error about the overly-qualified name now. */
20288 cp_parser_error (parser
,
20289 "global qualification of class name is invalid");
20290 type
= error_mark_node
;
20293 else if (invalid_nested_name_p
)
20295 cp_parser_error (parser
,
20296 "qualified name does not name a class");
20297 type
= error_mark_node
;
20300 else if (nested_name_specifier
)
20304 /* Reject typedef-names in class heads. */
20305 if (!DECL_IMPLICIT_TYPEDEF_P (type
))
20307 error_at (type_start_token
->location
,
20308 "invalid class name in declaration of %qD",
20314 /* Figure out in what scope the declaration is being placed. */
20315 scope
= current_scope ();
20316 /* If that scope does not contain the scope in which the
20317 class was originally declared, the program is invalid. */
20318 if (scope
&& !is_ancestor (scope
, nested_name_specifier
))
20320 if (at_namespace_scope_p ())
20321 error_at (type_start_token
->location
,
20322 "declaration of %qD in namespace %qD which does not "
20324 type
, scope
, nested_name_specifier
);
20326 error_at (type_start_token
->location
,
20327 "declaration of %qD in %qD which does not enclose %qD",
20328 type
, scope
, nested_name_specifier
);
20334 A declarator-id shall not be qualified except for the
20335 definition of a ... nested class outside of its class
20336 ... [or] the definition or explicit instantiation of a
20337 class member of a namespace outside of its namespace. */
20338 if (scope
== nested_name_specifier
)
20340 permerror (nested_name_specifier_token_start
->location
,
20341 "extra qualification not allowed");
20342 nested_name_specifier
= NULL_TREE
;
20346 /* An explicit-specialization must be preceded by "template <>". If
20347 it is not, try to recover gracefully. */
20348 if (at_namespace_scope_p ()
20349 && parser
->num_template_parameter_lists
== 0
20352 error_at (type_start_token
->location
,
20353 "an explicit specialization must be preceded by %<template <>%>");
20354 invalid_explicit_specialization_p
= true;
20355 /* Take the same action that would have been taken by
20356 cp_parser_explicit_specialization. */
20357 ++parser
->num_template_parameter_lists
;
20358 begin_specialization ();
20360 /* There must be no "return" statements between this point and the
20361 end of this function; set "type "to the correct return value and
20362 use "goto done;" to return. */
20363 /* Make sure that the right number of template parameters were
20365 if (!cp_parser_check_template_parameters (parser
, num_templates
,
20366 type_start_token
->location
,
20367 /*declarator=*/NULL
))
20369 /* If something went wrong, there is no point in even trying to
20370 process the class-definition. */
20375 /* Look up the type. */
20378 if (TREE_CODE (id
) == TEMPLATE_ID_EXPR
20379 && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id
, 0))
20380 || TREE_CODE (TREE_OPERAND (id
, 0)) == OVERLOAD
))
20382 error_at (type_start_token
->location
,
20383 "function template %qD redeclared as a class template", id
);
20384 type
= error_mark_node
;
20388 type
= TREE_TYPE (id
);
20389 type
= maybe_process_partial_specialization (type
);
20391 if (nested_name_specifier
)
20392 pushed_scope
= push_scope (nested_name_specifier
);
20394 else if (nested_name_specifier
)
20400 template <typename T> struct S { struct T };
20401 template <typename T> struct S<T>::T { };
20403 we will get a TYPENAME_TYPE when processing the definition of
20404 `S::T'. We need to resolve it to the actual type before we
20405 try to define it. */
20406 if (TREE_CODE (TREE_TYPE (type
)) == TYPENAME_TYPE
)
20408 class_type
= resolve_typename_type (TREE_TYPE (type
),
20409 /*only_current_p=*/false);
20410 if (TREE_CODE (class_type
) != TYPENAME_TYPE
)
20411 type
= TYPE_NAME (class_type
);
20414 cp_parser_error (parser
, "could not resolve typename type");
20415 type
= error_mark_node
;
20419 if (maybe_process_partial_specialization (TREE_TYPE (type
))
20420 == error_mark_node
)
20426 class_type
= current_class_type
;
20427 /* Enter the scope indicated by the nested-name-specifier. */
20428 pushed_scope
= push_scope (nested_name_specifier
);
20429 /* Get the canonical version of this type. */
20430 type
= TYPE_MAIN_DECL (TREE_TYPE (type
));
20431 /* Call push_template_decl if it seems like we should be defining a
20432 template either from the template headers or the type we're
20433 defining, so that we diagnose both extra and missing headers. */
20434 if ((PROCESSING_REAL_TEMPLATE_DECL_P ()
20435 || CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (type
)))
20436 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type
)))
20438 type
= push_template_decl (type
);
20439 if (type
== error_mark_node
)
20446 type
= TREE_TYPE (type
);
20447 *nested_name_specifier_p
= true;
20449 else /* The name is not a nested name. */
20451 /* If the class was unnamed, create a dummy name. */
20453 id
= make_anon_name ();
20454 type
= xref_tag (class_key
, id
, /*tag_scope=*/ts_current
,
20455 parser
->num_template_parameter_lists
);
20458 /* Indicate whether this class was declared as a `class' or as a
20460 if (TREE_CODE (type
) == RECORD_TYPE
)
20461 CLASSTYPE_DECLARED_CLASS (type
) = (class_key
== class_type
);
20462 cp_parser_check_class_key (class_key
, type
);
20464 /* If this type was already complete, and we see another definition,
20465 that's an error. */
20466 if (type
!= error_mark_node
&& COMPLETE_TYPE_P (type
))
20468 error_at (type_start_token
->location
, "redefinition of %q#T",
20470 error_at (type_start_token
->location
, "previous definition of %q+#T",
20475 else if (type
== error_mark_node
)
20480 /* Apply attributes now, before any use of the class as a template
20481 argument in its base list. */
20482 cplus_decl_attributes (&type
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
20483 fixup_attribute_variants (type
);
20486 /* We will have entered the scope containing the class; the names of
20487 base classes should be looked up in that context. For example:
20489 struct A { struct B {}; struct C; };
20490 struct A::C : B {};
20494 /* Get the list of base-classes, if there is one. */
20495 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
20497 /* PR59482: enter the class scope so that base-specifiers are looked
20501 bases
= cp_parser_base_clause (parser
);
20502 /* PR59482: get out of the previously pushed class scope so that the
20503 subsequent pops pop the right thing. */
20510 /* If we're really defining a class, process the base classes.
20511 If they're invalid, fail. */
20512 if (type
&& cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
)
20513 && !xref_basetypes (type
, bases
))
20517 /* Leave the scope given by the nested-name-specifier. We will
20518 enter the class scope itself while processing the members. */
20520 pop_scope (pushed_scope
);
20522 if (invalid_explicit_specialization_p
)
20524 end_specialization ();
20525 --parser
->num_template_parameter_lists
;
20529 DECL_SOURCE_LOCATION (TYPE_NAME (type
)) = type_start_token
->location
;
20530 if (type
&& (virt_specifiers
& VIRT_SPEC_FINAL
))
20531 CLASSTYPE_FINAL (type
) = 1;
20533 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
20537 /* Parse a class-key.
20544 Returns the kind of class-key specified, or none_type to indicate
20547 static enum tag_types
20548 cp_parser_class_key (cp_parser
* parser
)
20551 enum tag_types tag_type
;
20553 /* Look for the class-key. */
20554 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_CLASS_KEY
);
20558 /* Check to see if the TOKEN is a class-key. */
20559 tag_type
= cp_parser_token_is_class_key (token
);
20561 cp_parser_error (parser
, "expected class-key");
20565 /* Parse a type-parameter-key.
20567 type-parameter-key:
20573 cp_parser_type_parameter_key (cp_parser
* parser
)
20575 /* Look for the type-parameter-key. */
20576 enum tag_types tag_type
= none_type
;
20577 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
20578 if ((tag_type
= cp_parser_token_is_type_parameter_key (token
)) != none_type
)
20580 cp_lexer_consume_token (parser
->lexer
);
20581 if (pedantic
&& tag_type
== typename_type
&& cxx_dialect
< cxx1z
)
20582 /* typename is not allowed in a template template parameter
20583 by the standard until C++1Z. */
20584 pedwarn (token
->location
, OPT_Wpedantic
,
20585 "ISO C++ forbids typename key in template template parameter;"
20586 " use -std=c++1z or -std=gnu++1z");
20589 cp_parser_error (parser
, "expected %<class%> or %<typename%>");
20594 /* Parse an (optional) member-specification.
20596 member-specification:
20597 member-declaration member-specification [opt]
20598 access-specifier : member-specification [opt] */
20601 cp_parser_member_specification_opt (cp_parser
* parser
)
20608 /* Peek at the next token. */
20609 token
= cp_lexer_peek_token (parser
->lexer
);
20610 /* If it's a `}', or EOF then we've seen all the members. */
20611 if (token
->type
== CPP_CLOSE_BRACE
20612 || token
->type
== CPP_EOF
20613 || token
->type
== CPP_PRAGMA_EOL
)
20616 /* See if this token is a keyword. */
20617 keyword
= token
->keyword
;
20621 case RID_PROTECTED
:
20623 /* Consume the access-specifier. */
20624 cp_lexer_consume_token (parser
->lexer
);
20625 /* Remember which access-specifier is active. */
20626 current_access_specifier
= token
->u
.value
;
20627 /* Look for the `:'. */
20628 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
20632 /* Accept #pragmas at class scope. */
20633 if (token
->type
== CPP_PRAGMA
)
20635 cp_parser_pragma (parser
, pragma_member
);
20639 /* Otherwise, the next construction must be a
20640 member-declaration. */
20641 cp_parser_member_declaration (parser
);
20646 /* Parse a member-declaration.
20648 member-declaration:
20649 decl-specifier-seq [opt] member-declarator-list [opt] ;
20650 function-definition ; [opt]
20651 :: [opt] nested-name-specifier template [opt] unqualified-id ;
20653 template-declaration
20656 member-declarator-list:
20658 member-declarator-list , member-declarator
20661 declarator pure-specifier [opt]
20662 declarator constant-initializer [opt]
20663 identifier [opt] : constant-expression
20667 member-declaration:
20668 __extension__ member-declaration
20671 declarator attributes [opt] pure-specifier [opt]
20672 declarator attributes [opt] constant-initializer [opt]
20673 identifier [opt] attributes [opt] : constant-expression
20677 member-declaration:
20678 static_assert-declaration */
20681 cp_parser_member_declaration (cp_parser
* parser
)
20683 cp_decl_specifier_seq decl_specifiers
;
20684 tree prefix_attributes
;
20686 int declares_class_or_enum
;
20688 cp_token
*token
= NULL
;
20689 cp_token
*decl_spec_token_start
= NULL
;
20690 cp_token
*initializer_token_start
= NULL
;
20691 int saved_pedantic
;
20692 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
20694 /* Check for the `__extension__' keyword. */
20695 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
20698 cp_parser_member_declaration (parser
);
20699 /* Restore the old value of the PEDANTIC flag. */
20700 pedantic
= saved_pedantic
;
20705 /* Check for a template-declaration. */
20706 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
20708 /* An explicit specialization here is an error condition, and we
20709 expect the specialization handler to detect and report this. */
20710 if (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_LESS
20711 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_GREATER
)
20712 cp_parser_explicit_specialization (parser
);
20714 cp_parser_template_declaration (parser
, /*member_p=*/true);
20719 /* Check for a using-declaration. */
20720 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_USING
))
20722 if (cxx_dialect
< cxx11
)
20724 /* Parse the using-declaration. */
20725 cp_parser_using_declaration (parser
,
20726 /*access_declaration_p=*/false);
20732 bool alias_decl_expected
;
20733 cp_parser_parse_tentatively (parser
);
20734 decl
= cp_parser_alias_declaration (parser
);
20735 /* Note that if we actually see the '=' token after the
20736 identifier, cp_parser_alias_declaration commits the
20737 tentative parse. In that case, we really expects an
20738 alias-declaration. Otherwise, we expect a using
20740 alias_decl_expected
=
20741 !cp_parser_uncommitted_to_tentative_parse_p (parser
);
20742 cp_parser_parse_definitely (parser
);
20744 if (alias_decl_expected
)
20745 finish_member_declaration (decl
);
20747 cp_parser_using_declaration (parser
,
20748 /*access_declaration_p=*/false);
20753 /* Check for @defs. */
20754 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_DEFS
))
20757 tree ivar_chains
= cp_parser_objc_defs_expression (parser
);
20758 ivar
= ivar_chains
;
20762 ivar
= TREE_CHAIN (member
);
20763 TREE_CHAIN (member
) = NULL_TREE
;
20764 finish_member_declaration (member
);
20769 /* If the next token is `static_assert' we have a static assertion. */
20770 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC_ASSERT
))
20772 cp_parser_static_assert (parser
, /*member_p=*/true);
20776 parser
->colon_corrects_to_scope_p
= false;
20778 if (cp_parser_using_declaration (parser
, /*access_declaration=*/true))
20781 /* Parse the decl-specifier-seq. */
20782 decl_spec_token_start
= cp_lexer_peek_token (parser
->lexer
);
20783 cp_parser_decl_specifier_seq (parser
,
20784 CP_PARSER_FLAGS_OPTIONAL
,
20786 &declares_class_or_enum
);
20787 /* Check for an invalid type-name. */
20788 if (!decl_specifiers
.any_type_specifiers_p
20789 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
20791 /* If there is no declarator, then the decl-specifier-seq should
20793 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
20795 /* If there was no decl-specifier-seq, and the next token is a
20796 `;', then we have something like:
20802 Each member-declaration shall declare at least one member
20803 name of the class. */
20804 if (!decl_specifiers
.any_specifiers_p
)
20806 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
20807 if (!in_system_header_at (token
->location
))
20808 pedwarn (token
->location
, OPT_Wpedantic
, "extra %<;%>");
20814 /* See if this declaration is a friend. */
20815 friend_p
= cp_parser_friend_p (&decl_specifiers
);
20816 /* If there were decl-specifiers, check to see if there was
20817 a class-declaration. */
20818 type
= check_tag_decl (&decl_specifiers
,
20819 /*explicit_type_instantiation_p=*/false);
20820 /* Nested classes have already been added to the class, but
20821 a `friend' needs to be explicitly registered. */
20824 /* If the `friend' keyword was present, the friend must
20825 be introduced with a class-key. */
20826 if (!declares_class_or_enum
&& cxx_dialect
< cxx11
)
20827 pedwarn (decl_spec_token_start
->location
, OPT_Wpedantic
,
20828 "in C++03 a class-key must be used "
20829 "when declaring a friend");
20832 template <typename T> struct A {
20833 friend struct A<T>::B;
20836 A<T>::B will be represented by a TYPENAME_TYPE, and
20837 therefore not recognized by check_tag_decl. */
20840 type
= decl_specifiers
.type
;
20841 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
20842 type
= TREE_TYPE (type
);
20844 if (!type
|| !TYPE_P (type
))
20845 error_at (decl_spec_token_start
->location
,
20846 "friend declaration does not name a class or "
20849 make_friend_class (current_class_type
, type
,
20850 /*complain=*/true);
20852 /* If there is no TYPE, an error message will already have
20854 else if (!type
|| type
== error_mark_node
)
20856 /* An anonymous aggregate has to be handled specially; such
20857 a declaration really declares a data member (with a
20858 particular type), as opposed to a nested class. */
20859 else if (ANON_AGGR_TYPE_P (type
))
20862 if (decl_specifiers
.storage_class
!= sc_none
)
20863 error_at (decl_spec_token_start
->location
,
20864 "a storage class on an anonymous aggregate "
20865 "in class scope is not allowed");
20867 /* Remove constructors and such from TYPE, now that we
20868 know it is an anonymous aggregate. */
20869 fixup_anonymous_aggr (type
);
20870 /* And make the corresponding data member. */
20871 decl
= build_decl (decl_spec_token_start
->location
,
20872 FIELD_DECL
, NULL_TREE
, type
);
20873 /* Add it to the class. */
20874 finish_member_declaration (decl
);
20877 cp_parser_check_access_in_redeclaration
20879 decl_spec_token_start
->location
);
20884 bool assume_semicolon
= false;
20886 /* Clear attributes from the decl_specifiers but keep them
20887 around as prefix attributes that apply them to the entity
20889 prefix_attributes
= decl_specifiers
.attributes
;
20890 decl_specifiers
.attributes
= NULL_TREE
;
20892 /* See if these declarations will be friends. */
20893 friend_p
= cp_parser_friend_p (&decl_specifiers
);
20895 /* Keep going until we hit the `;' at the end of the
20897 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
20899 tree attributes
= NULL_TREE
;
20900 tree first_attribute
;
20902 /* Peek at the next token. */
20903 token
= cp_lexer_peek_token (parser
->lexer
);
20905 /* Check for a bitfield declaration. */
20906 if (token
->type
== CPP_COLON
20907 || (token
->type
== CPP_NAME
20908 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
20914 /* Get the name of the bitfield. Note that we cannot just
20915 check TOKEN here because it may have been invalidated by
20916 the call to cp_lexer_peek_nth_token above. */
20917 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_COLON
)
20918 identifier
= cp_parser_identifier (parser
);
20920 identifier
= NULL_TREE
;
20922 /* Consume the `:' token. */
20923 cp_lexer_consume_token (parser
->lexer
);
20924 /* Get the width of the bitfield. */
20926 = cp_parser_constant_expression (parser
);
20928 /* Look for attributes that apply to the bitfield. */
20929 attributes
= cp_parser_attributes_opt (parser
);
20930 /* Remember which attributes are prefix attributes and
20932 first_attribute
= attributes
;
20933 /* Combine the attributes. */
20934 attributes
= chainon (prefix_attributes
, attributes
);
20936 /* Create the bitfield declaration. */
20937 decl
= grokbitfield (identifier
20938 ? make_id_declarator (NULL_TREE
,
20948 cp_declarator
*declarator
;
20950 tree asm_specification
;
20951 int ctor_dtor_or_conv_p
;
20953 /* Parse the declarator. */
20955 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
20956 &ctor_dtor_or_conv_p
,
20957 /*parenthesized_p=*/NULL
,
20961 /* If something went wrong parsing the declarator, make sure
20962 that we at least consume some tokens. */
20963 if (declarator
== cp_error_declarator
)
20965 /* Skip to the end of the statement. */
20966 cp_parser_skip_to_end_of_statement (parser
);
20967 /* If the next token is not a semicolon, that is
20968 probably because we just skipped over the body of
20969 a function. So, we consume a semicolon if
20970 present, but do not issue an error message if it
20972 if (cp_lexer_next_token_is (parser
->lexer
,
20974 cp_lexer_consume_token (parser
->lexer
);
20978 if (declares_class_or_enum
& 2)
20979 cp_parser_check_for_definition_in_return_type
20980 (declarator
, decl_specifiers
.type
,
20981 decl_specifiers
.locations
[ds_type_spec
]);
20983 /* Look for an asm-specification. */
20984 asm_specification
= cp_parser_asm_specification_opt (parser
);
20985 /* Look for attributes that apply to the declaration. */
20986 attributes
= cp_parser_attributes_opt (parser
);
20987 /* Remember which attributes are prefix attributes and
20989 first_attribute
= attributes
;
20990 /* Combine the attributes. */
20991 attributes
= chainon (prefix_attributes
, attributes
);
20993 /* If it's an `=', then we have a constant-initializer or a
20994 pure-specifier. It is not correct to parse the
20995 initializer before registering the member declaration
20996 since the member declaration should be in scope while
20997 its initializer is processed. However, the rest of the
20998 front end does not yet provide an interface that allows
20999 us to handle this correctly. */
21000 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
21004 A pure-specifier shall be used only in the declaration of
21005 a virtual function.
21007 A member-declarator can contain a constant-initializer
21008 only if it declares a static member of integral or
21011 Therefore, if the DECLARATOR is for a function, we look
21012 for a pure-specifier; otherwise, we look for a
21013 constant-initializer. When we call `grokfield', it will
21014 perform more stringent semantics checks. */
21015 initializer_token_start
= cp_lexer_peek_token (parser
->lexer
);
21016 if (function_declarator_p (declarator
)
21017 || (decl_specifiers
.type
21018 && TREE_CODE (decl_specifiers
.type
) == TYPE_DECL
21019 && declarator
->kind
== cdk_id
21020 && (TREE_CODE (TREE_TYPE (decl_specifiers
.type
))
21021 == FUNCTION_TYPE
)))
21022 initializer
= cp_parser_pure_specifier (parser
);
21023 else if (decl_specifiers
.storage_class
!= sc_static
)
21024 initializer
= cp_parser_save_nsdmi (parser
);
21025 else if (cxx_dialect
>= cxx11
)
21028 /* Don't require a constant rvalue in C++11, since we
21029 might want a reference constant. We'll enforce
21030 constancy later. */
21031 cp_lexer_consume_token (parser
->lexer
);
21032 /* Parse the initializer. */
21033 initializer
= cp_parser_initializer_clause (parser
,
21037 /* Parse the initializer. */
21038 initializer
= cp_parser_constant_initializer (parser
);
21040 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
)
21041 && !function_declarator_p (declarator
))
21044 if (decl_specifiers
.storage_class
!= sc_static
)
21045 initializer
= cp_parser_save_nsdmi (parser
);
21047 initializer
= cp_parser_initializer (parser
, &x
, &x
);
21049 /* Otherwise, there is no initializer. */
21051 initializer
= NULL_TREE
;
21053 /* See if we are probably looking at a function
21054 definition. We are certainly not looking at a
21055 member-declarator. Calling `grokfield' has
21056 side-effects, so we must not do it unless we are sure
21057 that we are looking at a member-declarator. */
21058 if (cp_parser_token_starts_function_definition_p
21059 (cp_lexer_peek_token (parser
->lexer
)))
21061 /* The grammar does not allow a pure-specifier to be
21062 used when a member function is defined. (It is
21063 possible that this fact is an oversight in the
21064 standard, since a pure function may be defined
21065 outside of the class-specifier. */
21066 if (initializer
&& initializer_token_start
)
21067 error_at (initializer_token_start
->location
,
21068 "pure-specifier on function-definition");
21069 decl
= cp_parser_save_member_function_body (parser
,
21073 if (parser
->fully_implicit_function_template_p
)
21074 decl
= finish_fully_implicit_template (parser
, decl
);
21075 /* If the member was not a friend, declare it here. */
21077 finish_member_declaration (decl
);
21078 /* Peek at the next token. */
21079 token
= cp_lexer_peek_token (parser
->lexer
);
21080 /* If the next token is a semicolon, consume it. */
21081 if (token
->type
== CPP_SEMICOLON
)
21082 cp_lexer_consume_token (parser
->lexer
);
21086 if (declarator
->kind
== cdk_function
)
21087 declarator
->id_loc
= token
->location
;
21088 /* Create the declaration. */
21089 decl
= grokfield (declarator
, &decl_specifiers
,
21090 initializer
, /*init_const_expr_p=*/true,
21091 asm_specification
, attributes
);
21092 if (parser
->fully_implicit_function_template_p
)
21095 finish_fully_implicit_template (parser
, 0);
21097 decl
= finish_fully_implicit_template (parser
, decl
);
21101 cp_finalize_omp_declare_simd (parser
, decl
);
21103 /* Reset PREFIX_ATTRIBUTES. */
21104 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
21105 attributes
= TREE_CHAIN (attributes
);
21107 TREE_CHAIN (attributes
) = NULL_TREE
;
21109 /* If there is any qualification still in effect, clear it
21110 now; we will be starting fresh with the next declarator. */
21111 parser
->scope
= NULL_TREE
;
21112 parser
->qualifying_scope
= NULL_TREE
;
21113 parser
->object_scope
= NULL_TREE
;
21114 /* If it's a `,', then there are more declarators. */
21115 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
21117 cp_lexer_consume_token (parser
->lexer
);
21118 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
21120 cp_token
*token
= cp_lexer_previous_token (parser
->lexer
);
21121 error_at (token
->location
,
21122 "stray %<,%> at end of member declaration");
21125 /* If the next token isn't a `;', then we have a parse error. */
21126 else if (cp_lexer_next_token_is_not (parser
->lexer
,
21129 /* The next token might be a ways away from where the
21130 actual semicolon is missing. Find the previous token
21131 and use that for our error position. */
21132 cp_token
*token
= cp_lexer_previous_token (parser
->lexer
);
21133 error_at (token
->location
,
21134 "expected %<;%> at end of member declaration");
21136 /* Assume that the user meant to provide a semicolon. If
21137 we were to cp_parser_skip_to_end_of_statement, we might
21138 skip to a semicolon inside a member function definition
21139 and issue nonsensical error messages. */
21140 assume_semicolon
= true;
21145 /* Add DECL to the list of members. */
21147 /* Explicitly include, eg, NSDMIs, for better error
21148 recovery (c++/58650). */
21149 || !DECL_DECLARES_FUNCTION_P (decl
))
21150 finish_member_declaration (decl
);
21152 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21153 cp_parser_save_default_args (parser
, decl
);
21154 else if (TREE_CODE (decl
) == FIELD_DECL
21155 && !DECL_C_BIT_FIELD (decl
)
21156 && DECL_INITIAL (decl
))
21157 /* Add DECL to the queue of NSDMI to be parsed later. */
21158 vec_safe_push (unparsed_nsdmis
, decl
);
21161 if (assume_semicolon
)
21166 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
21168 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
21171 /* Parse a pure-specifier.
21176 Returns INTEGER_ZERO_NODE if a pure specifier is found.
21177 Otherwise, ERROR_MARK_NODE is returned. */
21180 cp_parser_pure_specifier (cp_parser
* parser
)
21184 /* Look for the `=' token. */
21185 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
21186 return error_mark_node
;
21187 /* Look for the `0' token. */
21188 token
= cp_lexer_peek_token (parser
->lexer
);
21190 if (token
->type
== CPP_EOF
21191 || token
->type
== CPP_PRAGMA_EOL
)
21192 return error_mark_node
;
21194 cp_lexer_consume_token (parser
->lexer
);
21196 /* Accept = default or = delete in c++0x mode. */
21197 if (token
->keyword
== RID_DEFAULT
21198 || token
->keyword
== RID_DELETE
)
21200 maybe_warn_cpp0x (CPP0X_DEFAULTED_DELETED
);
21201 return token
->u
.value
;
21204 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
21205 if (token
->type
!= CPP_NUMBER
|| !(token
->flags
& PURE_ZERO
))
21207 cp_parser_error (parser
,
21208 "invalid pure specifier (only %<= 0%> is allowed)");
21209 cp_parser_skip_to_end_of_statement (parser
);
21210 return error_mark_node
;
21212 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
21214 error_at (token
->location
, "templates may not be %<virtual%>");
21215 return error_mark_node
;
21218 return integer_zero_node
;
21221 /* Parse a constant-initializer.
21223 constant-initializer:
21224 = constant-expression
21226 Returns a representation of the constant-expression. */
21229 cp_parser_constant_initializer (cp_parser
* parser
)
21231 /* Look for the `=' token. */
21232 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
21233 return error_mark_node
;
21235 /* It is invalid to write:
21237 struct S { static const int i = { 7 }; };
21240 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
21242 cp_parser_error (parser
,
21243 "a brace-enclosed initializer is not allowed here");
21244 /* Consume the opening brace. */
21245 cp_lexer_consume_token (parser
->lexer
);
21246 /* Skip the initializer. */
21247 cp_parser_skip_to_closing_brace (parser
);
21248 /* Look for the trailing `}'. */
21249 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
21251 return error_mark_node
;
21254 return cp_parser_constant_expression (parser
);
21257 /* Derived classes [gram.class.derived] */
21259 /* Parse a base-clause.
21262 : base-specifier-list
21264 base-specifier-list:
21265 base-specifier ... [opt]
21266 base-specifier-list , base-specifier ... [opt]
21268 Returns a TREE_LIST representing the base-classes, in the order in
21269 which they were declared. The representation of each node is as
21270 described by cp_parser_base_specifier.
21272 In the case that no bases are specified, this function will return
21273 NULL_TREE, not ERROR_MARK_NODE. */
21276 cp_parser_base_clause (cp_parser
* parser
)
21278 tree bases
= NULL_TREE
;
21280 /* Look for the `:' that begins the list. */
21281 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
21283 /* Scan the base-specifier-list. */
21288 bool pack_expansion_p
= false;
21290 /* Look for the base-specifier. */
21291 base
= cp_parser_base_specifier (parser
);
21292 /* Look for the (optional) ellipsis. */
21293 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
21295 /* Consume the `...'. */
21296 cp_lexer_consume_token (parser
->lexer
);
21298 pack_expansion_p
= true;
21301 /* Add BASE to the front of the list. */
21302 if (base
&& base
!= error_mark_node
)
21304 if (pack_expansion_p
)
21305 /* Make this a pack expansion type. */
21306 TREE_VALUE (base
) = make_pack_expansion (TREE_VALUE (base
));
21308 if (!check_for_bare_parameter_packs (TREE_VALUE (base
)))
21310 TREE_CHAIN (base
) = bases
;
21314 /* Peek at the next token. */
21315 token
= cp_lexer_peek_token (parser
->lexer
);
21316 /* If it's not a comma, then the list is complete. */
21317 if (token
->type
!= CPP_COMMA
)
21319 /* Consume the `,'. */
21320 cp_lexer_consume_token (parser
->lexer
);
21323 /* PARSER->SCOPE may still be non-NULL at this point, if the last
21324 base class had a qualified name. However, the next name that
21325 appears is certainly not qualified. */
21326 parser
->scope
= NULL_TREE
;
21327 parser
->qualifying_scope
= NULL_TREE
;
21328 parser
->object_scope
= NULL_TREE
;
21330 return nreverse (bases
);
21333 /* Parse a base-specifier.
21336 :: [opt] nested-name-specifier [opt] class-name
21337 virtual access-specifier [opt] :: [opt] nested-name-specifier
21339 access-specifier virtual [opt] :: [opt] nested-name-specifier
21342 Returns a TREE_LIST. The TREE_PURPOSE will be one of
21343 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
21344 indicate the specifiers provided. The TREE_VALUE will be a TYPE
21345 (or the ERROR_MARK_NODE) indicating the type that was specified. */
21348 cp_parser_base_specifier (cp_parser
* parser
)
21352 bool virtual_p
= false;
21353 bool duplicate_virtual_error_issued_p
= false;
21354 bool duplicate_access_error_issued_p
= false;
21355 bool class_scope_p
, template_p
;
21356 tree access
= access_default_node
;
21359 /* Process the optional `virtual' and `access-specifier'. */
21362 /* Peek at the next token. */
21363 token
= cp_lexer_peek_token (parser
->lexer
);
21364 /* Process `virtual'. */
21365 switch (token
->keyword
)
21368 /* If `virtual' appears more than once, issue an error. */
21369 if (virtual_p
&& !duplicate_virtual_error_issued_p
)
21371 cp_parser_error (parser
,
21372 "%<virtual%> specified more than once in base-specified");
21373 duplicate_virtual_error_issued_p
= true;
21378 /* Consume the `virtual' token. */
21379 cp_lexer_consume_token (parser
->lexer
);
21384 case RID_PROTECTED
:
21386 /* If more than one access specifier appears, issue an
21388 if (access
!= access_default_node
21389 && !duplicate_access_error_issued_p
)
21391 cp_parser_error (parser
,
21392 "more than one access specifier in base-specified");
21393 duplicate_access_error_issued_p
= true;
21396 access
= ridpointers
[(int) token
->keyword
];
21398 /* Consume the access-specifier. */
21399 cp_lexer_consume_token (parser
->lexer
);
21408 /* It is not uncommon to see programs mechanically, erroneously, use
21409 the 'typename' keyword to denote (dependent) qualified types
21410 as base classes. */
21411 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TYPENAME
))
21413 token
= cp_lexer_peek_token (parser
->lexer
);
21414 if (!processing_template_decl
)
21415 error_at (token
->location
,
21416 "keyword %<typename%> not allowed outside of templates");
21418 error_at (token
->location
,
21419 "keyword %<typename%> not allowed in this context "
21420 "(the base class is implicitly a type)");
21421 cp_lexer_consume_token (parser
->lexer
);
21424 /* Look for the optional `::' operator. */
21425 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false);
21426 /* Look for the nested-name-specifier. The simplest way to
21431 The keyword `typename' is not permitted in a base-specifier or
21432 mem-initializer; in these contexts a qualified name that
21433 depends on a template-parameter is implicitly assumed to be a
21436 is to pretend that we have seen the `typename' keyword at this
21438 cp_parser_nested_name_specifier_opt (parser
,
21439 /*typename_keyword_p=*/true,
21440 /*check_dependency_p=*/true,
21442 /*is_declaration=*/true);
21443 /* If the base class is given by a qualified name, assume that names
21444 we see are type names or templates, as appropriate. */
21445 class_scope_p
= (parser
->scope
&& TYPE_P (parser
->scope
));
21446 template_p
= class_scope_p
&& cp_parser_optional_template_keyword (parser
);
21449 && cp_lexer_next_token_is_decltype (parser
->lexer
))
21450 /* DR 950 allows decltype as a base-specifier. */
21451 type
= cp_parser_decltype (parser
);
21454 /* Otherwise, look for the class-name. */
21455 type
= cp_parser_class_name (parser
,
21459 /*check_dependency_p=*/true,
21460 /*class_head_p=*/false,
21461 /*is_declaration=*/true);
21462 type
= TREE_TYPE (type
);
21465 if (type
== error_mark_node
)
21466 return error_mark_node
;
21468 return finish_base_specifier (type
, access
, virtual_p
);
21471 /* Exception handling [gram.exception] */
21473 /* Parse an (optional) noexcept-specification.
21475 noexcept-specification:
21476 noexcept ( constant-expression ) [opt]
21478 If no noexcept-specification is present, returns NULL_TREE.
21479 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
21480 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
21481 there are no parentheses. CONSUMED_EXPR will be set accordingly.
21482 Otherwise, returns a noexcept specification unless RETURN_COND is true,
21483 in which case a boolean condition is returned instead. */
21486 cp_parser_noexcept_specification_opt (cp_parser
* parser
,
21487 bool require_constexpr
,
21488 bool* consumed_expr
,
21492 const char *saved_message
;
21494 /* Peek at the next token. */
21495 token
= cp_lexer_peek_token (parser
->lexer
);
21497 /* Is it a noexcept-specification? */
21498 if (cp_parser_is_keyword (token
, RID_NOEXCEPT
))
21501 cp_lexer_consume_token (parser
->lexer
);
21503 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
21505 cp_lexer_consume_token (parser
->lexer
);
21507 if (require_constexpr
)
21509 /* Types may not be defined in an exception-specification. */
21510 saved_message
= parser
->type_definition_forbidden_message
;
21511 parser
->type_definition_forbidden_message
21512 = G_("types may not be defined in an exception-specification");
21514 expr
= cp_parser_constant_expression (parser
);
21516 /* Restore the saved message. */
21517 parser
->type_definition_forbidden_message
= saved_message
;
21521 expr
= cp_parser_expression (parser
);
21522 *consumed_expr
= true;
21525 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21529 expr
= boolean_true_node
;
21530 if (!require_constexpr
)
21531 *consumed_expr
= false;
21534 /* We cannot build a noexcept-spec right away because this will check
21535 that expr is a constexpr. */
21537 return build_noexcept_spec (expr
, tf_warning_or_error
);
21545 /* Parse an (optional) exception-specification.
21547 exception-specification:
21548 throw ( type-id-list [opt] )
21550 Returns a TREE_LIST representing the exception-specification. The
21551 TREE_VALUE of each node is a type. */
21554 cp_parser_exception_specification_opt (cp_parser
* parser
)
21558 const char *saved_message
;
21560 /* Peek at the next token. */
21561 token
= cp_lexer_peek_token (parser
->lexer
);
21563 /* Is it a noexcept-specification? */
21564 type_id_list
= cp_parser_noexcept_specification_opt(parser
, true, NULL
,
21566 if (type_id_list
!= NULL_TREE
)
21567 return type_id_list
;
21569 /* If it's not `throw', then there's no exception-specification. */
21570 if (!cp_parser_is_keyword (token
, RID_THROW
))
21574 /* Enable this once a lot of code has transitioned to noexcept? */
21575 if (cxx_dialect
>= cxx11
&& !in_system_header_at (input_location
))
21576 warning (OPT_Wdeprecated
, "dynamic exception specifications are "
21577 "deprecated in C++0x; use %<noexcept%> instead");
21580 /* Consume the `throw'. */
21581 cp_lexer_consume_token (parser
->lexer
);
21583 /* Look for the `('. */
21584 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21586 /* Peek at the next token. */
21587 token
= cp_lexer_peek_token (parser
->lexer
);
21588 /* If it's not a `)', then there is a type-id-list. */
21589 if (token
->type
!= CPP_CLOSE_PAREN
)
21591 /* Types may not be defined in an exception-specification. */
21592 saved_message
= parser
->type_definition_forbidden_message
;
21593 parser
->type_definition_forbidden_message
21594 = G_("types may not be defined in an exception-specification");
21595 /* Parse the type-id-list. */
21596 type_id_list
= cp_parser_type_id_list (parser
);
21597 /* Restore the saved message. */
21598 parser
->type_definition_forbidden_message
= saved_message
;
21601 type_id_list
= empty_except_spec
;
21603 /* Look for the `)'. */
21604 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21606 return type_id_list
;
21609 /* Parse an (optional) type-id-list.
21613 type-id-list , type-id ... [opt]
21615 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
21616 in the order that the types were presented. */
21619 cp_parser_type_id_list (cp_parser
* parser
)
21621 tree types
= NULL_TREE
;
21628 /* Get the next type-id. */
21629 type
= cp_parser_type_id (parser
);
21630 /* Parse the optional ellipsis. */
21631 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
21633 /* Consume the `...'. */
21634 cp_lexer_consume_token (parser
->lexer
);
21636 /* Turn the type into a pack expansion expression. */
21637 type
= make_pack_expansion (type
);
21639 /* Add it to the list. */
21640 types
= add_exception_specifier (types
, type
, /*complain=*/1);
21641 /* Peek at the next token. */
21642 token
= cp_lexer_peek_token (parser
->lexer
);
21643 /* If it is not a `,', we are done. */
21644 if (token
->type
!= CPP_COMMA
)
21646 /* Consume the `,'. */
21647 cp_lexer_consume_token (parser
->lexer
);
21650 return nreverse (types
);
21653 /* Parse a try-block.
21656 try compound-statement handler-seq */
21659 cp_parser_try_block (cp_parser
* parser
)
21663 cp_parser_require_keyword (parser
, RID_TRY
, RT_TRY
);
21664 if (parser
->in_function_body
21665 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
21666 error ("%<try%> in %<constexpr%> function");
21668 try_block
= begin_try_block ();
21669 cp_parser_compound_statement (parser
, NULL
, true, false);
21670 finish_try_block (try_block
);
21671 cp_parser_handler_seq (parser
);
21672 finish_handler_sequence (try_block
);
21677 /* Parse a function-try-block.
21679 function-try-block:
21680 try ctor-initializer [opt] function-body handler-seq */
21683 cp_parser_function_try_block (cp_parser
* parser
)
21685 tree compound_stmt
;
21687 bool ctor_initializer_p
;
21689 /* Look for the `try' keyword. */
21690 if (!cp_parser_require_keyword (parser
, RID_TRY
, RT_TRY
))
21692 /* Let the rest of the front end know where we are. */
21693 try_block
= begin_function_try_block (&compound_stmt
);
21694 /* Parse the function-body. */
21695 ctor_initializer_p
= cp_parser_ctor_initializer_opt_and_function_body
21696 (parser
, /*in_function_try_block=*/true);
21697 /* We're done with the `try' part. */
21698 finish_function_try_block (try_block
);
21699 /* Parse the handlers. */
21700 cp_parser_handler_seq (parser
);
21701 /* We're done with the handlers. */
21702 finish_function_handler_sequence (try_block
, compound_stmt
);
21704 return ctor_initializer_p
;
21707 /* Parse a handler-seq.
21710 handler handler-seq [opt] */
21713 cp_parser_handler_seq (cp_parser
* parser
)
21719 /* Parse the handler. */
21720 cp_parser_handler (parser
);
21721 /* Peek at the next token. */
21722 token
= cp_lexer_peek_token (parser
->lexer
);
21723 /* If it's not `catch' then there are no more handlers. */
21724 if (!cp_parser_is_keyword (token
, RID_CATCH
))
21729 /* Parse a handler.
21732 catch ( exception-declaration ) compound-statement */
21735 cp_parser_handler (cp_parser
* parser
)
21740 cp_parser_require_keyword (parser
, RID_CATCH
, RT_CATCH
);
21741 handler
= begin_handler ();
21742 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21743 declaration
= cp_parser_exception_declaration (parser
);
21744 finish_handler_parms (declaration
, handler
);
21745 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21746 cp_parser_compound_statement (parser
, NULL
, false, false);
21747 finish_handler (handler
);
21750 /* Parse an exception-declaration.
21752 exception-declaration:
21753 type-specifier-seq declarator
21754 type-specifier-seq abstract-declarator
21758 Returns a VAR_DECL for the declaration, or NULL_TREE if the
21759 ellipsis variant is used. */
21762 cp_parser_exception_declaration (cp_parser
* parser
)
21764 cp_decl_specifier_seq type_specifiers
;
21765 cp_declarator
*declarator
;
21766 const char *saved_message
;
21768 /* If it's an ellipsis, it's easy to handle. */
21769 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
21771 /* Consume the `...' token. */
21772 cp_lexer_consume_token (parser
->lexer
);
21776 /* Types may not be defined in exception-declarations. */
21777 saved_message
= parser
->type_definition_forbidden_message
;
21778 parser
->type_definition_forbidden_message
21779 = G_("types may not be defined in exception-declarations");
21781 /* Parse the type-specifier-seq. */
21782 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/true,
21783 /*is_trailing_return=*/false,
21785 /* If it's a `)', then there is no declarator. */
21786 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
21789 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_EITHER
,
21790 /*ctor_dtor_or_conv_p=*/NULL
,
21791 /*parenthesized_p=*/NULL
,
21792 /*member_p=*/false,
21793 /*friend_p=*/false);
21795 /* Restore the saved message. */
21796 parser
->type_definition_forbidden_message
= saved_message
;
21798 if (!type_specifiers
.any_specifiers_p
)
21799 return error_mark_node
;
21801 return grokdeclarator (declarator
, &type_specifiers
, CATCHPARM
, 1, NULL
);
21804 /* Parse a throw-expression.
21807 throw assignment-expression [opt]
21809 Returns a THROW_EXPR representing the throw-expression. */
21812 cp_parser_throw_expression (cp_parser
* parser
)
21817 cp_parser_require_keyword (parser
, RID_THROW
, RT_THROW
);
21818 token
= cp_lexer_peek_token (parser
->lexer
);
21819 /* Figure out whether or not there is an assignment-expression
21820 following the "throw" keyword. */
21821 if (token
->type
== CPP_COMMA
21822 || token
->type
== CPP_SEMICOLON
21823 || token
->type
== CPP_CLOSE_PAREN
21824 || token
->type
== CPP_CLOSE_SQUARE
21825 || token
->type
== CPP_CLOSE_BRACE
21826 || token
->type
== CPP_COLON
)
21827 expression
= NULL_TREE
;
21829 expression
= cp_parser_assignment_expression (parser
);
21831 return build_throw (expression
);
21834 /* GNU Extensions */
21836 /* Parse an (optional) asm-specification.
21839 asm ( string-literal )
21841 If the asm-specification is present, returns a STRING_CST
21842 corresponding to the string-literal. Otherwise, returns
21846 cp_parser_asm_specification_opt (cp_parser
* parser
)
21849 tree asm_specification
;
21851 /* Peek at the next token. */
21852 token
= cp_lexer_peek_token (parser
->lexer
);
21853 /* If the next token isn't the `asm' keyword, then there's no
21854 asm-specification. */
21855 if (!cp_parser_is_keyword (token
, RID_ASM
))
21858 /* Consume the `asm' token. */
21859 cp_lexer_consume_token (parser
->lexer
);
21860 /* Look for the `('. */
21861 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21863 /* Look for the string-literal. */
21864 asm_specification
= cp_parser_string_literal (parser
, false, false);
21866 /* Look for the `)'. */
21867 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21869 return asm_specification
;
21872 /* Parse an asm-operand-list.
21876 asm-operand-list , asm-operand
21879 string-literal ( expression )
21880 [ string-literal ] string-literal ( expression )
21882 Returns a TREE_LIST representing the operands. The TREE_VALUE of
21883 each node is the expression. The TREE_PURPOSE is itself a
21884 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
21885 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
21886 is a STRING_CST for the string literal before the parenthesis. Returns
21887 ERROR_MARK_NODE if any of the operands are invalid. */
21890 cp_parser_asm_operand_list (cp_parser
* parser
)
21892 tree asm_operands
= NULL_TREE
;
21893 bool invalid_operands
= false;
21897 tree string_literal
;
21901 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
21903 /* Consume the `[' token. */
21904 cp_lexer_consume_token (parser
->lexer
);
21905 /* Read the operand name. */
21906 name
= cp_parser_identifier (parser
);
21907 if (name
!= error_mark_node
)
21908 name
= build_string (IDENTIFIER_LENGTH (name
),
21909 IDENTIFIER_POINTER (name
));
21910 /* Look for the closing `]'. */
21911 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
21915 /* Look for the string-literal. */
21916 string_literal
= cp_parser_string_literal (parser
, false, false);
21918 /* Look for the `('. */
21919 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21920 /* Parse the expression. */
21921 expression
= cp_parser_expression (parser
);
21922 /* Look for the `)'. */
21923 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21925 if (name
== error_mark_node
21926 || string_literal
== error_mark_node
21927 || expression
== error_mark_node
)
21928 invalid_operands
= true;
21930 /* Add this operand to the list. */
21931 asm_operands
= tree_cons (build_tree_list (name
, string_literal
),
21934 /* If the next token is not a `,', there are no more
21936 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
21938 /* Consume the `,'. */
21939 cp_lexer_consume_token (parser
->lexer
);
21942 return invalid_operands
? error_mark_node
: nreverse (asm_operands
);
21945 /* Parse an asm-clobber-list.
21949 asm-clobber-list , string-literal
21951 Returns a TREE_LIST, indicating the clobbers in the order that they
21952 appeared. The TREE_VALUE of each node is a STRING_CST. */
21955 cp_parser_asm_clobber_list (cp_parser
* parser
)
21957 tree clobbers
= NULL_TREE
;
21961 tree string_literal
;
21963 /* Look for the string literal. */
21964 string_literal
= cp_parser_string_literal (parser
, false, false);
21965 /* Add it to the list. */
21966 clobbers
= tree_cons (NULL_TREE
, string_literal
, clobbers
);
21967 /* If the next token is not a `,', then the list is
21969 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
21971 /* Consume the `,' token. */
21972 cp_lexer_consume_token (parser
->lexer
);
21978 /* Parse an asm-label-list.
21982 asm-label-list , identifier
21984 Returns a TREE_LIST, indicating the labels in the order that they
21985 appeared. The TREE_VALUE of each node is a label. */
21988 cp_parser_asm_label_list (cp_parser
* parser
)
21990 tree labels
= NULL_TREE
;
21994 tree identifier
, label
, name
;
21996 /* Look for the identifier. */
21997 identifier
= cp_parser_identifier (parser
);
21998 if (!error_operand_p (identifier
))
22000 label
= lookup_label (identifier
);
22001 if (TREE_CODE (label
) == LABEL_DECL
)
22003 TREE_USED (label
) = 1;
22004 check_goto (label
);
22005 name
= build_string (IDENTIFIER_LENGTH (identifier
),
22006 IDENTIFIER_POINTER (identifier
));
22007 labels
= tree_cons (name
, label
, labels
);
22010 /* If the next token is not a `,', then the list is
22012 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
22014 /* Consume the `,' token. */
22015 cp_lexer_consume_token (parser
->lexer
);
22018 return nreverse (labels
);
22021 /* Return TRUE iff the next tokens in the stream are possibly the
22022 beginning of a GNU extension attribute. */
22025 cp_next_tokens_can_be_gnu_attribute_p (cp_parser
*parser
)
22027 return cp_nth_tokens_can_be_gnu_attribute_p (parser
, 1);
22030 /* Return TRUE iff the next tokens in the stream are possibly the
22031 beginning of a standard C++-11 attribute specifier. */
22034 cp_next_tokens_can_be_std_attribute_p (cp_parser
*parser
)
22036 return cp_nth_tokens_can_be_std_attribute_p (parser
, 1);
22039 /* Return TRUE iff the next Nth tokens in the stream are possibly the
22040 beginning of a standard C++-11 attribute specifier. */
22043 cp_nth_tokens_can_be_std_attribute_p (cp_parser
*parser
, size_t n
)
22045 cp_token
*token
= cp_lexer_peek_nth_token (parser
->lexer
, n
);
22047 return (cxx_dialect
>= cxx11
22048 && ((token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_ALIGNAS
)
22049 || (token
->type
== CPP_OPEN_SQUARE
22050 && (token
= cp_lexer_peek_nth_token (parser
->lexer
, n
+ 1))
22051 && token
->type
== CPP_OPEN_SQUARE
)));
22054 /* Return TRUE iff the next Nth tokens in the stream are possibly the
22055 beginning of a GNU extension attribute. */
22058 cp_nth_tokens_can_be_gnu_attribute_p (cp_parser
*parser
, size_t n
)
22060 cp_token
*token
= cp_lexer_peek_nth_token (parser
->lexer
, n
);
22062 return token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_ATTRIBUTE
;
22065 /* Return true iff the next tokens can be the beginning of either a
22066 GNU attribute list, or a standard C++11 attribute sequence. */
22069 cp_next_tokens_can_be_attribute_p (cp_parser
*parser
)
22071 return (cp_next_tokens_can_be_gnu_attribute_p (parser
)
22072 || cp_next_tokens_can_be_std_attribute_p (parser
));
22075 /* Return true iff the next Nth tokens can be the beginning of either
22076 a GNU attribute list, or a standard C++11 attribute sequence. */
22079 cp_nth_tokens_can_be_attribute_p (cp_parser
*parser
, size_t n
)
22081 return (cp_nth_tokens_can_be_gnu_attribute_p (parser
, n
)
22082 || cp_nth_tokens_can_be_std_attribute_p (parser
, n
));
22085 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
22086 of GNU attributes, or return NULL. */
22089 cp_parser_attributes_opt (cp_parser
*parser
)
22091 if (cp_next_tokens_can_be_gnu_attribute_p (parser
))
22092 return cp_parser_gnu_attributes_opt (parser
);
22093 return cp_parser_std_attribute_spec_seq (parser
);
22096 #define CILK_SIMD_FN_CLAUSE_MASK \
22097 ((OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_VECTORLENGTH) \
22098 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_LINEAR) \
22099 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_UNIFORM) \
22100 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_MASK) \
22101 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_NOMASK))
22103 /* Parses the Cilk Plus SIMD-enabled function's attribute. Syntax:
22104 vector [(<clauses>)] */
22107 cp_parser_cilk_simd_fn_vector_attrs (cp_parser
*parser
, cp_token
*v_token
)
22109 bool first_p
= parser
->cilk_simd_fn_info
== NULL
;
22110 cp_token
*token
= v_token
;
22113 parser
->cilk_simd_fn_info
= XNEW (cp_omp_declare_simd_data
);
22114 parser
->cilk_simd_fn_info
->error_seen
= false;
22115 parser
->cilk_simd_fn_info
->fndecl_seen
= false;
22116 parser
->cilk_simd_fn_info
->tokens
= vNULL
;
22118 int paren_scope
= 0;
22119 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
22121 cp_lexer_consume_token (parser
->lexer
);
22122 v_token
= cp_lexer_peek_token (parser
->lexer
);
22125 while (paren_scope
> 0)
22127 token
= cp_lexer_peek_token (parser
->lexer
);
22128 if (token
->type
== CPP_OPEN_PAREN
)
22130 else if (token
->type
== CPP_CLOSE_PAREN
)
22132 /* Do not push the last ')' */
22133 if (!(token
->type
== CPP_CLOSE_PAREN
&& paren_scope
== 0))
22134 cp_lexer_consume_token (parser
->lexer
);
22137 token
->type
= CPP_PRAGMA_EOL
;
22138 parser
->lexer
->next_token
= token
;
22139 cp_lexer_consume_token (parser
->lexer
);
22141 struct cp_token_cache
*cp
22142 = cp_token_cache_new (v_token
, cp_lexer_peek_token (parser
->lexer
));
22143 parser
->cilk_simd_fn_info
->tokens
.safe_push (cp
);
22146 /* Parse an (optional) series of attributes.
22149 attributes attribute
22152 __attribute__ (( attribute-list [opt] ))
22154 The return value is as for cp_parser_gnu_attribute_list. */
22157 cp_parser_gnu_attributes_opt (cp_parser
* parser
)
22159 tree attributes
= NULL_TREE
;
22164 tree attribute_list
;
22167 /* Peek at the next token. */
22168 token
= cp_lexer_peek_token (parser
->lexer
);
22169 /* If it's not `__attribute__', then we're done. */
22170 if (token
->keyword
!= RID_ATTRIBUTE
)
22173 /* Consume the `__attribute__' keyword. */
22174 cp_lexer_consume_token (parser
->lexer
);
22175 /* Look for the two `(' tokens. */
22176 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
22177 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
22179 /* Peek at the next token. */
22180 token
= cp_lexer_peek_token (parser
->lexer
);
22181 if (token
->type
!= CPP_CLOSE_PAREN
)
22182 /* Parse the attribute-list. */
22183 attribute_list
= cp_parser_gnu_attribute_list (parser
);
22185 /* If the next token is a `)', then there is no attribute
22187 attribute_list
= NULL
;
22189 /* Look for the two `)' tokens. */
22190 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
22192 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
22195 cp_parser_skip_to_end_of_statement (parser
);
22197 /* Add these new attributes to the list. */
22198 attributes
= chainon (attributes
, attribute_list
);
22204 /* Returns true of NAME is an IDENTIFIER_NODE with identiifer "vector,"
22205 "__vector" or "__vector__." */
22208 is_cilkplus_vector_p (tree name
)
22210 if (flag_cilkplus
&& is_attribute_p ("vector", name
))
22215 /* Parse a GNU attribute-list.
22219 attribute-list , attribute
22223 identifier ( identifier )
22224 identifier ( identifier , expression-list )
22225 identifier ( expression-list )
22227 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
22228 to an attribute. The TREE_PURPOSE of each node is the identifier
22229 indicating which attribute is in use. The TREE_VALUE represents
22230 the arguments, if any. */
22233 cp_parser_gnu_attribute_list (cp_parser
* parser
)
22235 tree attribute_list
= NULL_TREE
;
22236 bool save_translate_strings_p
= parser
->translate_strings_p
;
22238 parser
->translate_strings_p
= false;
22245 /* Look for the identifier. We also allow keywords here; for
22246 example `__attribute__ ((const))' is legal. */
22247 token
= cp_lexer_peek_token (parser
->lexer
);
22248 if (token
->type
== CPP_NAME
22249 || token
->type
== CPP_KEYWORD
)
22251 tree arguments
= NULL_TREE
;
22253 /* Consume the token, but save it since we need it for the
22254 SIMD enabled function parsing. */
22255 cp_token
*id_token
= cp_lexer_consume_token (parser
->lexer
);
22257 /* Save away the identifier that indicates which attribute
22259 identifier
= (token
->type
== CPP_KEYWORD
)
22260 /* For keywords, use the canonical spelling, not the
22261 parsed identifier. */
22262 ? ridpointers
[(int) token
->keyword
]
22263 : id_token
->u
.value
;
22265 attribute
= build_tree_list (identifier
, NULL_TREE
);
22267 /* Peek at the next token. */
22268 token
= cp_lexer_peek_token (parser
->lexer
);
22269 /* If it's an `(', then parse the attribute arguments. */
22270 if (token
->type
== CPP_OPEN_PAREN
)
22272 vec
<tree
, va_gc
> *vec
;
22273 int attr_flag
= (attribute_takes_identifier_p (identifier
)
22274 ? id_attr
: normal_attr
);
22275 if (is_cilkplus_vector_p (identifier
))
22277 cp_parser_cilk_simd_fn_vector_attrs (parser
, id_token
);
22281 vec
= cp_parser_parenthesized_expression_list
22282 (parser
, attr_flag
, /*cast_p=*/false,
22283 /*allow_expansion_p=*/false,
22284 /*non_constant_p=*/NULL
);
22286 arguments
= error_mark_node
;
22289 arguments
= build_tree_list_vec (vec
);
22290 release_tree_vector (vec
);
22292 /* Save the arguments away. */
22293 TREE_VALUE (attribute
) = arguments
;
22295 else if (is_cilkplus_vector_p (identifier
))
22297 cp_parser_cilk_simd_fn_vector_attrs (parser
, id_token
);
22301 if (arguments
!= error_mark_node
)
22303 /* Add this attribute to the list. */
22304 TREE_CHAIN (attribute
) = attribute_list
;
22305 attribute_list
= attribute
;
22308 token
= cp_lexer_peek_token (parser
->lexer
);
22310 /* Now, look for more attributes. If the next token isn't a
22311 `,', we're done. */
22312 if (token
->type
!= CPP_COMMA
)
22315 /* Consume the comma and keep going. */
22316 cp_lexer_consume_token (parser
->lexer
);
22318 parser
->translate_strings_p
= save_translate_strings_p
;
22320 /* We built up the list in reverse order. */
22321 return nreverse (attribute_list
);
22324 /* Parse a standard C++11 attribute.
22326 The returned representation is a TREE_LIST which TREE_PURPOSE is
22327 the scoped name of the attribute, and the TREE_VALUE is its
22330 Note that the scoped name of the attribute is itself a TREE_LIST
22331 which TREE_PURPOSE is the namespace of the attribute, and
22332 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
22333 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
22334 and which TREE_PURPOSE is directly the attribute name.
22336 Clients of the attribute code should use get_attribute_namespace
22337 and get_attribute_name to get the actual namespace and name of
22338 attributes, regardless of their being GNU or C++11 attributes.
22341 attribute-token attribute-argument-clause [opt]
22345 attribute-scoped-token
22347 attribute-scoped-token:
22348 attribute-namespace :: identifier
22350 attribute-namespace:
22353 attribute-argument-clause:
22354 ( balanced-token-seq )
22356 balanced-token-seq:
22357 balanced-token [opt]
22358 balanced-token-seq balanced-token
22361 ( balanced-token-seq )
22362 [ balanced-token-seq ]
22363 { balanced-token-seq }. */
22366 cp_parser_std_attribute (cp_parser
*parser
)
22368 tree attribute
, attr_ns
= NULL_TREE
, attr_id
= NULL_TREE
, arguments
;
22371 /* First, parse name of the the attribute, a.k.a
22372 attribute-token. */
22374 token
= cp_lexer_peek_token (parser
->lexer
);
22375 if (token
->type
== CPP_NAME
)
22376 attr_id
= token
->u
.value
;
22377 else if (token
->type
== CPP_KEYWORD
)
22378 attr_id
= ridpointers
[(int) token
->keyword
];
22379 else if (token
->flags
& NAMED_OP
)
22380 attr_id
= get_identifier (cpp_type2name (token
->type
, token
->flags
));
22382 if (attr_id
== NULL_TREE
)
22385 cp_lexer_consume_token (parser
->lexer
);
22387 token
= cp_lexer_peek_token (parser
->lexer
);
22388 if (token
->type
== CPP_SCOPE
)
22390 /* We are seeing a scoped attribute token. */
22392 cp_lexer_consume_token (parser
->lexer
);
22395 token
= cp_lexer_consume_token (parser
->lexer
);
22396 if (token
->type
== CPP_NAME
)
22397 attr_id
= token
->u
.value
;
22398 else if (token
->type
== CPP_KEYWORD
)
22399 attr_id
= ridpointers
[(int) token
->keyword
];
22402 error_at (token
->location
,
22403 "expected an identifier for the attribute name");
22404 return error_mark_node
;
22406 attribute
= build_tree_list (build_tree_list (attr_ns
, attr_id
),
22408 token
= cp_lexer_peek_token (parser
->lexer
);
22412 attribute
= build_tree_list (build_tree_list (NULL_TREE
, attr_id
),
22414 /* C++11 noreturn attribute is equivalent to GNU's. */
22415 if (is_attribute_p ("noreturn", attr_id
))
22416 TREE_PURPOSE (TREE_PURPOSE (attribute
)) = get_identifier ("gnu");
22417 /* C++14 deprecated attribute is equivalent to GNU's. */
22418 else if (cxx_dialect
>= cxx11
&& is_attribute_p ("deprecated", attr_id
))
22420 if (cxx_dialect
== cxx11
)
22421 pedwarn (token
->location
, OPT_Wpedantic
,
22422 "%<deprecated%> is a C++14 feature;"
22423 " use %<gnu::deprecated%>");
22424 TREE_PURPOSE (TREE_PURPOSE (attribute
)) = get_identifier ("gnu");
22428 /* Now parse the optional argument clause of the attribute. */
22430 if (token
->type
!= CPP_OPEN_PAREN
)
22434 vec
<tree
, va_gc
> *vec
;
22435 int attr_flag
= normal_attr
;
22437 if (attr_ns
== get_identifier ("gnu")
22438 && attribute_takes_identifier_p (attr_id
))
22439 /* A GNU attribute that takes an identifier in parameter. */
22440 attr_flag
= id_attr
;
22442 vec
= cp_parser_parenthesized_expression_list
22443 (parser
, attr_flag
, /*cast_p=*/false,
22444 /*allow_expansion_p=*/true,
22445 /*non_constant_p=*/NULL
);
22447 arguments
= error_mark_node
;
22450 arguments
= build_tree_list_vec (vec
);
22451 release_tree_vector (vec
);
22454 if (arguments
== error_mark_node
)
22455 attribute
= error_mark_node
;
22457 TREE_VALUE (attribute
) = arguments
;
22463 /* Parse a list of standard C++-11 attributes.
22467 attribute-list , attribute[opt]
22469 attribute-list , attribute ...
22473 cp_parser_std_attribute_list (cp_parser
*parser
)
22475 tree attributes
= NULL_TREE
, attribute
= NULL_TREE
;
22476 cp_token
*token
= NULL
;
22480 attribute
= cp_parser_std_attribute (parser
);
22481 if (attribute
== error_mark_node
)
22483 if (attribute
!= NULL_TREE
)
22485 TREE_CHAIN (attribute
) = attributes
;
22486 attributes
= attribute
;
22488 token
= cp_lexer_peek_token (parser
->lexer
);
22489 if (token
->type
!= CPP_COMMA
)
22491 cp_lexer_consume_token (parser
->lexer
);
22493 attributes
= nreverse (attributes
);
22497 /* Parse a standard C++-11 attribute specifier.
22499 attribute-specifier:
22500 [ [ attribute-list ] ]
22501 alignment-specifier
22503 alignment-specifier:
22504 alignas ( type-id ... [opt] )
22505 alignas ( alignment-expression ... [opt] ). */
22508 cp_parser_std_attribute_spec (cp_parser
*parser
)
22510 tree attributes
= NULL_TREE
;
22511 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
22513 if (token
->type
== CPP_OPEN_SQUARE
22514 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_OPEN_SQUARE
)
22516 cp_lexer_consume_token (parser
->lexer
);
22517 cp_lexer_consume_token (parser
->lexer
);
22519 attributes
= cp_parser_std_attribute_list (parser
);
22521 if (!cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
)
22522 || !cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
))
22523 cp_parser_skip_to_end_of_statement (parser
);
22525 /* Warn about parsing c++11 attribute in non-c++1 mode, only
22526 when we are sure that we have actually parsed them. */
22527 maybe_warn_cpp0x (CPP0X_ATTRIBUTES
);
22533 /* Look for an alignment-specifier. */
22535 token
= cp_lexer_peek_token (parser
->lexer
);
22537 if (token
->type
!= CPP_KEYWORD
22538 || token
->keyword
!= RID_ALIGNAS
)
22541 cp_lexer_consume_token (parser
->lexer
);
22542 maybe_warn_cpp0x (CPP0X_ATTRIBUTES
);
22544 if (cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
) == NULL
)
22546 cp_parser_error (parser
, "expected %<(%>");
22547 return error_mark_node
;
22550 cp_parser_parse_tentatively (parser
);
22551 alignas_expr
= cp_parser_type_id (parser
);
22553 if (!cp_parser_parse_definitely (parser
))
22555 gcc_assert (alignas_expr
== error_mark_node
22556 || alignas_expr
== NULL_TREE
);
22559 cp_parser_assignment_expression (parser
);
22560 if (alignas_expr
== error_mark_node
)
22561 cp_parser_skip_to_end_of_statement (parser
);
22562 if (alignas_expr
== NULL_TREE
22563 || alignas_expr
== error_mark_node
)
22564 return alignas_expr
;
22567 if (cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
) == NULL
)
22569 cp_parser_error (parser
, "expected %<)%>");
22570 return error_mark_node
;
22573 alignas_expr
= cxx_alignas_expr (alignas_expr
);
22575 /* Build the C++-11 representation of an 'aligned'
22578 build_tree_list (build_tree_list (get_identifier ("gnu"),
22579 get_identifier ("aligned")),
22580 build_tree_list (NULL_TREE
, alignas_expr
));
22586 /* Parse a standard C++-11 attribute-specifier-seq.
22588 attribute-specifier-seq:
22589 attribute-specifier-seq [opt] attribute-specifier
22593 cp_parser_std_attribute_spec_seq (cp_parser
*parser
)
22595 tree attr_specs
= NULL
;
22599 tree attr_spec
= cp_parser_std_attribute_spec (parser
);
22600 if (attr_spec
== NULL_TREE
)
22602 if (attr_spec
== error_mark_node
)
22603 return error_mark_node
;
22605 TREE_CHAIN (attr_spec
) = attr_specs
;
22606 attr_specs
= attr_spec
;
22609 attr_specs
= nreverse (attr_specs
);
22613 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
22614 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
22615 current value of the PEDANTIC flag, regardless of whether or not
22616 the `__extension__' keyword is present. The caller is responsible
22617 for restoring the value of the PEDANTIC flag. */
22620 cp_parser_extension_opt (cp_parser
* parser
, int* saved_pedantic
)
22622 /* Save the old value of the PEDANTIC flag. */
22623 *saved_pedantic
= pedantic
;
22625 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_EXTENSION
))
22627 /* Consume the `__extension__' token. */
22628 cp_lexer_consume_token (parser
->lexer
);
22629 /* We're not being pedantic while the `__extension__' keyword is
22639 /* Parse a label declaration.
22642 __label__ label-declarator-seq ;
22644 label-declarator-seq:
22645 identifier , label-declarator-seq
22649 cp_parser_label_declaration (cp_parser
* parser
)
22651 /* Look for the `__label__' keyword. */
22652 cp_parser_require_keyword (parser
, RID_LABEL
, RT_LABEL
);
22658 /* Look for an identifier. */
22659 identifier
= cp_parser_identifier (parser
);
22660 /* If we failed, stop. */
22661 if (identifier
== error_mark_node
)
22663 /* Declare it as a label. */
22664 finish_label_decl (identifier
);
22665 /* If the next token is a `;', stop. */
22666 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
22668 /* Look for the `,' separating the label declarations. */
22669 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
22672 /* Look for the final `;'. */
22673 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
22676 /* Support Functions */
22678 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
22679 NAME should have one of the representations used for an
22680 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
22681 is returned. If PARSER->SCOPE is a dependent type, then a
22682 SCOPE_REF is returned.
22684 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
22685 returned; the name was already resolved when the TEMPLATE_ID_EXPR
22686 was formed. Abstractly, such entities should not be passed to this
22687 function, because they do not need to be looked up, but it is
22688 simpler to check for this special case here, rather than at the
22691 In cases not explicitly covered above, this function returns a
22692 DECL, OVERLOAD, or baselink representing the result of the lookup.
22693 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
22696 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
22697 (e.g., "struct") that was used. In that case bindings that do not
22698 refer to types are ignored.
22700 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
22703 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
22706 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
22709 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
22710 TREE_LIST of candidates if name-lookup results in an ambiguity, and
22711 NULL_TREE otherwise. */
22714 cp_parser_lookup_name (cp_parser
*parser
, tree name
,
22715 enum tag_types tag_type
,
22718 bool check_dependency
,
22719 tree
*ambiguous_decls
,
22720 location_t name_location
)
22723 tree object_type
= parser
->context
->object_type
;
22725 /* Assume that the lookup will be unambiguous. */
22726 if (ambiguous_decls
)
22727 *ambiguous_decls
= NULL_TREE
;
22729 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
22730 no longer valid. Note that if we are parsing tentatively, and
22731 the parse fails, OBJECT_TYPE will be automatically restored. */
22732 parser
->context
->object_type
= NULL_TREE
;
22734 if (name
== error_mark_node
)
22735 return error_mark_node
;
22737 /* A template-id has already been resolved; there is no lookup to
22739 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
22741 if (BASELINK_P (name
))
22743 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name
))
22744 == TEMPLATE_ID_EXPR
);
22748 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
22749 it should already have been checked to make sure that the name
22750 used matches the type being destroyed. */
22751 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
22755 /* Figure out to which type this destructor applies. */
22757 type
= parser
->scope
;
22758 else if (object_type
)
22759 type
= object_type
;
22761 type
= current_class_type
;
22762 /* If that's not a class type, there is no destructor. */
22763 if (!type
|| !CLASS_TYPE_P (type
))
22764 return error_mark_node
;
22765 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
22766 lazily_declare_fn (sfk_destructor
, type
);
22767 if (!CLASSTYPE_DESTRUCTORS (type
))
22768 return error_mark_node
;
22769 /* If it was a class type, return the destructor. */
22770 return CLASSTYPE_DESTRUCTORS (type
);
22773 /* By this point, the NAME should be an ordinary identifier. If
22774 the id-expression was a qualified name, the qualifying scope is
22775 stored in PARSER->SCOPE at this point. */
22776 gcc_assert (identifier_p (name
));
22778 /* Perform the lookup. */
22783 if (parser
->scope
== error_mark_node
)
22784 return error_mark_node
;
22786 /* If the SCOPE is dependent, the lookup must be deferred until
22787 the template is instantiated -- unless we are explicitly
22788 looking up names in uninstantiated templates. Even then, we
22789 cannot look up the name if the scope is not a class type; it
22790 might, for example, be a template type parameter. */
22791 dependent_p
= (TYPE_P (parser
->scope
)
22792 && dependent_scope_p (parser
->scope
));
22793 if ((check_dependency
|| !CLASS_TYPE_P (parser
->scope
))
22795 /* Defer lookup. */
22796 decl
= error_mark_node
;
22799 tree pushed_scope
= NULL_TREE
;
22801 /* If PARSER->SCOPE is a dependent type, then it must be a
22802 class type, and we must not be checking dependencies;
22803 otherwise, we would have processed this lookup above. So
22804 that PARSER->SCOPE is not considered a dependent base by
22805 lookup_member, we must enter the scope here. */
22807 pushed_scope
= push_scope (parser
->scope
);
22809 /* If the PARSER->SCOPE is a template specialization, it
22810 may be instantiated during name lookup. In that case,
22811 errors may be issued. Even if we rollback the current
22812 tentative parse, those errors are valid. */
22813 decl
= lookup_qualified_name (parser
->scope
, name
,
22814 tag_type
!= none_type
,
22815 /*complain=*/true);
22817 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
22818 lookup result and the nested-name-specifier nominates a class C:
22819 * if the name specified after the nested-name-specifier, when
22820 looked up in C, is the injected-class-name of C (Clause 9), or
22821 * if the name specified after the nested-name-specifier is the
22822 same as the identifier or the simple-template-id's template-
22823 name in the last component of the nested-name-specifier,
22824 the name is instead considered to name the constructor of
22825 class C. [ Note: for example, the constructor is not an
22826 acceptable lookup result in an elaborated-type-specifier so
22827 the constructor would not be used in place of the
22828 injected-class-name. --end note ] Such a constructor name
22829 shall be used only in the declarator-id of a declaration that
22830 names a constructor or in a using-declaration. */
22831 if (tag_type
== none_type
22832 && DECL_SELF_REFERENCE_P (decl
)
22833 && same_type_p (DECL_CONTEXT (decl
), parser
->scope
))
22834 decl
= lookup_qualified_name (parser
->scope
, ctor_identifier
,
22835 tag_type
!= none_type
,
22836 /*complain=*/true);
22838 /* If we have a single function from a using decl, pull it out. */
22839 if (TREE_CODE (decl
) == OVERLOAD
22840 && !really_overloaded_fn (decl
))
22841 decl
= OVL_FUNCTION (decl
);
22844 pop_scope (pushed_scope
);
22847 /* If the scope is a dependent type and either we deferred lookup or
22848 we did lookup but didn't find the name, rememeber the name. */
22849 if (decl
== error_mark_node
&& TYPE_P (parser
->scope
)
22850 && dependent_type_p (parser
->scope
))
22856 /* The resolution to Core Issue 180 says that `struct
22857 A::B' should be considered a type-name, even if `A'
22859 type
= make_typename_type (parser
->scope
, name
, tag_type
,
22860 /*complain=*/tf_error
);
22861 if (type
!= error_mark_node
)
22862 decl
= TYPE_NAME (type
);
22864 else if (is_template
22865 && (cp_parser_next_token_ends_template_argument_p (parser
)
22866 || cp_lexer_next_token_is (parser
->lexer
,
22868 decl
= make_unbound_class_template (parser
->scope
,
22870 /*complain=*/tf_error
);
22872 decl
= build_qualified_name (/*type=*/NULL_TREE
,
22873 parser
->scope
, name
,
22876 parser
->qualifying_scope
= parser
->scope
;
22877 parser
->object_scope
= NULL_TREE
;
22879 else if (object_type
)
22881 /* Look up the name in the scope of the OBJECT_TYPE, unless the
22882 OBJECT_TYPE is not a class. */
22883 if (CLASS_TYPE_P (object_type
))
22884 /* If the OBJECT_TYPE is a template specialization, it may
22885 be instantiated during name lookup. In that case, errors
22886 may be issued. Even if we rollback the current tentative
22887 parse, those errors are valid. */
22888 decl
= lookup_member (object_type
,
22891 tag_type
!= none_type
,
22892 tf_warning_or_error
);
22897 /* Look it up in the enclosing context. */
22898 decl
= lookup_name_real (name
, tag_type
!= none_type
,
22900 /*block_p=*/true, is_namespace
, 0);
22901 parser
->object_scope
= object_type
;
22902 parser
->qualifying_scope
= NULL_TREE
;
22906 decl
= lookup_name_real (name
, tag_type
!= none_type
,
22908 /*block_p=*/true, is_namespace
, 0);
22909 parser
->qualifying_scope
= NULL_TREE
;
22910 parser
->object_scope
= NULL_TREE
;
22913 /* If the lookup failed, let our caller know. */
22914 if (!decl
|| decl
== error_mark_node
)
22915 return error_mark_node
;
22917 /* Pull out the template from an injected-class-name (or multiple). */
22919 decl
= maybe_get_template_decl_from_type_decl (decl
);
22921 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
22922 if (TREE_CODE (decl
) == TREE_LIST
)
22924 if (ambiguous_decls
)
22925 *ambiguous_decls
= decl
;
22926 /* The error message we have to print is too complicated for
22927 cp_parser_error, so we incorporate its actions directly. */
22928 if (!cp_parser_simulate_error (parser
))
22930 error_at (name_location
, "reference to %qD is ambiguous",
22932 print_candidates (decl
);
22934 return error_mark_node
;
22937 gcc_assert (DECL_P (decl
)
22938 || TREE_CODE (decl
) == OVERLOAD
22939 || TREE_CODE (decl
) == SCOPE_REF
22940 || TREE_CODE (decl
) == UNBOUND_CLASS_TEMPLATE
22941 || BASELINK_P (decl
));
22943 /* If we have resolved the name of a member declaration, check to
22944 see if the declaration is accessible. When the name resolves to
22945 set of overloaded functions, accessibility is checked when
22946 overload resolution is done.
22948 During an explicit instantiation, access is not checked at all,
22949 as per [temp.explicit]. */
22951 check_accessibility_of_qualified_id (decl
, object_type
, parser
->scope
);
22953 maybe_record_typedef_use (decl
);
22958 /* Like cp_parser_lookup_name, but for use in the typical case where
22959 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
22960 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
22963 cp_parser_lookup_name_simple (cp_parser
* parser
, tree name
, location_t location
)
22965 return cp_parser_lookup_name (parser
, name
,
22967 /*is_template=*/false,
22968 /*is_namespace=*/false,
22969 /*check_dependency=*/true,
22970 /*ambiguous_decls=*/NULL
,
22974 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
22975 the current context, return the TYPE_DECL. If TAG_NAME_P is
22976 true, the DECL indicates the class being defined in a class-head,
22977 or declared in an elaborated-type-specifier.
22979 Otherwise, return DECL. */
22982 cp_parser_maybe_treat_template_as_class (tree decl
, bool tag_name_p
)
22984 /* If the TEMPLATE_DECL is being declared as part of a class-head,
22985 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
22988 template <typename T> struct B;
22991 template <typename T> struct A::B {};
22993 Similarly, in an elaborated-type-specifier:
22995 namespace N { struct X{}; }
22998 template <typename T> friend struct N::X;
23001 However, if the DECL refers to a class type, and we are in
23002 the scope of the class, then the name lookup automatically
23003 finds the TYPE_DECL created by build_self_reference rather
23004 than a TEMPLATE_DECL. For example, in:
23006 template <class T> struct S {
23010 there is no need to handle such case. */
23012 if (DECL_CLASS_TEMPLATE_P (decl
) && tag_name_p
)
23013 return DECL_TEMPLATE_RESULT (decl
);
23018 /* If too many, or too few, template-parameter lists apply to the
23019 declarator, issue an error message. Returns TRUE if all went well,
23020 and FALSE otherwise. */
23023 cp_parser_check_declarator_template_parameters (cp_parser
* parser
,
23024 cp_declarator
*declarator
,
23025 location_t declarator_location
)
23027 switch (declarator
->kind
)
23031 unsigned num_templates
= 0;
23032 tree scope
= declarator
->u
.id
.qualifying_scope
;
23035 num_templates
= num_template_headers_for_class (scope
);
23036 else if (TREE_CODE (declarator
->u
.id
.unqualified_name
)
23037 == TEMPLATE_ID_EXPR
)
23038 /* If the DECLARATOR has the form `X<y>' then it uses one
23039 additional level of template parameters. */
23042 return cp_parser_check_template_parameters
23043 (parser
, num_templates
, declarator_location
, declarator
);
23049 case cdk_reference
:
23051 return (cp_parser_check_declarator_template_parameters
23052 (parser
, declarator
->declarator
, declarator_location
));
23058 gcc_unreachable ();
23063 /* NUM_TEMPLATES were used in the current declaration. If that is
23064 invalid, return FALSE and issue an error messages. Otherwise,
23065 return TRUE. If DECLARATOR is non-NULL, then we are checking a
23066 declarator and we can print more accurate diagnostics. */
23069 cp_parser_check_template_parameters (cp_parser
* parser
,
23070 unsigned num_templates
,
23071 location_t location
,
23072 cp_declarator
*declarator
)
23074 /* If there are the same number of template classes and parameter
23075 lists, that's OK. */
23076 if (parser
->num_template_parameter_lists
== num_templates
)
23078 /* If there are more, but only one more, then we are referring to a
23079 member template. That's OK too. */
23080 if (parser
->num_template_parameter_lists
== num_templates
+ 1)
23082 /* If there are more template classes than parameter lists, we have
23085 template <class T> void S<T>::R<T>::f (); */
23086 if (parser
->num_template_parameter_lists
< num_templates
)
23088 if (declarator
&& !current_function_decl
)
23089 error_at (location
, "specializing member %<%T::%E%> "
23090 "requires %<template<>%> syntax",
23091 declarator
->u
.id
.qualifying_scope
,
23092 declarator
->u
.id
.unqualified_name
);
23093 else if (declarator
)
23094 error_at (location
, "invalid declaration of %<%T::%E%>",
23095 declarator
->u
.id
.qualifying_scope
,
23096 declarator
->u
.id
.unqualified_name
);
23098 error_at (location
, "too few template-parameter-lists");
23101 /* Otherwise, there are too many template parameter lists. We have
23104 template <class T> template <class U> void S::f(); */
23105 error_at (location
, "too many template-parameter-lists");
23109 /* Parse an optional `::' token indicating that the following name is
23110 from the global namespace. If so, PARSER->SCOPE is set to the
23111 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
23112 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
23113 Returns the new value of PARSER->SCOPE, if the `::' token is
23114 present, and NULL_TREE otherwise. */
23117 cp_parser_global_scope_opt (cp_parser
* parser
, bool current_scope_valid_p
)
23121 /* Peek at the next token. */
23122 token
= cp_lexer_peek_token (parser
->lexer
);
23123 /* If we're looking at a `::' token then we're starting from the
23124 global namespace, not our current location. */
23125 if (token
->type
== CPP_SCOPE
)
23127 /* Consume the `::' token. */
23128 cp_lexer_consume_token (parser
->lexer
);
23129 /* Set the SCOPE so that we know where to start the lookup. */
23130 parser
->scope
= global_namespace
;
23131 parser
->qualifying_scope
= global_namespace
;
23132 parser
->object_scope
= NULL_TREE
;
23134 return parser
->scope
;
23136 else if (!current_scope_valid_p
)
23138 parser
->scope
= NULL_TREE
;
23139 parser
->qualifying_scope
= NULL_TREE
;
23140 parser
->object_scope
= NULL_TREE
;
23146 /* Returns TRUE if the upcoming token sequence is the start of a
23147 constructor declarator. If FRIEND_P is true, the declarator is
23148 preceded by the `friend' specifier. */
23151 cp_parser_constructor_declarator_p (cp_parser
*parser
, bool friend_p
)
23153 bool constructor_p
;
23154 bool outside_class_specifier_p
;
23155 tree nested_name_specifier
;
23156 cp_token
*next_token
;
23158 /* The common case is that this is not a constructor declarator, so
23159 try to avoid doing lots of work if at all possible. It's not
23160 valid declare a constructor at function scope. */
23161 if (parser
->in_function_body
)
23163 /* And only certain tokens can begin a constructor declarator. */
23164 next_token
= cp_lexer_peek_token (parser
->lexer
);
23165 if (next_token
->type
!= CPP_NAME
23166 && next_token
->type
!= CPP_SCOPE
23167 && next_token
->type
!= CPP_NESTED_NAME_SPECIFIER
23168 && next_token
->type
!= CPP_TEMPLATE_ID
)
23171 /* Parse tentatively; we are going to roll back all of the tokens
23173 cp_parser_parse_tentatively (parser
);
23174 /* Assume that we are looking at a constructor declarator. */
23175 constructor_p
= true;
23177 /* Look for the optional `::' operator. */
23178 cp_parser_global_scope_opt (parser
,
23179 /*current_scope_valid_p=*/false);
23180 /* Look for the nested-name-specifier. */
23181 nested_name_specifier
23182 = (cp_parser_nested_name_specifier_opt (parser
,
23183 /*typename_keyword_p=*/false,
23184 /*check_dependency_p=*/false,
23186 /*is_declaration=*/false));
23188 outside_class_specifier_p
= (!at_class_scope_p ()
23189 || !TYPE_BEING_DEFINED (current_class_type
)
23192 /* Outside of a class-specifier, there must be a
23193 nested-name-specifier. */
23194 if (!nested_name_specifier
&& outside_class_specifier_p
)
23195 constructor_p
= false;
23196 else if (nested_name_specifier
== error_mark_node
)
23197 constructor_p
= false;
23199 /* If we have a class scope, this is easy; DR 147 says that S::S always
23200 names the constructor, and no other qualified name could. */
23201 if (constructor_p
&& nested_name_specifier
23202 && CLASS_TYPE_P (nested_name_specifier
))
23204 tree id
= cp_parser_unqualified_id (parser
,
23205 /*template_keyword_p=*/false,
23206 /*check_dependency_p=*/false,
23207 /*declarator_p=*/true,
23208 /*optional_p=*/false);
23209 if (is_overloaded_fn (id
))
23210 id
= DECL_NAME (get_first_fn (id
));
23211 if (!constructor_name_p (id
, nested_name_specifier
))
23212 constructor_p
= false;
23214 /* If we still think that this might be a constructor-declarator,
23215 look for a class-name. */
23216 else if (constructor_p
)
23220 template <typename T> struct S {
23224 we must recognize that the nested `S' names a class. */
23226 type_decl
= cp_parser_class_name (parser
,
23227 /*typename_keyword_p=*/false,
23228 /*template_keyword_p=*/false,
23230 /*check_dependency_p=*/false,
23231 /*class_head_p=*/false,
23232 /*is_declaration=*/false);
23233 /* If there was no class-name, then this is not a constructor.
23234 Otherwise, if we are in a class-specifier and we aren't
23235 handling a friend declaration, check that its type matches
23236 current_class_type (c++/38313). Note: error_mark_node
23237 is left alone for error recovery purposes. */
23238 constructor_p
= (!cp_parser_error_occurred (parser
)
23239 && (outside_class_specifier_p
23240 || type_decl
== error_mark_node
23241 || same_type_p (current_class_type
,
23242 TREE_TYPE (type_decl
))));
23244 /* If we're still considering a constructor, we have to see a `(',
23245 to begin the parameter-declaration-clause, followed by either a
23246 `)', an `...', or a decl-specifier. We need to check for a
23247 type-specifier to avoid being fooled into thinking that:
23251 is a constructor. (It is actually a function named `f' that
23252 takes one parameter (of type `int') and returns a value of type
23255 && !cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
23256 constructor_p
= false;
23259 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
)
23260 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_ELLIPSIS
)
23261 /* A parameter declaration begins with a decl-specifier,
23262 which is either the "attribute" keyword, a storage class
23263 specifier, or (usually) a type-specifier. */
23264 && !cp_lexer_next_token_is_decl_specifier_keyword (parser
->lexer
))
23267 tree pushed_scope
= NULL_TREE
;
23268 unsigned saved_num_template_parameter_lists
;
23270 /* Names appearing in the type-specifier should be looked up
23271 in the scope of the class. */
23272 if (current_class_type
)
23276 type
= TREE_TYPE (type_decl
);
23277 if (TREE_CODE (type
) == TYPENAME_TYPE
)
23279 type
= resolve_typename_type (type
,
23280 /*only_current_p=*/false);
23281 if (TREE_CODE (type
) == TYPENAME_TYPE
)
23283 cp_parser_abort_tentative_parse (parser
);
23287 pushed_scope
= push_scope (type
);
23290 /* Inside the constructor parameter list, surrounding
23291 template-parameter-lists do not apply. */
23292 saved_num_template_parameter_lists
23293 = parser
->num_template_parameter_lists
;
23294 parser
->num_template_parameter_lists
= 0;
23296 /* Look for the type-specifier. */
23297 cp_parser_type_specifier (parser
,
23298 CP_PARSER_FLAGS_NONE
,
23299 /*decl_specs=*/NULL
,
23300 /*is_declarator=*/true,
23301 /*declares_class_or_enum=*/NULL
,
23302 /*is_cv_qualifier=*/NULL
);
23304 parser
->num_template_parameter_lists
23305 = saved_num_template_parameter_lists
;
23307 /* Leave the scope of the class. */
23309 pop_scope (pushed_scope
);
23311 constructor_p
= !cp_parser_error_occurred (parser
);
23315 /* We did not really want to consume any tokens. */
23316 cp_parser_abort_tentative_parse (parser
);
23318 return constructor_p
;
23321 /* Parse the definition of the function given by the DECL_SPECIFIERS,
23322 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
23323 they must be performed once we are in the scope of the function.
23325 Returns the function defined. */
23328 cp_parser_function_definition_from_specifiers_and_declarator
23329 (cp_parser
* parser
,
23330 cp_decl_specifier_seq
*decl_specifiers
,
23332 const cp_declarator
*declarator
)
23337 /* Begin the function-definition. */
23338 success_p
= start_function (decl_specifiers
, declarator
, attributes
);
23340 /* The things we're about to see are not directly qualified by any
23341 template headers we've seen thus far. */
23342 reset_specialization ();
23344 /* If there were names looked up in the decl-specifier-seq that we
23345 did not check, check them now. We must wait until we are in the
23346 scope of the function to perform the checks, since the function
23347 might be a friend. */
23348 perform_deferred_access_checks (tf_warning_or_error
);
23352 cp_finalize_omp_declare_simd (parser
, current_function_decl
);
23353 parser
->omp_declare_simd
= NULL
;
23358 /* Skip the entire function. */
23359 cp_parser_skip_to_end_of_block_or_statement (parser
);
23360 fn
= error_mark_node
;
23362 else if (DECL_INITIAL (current_function_decl
) != error_mark_node
)
23364 /* Seen already, skip it. An error message has already been output. */
23365 cp_parser_skip_to_end_of_block_or_statement (parser
);
23366 fn
= current_function_decl
;
23367 current_function_decl
= NULL_TREE
;
23368 /* If this is a function from a class, pop the nested class. */
23369 if (current_class_name
)
23370 pop_nested_class ();
23375 if (DECL_DECLARED_INLINE_P (current_function_decl
))
23376 tv
= TV_PARSE_INLINE
;
23378 tv
= TV_PARSE_FUNC
;
23380 fn
= cp_parser_function_definition_after_declarator (parser
,
23381 /*inline_p=*/false);
23388 /* Parse the part of a function-definition that follows the
23389 declarator. INLINE_P is TRUE iff this function is an inline
23390 function defined within a class-specifier.
23392 Returns the function defined. */
23395 cp_parser_function_definition_after_declarator (cp_parser
* parser
,
23399 bool ctor_initializer_p
= false;
23400 bool saved_in_unbraced_linkage_specification_p
;
23401 bool saved_in_function_body
;
23402 unsigned saved_num_template_parameter_lists
;
23404 bool fully_implicit_function_template_p
23405 = parser
->fully_implicit_function_template_p
;
23406 parser
->fully_implicit_function_template_p
= false;
23407 tree implicit_template_parms
23408 = parser
->implicit_template_parms
;
23409 parser
->implicit_template_parms
= 0;
23410 cp_binding_level
* implicit_template_scope
23411 = parser
->implicit_template_scope
;
23412 parser
->implicit_template_scope
= 0;
23414 saved_in_function_body
= parser
->in_function_body
;
23415 parser
->in_function_body
= true;
23416 /* If the next token is `return', then the code may be trying to
23417 make use of the "named return value" extension that G++ used to
23419 token
= cp_lexer_peek_token (parser
->lexer
);
23420 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_RETURN
))
23422 /* Consume the `return' keyword. */
23423 cp_lexer_consume_token (parser
->lexer
);
23424 /* Look for the identifier that indicates what value is to be
23426 cp_parser_identifier (parser
);
23427 /* Issue an error message. */
23428 error_at (token
->location
,
23429 "named return values are no longer supported");
23430 /* Skip tokens until we reach the start of the function body. */
23433 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
23434 if (token
->type
== CPP_OPEN_BRACE
23435 || token
->type
== CPP_EOF
23436 || token
->type
== CPP_PRAGMA_EOL
)
23438 cp_lexer_consume_token (parser
->lexer
);
23441 /* The `extern' in `extern "C" void f () { ... }' does not apply to
23442 anything declared inside `f'. */
23443 saved_in_unbraced_linkage_specification_p
23444 = parser
->in_unbraced_linkage_specification_p
;
23445 parser
->in_unbraced_linkage_specification_p
= false;
23446 /* Inside the function, surrounding template-parameter-lists do not
23448 saved_num_template_parameter_lists
23449 = parser
->num_template_parameter_lists
;
23450 parser
->num_template_parameter_lists
= 0;
23452 start_lambda_scope (current_function_decl
);
23454 /* If the next token is `try', `__transaction_atomic', or
23455 `__transaction_relaxed`, then we are looking at either function-try-block
23456 or function-transaction-block. Note that all of these include the
23458 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRANSACTION_ATOMIC
))
23459 ctor_initializer_p
= cp_parser_function_transaction (parser
,
23460 RID_TRANSACTION_ATOMIC
);
23461 else if (cp_lexer_next_token_is_keyword (parser
->lexer
,
23462 RID_TRANSACTION_RELAXED
))
23463 ctor_initializer_p
= cp_parser_function_transaction (parser
,
23464 RID_TRANSACTION_RELAXED
);
23465 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRY
))
23466 ctor_initializer_p
= cp_parser_function_try_block (parser
);
23468 ctor_initializer_p
= cp_parser_ctor_initializer_opt_and_function_body
23469 (parser
, /*in_function_try_block=*/false);
23471 finish_lambda_scope ();
23473 /* Finish the function. */
23474 fn
= finish_function ((ctor_initializer_p
? 1 : 0) |
23475 (inline_p
? 2 : 0));
23476 /* Generate code for it, if necessary. */
23477 expand_or_defer_fn (fn
);
23478 /* Restore the saved values. */
23479 parser
->in_unbraced_linkage_specification_p
23480 = saved_in_unbraced_linkage_specification_p
;
23481 parser
->num_template_parameter_lists
23482 = saved_num_template_parameter_lists
;
23483 parser
->in_function_body
= saved_in_function_body
;
23485 parser
->fully_implicit_function_template_p
23486 = fully_implicit_function_template_p
;
23487 parser
->implicit_template_parms
23488 = implicit_template_parms
;
23489 parser
->implicit_template_scope
23490 = implicit_template_scope
;
23492 if (parser
->fully_implicit_function_template_p
)
23493 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
23498 /* Parse a template-declaration, assuming that the `export' (and
23499 `extern') keywords, if present, has already been scanned. MEMBER_P
23500 is as for cp_parser_template_declaration. */
23503 cp_parser_template_declaration_after_export (cp_parser
* parser
, bool member_p
)
23505 tree decl
= NULL_TREE
;
23506 vec
<deferred_access_check
, va_gc
> *checks
;
23507 tree parameter_list
;
23508 bool friend_p
= false;
23509 bool need_lang_pop
;
23512 /* Look for the `template' keyword. */
23513 token
= cp_lexer_peek_token (parser
->lexer
);
23514 if (!cp_parser_require_keyword (parser
, RID_TEMPLATE
, RT_TEMPLATE
))
23518 if (!cp_parser_require (parser
, CPP_LESS
, RT_LESS
))
23520 if (at_class_scope_p () && current_function_decl
)
23522 /* 14.5.2.2 [temp.mem]
23524 A local class shall not have member templates. */
23525 error_at (token
->location
,
23526 "invalid declaration of member template in local class");
23527 cp_parser_skip_to_end_of_block_or_statement (parser
);
23532 A template ... shall not have C linkage. */
23533 if (current_lang_name
== lang_name_c
)
23535 error_at (token
->location
, "template with C linkage");
23536 /* Give it C++ linkage to avoid confusing other parts of the
23538 push_lang_context (lang_name_cplusplus
);
23539 need_lang_pop
= true;
23542 need_lang_pop
= false;
23544 /* We cannot perform access checks on the template parameter
23545 declarations until we know what is being declared, just as we
23546 cannot check the decl-specifier list. */
23547 push_deferring_access_checks (dk_deferred
);
23549 /* If the next token is `>', then we have an invalid
23550 specialization. Rather than complain about an invalid template
23551 parameter, issue an error message here. */
23552 if (cp_lexer_next_token_is (parser
->lexer
, CPP_GREATER
))
23554 cp_parser_error (parser
, "invalid explicit specialization");
23555 begin_specialization ();
23556 parameter_list
= NULL_TREE
;
23560 /* Parse the template parameters. */
23561 parameter_list
= cp_parser_template_parameter_list (parser
);
23564 /* Get the deferred access checks from the parameter list. These
23565 will be checked once we know what is being declared, as for a
23566 member template the checks must be performed in the scope of the
23567 class containing the member. */
23568 checks
= get_deferred_access_checks ();
23570 /* Look for the `>'. */
23571 cp_parser_skip_to_end_of_template_parameter_list (parser
);
23572 /* We just processed one more parameter list. */
23573 ++parser
->num_template_parameter_lists
;
23574 /* If the next token is `template', there are more template
23576 if (cp_lexer_next_token_is_keyword (parser
->lexer
,
23578 cp_parser_template_declaration_after_export (parser
, member_p
);
23579 else if (cxx_dialect
>= cxx11
23580 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_USING
))
23581 decl
= cp_parser_alias_declaration (parser
);
23584 /* There are no access checks when parsing a template, as we do not
23585 know if a specialization will be a friend. */
23586 push_deferring_access_checks (dk_no_check
);
23587 token
= cp_lexer_peek_token (parser
->lexer
);
23588 decl
= cp_parser_single_declaration (parser
,
23591 /*explicit_specialization_p=*/false,
23593 pop_deferring_access_checks ();
23595 /* If this is a member template declaration, let the front
23597 if (member_p
&& !friend_p
&& decl
)
23599 if (TREE_CODE (decl
) == TYPE_DECL
)
23600 cp_parser_check_access_in_redeclaration (decl
, token
->location
);
23602 decl
= finish_member_template_decl (decl
);
23604 else if (friend_p
&& decl
23605 && DECL_DECLARES_TYPE_P (decl
))
23606 make_friend_class (current_class_type
, TREE_TYPE (decl
),
23607 /*complain=*/true);
23609 /* We are done with the current parameter list. */
23610 --parser
->num_template_parameter_lists
;
23612 pop_deferring_access_checks ();
23615 finish_template_decl (parameter_list
);
23617 /* Check the template arguments for a literal operator template. */
23619 && DECL_DECLARES_FUNCTION_P (decl
)
23620 && UDLIT_OPER_P (DECL_NAME (decl
)))
23623 if (parameter_list
== NULL_TREE
)
23627 int num_parms
= TREE_VEC_LENGTH (parameter_list
);
23628 if (num_parms
== 1)
23630 tree parm_list
= TREE_VEC_ELT (parameter_list
, 0);
23631 tree parm
= INNERMOST_TEMPLATE_PARMS (parm_list
);
23632 if (TREE_TYPE (parm
) != char_type_node
23633 || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
23636 else if (num_parms
== 2 && cxx_dialect
>= cxx14
)
23638 tree parm_type
= TREE_VEC_ELT (parameter_list
, 0);
23639 tree type
= INNERMOST_TEMPLATE_PARMS (parm_type
);
23640 tree parm_list
= TREE_VEC_ELT (parameter_list
, 1);
23641 tree parm
= INNERMOST_TEMPLATE_PARMS (parm_list
);
23642 if (TREE_TYPE (parm
) != TREE_TYPE (type
)
23643 || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
23651 if (cxx_dialect
>= cxx14
)
23652 error ("literal operator template %qD has invalid parameter list."
23653 " Expected non-type template argument pack <char...>"
23654 " or <typename CharT, CharT...>",
23657 error ("literal operator template %qD has invalid parameter list."
23658 " Expected non-type template argument pack <char...>",
23662 /* Register member declarations. */
23663 if (member_p
&& !friend_p
&& decl
&& !DECL_CLASS_TEMPLATE_P (decl
))
23664 finish_member_declaration (decl
);
23665 /* For the erroneous case of a template with C linkage, we pushed an
23666 implicit C++ linkage scope; exit that scope now. */
23668 pop_lang_context ();
23669 /* If DECL is a function template, we must return to parse it later.
23670 (Even though there is no definition, there might be default
23671 arguments that need handling.) */
23672 if (member_p
&& decl
23673 && DECL_DECLARES_FUNCTION_P (decl
))
23674 vec_safe_push (unparsed_funs_with_definitions
, decl
);
23677 /* Perform the deferred access checks from a template-parameter-list.
23678 CHECKS is a TREE_LIST of access checks, as returned by
23679 get_deferred_access_checks. */
23682 cp_parser_perform_template_parameter_access_checks (vec
<deferred_access_check
, va_gc
> *checks
)
23684 ++processing_template_parmlist
;
23685 perform_access_checks (checks
, tf_warning_or_error
);
23686 --processing_template_parmlist
;
23689 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
23690 `function-definition' sequence that follows a template header.
23691 If MEMBER_P is true, this declaration appears in a class scope.
23693 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
23694 *FRIEND_P is set to TRUE iff the declaration is a friend. */
23697 cp_parser_single_declaration (cp_parser
* parser
,
23698 vec
<deferred_access_check
, va_gc
> *checks
,
23700 bool explicit_specialization_p
,
23703 int declares_class_or_enum
;
23704 tree decl
= NULL_TREE
;
23705 cp_decl_specifier_seq decl_specifiers
;
23706 bool function_definition_p
= false;
23707 cp_token
*decl_spec_token_start
;
23709 /* This function is only used when processing a template
23711 gcc_assert (innermost_scope_kind () == sk_template_parms
23712 || innermost_scope_kind () == sk_template_spec
);
23714 /* Defer access checks until we know what is being declared. */
23715 push_deferring_access_checks (dk_deferred
);
23717 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
23719 decl_spec_token_start
= cp_lexer_peek_token (parser
->lexer
);
23720 cp_parser_decl_specifier_seq (parser
,
23721 CP_PARSER_FLAGS_OPTIONAL
,
23723 &declares_class_or_enum
);
23725 *friend_p
= cp_parser_friend_p (&decl_specifiers
);
23727 /* There are no template typedefs. */
23728 if (decl_spec_seq_has_spec_p (&decl_specifiers
, ds_typedef
))
23730 error_at (decl_spec_token_start
->location
,
23731 "template declaration of %<typedef%>");
23732 decl
= error_mark_node
;
23735 /* Gather up the access checks that occurred the
23736 decl-specifier-seq. */
23737 stop_deferring_access_checks ();
23739 /* Check for the declaration of a template class. */
23740 if (declares_class_or_enum
)
23742 if (cp_parser_declares_only_class_p (parser
))
23744 decl
= shadow_tag (&decl_specifiers
);
23749 friend template <typename T> struct A<T>::B;
23752 A<T>::B will be represented by a TYPENAME_TYPE, and
23753 therefore not recognized by shadow_tag. */
23754 if (friend_p
&& *friend_p
23756 && decl_specifiers
.type
23757 && TYPE_P (decl_specifiers
.type
))
23758 decl
= decl_specifiers
.type
;
23760 if (decl
&& decl
!= error_mark_node
)
23761 decl
= TYPE_NAME (decl
);
23763 decl
= error_mark_node
;
23765 /* Perform access checks for template parameters. */
23766 cp_parser_perform_template_parameter_access_checks (checks
);
23770 /* Complain about missing 'typename' or other invalid type names. */
23771 if (!decl_specifiers
.any_type_specifiers_p
23772 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
23774 /* cp_parser_parse_and_diagnose_invalid_type_name calls
23775 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
23776 the rest of this declaration. */
23777 decl
= error_mark_node
;
23781 /* If it's not a template class, try for a template function. If
23782 the next token is a `;', then this declaration does not declare
23783 anything. But, if there were errors in the decl-specifiers, then
23784 the error might well have come from an attempted class-specifier.
23785 In that case, there's no need to warn about a missing declarator. */
23787 && (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
)
23788 || decl_specifiers
.type
!= error_mark_node
))
23790 decl
= cp_parser_init_declarator (parser
,
23793 /*function_definition_allowed_p=*/true,
23795 declares_class_or_enum
,
23796 &function_definition_p
,
23799 /* 7.1.1-1 [dcl.stc]
23801 A storage-class-specifier shall not be specified in an explicit
23802 specialization... */
23804 && explicit_specialization_p
23805 && decl_specifiers
.storage_class
!= sc_none
)
23807 error_at (decl_spec_token_start
->location
,
23808 "explicit template specialization cannot have a storage class");
23809 decl
= error_mark_node
;
23812 if (decl
&& VAR_P (decl
))
23813 check_template_variable (decl
);
23816 /* Look for a trailing `;' after the declaration. */
23817 if (!function_definition_p
23818 && (decl
== error_mark_node
23819 || !cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
)))
23820 cp_parser_skip_to_end_of_block_or_statement (parser
);
23823 pop_deferring_access_checks ();
23825 /* Clear any current qualification; whatever comes next is the start
23826 of something new. */
23827 parser
->scope
= NULL_TREE
;
23828 parser
->qualifying_scope
= NULL_TREE
;
23829 parser
->object_scope
= NULL_TREE
;
23834 /* Parse a cast-expression that is not the operand of a unary "&". */
23837 cp_parser_simple_cast_expression (cp_parser
*parser
)
23839 return cp_parser_cast_expression (parser
, /*address_p=*/false,
23840 /*cast_p=*/false, /*decltype*/false, NULL
);
23843 /* Parse a functional cast to TYPE. Returns an expression
23844 representing the cast. */
23847 cp_parser_functional_cast (cp_parser
* parser
, tree type
)
23849 vec
<tree
, va_gc
> *vec
;
23850 tree expression_list
;
23855 type
= error_mark_node
;
23857 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
23859 cp_lexer_set_source_position (parser
->lexer
);
23860 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
23861 expression_list
= cp_parser_braced_list (parser
, &nonconst_p
);
23862 CONSTRUCTOR_IS_DIRECT_INIT (expression_list
) = 1;
23863 if (TREE_CODE (type
) == TYPE_DECL
)
23864 type
= TREE_TYPE (type
);
23865 return finish_compound_literal (type
, expression_list
,
23866 tf_warning_or_error
);
23870 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
23872 /*allow_expansion_p=*/true,
23873 /*non_constant_p=*/NULL
);
23875 expression_list
= error_mark_node
;
23878 expression_list
= build_tree_list_vec (vec
);
23879 release_tree_vector (vec
);
23882 cast
= build_functional_cast (type
, expression_list
,
23883 tf_warning_or_error
);
23884 /* [expr.const]/1: In an integral constant expression "only type
23885 conversions to integral or enumeration type can be used". */
23886 if (TREE_CODE (type
) == TYPE_DECL
)
23887 type
= TREE_TYPE (type
);
23888 if (cast
!= error_mark_node
23889 && !cast_valid_in_integral_constant_expression_p (type
)
23890 && cp_parser_non_integral_constant_expression (parser
,
23892 return error_mark_node
;
23896 /* Save the tokens that make up the body of a member function defined
23897 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
23898 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
23899 specifiers applied to the declaration. Returns the FUNCTION_DECL
23900 for the member function. */
23903 cp_parser_save_member_function_body (cp_parser
* parser
,
23904 cp_decl_specifier_seq
*decl_specifiers
,
23905 cp_declarator
*declarator
,
23912 /* Create the FUNCTION_DECL. */
23913 fn
= grokmethod (decl_specifiers
, declarator
, attributes
);
23914 cp_finalize_omp_declare_simd (parser
, fn
);
23915 /* If something went badly wrong, bail out now. */
23916 if (fn
== error_mark_node
)
23918 /* If there's a function-body, skip it. */
23919 if (cp_parser_token_starts_function_definition_p
23920 (cp_lexer_peek_token (parser
->lexer
)))
23921 cp_parser_skip_to_end_of_block_or_statement (parser
);
23922 return error_mark_node
;
23925 /* Remember it, if there default args to post process. */
23926 cp_parser_save_default_args (parser
, fn
);
23928 /* Save away the tokens that make up the body of the
23930 first
= parser
->lexer
->next_token
;
23931 /* Handle function try blocks. */
23932 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRY
))
23933 cp_lexer_consume_token (parser
->lexer
);
23934 /* We can have braced-init-list mem-initializers before the fn body. */
23935 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
23937 cp_lexer_consume_token (parser
->lexer
);
23938 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
23940 /* cache_group will stop after an un-nested { } pair, too. */
23941 if (cp_parser_cache_group (parser
, CPP_CLOSE_PAREN
, /*depth=*/0))
23944 /* variadic mem-inits have ... after the ')'. */
23945 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
23946 cp_lexer_consume_token (parser
->lexer
);
23949 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
23950 /* Handle function try blocks. */
23951 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CATCH
))
23952 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
23953 last
= parser
->lexer
->next_token
;
23955 /* Save away the inline definition; we will process it when the
23956 class is complete. */
23957 DECL_PENDING_INLINE_INFO (fn
) = cp_token_cache_new (first
, last
);
23958 DECL_PENDING_INLINE_P (fn
) = 1;
23960 /* We need to know that this was defined in the class, so that
23961 friend templates are handled correctly. */
23962 DECL_INITIALIZED_IN_CLASS_P (fn
) = 1;
23964 /* Add FN to the queue of functions to be parsed later. */
23965 vec_safe_push (unparsed_funs_with_definitions
, fn
);
23970 /* Save the tokens that make up the in-class initializer for a non-static
23971 data member. Returns a DEFAULT_ARG. */
23974 cp_parser_save_nsdmi (cp_parser
* parser
)
23976 return cp_parser_cache_defarg (parser
, /*nsdmi=*/true);
23979 /* Parse a template-argument-list, as well as the trailing ">" (but
23980 not the opening "<"). See cp_parser_template_argument_list for the
23984 cp_parser_enclosed_template_argument_list (cp_parser
* parser
)
23988 tree saved_qualifying_scope
;
23989 tree saved_object_scope
;
23990 bool saved_greater_than_is_operator_p
;
23991 int saved_unevaluated_operand
;
23992 int saved_inhibit_evaluation_warnings
;
23996 When parsing a template-id, the first non-nested `>' is taken as
23997 the end of the template-argument-list rather than a greater-than
23999 saved_greater_than_is_operator_p
24000 = parser
->greater_than_is_operator_p
;
24001 parser
->greater_than_is_operator_p
= false;
24002 /* Parsing the argument list may modify SCOPE, so we save it
24004 saved_scope
= parser
->scope
;
24005 saved_qualifying_scope
= parser
->qualifying_scope
;
24006 saved_object_scope
= parser
->object_scope
;
24007 /* We need to evaluate the template arguments, even though this
24008 template-id may be nested within a "sizeof". */
24009 saved_unevaluated_operand
= cp_unevaluated_operand
;
24010 cp_unevaluated_operand
= 0;
24011 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
24012 c_inhibit_evaluation_warnings
= 0;
24013 /* Parse the template-argument-list itself. */
24014 if (cp_lexer_next_token_is (parser
->lexer
, CPP_GREATER
)
24015 || cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
24016 arguments
= NULL_TREE
;
24018 arguments
= cp_parser_template_argument_list (parser
);
24019 /* Look for the `>' that ends the template-argument-list. If we find
24020 a '>>' instead, it's probably just a typo. */
24021 if (cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
24023 if (cxx_dialect
!= cxx98
)
24025 /* In C++0x, a `>>' in a template argument list or cast
24026 expression is considered to be two separate `>'
24027 tokens. So, change the current token to a `>', but don't
24028 consume it: it will be consumed later when the outer
24029 template argument list (or cast expression) is parsed.
24030 Note that this replacement of `>' for `>>' is necessary
24031 even if we are parsing tentatively: in the tentative
24032 case, after calling
24033 cp_parser_enclosed_template_argument_list we will always
24034 throw away all of the template arguments and the first
24035 closing `>', either because the template argument list
24036 was erroneous or because we are replacing those tokens
24037 with a CPP_TEMPLATE_ID token. The second `>' (which will
24038 not have been thrown away) is needed either to close an
24039 outer template argument list or to complete a new-style
24041 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
24042 token
->type
= CPP_GREATER
;
24044 else if (!saved_greater_than_is_operator_p
)
24046 /* If we're in a nested template argument list, the '>>' has
24047 to be a typo for '> >'. We emit the error message, but we
24048 continue parsing and we push a '>' as next token, so that
24049 the argument list will be parsed correctly. Note that the
24050 global source location is still on the token before the
24051 '>>', so we need to say explicitly where we want it. */
24052 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
24053 error_at (token
->location
, "%<>>%> should be %<> >%> "
24054 "within a nested template argument list");
24056 token
->type
= CPP_GREATER
;
24060 /* If this is not a nested template argument list, the '>>'
24061 is a typo for '>'. Emit an error message and continue.
24062 Same deal about the token location, but here we can get it
24063 right by consuming the '>>' before issuing the diagnostic. */
24064 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
24065 error_at (token
->location
,
24066 "spurious %<>>%>, use %<>%> to terminate "
24067 "a template argument list");
24071 cp_parser_skip_to_end_of_template_parameter_list (parser
);
24072 /* The `>' token might be a greater-than operator again now. */
24073 parser
->greater_than_is_operator_p
24074 = saved_greater_than_is_operator_p
;
24075 /* Restore the SAVED_SCOPE. */
24076 parser
->scope
= saved_scope
;
24077 parser
->qualifying_scope
= saved_qualifying_scope
;
24078 parser
->object_scope
= saved_object_scope
;
24079 cp_unevaluated_operand
= saved_unevaluated_operand
;
24080 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
24085 /* MEMBER_FUNCTION is a member function, or a friend. If default
24086 arguments, or the body of the function have not yet been parsed,
24090 cp_parser_late_parsing_for_member (cp_parser
* parser
, tree member_function
)
24092 timevar_push (TV_PARSE_INMETH
);
24093 /* If this member is a template, get the underlying
24095 if (DECL_FUNCTION_TEMPLATE_P (member_function
))
24096 member_function
= DECL_TEMPLATE_RESULT (member_function
);
24098 /* There should not be any class definitions in progress at this
24099 point; the bodies of members are only parsed outside of all class
24101 gcc_assert (parser
->num_classes_being_defined
== 0);
24102 /* While we're parsing the member functions we might encounter more
24103 classes. We want to handle them right away, but we don't want
24104 them getting mixed up with functions that are currently in the
24106 push_unparsed_function_queues (parser
);
24108 /* Make sure that any template parameters are in scope. */
24109 maybe_begin_member_template_processing (member_function
);
24111 /* If the body of the function has not yet been parsed, parse it
24113 if (DECL_PENDING_INLINE_P (member_function
))
24115 tree function_scope
;
24116 cp_token_cache
*tokens
;
24118 /* The function is no longer pending; we are processing it. */
24119 tokens
= DECL_PENDING_INLINE_INFO (member_function
);
24120 DECL_PENDING_INLINE_INFO (member_function
) = NULL
;
24121 DECL_PENDING_INLINE_P (member_function
) = 0;
24123 /* If this is a local class, enter the scope of the containing
24125 function_scope
= current_function_decl
;
24126 if (function_scope
)
24127 push_function_context ();
24129 /* Push the body of the function onto the lexer stack. */
24130 cp_parser_push_lexer_for_tokens (parser
, tokens
);
24132 /* Let the front end know that we going to be defining this
24134 start_preparsed_function (member_function
, NULL_TREE
,
24135 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
24137 /* Don't do access checking if it is a templated function. */
24138 if (processing_template_decl
)
24139 push_deferring_access_checks (dk_no_check
);
24141 /* #pragma omp declare reduction needs special parsing. */
24142 if (DECL_OMP_DECLARE_REDUCTION_P (member_function
))
24144 parser
->lexer
->in_pragma
= true;
24145 cp_parser_omp_declare_reduction_exprs (member_function
, parser
);
24146 finish_function (/*inline*/2);
24147 cp_check_omp_declare_reduction (member_function
);
24150 /* Now, parse the body of the function. */
24151 cp_parser_function_definition_after_declarator (parser
,
24152 /*inline_p=*/true);
24154 if (processing_template_decl
)
24155 pop_deferring_access_checks ();
24157 /* Leave the scope of the containing function. */
24158 if (function_scope
)
24159 pop_function_context ();
24160 cp_parser_pop_lexer (parser
);
24163 /* Remove any template parameters from the symbol table. */
24164 maybe_end_member_template_processing ();
24166 /* Restore the queue. */
24167 pop_unparsed_function_queues (parser
);
24168 timevar_pop (TV_PARSE_INMETH
);
24171 /* If DECL contains any default args, remember it on the unparsed
24172 functions queue. */
24175 cp_parser_save_default_args (cp_parser
* parser
, tree decl
)
24179 for (probe
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
24181 probe
= TREE_CHAIN (probe
))
24182 if (TREE_PURPOSE (probe
))
24184 cp_default_arg_entry entry
= {current_class_type
, decl
};
24185 vec_safe_push (unparsed_funs_with_default_args
, entry
);
24190 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
24191 which is either a FIELD_DECL or PARM_DECL. Parse it and return
24192 the result. For a PARM_DECL, PARMTYPE is the corresponding type
24193 from the parameter-type-list. */
24196 cp_parser_late_parse_one_default_arg (cp_parser
*parser
, tree decl
,
24197 tree default_arg
, tree parmtype
)
24199 cp_token_cache
*tokens
;
24203 if (default_arg
== error_mark_node
)
24204 return error_mark_node
;
24206 /* Push the saved tokens for the default argument onto the parser's
24208 tokens
= DEFARG_TOKENS (default_arg
);
24209 cp_parser_push_lexer_for_tokens (parser
, tokens
);
24211 start_lambda_scope (decl
);
24213 /* Parse the default argument. */
24214 parsed_arg
= cp_parser_initializer (parser
, &dummy
, &dummy
);
24215 if (BRACE_ENCLOSED_INITIALIZER_P (parsed_arg
))
24216 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
24218 finish_lambda_scope ();
24220 if (parsed_arg
== error_mark_node
)
24221 cp_parser_skip_to_end_of_statement (parser
);
24223 if (!processing_template_decl
)
24225 /* In a non-template class, check conversions now. In a template,
24226 we'll wait and instantiate these as needed. */
24227 if (TREE_CODE (decl
) == PARM_DECL
)
24228 parsed_arg
= check_default_argument (parmtype
, parsed_arg
,
24229 tf_warning_or_error
);
24231 parsed_arg
= digest_nsdmi_init (decl
, parsed_arg
);
24234 /* If the token stream has not been completely used up, then
24235 there was extra junk after the end of the default
24237 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
24239 if (TREE_CODE (decl
) == PARM_DECL
)
24240 cp_parser_error (parser
, "expected %<,%>");
24242 cp_parser_error (parser
, "expected %<;%>");
24245 /* Revert to the main lexer. */
24246 cp_parser_pop_lexer (parser
);
24251 /* FIELD is a non-static data member with an initializer which we saved for
24252 later; parse it now. */
24255 cp_parser_late_parsing_nsdmi (cp_parser
*parser
, tree field
)
24259 maybe_begin_member_template_processing (field
);
24261 push_unparsed_function_queues (parser
);
24262 def
= cp_parser_late_parse_one_default_arg (parser
, field
,
24263 DECL_INITIAL (field
),
24265 pop_unparsed_function_queues (parser
);
24267 maybe_end_member_template_processing ();
24269 DECL_INITIAL (field
) = def
;
24272 /* FN is a FUNCTION_DECL which may contains a parameter with an
24273 unparsed DEFAULT_ARG. Parse the default args now. This function
24274 assumes that the current scope is the scope in which the default
24275 argument should be processed. */
24278 cp_parser_late_parsing_default_args (cp_parser
*parser
, tree fn
)
24280 bool saved_local_variables_forbidden_p
;
24281 tree parm
, parmdecl
;
24283 /* While we're parsing the default args, we might (due to the
24284 statement expression extension) encounter more classes. We want
24285 to handle them right away, but we don't want them getting mixed
24286 up with default args that are currently in the queue. */
24287 push_unparsed_function_queues (parser
);
24289 /* Local variable names (and the `this' keyword) may not appear
24290 in a default argument. */
24291 saved_local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
24292 parser
->local_variables_forbidden_p
= true;
24294 push_defarg_context (fn
);
24296 for (parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
)),
24297 parmdecl
= DECL_ARGUMENTS (fn
);
24298 parm
&& parm
!= void_list_node
;
24299 parm
= TREE_CHAIN (parm
),
24300 parmdecl
= DECL_CHAIN (parmdecl
))
24302 tree default_arg
= TREE_PURPOSE (parm
);
24304 vec
<tree
, va_gc
> *insts
;
24311 if (TREE_CODE (default_arg
) != DEFAULT_ARG
)
24312 /* This can happen for a friend declaration for a function
24313 already declared with default arguments. */
24317 = cp_parser_late_parse_one_default_arg (parser
, parmdecl
,
24319 TREE_VALUE (parm
));
24320 if (parsed_arg
== error_mark_node
)
24325 TREE_PURPOSE (parm
) = parsed_arg
;
24327 /* Update any instantiations we've already created. */
24328 for (insts
= DEFARG_INSTANTIATIONS (default_arg
), ix
= 0;
24329 vec_safe_iterate (insts
, ix
, ©
); ix
++)
24330 TREE_PURPOSE (copy
) = parsed_arg
;
24333 pop_defarg_context ();
24335 /* Make sure no default arg is missing. */
24336 check_default_args (fn
);
24338 /* Restore the state of local_variables_forbidden_p. */
24339 parser
->local_variables_forbidden_p
= saved_local_variables_forbidden_p
;
24341 /* Restore the queue. */
24342 pop_unparsed_function_queues (parser
);
24345 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
24347 sizeof ... ( identifier )
24349 where the 'sizeof' token has already been consumed. */
24352 cp_parser_sizeof_pack (cp_parser
*parser
)
24354 /* Consume the `...'. */
24355 cp_lexer_consume_token (parser
->lexer
);
24356 maybe_warn_variadic_templates ();
24358 bool paren
= cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
);
24360 cp_lexer_consume_token (parser
->lexer
);
24362 permerror (cp_lexer_peek_token (parser
->lexer
)->location
,
24363 "%<sizeof...%> argument must be surrounded by parentheses");
24365 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
24366 tree name
= cp_parser_identifier (parser
);
24367 if (name
== error_mark_node
)
24368 return error_mark_node
;
24369 /* The name is not qualified. */
24370 parser
->scope
= NULL_TREE
;
24371 parser
->qualifying_scope
= NULL_TREE
;
24372 parser
->object_scope
= NULL_TREE
;
24373 tree expr
= cp_parser_lookup_name_simple (parser
, name
, token
->location
);
24374 if (expr
== error_mark_node
)
24375 cp_parser_name_lookup_error (parser
, name
, expr
, NLE_NULL
,
24377 if (TREE_CODE (expr
) == TYPE_DECL
)
24378 expr
= TREE_TYPE (expr
);
24379 else if (TREE_CODE (expr
) == CONST_DECL
)
24380 expr
= DECL_INITIAL (expr
);
24381 expr
= make_pack_expansion (expr
);
24384 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
24389 /* Parse the operand of `sizeof' (or a similar operator). Returns
24390 either a TYPE or an expression, depending on the form of the
24391 input. The KEYWORD indicates which kind of expression we have
24395 cp_parser_sizeof_operand (cp_parser
* parser
, enum rid keyword
)
24397 tree expr
= NULL_TREE
;
24398 const char *saved_message
;
24400 bool saved_integral_constant_expression_p
;
24401 bool saved_non_integral_constant_expression_p
;
24403 /* If it's a `...', then we are computing the length of a parameter
24405 if (keyword
== RID_SIZEOF
24406 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
24407 return cp_parser_sizeof_pack (parser
);
24409 /* Types cannot be defined in a `sizeof' expression. Save away the
24411 saved_message
= parser
->type_definition_forbidden_message
;
24412 /* And create the new one. */
24413 tmp
= concat ("types may not be defined in %<",
24414 IDENTIFIER_POINTER (ridpointers
[keyword
]),
24415 "%> expressions", NULL
);
24416 parser
->type_definition_forbidden_message
= tmp
;
24418 /* The restrictions on constant-expressions do not apply inside
24419 sizeof expressions. */
24420 saved_integral_constant_expression_p
24421 = parser
->integral_constant_expression_p
;
24422 saved_non_integral_constant_expression_p
24423 = parser
->non_integral_constant_expression_p
;
24424 parser
->integral_constant_expression_p
= false;
24426 /* Do not actually evaluate the expression. */
24427 ++cp_unevaluated_operand
;
24428 ++c_inhibit_evaluation_warnings
;
24429 /* If it's a `(', then we might be looking at the type-id
24431 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
24433 tree type
= NULL_TREE
;
24435 /* We can't be sure yet whether we're looking at a type-id or an
24437 cp_parser_parse_tentatively (parser
);
24438 /* Note: as a GNU Extension, compound literals are considered
24439 postfix-expressions as they are in C99, so they are valid
24440 arguments to sizeof. See comment in cp_parser_cast_expression
24442 if (cp_parser_compound_literal_p (parser
))
24443 cp_parser_simulate_error (parser
);
24446 bool saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
24447 parser
->in_type_id_in_expr_p
= true;
24448 /* Look for the type-id. */
24449 type
= cp_parser_type_id (parser
);
24450 /* Look for the closing `)'. */
24451 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
24452 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
24455 /* If all went well, then we're done. */
24456 if (cp_parser_parse_definitely (parser
))
24458 cp_decl_specifier_seq decl_specs
;
24460 /* Build a trivial decl-specifier-seq. */
24461 clear_decl_specs (&decl_specs
);
24462 decl_specs
.type
= type
;
24464 /* Call grokdeclarator to figure out what type this is. */
24465 expr
= grokdeclarator (NULL
,
24469 /*attrlist=*/NULL
);
24473 /* If the type-id production did not work out, then we must be
24474 looking at the unary-expression production. */
24476 expr
= cp_parser_unary_expression (parser
);
24478 /* Go back to evaluating expressions. */
24479 --cp_unevaluated_operand
;
24480 --c_inhibit_evaluation_warnings
;
24482 /* Free the message we created. */
24484 /* And restore the old one. */
24485 parser
->type_definition_forbidden_message
= saved_message
;
24486 parser
->integral_constant_expression_p
24487 = saved_integral_constant_expression_p
;
24488 parser
->non_integral_constant_expression_p
24489 = saved_non_integral_constant_expression_p
;
24494 /* If the current declaration has no declarator, return true. */
24497 cp_parser_declares_only_class_p (cp_parser
*parser
)
24499 /* If the next token is a `;' or a `,' then there is no
24501 return (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
24502 || cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
));
24505 /* Update the DECL_SPECS to reflect the storage class indicated by
24509 cp_parser_set_storage_class (cp_parser
*parser
,
24510 cp_decl_specifier_seq
*decl_specs
,
24514 cp_storage_class storage_class
;
24516 if (parser
->in_unbraced_linkage_specification_p
)
24518 error_at (token
->location
, "invalid use of %qD in linkage specification",
24519 ridpointers
[keyword
]);
24522 else if (decl_specs
->storage_class
!= sc_none
)
24524 decl_specs
->conflicting_specifiers_p
= true;
24528 if ((keyword
== RID_EXTERN
|| keyword
== RID_STATIC
)
24529 && decl_spec_seq_has_spec_p (decl_specs
, ds_thread
)
24530 && decl_specs
->gnu_thread_keyword_p
)
24532 pedwarn (decl_specs
->locations
[ds_thread
], 0,
24533 "%<__thread%> before %qD", ridpointers
[keyword
]);
24539 storage_class
= sc_auto
;
24542 storage_class
= sc_register
;
24545 storage_class
= sc_static
;
24548 storage_class
= sc_extern
;
24551 storage_class
= sc_mutable
;
24554 gcc_unreachable ();
24556 decl_specs
->storage_class
= storage_class
;
24557 set_and_check_decl_spec_loc (decl_specs
, ds_storage_class
, token
);
24559 /* A storage class specifier cannot be applied alongside a typedef
24560 specifier. If there is a typedef specifier present then set
24561 conflicting_specifiers_p which will trigger an error later
24562 on in grokdeclarator. */
24563 if (decl_spec_seq_has_spec_p (decl_specs
, ds_typedef
))
24564 decl_specs
->conflicting_specifiers_p
= true;
24567 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
24568 is true, the type is a class or enum definition. */
24571 cp_parser_set_decl_spec_type (cp_decl_specifier_seq
*decl_specs
,
24574 bool type_definition_p
)
24576 decl_specs
->any_specifiers_p
= true;
24578 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
24579 (with, for example, in "typedef int wchar_t;") we remember that
24580 this is what happened. In system headers, we ignore these
24581 declarations so that G++ can work with system headers that are not
24583 if (decl_spec_seq_has_spec_p (decl_specs
, ds_typedef
)
24584 && !type_definition_p
24585 && (type_spec
== boolean_type_node
24586 || type_spec
== char16_type_node
24587 || type_spec
== char32_type_node
24588 || type_spec
== wchar_type_node
)
24589 && (decl_specs
->type
24590 || decl_spec_seq_has_spec_p (decl_specs
, ds_long
)
24591 || decl_spec_seq_has_spec_p (decl_specs
, ds_short
)
24592 || decl_spec_seq_has_spec_p (decl_specs
, ds_unsigned
)
24593 || decl_spec_seq_has_spec_p (decl_specs
, ds_signed
)))
24595 decl_specs
->redefined_builtin_type
= type_spec
;
24596 set_and_check_decl_spec_loc (decl_specs
,
24597 ds_redefined_builtin_type_spec
,
24599 if (!decl_specs
->type
)
24601 decl_specs
->type
= type_spec
;
24602 decl_specs
->type_definition_p
= false;
24603 set_and_check_decl_spec_loc (decl_specs
,ds_type_spec
, token
);
24606 else if (decl_specs
->type
)
24607 decl_specs
->multiple_types_p
= true;
24610 decl_specs
->type
= type_spec
;
24611 decl_specs
->type_definition_p
= type_definition_p
;
24612 decl_specs
->redefined_builtin_type
= NULL_TREE
;
24613 set_and_check_decl_spec_loc (decl_specs
, ds_type_spec
, token
);
24617 /* True iff TOKEN is the GNU keyword __thread. */
24620 token_is__thread (cp_token
*token
)
24622 gcc_assert (token
->keyword
== RID_THREAD
);
24623 return !strcmp (IDENTIFIER_POINTER (token
->u
.value
), "__thread");
24626 /* Set the location for a declarator specifier and check if it is
24629 DECL_SPECS is the sequence of declarator specifiers onto which to
24632 DS is the single declarator specifier to set which location is to
24633 be set onto the existing sequence of declarators.
24635 LOCATION is the location for the declarator specifier to
24639 set_and_check_decl_spec_loc (cp_decl_specifier_seq
*decl_specs
,
24640 cp_decl_spec ds
, cp_token
*token
)
24642 gcc_assert (ds
< ds_last
);
24644 if (decl_specs
== NULL
)
24647 source_location location
= token
->location
;
24649 if (decl_specs
->locations
[ds
] == 0)
24651 decl_specs
->locations
[ds
] = location
;
24652 if (ds
== ds_thread
)
24653 decl_specs
->gnu_thread_keyword_p
= token_is__thread (token
);
24659 if (decl_specs
->locations
[ds_long_long
] != 0)
24660 error_at (location
,
24661 "%<long long long%> is too long for GCC");
24664 decl_specs
->locations
[ds_long_long
] = location
;
24665 pedwarn_cxx98 (location
,
24667 "ISO C++ 1998 does not support %<long long%>");
24670 else if (ds
== ds_thread
)
24672 bool gnu
= token_is__thread (token
);
24673 if (gnu
!= decl_specs
->gnu_thread_keyword_p
)
24674 error_at (location
,
24675 "both %<__thread%> and %<thread_local%> specified");
24677 error_at (location
, "duplicate %qD", token
->u
.value
);
24681 static const char *const decl_spec_names
[] = {
24698 error_at (location
,
24699 "duplicate %qs", decl_spec_names
[ds
]);
24704 /* Return true iff the declarator specifier DS is present in the
24705 sequence of declarator specifiers DECL_SPECS. */
24708 decl_spec_seq_has_spec_p (const cp_decl_specifier_seq
* decl_specs
,
24711 gcc_assert (ds
< ds_last
);
24713 if (decl_specs
== NULL
)
24716 return decl_specs
->locations
[ds
] != 0;
24719 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
24720 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
24723 cp_parser_friend_p (const cp_decl_specifier_seq
*decl_specifiers
)
24725 return decl_spec_seq_has_spec_p (decl_specifiers
, ds_friend
);
24728 /* Issue an error message indicating that TOKEN_DESC was expected.
24729 If KEYWORD is true, it indicated this function is called by
24730 cp_parser_require_keword and the required token can only be
24731 a indicated keyword. */
24734 cp_parser_required_error (cp_parser
*parser
,
24735 required_token token_desc
,
24738 switch (token_desc
)
24741 cp_parser_error (parser
, "expected %<new%>");
24744 cp_parser_error (parser
, "expected %<delete%>");
24747 cp_parser_error (parser
, "expected %<return%>");
24750 cp_parser_error (parser
, "expected %<while%>");
24753 cp_parser_error (parser
, "expected %<extern%>");
24755 case RT_STATIC_ASSERT
:
24756 cp_parser_error (parser
, "expected %<static_assert%>");
24759 cp_parser_error (parser
, "expected %<decltype%>");
24762 cp_parser_error (parser
, "expected %<operator%>");
24765 cp_parser_error (parser
, "expected %<class%>");
24768 cp_parser_error (parser
, "expected %<template%>");
24771 cp_parser_error (parser
, "expected %<namespace%>");
24774 cp_parser_error (parser
, "expected %<using%>");
24777 cp_parser_error (parser
, "expected %<asm%>");
24780 cp_parser_error (parser
, "expected %<try%>");
24783 cp_parser_error (parser
, "expected %<catch%>");
24786 cp_parser_error (parser
, "expected %<throw%>");
24789 cp_parser_error (parser
, "expected %<__label__%>");
24792 cp_parser_error (parser
, "expected %<@try%>");
24794 case RT_AT_SYNCHRONIZED
:
24795 cp_parser_error (parser
, "expected %<@synchronized%>");
24798 cp_parser_error (parser
, "expected %<@throw%>");
24800 case RT_TRANSACTION_ATOMIC
:
24801 cp_parser_error (parser
, "expected %<__transaction_atomic%>");
24803 case RT_TRANSACTION_RELAXED
:
24804 cp_parser_error (parser
, "expected %<__transaction_relaxed%>");
24811 switch (token_desc
)
24814 cp_parser_error (parser
, "expected %<;%>");
24816 case RT_OPEN_PAREN
:
24817 cp_parser_error (parser
, "expected %<(%>");
24819 case RT_CLOSE_BRACE
:
24820 cp_parser_error (parser
, "expected %<}%>");
24822 case RT_OPEN_BRACE
:
24823 cp_parser_error (parser
, "expected %<{%>");
24825 case RT_CLOSE_SQUARE
:
24826 cp_parser_error (parser
, "expected %<]%>");
24828 case RT_OPEN_SQUARE
:
24829 cp_parser_error (parser
, "expected %<[%>");
24832 cp_parser_error (parser
, "expected %<,%>");
24835 cp_parser_error (parser
, "expected %<::%>");
24838 cp_parser_error (parser
, "expected %<<%>");
24841 cp_parser_error (parser
, "expected %<>%>");
24844 cp_parser_error (parser
, "expected %<=%>");
24847 cp_parser_error (parser
, "expected %<...%>");
24850 cp_parser_error (parser
, "expected %<*%>");
24853 cp_parser_error (parser
, "expected %<~%>");
24856 cp_parser_error (parser
, "expected %<:%>");
24858 case RT_COLON_SCOPE
:
24859 cp_parser_error (parser
, "expected %<:%> or %<::%>");
24861 case RT_CLOSE_PAREN
:
24862 cp_parser_error (parser
, "expected %<)%>");
24864 case RT_COMMA_CLOSE_PAREN
:
24865 cp_parser_error (parser
, "expected %<,%> or %<)%>");
24867 case RT_PRAGMA_EOL
:
24868 cp_parser_error (parser
, "expected end of line");
24871 cp_parser_error (parser
, "expected identifier");
24874 cp_parser_error (parser
, "expected selection-statement");
24876 case RT_INTERATION
:
24877 cp_parser_error (parser
, "expected iteration-statement");
24880 cp_parser_error (parser
, "expected jump-statement");
24883 cp_parser_error (parser
, "expected class-key");
24885 case RT_CLASS_TYPENAME_TEMPLATE
:
24886 cp_parser_error (parser
,
24887 "expected %<class%>, %<typename%>, or %<template%>");
24890 gcc_unreachable ();
24894 gcc_unreachable ();
24899 /* If the next token is of the indicated TYPE, consume it. Otherwise,
24900 issue an error message indicating that TOKEN_DESC was expected.
24902 Returns the token consumed, if the token had the appropriate type.
24903 Otherwise, returns NULL. */
24906 cp_parser_require (cp_parser
* parser
,
24907 enum cpp_ttype type
,
24908 required_token token_desc
)
24910 if (cp_lexer_next_token_is (parser
->lexer
, type
))
24911 return cp_lexer_consume_token (parser
->lexer
);
24914 /* Output the MESSAGE -- unless we're parsing tentatively. */
24915 if (!cp_parser_simulate_error (parser
))
24916 cp_parser_required_error (parser
, token_desc
, /*keyword=*/false);
24921 /* An error message is produced if the next token is not '>'.
24922 All further tokens are skipped until the desired token is
24923 found or '{', '}', ';' or an unbalanced ')' or ']'. */
24926 cp_parser_skip_to_end_of_template_parameter_list (cp_parser
* parser
)
24928 /* Current level of '< ... >'. */
24929 unsigned level
= 0;
24930 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
24931 unsigned nesting_depth
= 0;
24933 /* Are we ready, yet? If not, issue error message. */
24934 if (cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
))
24937 /* Skip tokens until the desired token is found. */
24940 /* Peek at the next token. */
24941 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
24944 if (!nesting_depth
)
24949 if (cxx_dialect
== cxx98
)
24950 /* C++0x views the `>>' operator as two `>' tokens, but
24953 else if (!nesting_depth
&& level
-- == 0)
24955 /* We've hit a `>>' where the first `>' closes the
24956 template argument list, and the second `>' is
24957 spurious. Just consume the `>>' and stop; we've
24958 already produced at least one error. */
24959 cp_lexer_consume_token (parser
->lexer
);
24962 /* Fall through for C++0x, so we handle the second `>' in
24966 if (!nesting_depth
&& level
-- == 0)
24968 /* We've reached the token we want, consume it and stop. */
24969 cp_lexer_consume_token (parser
->lexer
);
24974 case CPP_OPEN_PAREN
:
24975 case CPP_OPEN_SQUARE
:
24979 case CPP_CLOSE_PAREN
:
24980 case CPP_CLOSE_SQUARE
:
24981 if (nesting_depth
-- == 0)
24986 case CPP_PRAGMA_EOL
:
24987 case CPP_SEMICOLON
:
24988 case CPP_OPEN_BRACE
:
24989 case CPP_CLOSE_BRACE
:
24990 /* The '>' was probably forgotten, don't look further. */
24997 /* Consume this token. */
24998 cp_lexer_consume_token (parser
->lexer
);
25002 /* If the next token is the indicated keyword, consume it. Otherwise,
25003 issue an error message indicating that TOKEN_DESC was expected.
25005 Returns the token consumed, if the token had the appropriate type.
25006 Otherwise, returns NULL. */
25009 cp_parser_require_keyword (cp_parser
* parser
,
25011 required_token token_desc
)
25013 cp_token
*token
= cp_parser_require (parser
, CPP_KEYWORD
, token_desc
);
25015 if (token
&& token
->keyword
!= keyword
)
25017 cp_parser_required_error (parser
, token_desc
, /*keyword=*/true);
25024 /* Returns TRUE iff TOKEN is a token that can begin the body of a
25025 function-definition. */
25028 cp_parser_token_starts_function_definition_p (cp_token
* token
)
25030 return (/* An ordinary function-body begins with an `{'. */
25031 token
->type
== CPP_OPEN_BRACE
25032 /* A ctor-initializer begins with a `:'. */
25033 || token
->type
== CPP_COLON
25034 /* A function-try-block begins with `try'. */
25035 || token
->keyword
== RID_TRY
25036 /* A function-transaction-block begins with `__transaction_atomic'
25037 or `__transaction_relaxed'. */
25038 || token
->keyword
== RID_TRANSACTION_ATOMIC
25039 || token
->keyword
== RID_TRANSACTION_RELAXED
25040 /* The named return value extension begins with `return'. */
25041 || token
->keyword
== RID_RETURN
);
25044 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
25048 cp_parser_next_token_starts_class_definition_p (cp_parser
*parser
)
25052 token
= cp_lexer_peek_token (parser
->lexer
);
25053 return (token
->type
== CPP_OPEN_BRACE
25054 || (token
->type
== CPP_COLON
25055 && !parser
->colon_doesnt_start_class_def_p
));
25058 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
25059 C++0x) ending a template-argument. */
25062 cp_parser_next_token_ends_template_argument_p (cp_parser
*parser
)
25066 token
= cp_lexer_peek_token (parser
->lexer
);
25067 return (token
->type
== CPP_COMMA
25068 || token
->type
== CPP_GREATER
25069 || token
->type
== CPP_ELLIPSIS
25070 || ((cxx_dialect
!= cxx98
) && token
->type
== CPP_RSHIFT
));
25073 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
25074 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
25077 cp_parser_nth_token_starts_template_argument_list_p (cp_parser
* parser
,
25082 token
= cp_lexer_peek_nth_token (parser
->lexer
, n
);
25083 if (token
->type
== CPP_LESS
)
25085 /* Check for the sequence `<::' in the original code. It would be lexed as
25086 `[:', where `[' is a digraph, and there is no whitespace before
25088 if (token
->type
== CPP_OPEN_SQUARE
&& token
->flags
& DIGRAPH
)
25091 token2
= cp_lexer_peek_nth_token (parser
->lexer
, n
+1);
25092 if (token2
->type
== CPP_COLON
&& !(token2
->flags
& PREV_WHITE
))
25098 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
25099 or none_type otherwise. */
25101 static enum tag_types
25102 cp_parser_token_is_class_key (cp_token
* token
)
25104 switch (token
->keyword
)
25109 return record_type
;
25118 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
25119 or none_type otherwise or if the token is null. */
25121 static enum tag_types
25122 cp_parser_token_is_type_parameter_key (cp_token
* token
)
25127 switch (token
->keyword
)
25132 return typename_type
;
25139 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
25142 cp_parser_check_class_key (enum tag_types class_key
, tree type
)
25144 if (type
== error_mark_node
)
25146 if ((TREE_CODE (type
) == UNION_TYPE
) != (class_key
== union_type
))
25148 if (permerror (input_location
, "%qs tag used in naming %q#T",
25149 class_key
== union_type
? "union"
25150 : class_key
== record_type
? "struct" : "class",
25152 inform (DECL_SOURCE_LOCATION (TYPE_NAME (type
)),
25153 "%q#T was previously declared here", type
);
25157 /* Issue an error message if DECL is redeclared with different
25158 access than its original declaration [class.access.spec/3].
25159 This applies to nested classes and nested class templates.
25163 cp_parser_check_access_in_redeclaration (tree decl
, location_t location
)
25165 if (!decl
|| !CLASS_TYPE_P (TREE_TYPE (decl
)))
25168 if ((TREE_PRIVATE (decl
)
25169 != (current_access_specifier
== access_private_node
))
25170 || (TREE_PROTECTED (decl
)
25171 != (current_access_specifier
== access_protected_node
)))
25172 error_at (location
, "%qD redeclared with different access", decl
);
25175 /* Look for the `template' keyword, as a syntactic disambiguator.
25176 Return TRUE iff it is present, in which case it will be
25180 cp_parser_optional_template_keyword (cp_parser
*parser
)
25182 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
25184 /* In C++98 the `template' keyword can only be used within templates;
25185 outside templates the parser can always figure out what is a
25186 template and what is not. In C++11, per the resolution of DR 468,
25187 `template' is allowed in cases where it is not strictly necessary. */
25188 if (!processing_template_decl
25189 && pedantic
&& cxx_dialect
== cxx98
)
25191 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
25192 pedwarn (token
->location
, OPT_Wpedantic
,
25193 "in C++98 %<template%> (as a disambiguator) is only "
25194 "allowed within templates");
25195 /* If this part of the token stream is rescanned, the same
25196 error message would be generated. So, we purge the token
25197 from the stream. */
25198 cp_lexer_purge_token (parser
->lexer
);
25203 /* Consume the `template' keyword. */
25204 cp_lexer_consume_token (parser
->lexer
);
25211 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
25212 set PARSER->SCOPE, and perform other related actions. */
25215 cp_parser_pre_parsed_nested_name_specifier (cp_parser
*parser
)
25218 struct tree_check
*check_value
;
25219 deferred_access_check
*chk
;
25220 vec
<deferred_access_check
, va_gc
> *checks
;
25222 /* Get the stored value. */
25223 check_value
= cp_lexer_consume_token (parser
->lexer
)->u
.tree_check_value
;
25224 /* Perform any access checks that were deferred. */
25225 checks
= check_value
->checks
;
25228 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
25229 perform_or_defer_access_check (chk
->binfo
,
25231 chk
->diag_decl
, tf_warning_or_error
);
25233 /* Set the scope from the stored value. */
25234 parser
->scope
= check_value
->value
;
25235 parser
->qualifying_scope
= check_value
->qualifying_scope
;
25236 parser
->object_scope
= NULL_TREE
;
25239 /* Consume tokens up through a non-nested END token. Returns TRUE if we
25240 encounter the end of a block before what we were looking for. */
25243 cp_parser_cache_group (cp_parser
*parser
,
25244 enum cpp_ttype end
,
25249 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
25251 /* Abort a parenthesized expression if we encounter a semicolon. */
25252 if ((end
== CPP_CLOSE_PAREN
|| depth
== 0)
25253 && token
->type
== CPP_SEMICOLON
)
25255 /* If we've reached the end of the file, stop. */
25256 if (token
->type
== CPP_EOF
25257 || (end
!= CPP_PRAGMA_EOL
25258 && token
->type
== CPP_PRAGMA_EOL
))
25260 if (token
->type
== CPP_CLOSE_BRACE
&& depth
== 0)
25261 /* We've hit the end of an enclosing block, so there's been some
25262 kind of syntax error. */
25265 /* Consume the token. */
25266 cp_lexer_consume_token (parser
->lexer
);
25267 /* See if it starts a new group. */
25268 if (token
->type
== CPP_OPEN_BRACE
)
25270 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, depth
+ 1);
25271 /* In theory this should probably check end == '}', but
25272 cp_parser_save_member_function_body needs it to exit
25273 after either '}' or ')' when called with ')'. */
25277 else if (token
->type
== CPP_OPEN_PAREN
)
25279 cp_parser_cache_group (parser
, CPP_CLOSE_PAREN
, depth
+ 1);
25280 if (depth
== 0 && end
== CPP_CLOSE_PAREN
)
25283 else if (token
->type
== CPP_PRAGMA
)
25284 cp_parser_cache_group (parser
, CPP_PRAGMA_EOL
, depth
+ 1);
25285 else if (token
->type
== end
)
25290 /* Like above, for caching a default argument or NSDMI. Both of these are
25291 terminated by a non-nested comma, but it can be unclear whether or not a
25292 comma is nested in a template argument list unless we do more parsing.
25293 In order to handle this ambiguity, when we encounter a ',' after a '<'
25294 we try to parse what follows as a parameter-declaration-list (in the
25295 case of a default argument) or a member-declarator (in the case of an
25296 NSDMI). If that succeeds, then we stop caching. */
25299 cp_parser_cache_defarg (cp_parser
*parser
, bool nsdmi
)
25301 unsigned depth
= 0;
25302 int maybe_template_id
= 0;
25303 cp_token
*first_token
;
25305 tree default_argument
;
25307 /* Add tokens until we have processed the entire default
25308 argument. We add the range [first_token, token). */
25309 first_token
= cp_lexer_peek_token (parser
->lexer
);
25310 if (first_token
->type
== CPP_OPEN_BRACE
)
25312 /* For list-initialization, this is straightforward. */
25313 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
25314 token
= cp_lexer_peek_token (parser
->lexer
);
25320 /* Peek at the next token. */
25321 token
= cp_lexer_peek_token (parser
->lexer
);
25322 /* What we do depends on what token we have. */
25323 switch (token
->type
)
25325 /* In valid code, a default argument must be
25326 immediately followed by a `,' `)', or `...'. */
25328 if (depth
== 0 && maybe_template_id
)
25330 /* If we've seen a '<', we might be in a
25331 template-argument-list. Until Core issue 325 is
25332 resolved, we don't know how this situation ought
25333 to be handled, so try to DTRT. We check whether
25334 what comes after the comma is a valid parameter
25335 declaration list. If it is, then the comma ends
25336 the default argument; otherwise the default
25337 argument continues. */
25338 bool error
= false;
25340 /* Set ITALP so cp_parser_parameter_declaration_list
25341 doesn't decide to commit to this parse. */
25342 bool saved_italp
= parser
->in_template_argument_list_p
;
25343 parser
->in_template_argument_list_p
= true;
25345 cp_parser_parse_tentatively (parser
);
25346 cp_lexer_consume_token (parser
->lexer
);
25350 int ctor_dtor_or_conv_p
;
25351 cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
25352 &ctor_dtor_or_conv_p
,
25353 /*parenthesized_p=*/NULL
,
25355 /*friend_p=*/false);
25359 begin_scope (sk_function_parms
, NULL_TREE
);
25360 cp_parser_parameter_declaration_list (parser
, &error
);
25361 pop_bindings_and_leave_scope ();
25363 if (!cp_parser_error_occurred (parser
) && !error
)
25365 cp_parser_abort_tentative_parse (parser
);
25367 parser
->in_template_argument_list_p
= saved_italp
;
25370 case CPP_CLOSE_PAREN
:
25372 /* If we run into a non-nested `;', `}', or `]',
25373 then the code is invalid -- but the default
25374 argument is certainly over. */
25375 case CPP_SEMICOLON
:
25376 case CPP_CLOSE_BRACE
:
25377 case CPP_CLOSE_SQUARE
:
25379 /* Handle correctly int n = sizeof ... ( p ); */
25380 && token
->type
!= CPP_ELLIPSIS
)
25382 /* Update DEPTH, if necessary. */
25383 else if (token
->type
== CPP_CLOSE_PAREN
25384 || token
->type
== CPP_CLOSE_BRACE
25385 || token
->type
== CPP_CLOSE_SQUARE
)
25389 case CPP_OPEN_PAREN
:
25390 case CPP_OPEN_SQUARE
:
25391 case CPP_OPEN_BRACE
:
25397 /* This might be the comparison operator, or it might
25398 start a template argument list. */
25399 ++maybe_template_id
;
25403 if (cxx_dialect
== cxx98
)
25405 /* Fall through for C++0x, which treats the `>>'
25406 operator like two `>' tokens in certain
25412 /* This might be an operator, or it might close a
25413 template argument list. But if a previous '<'
25414 started a template argument list, this will have
25415 closed it, so we can't be in one anymore. */
25416 maybe_template_id
-= 1 + (token
->type
== CPP_RSHIFT
);
25417 if (maybe_template_id
< 0)
25418 maybe_template_id
= 0;
25422 /* If we run out of tokens, issue an error message. */
25424 case CPP_PRAGMA_EOL
:
25425 error_at (token
->location
, "file ends in default argument");
25431 /* In these cases, we should look for template-ids.
25432 For example, if the default argument is
25433 `X<int, double>()', we need to do name lookup to
25434 figure out whether or not `X' is a template; if
25435 so, the `,' does not end the default argument.
25437 That is not yet done. */
25444 /* If we've reached the end, stop. */
25448 /* Add the token to the token block. */
25449 token
= cp_lexer_consume_token (parser
->lexer
);
25452 /* Create a DEFAULT_ARG to represent the unparsed default
25454 default_argument
= make_node (DEFAULT_ARG
);
25455 DEFARG_TOKENS (default_argument
)
25456 = cp_token_cache_new (first_token
, token
);
25457 DEFARG_INSTANTIATIONS (default_argument
) = NULL
;
25459 return default_argument
;
25462 /* Begin parsing tentatively. We always save tokens while parsing
25463 tentatively so that if the tentative parsing fails we can restore the
25467 cp_parser_parse_tentatively (cp_parser
* parser
)
25469 /* Enter a new parsing context. */
25470 parser
->context
= cp_parser_context_new (parser
->context
);
25471 /* Begin saving tokens. */
25472 cp_lexer_save_tokens (parser
->lexer
);
25473 /* In order to avoid repetitive access control error messages,
25474 access checks are queued up until we are no longer parsing
25476 push_deferring_access_checks (dk_deferred
);
25479 /* Commit to the currently active tentative parse. */
25482 cp_parser_commit_to_tentative_parse (cp_parser
* parser
)
25484 cp_parser_context
*context
;
25487 /* Mark all of the levels as committed. */
25488 lexer
= parser
->lexer
;
25489 for (context
= parser
->context
; context
->next
; context
= context
->next
)
25491 if (context
->status
== CP_PARSER_STATUS_KIND_COMMITTED
)
25493 context
->status
= CP_PARSER_STATUS_KIND_COMMITTED
;
25494 while (!cp_lexer_saving_tokens (lexer
))
25495 lexer
= lexer
->next
;
25496 cp_lexer_commit_tokens (lexer
);
25500 /* Commit to the topmost currently active tentative parse.
25502 Note that this function shouldn't be called when there are
25503 irreversible side-effects while in a tentative state. For
25504 example, we shouldn't create a permanent entry in the symbol
25505 table, or issue an error message that might not apply if the
25506 tentative parse is aborted. */
25509 cp_parser_commit_to_topmost_tentative_parse (cp_parser
* parser
)
25511 cp_parser_context
*context
= parser
->context
;
25512 cp_lexer
*lexer
= parser
->lexer
;
25516 if (context
->status
== CP_PARSER_STATUS_KIND_COMMITTED
)
25518 context
->status
= CP_PARSER_STATUS_KIND_COMMITTED
;
25520 while (!cp_lexer_saving_tokens (lexer
))
25521 lexer
= lexer
->next
;
25522 cp_lexer_commit_tokens (lexer
);
25526 /* Abort the currently active tentative parse. All consumed tokens
25527 will be rolled back, and no diagnostics will be issued. */
25530 cp_parser_abort_tentative_parse (cp_parser
* parser
)
25532 gcc_assert (parser
->context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
25533 || errorcount
> 0);
25534 cp_parser_simulate_error (parser
);
25535 /* Now, pretend that we want to see if the construct was
25536 successfully parsed. */
25537 cp_parser_parse_definitely (parser
);
25540 /* Stop parsing tentatively. If a parse error has occurred, restore the
25541 token stream. Otherwise, commit to the tokens we have consumed.
25542 Returns true if no error occurred; false otherwise. */
25545 cp_parser_parse_definitely (cp_parser
* parser
)
25547 bool error_occurred
;
25548 cp_parser_context
*context
;
25550 /* Remember whether or not an error occurred, since we are about to
25551 destroy that information. */
25552 error_occurred
= cp_parser_error_occurred (parser
);
25553 /* Remove the topmost context from the stack. */
25554 context
= parser
->context
;
25555 parser
->context
= context
->next
;
25556 /* If no parse errors occurred, commit to the tentative parse. */
25557 if (!error_occurred
)
25559 /* Commit to the tokens read tentatively, unless that was
25561 if (context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
)
25562 cp_lexer_commit_tokens (parser
->lexer
);
25564 pop_to_parent_deferring_access_checks ();
25566 /* Otherwise, if errors occurred, roll back our state so that things
25567 are just as they were before we began the tentative parse. */
25570 cp_lexer_rollback_tokens (parser
->lexer
);
25571 pop_deferring_access_checks ();
25573 /* Add the context to the front of the free list. */
25574 context
->next
= cp_parser_context_free_list
;
25575 cp_parser_context_free_list
= context
;
25577 return !error_occurred
;
25580 /* Returns true if we are parsing tentatively and are not committed to
25581 this tentative parse. */
25584 cp_parser_uncommitted_to_tentative_parse_p (cp_parser
* parser
)
25586 return (cp_parser_parsing_tentatively (parser
)
25587 && parser
->context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
);
25590 /* Returns nonzero iff an error has occurred during the most recent
25591 tentative parse. */
25594 cp_parser_error_occurred (cp_parser
* parser
)
25596 return (cp_parser_parsing_tentatively (parser
)
25597 && parser
->context
->status
== CP_PARSER_STATUS_KIND_ERROR
);
25600 /* Returns nonzero if GNU extensions are allowed. */
25603 cp_parser_allow_gnu_extensions_p (cp_parser
* parser
)
25605 return parser
->allow_gnu_extensions_p
;
25608 /* Objective-C++ Productions */
25611 /* Parse an Objective-C expression, which feeds into a primary-expression
25615 objc-message-expression
25616 objc-string-literal
25617 objc-encode-expression
25618 objc-protocol-expression
25619 objc-selector-expression
25621 Returns a tree representation of the expression. */
25624 cp_parser_objc_expression (cp_parser
* parser
)
25626 /* Try to figure out what kind of declaration is present. */
25627 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
25631 case CPP_OPEN_SQUARE
:
25632 return cp_parser_objc_message_expression (parser
);
25634 case CPP_OBJC_STRING
:
25635 kwd
= cp_lexer_consume_token (parser
->lexer
);
25636 return objc_build_string_object (kwd
->u
.value
);
25639 switch (kwd
->keyword
)
25641 case RID_AT_ENCODE
:
25642 return cp_parser_objc_encode_expression (parser
);
25644 case RID_AT_PROTOCOL
:
25645 return cp_parser_objc_protocol_expression (parser
);
25647 case RID_AT_SELECTOR
:
25648 return cp_parser_objc_selector_expression (parser
);
25654 error_at (kwd
->location
,
25655 "misplaced %<@%D%> Objective-C++ construct",
25657 cp_parser_skip_to_end_of_block_or_statement (parser
);
25660 return error_mark_node
;
25663 /* Parse an Objective-C message expression.
25665 objc-message-expression:
25666 [ objc-message-receiver objc-message-args ]
25668 Returns a representation of an Objective-C message. */
25671 cp_parser_objc_message_expression (cp_parser
* parser
)
25673 tree receiver
, messageargs
;
25675 cp_lexer_consume_token (parser
->lexer
); /* Eat '['. */
25676 receiver
= cp_parser_objc_message_receiver (parser
);
25677 messageargs
= cp_parser_objc_message_args (parser
);
25678 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
25680 return objc_build_message_expr (receiver
, messageargs
);
25683 /* Parse an objc-message-receiver.
25685 objc-message-receiver:
25687 simple-type-specifier
25689 Returns a representation of the type or expression. */
25692 cp_parser_objc_message_receiver (cp_parser
* parser
)
25696 /* An Objective-C message receiver may be either (1) a type
25697 or (2) an expression. */
25698 cp_parser_parse_tentatively (parser
);
25699 rcv
= cp_parser_expression (parser
);
25701 /* If that worked out, fine. */
25702 if (cp_parser_parse_definitely (parser
))
25705 cp_parser_parse_tentatively (parser
);
25706 rcv
= cp_parser_simple_type_specifier (parser
,
25707 /*decl_specs=*/NULL
,
25708 CP_PARSER_FLAGS_NONE
);
25710 if (cp_parser_parse_definitely (parser
))
25711 return objc_get_class_reference (rcv
);
25713 cp_parser_error (parser
, "objective-c++ message receiver expected");
25714 return error_mark_node
;
25717 /* Parse the arguments and selectors comprising an Objective-C message.
25722 objc-selector-args , objc-comma-args
25724 objc-selector-args:
25725 objc-selector [opt] : assignment-expression
25726 objc-selector-args objc-selector [opt] : assignment-expression
25729 assignment-expression
25730 objc-comma-args , assignment-expression
25732 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
25733 selector arguments and TREE_VALUE containing a list of comma
25737 cp_parser_objc_message_args (cp_parser
* parser
)
25739 tree sel_args
= NULL_TREE
, addl_args
= NULL_TREE
;
25740 bool maybe_unary_selector_p
= true;
25741 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
25743 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
)
25745 tree selector
= NULL_TREE
, arg
;
25747 if (token
->type
!= CPP_COLON
)
25748 selector
= cp_parser_objc_selector (parser
);
25750 /* Detect if we have a unary selector. */
25751 if (maybe_unary_selector_p
25752 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
25753 return build_tree_list (selector
, NULL_TREE
);
25755 maybe_unary_selector_p
= false;
25756 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
25757 arg
= cp_parser_assignment_expression (parser
);
25760 = chainon (sel_args
,
25761 build_tree_list (selector
, arg
));
25763 token
= cp_lexer_peek_token (parser
->lexer
);
25766 /* Handle non-selector arguments, if any. */
25767 while (token
->type
== CPP_COMMA
)
25771 cp_lexer_consume_token (parser
->lexer
);
25772 arg
= cp_parser_assignment_expression (parser
);
25775 = chainon (addl_args
,
25776 build_tree_list (NULL_TREE
, arg
));
25778 token
= cp_lexer_peek_token (parser
->lexer
);
25781 if (sel_args
== NULL_TREE
&& addl_args
== NULL_TREE
)
25783 cp_parser_error (parser
, "objective-c++ message argument(s) are expected");
25784 return build_tree_list (error_mark_node
, error_mark_node
);
25787 return build_tree_list (sel_args
, addl_args
);
25790 /* Parse an Objective-C encode expression.
25792 objc-encode-expression:
25793 @encode objc-typename
25795 Returns an encoded representation of the type argument. */
25798 cp_parser_objc_encode_expression (cp_parser
* parser
)
25803 cp_lexer_consume_token (parser
->lexer
); /* Eat '@encode'. */
25804 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25805 token
= cp_lexer_peek_token (parser
->lexer
);
25806 type
= complete_type (cp_parser_type_id (parser
));
25807 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25811 error_at (token
->location
,
25812 "%<@encode%> must specify a type as an argument");
25813 return error_mark_node
;
25816 /* This happens if we find @encode(T) (where T is a template
25817 typename or something dependent on a template typename) when
25818 parsing a template. In that case, we can't compile it
25819 immediately, but we rather create an AT_ENCODE_EXPR which will
25820 need to be instantiated when the template is used.
25822 if (dependent_type_p (type
))
25824 tree value
= build_min (AT_ENCODE_EXPR
, size_type_node
, type
);
25825 TREE_READONLY (value
) = 1;
25829 return objc_build_encode_expr (type
);
25832 /* Parse an Objective-C @defs expression. */
25835 cp_parser_objc_defs_expression (cp_parser
*parser
)
25839 cp_lexer_consume_token (parser
->lexer
); /* Eat '@defs'. */
25840 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25841 name
= cp_parser_identifier (parser
);
25842 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25844 return objc_get_class_ivars (name
);
25847 /* Parse an Objective-C protocol expression.
25849 objc-protocol-expression:
25850 @protocol ( identifier )
25852 Returns a representation of the protocol expression. */
25855 cp_parser_objc_protocol_expression (cp_parser
* parser
)
25859 cp_lexer_consume_token (parser
->lexer
); /* Eat '@protocol'. */
25860 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25861 proto
= cp_parser_identifier (parser
);
25862 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25864 return objc_build_protocol_expr (proto
);
25867 /* Parse an Objective-C selector expression.
25869 objc-selector-expression:
25870 @selector ( objc-method-signature )
25872 objc-method-signature:
25878 objc-selector-seq objc-selector :
25880 Returns a representation of the method selector. */
25883 cp_parser_objc_selector_expression (cp_parser
* parser
)
25885 tree sel_seq
= NULL_TREE
;
25886 bool maybe_unary_selector_p
= true;
25888 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
25890 cp_lexer_consume_token (parser
->lexer
); /* Eat '@selector'. */
25891 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25892 token
= cp_lexer_peek_token (parser
->lexer
);
25894 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
25895 || token
->type
== CPP_SCOPE
)
25897 tree selector
= NULL_TREE
;
25899 if (token
->type
!= CPP_COLON
25900 || token
->type
== CPP_SCOPE
)
25901 selector
= cp_parser_objc_selector (parser
);
25903 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
)
25904 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_SCOPE
))
25906 /* Detect if we have a unary selector. */
25907 if (maybe_unary_selector_p
)
25909 sel_seq
= selector
;
25910 goto finish_selector
;
25914 cp_parser_error (parser
, "expected %<:%>");
25917 maybe_unary_selector_p
= false;
25918 token
= cp_lexer_consume_token (parser
->lexer
);
25920 if (token
->type
== CPP_SCOPE
)
25923 = chainon (sel_seq
,
25924 build_tree_list (selector
, NULL_TREE
));
25926 = chainon (sel_seq
,
25927 build_tree_list (NULL_TREE
, NULL_TREE
));
25931 = chainon (sel_seq
,
25932 build_tree_list (selector
, NULL_TREE
));
25934 token
= cp_lexer_peek_token (parser
->lexer
);
25938 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25940 return objc_build_selector_expr (loc
, sel_seq
);
25943 /* Parse a list of identifiers.
25945 objc-identifier-list:
25947 objc-identifier-list , identifier
25949 Returns a TREE_LIST of identifier nodes. */
25952 cp_parser_objc_identifier_list (cp_parser
* parser
)
25958 identifier
= cp_parser_identifier (parser
);
25959 if (identifier
== error_mark_node
)
25960 return error_mark_node
;
25962 list
= build_tree_list (NULL_TREE
, identifier
);
25963 sep
= cp_lexer_peek_token (parser
->lexer
);
25965 while (sep
->type
== CPP_COMMA
)
25967 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
25968 identifier
= cp_parser_identifier (parser
);
25969 if (identifier
== error_mark_node
)
25972 list
= chainon (list
, build_tree_list (NULL_TREE
,
25974 sep
= cp_lexer_peek_token (parser
->lexer
);
25980 /* Parse an Objective-C alias declaration.
25982 objc-alias-declaration:
25983 @compatibility_alias identifier identifier ;
25985 This function registers the alias mapping with the Objective-C front end.
25986 It returns nothing. */
25989 cp_parser_objc_alias_declaration (cp_parser
* parser
)
25993 cp_lexer_consume_token (parser
->lexer
); /* Eat '@compatibility_alias'. */
25994 alias
= cp_parser_identifier (parser
);
25995 orig
= cp_parser_identifier (parser
);
25996 objc_declare_alias (alias
, orig
);
25997 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26000 /* Parse an Objective-C class forward-declaration.
26002 objc-class-declaration:
26003 @class objc-identifier-list ;
26005 The function registers the forward declarations with the Objective-C
26006 front end. It returns nothing. */
26009 cp_parser_objc_class_declaration (cp_parser
* parser
)
26011 cp_lexer_consume_token (parser
->lexer
); /* Eat '@class'. */
26016 id
= cp_parser_identifier (parser
);
26017 if (id
== error_mark_node
)
26020 objc_declare_class (id
);
26022 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
26023 cp_lexer_consume_token (parser
->lexer
);
26027 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26030 /* Parse a list of Objective-C protocol references.
26032 objc-protocol-refs-opt:
26033 objc-protocol-refs [opt]
26035 objc-protocol-refs:
26036 < objc-identifier-list >
26038 Returns a TREE_LIST of identifiers, if any. */
26041 cp_parser_objc_protocol_refs_opt (cp_parser
* parser
)
26043 tree protorefs
= NULL_TREE
;
26045 if(cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
26047 cp_lexer_consume_token (parser
->lexer
); /* Eat '<'. */
26048 protorefs
= cp_parser_objc_identifier_list (parser
);
26049 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
26055 /* Parse a Objective-C visibility specification. */
26058 cp_parser_objc_visibility_spec (cp_parser
* parser
)
26060 cp_token
*vis
= cp_lexer_peek_token (parser
->lexer
);
26062 switch (vis
->keyword
)
26064 case RID_AT_PRIVATE
:
26065 objc_set_visibility (OBJC_IVAR_VIS_PRIVATE
);
26067 case RID_AT_PROTECTED
:
26068 objc_set_visibility (OBJC_IVAR_VIS_PROTECTED
);
26070 case RID_AT_PUBLIC
:
26071 objc_set_visibility (OBJC_IVAR_VIS_PUBLIC
);
26073 case RID_AT_PACKAGE
:
26074 objc_set_visibility (OBJC_IVAR_VIS_PACKAGE
);
26080 /* Eat '@private'/'@protected'/'@public'. */
26081 cp_lexer_consume_token (parser
->lexer
);
26084 /* Parse an Objective-C method type. Return 'true' if it is a class
26085 (+) method, and 'false' if it is an instance (-) method. */
26088 cp_parser_objc_method_type (cp_parser
* parser
)
26090 if (cp_lexer_consume_token (parser
->lexer
)->type
== CPP_PLUS
)
26096 /* Parse an Objective-C protocol qualifier. */
26099 cp_parser_objc_protocol_qualifiers (cp_parser
* parser
)
26101 tree quals
= NULL_TREE
, node
;
26102 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26104 node
= token
->u
.value
;
26106 while (node
&& identifier_p (node
)
26107 && (node
== ridpointers
[(int) RID_IN
]
26108 || node
== ridpointers
[(int) RID_OUT
]
26109 || node
== ridpointers
[(int) RID_INOUT
]
26110 || node
== ridpointers
[(int) RID_BYCOPY
]
26111 || node
== ridpointers
[(int) RID_BYREF
]
26112 || node
== ridpointers
[(int) RID_ONEWAY
]))
26114 quals
= tree_cons (NULL_TREE
, node
, quals
);
26115 cp_lexer_consume_token (parser
->lexer
);
26116 token
= cp_lexer_peek_token (parser
->lexer
);
26117 node
= token
->u
.value
;
26123 /* Parse an Objective-C typename. */
26126 cp_parser_objc_typename (cp_parser
* parser
)
26128 tree type_name
= NULL_TREE
;
26130 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
26132 tree proto_quals
, cp_type
= NULL_TREE
;
26134 cp_lexer_consume_token (parser
->lexer
); /* Eat '('. */
26135 proto_quals
= cp_parser_objc_protocol_qualifiers (parser
);
26137 /* An ObjC type name may consist of just protocol qualifiers, in which
26138 case the type shall default to 'id'. */
26139 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
26141 cp_type
= cp_parser_type_id (parser
);
26143 /* If the type could not be parsed, an error has already
26144 been produced. For error recovery, behave as if it had
26145 not been specified, which will use the default type
26147 if (cp_type
== error_mark_node
)
26149 cp_type
= NULL_TREE
;
26150 /* We need to skip to the closing parenthesis as
26151 cp_parser_type_id() does not seem to do it for
26153 cp_parser_skip_to_closing_parenthesis (parser
,
26154 /*recovering=*/true,
26155 /*or_comma=*/false,
26156 /*consume_paren=*/false);
26160 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
26161 type_name
= build_tree_list (proto_quals
, cp_type
);
26167 /* Check to see if TYPE refers to an Objective-C selector name. */
26170 cp_parser_objc_selector_p (enum cpp_ttype type
)
26172 return (type
== CPP_NAME
|| type
== CPP_KEYWORD
26173 || type
== CPP_AND_AND
|| type
== CPP_AND_EQ
|| type
== CPP_AND
26174 || type
== CPP_OR
|| type
== CPP_COMPL
|| type
== CPP_NOT
26175 || type
== CPP_NOT_EQ
|| type
== CPP_OR_OR
|| type
== CPP_OR_EQ
26176 || type
== CPP_XOR
|| type
== CPP_XOR_EQ
);
26179 /* Parse an Objective-C selector. */
26182 cp_parser_objc_selector (cp_parser
* parser
)
26184 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
26186 if (!cp_parser_objc_selector_p (token
->type
))
26188 error_at (token
->location
, "invalid Objective-C++ selector name");
26189 return error_mark_node
;
26192 /* C++ operator names are allowed to appear in ObjC selectors. */
26193 switch (token
->type
)
26195 case CPP_AND_AND
: return get_identifier ("and");
26196 case CPP_AND_EQ
: return get_identifier ("and_eq");
26197 case CPP_AND
: return get_identifier ("bitand");
26198 case CPP_OR
: return get_identifier ("bitor");
26199 case CPP_COMPL
: return get_identifier ("compl");
26200 case CPP_NOT
: return get_identifier ("not");
26201 case CPP_NOT_EQ
: return get_identifier ("not_eq");
26202 case CPP_OR_OR
: return get_identifier ("or");
26203 case CPP_OR_EQ
: return get_identifier ("or_eq");
26204 case CPP_XOR
: return get_identifier ("xor");
26205 case CPP_XOR_EQ
: return get_identifier ("xor_eq");
26206 default: return token
->u
.value
;
26210 /* Parse an Objective-C params list. */
26213 cp_parser_objc_method_keyword_params (cp_parser
* parser
, tree
* attributes
)
26215 tree params
= NULL_TREE
;
26216 bool maybe_unary_selector_p
= true;
26217 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26219 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
)
26221 tree selector
= NULL_TREE
, type_name
, identifier
;
26222 tree parm_attr
= NULL_TREE
;
26224 if (token
->keyword
== RID_ATTRIBUTE
)
26227 if (token
->type
!= CPP_COLON
)
26228 selector
= cp_parser_objc_selector (parser
);
26230 /* Detect if we have a unary selector. */
26231 if (maybe_unary_selector_p
26232 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
26234 params
= selector
; /* Might be followed by attributes. */
26238 maybe_unary_selector_p
= false;
26239 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
26241 /* Something went quite wrong. There should be a colon
26242 here, but there is not. Stop parsing parameters. */
26245 type_name
= cp_parser_objc_typename (parser
);
26246 /* New ObjC allows attributes on parameters too. */
26247 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ATTRIBUTE
))
26248 parm_attr
= cp_parser_attributes_opt (parser
);
26249 identifier
= cp_parser_identifier (parser
);
26253 objc_build_keyword_decl (selector
,
26258 token
= cp_lexer_peek_token (parser
->lexer
);
26261 if (params
== NULL_TREE
)
26263 cp_parser_error (parser
, "objective-c++ method declaration is expected");
26264 return error_mark_node
;
26267 /* We allow tail attributes for the method. */
26268 if (token
->keyword
== RID_ATTRIBUTE
)
26270 *attributes
= cp_parser_attributes_opt (parser
);
26271 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
26272 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
26274 cp_parser_error (parser
,
26275 "method attributes must be specified at the end");
26276 return error_mark_node
;
26279 if (params
== NULL_TREE
)
26281 cp_parser_error (parser
, "objective-c++ method declaration is expected");
26282 return error_mark_node
;
26287 /* Parse the non-keyword Objective-C params. */
26290 cp_parser_objc_method_tail_params_opt (cp_parser
* parser
, bool *ellipsisp
,
26293 tree params
= make_node (TREE_LIST
);
26294 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26295 *ellipsisp
= false; /* Initially, assume no ellipsis. */
26297 while (token
->type
== CPP_COMMA
)
26299 cp_parameter_declarator
*parmdecl
;
26302 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
26303 token
= cp_lexer_peek_token (parser
->lexer
);
26305 if (token
->type
== CPP_ELLIPSIS
)
26307 cp_lexer_consume_token (parser
->lexer
); /* Eat '...'. */
26309 token
= cp_lexer_peek_token (parser
->lexer
);
26313 /* TODO: parse attributes for tail parameters. */
26314 parmdecl
= cp_parser_parameter_declaration (parser
, false, NULL
);
26315 parm
= grokdeclarator (parmdecl
->declarator
,
26316 &parmdecl
->decl_specifiers
,
26317 PARM
, /*initialized=*/0,
26318 /*attrlist=*/NULL
);
26320 chainon (params
, build_tree_list (NULL_TREE
, parm
));
26321 token
= cp_lexer_peek_token (parser
->lexer
);
26324 /* We allow tail attributes for the method. */
26325 if (token
->keyword
== RID_ATTRIBUTE
)
26327 if (*attributes
== NULL_TREE
)
26329 *attributes
= cp_parser_attributes_opt (parser
);
26330 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
26331 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
26335 /* We have an error, but parse the attributes, so that we can
26337 *attributes
= cp_parser_attributes_opt (parser
);
26339 cp_parser_error (parser
,
26340 "method attributes must be specified at the end");
26341 return error_mark_node
;
26347 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
26350 cp_parser_objc_interstitial_code (cp_parser
* parser
)
26352 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26354 /* If the next token is `extern' and the following token is a string
26355 literal, then we have a linkage specification. */
26356 if (token
->keyword
== RID_EXTERN
26357 && cp_parser_is_pure_string_literal
26358 (cp_lexer_peek_nth_token (parser
->lexer
, 2)))
26359 cp_parser_linkage_specification (parser
);
26360 /* Handle #pragma, if any. */
26361 else if (token
->type
== CPP_PRAGMA
)
26362 cp_parser_pragma (parser
, pragma_objc_icode
);
26363 /* Allow stray semicolons. */
26364 else if (token
->type
== CPP_SEMICOLON
)
26365 cp_lexer_consume_token (parser
->lexer
);
26366 /* Mark methods as optional or required, when building protocols. */
26367 else if (token
->keyword
== RID_AT_OPTIONAL
)
26369 cp_lexer_consume_token (parser
->lexer
);
26370 objc_set_method_opt (true);
26372 else if (token
->keyword
== RID_AT_REQUIRED
)
26374 cp_lexer_consume_token (parser
->lexer
);
26375 objc_set_method_opt (false);
26377 else if (token
->keyword
== RID_NAMESPACE
)
26378 cp_parser_namespace_definition (parser
);
26379 /* Other stray characters must generate errors. */
26380 else if (token
->type
== CPP_OPEN_BRACE
|| token
->type
== CPP_CLOSE_BRACE
)
26382 cp_lexer_consume_token (parser
->lexer
);
26383 error ("stray %qs between Objective-C++ methods",
26384 token
->type
== CPP_OPEN_BRACE
? "{" : "}");
26386 /* Finally, try to parse a block-declaration, or a function-definition. */
26388 cp_parser_block_declaration (parser
, /*statement_p=*/false);
26391 /* Parse a method signature. */
26394 cp_parser_objc_method_signature (cp_parser
* parser
, tree
* attributes
)
26396 tree rettype
, kwdparms
, optparms
;
26397 bool ellipsis
= false;
26398 bool is_class_method
;
26400 is_class_method
= cp_parser_objc_method_type (parser
);
26401 rettype
= cp_parser_objc_typename (parser
);
26402 *attributes
= NULL_TREE
;
26403 kwdparms
= cp_parser_objc_method_keyword_params (parser
, attributes
);
26404 if (kwdparms
== error_mark_node
)
26405 return error_mark_node
;
26406 optparms
= cp_parser_objc_method_tail_params_opt (parser
, &ellipsis
, attributes
);
26407 if (optparms
== error_mark_node
)
26408 return error_mark_node
;
26410 return objc_build_method_signature (is_class_method
, rettype
, kwdparms
, optparms
, ellipsis
);
26414 cp_parser_objc_method_maybe_bad_prefix_attributes (cp_parser
* parser
)
26417 cp_lexer_save_tokens (parser
->lexer
);
26418 tattr
= cp_parser_attributes_opt (parser
);
26419 gcc_assert (tattr
) ;
26421 /* If the attributes are followed by a method introducer, this is not allowed.
26422 Dump the attributes and flag the situation. */
26423 if (cp_lexer_next_token_is (parser
->lexer
, CPP_PLUS
)
26424 || cp_lexer_next_token_is (parser
->lexer
, CPP_MINUS
))
26427 /* Otherwise, the attributes introduce some interstitial code, possibly so
26428 rewind to allow that check. */
26429 cp_lexer_rollback_tokens (parser
->lexer
);
26433 /* Parse an Objective-C method prototype list. */
26436 cp_parser_objc_method_prototype_list (cp_parser
* parser
)
26438 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26440 while (token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26442 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
)
26444 tree attributes
, sig
;
26445 bool is_class_method
;
26446 if (token
->type
== CPP_PLUS
)
26447 is_class_method
= true;
26449 is_class_method
= false;
26450 sig
= cp_parser_objc_method_signature (parser
, &attributes
);
26451 if (sig
== error_mark_node
)
26453 cp_parser_skip_to_end_of_block_or_statement (parser
);
26454 token
= cp_lexer_peek_token (parser
->lexer
);
26457 objc_add_method_declaration (is_class_method
, sig
, attributes
);
26458 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26460 else if (token
->keyword
== RID_AT_PROPERTY
)
26461 cp_parser_objc_at_property_declaration (parser
);
26462 else if (token
->keyword
== RID_ATTRIBUTE
26463 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser
))
26464 warning_at (cp_lexer_peek_token (parser
->lexer
)->location
,
26466 "prefix attributes are ignored for methods");
26468 /* Allow for interspersed non-ObjC++ code. */
26469 cp_parser_objc_interstitial_code (parser
);
26471 token
= cp_lexer_peek_token (parser
->lexer
);
26474 if (token
->type
!= CPP_EOF
)
26475 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
26477 cp_parser_error (parser
, "expected %<@end%>");
26479 objc_finish_interface ();
26482 /* Parse an Objective-C method definition list. */
26485 cp_parser_objc_method_definition_list (cp_parser
* parser
)
26487 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26489 while (token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26493 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
)
26496 tree sig
, attribute
;
26497 bool is_class_method
;
26498 if (token
->type
== CPP_PLUS
)
26499 is_class_method
= true;
26501 is_class_method
= false;
26502 push_deferring_access_checks (dk_deferred
);
26503 sig
= cp_parser_objc_method_signature (parser
, &attribute
);
26504 if (sig
== error_mark_node
)
26506 cp_parser_skip_to_end_of_block_or_statement (parser
);
26507 token
= cp_lexer_peek_token (parser
->lexer
);
26510 objc_start_method_definition (is_class_method
, sig
, attribute
,
26513 /* For historical reasons, we accept an optional semicolon. */
26514 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
26515 cp_lexer_consume_token (parser
->lexer
);
26517 ptk
= cp_lexer_peek_token (parser
->lexer
);
26518 if (!(ptk
->type
== CPP_PLUS
|| ptk
->type
== CPP_MINUS
26519 || ptk
->type
== CPP_EOF
|| ptk
->keyword
== RID_AT_END
))
26521 perform_deferred_access_checks (tf_warning_or_error
);
26522 stop_deferring_access_checks ();
26523 meth
= cp_parser_function_definition_after_declarator (parser
,
26525 pop_deferring_access_checks ();
26526 objc_finish_method_definition (meth
);
26529 /* The following case will be removed once @synthesize is
26530 completely implemented. */
26531 else if (token
->keyword
== RID_AT_PROPERTY
)
26532 cp_parser_objc_at_property_declaration (parser
);
26533 else if (token
->keyword
== RID_AT_SYNTHESIZE
)
26534 cp_parser_objc_at_synthesize_declaration (parser
);
26535 else if (token
->keyword
== RID_AT_DYNAMIC
)
26536 cp_parser_objc_at_dynamic_declaration (parser
);
26537 else if (token
->keyword
== RID_ATTRIBUTE
26538 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser
))
26539 warning_at (token
->location
, OPT_Wattributes
,
26540 "prefix attributes are ignored for methods");
26542 /* Allow for interspersed non-ObjC++ code. */
26543 cp_parser_objc_interstitial_code (parser
);
26545 token
= cp_lexer_peek_token (parser
->lexer
);
26548 if (token
->type
!= CPP_EOF
)
26549 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
26551 cp_parser_error (parser
, "expected %<@end%>");
26553 objc_finish_implementation ();
26556 /* Parse Objective-C ivars. */
26559 cp_parser_objc_class_ivars (cp_parser
* parser
)
26561 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26563 if (token
->type
!= CPP_OPEN_BRACE
)
26564 return; /* No ivars specified. */
26566 cp_lexer_consume_token (parser
->lexer
); /* Eat '{'. */
26567 token
= cp_lexer_peek_token (parser
->lexer
);
26569 while (token
->type
!= CPP_CLOSE_BRACE
26570 && token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26572 cp_decl_specifier_seq declspecs
;
26573 int decl_class_or_enum_p
;
26574 tree prefix_attributes
;
26576 cp_parser_objc_visibility_spec (parser
);
26578 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
26581 cp_parser_decl_specifier_seq (parser
,
26582 CP_PARSER_FLAGS_OPTIONAL
,
26584 &decl_class_or_enum_p
);
26586 /* auto, register, static, extern, mutable. */
26587 if (declspecs
.storage_class
!= sc_none
)
26589 cp_parser_error (parser
, "invalid type for instance variable");
26590 declspecs
.storage_class
= sc_none
;
26593 /* thread_local. */
26594 if (decl_spec_seq_has_spec_p (&declspecs
, ds_thread
))
26596 cp_parser_error (parser
, "invalid type for instance variable");
26597 declspecs
.locations
[ds_thread
] = 0;
26601 if (decl_spec_seq_has_spec_p (&declspecs
, ds_typedef
))
26603 cp_parser_error (parser
, "invalid type for instance variable");
26604 declspecs
.locations
[ds_typedef
] = 0;
26607 prefix_attributes
= declspecs
.attributes
;
26608 declspecs
.attributes
= NULL_TREE
;
26610 /* Keep going until we hit the `;' at the end of the
26612 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
26614 tree width
= NULL_TREE
, attributes
, first_attribute
, decl
;
26615 cp_declarator
*declarator
= NULL
;
26616 int ctor_dtor_or_conv_p
;
26618 /* Check for a (possibly unnamed) bitfield declaration. */
26619 token
= cp_lexer_peek_token (parser
->lexer
);
26620 if (token
->type
== CPP_COLON
)
26623 if (token
->type
== CPP_NAME
26624 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
26627 /* Get the name of the bitfield. */
26628 declarator
= make_id_declarator (NULL_TREE
,
26629 cp_parser_identifier (parser
),
26633 cp_lexer_consume_token (parser
->lexer
); /* Eat ':'. */
26634 /* Get the width of the bitfield. */
26636 = cp_parser_constant_expression (parser
);
26640 /* Parse the declarator. */
26642 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
26643 &ctor_dtor_or_conv_p
,
26644 /*parenthesized_p=*/NULL
,
26645 /*member_p=*/false,
26646 /*friend_p=*/false);
26649 /* Look for attributes that apply to the ivar. */
26650 attributes
= cp_parser_attributes_opt (parser
);
26651 /* Remember which attributes are prefix attributes and
26653 first_attribute
= attributes
;
26654 /* Combine the attributes. */
26655 attributes
= chainon (prefix_attributes
, attributes
);
26658 /* Create the bitfield declaration. */
26659 decl
= grokbitfield (declarator
, &declspecs
,
26663 decl
= grokfield (declarator
, &declspecs
,
26664 NULL_TREE
, /*init_const_expr_p=*/false,
26665 NULL_TREE
, attributes
);
26667 /* Add the instance variable. */
26668 if (decl
!= error_mark_node
&& decl
!= NULL_TREE
)
26669 objc_add_instance_variable (decl
);
26671 /* Reset PREFIX_ATTRIBUTES. */
26672 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
26673 attributes
= TREE_CHAIN (attributes
);
26675 TREE_CHAIN (attributes
) = NULL_TREE
;
26677 token
= cp_lexer_peek_token (parser
->lexer
);
26679 if (token
->type
== CPP_COMMA
)
26681 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
26687 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26688 token
= cp_lexer_peek_token (parser
->lexer
);
26691 if (token
->keyword
== RID_AT_END
)
26692 cp_parser_error (parser
, "expected %<}%>");
26694 /* Do not consume the RID_AT_END, so it will be read again as terminating
26695 the @interface of @implementation. */
26696 if (token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26697 cp_lexer_consume_token (parser
->lexer
); /* Eat '}'. */
26699 /* For historical reasons, we accept an optional semicolon. */
26700 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
26701 cp_lexer_consume_token (parser
->lexer
);
26704 /* Parse an Objective-C protocol declaration. */
26707 cp_parser_objc_protocol_declaration (cp_parser
* parser
, tree attributes
)
26709 tree proto
, protorefs
;
26712 cp_lexer_consume_token (parser
->lexer
); /* Eat '@protocol'. */
26713 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
26715 tok
= cp_lexer_peek_token (parser
->lexer
);
26716 error_at (tok
->location
, "identifier expected after %<@protocol%>");
26717 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26721 /* See if we have a forward declaration or a definition. */
26722 tok
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
26724 /* Try a forward declaration first. */
26725 if (tok
->type
== CPP_COMMA
|| tok
->type
== CPP_SEMICOLON
)
26731 id
= cp_parser_identifier (parser
);
26732 if (id
== error_mark_node
)
26735 objc_declare_protocol (id
, attributes
);
26737 if(cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
26738 cp_lexer_consume_token (parser
->lexer
);
26742 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26745 /* Ok, we got a full-fledged definition (or at least should). */
26748 proto
= cp_parser_identifier (parser
);
26749 protorefs
= cp_parser_objc_protocol_refs_opt (parser
);
26750 objc_start_protocol (proto
, protorefs
, attributes
);
26751 cp_parser_objc_method_prototype_list (parser
);
26755 /* Parse an Objective-C superclass or category. */
26758 cp_parser_objc_superclass_or_category (cp_parser
*parser
,
26761 tree
*categ
, bool *is_class_extension
)
26763 cp_token
*next
= cp_lexer_peek_token (parser
->lexer
);
26765 *super
= *categ
= NULL_TREE
;
26766 *is_class_extension
= false;
26767 if (next
->type
== CPP_COLON
)
26769 cp_lexer_consume_token (parser
->lexer
); /* Eat ':'. */
26770 *super
= cp_parser_identifier (parser
);
26772 else if (next
->type
== CPP_OPEN_PAREN
)
26774 cp_lexer_consume_token (parser
->lexer
); /* Eat '('. */
26776 /* If there is no category name, and this is an @interface, we
26777 have a class extension. */
26778 if (iface_p
&& cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
26780 *categ
= NULL_TREE
;
26781 *is_class_extension
= true;
26784 *categ
= cp_parser_identifier (parser
);
26786 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
26790 /* Parse an Objective-C class interface. */
26793 cp_parser_objc_class_interface (cp_parser
* parser
, tree attributes
)
26795 tree name
, super
, categ
, protos
;
26796 bool is_class_extension
;
26798 cp_lexer_consume_token (parser
->lexer
); /* Eat '@interface'. */
26799 name
= cp_parser_identifier (parser
);
26800 if (name
== error_mark_node
)
26802 /* It's hard to recover because even if valid @interface stuff
26803 is to follow, we can't compile it (or validate it) if we
26804 don't even know which class it refers to. Let's assume this
26805 was a stray '@interface' token in the stream and skip it.
26809 cp_parser_objc_superclass_or_category (parser
, true, &super
, &categ
,
26810 &is_class_extension
);
26811 protos
= cp_parser_objc_protocol_refs_opt (parser
);
26813 /* We have either a class or a category on our hands. */
26814 if (categ
|| is_class_extension
)
26815 objc_start_category_interface (name
, categ
, protos
, attributes
);
26818 objc_start_class_interface (name
, super
, protos
, attributes
);
26819 /* Handle instance variable declarations, if any. */
26820 cp_parser_objc_class_ivars (parser
);
26821 objc_continue_interface ();
26824 cp_parser_objc_method_prototype_list (parser
);
26827 /* Parse an Objective-C class implementation. */
26830 cp_parser_objc_class_implementation (cp_parser
* parser
)
26832 tree name
, super
, categ
;
26833 bool is_class_extension
;
26835 cp_lexer_consume_token (parser
->lexer
); /* Eat '@implementation'. */
26836 name
= cp_parser_identifier (parser
);
26837 if (name
== error_mark_node
)
26839 /* It's hard to recover because even if valid @implementation
26840 stuff is to follow, we can't compile it (or validate it) if
26841 we don't even know which class it refers to. Let's assume
26842 this was a stray '@implementation' token in the stream and
26847 cp_parser_objc_superclass_or_category (parser
, false, &super
, &categ
,
26848 &is_class_extension
);
26850 /* We have either a class or a category on our hands. */
26852 objc_start_category_implementation (name
, categ
);
26855 objc_start_class_implementation (name
, super
);
26856 /* Handle instance variable declarations, if any. */
26857 cp_parser_objc_class_ivars (parser
);
26858 objc_continue_implementation ();
26861 cp_parser_objc_method_definition_list (parser
);
26864 /* Consume the @end token and finish off the implementation. */
26867 cp_parser_objc_end_implementation (cp_parser
* parser
)
26869 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
26870 objc_finish_implementation ();
26873 /* Parse an Objective-C declaration. */
26876 cp_parser_objc_declaration (cp_parser
* parser
, tree attributes
)
26878 /* Try to figure out what kind of declaration is present. */
26879 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
26882 switch (kwd
->keyword
)
26887 error_at (kwd
->location
, "attributes may not be specified before"
26888 " the %<@%D%> Objective-C++ keyword",
26892 case RID_AT_IMPLEMENTATION
:
26893 warning_at (kwd
->location
, OPT_Wattributes
,
26894 "prefix attributes are ignored before %<@%D%>",
26901 switch (kwd
->keyword
)
26904 cp_parser_objc_alias_declaration (parser
);
26907 cp_parser_objc_class_declaration (parser
);
26909 case RID_AT_PROTOCOL
:
26910 cp_parser_objc_protocol_declaration (parser
, attributes
);
26912 case RID_AT_INTERFACE
:
26913 cp_parser_objc_class_interface (parser
, attributes
);
26915 case RID_AT_IMPLEMENTATION
:
26916 cp_parser_objc_class_implementation (parser
);
26919 cp_parser_objc_end_implementation (parser
);
26922 error_at (kwd
->location
, "misplaced %<@%D%> Objective-C++ construct",
26924 cp_parser_skip_to_end_of_block_or_statement (parser
);
26928 /* Parse an Objective-C try-catch-finally statement.
26930 objc-try-catch-finally-stmt:
26931 @try compound-statement objc-catch-clause-seq [opt]
26932 objc-finally-clause [opt]
26934 objc-catch-clause-seq:
26935 objc-catch-clause objc-catch-clause-seq [opt]
26938 @catch ( objc-exception-declaration ) compound-statement
26940 objc-finally-clause:
26941 @finally compound-statement
26943 objc-exception-declaration:
26944 parameter-declaration
26947 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
26951 PS: This function is identical to c_parser_objc_try_catch_finally_statement
26952 for C. Keep them in sync. */
26955 cp_parser_objc_try_catch_finally_statement (cp_parser
*parser
)
26957 location_t location
;
26960 cp_parser_require_keyword (parser
, RID_AT_TRY
, RT_AT_TRY
);
26961 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
26962 objc_maybe_warn_exceptions (location
);
26963 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
26964 node, lest it get absorbed into the surrounding block. */
26965 stmt
= push_stmt_list ();
26966 cp_parser_compound_statement (parser
, NULL
, false, false);
26967 objc_begin_try_stmt (location
, pop_stmt_list (stmt
));
26969 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_CATCH
))
26971 cp_parameter_declarator
*parm
;
26972 tree parameter_declaration
= error_mark_node
;
26973 bool seen_open_paren
= false;
26975 cp_lexer_consume_token (parser
->lexer
);
26976 if (cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
26977 seen_open_paren
= true;
26978 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
26980 /* We have "@catch (...)" (where the '...' are literally
26981 what is in the code). Skip the '...'.
26982 parameter_declaration is set to NULL_TREE, and
26983 objc_being_catch_clauses() knows that that means
26985 cp_lexer_consume_token (parser
->lexer
);
26986 parameter_declaration
= NULL_TREE
;
26990 /* We have "@catch (NSException *exception)" or something
26991 like that. Parse the parameter declaration. */
26992 parm
= cp_parser_parameter_declaration (parser
, false, NULL
);
26994 parameter_declaration
= error_mark_node
;
26996 parameter_declaration
= grokdeclarator (parm
->declarator
,
26997 &parm
->decl_specifiers
,
26998 PARM
, /*initialized=*/0,
26999 /*attrlist=*/NULL
);
27001 if (seen_open_paren
)
27002 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
27005 /* If there was no open parenthesis, we are recovering from
27006 an error, and we are trying to figure out what mistake
27007 the user has made. */
27009 /* If there is an immediate closing parenthesis, the user
27010 probably forgot the opening one (ie, they typed "@catch
27011 NSException *e)". Parse the closing parenthesis and keep
27013 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
27014 cp_lexer_consume_token (parser
->lexer
);
27016 /* If these is no immediate closing parenthesis, the user
27017 probably doesn't know that parenthesis are required at
27018 all (ie, they typed "@catch NSException *e"). So, just
27019 forget about the closing parenthesis and keep going. */
27021 objc_begin_catch_clause (parameter_declaration
);
27022 cp_parser_compound_statement (parser
, NULL
, false, false);
27023 objc_finish_catch_clause ();
27025 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_FINALLY
))
27027 cp_lexer_consume_token (parser
->lexer
);
27028 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
27029 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
27030 node, lest it get absorbed into the surrounding block. */
27031 stmt
= push_stmt_list ();
27032 cp_parser_compound_statement (parser
, NULL
, false, false);
27033 objc_build_finally_clause (location
, pop_stmt_list (stmt
));
27036 return objc_finish_try_stmt ();
27039 /* Parse an Objective-C synchronized statement.
27041 objc-synchronized-stmt:
27042 @synchronized ( expression ) compound-statement
27044 Returns NULL_TREE. */
27047 cp_parser_objc_synchronized_statement (cp_parser
*parser
)
27049 location_t location
;
27052 cp_parser_require_keyword (parser
, RID_AT_SYNCHRONIZED
, RT_AT_SYNCHRONIZED
);
27054 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
27055 objc_maybe_warn_exceptions (location
);
27056 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
27057 lock
= cp_parser_expression (parser
);
27058 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
27060 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
27061 node, lest it get absorbed into the surrounding block. */
27062 stmt
= push_stmt_list ();
27063 cp_parser_compound_statement (parser
, NULL
, false, false);
27065 return objc_build_synchronized (location
, lock
, pop_stmt_list (stmt
));
27068 /* Parse an Objective-C throw statement.
27071 @throw assignment-expression [opt] ;
27073 Returns a constructed '@throw' statement. */
27076 cp_parser_objc_throw_statement (cp_parser
*parser
)
27078 tree expr
= NULL_TREE
;
27079 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27081 cp_parser_require_keyword (parser
, RID_AT_THROW
, RT_AT_THROW
);
27083 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
27084 expr
= cp_parser_expression (parser
);
27086 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27088 return objc_build_throw_stmt (loc
, expr
);
27091 /* Parse an Objective-C statement. */
27094 cp_parser_objc_statement (cp_parser
* parser
)
27096 /* Try to figure out what kind of declaration is present. */
27097 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
27099 switch (kwd
->keyword
)
27102 return cp_parser_objc_try_catch_finally_statement (parser
);
27103 case RID_AT_SYNCHRONIZED
:
27104 return cp_parser_objc_synchronized_statement (parser
);
27106 return cp_parser_objc_throw_statement (parser
);
27108 error_at (kwd
->location
, "misplaced %<@%D%> Objective-C++ construct",
27110 cp_parser_skip_to_end_of_block_or_statement (parser
);
27113 return error_mark_node
;
27116 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
27117 look ahead to see if an objc keyword follows the attributes. This
27118 is to detect the use of prefix attributes on ObjC @interface and
27122 cp_parser_objc_valid_prefix_attributes (cp_parser
* parser
, tree
*attrib
)
27124 cp_lexer_save_tokens (parser
->lexer
);
27125 *attrib
= cp_parser_attributes_opt (parser
);
27126 gcc_assert (*attrib
);
27127 if (OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser
->lexer
)->keyword
))
27129 cp_lexer_commit_tokens (parser
->lexer
);
27132 cp_lexer_rollback_tokens (parser
->lexer
);
27136 /* This routine is a minimal replacement for
27137 c_parser_struct_declaration () used when parsing the list of
27138 types/names or ObjC++ properties. For example, when parsing the
27141 @property (readonly) int a, b, c;
27143 this function is responsible for parsing "int a, int b, int c" and
27144 returning the declarations as CHAIN of DECLs.
27146 TODO: Share this code with cp_parser_objc_class_ivars. It's very
27147 similar parsing. */
27149 cp_parser_objc_struct_declaration (cp_parser
*parser
)
27151 tree decls
= NULL_TREE
;
27152 cp_decl_specifier_seq declspecs
;
27153 int decl_class_or_enum_p
;
27154 tree prefix_attributes
;
27156 cp_parser_decl_specifier_seq (parser
,
27157 CP_PARSER_FLAGS_NONE
,
27159 &decl_class_or_enum_p
);
27161 if (declspecs
.type
== error_mark_node
)
27162 return error_mark_node
;
27164 /* auto, register, static, extern, mutable. */
27165 if (declspecs
.storage_class
!= sc_none
)
27167 cp_parser_error (parser
, "invalid type for property");
27168 declspecs
.storage_class
= sc_none
;
27171 /* thread_local. */
27172 if (decl_spec_seq_has_spec_p (&declspecs
, ds_thread
))
27174 cp_parser_error (parser
, "invalid type for property");
27175 declspecs
.locations
[ds_thread
] = 0;
27179 if (decl_spec_seq_has_spec_p (&declspecs
, ds_typedef
))
27181 cp_parser_error (parser
, "invalid type for property");
27182 declspecs
.locations
[ds_typedef
] = 0;
27185 prefix_attributes
= declspecs
.attributes
;
27186 declspecs
.attributes
= NULL_TREE
;
27188 /* Keep going until we hit the `;' at the end of the declaration. */
27189 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
27191 tree attributes
, first_attribute
, decl
;
27192 cp_declarator
*declarator
;
27195 /* Parse the declarator. */
27196 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
27197 NULL
, NULL
, false, false);
27199 /* Look for attributes that apply to the ivar. */
27200 attributes
= cp_parser_attributes_opt (parser
);
27201 /* Remember which attributes are prefix attributes and
27203 first_attribute
= attributes
;
27204 /* Combine the attributes. */
27205 attributes
= chainon (prefix_attributes
, attributes
);
27207 decl
= grokfield (declarator
, &declspecs
,
27208 NULL_TREE
, /*init_const_expr_p=*/false,
27209 NULL_TREE
, attributes
);
27211 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
27212 return error_mark_node
;
27214 /* Reset PREFIX_ATTRIBUTES. */
27215 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
27216 attributes
= TREE_CHAIN (attributes
);
27218 TREE_CHAIN (attributes
) = NULL_TREE
;
27220 DECL_CHAIN (decl
) = decls
;
27223 token
= cp_lexer_peek_token (parser
->lexer
);
27224 if (token
->type
== CPP_COMMA
)
27226 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
27235 /* Parse an Objective-C @property declaration. The syntax is:
27237 objc-property-declaration:
27238 '@property' objc-property-attributes[opt] struct-declaration ;
27240 objc-property-attributes:
27241 '(' objc-property-attribute-list ')'
27243 objc-property-attribute-list:
27244 objc-property-attribute
27245 objc-property-attribute-list, objc-property-attribute
27247 objc-property-attribute
27248 'getter' = identifier
27249 'setter' = identifier
27258 @property NSString *name;
27259 @property (readonly) id object;
27260 @property (retain, nonatomic, getter=getTheName) id name;
27261 @property int a, b, c;
27263 PS: This function is identical to
27264 c_parser_objc_at_property_declaration for C. Keep them in sync. */
27266 cp_parser_objc_at_property_declaration (cp_parser
*parser
)
27268 /* The following variables hold the attributes of the properties as
27269 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
27270 seen. When we see an attribute, we set them to 'true' (if they
27271 are boolean properties) or to the identifier (if they have an
27272 argument, ie, for getter and setter). Note that here we only
27273 parse the list of attributes, check the syntax and accumulate the
27274 attributes that we find. objc_add_property_declaration() will
27275 then process the information. */
27276 bool property_assign
= false;
27277 bool property_copy
= false;
27278 tree property_getter_ident
= NULL_TREE
;
27279 bool property_nonatomic
= false;
27280 bool property_readonly
= false;
27281 bool property_readwrite
= false;
27282 bool property_retain
= false;
27283 tree property_setter_ident
= NULL_TREE
;
27285 /* 'properties' is the list of properties that we read. Usually a
27286 single one, but maybe more (eg, in "@property int a, b, c;" there
27291 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27293 cp_lexer_consume_token (parser
->lexer
); /* Eat '@property'. */
27295 /* Parse the optional attribute list... */
27296 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
27299 cp_lexer_consume_token (parser
->lexer
);
27303 bool syntax_error
= false;
27304 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
27307 if (token
->type
!= CPP_NAME
)
27309 cp_parser_error (parser
, "expected identifier");
27312 keyword
= C_RID_CODE (token
->u
.value
);
27313 cp_lexer_consume_token (parser
->lexer
);
27316 case RID_ASSIGN
: property_assign
= true; break;
27317 case RID_COPY
: property_copy
= true; break;
27318 case RID_NONATOMIC
: property_nonatomic
= true; break;
27319 case RID_READONLY
: property_readonly
= true; break;
27320 case RID_READWRITE
: property_readwrite
= true; break;
27321 case RID_RETAIN
: property_retain
= true; break;
27325 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
))
27327 if (keyword
== RID_GETTER
)
27328 cp_parser_error (parser
,
27329 "missing %<=%> (after %<getter%> attribute)");
27331 cp_parser_error (parser
,
27332 "missing %<=%> (after %<setter%> attribute)");
27333 syntax_error
= true;
27336 cp_lexer_consume_token (parser
->lexer
); /* eat the = */
27337 if (!cp_parser_objc_selector_p (cp_lexer_peek_token (parser
->lexer
)->type
))
27339 cp_parser_error (parser
, "expected identifier");
27340 syntax_error
= true;
27343 if (keyword
== RID_SETTER
)
27345 if (property_setter_ident
!= NULL_TREE
)
27347 cp_parser_error (parser
, "the %<setter%> attribute may only be specified once");
27348 cp_lexer_consume_token (parser
->lexer
);
27351 property_setter_ident
= cp_parser_objc_selector (parser
);
27352 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
27353 cp_parser_error (parser
, "setter name must terminate with %<:%>");
27355 cp_lexer_consume_token (parser
->lexer
);
27359 if (property_getter_ident
!= NULL_TREE
)
27361 cp_parser_error (parser
, "the %<getter%> attribute may only be specified once");
27362 cp_lexer_consume_token (parser
->lexer
);
27365 property_getter_ident
= cp_parser_objc_selector (parser
);
27369 cp_parser_error (parser
, "unknown property attribute");
27370 syntax_error
= true;
27377 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
27378 cp_lexer_consume_token (parser
->lexer
);
27383 /* FIXME: "@property (setter, assign);" will generate a spurious
27384 "error: expected ‘)’ before ‘,’ token". This is because
27385 cp_parser_require, unlike the C counterpart, will produce an
27386 error even if we are in error recovery. */
27387 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
27389 cp_parser_skip_to_closing_parenthesis (parser
,
27390 /*recovering=*/true,
27391 /*or_comma=*/false,
27392 /*consume_paren=*/true);
27396 /* ... and the property declaration(s). */
27397 properties
= cp_parser_objc_struct_declaration (parser
);
27399 if (properties
== error_mark_node
)
27401 cp_parser_skip_to_end_of_statement (parser
);
27402 /* If the next token is now a `;', consume it. */
27403 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
27404 cp_lexer_consume_token (parser
->lexer
);
27408 if (properties
== NULL_TREE
)
27409 cp_parser_error (parser
, "expected identifier");
27412 /* Comma-separated properties are chained together in
27413 reverse order; add them one by one. */
27414 properties
= nreverse (properties
);
27416 for (; properties
; properties
= TREE_CHAIN (properties
))
27417 objc_add_property_declaration (loc
, copy_node (properties
),
27418 property_readonly
, property_readwrite
,
27419 property_assign
, property_retain
,
27420 property_copy
, property_nonatomic
,
27421 property_getter_ident
, property_setter_ident
);
27424 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27427 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
27429 objc-synthesize-declaration:
27430 @synthesize objc-synthesize-identifier-list ;
27432 objc-synthesize-identifier-list:
27433 objc-synthesize-identifier
27434 objc-synthesize-identifier-list, objc-synthesize-identifier
27436 objc-synthesize-identifier
27438 identifier = identifier
27441 @synthesize MyProperty;
27442 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
27444 PS: This function is identical to c_parser_objc_at_synthesize_declaration
27445 for C. Keep them in sync.
27448 cp_parser_objc_at_synthesize_declaration (cp_parser
*parser
)
27450 tree list
= NULL_TREE
;
27452 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27454 cp_lexer_consume_token (parser
->lexer
); /* Eat '@synthesize'. */
27457 tree property
, ivar
;
27458 property
= cp_parser_identifier (parser
);
27459 if (property
== error_mark_node
)
27461 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27464 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
27466 cp_lexer_consume_token (parser
->lexer
);
27467 ivar
= cp_parser_identifier (parser
);
27468 if (ivar
== error_mark_node
)
27470 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27476 list
= chainon (list
, build_tree_list (ivar
, property
));
27477 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
27478 cp_lexer_consume_token (parser
->lexer
);
27482 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27483 objc_add_synthesize_declaration (loc
, list
);
27486 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
27488 objc-dynamic-declaration:
27489 @dynamic identifier-list ;
27492 @dynamic MyProperty;
27493 @dynamic MyProperty, AnotherProperty;
27495 PS: This function is identical to c_parser_objc_at_dynamic_declaration
27496 for C. Keep them in sync.
27499 cp_parser_objc_at_dynamic_declaration (cp_parser
*parser
)
27501 tree list
= NULL_TREE
;
27503 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27505 cp_lexer_consume_token (parser
->lexer
); /* Eat '@dynamic'. */
27509 property
= cp_parser_identifier (parser
);
27510 if (property
== error_mark_node
)
27512 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27515 list
= chainon (list
, build_tree_list (NULL
, property
));
27516 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
27517 cp_lexer_consume_token (parser
->lexer
);
27521 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27522 objc_add_dynamic_declaration (loc
, list
);
27526 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 parsing routines. */
27528 /* Returns name of the next clause.
27529 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
27530 the token is not consumed. Otherwise appropriate pragma_omp_clause is
27531 returned and the token is consumed. */
27533 static pragma_omp_clause
27534 cp_parser_omp_clause_name (cp_parser
*parser
)
27536 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
27538 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_IF
))
27539 result
= PRAGMA_OMP_CLAUSE_IF
;
27540 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_DEFAULT
))
27541 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
27542 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_DELETE
))
27543 result
= PRAGMA_OACC_CLAUSE_DELETE
;
27544 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_PRIVATE
))
27545 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
27546 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
27547 result
= PRAGMA_OMP_CLAUSE_FOR
;
27548 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
27550 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
27551 const char *p
= IDENTIFIER_POINTER (id
);
27556 if (!strcmp ("aligned", p
))
27557 result
= PRAGMA_OMP_CLAUSE_ALIGNED
;
27558 else if (!strcmp ("async", p
))
27559 result
= PRAGMA_OACC_CLAUSE_ASYNC
;
27562 if (!strcmp ("collapse", p
))
27563 result
= PRAGMA_OMP_CLAUSE_COLLAPSE
;
27564 else if (!strcmp ("copy", p
))
27565 result
= PRAGMA_OACC_CLAUSE_COPY
;
27566 else if (!strcmp ("copyin", p
))
27567 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
27568 else if (!strcmp ("copyout", p
))
27569 result
= PRAGMA_OACC_CLAUSE_COPYOUT
;
27570 else if (!strcmp ("copyprivate", p
))
27571 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
27572 else if (!strcmp ("create", p
))
27573 result
= PRAGMA_OACC_CLAUSE_CREATE
;
27576 if (!strcmp ("depend", p
))
27577 result
= PRAGMA_OMP_CLAUSE_DEPEND
;
27578 else if (!strcmp ("device", p
))
27579 result
= PRAGMA_OMP_CLAUSE_DEVICE
;
27580 else if (!strcmp ("deviceptr", p
))
27581 result
= PRAGMA_OACC_CLAUSE_DEVICEPTR
;
27582 else if (!strcmp ("dist_schedule", p
))
27583 result
= PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
;
27586 if (!strcmp ("final", p
))
27587 result
= PRAGMA_OMP_CLAUSE_FINAL
;
27588 else if (!strcmp ("firstprivate", p
))
27589 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
27590 else if (!strcmp ("from", p
))
27591 result
= PRAGMA_OMP_CLAUSE_FROM
;
27594 if (!strcmp ("host", p
))
27595 result
= PRAGMA_OACC_CLAUSE_HOST
;
27598 if (!strcmp ("inbranch", p
))
27599 result
= PRAGMA_OMP_CLAUSE_INBRANCH
;
27602 if (!strcmp ("lastprivate", p
))
27603 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
27604 else if (!strcmp ("linear", p
))
27605 result
= PRAGMA_OMP_CLAUSE_LINEAR
;
27608 if (!strcmp ("map", p
))
27609 result
= PRAGMA_OMP_CLAUSE_MAP
;
27610 else if (!strcmp ("mergeable", p
))
27611 result
= PRAGMA_OMP_CLAUSE_MERGEABLE
;
27612 else if (flag_cilkplus
&& !strcmp ("mask", p
))
27613 result
= PRAGMA_CILK_CLAUSE_MASK
;
27616 if (!strcmp ("notinbranch", p
))
27617 result
= PRAGMA_OMP_CLAUSE_NOTINBRANCH
;
27618 else if (!strcmp ("nowait", p
))
27619 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
27620 else if (flag_cilkplus
&& !strcmp ("nomask", p
))
27621 result
= PRAGMA_CILK_CLAUSE_NOMASK
;
27622 else if (!strcmp ("num_gangs", p
))
27623 result
= PRAGMA_OACC_CLAUSE_NUM_GANGS
;
27624 else if (!strcmp ("num_teams", p
))
27625 result
= PRAGMA_OMP_CLAUSE_NUM_TEAMS
;
27626 else if (!strcmp ("num_threads", p
))
27627 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
27628 else if (!strcmp ("num_workers", p
))
27629 result
= PRAGMA_OACC_CLAUSE_NUM_WORKERS
;
27632 if (!strcmp ("ordered", p
))
27633 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
27636 if (!strcmp ("parallel", p
))
27637 result
= PRAGMA_OMP_CLAUSE_PARALLEL
;
27638 else if (!strcmp ("present", p
))
27639 result
= PRAGMA_OACC_CLAUSE_PRESENT
;
27640 else if (!strcmp ("present_or_copy", p
)
27641 || !strcmp ("pcopy", p
))
27642 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY
;
27643 else if (!strcmp ("present_or_copyin", p
)
27644 || !strcmp ("pcopyin", p
))
27645 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN
;
27646 else if (!strcmp ("present_or_copyout", p
)
27647 || !strcmp ("pcopyout", p
))
27648 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT
;
27649 else if (!strcmp ("present_or_create", p
)
27650 || !strcmp ("pcreate", p
))
27651 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE
;
27652 else if (!strcmp ("proc_bind", p
))
27653 result
= PRAGMA_OMP_CLAUSE_PROC_BIND
;
27656 if (!strcmp ("reduction", p
))
27657 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
27660 if (!strcmp ("safelen", p
))
27661 result
= PRAGMA_OMP_CLAUSE_SAFELEN
;
27662 else if (!strcmp ("schedule", p
))
27663 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
27664 else if (!strcmp ("sections", p
))
27665 result
= PRAGMA_OMP_CLAUSE_SECTIONS
;
27666 else if (!strcmp ("self", p
))
27667 result
= PRAGMA_OACC_CLAUSE_SELF
;
27668 else if (!strcmp ("shared", p
))
27669 result
= PRAGMA_OMP_CLAUSE_SHARED
;
27670 else if (!strcmp ("simdlen", p
))
27671 result
= PRAGMA_OMP_CLAUSE_SIMDLEN
;
27674 if (!strcmp ("taskgroup", p
))
27675 result
= PRAGMA_OMP_CLAUSE_TASKGROUP
;
27676 else if (!strcmp ("thread_limit", p
))
27677 result
= PRAGMA_OMP_CLAUSE_THREAD_LIMIT
;
27678 else if (!strcmp ("to", p
))
27679 result
= PRAGMA_OMP_CLAUSE_TO
;
27682 if (!strcmp ("uniform", p
))
27683 result
= PRAGMA_OMP_CLAUSE_UNIFORM
;
27684 else if (!strcmp ("untied", p
))
27685 result
= PRAGMA_OMP_CLAUSE_UNTIED
;
27688 if (!strcmp ("vector_length", p
))
27689 result
= PRAGMA_OACC_CLAUSE_VECTOR_LENGTH
;
27690 else if (flag_cilkplus
&& !strcmp ("vectorlength", p
))
27691 result
= PRAGMA_CILK_CLAUSE_VECTORLENGTH
;
27694 if (!strcmp ("wait", p
))
27695 result
= PRAGMA_OACC_CLAUSE_WAIT
;
27700 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
27701 cp_lexer_consume_token (parser
->lexer
);
27706 /* Validate that a clause of the given type does not already exist. */
27709 check_no_duplicate_clause (tree clauses
, enum omp_clause_code code
,
27710 const char *name
, location_t location
)
27714 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
27715 if (OMP_CLAUSE_CODE (c
) == code
)
27717 error_at (location
, "too many %qs clauses", name
);
27725 variable-list , identifier
27727 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
27728 colon). An opening parenthesis will have been consumed by the caller.
27730 If KIND is nonzero, create the appropriate node and install the decl
27731 in OMP_CLAUSE_DECL and add the node to the head of the list.
27733 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
27734 return the list created.
27736 COLON can be NULL if only closing parenthesis should end the list,
27737 or pointer to bool which will receive false if the list is terminated
27738 by closing parenthesis or true if the list is terminated by colon. */
27741 cp_parser_omp_var_list_no_open (cp_parser
*parser
, enum omp_clause_code kind
,
27742 tree list
, bool *colon
)
27745 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
27748 parser
->colon_corrects_to_scope_p
= false;
27755 token
= cp_lexer_peek_token (parser
->lexer
);
27756 name
= cp_parser_id_expression (parser
, /*template_p=*/false,
27757 /*check_dependency_p=*/true,
27758 /*template_p=*/NULL
,
27759 /*declarator_p=*/false,
27760 /*optional_p=*/false);
27761 if (name
== error_mark_node
)
27764 decl
= cp_parser_lookup_name_simple (parser
, name
, token
->location
);
27765 if (decl
== error_mark_node
)
27766 cp_parser_name_lookup_error (parser
, name
, decl
, NLE_NULL
,
27768 else if (kind
!= 0)
27772 case OMP_CLAUSE__CACHE_
:
27773 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_OPEN_SQUARE
)
27775 error_at (token
->location
, "expected %<[%>");
27776 decl
= error_mark_node
;
27779 /* FALL THROUGH. */
27780 case OMP_CLAUSE_MAP
:
27781 case OMP_CLAUSE_FROM
:
27782 case OMP_CLAUSE_TO
:
27783 case OMP_CLAUSE_DEPEND
:
27784 while (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
27786 tree low_bound
= NULL_TREE
, length
= NULL_TREE
;
27788 parser
->colon_corrects_to_scope_p
= false;
27789 cp_lexer_consume_token (parser
->lexer
);
27790 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
27791 low_bound
= cp_parser_expression (parser
);
27793 parser
->colon_corrects_to_scope_p
27794 = saved_colon_corrects_to_scope_p
;
27795 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_SQUARE
))
27796 length
= integer_one_node
;
27799 /* Look for `:'. */
27800 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
27802 if (!cp_lexer_next_token_is (parser
->lexer
,
27804 length
= cp_parser_expression (parser
);
27806 /* Look for the closing `]'. */
27807 if (!cp_parser_require (parser
, CPP_CLOSE_SQUARE
,
27811 if (kind
== OMP_CLAUSE__CACHE_
)
27813 if (TREE_CODE (low_bound
) != INTEGER_CST
27814 && !TREE_READONLY (low_bound
))
27816 error_at (token
->location
,
27817 "%qD is not a constant", low_bound
);
27818 decl
= error_mark_node
;
27821 if (TREE_CODE (length
) != INTEGER_CST
27822 && !TREE_READONLY (length
))
27824 error_at (token
->location
,
27825 "%qD is not a constant", length
);
27826 decl
= error_mark_node
;
27830 decl
= tree_cons (low_bound
, length
, decl
);
27837 tree u
= build_omp_clause (token
->location
, kind
);
27838 OMP_CLAUSE_DECL (u
) = decl
;
27839 OMP_CLAUSE_CHAIN (u
) = list
;
27843 list
= tree_cons (decl
, NULL_TREE
, list
);
27846 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
27848 cp_lexer_consume_token (parser
->lexer
);
27852 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
27854 if (colon
!= NULL
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
27857 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
27861 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
27865 /* Try to resync to an unnested comma. Copied from
27866 cp_parser_parenthesized_expression_list. */
27869 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
27870 ending
= cp_parser_skip_to_closing_parenthesis (parser
,
27871 /*recovering=*/true,
27873 /*consume_paren=*/true);
27881 /* Similarly, but expect leading and trailing parenthesis. This is a very
27882 common case for omp clauses. */
27885 cp_parser_omp_var_list (cp_parser
*parser
, enum omp_clause_code kind
, tree list
)
27887 if (cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
27888 return cp_parser_omp_var_list_no_open (parser
, kind
, list
, NULL
);
27893 copy ( variable-list )
27894 copyin ( variable-list )
27895 copyout ( variable-list )
27896 create ( variable-list )
27897 delete ( variable-list )
27898 present ( variable-list )
27899 present_or_copy ( variable-list )
27900 pcopy ( variable-list )
27901 present_or_copyin ( variable-list )
27902 pcopyin ( variable-list )
27903 present_or_copyout ( variable-list )
27904 pcopyout ( variable-list )
27905 present_or_create ( variable-list )
27906 pcreate ( variable-list ) */
27909 cp_parser_oacc_data_clause (cp_parser
*parser
, pragma_omp_clause c_kind
,
27912 enum gomp_map_kind kind
;
27915 case PRAGMA_OACC_CLAUSE_COPY
:
27916 kind
= GOMP_MAP_FORCE_TOFROM
;
27918 case PRAGMA_OACC_CLAUSE_COPYIN
:
27919 kind
= GOMP_MAP_FORCE_TO
;
27921 case PRAGMA_OACC_CLAUSE_COPYOUT
:
27922 kind
= GOMP_MAP_FORCE_FROM
;
27924 case PRAGMA_OACC_CLAUSE_CREATE
:
27925 kind
= GOMP_MAP_FORCE_ALLOC
;
27927 case PRAGMA_OACC_CLAUSE_DELETE
:
27928 kind
= GOMP_MAP_FORCE_DEALLOC
;
27930 case PRAGMA_OACC_CLAUSE_DEVICE
:
27931 kind
= GOMP_MAP_FORCE_TO
;
27933 case PRAGMA_OACC_CLAUSE_HOST
:
27934 case PRAGMA_OACC_CLAUSE_SELF
:
27935 kind
= GOMP_MAP_FORCE_FROM
;
27937 case PRAGMA_OACC_CLAUSE_PRESENT
:
27938 kind
= GOMP_MAP_FORCE_PRESENT
;
27940 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY
:
27941 kind
= GOMP_MAP_TOFROM
;
27943 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN
:
27944 kind
= GOMP_MAP_TO
;
27946 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT
:
27947 kind
= GOMP_MAP_FROM
;
27949 case PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE
:
27950 kind
= GOMP_MAP_ALLOC
;
27953 gcc_unreachable ();
27956 nl
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_MAP
, list
);
27958 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
27959 OMP_CLAUSE_SET_MAP_KIND (c
, kind
);
27965 deviceptr ( variable-list ) */
27968 cp_parser_oacc_data_clause_deviceptr (cp_parser
*parser
, tree list
)
27970 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27973 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
27974 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
27975 variable-list must only allow for pointer variables. */
27976 vars
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_ERROR
, NULL
);
27977 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
27979 tree v
= TREE_PURPOSE (t
);
27981 /* FIXME diagnostics: Ideally we should keep individual
27982 locations for all the variables in the var list to make the
27983 following errors more precise. Perhaps
27984 c_parser_omp_var_list_parens should construct a list of
27985 locations to go along with the var list. */
27987 if (TREE_CODE (v
) != VAR_DECL
)
27988 error_at (loc
, "%qD is not a variable", v
);
27989 else if (TREE_TYPE (v
) == error_mark_node
)
27991 else if (!POINTER_TYPE_P (TREE_TYPE (v
)))
27992 error_at (loc
, "%qD is not a pointer variable", v
);
27994 tree u
= build_omp_clause (loc
, OMP_CLAUSE_MAP
);
27995 OMP_CLAUSE_SET_MAP_KIND (u
, GOMP_MAP_FORCE_DEVICEPTR
);
27996 OMP_CLAUSE_DECL (u
) = v
;
27997 OMP_CLAUSE_CHAIN (u
) = list
;
28005 vector_length ( expression ) */
28008 cp_parser_oacc_clause_vector_length (cp_parser
*parser
, tree list
)
28011 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28012 bool error
= false;
28014 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28017 t
= cp_parser_condition (parser
);
28018 if (t
== error_mark_node
|| !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
28020 error_at (location
, "expected positive integer expression");
28024 if (error
|| !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28026 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28027 /*or_comma=*/false,
28028 /*consume_paren=*/true);
28032 check_no_duplicate_clause (list
, OMP_CLAUSE_VECTOR_LENGTH
, "vector_length",
28035 c
= build_omp_clause (location
, OMP_CLAUSE_VECTOR_LENGTH
);
28036 OMP_CLAUSE_VECTOR_LENGTH_EXPR (c
) = t
;
28037 OMP_CLAUSE_CHAIN (c
) = list
;
28044 Parse wait clause or directive parameters. */
28047 cp_parser_oacc_wait_list (cp_parser
*parser
, location_t clause_loc
, tree list
)
28049 vec
<tree
, va_gc
> *args
;
28052 args
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
28054 /*allow_expansion_p=*/true,
28055 /*non_constant_p=*/NULL
);
28057 if (args
== NULL
|| args
->length () == 0)
28059 cp_parser_error (parser
, "expected integer expression before ')'");
28061 release_tree_vector (args
);
28065 args_tree
= build_tree_list_vec (args
);
28067 release_tree_vector (args
);
28069 for (t
= args_tree
; t
; t
= TREE_CHAIN (t
))
28071 tree targ
= TREE_VALUE (t
);
28073 if (targ
!= error_mark_node
)
28075 if (!INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
28076 error ("%<wait%> expression must be integral");
28079 tree c
= build_omp_clause (clause_loc
, OMP_CLAUSE_WAIT
);
28081 mark_rvalue_use (targ
);
28082 OMP_CLAUSE_DECL (c
) = targ
;
28083 OMP_CLAUSE_CHAIN (c
) = list
;
28093 wait ( int-expr-list ) */
28096 cp_parser_oacc_clause_wait (cp_parser
*parser
, tree list
)
28098 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28100 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_OPEN_PAREN
)
28103 list
= cp_parser_oacc_wait_list (parser
, location
, list
);
28109 collapse ( constant-expression ) */
28112 cp_parser_omp_clause_collapse (cp_parser
*parser
, tree list
, location_t location
)
28118 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
28119 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28122 num
= cp_parser_constant_expression (parser
);
28124 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28125 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28126 /*or_comma=*/false,
28127 /*consume_paren=*/true);
28129 if (num
== error_mark_node
)
28131 num
= fold_non_dependent_expr (num
);
28132 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
28133 || !tree_fits_shwi_p (num
)
28134 || (n
= tree_to_shwi (num
)) <= 0
28137 error_at (loc
, "collapse argument needs positive constant integer expression");
28141 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse", location
);
28142 c
= build_omp_clause (loc
, OMP_CLAUSE_COLLAPSE
);
28143 OMP_CLAUSE_CHAIN (c
) = list
;
28144 OMP_CLAUSE_COLLAPSE_EXPR (c
) = num
;
28150 default ( shared | none ) */
28153 cp_parser_omp_clause_default (cp_parser
*parser
, tree list
, location_t location
)
28155 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
28158 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28160 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
28162 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28163 const char *p
= IDENTIFIER_POINTER (id
);
28168 if (strcmp ("none", p
) != 0)
28170 kind
= OMP_CLAUSE_DEFAULT_NONE
;
28174 if (strcmp ("shared", p
) != 0)
28176 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
28183 cp_lexer_consume_token (parser
->lexer
);
28188 cp_parser_error (parser
, "expected %<none%> or %<shared%>");
28191 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28192 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28193 /*or_comma=*/false,
28194 /*consume_paren=*/true);
28196 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
28199 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default", location
);
28200 c
= build_omp_clause (location
, OMP_CLAUSE_DEFAULT
);
28201 OMP_CLAUSE_CHAIN (c
) = list
;
28202 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
28208 final ( expression ) */
28211 cp_parser_omp_clause_final (cp_parser
*parser
, tree list
, location_t location
)
28215 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28218 t
= cp_parser_condition (parser
);
28220 if (t
== error_mark_node
28221 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28222 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28223 /*or_comma=*/false,
28224 /*consume_paren=*/true);
28226 check_no_duplicate_clause (list
, OMP_CLAUSE_FINAL
, "final", location
);
28228 c
= build_omp_clause (location
, OMP_CLAUSE_FINAL
);
28229 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
28230 OMP_CLAUSE_CHAIN (c
) = list
;
28236 if ( expression ) */
28239 cp_parser_omp_clause_if (cp_parser
*parser
, tree list
, location_t location
)
28243 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28246 t
= cp_parser_condition (parser
);
28248 if (t
== error_mark_node
28249 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28250 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28251 /*or_comma=*/false,
28252 /*consume_paren=*/true);
28254 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if", location
);
28256 c
= build_omp_clause (location
, OMP_CLAUSE_IF
);
28257 OMP_CLAUSE_IF_EXPR (c
) = t
;
28258 OMP_CLAUSE_CHAIN (c
) = list
;
28267 cp_parser_omp_clause_mergeable (cp_parser
* /*parser*/,
28268 tree list
, location_t location
)
28272 check_no_duplicate_clause (list
, OMP_CLAUSE_MERGEABLE
, "mergeable",
28275 c
= build_omp_clause (location
, OMP_CLAUSE_MERGEABLE
);
28276 OMP_CLAUSE_CHAIN (c
) = list
;
28284 cp_parser_omp_clause_nowait (cp_parser
* /*parser*/,
28285 tree list
, location_t location
)
28289 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait", location
);
28291 c
= build_omp_clause (location
, OMP_CLAUSE_NOWAIT
);
28292 OMP_CLAUSE_CHAIN (c
) = list
;
28297 num_gangs ( expression ) */
28300 cp_parser_omp_clause_num_gangs (cp_parser
*parser
, tree list
)
28303 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28305 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28308 t
= cp_parser_condition (parser
);
28310 if (t
== error_mark_node
28311 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28312 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28313 /*or_comma=*/false,
28314 /*consume_paren=*/true);
28316 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
28318 error_at (location
, "expected positive integer expression");
28322 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_GANGS
, "num_gangs", location
);
28324 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_GANGS
);
28325 OMP_CLAUSE_NUM_GANGS_EXPR (c
) = t
;
28326 OMP_CLAUSE_CHAIN (c
) = list
;
28333 num_threads ( expression ) */
28336 cp_parser_omp_clause_num_threads (cp_parser
*parser
, tree list
,
28337 location_t location
)
28341 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28344 t
= cp_parser_expression (parser
);
28346 if (t
== error_mark_node
28347 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28348 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28349 /*or_comma=*/false,
28350 /*consume_paren=*/true);
28352 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
,
28353 "num_threads", location
);
28355 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_THREADS
);
28356 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
28357 OMP_CLAUSE_CHAIN (c
) = list
;
28363 num_workers ( expression ) */
28366 cp_parser_omp_clause_num_workers (cp_parser
*parser
, tree list
)
28369 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28371 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28374 t
= cp_parser_condition (parser
);
28376 if (t
== error_mark_node
28377 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28378 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28379 /*or_comma=*/false,
28380 /*consume_paren=*/true);
28382 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
28384 error_at (location
, "expected positive integer expression");
28388 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_WORKERS
, "num_gangs",
28391 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_WORKERS
);
28392 OMP_CLAUSE_NUM_WORKERS_EXPR (c
) = t
;
28393 OMP_CLAUSE_CHAIN (c
) = list
;
28403 cp_parser_omp_clause_ordered (cp_parser
* /*parser*/,
28404 tree list
, location_t location
)
28408 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
,
28409 "ordered", location
);
28411 c
= build_omp_clause (location
, OMP_CLAUSE_ORDERED
);
28412 OMP_CLAUSE_CHAIN (c
) = list
;
28417 reduction ( reduction-operator : variable-list )
28419 reduction-operator:
28420 One of: + * - & ^ | && ||
28424 reduction-operator:
28425 One of: + * - & ^ | && || min max
28429 reduction-operator:
28430 One of: + * - & ^ | && ||
28434 cp_parser_omp_clause_reduction (cp_parser
*parser
, tree list
)
28436 enum tree_code code
= ERROR_MARK
;
28437 tree nlist
, c
, id
= NULL_TREE
;
28439 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28442 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
28444 case CPP_PLUS
: code
= PLUS_EXPR
; break;
28445 case CPP_MULT
: code
= MULT_EXPR
; break;
28446 case CPP_MINUS
: code
= MINUS_EXPR
; break;
28447 case CPP_AND
: code
= BIT_AND_EXPR
; break;
28448 case CPP_XOR
: code
= BIT_XOR_EXPR
; break;
28449 case CPP_OR
: code
= BIT_IOR_EXPR
; break;
28450 case CPP_AND_AND
: code
= TRUTH_ANDIF_EXPR
; break;
28451 case CPP_OR_OR
: code
= TRUTH_ORIF_EXPR
; break;
28455 if (code
!= ERROR_MARK
)
28456 cp_lexer_consume_token (parser
->lexer
);
28459 bool saved_colon_corrects_to_scope_p
;
28460 saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
28461 parser
->colon_corrects_to_scope_p
= false;
28462 id
= cp_parser_id_expression (parser
, /*template_p=*/false,
28463 /*check_dependency_p=*/true,
28464 /*template_p=*/NULL
,
28465 /*declarator_p=*/false,
28466 /*optional_p=*/false);
28467 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
28468 if (identifier_p (id
))
28470 const char *p
= IDENTIFIER_POINTER (id
);
28472 if (strcmp (p
, "min") == 0)
28474 else if (strcmp (p
, "max") == 0)
28476 else if (id
== ansi_opname (PLUS_EXPR
))
28478 else if (id
== ansi_opname (MULT_EXPR
))
28480 else if (id
== ansi_opname (MINUS_EXPR
))
28482 else if (id
== ansi_opname (BIT_AND_EXPR
))
28483 code
= BIT_AND_EXPR
;
28484 else if (id
== ansi_opname (BIT_IOR_EXPR
))
28485 code
= BIT_IOR_EXPR
;
28486 else if (id
== ansi_opname (BIT_XOR_EXPR
))
28487 code
= BIT_XOR_EXPR
;
28488 else if (id
== ansi_opname (TRUTH_ANDIF_EXPR
))
28489 code
= TRUTH_ANDIF_EXPR
;
28490 else if (id
== ansi_opname (TRUTH_ORIF_EXPR
))
28491 code
= TRUTH_ORIF_EXPR
;
28492 id
= omp_reduction_id (code
, id
, NULL_TREE
);
28493 tree scope
= parser
->scope
;
28495 id
= build_qualified_name (NULL_TREE
, scope
, id
, false);
28496 parser
->scope
= NULL_TREE
;
28497 parser
->qualifying_scope
= NULL_TREE
;
28498 parser
->object_scope
= NULL_TREE
;
28502 error ("invalid reduction-identifier");
28504 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28505 /*or_comma=*/false,
28506 /*consume_paren=*/true);
28511 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
28514 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_REDUCTION
, list
,
28516 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28518 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
28519 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = id
;
28526 schedule ( schedule-kind )
28527 schedule ( schedule-kind , expression )
28530 static | dynamic | guided | runtime | auto */
28533 cp_parser_omp_clause_schedule (cp_parser
*parser
, tree list
, location_t location
)
28537 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28540 c
= build_omp_clause (location
, OMP_CLAUSE_SCHEDULE
);
28542 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
28544 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28545 const char *p
= IDENTIFIER_POINTER (id
);
28550 if (strcmp ("dynamic", p
) != 0)
28552 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
28556 if (strcmp ("guided", p
) != 0)
28558 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
28562 if (strcmp ("runtime", p
) != 0)
28564 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
28571 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC
))
28572 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
28573 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AUTO
))
28574 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_AUTO
;
28577 cp_lexer_consume_token (parser
->lexer
);
28579 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
28582 cp_lexer_consume_token (parser
->lexer
);
28584 token
= cp_lexer_peek_token (parser
->lexer
);
28585 t
= cp_parser_assignment_expression (parser
);
28587 if (t
== error_mark_node
)
28589 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
28590 error_at (token
->location
, "schedule %<runtime%> does not take "
28591 "a %<chunk_size%> parameter");
28592 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_AUTO
)
28593 error_at (token
->location
, "schedule %<auto%> does not take "
28594 "a %<chunk_size%> parameter");
28596 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
28598 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28601 else if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_COMMA_CLOSE_PAREN
))
28604 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule", location
);
28605 OMP_CLAUSE_CHAIN (c
) = list
;
28609 cp_parser_error (parser
, "invalid schedule kind");
28611 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28612 /*or_comma=*/false,
28613 /*consume_paren=*/true);
28621 cp_parser_omp_clause_untied (cp_parser
* /*parser*/,
28622 tree list
, location_t location
)
28626 check_no_duplicate_clause (list
, OMP_CLAUSE_UNTIED
, "untied", location
);
28628 c
= build_omp_clause (location
, OMP_CLAUSE_UNTIED
);
28629 OMP_CLAUSE_CHAIN (c
) = list
;
28638 cp_parser_omp_clause_branch (cp_parser
* /*parser*/, enum omp_clause_code code
,
28639 tree list
, location_t location
)
28641 check_no_duplicate_clause (list
, code
, omp_clause_code_name
[code
], location
);
28642 tree c
= build_omp_clause (location
, code
);
28643 OMP_CLAUSE_CHAIN (c
) = list
;
28654 cp_parser_omp_clause_cancelkind (cp_parser
* /*parser*/,
28655 enum omp_clause_code code
,
28656 tree list
, location_t location
)
28658 tree c
= build_omp_clause (location
, code
);
28659 OMP_CLAUSE_CHAIN (c
) = list
;
28664 num_teams ( expression ) */
28667 cp_parser_omp_clause_num_teams (cp_parser
*parser
, tree list
,
28668 location_t location
)
28672 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28675 t
= cp_parser_expression (parser
);
28677 if (t
== error_mark_node
28678 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28679 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28680 /*or_comma=*/false,
28681 /*consume_paren=*/true);
28683 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_TEAMS
,
28684 "num_teams", location
);
28686 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_TEAMS
);
28687 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = t
;
28688 OMP_CLAUSE_CHAIN (c
) = list
;
28694 thread_limit ( expression ) */
28697 cp_parser_omp_clause_thread_limit (cp_parser
*parser
, tree list
,
28698 location_t location
)
28702 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28705 t
= cp_parser_expression (parser
);
28707 if (t
== error_mark_node
28708 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28709 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28710 /*or_comma=*/false,
28711 /*consume_paren=*/true);
28713 check_no_duplicate_clause (list
, OMP_CLAUSE_THREAD_LIMIT
,
28714 "thread_limit", location
);
28716 c
= build_omp_clause (location
, OMP_CLAUSE_THREAD_LIMIT
);
28717 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = t
;
28718 OMP_CLAUSE_CHAIN (c
) = list
;
28724 aligned ( variable-list )
28725 aligned ( variable-list : constant-expression ) */
28728 cp_parser_omp_clause_aligned (cp_parser
*parser
, tree list
)
28730 tree nlist
, c
, alignment
= NULL_TREE
;
28733 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28736 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_ALIGNED
, list
,
28741 alignment
= cp_parser_constant_expression (parser
);
28743 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28744 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28745 /*or_comma=*/false,
28746 /*consume_paren=*/true);
28748 if (alignment
== error_mark_node
)
28749 alignment
= NULL_TREE
;
28752 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28753 OMP_CLAUSE_ALIGNED_ALIGNMENT (c
) = alignment
;
28759 linear ( variable-list )
28760 linear ( variable-list : expression ) */
28763 cp_parser_omp_clause_linear (cp_parser
*parser
, tree list
,
28764 bool is_cilk_simd_fn
)
28766 tree nlist
, c
, step
= integer_one_node
;
28769 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28772 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_LINEAR
, list
,
28777 step
= cp_parser_expression (parser
);
28779 if (is_cilk_simd_fn
&& TREE_CODE (step
) == PARM_DECL
)
28781 sorry ("using parameters for %<linear%> step is not supported yet");
28782 step
= integer_one_node
;
28784 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28785 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28786 /*or_comma=*/false,
28787 /*consume_paren=*/true);
28789 if (step
== error_mark_node
)
28793 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28794 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
28800 safelen ( constant-expression ) */
28803 cp_parser_omp_clause_safelen (cp_parser
*parser
, tree list
,
28804 location_t location
)
28808 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28811 t
= cp_parser_constant_expression (parser
);
28813 if (t
== error_mark_node
28814 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28815 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28816 /*or_comma=*/false,
28817 /*consume_paren=*/true);
28819 check_no_duplicate_clause (list
, OMP_CLAUSE_SAFELEN
, "safelen", location
);
28821 c
= build_omp_clause (location
, OMP_CLAUSE_SAFELEN
);
28822 OMP_CLAUSE_SAFELEN_EXPR (c
) = t
;
28823 OMP_CLAUSE_CHAIN (c
) = list
;
28829 simdlen ( constant-expression ) */
28832 cp_parser_omp_clause_simdlen (cp_parser
*parser
, tree list
,
28833 location_t location
)
28837 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28840 t
= cp_parser_constant_expression (parser
);
28842 if (t
== error_mark_node
28843 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28844 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28845 /*or_comma=*/false,
28846 /*consume_paren=*/true);
28848 check_no_duplicate_clause (list
, OMP_CLAUSE_SIMDLEN
, "simdlen", location
);
28850 c
= build_omp_clause (location
, OMP_CLAUSE_SIMDLEN
);
28851 OMP_CLAUSE_SIMDLEN_EXPR (c
) = t
;
28852 OMP_CLAUSE_CHAIN (c
) = list
;
28858 depend ( depend-kind : variable-list )
28861 in | out | inout */
28864 cp_parser_omp_clause_depend (cp_parser
*parser
, tree list
)
28867 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_INOUT
;
28869 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28872 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
28874 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28875 const char *p
= IDENTIFIER_POINTER (id
);
28877 if (strcmp ("in", p
) == 0)
28878 kind
= OMP_CLAUSE_DEPEND_IN
;
28879 else if (strcmp ("inout", p
) == 0)
28880 kind
= OMP_CLAUSE_DEPEND_INOUT
;
28881 else if (strcmp ("out", p
) == 0)
28882 kind
= OMP_CLAUSE_DEPEND_OUT
;
28889 cp_lexer_consume_token (parser
->lexer
);
28890 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
28893 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_DEPEND
, list
,
28896 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28897 OMP_CLAUSE_DEPEND_KIND (c
) = kind
;
28902 cp_parser_error (parser
, "invalid depend kind");
28904 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28905 /*or_comma=*/false,
28906 /*consume_paren=*/true);
28911 map ( map-kind : variable-list )
28912 map ( variable-list )
28915 alloc | to | from | tofrom */
28918 cp_parser_omp_clause_map (cp_parser
*parser
, tree list
)
28921 enum gomp_map_kind kind
= GOMP_MAP_TOFROM
;
28923 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28926 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
28927 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_COLON
)
28929 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28930 const char *p
= IDENTIFIER_POINTER (id
);
28932 if (strcmp ("alloc", p
) == 0)
28933 kind
= GOMP_MAP_ALLOC
;
28934 else if (strcmp ("to", p
) == 0)
28935 kind
= GOMP_MAP_TO
;
28936 else if (strcmp ("from", p
) == 0)
28937 kind
= GOMP_MAP_FROM
;
28938 else if (strcmp ("tofrom", p
) == 0)
28939 kind
= GOMP_MAP_TOFROM
;
28942 cp_parser_error (parser
, "invalid map kind");
28943 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28944 /*or_comma=*/false,
28945 /*consume_paren=*/true);
28948 cp_lexer_consume_token (parser
->lexer
);
28949 cp_lexer_consume_token (parser
->lexer
);
28952 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_MAP
, list
,
28955 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28956 OMP_CLAUSE_SET_MAP_KIND (c
, kind
);
28962 device ( expression ) */
28965 cp_parser_omp_clause_device (cp_parser
*parser
, tree list
,
28966 location_t location
)
28970 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28973 t
= cp_parser_expression (parser
);
28975 if (t
== error_mark_node
28976 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28977 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28978 /*or_comma=*/false,
28979 /*consume_paren=*/true);
28981 check_no_duplicate_clause (list
, OMP_CLAUSE_DEVICE
,
28982 "device", location
);
28984 c
= build_omp_clause (location
, OMP_CLAUSE_DEVICE
);
28985 OMP_CLAUSE_DEVICE_ID (c
) = t
;
28986 OMP_CLAUSE_CHAIN (c
) = list
;
28992 dist_schedule ( static )
28993 dist_schedule ( static , expression ) */
28996 cp_parser_omp_clause_dist_schedule (cp_parser
*parser
, tree list
,
28997 location_t location
)
29001 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
29004 c
= build_omp_clause (location
, OMP_CLAUSE_DIST_SCHEDULE
);
29006 if (!cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC
))
29008 cp_lexer_consume_token (parser
->lexer
);
29010 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
29012 cp_lexer_consume_token (parser
->lexer
);
29014 t
= cp_parser_assignment_expression (parser
);
29016 if (t
== error_mark_node
)
29018 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
) = t
;
29020 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
29023 else if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_COMMA_CLOSE_PAREN
))
29026 check_no_duplicate_clause (list
, OMP_CLAUSE_DIST_SCHEDULE
, "dist_schedule",
29028 OMP_CLAUSE_CHAIN (c
) = list
;
29032 cp_parser_error (parser
, "invalid dist_schedule kind");
29034 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
29035 /*or_comma=*/false,
29036 /*consume_paren=*/true);
29041 proc_bind ( proc-bind-kind )
29044 master | close | spread */
29047 cp_parser_omp_clause_proc_bind (cp_parser
*parser
, tree list
,
29048 location_t location
)
29051 enum omp_clause_proc_bind_kind kind
;
29053 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
29056 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29058 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29059 const char *p
= IDENTIFIER_POINTER (id
);
29061 if (strcmp ("master", p
) == 0)
29062 kind
= OMP_CLAUSE_PROC_BIND_MASTER
;
29063 else if (strcmp ("close", p
) == 0)
29064 kind
= OMP_CLAUSE_PROC_BIND_CLOSE
;
29065 else if (strcmp ("spread", p
) == 0)
29066 kind
= OMP_CLAUSE_PROC_BIND_SPREAD
;
29073 cp_lexer_consume_token (parser
->lexer
);
29074 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_COMMA_CLOSE_PAREN
))
29077 c
= build_omp_clause (location
, OMP_CLAUSE_PROC_BIND
);
29078 check_no_duplicate_clause (list
, OMP_CLAUSE_PROC_BIND
, "proc_bind",
29080 OMP_CLAUSE_PROC_BIND_KIND (c
) = kind
;
29081 OMP_CLAUSE_CHAIN (c
) = list
;
29085 cp_parser_error (parser
, "invalid depend kind");
29087 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
29088 /*or_comma=*/false,
29089 /*consume_paren=*/true);
29094 async [( int-expr )] */
29097 cp_parser_oacc_clause_async (cp_parser
*parser
, tree list
)
29100 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
29102 t
= build_int_cst (integer_type_node
, GOMP_ASYNC_NOVAL
);
29104 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
29106 cp_lexer_consume_token (parser
->lexer
);
29108 t
= cp_parser_expression (parser
);
29109 if (t
== error_mark_node
29110 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
29111 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
29112 /*or_comma=*/false,
29113 /*consume_paren=*/true);
29116 check_no_duplicate_clause (list
, OMP_CLAUSE_ASYNC
, "async", loc
);
29118 c
= build_omp_clause (loc
, OMP_CLAUSE_ASYNC
);
29119 OMP_CLAUSE_ASYNC_EXPR (c
) = t
;
29120 OMP_CLAUSE_CHAIN (c
) = list
;
29126 /* Parse all OpenACC clauses. The set clauses allowed by the directive
29127 is a bitmask in MASK. Return the list of clauses found. */
29130 cp_parser_oacc_all_clauses (cp_parser
*parser
, omp_clause_mask mask
,
29131 const char *where
, cp_token
*pragma_tok
,
29132 bool finish_p
= true)
29134 tree clauses
= NULL
;
29137 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
29140 pragma_omp_clause c_kind
;
29141 const char *c_name
;
29142 tree prev
= clauses
;
29144 if (!first
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
29145 cp_lexer_consume_token (parser
->lexer
);
29147 here
= cp_lexer_peek_token (parser
->lexer
)->location
;
29148 c_kind
= cp_parser_omp_clause_name (parser
);
29152 case PRAGMA_OACC_CLAUSE_ASYNC
:
29153 clauses
= cp_parser_oacc_clause_async (parser
, clauses
);
29156 case PRAGMA_OACC_CLAUSE_COLLAPSE
:
29157 clauses
= cp_parser_omp_clause_collapse (parser
, clauses
, here
);
29158 c_name
= "collapse";
29160 case PRAGMA_OACC_CLAUSE_COPY
:
29161 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29164 case PRAGMA_OACC_CLAUSE_COPYIN
:
29165 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29168 case PRAGMA_OACC_CLAUSE_COPYOUT
:
29169 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29170 c_name
= "copyout";
29172 case PRAGMA_OACC_CLAUSE_CREATE
:
29173 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29176 case PRAGMA_OACC_CLAUSE_DELETE
:
29177 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29180 case PRAGMA_OACC_CLAUSE_DEVICE
:
29181 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29184 case PRAGMA_OACC_CLAUSE_DEVICEPTR
:
29185 clauses
= cp_parser_oacc_data_clause_deviceptr (parser
, clauses
);
29186 c_name
= "deviceptr";
29188 case PRAGMA_OACC_CLAUSE_HOST
:
29189 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29192 case PRAGMA_OACC_CLAUSE_IF
:
29193 clauses
= cp_parser_omp_clause_if (parser
, clauses
, here
);
29196 case PRAGMA_OACC_CLAUSE_NUM_GANGS
:
29197 clauses
= cp_parser_omp_clause_num_gangs (parser
, clauses
);
29198 c_name
= "num_gangs";
29200 case PRAGMA_OACC_CLAUSE_NUM_WORKERS
:
29201 clauses
= cp_parser_omp_clause_num_workers (parser
, clauses
);
29202 c_name
= "num_workers";
29204 case PRAGMA_OACC_CLAUSE_PRESENT
:
29205 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29206 c_name
= "present";
29208 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY
:
29209 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29210 c_name
= "present_or_copy";
29212 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN
:
29213 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29214 c_name
= "present_or_copyin";
29216 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT
:
29217 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29218 c_name
= "present_or_copyout";
29220 case PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE
:
29221 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29222 c_name
= "present_or_create";
29224 case PRAGMA_OACC_CLAUSE_REDUCTION
:
29225 clauses
= cp_parser_omp_clause_reduction (parser
, clauses
);
29226 c_name
= "reduction";
29228 case PRAGMA_OACC_CLAUSE_SELF
:
29229 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29232 case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH
:
29233 clauses
= cp_parser_oacc_clause_vector_length (parser
, clauses
);
29234 c_name
= "vector_length";
29236 case PRAGMA_OACC_CLAUSE_WAIT
:
29237 clauses
= cp_parser_oacc_clause_wait (parser
, clauses
);
29241 cp_parser_error (parser
, "expected %<#pragma acc%> clause");
29247 if (((mask
>> c_kind
) & 1) == 0)
29249 /* Remove the invalid clause(s) from the list to avoid
29250 confusing the rest of the compiler. */
29252 error_at (here
, "%qs is not valid for %qs", c_name
, where
);
29257 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
29260 return finish_omp_clauses (clauses
);
29265 /* Parse all OpenMP clauses. The set clauses allowed by the directive
29266 is a bitmask in MASK. Return the list of clauses found; the result
29267 of clause default goes in *pdefault. */
29270 cp_parser_omp_all_clauses (cp_parser
*parser
, omp_clause_mask mask
,
29271 const char *where
, cp_token
*pragma_tok
,
29272 bool finish_p
= true)
29274 tree clauses
= NULL
;
29276 cp_token
*token
= NULL
;
29277 bool cilk_simd_fn
= false;
29279 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
29281 pragma_omp_clause c_kind
;
29282 const char *c_name
;
29283 tree prev
= clauses
;
29285 if (!first
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
29286 cp_lexer_consume_token (parser
->lexer
);
29288 token
= cp_lexer_peek_token (parser
->lexer
);
29289 c_kind
= cp_parser_omp_clause_name (parser
);
29293 case PRAGMA_OMP_CLAUSE_COLLAPSE
:
29294 clauses
= cp_parser_omp_clause_collapse (parser
, clauses
,
29296 c_name
= "collapse";
29298 case PRAGMA_OMP_CLAUSE_COPYIN
:
29299 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_COPYIN
, clauses
);
29302 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
29303 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_COPYPRIVATE
,
29305 c_name
= "copyprivate";
29307 case PRAGMA_OMP_CLAUSE_DEFAULT
:
29308 clauses
= cp_parser_omp_clause_default (parser
, clauses
,
29310 c_name
= "default";
29312 case PRAGMA_OMP_CLAUSE_FINAL
:
29313 clauses
= cp_parser_omp_clause_final (parser
, clauses
, token
->location
);
29316 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
29317 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_FIRSTPRIVATE
,
29319 c_name
= "firstprivate";
29321 case PRAGMA_OMP_CLAUSE_IF
:
29322 clauses
= cp_parser_omp_clause_if (parser
, clauses
, token
->location
);
29325 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
29326 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_LASTPRIVATE
,
29328 c_name
= "lastprivate";
29330 case PRAGMA_OMP_CLAUSE_MERGEABLE
:
29331 clauses
= cp_parser_omp_clause_mergeable (parser
, clauses
,
29333 c_name
= "mergeable";
29335 case PRAGMA_OMP_CLAUSE_NOWAIT
:
29336 clauses
= cp_parser_omp_clause_nowait (parser
, clauses
, token
->location
);
29339 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
29340 clauses
= cp_parser_omp_clause_num_threads (parser
, clauses
,
29342 c_name
= "num_threads";
29344 case PRAGMA_OMP_CLAUSE_ORDERED
:
29345 clauses
= cp_parser_omp_clause_ordered (parser
, clauses
,
29347 c_name
= "ordered";
29349 case PRAGMA_OMP_CLAUSE_PRIVATE
:
29350 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_PRIVATE
,
29352 c_name
= "private";
29354 case PRAGMA_OMP_CLAUSE_REDUCTION
:
29355 clauses
= cp_parser_omp_clause_reduction (parser
, clauses
);
29356 c_name
= "reduction";
29358 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
29359 clauses
= cp_parser_omp_clause_schedule (parser
, clauses
,
29361 c_name
= "schedule";
29363 case PRAGMA_OMP_CLAUSE_SHARED
:
29364 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_SHARED
,
29368 case PRAGMA_OMP_CLAUSE_UNTIED
:
29369 clauses
= cp_parser_omp_clause_untied (parser
, clauses
,
29373 case PRAGMA_OMP_CLAUSE_INBRANCH
:
29374 case PRAGMA_CILK_CLAUSE_MASK
:
29375 clauses
= cp_parser_omp_clause_branch (parser
, OMP_CLAUSE_INBRANCH
,
29376 clauses
, token
->location
);
29377 c_name
= "inbranch";
29379 case PRAGMA_OMP_CLAUSE_NOTINBRANCH
:
29380 case PRAGMA_CILK_CLAUSE_NOMASK
:
29381 clauses
= cp_parser_omp_clause_branch (parser
,
29382 OMP_CLAUSE_NOTINBRANCH
,
29383 clauses
, token
->location
);
29384 c_name
= "notinbranch";
29386 case PRAGMA_OMP_CLAUSE_PARALLEL
:
29387 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_PARALLEL
,
29388 clauses
, token
->location
);
29389 c_name
= "parallel";
29393 error_at (token
->location
, "%qs must be the first clause of %qs",
29398 case PRAGMA_OMP_CLAUSE_FOR
:
29399 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_FOR
,
29400 clauses
, token
->location
);
29403 goto clause_not_first
;
29405 case PRAGMA_OMP_CLAUSE_SECTIONS
:
29406 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_SECTIONS
,
29407 clauses
, token
->location
);
29408 c_name
= "sections";
29410 goto clause_not_first
;
29412 case PRAGMA_OMP_CLAUSE_TASKGROUP
:
29413 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_TASKGROUP
,
29414 clauses
, token
->location
);
29415 c_name
= "taskgroup";
29417 goto clause_not_first
;
29419 case PRAGMA_OMP_CLAUSE_TO
:
29420 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_TO
,
29424 case PRAGMA_OMP_CLAUSE_FROM
:
29425 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_FROM
,
29429 case PRAGMA_OMP_CLAUSE_UNIFORM
:
29430 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_UNIFORM
,
29432 c_name
= "uniform";
29434 case PRAGMA_OMP_CLAUSE_NUM_TEAMS
:
29435 clauses
= cp_parser_omp_clause_num_teams (parser
, clauses
,
29437 c_name
= "num_teams";
29439 case PRAGMA_OMP_CLAUSE_THREAD_LIMIT
:
29440 clauses
= cp_parser_omp_clause_thread_limit (parser
, clauses
,
29442 c_name
= "thread_limit";
29444 case PRAGMA_OMP_CLAUSE_ALIGNED
:
29445 clauses
= cp_parser_omp_clause_aligned (parser
, clauses
);
29446 c_name
= "aligned";
29448 case PRAGMA_OMP_CLAUSE_LINEAR
:
29449 if (((mask
>> PRAGMA_CILK_CLAUSE_VECTORLENGTH
) & 1) != 0)
29450 cilk_simd_fn
= true;
29451 clauses
= cp_parser_omp_clause_linear (parser
, clauses
, cilk_simd_fn
);
29454 case PRAGMA_OMP_CLAUSE_DEPEND
:
29455 clauses
= cp_parser_omp_clause_depend (parser
, clauses
);
29458 case PRAGMA_OMP_CLAUSE_MAP
:
29459 clauses
= cp_parser_omp_clause_map (parser
, clauses
);
29462 case PRAGMA_OMP_CLAUSE_DEVICE
:
29463 clauses
= cp_parser_omp_clause_device (parser
, clauses
,
29467 case PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
:
29468 clauses
= cp_parser_omp_clause_dist_schedule (parser
, clauses
,
29470 c_name
= "dist_schedule";
29472 case PRAGMA_OMP_CLAUSE_PROC_BIND
:
29473 clauses
= cp_parser_omp_clause_proc_bind (parser
, clauses
,
29475 c_name
= "proc_bind";
29477 case PRAGMA_OMP_CLAUSE_SAFELEN
:
29478 clauses
= cp_parser_omp_clause_safelen (parser
, clauses
,
29480 c_name
= "safelen";
29482 case PRAGMA_OMP_CLAUSE_SIMDLEN
:
29483 clauses
= cp_parser_omp_clause_simdlen (parser
, clauses
,
29485 c_name
= "simdlen";
29487 case PRAGMA_CILK_CLAUSE_VECTORLENGTH
:
29488 clauses
= cp_parser_cilk_simd_vectorlength (parser
, clauses
, true);
29489 c_name
= "simdlen";
29492 cp_parser_error (parser
, "expected %<#pragma omp%> clause");
29498 if (((mask
>> c_kind
) & 1) == 0)
29500 /* Remove the invalid clause(s) from the list to avoid
29501 confusing the rest of the compiler. */
29503 error_at (token
->location
, "%qs is not valid for %qs", c_name
, where
);
29507 /* In Cilk Plus SIMD enabled functions there is no pragma_token, so
29508 no reason to skip to the end. */
29509 if (!(flag_cilkplus
&& pragma_tok
== NULL
))
29510 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
29512 return finish_omp_clauses (clauses
);
29520 In practice, we're also interested in adding the statement to an
29521 outer node. So it is convenient if we work around the fact that
29522 cp_parser_statement calls add_stmt. */
29525 cp_parser_begin_omp_structured_block (cp_parser
*parser
)
29527 unsigned save
= parser
->in_statement
;
29529 /* Only move the values to IN_OMP_BLOCK if they weren't false.
29530 This preserves the "not within loop or switch" style error messages
29531 for nonsense cases like
29537 if (parser
->in_statement
)
29538 parser
->in_statement
= IN_OMP_BLOCK
;
29544 cp_parser_end_omp_structured_block (cp_parser
*parser
, unsigned save
)
29546 parser
->in_statement
= save
;
29550 cp_parser_omp_structured_block (cp_parser
*parser
)
29552 tree stmt
= begin_omp_structured_block ();
29553 unsigned int save
= cp_parser_begin_omp_structured_block (parser
);
29555 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
29557 cp_parser_end_omp_structured_block (parser
, save
);
29558 return finish_omp_structured_block (stmt
);
29562 # pragma omp atomic new-line
29566 x binop= expr | x++ | ++x | x-- | --x
29568 +, *, -, /, &, ^, |, <<, >>
29570 where x is an lvalue expression with scalar type.
29573 # pragma omp atomic new-line
29576 # pragma omp atomic read new-line
29579 # pragma omp atomic write new-line
29582 # pragma omp atomic update new-line
29585 # pragma omp atomic capture new-line
29588 # pragma omp atomic capture new-line
29596 expression-stmt | x = x binop expr
29598 v = expression-stmt
29600 { v = x; update-stmt; } | { update-stmt; v = x; }
29604 expression-stmt | x = x binop expr | x = expr binop x
29608 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
29610 where x and v are lvalue expressions with scalar type. */
29613 cp_parser_omp_atomic (cp_parser
*parser
, cp_token
*pragma_tok
)
29615 tree lhs
= NULL_TREE
, rhs
= NULL_TREE
, v
= NULL_TREE
, lhs1
= NULL_TREE
;
29616 tree rhs1
= NULL_TREE
, orig_lhs
;
29617 enum tree_code code
= OMP_ATOMIC
, opcode
= NOP_EXPR
;
29618 bool structured_block
= false;
29619 bool seq_cst
= false;
29621 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29623 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29624 const char *p
= IDENTIFIER_POINTER (id
);
29626 if (!strcmp (p
, "seq_cst"))
29629 cp_lexer_consume_token (parser
->lexer
);
29630 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
)
29631 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_NAME
)
29632 cp_lexer_consume_token (parser
->lexer
);
29635 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29637 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29638 const char *p
= IDENTIFIER_POINTER (id
);
29640 if (!strcmp (p
, "read"))
29641 code
= OMP_ATOMIC_READ
;
29642 else if (!strcmp (p
, "write"))
29644 else if (!strcmp (p
, "update"))
29646 else if (!strcmp (p
, "capture"))
29647 code
= OMP_ATOMIC_CAPTURE_NEW
;
29651 cp_lexer_consume_token (parser
->lexer
);
29655 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
)
29656 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_NAME
)
29657 cp_lexer_consume_token (parser
->lexer
);
29659 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29661 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29662 const char *p
= IDENTIFIER_POINTER (id
);
29664 if (!strcmp (p
, "seq_cst"))
29667 cp_lexer_consume_token (parser
->lexer
);
29671 cp_parser_require_pragma_eol (parser
, pragma_tok
);
29675 case OMP_ATOMIC_READ
:
29676 case NOP_EXPR
: /* atomic write */
29677 v
= cp_parser_unary_expression (parser
);
29678 if (v
== error_mark_node
)
29680 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
29682 if (code
== NOP_EXPR
)
29683 lhs
= cp_parser_expression (parser
);
29685 lhs
= cp_parser_unary_expression (parser
);
29686 if (lhs
== error_mark_node
)
29688 if (code
== NOP_EXPR
)
29690 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
29698 case OMP_ATOMIC_CAPTURE_NEW
:
29699 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
29701 cp_lexer_consume_token (parser
->lexer
);
29702 structured_block
= true;
29706 v
= cp_parser_unary_expression (parser
);
29707 if (v
== error_mark_node
)
29709 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
29717 lhs
= cp_parser_unary_expression (parser
);
29719 switch (TREE_CODE (lhs
))
29724 case POSTINCREMENT_EXPR
:
29725 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
29726 code
= OMP_ATOMIC_CAPTURE_OLD
;
29728 case PREINCREMENT_EXPR
:
29729 lhs
= TREE_OPERAND (lhs
, 0);
29730 opcode
= PLUS_EXPR
;
29731 rhs
= integer_one_node
;
29734 case POSTDECREMENT_EXPR
:
29735 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
29736 code
= OMP_ATOMIC_CAPTURE_OLD
;
29738 case PREDECREMENT_EXPR
:
29739 lhs
= TREE_OPERAND (lhs
, 0);
29740 opcode
= MINUS_EXPR
;
29741 rhs
= integer_one_node
;
29744 case COMPOUND_EXPR
:
29745 if (TREE_CODE (TREE_OPERAND (lhs
, 0)) == SAVE_EXPR
29746 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == COMPOUND_EXPR
29747 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0)) == MODIFY_EXPR
29748 && TREE_OPERAND (TREE_OPERAND (lhs
, 1), 1) == TREE_OPERAND (lhs
, 0)
29749 && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
29750 (TREE_OPERAND (lhs
, 1), 0), 0)))
29752 /* Undo effects of boolean_increment for post {in,de}crement. */
29753 lhs
= TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0);
29756 if (TREE_CODE (lhs
) == MODIFY_EXPR
29757 && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) == BOOLEAN_TYPE
)
29759 /* Undo effects of boolean_increment. */
29760 if (integer_onep (TREE_OPERAND (lhs
, 1)))
29762 /* This is pre or post increment. */
29763 rhs
= TREE_OPERAND (lhs
, 1);
29764 lhs
= TREE_OPERAND (lhs
, 0);
29766 if (code
== OMP_ATOMIC_CAPTURE_NEW
29767 && !structured_block
29768 && TREE_CODE (orig_lhs
) == COMPOUND_EXPR
)
29769 code
= OMP_ATOMIC_CAPTURE_OLD
;
29775 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
29778 opcode
= MULT_EXPR
;
29781 opcode
= TRUNC_DIV_EXPR
;
29784 opcode
= PLUS_EXPR
;
29787 opcode
= MINUS_EXPR
;
29789 case CPP_LSHIFT_EQ
:
29790 opcode
= LSHIFT_EXPR
;
29792 case CPP_RSHIFT_EQ
:
29793 opcode
= RSHIFT_EXPR
;
29796 opcode
= BIT_AND_EXPR
;
29799 opcode
= BIT_IOR_EXPR
;
29802 opcode
= BIT_XOR_EXPR
;
29805 enum cp_parser_prec oprec
;
29807 cp_lexer_consume_token (parser
->lexer
);
29808 cp_parser_parse_tentatively (parser
);
29809 rhs1
= cp_parser_simple_cast_expression (parser
);
29810 if (rhs1
== error_mark_node
)
29812 cp_parser_abort_tentative_parse (parser
);
29813 cp_parser_simple_cast_expression (parser
);
29816 token
= cp_lexer_peek_token (parser
->lexer
);
29817 if (token
->type
!= CPP_SEMICOLON
&& !cp_tree_equal (lhs
, rhs1
))
29819 cp_parser_abort_tentative_parse (parser
);
29820 cp_parser_parse_tentatively (parser
);
29821 rhs
= cp_parser_binary_expression (parser
, false, true,
29822 PREC_NOT_OPERATOR
, NULL
);
29823 if (rhs
== error_mark_node
)
29825 cp_parser_abort_tentative_parse (parser
);
29826 cp_parser_binary_expression (parser
, false, true,
29827 PREC_NOT_OPERATOR
, NULL
);
29830 switch (TREE_CODE (rhs
))
29833 case TRUNC_DIV_EXPR
:
29842 if (cp_tree_equal (lhs
, TREE_OPERAND (rhs
, 1)))
29844 if (cp_parser_parse_definitely (parser
))
29846 opcode
= TREE_CODE (rhs
);
29847 rhs1
= TREE_OPERAND (rhs
, 0);
29848 rhs
= TREE_OPERAND (rhs
, 1);
29858 cp_parser_abort_tentative_parse (parser
);
29859 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_OLD
)
29861 rhs
= cp_parser_expression (parser
);
29862 if (rhs
== error_mark_node
)
29868 cp_parser_error (parser
,
29869 "invalid form of %<#pragma omp atomic%>");
29872 if (!cp_parser_parse_definitely (parser
))
29874 switch (token
->type
)
29876 case CPP_SEMICOLON
:
29877 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
29879 code
= OMP_ATOMIC_CAPTURE_OLD
;
29884 cp_lexer_consume_token (parser
->lexer
);
29887 else if (structured_block
)
29894 cp_parser_error (parser
,
29895 "invalid form of %<#pragma omp atomic%>");
29898 opcode
= MULT_EXPR
;
29901 opcode
= TRUNC_DIV_EXPR
;
29904 opcode
= PLUS_EXPR
;
29907 opcode
= MINUS_EXPR
;
29910 opcode
= LSHIFT_EXPR
;
29913 opcode
= RSHIFT_EXPR
;
29916 opcode
= BIT_AND_EXPR
;
29919 opcode
= BIT_IOR_EXPR
;
29922 opcode
= BIT_XOR_EXPR
;
29925 cp_parser_error (parser
,
29926 "invalid operator for %<#pragma omp atomic%>");
29929 oprec
= TOKEN_PRECEDENCE (token
);
29930 gcc_assert (oprec
!= PREC_NOT_OPERATOR
);
29931 if (commutative_tree_code (opcode
))
29932 oprec
= (enum cp_parser_prec
) (oprec
- 1);
29933 cp_lexer_consume_token (parser
->lexer
);
29934 rhs
= cp_parser_binary_expression (parser
, false, false,
29936 if (rhs
== error_mark_node
)
29941 cp_parser_error (parser
,
29942 "invalid operator for %<#pragma omp atomic%>");
29945 cp_lexer_consume_token (parser
->lexer
);
29947 rhs
= cp_parser_expression (parser
);
29948 if (rhs
== error_mark_node
)
29953 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
29955 if (!cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
))
29957 v
= cp_parser_unary_expression (parser
);
29958 if (v
== error_mark_node
)
29960 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
29962 lhs1
= cp_parser_unary_expression (parser
);
29963 if (lhs1
== error_mark_node
)
29966 if (structured_block
)
29968 cp_parser_consume_semicolon_at_end_of_statement (parser
);
29969 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
29972 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
, seq_cst
);
29973 if (!structured_block
)
29974 cp_parser_consume_semicolon_at_end_of_statement (parser
);
29978 cp_parser_skip_to_end_of_block_or_statement (parser
);
29979 if (structured_block
)
29981 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
29982 cp_lexer_consume_token (parser
->lexer
);
29983 else if (code
== OMP_ATOMIC_CAPTURE_NEW
)
29985 cp_parser_skip_to_end_of_block_or_statement (parser
);
29986 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
29987 cp_lexer_consume_token (parser
->lexer
);
29994 # pragma omp barrier new-line */
29997 cp_parser_omp_barrier (cp_parser
*parser
, cp_token
*pragma_tok
)
29999 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30000 finish_omp_barrier ();
30004 # pragma omp critical [(name)] new-line
30005 structured-block */
30008 cp_parser_omp_critical (cp_parser
*parser
, cp_token
*pragma_tok
)
30010 tree stmt
, name
= NULL
;
30012 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
30014 cp_lexer_consume_token (parser
->lexer
);
30016 name
= cp_parser_identifier (parser
);
30018 if (name
== error_mark_node
30019 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
30020 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
30021 /*or_comma=*/false,
30022 /*consume_paren=*/true);
30023 if (name
== error_mark_node
)
30026 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30028 stmt
= cp_parser_omp_structured_block (parser
);
30029 return c_finish_omp_critical (input_location
, stmt
, name
);
30033 # pragma omp flush flush-vars[opt] new-line
30036 ( variable-list ) */
30039 cp_parser_omp_flush (cp_parser
*parser
, cp_token
*pragma_tok
)
30041 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
30042 (void) cp_parser_omp_var_list (parser
, OMP_CLAUSE_ERROR
, NULL
);
30043 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30045 finish_omp_flush ();
30048 /* Helper function, to parse omp for increment expression. */
30051 cp_parser_omp_for_cond (cp_parser
*parser
, tree decl
, enum tree_code code
)
30053 tree cond
= cp_parser_binary_expression (parser
, false, true,
30054 PREC_NOT_OPERATOR
, NULL
);
30055 if (cond
== error_mark_node
30056 || cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
30058 cp_parser_skip_to_end_of_statement (parser
);
30059 return error_mark_node
;
30062 switch (TREE_CODE (cond
))
30070 if (code
== CILK_SIMD
|| code
== CILK_FOR
)
30072 /* Fall through: OpenMP disallows NE_EXPR. */
30074 return error_mark_node
;
30077 /* If decl is an iterator, preserve LHS and RHS of the relational
30078 expr until finish_omp_for. */
30080 && (type_dependent_expression_p (decl
)
30081 || CLASS_TYPE_P (TREE_TYPE (decl
))))
30084 return build_x_binary_op (input_location
, TREE_CODE (cond
),
30085 TREE_OPERAND (cond
, 0), ERROR_MARK
,
30086 TREE_OPERAND (cond
, 1), ERROR_MARK
,
30087 /*overload=*/NULL
, tf_warning_or_error
);
30090 /* Helper function, to parse omp for increment expression. */
30093 cp_parser_omp_for_incr (cp_parser
*parser
, tree decl
)
30095 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
30101 if (token
->type
== CPP_PLUS_PLUS
|| token
->type
== CPP_MINUS_MINUS
)
30103 op
= (token
->type
== CPP_PLUS_PLUS
30104 ? PREINCREMENT_EXPR
: PREDECREMENT_EXPR
);
30105 cp_lexer_consume_token (parser
->lexer
);
30106 lhs
= cp_parser_simple_cast_expression (parser
);
30108 return error_mark_node
;
30109 return build2 (op
, TREE_TYPE (decl
), decl
, NULL_TREE
);
30112 lhs
= cp_parser_primary_expression (parser
, false, false, false, &idk
);
30114 return error_mark_node
;
30116 token
= cp_lexer_peek_token (parser
->lexer
);
30117 if (token
->type
== CPP_PLUS_PLUS
|| token
->type
== CPP_MINUS_MINUS
)
30119 op
= (token
->type
== CPP_PLUS_PLUS
30120 ? POSTINCREMENT_EXPR
: POSTDECREMENT_EXPR
);
30121 cp_lexer_consume_token (parser
->lexer
);
30122 return build2 (op
, TREE_TYPE (decl
), decl
, NULL_TREE
);
30125 op
= cp_parser_assignment_operator_opt (parser
);
30126 if (op
== ERROR_MARK
)
30127 return error_mark_node
;
30129 if (op
!= NOP_EXPR
)
30131 rhs
= cp_parser_assignment_expression (parser
);
30132 rhs
= build2 (op
, TREE_TYPE (decl
), decl
, rhs
);
30133 return build2 (MODIFY_EXPR
, TREE_TYPE (decl
), decl
, rhs
);
30136 lhs
= cp_parser_binary_expression (parser
, false, false,
30137 PREC_ADDITIVE_EXPRESSION
, NULL
);
30138 token
= cp_lexer_peek_token (parser
->lexer
);
30139 decl_first
= lhs
== decl
;
30142 if (token
->type
!= CPP_PLUS
30143 && token
->type
!= CPP_MINUS
)
30144 return error_mark_node
;
30148 op
= token
->type
== CPP_PLUS
? PLUS_EXPR
: MINUS_EXPR
;
30149 cp_lexer_consume_token (parser
->lexer
);
30150 rhs
= cp_parser_binary_expression (parser
, false, false,
30151 PREC_ADDITIVE_EXPRESSION
, NULL
);
30152 token
= cp_lexer_peek_token (parser
->lexer
);
30153 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
|| decl_first
)
30155 if (lhs
== NULL_TREE
)
30157 if (op
== PLUS_EXPR
)
30160 lhs
= build_x_unary_op (input_location
, NEGATE_EXPR
, rhs
,
30161 tf_warning_or_error
);
30164 lhs
= build_x_binary_op (input_location
, op
, lhs
, ERROR_MARK
, rhs
,
30165 ERROR_MARK
, NULL
, tf_warning_or_error
);
30168 while (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
);
30172 if (rhs
!= decl
|| op
== MINUS_EXPR
)
30173 return error_mark_node
;
30174 rhs
= build2 (op
, TREE_TYPE (decl
), lhs
, decl
);
30177 rhs
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), decl
, lhs
);
30179 return build2 (MODIFY_EXPR
, TREE_TYPE (decl
), decl
, rhs
);
30182 /* Parse the initialization statement of either an OpenMP for loop or
30183 a Cilk Plus for loop.
30185 Return true if the resulting construct should have an
30186 OMP_CLAUSE_PRIVATE added to it. */
30189 cp_parser_omp_for_loop_init (cp_parser
*parser
,
30190 enum tree_code code
,
30191 tree
&this_pre_body
,
30192 vec
<tree
, va_gc
> *for_block
,
30197 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
30200 bool add_private_clause
= false;
30202 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
30206 integer-type var = lb
30207 random-access-iterator-type var = lb
30208 pointer-type var = lb
30210 cp_decl_specifier_seq type_specifiers
;
30212 /* First, try to parse as an initialized declaration. See
30213 cp_parser_condition, from whence the bulk of this is copied. */
30215 cp_parser_parse_tentatively (parser
);
30216 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/true,
30217 /*is_trailing_return=*/false,
30219 if (cp_parser_parse_definitely (parser
))
30221 /* If parsing a type specifier seq succeeded, then this
30222 MUST be a initialized declaration. */
30223 tree asm_specification
, attributes
;
30224 cp_declarator
*declarator
;
30226 declarator
= cp_parser_declarator (parser
,
30227 CP_PARSER_DECLARATOR_NAMED
,
30228 /*ctor_dtor_or_conv_p=*/NULL
,
30229 /*parenthesized_p=*/NULL
,
30230 /*member_p=*/false,
30231 /*friend_p=*/false);
30232 attributes
= cp_parser_attributes_opt (parser
);
30233 asm_specification
= cp_parser_asm_specification_opt (parser
);
30235 if (declarator
== cp_error_declarator
)
30236 cp_parser_skip_to_end_of_statement (parser
);
30240 tree pushed_scope
, auto_node
;
30242 decl
= start_decl (declarator
, &type_specifiers
,
30243 SD_INITIALIZED
, attributes
,
30244 /*prefix_attributes=*/NULL_TREE
,
30247 auto_node
= type_uses_auto (TREE_TYPE (decl
));
30248 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
))
30250 if (cp_lexer_next_token_is (parser
->lexer
,
30253 if (code
!= CILK_SIMD
&& code
!= CILK_FOR
)
30254 error ("parenthesized initialization is not allowed in "
30255 "OpenMP %<for%> loop");
30257 error ("parenthesized initialization is "
30258 "not allowed in for-loop");
30261 /* Trigger an error. */
30262 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
30264 init
= error_mark_node
;
30265 cp_parser_skip_to_end_of_statement (parser
);
30267 else if (CLASS_TYPE_P (TREE_TYPE (decl
))
30268 || type_dependent_expression_p (decl
)
30271 bool is_direct_init
, is_non_constant_init
;
30273 init
= cp_parser_initializer (parser
,
30275 &is_non_constant_init
);
30280 = do_auto_deduction (TREE_TYPE (decl
), init
,
30283 if (!CLASS_TYPE_P (TREE_TYPE (decl
))
30284 && !type_dependent_expression_p (decl
))
30288 cp_finish_decl (decl
, init
, !is_non_constant_init
,
30290 LOOKUP_ONLYCONVERTING
);
30291 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
30293 vec_safe_push (for_block
, this_pre_body
);
30297 init
= pop_stmt_list (this_pre_body
);
30298 this_pre_body
= NULL_TREE
;
30303 cp_lexer_consume_token (parser
->lexer
);
30304 init
= cp_parser_assignment_expression (parser
);
30307 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
)
30308 init
= error_mark_node
;
30310 cp_finish_decl (decl
, NULL_TREE
,
30311 /*init_const_expr_p=*/false,
30313 LOOKUP_ONLYCONVERTING
);
30317 pop_scope (pushed_scope
);
30323 /* If parsing a type specifier sequence failed, then
30324 this MUST be a simple expression. */
30325 if (code
== CILK_FOR
)
30326 error ("%<_Cilk_for%> allows expression instead of declaration only "
30327 "in C, not in C++");
30328 cp_parser_parse_tentatively (parser
);
30329 decl
= cp_parser_primary_expression (parser
, false, false,
30331 if (!cp_parser_error_occurred (parser
)
30334 && CLASS_TYPE_P (TREE_TYPE (decl
)))
30338 cp_parser_parse_definitely (parser
);
30339 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
30340 rhs
= cp_parser_assignment_expression (parser
);
30341 finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs
),
30344 tf_warning_or_error
));
30345 add_private_clause
= true;
30350 cp_parser_abort_tentative_parse (parser
);
30351 init
= cp_parser_expression (parser
);
30354 if (TREE_CODE (init
) == MODIFY_EXPR
30355 || TREE_CODE (init
) == MODOP_EXPR
)
30356 real_decl
= TREE_OPERAND (init
, 0);
30360 return add_private_clause
;
30363 /* Parse the restricted form of the for statement allowed by OpenMP. */
30366 cp_parser_omp_for_loop (cp_parser
*parser
, enum tree_code code
, tree clauses
,
30369 tree init
, cond
, incr
, body
, decl
, pre_body
= NULL_TREE
, ret
;
30370 tree real_decl
, initv
, condv
, incrv
, declv
;
30371 tree this_pre_body
, cl
;
30372 location_t loc_first
;
30373 bool collapse_err
= false;
30374 int i
, collapse
= 1, nbraces
= 0;
30375 vec
<tree
, va_gc
> *for_block
= make_tree_vector ();
30377 for (cl
= clauses
; cl
; cl
= OMP_CLAUSE_CHAIN (cl
))
30378 if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_COLLAPSE
)
30379 collapse
= tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (cl
));
30381 gcc_assert (collapse
>= 1);
30383 declv
= make_tree_vec (collapse
);
30384 initv
= make_tree_vec (collapse
);
30385 condv
= make_tree_vec (collapse
);
30386 incrv
= make_tree_vec (collapse
);
30388 loc_first
= cp_lexer_peek_token (parser
->lexer
)->location
;
30390 for (i
= 0; i
< collapse
; i
++)
30392 int bracecount
= 0;
30393 bool add_private_clause
= false;
30396 if (code
!= CILK_FOR
30397 && !cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
30399 cp_parser_error (parser
, "for statement expected");
30402 if (code
== CILK_FOR
30403 && !cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CILK_FOR
))
30405 cp_parser_error (parser
, "_Cilk_for statement expected");
30408 loc
= cp_lexer_consume_token (parser
->lexer
)->location
;
30410 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
30413 init
= decl
= real_decl
= NULL
;
30414 this_pre_body
= push_stmt_list ();
30417 |= cp_parser_omp_for_loop_init (parser
, code
,
30418 this_pre_body
, for_block
,
30419 init
, decl
, real_decl
);
30421 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
30424 this_pre_body
= pop_stmt_list (this_pre_body
);
30428 pre_body
= push_stmt_list ();
30430 add_stmt (this_pre_body
);
30431 pre_body
= pop_stmt_list (pre_body
);
30434 pre_body
= this_pre_body
;
30439 if (cclauses
!= NULL
30440 && cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
] != NULL
30441 && real_decl
!= NULL_TREE
)
30444 for (c
= &cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
]; *c
; )
30445 if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_FIRSTPRIVATE
30446 && OMP_CLAUSE_DECL (*c
) == real_decl
)
30448 error_at (loc
, "iteration variable %qD"
30449 " should not be firstprivate", real_decl
);
30450 *c
= OMP_CLAUSE_CHAIN (*c
);
30452 else if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_LASTPRIVATE
30453 && OMP_CLAUSE_DECL (*c
) == real_decl
)
30455 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
30456 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
30457 tree l
= build_omp_clause (loc
, OMP_CLAUSE_LASTPRIVATE
);
30458 OMP_CLAUSE_DECL (l
) = real_decl
;
30459 CP_OMP_CLAUSE_INFO (l
) = CP_OMP_CLAUSE_INFO (*c
);
30460 if (code
== OMP_SIMD
)
30462 OMP_CLAUSE_CHAIN (l
) = cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
30463 cclauses
[C_OMP_CLAUSE_SPLIT_FOR
] = l
;
30467 OMP_CLAUSE_CHAIN (l
) = clauses
;
30470 OMP_CLAUSE_SET_CODE (*c
, OMP_CLAUSE_SHARED
);
30471 CP_OMP_CLAUSE_INFO (*c
) = NULL
;
30472 add_private_clause
= false;
30476 if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_PRIVATE
30477 && OMP_CLAUSE_DECL (*c
) == real_decl
)
30478 add_private_clause
= false;
30479 c
= &OMP_CLAUSE_CHAIN (*c
);
30483 if (add_private_clause
)
30486 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
30488 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
30489 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
30490 && OMP_CLAUSE_DECL (c
) == decl
)
30492 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
30493 && OMP_CLAUSE_DECL (c
) == decl
)
30494 error_at (loc
, "iteration variable %qD "
30495 "should not be firstprivate",
30497 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
30498 && OMP_CLAUSE_DECL (c
) == decl
)
30499 error_at (loc
, "iteration variable %qD should not be reduction",
30504 c
= build_omp_clause (loc
, OMP_CLAUSE_PRIVATE
);
30505 OMP_CLAUSE_DECL (c
) = decl
;
30506 c
= finish_omp_clauses (c
);
30509 OMP_CLAUSE_CHAIN (c
) = clauses
;
30516 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
30517 cond
= cp_parser_omp_for_cond (parser
, decl
, code
);
30518 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
30521 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
30523 /* If decl is an iterator, preserve the operator on decl
30524 until finish_omp_for. */
30526 && ((processing_template_decl
30527 && !POINTER_TYPE_P (TREE_TYPE (real_decl
)))
30528 || CLASS_TYPE_P (TREE_TYPE (real_decl
))))
30529 incr
= cp_parser_omp_for_incr (parser
, real_decl
);
30531 incr
= cp_parser_expression (parser
);
30532 if (CAN_HAVE_LOCATION_P (incr
) && !EXPR_HAS_LOCATION (incr
))
30533 SET_EXPR_LOCATION (incr
, input_location
);
30536 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
30537 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
30538 /*or_comma=*/false,
30539 /*consume_paren=*/true);
30541 TREE_VEC_ELT (declv
, i
) = decl
;
30542 TREE_VEC_ELT (initv
, i
) = init
;
30543 TREE_VEC_ELT (condv
, i
) = cond
;
30544 TREE_VEC_ELT (incrv
, i
) = incr
;
30546 if (i
== collapse
- 1)
30549 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
30550 in between the collapsed for loops to be still considered perfectly
30551 nested. Hopefully the final version clarifies this.
30552 For now handle (multiple) {'s and empty statements. */
30553 cp_parser_parse_tentatively (parser
);
30556 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
30558 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
30560 cp_lexer_consume_token (parser
->lexer
);
30563 else if (bracecount
30564 && cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
30565 cp_lexer_consume_token (parser
->lexer
);
30568 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30569 error_at (loc
, "not enough collapsed for loops");
30570 collapse_err
= true;
30571 cp_parser_abort_tentative_parse (parser
);
30580 cp_parser_parse_definitely (parser
);
30581 nbraces
+= bracecount
;
30585 /* Note that we saved the original contents of this flag when we entered
30586 the structured block, and so we don't need to re-save it here. */
30587 if (code
== CILK_SIMD
|| code
== CILK_FOR
)
30588 parser
->in_statement
= IN_CILK_SIMD_FOR
;
30590 parser
->in_statement
= IN_OMP_FOR
;
30592 /* Note that the grammar doesn't call for a structured block here,
30593 though the loop as a whole is a structured block. */
30594 body
= push_stmt_list ();
30595 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
30596 body
= pop_stmt_list (body
);
30598 if (declv
== NULL_TREE
)
30601 ret
= finish_omp_for (loc_first
, code
, declv
, initv
, condv
, incrv
, body
,
30602 pre_body
, clauses
);
30606 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
30608 cp_lexer_consume_token (parser
->lexer
);
30611 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
30612 cp_lexer_consume_token (parser
->lexer
);
30617 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
30618 "collapsed loops not perfectly nested");
30620 collapse_err
= true;
30621 cp_parser_statement_seq_opt (parser
, NULL
);
30622 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
30627 while (!for_block
->is_empty ())
30628 add_stmt (pop_stmt_list (for_block
->pop ()));
30629 release_tree_vector (for_block
);
30634 /* Helper function for OpenMP parsing, split clauses and call
30635 finish_omp_clauses on each of the set of clauses afterwards. */
30638 cp_omp_split_clauses (location_t loc
, enum tree_code code
,
30639 omp_clause_mask mask
, tree clauses
, tree
*cclauses
)
30642 c_omp_split_clauses (loc
, code
, mask
, clauses
, cclauses
);
30643 for (i
= 0; i
< C_OMP_CLAUSE_SPLIT_COUNT
; i
++)
30645 cclauses
[i
] = finish_omp_clauses (cclauses
[i
]);
30649 #pragma omp simd simd-clause[optseq] new-line
30652 #define OMP_SIMD_CLAUSE_MASK \
30653 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
30654 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
30655 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
30656 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30657 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30658 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30659 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30662 cp_parser_omp_simd (cp_parser
*parser
, cp_token
*pragma_tok
,
30663 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30665 tree clauses
, sb
, ret
;
30667 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30669 strcat (p_name
, " simd");
30670 mask
|= OMP_SIMD_CLAUSE_MASK
;
30671 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_ORDERED
);
30673 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
30677 cp_omp_split_clauses (loc
, OMP_SIMD
, mask
, clauses
, cclauses
);
30678 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SIMD
];
30681 sb
= begin_omp_structured_block ();
30682 save
= cp_parser_begin_omp_structured_block (parser
);
30684 ret
= cp_parser_omp_for_loop (parser
, OMP_SIMD
, clauses
, cclauses
);
30686 cp_parser_end_omp_structured_block (parser
, save
);
30687 add_stmt (finish_omp_structured_block (sb
));
30693 #pragma omp for for-clause[optseq] new-line
30697 #pragma omp for simd for-simd-clause[optseq] new-line
30700 #define OMP_FOR_CLAUSE_MASK \
30701 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30702 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30703 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30704 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30705 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
30706 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
30707 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
30708 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30711 cp_parser_omp_for (cp_parser
*parser
, cp_token
*pragma_tok
,
30712 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30714 tree clauses
, sb
, ret
;
30716 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30718 strcat (p_name
, " for");
30719 mask
|= OMP_FOR_CLAUSE_MASK
;
30721 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
30723 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
30725 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
30726 const char *p
= IDENTIFIER_POINTER (id
);
30728 if (strcmp (p
, "simd") == 0)
30730 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
30731 if (cclauses
== NULL
)
30732 cclauses
= cclauses_buf
;
30734 cp_lexer_consume_token (parser
->lexer
);
30735 if (!flag_openmp
) /* flag_openmp_simd */
30736 return cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
30738 sb
= begin_omp_structured_block ();
30739 save
= cp_parser_begin_omp_structured_block (parser
);
30740 ret
= cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
30742 cp_parser_end_omp_structured_block (parser
, save
);
30743 tree body
= finish_omp_structured_block (sb
);
30746 ret
= make_node (OMP_FOR
);
30747 TREE_TYPE (ret
) = void_type_node
;
30748 OMP_FOR_BODY (ret
) = body
;
30749 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
30750 SET_EXPR_LOCATION (ret
, loc
);
30755 if (!flag_openmp
) /* flag_openmp_simd */
30757 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
30761 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
30765 cp_omp_split_clauses (loc
, OMP_FOR
, mask
, clauses
, cclauses
);
30766 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
30769 sb
= begin_omp_structured_block ();
30770 save
= cp_parser_begin_omp_structured_block (parser
);
30772 ret
= cp_parser_omp_for_loop (parser
, OMP_FOR
, clauses
, cclauses
);
30774 cp_parser_end_omp_structured_block (parser
, save
);
30775 add_stmt (finish_omp_structured_block (sb
));
30781 # pragma omp master new-line
30782 structured-block */
30785 cp_parser_omp_master (cp_parser
*parser
, cp_token
*pragma_tok
)
30787 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30788 return c_finish_omp_master (input_location
,
30789 cp_parser_omp_structured_block (parser
));
30793 # pragma omp ordered new-line
30794 structured-block */
30797 cp_parser_omp_ordered (cp_parser
*parser
, cp_token
*pragma_tok
)
30799 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30800 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30801 return c_finish_omp_ordered (loc
, cp_parser_omp_structured_block (parser
));
30807 { section-sequence }
30810 section-directive[opt] structured-block
30811 section-sequence section-directive structured-block */
30814 cp_parser_omp_sections_scope (cp_parser
*parser
)
30816 tree stmt
, substmt
;
30817 bool error_suppress
= false;
30820 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
30823 stmt
= push_stmt_list ();
30825 if (cp_lexer_peek_token (parser
->lexer
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
30827 substmt
= cp_parser_omp_structured_block (parser
);
30828 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
30829 add_stmt (substmt
);
30834 tok
= cp_lexer_peek_token (parser
->lexer
);
30835 if (tok
->type
== CPP_CLOSE_BRACE
)
30837 if (tok
->type
== CPP_EOF
)
30840 if (tok
->pragma_kind
== PRAGMA_OMP_SECTION
)
30842 cp_lexer_consume_token (parser
->lexer
);
30843 cp_parser_require_pragma_eol (parser
, tok
);
30844 error_suppress
= false;
30846 else if (!error_suppress
)
30848 cp_parser_error (parser
, "expected %<#pragma omp section%> or %<}%>");
30849 error_suppress
= true;
30852 substmt
= cp_parser_omp_structured_block (parser
);
30853 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
30854 add_stmt (substmt
);
30856 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
30858 substmt
= pop_stmt_list (stmt
);
30860 stmt
= make_node (OMP_SECTIONS
);
30861 TREE_TYPE (stmt
) = void_type_node
;
30862 OMP_SECTIONS_BODY (stmt
) = substmt
;
30869 # pragma omp sections sections-clause[optseq] newline
30872 #define OMP_SECTIONS_CLAUSE_MASK \
30873 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30874 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30875 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30876 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30877 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
30880 cp_parser_omp_sections (cp_parser
*parser
, cp_token
*pragma_tok
,
30881 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30884 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30886 strcat (p_name
, " sections");
30887 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
30889 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
30891 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
30895 cp_omp_split_clauses (loc
, OMP_SECTIONS
, mask
, clauses
, cclauses
);
30896 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SECTIONS
];
30899 ret
= cp_parser_omp_sections_scope (parser
);
30901 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
30907 # pragma omp parallel parallel-clause[optseq] new-line
30909 # pragma omp parallel for parallel-for-clause[optseq] new-line
30911 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
30915 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
30916 structured-block */
30918 #define OMP_PARALLEL_CLAUSE_MASK \
30919 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
30920 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30921 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30922 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
30923 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
30924 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
30925 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30926 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
30927 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
30930 cp_parser_omp_parallel (cp_parser
*parser
, cp_token
*pragma_tok
,
30931 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30933 tree stmt
, clauses
, block
;
30935 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30937 strcat (p_name
, " parallel");
30938 mask
|= OMP_PARALLEL_CLAUSE_MASK
;
30940 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
30942 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
30943 if (cclauses
== NULL
)
30944 cclauses
= cclauses_buf
;
30946 cp_lexer_consume_token (parser
->lexer
);
30947 if (!flag_openmp
) /* flag_openmp_simd */
30948 return cp_parser_omp_for (parser
, pragma_tok
, p_name
, mask
, cclauses
);
30949 block
= begin_omp_parallel ();
30950 save
= cp_parser_begin_omp_structured_block (parser
);
30951 tree ret
= cp_parser_omp_for (parser
, pragma_tok
, p_name
, mask
, cclauses
);
30952 cp_parser_end_omp_structured_block (parser
, save
);
30953 stmt
= finish_omp_parallel (cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
30955 if (ret
== NULL_TREE
)
30957 OMP_PARALLEL_COMBINED (stmt
) = 1;
30962 error_at (loc
, "expected %<for%> after %qs", p_name
);
30963 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
30966 else if (!flag_openmp
) /* flag_openmp_simd */
30968 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
30971 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
30973 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
30974 const char *p
= IDENTIFIER_POINTER (id
);
30975 if (strcmp (p
, "sections") == 0)
30977 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
30978 cclauses
= cclauses_buf
;
30980 cp_lexer_consume_token (parser
->lexer
);
30981 block
= begin_omp_parallel ();
30982 save
= cp_parser_begin_omp_structured_block (parser
);
30983 cp_parser_omp_sections (parser
, pragma_tok
, p_name
, mask
, cclauses
);
30984 cp_parser_end_omp_structured_block (parser
, save
);
30985 stmt
= finish_omp_parallel (cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
30987 OMP_PARALLEL_COMBINED (stmt
) = 1;
30992 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
);
30994 block
= begin_omp_parallel ();
30995 save
= cp_parser_begin_omp_structured_block (parser
);
30996 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
30997 cp_parser_end_omp_structured_block (parser
, save
);
30998 stmt
= finish_omp_parallel (clauses
, block
);
31003 # pragma omp single single-clause[optseq] new-line
31004 structured-block */
31006 #define OMP_SINGLE_CLAUSE_MASK \
31007 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31008 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31009 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
31010 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
31013 cp_parser_omp_single (cp_parser
*parser
, cp_token
*pragma_tok
)
31015 tree stmt
= make_node (OMP_SINGLE
);
31016 TREE_TYPE (stmt
) = void_type_node
;
31018 OMP_SINGLE_CLAUSES (stmt
)
31019 = cp_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
31020 "#pragma omp single", pragma_tok
);
31021 OMP_SINGLE_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31023 return add_stmt (stmt
);
31027 # pragma omp task task-clause[optseq] new-line
31028 structured-block */
31030 #define OMP_TASK_CLAUSE_MASK \
31031 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
31032 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
31033 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
31034 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31035 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31036 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
31037 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
31038 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
31039 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND))
31042 cp_parser_omp_task (cp_parser
*parser
, cp_token
*pragma_tok
)
31044 tree clauses
, block
;
31047 clauses
= cp_parser_omp_all_clauses (parser
, OMP_TASK_CLAUSE_MASK
,
31048 "#pragma omp task", pragma_tok
);
31049 block
= begin_omp_task ();
31050 save
= cp_parser_begin_omp_structured_block (parser
);
31051 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31052 cp_parser_end_omp_structured_block (parser
, save
);
31053 return finish_omp_task (clauses
, block
);
31057 # pragma omp taskwait new-line */
31060 cp_parser_omp_taskwait (cp_parser
*parser
, cp_token
*pragma_tok
)
31062 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31063 finish_omp_taskwait ();
31067 # pragma omp taskyield new-line */
31070 cp_parser_omp_taskyield (cp_parser
*parser
, cp_token
*pragma_tok
)
31072 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31073 finish_omp_taskyield ();
31077 # pragma omp taskgroup new-line
31078 structured-block */
31081 cp_parser_omp_taskgroup (cp_parser
*parser
, cp_token
*pragma_tok
)
31083 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31084 return c_finish_omp_taskgroup (input_location
,
31085 cp_parser_omp_structured_block (parser
));
31090 # pragma omp threadprivate (variable-list) */
31093 cp_parser_omp_threadprivate (cp_parser
*parser
, cp_token
*pragma_tok
)
31097 vars
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_ERROR
, NULL
);
31098 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31100 finish_omp_threadprivate (vars
);
31104 # pragma omp cancel cancel-clause[optseq] new-line */
31106 #define OMP_CANCEL_CLAUSE_MASK \
31107 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
31108 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
31109 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
31110 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
31111 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31114 cp_parser_omp_cancel (cp_parser
*parser
, cp_token
*pragma_tok
)
31116 tree clauses
= cp_parser_omp_all_clauses (parser
, OMP_CANCEL_CLAUSE_MASK
,
31117 "#pragma omp cancel", pragma_tok
);
31118 finish_omp_cancel (clauses
);
31122 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
31124 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
31125 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
31126 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
31127 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
31128 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
31131 cp_parser_omp_cancellation_point (cp_parser
*parser
, cp_token
*pragma_tok
)
31134 bool point_seen
= false;
31136 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31138 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31139 const char *p
= IDENTIFIER_POINTER (id
);
31141 if (strcmp (p
, "point") == 0)
31143 cp_lexer_consume_token (parser
->lexer
);
31149 cp_parser_error (parser
, "expected %<point%>");
31150 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31154 clauses
= cp_parser_omp_all_clauses (parser
,
31155 OMP_CANCELLATION_POINT_CLAUSE_MASK
,
31156 "#pragma omp cancellation point",
31158 finish_omp_cancellation_point (clauses
);
31162 #pragma omp distribute distribute-clause[optseq] new-line
31165 #define OMP_DISTRIBUTE_CLAUSE_MASK \
31166 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31167 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31168 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
31169 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
31172 cp_parser_omp_distribute (cp_parser
*parser
, cp_token
*pragma_tok
,
31173 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
31175 tree clauses
, sb
, ret
;
31177 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
31179 strcat (p_name
, " distribute");
31180 mask
|= OMP_DISTRIBUTE_CLAUSE_MASK
;
31182 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31184 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31185 const char *p
= IDENTIFIER_POINTER (id
);
31187 bool parallel
= false;
31189 if (strcmp (p
, "simd") == 0)
31192 parallel
= strcmp (p
, "parallel") == 0;
31193 if (parallel
|| simd
)
31195 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
31196 if (cclauses
== NULL
)
31197 cclauses
= cclauses_buf
;
31198 cp_lexer_consume_token (parser
->lexer
);
31199 if (!flag_openmp
) /* flag_openmp_simd */
31202 return cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
31205 return cp_parser_omp_parallel (parser
, pragma_tok
, p_name
, mask
,
31208 sb
= begin_omp_structured_block ();
31209 save
= cp_parser_begin_omp_structured_block (parser
);
31211 ret
= cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
31214 ret
= cp_parser_omp_parallel (parser
, pragma_tok
, p_name
, mask
,
31216 cp_parser_end_omp_structured_block (parser
, save
);
31217 tree body
= finish_omp_structured_block (sb
);
31220 ret
= make_node (OMP_DISTRIBUTE
);
31221 TREE_TYPE (ret
) = void_type_node
;
31222 OMP_FOR_BODY (ret
) = body
;
31223 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
31224 SET_EXPR_LOCATION (ret
, loc
);
31229 if (!flag_openmp
) /* flag_openmp_simd */
31231 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31235 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
31239 cp_omp_split_clauses (loc
, OMP_DISTRIBUTE
, mask
, clauses
, cclauses
);
31240 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
31243 sb
= begin_omp_structured_block ();
31244 save
= cp_parser_begin_omp_structured_block (parser
);
31246 ret
= cp_parser_omp_for_loop (parser
, OMP_DISTRIBUTE
, clauses
, NULL
);
31248 cp_parser_end_omp_structured_block (parser
, save
);
31249 add_stmt (finish_omp_structured_block (sb
));
31255 # pragma omp teams teams-clause[optseq] new-line
31256 structured-block */
31258 #define OMP_TEAMS_CLAUSE_MASK \
31259 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31260 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31261 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
31262 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
31263 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
31264 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
31265 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
31268 cp_parser_omp_teams (cp_parser
*parser
, cp_token
*pragma_tok
,
31269 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
31271 tree clauses
, sb
, ret
;
31273 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
31275 strcat (p_name
, " teams");
31276 mask
|= OMP_TEAMS_CLAUSE_MASK
;
31278 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31280 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31281 const char *p
= IDENTIFIER_POINTER (id
);
31282 if (strcmp (p
, "distribute") == 0)
31284 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
31285 if (cclauses
== NULL
)
31286 cclauses
= cclauses_buf
;
31288 cp_lexer_consume_token (parser
->lexer
);
31289 if (!flag_openmp
) /* flag_openmp_simd */
31290 return cp_parser_omp_distribute (parser
, pragma_tok
, p_name
, mask
,
31292 sb
= begin_omp_structured_block ();
31293 save
= cp_parser_begin_omp_structured_block (parser
);
31294 ret
= cp_parser_omp_distribute (parser
, pragma_tok
, p_name
, mask
,
31296 cp_parser_end_omp_structured_block (parser
, save
);
31297 tree body
= finish_omp_structured_block (sb
);
31300 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
31301 ret
= make_node (OMP_TEAMS
);
31302 TREE_TYPE (ret
) = void_type_node
;
31303 OMP_TEAMS_CLAUSES (ret
) = clauses
;
31304 OMP_TEAMS_BODY (ret
) = body
;
31305 return add_stmt (ret
);
31308 if (!flag_openmp
) /* flag_openmp_simd */
31310 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31314 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
31318 cp_omp_split_clauses (loc
, OMP_TEAMS
, mask
, clauses
, cclauses
);
31319 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
31322 tree stmt
= make_node (OMP_TEAMS
);
31323 TREE_TYPE (stmt
) = void_type_node
;
31324 OMP_TEAMS_CLAUSES (stmt
) = clauses
;
31325 OMP_TEAMS_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31327 return add_stmt (stmt
);
31331 # pragma omp target data target-data-clause[optseq] new-line
31332 structured-block */
31334 #define OMP_TARGET_DATA_CLAUSE_MASK \
31335 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31336 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
31337 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31340 cp_parser_omp_target_data (cp_parser
*parser
, cp_token
*pragma_tok
)
31342 tree stmt
= make_node (OMP_TARGET_DATA
);
31343 TREE_TYPE (stmt
) = void_type_node
;
31345 OMP_TARGET_DATA_CLAUSES (stmt
)
31346 = cp_parser_omp_all_clauses (parser
, OMP_TARGET_DATA_CLAUSE_MASK
,
31347 "#pragma omp target data", pragma_tok
);
31348 keep_next_level (true);
31349 OMP_TARGET_DATA_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31351 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31352 return add_stmt (stmt
);
31356 # pragma omp target update target-update-clause[optseq] new-line */
31358 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
31359 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
31360 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
31361 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31362 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31365 cp_parser_omp_target_update (cp_parser
*parser
, cp_token
*pragma_tok
,
31366 enum pragma_context context
)
31368 if (context
== pragma_stmt
)
31370 error_at (pragma_tok
->location
,
31371 "%<#pragma omp target update%> may only be "
31372 "used in compound statements");
31373 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31378 = cp_parser_omp_all_clauses (parser
, OMP_TARGET_UPDATE_CLAUSE_MASK
,
31379 "#pragma omp target update", pragma_tok
);
31380 if (find_omp_clause (clauses
, OMP_CLAUSE_TO
) == NULL_TREE
31381 && find_omp_clause (clauses
, OMP_CLAUSE_FROM
) == NULL_TREE
)
31383 error_at (pragma_tok
->location
,
31384 "%<#pragma omp target update%> must contain at least one "
31385 "%<from%> or %<to%> clauses");
31389 tree stmt
= make_node (OMP_TARGET_UPDATE
);
31390 TREE_TYPE (stmt
) = void_type_node
;
31391 OMP_TARGET_UPDATE_CLAUSES (stmt
) = clauses
;
31392 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31398 # pragma omp target target-clause[optseq] new-line
31399 structured-block */
31401 #define OMP_TARGET_CLAUSE_MASK \
31402 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31403 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
31404 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31407 cp_parser_omp_target (cp_parser
*parser
, cp_token
*pragma_tok
,
31408 enum pragma_context context
)
31410 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
31412 cp_parser_error (parser
, "expected declaration specifiers");
31413 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31417 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31419 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31420 const char *p
= IDENTIFIER_POINTER (id
);
31422 if (strcmp (p
, "teams") == 0)
31424 tree cclauses
[C_OMP_CLAUSE_SPLIT_COUNT
];
31425 char p_name
[sizeof ("#pragma omp target teams distribute "
31426 "parallel for simd")];
31428 cp_lexer_consume_token (parser
->lexer
);
31429 strcpy (p_name
, "#pragma omp target");
31430 if (!flag_openmp
) /* flag_openmp_simd */
31432 tree stmt
= cp_parser_omp_teams (parser
, pragma_tok
, p_name
,
31433 OMP_TARGET_CLAUSE_MASK
,
31435 return stmt
!= NULL_TREE
;
31437 keep_next_level (true);
31438 tree sb
= begin_omp_structured_block ();
31439 unsigned save
= cp_parser_begin_omp_structured_block (parser
);
31440 tree ret
= cp_parser_omp_teams (parser
, pragma_tok
, p_name
,
31441 OMP_TARGET_CLAUSE_MASK
, cclauses
);
31442 cp_parser_end_omp_structured_block (parser
, save
);
31443 tree body
= finish_omp_structured_block (sb
);
31444 if (ret
== NULL_TREE
)
31446 tree stmt
= make_node (OMP_TARGET
);
31447 TREE_TYPE (stmt
) = void_type_node
;
31448 OMP_TARGET_CLAUSES (stmt
) = cclauses
[C_OMP_CLAUSE_SPLIT_TARGET
];
31449 OMP_TARGET_BODY (stmt
) = body
;
31453 else if (!flag_openmp
) /* flag_openmp_simd */
31455 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31458 else if (strcmp (p
, "data") == 0)
31460 cp_lexer_consume_token (parser
->lexer
);
31461 cp_parser_omp_target_data (parser
, pragma_tok
);
31464 else if (strcmp (p
, "update") == 0)
31466 cp_lexer_consume_token (parser
->lexer
);
31467 return cp_parser_omp_target_update (parser
, pragma_tok
, context
);
31471 tree stmt
= make_node (OMP_TARGET
);
31472 TREE_TYPE (stmt
) = void_type_node
;
31474 OMP_TARGET_CLAUSES (stmt
)
31475 = cp_parser_omp_all_clauses (parser
, OMP_TARGET_CLAUSE_MASK
,
31476 "#pragma omp target", pragma_tok
);
31477 keep_next_level (true);
31478 OMP_TARGET_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31480 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31486 # pragma acc cache (variable-list) new-line
31490 cp_parser_oacc_cache (cp_parser
*parser
, cp_token
*pragma_tok
)
31492 tree stmt
, clauses
;
31494 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE__CACHE_
, NULL_TREE
);
31495 clauses
= finish_omp_clauses (clauses
);
31497 cp_parser_require_pragma_eol (parser
, cp_lexer_peek_token (parser
->lexer
));
31499 stmt
= make_node (OACC_CACHE
);
31500 TREE_TYPE (stmt
) = void_type_node
;
31501 OACC_CACHE_CLAUSES (stmt
) = clauses
;
31502 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31509 # pragma acc data oacc-data-clause[optseq] new-line
31510 structured-block */
31512 #define OACC_DATA_CLAUSE_MASK \
31513 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31514 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31515 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31516 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31517 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31518 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31519 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31520 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31521 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31522 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31523 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE))
31526 cp_parser_oacc_data (cp_parser
*parser
, cp_token
*pragma_tok
)
31528 tree stmt
, clauses
, block
;
31531 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_DATA_CLAUSE_MASK
,
31532 "#pragma acc data", pragma_tok
);
31534 block
= begin_omp_parallel ();
31535 save
= cp_parser_begin_omp_structured_block (parser
);
31536 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31537 cp_parser_end_omp_structured_block (parser
, save
);
31538 stmt
= finish_oacc_data (clauses
, block
);
31543 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
31547 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
31549 LOC is the location of the #pragma token.
31552 #define OACC_ENTER_DATA_CLAUSE_MASK \
31553 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31554 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31555 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31556 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31557 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31558 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31559 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
31561 #define OACC_EXIT_DATA_CLAUSE_MASK \
31562 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31563 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31564 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31565 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
31566 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
31569 cp_parser_oacc_enter_exit_data (cp_parser
*parser
, cp_token
*pragma_tok
,
31572 tree stmt
, clauses
;
31574 if (cp_lexer_next_token_is (parser
->lexer
, CPP_PRAGMA_EOL
)
31575 || cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
31577 cp_parser_error (parser
, enter
31578 ? "expected %<data%> in %<#pragma acc enter data%>"
31579 : "expected %<data%> in %<#pragma acc exit data%>");
31580 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31585 IDENTIFIER_POINTER (cp_lexer_peek_token (parser
->lexer
)->u
.value
);
31586 if (strcmp (p
, "data") != 0)
31588 cp_parser_error (parser
, "invalid pragma");
31589 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31593 cp_lexer_consume_token (parser
->lexer
);
31596 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_ENTER_DATA_CLAUSE_MASK
,
31597 "#pragma acc enter data", pragma_tok
);
31599 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_EXIT_DATA_CLAUSE_MASK
,
31600 "#pragma acc exit data", pragma_tok
);
31602 if (find_omp_clause (clauses
, OMP_CLAUSE_MAP
) == NULL_TREE
)
31604 error_at (pragma_tok
->location
,
31605 "%<#pragma acc enter data%> has no data movement clause");
31609 stmt
= enter
? make_node (OACC_ENTER_DATA
) : make_node (OACC_EXIT_DATA
);
31610 TREE_TYPE (stmt
) = void_type_node
;
31611 OMP_STANDALONE_CLAUSES (stmt
) = clauses
;
31612 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31618 # pragma acc kernels oacc-kernels-clause[optseq] new-line
31619 structured-block */
31621 #define OACC_KERNELS_CLAUSE_MASK \
31622 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31623 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31624 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31625 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31626 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31627 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31628 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31629 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31630 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31631 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31632 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31633 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31634 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31637 cp_parser_oacc_kernels (cp_parser
*parser
, cp_token
*pragma_tok
)
31639 tree stmt
, clauses
, block
;
31642 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_KERNELS_CLAUSE_MASK
,
31643 "#pragma acc kernels", pragma_tok
);
31645 block
= begin_omp_parallel ();
31646 save
= cp_parser_begin_omp_structured_block (parser
);
31647 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31648 cp_parser_end_omp_structured_block (parser
, save
);
31649 stmt
= finish_oacc_kernels (clauses
, block
);
31654 # pragma acc loop oacc-loop-clause[optseq] new-line
31655 structured-block */
31657 #define OACC_LOOP_CLAUSE_MASK \
31658 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
31659 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION))
31662 cp_parser_oacc_loop (cp_parser
*parser
, cp_token
*pragma_tok
)
31664 tree stmt
, clauses
, block
;
31667 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_LOOP_CLAUSE_MASK
,
31668 "#pragma acc loop", pragma_tok
);
31670 block
= begin_omp_structured_block ();
31671 save
= cp_parser_begin_omp_structured_block (parser
);
31672 stmt
= cp_parser_omp_for_loop (parser
, OACC_LOOP
, clauses
, NULL
);
31673 cp_parser_end_omp_structured_block (parser
, save
);
31674 add_stmt (finish_omp_structured_block (block
));
31679 # pragma acc parallel oacc-parallel-clause[optseq] new-line
31680 structured-block */
31682 #define OACC_PARALLEL_CLAUSE_MASK \
31683 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31685 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31686 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31687 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31688 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31689 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31690 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
31691 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
31692 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31693 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31694 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31695 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31696 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31697 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
31698 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
31699 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31702 cp_parser_oacc_parallel (cp_parser
*parser
, cp_token
*pragma_tok
)
31704 tree stmt
, clauses
, block
;
31707 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_PARALLEL_CLAUSE_MASK
,
31708 "#pragma acc parallel", pragma_tok
);
31710 block
= begin_omp_parallel ();
31711 save
= cp_parser_begin_omp_structured_block (parser
);
31712 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31713 cp_parser_end_omp_structured_block (parser
, save
);
31714 stmt
= finish_oacc_parallel (clauses
, block
);
31719 # pragma acc update oacc-update-clause[optseq] new-line
31722 #define OACC_UPDATE_CLAUSE_MASK \
31723 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31724 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
31725 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
31726 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31727 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
31728 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31731 cp_parser_oacc_update (cp_parser
*parser
, cp_token
*pragma_tok
)
31733 tree stmt
, clauses
;
31735 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_UPDATE_CLAUSE_MASK
,
31736 "#pragma acc update", pragma_tok
);
31738 if (find_omp_clause (clauses
, OMP_CLAUSE_MAP
) == NULL_TREE
)
31740 error_at (pragma_tok
->location
,
31741 "%<#pragma acc update%> must contain at least one "
31742 "%<device%> or %<host/self%> clause");
31746 stmt
= make_node (OACC_UPDATE
);
31747 TREE_TYPE (stmt
) = void_type_node
;
31748 OACC_UPDATE_CLAUSES (stmt
) = clauses
;
31749 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31755 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
31757 LOC is the location of the #pragma token.
31760 #define OACC_WAIT_CLAUSE_MASK \
31761 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
31764 cp_parser_oacc_wait (cp_parser
*parser
, cp_token
*pragma_tok
)
31766 tree clauses
, list
= NULL_TREE
, stmt
= NULL_TREE
;
31767 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
31769 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
31770 list
= cp_parser_oacc_wait_list (parser
, loc
, list
);
31772 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_WAIT_CLAUSE_MASK
,
31773 "#pragma acc wait", pragma_tok
);
31775 stmt
= c_finish_oacc_wait (loc
, list
, clauses
);
31781 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
31783 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
31784 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
31785 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
31786 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
31787 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
31788 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
31789 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
31792 cp_parser_omp_declare_simd (cp_parser
*parser
, cp_token
*pragma_tok
,
31793 enum pragma_context context
)
31795 bool first_p
= parser
->omp_declare_simd
== NULL
;
31796 cp_omp_declare_simd_data data
;
31799 data
.error_seen
= false;
31800 data
.fndecl_seen
= false;
31801 data
.tokens
= vNULL
;
31802 parser
->omp_declare_simd
= &data
;
31804 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
)
31805 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_EOF
))
31806 cp_lexer_consume_token (parser
->lexer
);
31807 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
31808 parser
->omp_declare_simd
->error_seen
= true;
31809 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31810 struct cp_token_cache
*cp
31811 = cp_token_cache_new (pragma_tok
, cp_lexer_peek_token (parser
->lexer
));
31812 parser
->omp_declare_simd
->tokens
.safe_push (cp
);
31815 while (cp_lexer_next_token_is (parser
->lexer
, CPP_PRAGMA
))
31816 cp_parser_pragma (parser
, context
);
31819 case pragma_external
:
31820 cp_parser_declaration (parser
);
31822 case pragma_member
:
31823 cp_parser_member_declaration (parser
);
31825 case pragma_objc_icode
:
31826 cp_parser_block_declaration (parser
, /*statement_p=*/false);
31829 cp_parser_declaration_statement (parser
);
31832 if (parser
->omp_declare_simd
31833 && !parser
->omp_declare_simd
->error_seen
31834 && !parser
->omp_declare_simd
->fndecl_seen
)
31835 error_at (pragma_tok
->location
,
31836 "%<#pragma omp declare simd%> not immediately followed by "
31837 "function declaration or definition");
31838 data
.tokens
.release ();
31839 parser
->omp_declare_simd
= NULL
;
31843 /* Handles the delayed parsing of the Cilk Plus SIMD-enabled function.
31844 This function is modelled similar to the late parsing of omp declare
31848 cp_parser_late_parsing_cilk_simd_fn_info (cp_parser
*parser
, tree attrs
)
31850 struct cp_token_cache
*ce
;
31851 cp_omp_declare_simd_data
*info
= parser
->cilk_simd_fn_info
;
31854 if (parser
->omp_declare_simd
!= NULL
)
31856 error ("%<#pragma omp declare simd%> cannot be used in the same function"
31857 " marked as a Cilk Plus SIMD-enabled function");
31858 XDELETE (parser
->cilk_simd_fn_info
);
31859 parser
->cilk_simd_fn_info
= NULL
;
31862 if (!info
->error_seen
&& info
->fndecl_seen
)
31864 error ("vector attribute not immediately followed by a single function"
31865 " declaration or definition");
31866 info
->error_seen
= true;
31868 if (info
->error_seen
)
31871 FOR_EACH_VEC_ELT (info
->tokens
, ii
, ce
)
31875 cp_parser_push_lexer_for_tokens (parser
, ce
);
31876 parser
->lexer
->in_pragma
= true;
31877 cl
= cp_parser_omp_all_clauses (parser
, CILK_SIMD_FN_CLAUSE_MASK
,
31878 "SIMD-enabled functions attribute",
31880 cp_parser_pop_lexer (parser
);
31882 cl
= tree_cons (NULL_TREE
, cl
, NULL_TREE
);
31884 c
= build_tree_list (get_identifier ("cilk simd function"), NULL_TREE
);
31885 TREE_CHAIN (c
) = attrs
;
31888 c
= build_tree_list (get_identifier ("omp declare simd"), cl
);
31889 TREE_CHAIN (c
) = attrs
;
31890 if (processing_template_decl
)
31891 ATTR_IS_DEPENDENT (c
) = 1;
31894 info
->fndecl_seen
= true;
31895 XDELETE (parser
->cilk_simd_fn_info
);
31896 parser
->cilk_simd_fn_info
= NULL
;
31900 /* Finalize #pragma omp declare simd clauses after direct declarator has
31901 been parsed, and put that into "omp declare simd" attribute. */
31904 cp_parser_late_parsing_omp_declare_simd (cp_parser
*parser
, tree attrs
)
31906 struct cp_token_cache
*ce
;
31907 cp_omp_declare_simd_data
*data
= parser
->omp_declare_simd
;
31910 if (!data
->error_seen
&& data
->fndecl_seen
)
31912 error ("%<#pragma omp declare simd%> not immediately followed by "
31913 "a single function declaration or definition");
31914 data
->error_seen
= true;
31917 if (data
->error_seen
)
31920 FOR_EACH_VEC_ELT (data
->tokens
, i
, ce
)
31924 cp_parser_push_lexer_for_tokens (parser
, ce
);
31925 parser
->lexer
->in_pragma
= true;
31926 gcc_assert (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_PRAGMA
);
31927 cp_token
*pragma_tok
= cp_lexer_consume_token (parser
->lexer
);
31928 cp_lexer_consume_token (parser
->lexer
);
31929 cl
= cp_parser_omp_all_clauses (parser
, OMP_DECLARE_SIMD_CLAUSE_MASK
,
31930 "#pragma omp declare simd", pragma_tok
);
31931 cp_parser_pop_lexer (parser
);
31933 cl
= tree_cons (NULL_TREE
, cl
, NULL_TREE
);
31934 c
= build_tree_list (get_identifier ("omp declare simd"), cl
);
31935 TREE_CHAIN (c
) = attrs
;
31936 if (processing_template_decl
)
31937 ATTR_IS_DEPENDENT (c
) = 1;
31941 data
->fndecl_seen
= true;
31947 # pragma omp declare target new-line
31948 declarations and definitions
31949 # pragma omp end declare target new-line */
31952 cp_parser_omp_declare_target (cp_parser
*parser
, cp_token
*pragma_tok
)
31954 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31955 scope_chain
->omp_declare_target_attribute
++;
31959 cp_parser_omp_end_declare_target (cp_parser
*parser
, cp_token
*pragma_tok
)
31961 const char *p
= "";
31962 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31964 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31965 p
= IDENTIFIER_POINTER (id
);
31967 if (strcmp (p
, "declare") == 0)
31969 cp_lexer_consume_token (parser
->lexer
);
31971 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31973 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31974 p
= IDENTIFIER_POINTER (id
);
31976 if (strcmp (p
, "target") == 0)
31977 cp_lexer_consume_token (parser
->lexer
);
31980 cp_parser_error (parser
, "expected %<target%>");
31981 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31987 cp_parser_error (parser
, "expected %<declare%>");
31988 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31991 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31992 if (!scope_chain
->omp_declare_target_attribute
)
31993 error_at (pragma_tok
->location
,
31994 "%<#pragma omp end declare target%> without corresponding "
31995 "%<#pragma omp declare target%>");
31997 scope_chain
->omp_declare_target_attribute
--;
32000 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
32001 expression and optional initializer clause of
32002 #pragma omp declare reduction. We store the expression(s) as
32003 either 3, 6 or 7 special statements inside of the artificial function's
32004 body. The first two statements are DECL_EXPRs for the artificial
32005 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
32006 expression that uses those variables.
32007 If there was any INITIALIZER clause, this is followed by further statements,
32008 the fourth and fifth statements are DECL_EXPRs for the artificial
32009 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
32010 constructor variant (first token after open paren is not omp_priv),
32011 then the sixth statement is a statement with the function call expression
32012 that uses the OMP_PRIV and optionally OMP_ORIG variable.
32013 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
32014 to initialize the OMP_PRIV artificial variable and there is seventh
32015 statement, a DECL_EXPR of the OMP_PRIV statement again. */
32018 cp_parser_omp_declare_reduction_exprs (tree fndecl
, cp_parser
*parser
)
32020 tree type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
32021 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
32022 type
= TREE_TYPE (type
);
32023 tree omp_out
= build_lang_decl (VAR_DECL
, get_identifier ("omp_out"), type
);
32024 DECL_ARTIFICIAL (omp_out
) = 1;
32025 pushdecl (omp_out
);
32026 add_decl_expr (omp_out
);
32027 tree omp_in
= build_lang_decl (VAR_DECL
, get_identifier ("omp_in"), type
);
32028 DECL_ARTIFICIAL (omp_in
) = 1;
32030 add_decl_expr (omp_in
);
32032 tree omp_priv
= NULL_TREE
, omp_orig
= NULL_TREE
, initializer
= NULL_TREE
;
32034 keep_next_level (true);
32035 tree block
= begin_omp_structured_block ();
32036 combiner
= cp_parser_expression (parser
);
32037 finish_expr_stmt (combiner
);
32038 block
= finish_omp_structured_block (block
);
32041 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
32044 const char *p
= "";
32045 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
32047 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
32048 p
= IDENTIFIER_POINTER (id
);
32051 if (strcmp (p
, "initializer") == 0)
32053 cp_lexer_consume_token (parser
->lexer
);
32054 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
32058 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
32060 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
32061 p
= IDENTIFIER_POINTER (id
);
32064 omp_priv
= build_lang_decl (VAR_DECL
, get_identifier ("omp_priv"), type
);
32065 DECL_ARTIFICIAL (omp_priv
) = 1;
32066 pushdecl (omp_priv
);
32067 add_decl_expr (omp_priv
);
32068 omp_orig
= build_lang_decl (VAR_DECL
, get_identifier ("omp_orig"), type
);
32069 DECL_ARTIFICIAL (omp_orig
) = 1;
32070 pushdecl (omp_orig
);
32071 add_decl_expr (omp_orig
);
32073 keep_next_level (true);
32074 block
= begin_omp_structured_block ();
32077 if (strcmp (p
, "omp_priv") == 0)
32079 bool is_direct_init
, is_non_constant_init
;
32081 cp_lexer_consume_token (parser
->lexer
);
32082 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
32083 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
)
32084 || (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
32085 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
32087 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
32088 == CPP_CLOSE_PAREN
))
32090 finish_omp_structured_block (block
);
32091 error ("invalid initializer clause");
32094 initializer
= cp_parser_initializer (parser
, &is_direct_init
,
32095 &is_non_constant_init
);
32096 cp_finish_decl (omp_priv
, initializer
, !is_non_constant_init
,
32097 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
32101 cp_parser_parse_tentatively (parser
);
32102 tree fn_name
= cp_parser_id_expression (parser
, /*template_p=*/false,
32103 /*check_dependency_p=*/true,
32104 /*template_p=*/NULL
,
32105 /*declarator_p=*/false,
32106 /*optional_p=*/false);
32107 vec
<tree
, va_gc
> *args
;
32108 if (fn_name
== error_mark_node
32109 || cp_parser_error_occurred (parser
)
32110 || !cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
32111 || ((args
= cp_parser_parenthesized_expression_list
32112 (parser
, non_attr
, /*cast_p=*/false,
32113 /*allow_expansion_p=*/true,
32114 /*non_constant_p=*/NULL
)),
32115 cp_parser_error_occurred (parser
)))
32117 finish_omp_structured_block (block
);
32118 cp_parser_abort_tentative_parse (parser
);
32119 cp_parser_error (parser
, "expected id-expression (arguments)");
32124 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
32125 if (arg
== omp_priv
32126 || (TREE_CODE (arg
) == ADDR_EXPR
32127 && TREE_OPERAND (arg
, 0) == omp_priv
))
32129 cp_parser_abort_tentative_parse (parser
);
32130 if (arg
== NULL_TREE
)
32131 error ("one of the initializer call arguments should be %<omp_priv%>"
32132 " or %<&omp_priv%>");
32133 initializer
= cp_parser_postfix_expression (parser
, false, false, false,
32135 finish_expr_stmt (initializer
);
32138 block
= finish_omp_structured_block (block
);
32139 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
32143 add_decl_expr (omp_orig
);
32145 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
32149 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_PRAGMA_EOL
))
32150 cp_parser_required_error (parser
, RT_PRAGMA_EOL
, /*keyword=*/false);
32156 #pragma omp declare reduction (reduction-id : typename-list : expression) \
32157 initializer-clause[opt] new-line
32159 initializer-clause:
32160 initializer (omp_priv initializer)
32161 initializer (function-name (argument-list)) */
32164 cp_parser_omp_declare_reduction (cp_parser
*parser
, cp_token
*pragma_tok
,
32165 enum pragma_context
)
32167 auto_vec
<tree
> types
;
32168 enum tree_code reduc_code
= ERROR_MARK
;
32169 tree reduc_id
= NULL_TREE
, orig_reduc_id
= NULL_TREE
, type
;
32171 cp_token
*first_token
;
32172 cp_token_cache
*cp
;
32176 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
32177 p
= obstack_alloc (&declarator_obstack
, 0);
32179 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
32182 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
32185 reduc_code
= PLUS_EXPR
;
32188 reduc_code
= MULT_EXPR
;
32191 reduc_code
= MINUS_EXPR
;
32194 reduc_code
= BIT_AND_EXPR
;
32197 reduc_code
= BIT_XOR_EXPR
;
32200 reduc_code
= BIT_IOR_EXPR
;
32203 reduc_code
= TRUTH_ANDIF_EXPR
;
32206 reduc_code
= TRUTH_ORIF_EXPR
;
32209 reduc_id
= orig_reduc_id
= cp_parser_identifier (parser
);
32212 cp_parser_error (parser
, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
32213 "%<|%>, %<&&%>, %<||%> or identifier");
32217 if (reduc_code
!= ERROR_MARK
)
32218 cp_lexer_consume_token (parser
->lexer
);
32220 reduc_id
= omp_reduction_id (reduc_code
, reduc_id
, NULL_TREE
);
32221 if (reduc_id
== error_mark_node
)
32224 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
32227 /* Types may not be defined in declare reduction type list. */
32228 const char *saved_message
;
32229 saved_message
= parser
->type_definition_forbidden_message
;
32230 parser
->type_definition_forbidden_message
32231 = G_("types may not be defined in declare reduction type list");
32232 bool saved_colon_corrects_to_scope_p
;
32233 saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
32234 parser
->colon_corrects_to_scope_p
= false;
32235 bool saved_colon_doesnt_start_class_def_p
;
32236 saved_colon_doesnt_start_class_def_p
32237 = parser
->colon_doesnt_start_class_def_p
;
32238 parser
->colon_doesnt_start_class_def_p
= true;
32242 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
32243 type
= cp_parser_type_id (parser
);
32244 if (type
== error_mark_node
)
32246 else if (ARITHMETIC_TYPE_P (type
)
32247 && (orig_reduc_id
== NULL_TREE
32248 || (TREE_CODE (type
) != COMPLEX_TYPE
32249 && (strcmp (IDENTIFIER_POINTER (orig_reduc_id
),
32251 || strcmp (IDENTIFIER_POINTER (orig_reduc_id
),
32253 error_at (loc
, "predeclared arithmetic type %qT in "
32254 "%<#pragma omp declare reduction%>", type
);
32255 else if (TREE_CODE (type
) == FUNCTION_TYPE
32256 || TREE_CODE (type
) == METHOD_TYPE
32257 || TREE_CODE (type
) == ARRAY_TYPE
)
32258 error_at (loc
, "function or array type %qT in "
32259 "%<#pragma omp declare reduction%>", type
);
32260 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
32261 error_at (loc
, "reference type %qT in "
32262 "%<#pragma omp declare reduction%>", type
);
32263 else if (TYPE_QUALS_NO_ADDR_SPACE (type
))
32264 error_at (loc
, "const, volatile or __restrict qualified type %qT in "
32265 "%<#pragma omp declare reduction%>", type
);
32267 types
.safe_push (type
);
32269 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
32270 cp_lexer_consume_token (parser
->lexer
);
32275 /* Restore the saved message. */
32276 parser
->type_definition_forbidden_message
= saved_message
;
32277 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
32278 parser
->colon_doesnt_start_class_def_p
32279 = saved_colon_doesnt_start_class_def_p
;
32281 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
)
32282 || types
.is_empty ())
32285 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32289 first_token
= cp_lexer_peek_token (parser
->lexer
);
32292 FOR_EACH_VEC_ELT (types
, i
, type
)
32295 = build_function_type_list (void_type_node
,
32296 cp_build_reference_type (type
, false),
32298 tree this_reduc_id
= reduc_id
;
32299 if (!dependent_type_p (type
))
32300 this_reduc_id
= omp_reduction_id (ERROR_MARK
, reduc_id
, type
);
32301 tree fndecl
= build_lang_decl (FUNCTION_DECL
, this_reduc_id
, fntype
);
32302 DECL_SOURCE_LOCATION (fndecl
) = pragma_tok
->location
;
32303 DECL_ARTIFICIAL (fndecl
) = 1;
32304 DECL_EXTERNAL (fndecl
) = 1;
32305 DECL_DECLARED_INLINE_P (fndecl
) = 1;
32306 DECL_IGNORED_P (fndecl
) = 1;
32307 DECL_OMP_DECLARE_REDUCTION_P (fndecl
) = 1;
32308 DECL_ATTRIBUTES (fndecl
)
32309 = tree_cons (get_identifier ("gnu_inline"), NULL_TREE
,
32310 DECL_ATTRIBUTES (fndecl
));
32311 if (processing_template_decl
)
32312 fndecl
= push_template_decl (fndecl
);
32313 bool block_scope
= false;
32314 tree block
= NULL_TREE
;
32315 if (current_function_decl
)
32317 block_scope
= true;
32318 DECL_CONTEXT (fndecl
) = global_namespace
;
32319 if (!processing_template_decl
)
32322 else if (current_class_type
)
32326 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
)
32327 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_EOF
))
32328 cp_lexer_consume_token (parser
->lexer
);
32329 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
32331 cp
= cp_token_cache_new (first_token
,
32332 cp_lexer_peek_nth_token (parser
->lexer
,
32335 DECL_STATIC_FUNCTION_P (fndecl
) = 1;
32336 finish_member_declaration (fndecl
);
32337 DECL_PENDING_INLINE_INFO (fndecl
) = cp
;
32338 DECL_PENDING_INLINE_P (fndecl
) = 1;
32339 vec_safe_push (unparsed_funs_with_definitions
, fndecl
);
32344 DECL_CONTEXT (fndecl
) = current_namespace
;
32348 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
32350 block
= begin_omp_structured_block ();
32353 cp_parser_push_lexer_for_tokens (parser
, cp
);
32354 parser
->lexer
->in_pragma
= true;
32356 if (!cp_parser_omp_declare_reduction_exprs (fndecl
, parser
))
32359 finish_function (0);
32361 DECL_CONTEXT (fndecl
) = current_function_decl
;
32363 cp_parser_pop_lexer (parser
);
32367 cp_parser_pop_lexer (parser
);
32369 finish_function (0);
32372 DECL_CONTEXT (fndecl
) = current_function_decl
;
32373 block
= finish_omp_structured_block (block
);
32374 if (TREE_CODE (block
) == BIND_EXPR
)
32375 DECL_SAVED_TREE (fndecl
) = BIND_EXPR_BODY (block
);
32376 else if (TREE_CODE (block
) == STATEMENT_LIST
)
32377 DECL_SAVED_TREE (fndecl
) = block
;
32378 if (processing_template_decl
)
32379 add_decl_expr (fndecl
);
32381 cp_check_omp_declare_reduction (fndecl
);
32382 if (cp
== NULL
&& types
.length () > 1)
32383 cp
= cp_token_cache_new (first_token
,
32384 cp_lexer_peek_nth_token (parser
->lexer
, 2));
32385 if (errs
!= errorcount
)
32389 cp_parser_require_pragma_eol (parser
, pragma_tok
);
32392 /* Free any declarators allocated. */
32393 obstack_free (&declarator_obstack
, p
);
32397 #pragma omp declare simd declare-simd-clauses[optseq] new-line
32398 #pragma omp declare reduction (reduction-id : typename-list : expression) \
32399 initializer-clause[opt] new-line
32400 #pragma omp declare target new-line */
32403 cp_parser_omp_declare (cp_parser
*parser
, cp_token
*pragma_tok
,
32404 enum pragma_context context
)
32406 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
32408 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
32409 const char *p
= IDENTIFIER_POINTER (id
);
32411 if (strcmp (p
, "simd") == 0)
32413 cp_lexer_consume_token (parser
->lexer
);
32414 cp_parser_omp_declare_simd (parser
, pragma_tok
,
32418 cp_ensure_no_omp_declare_simd (parser
);
32419 if (strcmp (p
, "reduction") == 0)
32421 cp_lexer_consume_token (parser
->lexer
);
32422 cp_parser_omp_declare_reduction (parser
, pragma_tok
,
32426 if (!flag_openmp
) /* flag_openmp_simd */
32428 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32431 if (strcmp (p
, "target") == 0)
32433 cp_lexer_consume_token (parser
->lexer
);
32434 cp_parser_omp_declare_target (parser
, pragma_tok
);
32438 cp_parser_error (parser
, "expected %<simd%> or %<reduction%> "
32440 cp_parser_require_pragma_eol (parser
, pragma_tok
);
32443 /* Main entry point to OpenMP statement pragmas. */
32446 cp_parser_omp_construct (cp_parser
*parser
, cp_token
*pragma_tok
)
32449 char p_name
[sizeof "#pragma omp teams distribute parallel for simd"];
32450 omp_clause_mask
mask (0);
32452 switch (pragma_tok
->pragma_kind
)
32454 case PRAGMA_OACC_CACHE
:
32455 stmt
= cp_parser_oacc_cache (parser
, pragma_tok
);
32457 case PRAGMA_OACC_DATA
:
32458 stmt
= cp_parser_oacc_data (parser
, pragma_tok
);
32460 case PRAGMA_OACC_ENTER_DATA
:
32461 stmt
= cp_parser_oacc_enter_exit_data (parser
, pragma_tok
, true);
32463 case PRAGMA_OACC_EXIT_DATA
:
32464 stmt
= cp_parser_oacc_enter_exit_data (parser
, pragma_tok
, false);
32466 case PRAGMA_OACC_KERNELS
:
32467 stmt
= cp_parser_oacc_kernels (parser
, pragma_tok
);
32469 case PRAGMA_OACC_LOOP
:
32470 stmt
= cp_parser_oacc_loop (parser
, pragma_tok
);
32472 case PRAGMA_OACC_PARALLEL
:
32473 stmt
= cp_parser_oacc_parallel (parser
, pragma_tok
);
32475 case PRAGMA_OACC_UPDATE
:
32476 stmt
= cp_parser_oacc_update (parser
, pragma_tok
);
32478 case PRAGMA_OACC_WAIT
:
32479 stmt
= cp_parser_oacc_wait (parser
, pragma_tok
);
32481 case PRAGMA_OMP_ATOMIC
:
32482 cp_parser_omp_atomic (parser
, pragma_tok
);
32484 case PRAGMA_OMP_CRITICAL
:
32485 stmt
= cp_parser_omp_critical (parser
, pragma_tok
);
32487 case PRAGMA_OMP_DISTRIBUTE
:
32488 strcpy (p_name
, "#pragma omp");
32489 stmt
= cp_parser_omp_distribute (parser
, pragma_tok
, p_name
, mask
, NULL
);
32491 case PRAGMA_OMP_FOR
:
32492 strcpy (p_name
, "#pragma omp");
32493 stmt
= cp_parser_omp_for (parser
, pragma_tok
, p_name
, mask
, NULL
);
32495 case PRAGMA_OMP_MASTER
:
32496 stmt
= cp_parser_omp_master (parser
, pragma_tok
);
32498 case PRAGMA_OMP_ORDERED
:
32499 stmt
= cp_parser_omp_ordered (parser
, pragma_tok
);
32501 case PRAGMA_OMP_PARALLEL
:
32502 strcpy (p_name
, "#pragma omp");
32503 stmt
= cp_parser_omp_parallel (parser
, pragma_tok
, p_name
, mask
, NULL
);
32505 case PRAGMA_OMP_SECTIONS
:
32506 strcpy (p_name
, "#pragma omp");
32507 stmt
= cp_parser_omp_sections (parser
, pragma_tok
, p_name
, mask
, NULL
);
32509 case PRAGMA_OMP_SIMD
:
32510 strcpy (p_name
, "#pragma omp");
32511 stmt
= cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
, NULL
);
32513 case PRAGMA_OMP_SINGLE
:
32514 stmt
= cp_parser_omp_single (parser
, pragma_tok
);
32516 case PRAGMA_OMP_TASK
:
32517 stmt
= cp_parser_omp_task (parser
, pragma_tok
);
32519 case PRAGMA_OMP_TASKGROUP
:
32520 stmt
= cp_parser_omp_taskgroup (parser
, pragma_tok
);
32522 case PRAGMA_OMP_TEAMS
:
32523 strcpy (p_name
, "#pragma omp");
32524 stmt
= cp_parser_omp_teams (parser
, pragma_tok
, p_name
, mask
, NULL
);
32527 gcc_unreachable ();
32531 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
32534 /* Transactional Memory parsing routines. */
32536 /* Parse a transaction attribute.
32542 ??? Simplify this when C++0x bracket attributes are
32543 implemented properly. */
32546 cp_parser_txn_attribute_opt (cp_parser
*parser
)
32549 tree attr_name
, attr
= NULL
;
32551 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ATTRIBUTE
))
32552 return cp_parser_attributes_opt (parser
);
32554 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_SQUARE
))
32556 cp_lexer_consume_token (parser
->lexer
);
32557 if (!cp_parser_require (parser
, CPP_OPEN_SQUARE
, RT_OPEN_SQUARE
))
32560 token
= cp_lexer_peek_token (parser
->lexer
);
32561 if (token
->type
== CPP_NAME
|| token
->type
== CPP_KEYWORD
)
32563 token
= cp_lexer_consume_token (parser
->lexer
);
32565 attr_name
= (token
->type
== CPP_KEYWORD
32566 /* For keywords, use the canonical spelling,
32567 not the parsed identifier. */
32568 ? ridpointers
[(int) token
->keyword
]
32570 attr
= build_tree_list (attr_name
, NULL_TREE
);
32573 cp_parser_error (parser
, "expected identifier");
32575 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
32577 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
32581 /* Parse a __transaction_atomic or __transaction_relaxed statement.
32583 transaction-statement:
32584 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
32586 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
32590 cp_parser_transaction (cp_parser
*parser
, enum rid keyword
)
32592 unsigned char old_in
= parser
->in_transaction
;
32593 unsigned char this_in
= 1, new_in
;
32595 tree stmt
, attrs
, noex
;
32597 gcc_assert (keyword
== RID_TRANSACTION_ATOMIC
32598 || keyword
== RID_TRANSACTION_RELAXED
);
32599 token
= cp_parser_require_keyword (parser
, keyword
,
32600 (keyword
== RID_TRANSACTION_ATOMIC
? RT_TRANSACTION_ATOMIC
32601 : RT_TRANSACTION_RELAXED
));
32602 gcc_assert (token
!= NULL
);
32604 if (keyword
== RID_TRANSACTION_RELAXED
)
32605 this_in
|= TM_STMT_ATTR_RELAXED
;
32608 attrs
= cp_parser_txn_attribute_opt (parser
);
32610 this_in
|= parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
);
32613 /* Parse a noexcept specification. */
32614 noex
= cp_parser_noexcept_specification_opt (parser
, true, NULL
, true);
32616 /* Keep track if we're in the lexical scope of an outer transaction. */
32617 new_in
= this_in
| (old_in
& TM_STMT_ATTR_OUTER
);
32619 stmt
= begin_transaction_stmt (token
->location
, NULL
, this_in
);
32621 parser
->in_transaction
= new_in
;
32622 cp_parser_compound_statement (parser
, NULL
, false, false);
32623 parser
->in_transaction
= old_in
;
32625 finish_transaction_stmt (stmt
, NULL
, this_in
, noex
);
32630 /* Parse a __transaction_atomic or __transaction_relaxed expression.
32632 transaction-expression:
32633 __transaction_atomic txn-noexcept-spec[opt] ( expression )
32634 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
32638 cp_parser_transaction_expression (cp_parser
*parser
, enum rid keyword
)
32640 unsigned char old_in
= parser
->in_transaction
;
32641 unsigned char this_in
= 1;
32646 gcc_assert (keyword
== RID_TRANSACTION_ATOMIC
32647 || keyword
== RID_TRANSACTION_RELAXED
);
32650 error (keyword
== RID_TRANSACTION_RELAXED
32651 ? G_("%<__transaction_relaxed%> without transactional memory "
32653 : G_("%<__transaction_atomic%> without transactional memory "
32654 "support enabled"));
32656 token
= cp_parser_require_keyword (parser
, keyword
,
32657 (keyword
== RID_TRANSACTION_ATOMIC
? RT_TRANSACTION_ATOMIC
32658 : RT_TRANSACTION_RELAXED
));
32659 gcc_assert (token
!= NULL
);
32661 if (keyword
== RID_TRANSACTION_RELAXED
)
32662 this_in
|= TM_STMT_ATTR_RELAXED
;
32664 /* Set this early. This might mean that we allow transaction_cancel in
32665 an expression that we find out later actually has to be a constexpr.
32666 However, we expect that cxx_constant_value will be able to deal with
32667 this; also, if the noexcept has no constexpr, then what we parse next
32668 really is a transaction's body. */
32669 parser
->in_transaction
= this_in
;
32671 /* Parse a noexcept specification. */
32672 noex
= cp_parser_noexcept_specification_opt (parser
, false, &noex_expr
,
32675 if (!noex
|| !noex_expr
32676 || cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
32678 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
32680 expr
= cp_parser_expression (parser
);
32681 expr
= finish_parenthesized_expr (expr
);
32683 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
32687 /* The only expression that is available got parsed for the noexcept
32688 already. noexcept is true then. */
32690 noex
= boolean_true_node
;
32693 expr
= build_transaction_expr (token
->location
, expr
, this_in
, noex
);
32694 parser
->in_transaction
= old_in
;
32696 if (cp_parser_non_integral_constant_expression (parser
, NIC_TRANSACTION
))
32697 return error_mark_node
;
32699 return (flag_tm
? expr
: error_mark_node
);
32702 /* Parse a function-transaction-block.
32704 function-transaction-block:
32705 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
32707 __transaction_atomic txn-attribute[opt] function-try-block
32708 __transaction_relaxed ctor-initializer[opt] function-body
32709 __transaction_relaxed function-try-block
32713 cp_parser_function_transaction (cp_parser
*parser
, enum rid keyword
)
32715 unsigned char old_in
= parser
->in_transaction
;
32716 unsigned char new_in
= 1;
32717 tree compound_stmt
, stmt
, attrs
;
32718 bool ctor_initializer_p
;
32721 gcc_assert (keyword
== RID_TRANSACTION_ATOMIC
32722 || keyword
== RID_TRANSACTION_RELAXED
);
32723 token
= cp_parser_require_keyword (parser
, keyword
,
32724 (keyword
== RID_TRANSACTION_ATOMIC
? RT_TRANSACTION_ATOMIC
32725 : RT_TRANSACTION_RELAXED
));
32726 gcc_assert (token
!= NULL
);
32728 if (keyword
== RID_TRANSACTION_RELAXED
)
32729 new_in
|= TM_STMT_ATTR_RELAXED
;
32732 attrs
= cp_parser_txn_attribute_opt (parser
);
32734 new_in
|= parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
);
32737 stmt
= begin_transaction_stmt (token
->location
, &compound_stmt
, new_in
);
32739 parser
->in_transaction
= new_in
;
32741 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRY
))
32742 ctor_initializer_p
= cp_parser_function_try_block (parser
);
32744 ctor_initializer_p
= cp_parser_ctor_initializer_opt_and_function_body
32745 (parser
, /*in_function_try_block=*/false);
32747 parser
->in_transaction
= old_in
;
32749 finish_transaction_stmt (stmt
, compound_stmt
, new_in
, NULL_TREE
);
32751 return ctor_initializer_p
;
32754 /* Parse a __transaction_cancel statement.
32757 __transaction_cancel txn-attribute[opt] ;
32758 __transaction_cancel txn-attribute[opt] throw-expression ;
32760 ??? Cancel and throw is not yet implemented. */
32763 cp_parser_transaction_cancel (cp_parser
*parser
)
32766 bool is_outer
= false;
32769 token
= cp_parser_require_keyword (parser
, RID_TRANSACTION_CANCEL
,
32770 RT_TRANSACTION_CANCEL
);
32771 gcc_assert (token
!= NULL
);
32773 attrs
= cp_parser_txn_attribute_opt (parser
);
32775 is_outer
= (parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
) != 0);
32777 /* ??? Parse cancel-and-throw here. */
32779 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
32783 error_at (token
->location
, "%<__transaction_cancel%> without "
32784 "transactional memory support enabled");
32785 return error_mark_node
;
32787 else if (parser
->in_transaction
& TM_STMT_ATTR_RELAXED
)
32789 error_at (token
->location
, "%<__transaction_cancel%> within a "
32790 "%<__transaction_relaxed%>");
32791 return error_mark_node
;
32795 if ((parser
->in_transaction
& TM_STMT_ATTR_OUTER
) == 0
32796 && !is_tm_may_cancel_outer (current_function_decl
))
32798 error_at (token
->location
, "outer %<__transaction_cancel%> not "
32799 "within outer %<__transaction_atomic%>");
32800 error_at (token
->location
,
32801 " or a %<transaction_may_cancel_outer%> function");
32802 return error_mark_node
;
32805 else if (parser
->in_transaction
== 0)
32807 error_at (token
->location
, "%<__transaction_cancel%> not within "
32808 "%<__transaction_atomic%>");
32809 return error_mark_node
;
32812 stmt
= build_tm_abort_call (token
->location
, is_outer
);
32820 static GTY (()) cp_parser
*the_parser
;
32823 /* Special handling for the first token or line in the file. The first
32824 thing in the file might be #pragma GCC pch_preprocess, which loads a
32825 PCH file, which is a GC collection point. So we need to handle this
32826 first pragma without benefit of an existing lexer structure.
32828 Always returns one token to the caller in *FIRST_TOKEN. This is
32829 either the true first token of the file, or the first token after
32830 the initial pragma. */
32833 cp_parser_initial_pragma (cp_token
*first_token
)
32837 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32838 if (first_token
->pragma_kind
!= PRAGMA_GCC_PCH_PREPROCESS
)
32841 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32842 if (first_token
->type
== CPP_STRING
)
32844 name
= first_token
->u
.value
;
32846 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32847 if (first_token
->type
!= CPP_PRAGMA_EOL
)
32848 error_at (first_token
->location
,
32849 "junk at end of %<#pragma GCC pch_preprocess%>");
32852 error_at (first_token
->location
, "expected string literal");
32854 /* Skip to the end of the pragma. */
32855 while (first_token
->type
!= CPP_PRAGMA_EOL
&& first_token
->type
!= CPP_EOF
)
32856 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32858 /* Now actually load the PCH file. */
32860 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
32862 /* Read one more token to return to our caller. We have to do this
32863 after reading the PCH file in, since its pointers have to be
32865 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32868 /* Parses the grainsize pragma for the _Cilk_for statement.
32870 #pragma cilk grainsize = <VALUE>. */
32873 cp_parser_cilk_grainsize (cp_parser
*parser
, cp_token
*pragma_tok
)
32875 if (cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
32877 tree exp
= cp_parser_binary_expression (parser
, false, false,
32878 PREC_NOT_OPERATOR
, NULL
);
32879 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32880 if (!exp
|| exp
== error_mark_node
)
32882 error_at (pragma_tok
->location
, "invalid grainsize for _Cilk_for");
32886 /* Make sure the next token is _Cilk_for, it is invalid otherwise. */
32887 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CILK_FOR
))
32888 cp_parser_cilk_for (parser
, exp
);
32890 warning_at (cp_lexer_peek_token (parser
->lexer
)->location
, 0,
32891 "%<#pragma cilk grainsize%> is not followed by "
32895 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32898 /* Normal parsing of a pragma token. Here we can (and must) use the
32902 cp_parser_pragma (cp_parser
*parser
, enum pragma_context context
)
32904 cp_token
*pragma_tok
;
32907 pragma_tok
= cp_lexer_consume_token (parser
->lexer
);
32908 gcc_assert (pragma_tok
->type
== CPP_PRAGMA
);
32909 parser
->lexer
->in_pragma
= true;
32911 id
= pragma_tok
->pragma_kind
;
32912 if (id
!= PRAGMA_OMP_DECLARE_REDUCTION
)
32913 cp_ensure_no_omp_declare_simd (parser
);
32916 case PRAGMA_GCC_PCH_PREPROCESS
:
32917 error_at (pragma_tok
->location
,
32918 "%<#pragma GCC pch_preprocess%> must be first");
32921 case PRAGMA_OMP_BARRIER
:
32924 case pragma_compound
:
32925 cp_parser_omp_barrier (parser
, pragma_tok
);
32928 error_at (pragma_tok
->location
, "%<#pragma omp barrier%> may only be "
32929 "used in compound statements");
32936 case PRAGMA_OMP_FLUSH
:
32939 case pragma_compound
:
32940 cp_parser_omp_flush (parser
, pragma_tok
);
32943 error_at (pragma_tok
->location
, "%<#pragma omp flush%> may only be "
32944 "used in compound statements");
32951 case PRAGMA_OMP_TASKWAIT
:
32954 case pragma_compound
:
32955 cp_parser_omp_taskwait (parser
, pragma_tok
);
32958 error_at (pragma_tok
->location
,
32959 "%<#pragma omp taskwait%> may only be "
32960 "used in compound statements");
32967 case PRAGMA_OMP_TASKYIELD
:
32970 case pragma_compound
:
32971 cp_parser_omp_taskyield (parser
, pragma_tok
);
32974 error_at (pragma_tok
->location
,
32975 "%<#pragma omp taskyield%> may only be "
32976 "used in compound statements");
32983 case PRAGMA_OMP_CANCEL
:
32986 case pragma_compound
:
32987 cp_parser_omp_cancel (parser
, pragma_tok
);
32990 error_at (pragma_tok
->location
,
32991 "%<#pragma omp cancel%> may only be "
32992 "used in compound statements");
32999 case PRAGMA_OMP_CANCELLATION_POINT
:
33002 case pragma_compound
:
33003 cp_parser_omp_cancellation_point (parser
, pragma_tok
);
33006 error_at (pragma_tok
->location
,
33007 "%<#pragma omp cancellation point%> may only be "
33008 "used in compound statements");
33015 case PRAGMA_OMP_THREADPRIVATE
:
33016 cp_parser_omp_threadprivate (parser
, pragma_tok
);
33019 case PRAGMA_OMP_DECLARE_REDUCTION
:
33020 cp_parser_omp_declare (parser
, pragma_tok
, context
);
33023 case PRAGMA_OACC_CACHE
:
33024 case PRAGMA_OACC_DATA
:
33025 case PRAGMA_OACC_ENTER_DATA
:
33026 case PRAGMA_OACC_EXIT_DATA
:
33027 case PRAGMA_OACC_KERNELS
:
33028 case PRAGMA_OACC_PARALLEL
:
33029 case PRAGMA_OACC_LOOP
:
33030 case PRAGMA_OACC_UPDATE
:
33031 case PRAGMA_OACC_WAIT
:
33032 case PRAGMA_OMP_ATOMIC
:
33033 case PRAGMA_OMP_CRITICAL
:
33034 case PRAGMA_OMP_DISTRIBUTE
:
33035 case PRAGMA_OMP_FOR
:
33036 case PRAGMA_OMP_MASTER
:
33037 case PRAGMA_OMP_ORDERED
:
33038 case PRAGMA_OMP_PARALLEL
:
33039 case PRAGMA_OMP_SECTIONS
:
33040 case PRAGMA_OMP_SIMD
:
33041 case PRAGMA_OMP_SINGLE
:
33042 case PRAGMA_OMP_TASK
:
33043 case PRAGMA_OMP_TASKGROUP
:
33044 case PRAGMA_OMP_TEAMS
:
33045 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
33047 cp_parser_omp_construct (parser
, pragma_tok
);
33050 case PRAGMA_OMP_TARGET
:
33051 return cp_parser_omp_target (parser
, pragma_tok
, context
);
33053 case PRAGMA_OMP_END_DECLARE_TARGET
:
33054 cp_parser_omp_end_declare_target (parser
, pragma_tok
);
33057 case PRAGMA_OMP_SECTION
:
33058 error_at (pragma_tok
->location
,
33059 "%<#pragma omp section%> may only be used in "
33060 "%<#pragma omp sections%> construct");
33065 if (context
== pragma_external
)
33067 error_at (pragma_tok
->location
,
33068 "%<#pragma GCC ivdep%> must be inside a function");
33071 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
33073 tok
= cp_lexer_peek_token (the_parser
->lexer
);
33074 if (tok
->type
!= CPP_KEYWORD
33075 || (tok
->keyword
!= RID_FOR
&& tok
->keyword
!= RID_WHILE
33076 && tok
->keyword
!= RID_DO
))
33078 cp_parser_error (parser
, "for, while or do statement expected");
33081 cp_parser_iteration_statement (parser
, true);
33085 case PRAGMA_CILK_SIMD
:
33086 if (context
== pragma_external
)
33088 error_at (pragma_tok
->location
,
33089 "%<#pragma simd%> must be inside a function");
33092 cp_parser_cilk_simd (parser
, pragma_tok
);
33095 case PRAGMA_CILK_GRAINSIZE
:
33096 if (context
== pragma_external
)
33098 error_at (pragma_tok
->location
,
33099 "%<#pragma cilk grainsize%> must be inside a function");
33103 /* Ignore the pragma if Cilk Plus is not enabled. */
33106 cp_parser_cilk_grainsize (parser
, pragma_tok
);
33111 error_at (pragma_tok
->location
, "-fcilkplus must be enabled to use "
33112 "%<#pragma cilk grainsize%>");
33117 gcc_assert (id
>= PRAGMA_FIRST_EXTERNAL
);
33118 c_invoke_pragma_handler (id
);
33122 cp_parser_error (parser
, "expected declaration specifiers");
33126 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
33130 /* The interface the pragma parsers have to the lexer. */
33133 pragma_lex (tree
*value
)
33136 enum cpp_ttype ret
;
33138 tok
= cp_lexer_peek_token (the_parser
->lexer
);
33141 *value
= tok
->u
.value
;
33143 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
33145 else if (ret
== CPP_STRING
)
33146 *value
= cp_parser_string_literal (the_parser
, false, false);
33149 cp_lexer_consume_token (the_parser
->lexer
);
33150 if (ret
== CPP_KEYWORD
)
33158 /* External interface. */
33160 /* Parse one entire translation unit. */
33163 c_parse_file (void)
33165 static bool already_called
= false;
33167 if (already_called
)
33168 fatal_error (input_location
,
33169 "inter-module optimizations not implemented for C++");
33170 already_called
= true;
33172 the_parser
= cp_parser_new ();
33173 push_deferring_access_checks (flag_access_control
33174 ? dk_no_deferred
: dk_no_check
);
33175 cp_parser_translation_unit (the_parser
);
33179 /* Parses the Cilk Plus #pragma simd and SIMD-enabled function attribute's
33180 vectorlength clause:
33182 vectorlength ( constant-expression ) */
33185 cp_parser_cilk_simd_vectorlength (cp_parser
*parser
, tree clauses
,
33188 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
33190 /* The vectorlength clause in #pragma simd behaves exactly like OpenMP's
33191 safelen clause. Thus, vectorlength is represented as OMP 4.0
33192 safelen. For SIMD-enabled function it is represented by OMP 4.0
33195 check_no_duplicate_clause (clauses
, OMP_CLAUSE_SAFELEN
, "vectorlength",
33198 check_no_duplicate_clause (clauses
, OMP_CLAUSE_SIMDLEN
, "vectorlength",
33201 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
33202 return error_mark_node
;
33204 expr
= cp_parser_constant_expression (parser
);
33205 expr
= maybe_constant_value (expr
);
33207 /* If expr == error_mark_node, then don't emit any errors nor
33208 create a clause. if any of the above functions returns
33209 error mark node then they would have emitted an error message. */
33210 if (expr
== error_mark_node
)
33212 else if (!TREE_TYPE (expr
)
33213 || !TREE_CONSTANT (expr
)
33214 || !INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
33215 error_at (loc
, "vectorlength must be an integer constant");
33216 else if (TREE_CONSTANT (expr
)
33217 && exact_log2 (TREE_INT_CST_LOW (expr
)) == -1)
33218 error_at (loc
, "vectorlength must be a power of 2");
33224 c
= build_omp_clause (loc
, OMP_CLAUSE_SAFELEN
);
33225 OMP_CLAUSE_SAFELEN_EXPR (c
) = expr
;
33226 OMP_CLAUSE_CHAIN (c
) = clauses
;
33231 c
= build_omp_clause (loc
, OMP_CLAUSE_SIMDLEN
);
33232 OMP_CLAUSE_SIMDLEN_EXPR (c
) = expr
;
33233 OMP_CLAUSE_CHAIN (c
) = clauses
;
33238 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
33239 return error_mark_node
;
33243 /* Handles the Cilk Plus #pragma simd linear clause.
33245 linear ( simd-linear-variable-list )
33247 simd-linear-variable-list:
33248 simd-linear-variable
33249 simd-linear-variable-list , simd-linear-variable
33251 simd-linear-variable:
33253 id-expression : simd-linear-step
33256 conditional-expression */
33259 cp_parser_cilk_simd_linear (cp_parser
*parser
, tree clauses
)
33261 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
33263 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
33265 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
33267 cp_parser_error (parser
, "expected identifier");
33268 cp_parser_skip_to_closing_parenthesis (parser
, false, false, true);
33269 return error_mark_node
;
33272 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
33273 parser
->colon_corrects_to_scope_p
= false;
33276 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
33277 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
33279 cp_parser_error (parser
, "expected variable-name");
33280 clauses
= error_mark_node
;
33284 tree var_name
= cp_parser_id_expression (parser
, false, true, NULL
,
33286 tree decl
= cp_parser_lookup_name_simple (parser
, var_name
,
33288 if (decl
== error_mark_node
)
33290 cp_parser_name_lookup_error (parser
, var_name
, decl
, NLE_NULL
,
33292 clauses
= error_mark_node
;
33296 tree e
= NULL_TREE
;
33297 tree step_size
= integer_one_node
;
33299 /* If present, parse the linear step. Otherwise, assume the default
33301 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_COLON
)
33303 cp_lexer_consume_token (parser
->lexer
);
33305 e
= cp_parser_assignment_expression (parser
);
33306 e
= maybe_constant_value (e
);
33308 if (e
== error_mark_node
)
33310 /* If an error has occurred, then the whole pragma is
33311 considered ill-formed. Thus, no reason to keep
33313 clauses
= error_mark_node
;
33316 else if (type_dependent_expression_p (e
)
33317 || value_dependent_expression_p (e
)
33319 && INTEGRAL_TYPE_P (TREE_TYPE (e
))
33320 && (TREE_CONSTANT (e
)
33324 cp_parser_error (parser
,
33325 "step size must be an integer constant "
33326 "expression or an integer variable");
33329 /* Use the OMP_CLAUSE_LINEAR, which has the same semantics. */
33330 tree l
= build_omp_clause (loc
, OMP_CLAUSE_LINEAR
);
33331 OMP_CLAUSE_DECL (l
) = decl
;
33332 OMP_CLAUSE_LINEAR_STEP (l
) = step_size
;
33333 OMP_CLAUSE_CHAIN (l
) = clauses
;
33336 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
33337 cp_lexer_consume_token (parser
->lexer
);
33338 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
33342 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
33343 "expected %<,%> or %<)%> after %qE", decl
);
33344 clauses
= error_mark_node
;
33348 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
33349 cp_parser_skip_to_closing_parenthesis (parser
, false, false, true);
33353 /* Returns the name of the next clause. If the clause is not
33354 recognized, then PRAGMA_CILK_CLAUSE_NONE is returned and the next
33355 token is not consumed. Otherwise, the appropriate enum from the
33356 pragma_simd_clause is returned and the token is consumed. */
33358 static pragma_omp_clause
33359 cp_parser_cilk_simd_clause_name (cp_parser
*parser
)
33361 pragma_omp_clause clause_type
;
33362 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
33364 if (token
->keyword
== RID_PRIVATE
)
33365 clause_type
= PRAGMA_CILK_CLAUSE_PRIVATE
;
33366 else if (!token
->u
.value
|| token
->type
!= CPP_NAME
)
33367 return PRAGMA_CILK_CLAUSE_NONE
;
33368 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "vectorlength"))
33369 clause_type
= PRAGMA_CILK_CLAUSE_VECTORLENGTH
;
33370 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "linear"))
33371 clause_type
= PRAGMA_CILK_CLAUSE_LINEAR
;
33372 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "firstprivate"))
33373 clause_type
= PRAGMA_CILK_CLAUSE_FIRSTPRIVATE
;
33374 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "lastprivate"))
33375 clause_type
= PRAGMA_CILK_CLAUSE_LASTPRIVATE
;
33376 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "reduction"))
33377 clause_type
= PRAGMA_CILK_CLAUSE_REDUCTION
;
33379 return PRAGMA_CILK_CLAUSE_NONE
;
33381 cp_lexer_consume_token (parser
->lexer
);
33382 return clause_type
;
33385 /* Parses all the #pragma simd clauses. Returns a list of clauses found. */
33388 cp_parser_cilk_simd_all_clauses (cp_parser
*parser
, cp_token
*pragma_token
)
33390 tree clauses
= NULL_TREE
;
33392 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
)
33393 && clauses
!= error_mark_node
)
33395 pragma_omp_clause c_kind
;
33396 c_kind
= cp_parser_cilk_simd_clause_name (parser
);
33397 if (c_kind
== PRAGMA_CILK_CLAUSE_VECTORLENGTH
)
33398 clauses
= cp_parser_cilk_simd_vectorlength (parser
, clauses
, false);
33399 else if (c_kind
== PRAGMA_CILK_CLAUSE_LINEAR
)
33400 clauses
= cp_parser_cilk_simd_linear (parser
, clauses
);
33401 else if (c_kind
== PRAGMA_CILK_CLAUSE_PRIVATE
)
33402 /* Use the OpenMP 4.0 equivalent function. */
33403 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_PRIVATE
, clauses
);
33404 else if (c_kind
== PRAGMA_CILK_CLAUSE_FIRSTPRIVATE
)
33405 /* Use the OpenMP 4.0 equivalent function. */
33406 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_FIRSTPRIVATE
,
33408 else if (c_kind
== PRAGMA_CILK_CLAUSE_LASTPRIVATE
)
33409 /* Use the OMP 4.0 equivalent function. */
33410 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_LASTPRIVATE
,
33412 else if (c_kind
== PRAGMA_CILK_CLAUSE_REDUCTION
)
33413 /* Use the OMP 4.0 equivalent function. */
33414 clauses
= cp_parser_omp_clause_reduction (parser
, clauses
);
33417 clauses
= error_mark_node
;
33418 cp_parser_error (parser
, "expected %<#pragma simd%> clause");
33423 cp_parser_skip_to_pragma_eol (parser
, pragma_token
);
33425 if (clauses
== error_mark_node
)
33426 return error_mark_node
;
33428 return c_finish_cilk_clauses (clauses
);
33431 /* Main entry-point for parsing Cilk Plus <#pragma simd> for loops. */
33434 cp_parser_cilk_simd (cp_parser
*parser
, cp_token
*pragma_token
)
33436 tree clauses
= cp_parser_cilk_simd_all_clauses (parser
, pragma_token
);
33438 if (clauses
== error_mark_node
)
33441 if (cp_lexer_next_token_is_not_keyword (parser
->lexer
, RID_FOR
))
33443 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
33444 "for statement expected");
33448 tree sb
= begin_omp_structured_block ();
33449 int save
= cp_parser_begin_omp_structured_block (parser
);
33450 tree ret
= cp_parser_omp_for_loop (parser
, CILK_SIMD
, clauses
, NULL
);
33452 cpp_validate_cilk_plus_loop (OMP_FOR_BODY (ret
));
33453 cp_parser_end_omp_structured_block (parser
, save
);
33454 add_stmt (finish_omp_structured_block (sb
));
33457 /* Main entry-point for parsing Cilk Plus _Cilk_for
33458 loops. The return value is error_mark_node
33459 when errors happen and CILK_FOR tree on success. */
33462 cp_parser_cilk_for (cp_parser
*parser
, tree grain
)
33464 if (cp_lexer_next_token_is_not_keyword (parser
->lexer
, RID_CILK_FOR
))
33465 gcc_unreachable ();
33467 tree sb
= begin_omp_structured_block ();
33468 int save
= cp_parser_begin_omp_structured_block (parser
);
33470 tree clauses
= build_omp_clause (EXPR_LOCATION (grain
), OMP_CLAUSE_SCHEDULE
);
33471 OMP_CLAUSE_SCHEDULE_KIND (clauses
) = OMP_CLAUSE_SCHEDULE_CILKFOR
;
33472 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clauses
) = grain
;
33473 clauses
= finish_omp_clauses (clauses
);
33475 tree ret
= cp_parser_omp_for_loop (parser
, CILK_FOR
, clauses
, NULL
);
33477 cpp_validate_cilk_plus_loop (ret
);
33479 ret
= error_mark_node
;
33481 cp_parser_end_omp_structured_block (parser
, save
);
33482 add_stmt (finish_omp_structured_block (sb
));
33486 /* Create an identifier for a generic parameter type (a synthesized
33487 template parameter implied by `auto' or a concept identifier). */
33489 static GTY(()) int generic_parm_count
;
33491 make_generic_type_name ()
33494 sprintf (buf
, "auto:%d", ++generic_parm_count
);
33495 return get_identifier (buf
);
33498 /* Predicate that behaves as is_auto_or_concept but matches the parent
33499 node of the generic type rather than the generic type itself. This
33500 allows for type transformation in add_implicit_template_parms. */
33503 tree_type_is_auto_or_concept (const_tree t
)
33505 return TREE_TYPE (t
) && is_auto_or_concept (TREE_TYPE (t
));
33508 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
33509 (creating a new template parameter list if necessary). Returns the newly
33510 created template type parm. */
33513 synthesize_implicit_template_parm (cp_parser
*parser
)
33515 gcc_assert (current_binding_level
->kind
== sk_function_parms
);
33517 /* We are either continuing a function template that already contains implicit
33518 template parameters, creating a new fully-implicit function template, or
33519 extending an existing explicit function template with implicit template
33522 cp_binding_level
*const entry_scope
= current_binding_level
;
33524 bool become_template
= false;
33525 cp_binding_level
*parent_scope
= 0;
33527 if (parser
->implicit_template_scope
)
33529 gcc_assert (parser
->implicit_template_parms
);
33531 current_binding_level
= parser
->implicit_template_scope
;
33535 /* Roll back to the existing template parameter scope (in the case of
33536 extending an explicit function template) or introduce a new template
33537 parameter scope ahead of the function parameter scope (or class scope
33538 in the case of out-of-line member definitions). The function scope is
33539 added back after template parameter synthesis below. */
33541 cp_binding_level
*scope
= entry_scope
;
33543 while (scope
->kind
== sk_function_parms
)
33545 parent_scope
= scope
;
33546 scope
= scope
->level_chain
;
33548 if (current_class_type
&& !LAMBDA_TYPE_P (current_class_type
))
33550 /* If not defining a class, then any class scope is a scope level in
33551 an out-of-line member definition. In this case simply wind back
33552 beyond the first such scope to inject the template parameter list.
33553 Otherwise wind back to the class being defined. The latter can
33554 occur in class member friend declarations such as:
33560 friend void A::foo (auto);
33563 The template parameter list synthesized for the friend declaration
33564 must be injected in the scope of 'B'. This can also occur in
33565 erroneous cases such as:
33571 void B::foo (auto) {}
33574 Here the attempted definition of 'B::foo' within 'A' is ill-formed
33575 but, nevertheless, the template parameter list synthesized for the
33576 declarator should be injected into the scope of 'A' as if the
33577 ill-formed template was specified explicitly. */
33579 while (scope
->kind
== sk_class
&& !scope
->defining_class_p
)
33581 parent_scope
= scope
;
33582 scope
= scope
->level_chain
;
33586 current_binding_level
= scope
;
33588 if (scope
->kind
!= sk_template_parms
33589 || !function_being_declared_is_template_p (parser
))
33591 /* Introduce a new template parameter list for implicit template
33594 become_template
= true;
33596 parser
->implicit_template_scope
33597 = begin_scope (sk_template_parms
, NULL
);
33599 ++processing_template_decl
;
33601 parser
->fully_implicit_function_template_p
= true;
33602 ++parser
->num_template_parameter_lists
;
33606 /* Synthesize implicit template parameters at the end of the explicit
33607 template parameter list. */
33609 gcc_assert (current_template_parms
);
33611 parser
->implicit_template_scope
= scope
;
33613 tree v
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
33614 parser
->implicit_template_parms
33615 = TREE_VEC_ELT (v
, TREE_VEC_LENGTH (v
) - 1);
33619 /* Synthesize a new template parameter and track the current template
33620 parameter chain with implicit_template_parms. */
33622 tree synth_id
= make_generic_type_name ();
33623 tree synth_tmpl_parm
= finish_template_type_parm (class_type_node
,
33626 = process_template_parm (parser
->implicit_template_parms
,
33628 build_tree_list (NULL_TREE
, synth_tmpl_parm
),
33629 /*non_type=*/false,
33630 /*param_pack=*/false);
33633 if (parser
->implicit_template_parms
)
33634 parser
->implicit_template_parms
33635 = TREE_CHAIN (parser
->implicit_template_parms
);
33637 parser
->implicit_template_parms
= new_parm
;
33639 tree new_type
= TREE_TYPE (getdecls ());
33641 /* If creating a fully implicit function template, start the new implicit
33642 template parameter list with this synthesized type, otherwise grow the
33643 current template parameter list. */
33645 if (become_template
)
33647 parent_scope
->level_chain
= current_binding_level
;
33649 tree new_parms
= make_tree_vec (1);
33650 TREE_VEC_ELT (new_parms
, 0) = parser
->implicit_template_parms
;
33651 current_template_parms
= tree_cons (size_int (processing_template_decl
),
33652 new_parms
, current_template_parms
);
33656 tree
& new_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
33657 int new_parm_idx
= TREE_VEC_LENGTH (new_parms
);
33658 new_parms
= grow_tree_vec (new_parms
, new_parm_idx
+ 1);
33659 TREE_VEC_ELT (new_parms
, new_parm_idx
) = parser
->implicit_template_parms
;
33662 current_binding_level
= entry_scope
;
33667 /* Finish the declaration of a fully implicit function template. Such a
33668 template has no explicit template parameter list so has not been through the
33669 normal template head and tail processing. synthesize_implicit_template_parm
33670 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
33671 provided if the declaration is a class member such that its template
33672 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
33673 form is returned. Otherwise NULL_TREE is returned. */
33676 finish_fully_implicit_template (cp_parser
*parser
, tree member_decl_opt
)
33678 gcc_assert (parser
->fully_implicit_function_template_p
);
33680 if (member_decl_opt
&& member_decl_opt
!= error_mark_node
33681 && DECL_VIRTUAL_P (member_decl_opt
))
33683 error_at (DECL_SOURCE_LOCATION (member_decl_opt
),
33684 "implicit templates may not be %<virtual%>");
33685 DECL_VIRTUAL_P (member_decl_opt
) = false;
33688 if (member_decl_opt
)
33689 member_decl_opt
= finish_member_template_decl (member_decl_opt
);
33690 end_template_decl ();
33692 parser
->fully_implicit_function_template_p
= false;
33693 --parser
->num_template_parameter_lists
;
33695 return member_decl_opt
;
33698 #include "gt-cp-parser.h"