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);
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 (TREE_CODE (decl
) == TEMPLATE_DECL
)
2962 "invalid use of template-name %qE without an argument list",
2964 else if (TREE_CODE (id
) == BIT_NOT_EXPR
)
2965 error_at (location
, "invalid use of destructor %qD as a type", id
);
2966 else if (TREE_CODE (decl
) == TYPE_DECL
)
2967 /* Something like 'unsigned A a;' */
2968 error_at (location
, "invalid combination of multiple type-specifiers");
2969 else if (!parser
->scope
)
2971 /* Issue an error message. */
2972 error_at (location
, "%qE does not name a type", id
);
2973 /* If we're in a template class, it's possible that the user was
2974 referring to a type from a base class. For example:
2976 template <typename T> struct A { typedef T X; };
2977 template <typename T> struct B : public A<T> { X x; };
2979 The user should have said "typename A<T>::X". */
2980 if (cxx_dialect
< cxx11
&& id
== ridpointers
[(int)RID_CONSTEXPR
])
2981 inform (location
, "C++11 %<constexpr%> only available with "
2982 "-std=c++11 or -std=gnu++11");
2983 else if (cxx_dialect
< cxx11
&& id
== ridpointers
[(int)RID_NOEXCEPT
])
2984 inform (location
, "C++11 %<noexcept%> only available with "
2985 "-std=c++11 or -std=gnu++11");
2986 else if (cxx_dialect
< cxx11
2987 && TREE_CODE (id
) == IDENTIFIER_NODE
2988 && !strcmp (IDENTIFIER_POINTER (id
), "thread_local"))
2989 inform (location
, "C++11 %<thread_local%> only available with "
2990 "-std=c++11 or -std=gnu++11");
2991 else if (processing_template_decl
&& current_class_type
2992 && TYPE_BINFO (current_class_type
))
2996 for (b
= TREE_CHAIN (TYPE_BINFO (current_class_type
));
3000 tree base_type
= BINFO_TYPE (b
);
3001 if (CLASS_TYPE_P (base_type
)
3002 && dependent_type_p (base_type
))
3005 /* Go from a particular instantiation of the
3006 template (which will have an empty TYPE_FIELDs),
3007 to the main version. */
3008 base_type
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type
);
3009 for (field
= TYPE_FIELDS (base_type
);
3011 field
= DECL_CHAIN (field
))
3012 if (TREE_CODE (field
) == TYPE_DECL
3013 && DECL_NAME (field
) == id
)
3016 "(perhaps %<typename %T::%E%> was intended)",
3017 BINFO_TYPE (b
), id
);
3026 /* Here we diagnose qualified-ids where the scope is actually correct,
3027 but the identifier does not resolve to a valid type name. */
3028 else if (parser
->scope
!= error_mark_node
)
3030 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
3032 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
3033 error_at (location_of (id
),
3034 "%qE in namespace %qE does not name a template type",
3037 error_at (location_of (id
),
3038 "%qE in namespace %qE does not name a type",
3041 else if (CLASS_TYPE_P (parser
->scope
)
3042 && constructor_name_p (id
, parser
->scope
))
3045 error_at (location
, "%<%T::%E%> names the constructor, not"
3046 " the type", parser
->scope
, id
);
3047 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
3048 error_at (location
, "and %qT has no template constructors",
3051 else if (TYPE_P (parser
->scope
)
3052 && dependent_scope_p (parser
->scope
))
3053 error_at (location
, "need %<typename%> before %<%T::%E%> because "
3054 "%qT is a dependent scope",
3055 parser
->scope
, id
, parser
->scope
);
3056 else if (TYPE_P (parser
->scope
))
3058 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
3059 error_at (location_of (id
),
3060 "%qE in %q#T does not name a template type",
3063 error_at (location_of (id
),
3064 "%qE in %q#T does not name a type",
3072 /* Check for a common situation where a type-name should be present,
3073 but is not, and issue a sensible error message. Returns true if an
3074 invalid type-name was detected.
3076 The situation handled by this function are variable declarations of the
3077 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3078 Usually, `ID' should name a type, but if we got here it means that it
3079 does not. We try to emit the best possible error message depending on
3080 how exactly the id-expression looks like. */
3083 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser
*parser
)
3086 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3088 /* Avoid duplicate error about ambiguous lookup. */
3089 if (token
->type
== CPP_NESTED_NAME_SPECIFIER
)
3091 cp_token
*next
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
3092 if (next
->type
== CPP_NAME
&& next
->error_reported
)
3096 cp_parser_parse_tentatively (parser
);
3097 id
= cp_parser_id_expression (parser
,
3098 /*template_keyword_p=*/false,
3099 /*check_dependency_p=*/true,
3100 /*template_p=*/NULL
,
3101 /*declarator_p=*/true,
3102 /*optional_p=*/false);
3103 /* If the next token is a (, this is a function with no explicit return
3104 type, i.e. constructor, destructor or conversion op. */
3105 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
3106 || TREE_CODE (id
) == TYPE_DECL
)
3108 cp_parser_abort_tentative_parse (parser
);
3111 if (!cp_parser_parse_definitely (parser
))
3114 /* Emit a diagnostic for the invalid type. */
3115 cp_parser_diagnose_invalid_type_name (parser
, id
, token
->location
);
3117 /* If we aren't in the middle of a declarator (i.e. in a
3118 parameter-declaration-clause), skip to the end of the declaration;
3119 there's no point in trying to process it. */
3120 if (!parser
->in_declarator_p
)
3121 cp_parser_skip_to_end_of_block_or_statement (parser
);
3125 /* Consume tokens up to, and including, the next non-nested closing `)'.
3126 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3127 are doing error recovery. Returns -1 if OR_COMMA is true and we
3128 found an unnested comma. */
3131 cp_parser_skip_to_closing_parenthesis (cp_parser
*parser
,
3136 unsigned paren_depth
= 0;
3137 unsigned brace_depth
= 0;
3138 unsigned square_depth
= 0;
3140 if (recovering
&& !or_comma
3141 && cp_parser_uncommitted_to_tentative_parse_p (parser
))
3146 cp_token
* token
= cp_lexer_peek_token (parser
->lexer
);
3148 switch (token
->type
)
3151 case CPP_PRAGMA_EOL
:
3152 /* If we've run out of tokens, then there is no closing `)'. */
3155 /* This is good for lambda expression capture-lists. */
3156 case CPP_OPEN_SQUARE
:
3159 case CPP_CLOSE_SQUARE
:
3160 if (!square_depth
--)
3165 /* This matches the processing in skip_to_end_of_statement. */
3170 case CPP_OPEN_BRACE
:
3173 case CPP_CLOSE_BRACE
:
3179 if (recovering
&& or_comma
&& !brace_depth
&& !paren_depth
3184 case CPP_OPEN_PAREN
:
3189 case CPP_CLOSE_PAREN
:
3190 if (!brace_depth
&& !paren_depth
--)
3193 cp_lexer_consume_token (parser
->lexer
);
3202 /* Consume the token. */
3203 cp_lexer_consume_token (parser
->lexer
);
3207 /* Consume tokens until we reach the end of the current statement.
3208 Normally, that will be just before consuming a `;'. However, if a
3209 non-nested `}' comes first, then we stop before consuming that. */
3212 cp_parser_skip_to_end_of_statement (cp_parser
* parser
)
3214 unsigned nesting_depth
= 0;
3216 /* Unwind generic function template scope if necessary. */
3217 if (parser
->fully_implicit_function_template_p
)
3218 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
3222 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3224 switch (token
->type
)
3227 case CPP_PRAGMA_EOL
:
3228 /* If we've run out of tokens, stop. */
3232 /* If the next token is a `;', we have reached the end of the
3238 case CPP_CLOSE_BRACE
:
3239 /* If this is a non-nested '}', stop before consuming it.
3240 That way, when confronted with something like:
3244 we stop before consuming the closing '}', even though we
3245 have not yet reached a `;'. */
3246 if (nesting_depth
== 0)
3249 /* If it is the closing '}' for a block that we have
3250 scanned, stop -- but only after consuming the token.
3256 we will stop after the body of the erroneously declared
3257 function, but before consuming the following `typedef'
3259 if (--nesting_depth
== 0)
3261 cp_lexer_consume_token (parser
->lexer
);
3265 case CPP_OPEN_BRACE
:
3273 /* Consume the token. */
3274 cp_lexer_consume_token (parser
->lexer
);
3278 /* This function is called at the end of a statement or declaration.
3279 If the next token is a semicolon, it is consumed; otherwise, error
3280 recovery is attempted. */
3283 cp_parser_consume_semicolon_at_end_of_statement (cp_parser
*parser
)
3285 /* Look for the trailing `;'. */
3286 if (!cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
))
3288 /* If there is additional (erroneous) input, skip to the end of
3290 cp_parser_skip_to_end_of_statement (parser
);
3291 /* If the next token is now a `;', consume it. */
3292 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
3293 cp_lexer_consume_token (parser
->lexer
);
3297 /* Skip tokens until we have consumed an entire block, or until we
3298 have consumed a non-nested `;'. */
3301 cp_parser_skip_to_end_of_block_or_statement (cp_parser
* parser
)
3303 int nesting_depth
= 0;
3305 /* Unwind generic function template scope if necessary. */
3306 if (parser
->fully_implicit_function_template_p
)
3307 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
3309 while (nesting_depth
>= 0)
3311 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3313 switch (token
->type
)
3316 case CPP_PRAGMA_EOL
:
3317 /* If we've run out of tokens, stop. */
3321 /* Stop if this is an unnested ';'. */
3326 case CPP_CLOSE_BRACE
:
3327 /* Stop if this is an unnested '}', or closes the outermost
3330 if (nesting_depth
< 0)
3336 case CPP_OPEN_BRACE
:
3345 /* Consume the token. */
3346 cp_lexer_consume_token (parser
->lexer
);
3350 /* Skip tokens until a non-nested closing curly brace is the next
3351 token, or there are no more tokens. Return true in the first case,
3355 cp_parser_skip_to_closing_brace (cp_parser
*parser
)
3357 unsigned nesting_depth
= 0;
3361 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
3363 switch (token
->type
)
3366 case CPP_PRAGMA_EOL
:
3367 /* If we've run out of tokens, stop. */
3370 case CPP_CLOSE_BRACE
:
3371 /* If the next token is a non-nested `}', then we have reached
3372 the end of the current block. */
3373 if (nesting_depth
-- == 0)
3377 case CPP_OPEN_BRACE
:
3378 /* If it the next token is a `{', then we are entering a new
3379 block. Consume the entire block. */
3387 /* Consume the token. */
3388 cp_lexer_consume_token (parser
->lexer
);
3392 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3393 parameter is the PRAGMA token, allowing us to purge the entire pragma
3397 cp_parser_skip_to_pragma_eol (cp_parser
* parser
, cp_token
*pragma_tok
)
3401 parser
->lexer
->in_pragma
= false;
3404 token
= cp_lexer_consume_token (parser
->lexer
);
3405 while (token
->type
!= CPP_PRAGMA_EOL
&& token
->type
!= CPP_EOF
);
3407 /* Ensure that the pragma is not parsed again. */
3408 cp_lexer_purge_tokens_after (parser
->lexer
, pragma_tok
);
3411 /* Require pragma end of line, resyncing with it as necessary. The
3412 arguments are as for cp_parser_skip_to_pragma_eol. */
3415 cp_parser_require_pragma_eol (cp_parser
*parser
, cp_token
*pragma_tok
)
3417 parser
->lexer
->in_pragma
= false;
3418 if (!cp_parser_require (parser
, CPP_PRAGMA_EOL
, RT_PRAGMA_EOL
))
3419 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
3422 /* This is a simple wrapper around make_typename_type. When the id is
3423 an unresolved identifier node, we can provide a superior diagnostic
3424 using cp_parser_diagnose_invalid_type_name. */
3427 cp_parser_make_typename_type (cp_parser
*parser
, tree id
,
3428 location_t id_location
)
3431 if (identifier_p (id
))
3433 result
= make_typename_type (parser
->scope
, id
, typename_type
,
3434 /*complain=*/tf_none
);
3435 if (result
== error_mark_node
)
3436 cp_parser_diagnose_invalid_type_name (parser
, id
, id_location
);
3439 return make_typename_type (parser
->scope
, id
, typename_type
, tf_error
);
3442 /* This is a wrapper around the
3443 make_{pointer,ptrmem,reference}_declarator functions that decides
3444 which one to call based on the CODE and CLASS_TYPE arguments. The
3445 CODE argument should be one of the values returned by
3446 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3447 appertain to the pointer or reference. */
3449 static cp_declarator
*
3450 cp_parser_make_indirect_declarator (enum tree_code code
, tree class_type
,
3451 cp_cv_quals cv_qualifiers
,
3452 cp_declarator
*target
,
3455 if (code
== ERROR_MARK
)
3456 return cp_error_declarator
;
3458 if (code
== INDIRECT_REF
)
3459 if (class_type
== NULL_TREE
)
3460 return make_pointer_declarator (cv_qualifiers
, target
, attributes
);
3462 return make_ptrmem_declarator (cv_qualifiers
, class_type
,
3463 target
, attributes
);
3464 else if (code
== ADDR_EXPR
&& class_type
== NULL_TREE
)
3465 return make_reference_declarator (cv_qualifiers
, target
,
3467 else if (code
== NON_LVALUE_EXPR
&& class_type
== NULL_TREE
)
3468 return make_reference_declarator (cv_qualifiers
, target
,
3473 /* Create a new C++ parser. */
3476 cp_parser_new (void)
3482 /* cp_lexer_new_main is called before doing GC allocation because
3483 cp_lexer_new_main might load a PCH file. */
3484 lexer
= cp_lexer_new_main ();
3486 /* Initialize the binops_by_token so that we can get the tree
3487 directly from the token. */
3488 for (i
= 0; i
< sizeof (binops
) / sizeof (binops
[0]); i
++)
3489 binops_by_token
[binops
[i
].token_type
] = binops
[i
];
3491 parser
= ggc_cleared_alloc
<cp_parser
> ();
3492 parser
->lexer
= lexer
;
3493 parser
->context
= cp_parser_context_new (NULL
);
3495 /* For now, we always accept GNU extensions. */
3496 parser
->allow_gnu_extensions_p
= 1;
3498 /* The `>' token is a greater-than operator, not the end of a
3500 parser
->greater_than_is_operator_p
= true;
3502 parser
->default_arg_ok_p
= true;
3504 /* We are not parsing a constant-expression. */
3505 parser
->integral_constant_expression_p
= false;
3506 parser
->allow_non_integral_constant_expression_p
= false;
3507 parser
->non_integral_constant_expression_p
= false;
3509 /* Local variable names are not forbidden. */
3510 parser
->local_variables_forbidden_p
= false;
3512 /* We are not processing an `extern "C"' declaration. */
3513 parser
->in_unbraced_linkage_specification_p
= false;
3515 /* We are not processing a declarator. */
3516 parser
->in_declarator_p
= false;
3518 /* We are not processing a template-argument-list. */
3519 parser
->in_template_argument_list_p
= false;
3521 /* We are not in an iteration statement. */
3522 parser
->in_statement
= 0;
3524 /* We are not in a switch statement. */
3525 parser
->in_switch_statement_p
= false;
3527 /* We are not parsing a type-id inside an expression. */
3528 parser
->in_type_id_in_expr_p
= false;
3530 /* Declarations aren't implicitly extern "C". */
3531 parser
->implicit_extern_c
= false;
3533 /* String literals should be translated to the execution character set. */
3534 parser
->translate_strings_p
= true;
3536 /* We are not parsing a function body. */
3537 parser
->in_function_body
= false;
3539 /* We can correct until told otherwise. */
3540 parser
->colon_corrects_to_scope_p
= true;
3542 /* The unparsed function queue is empty. */
3543 push_unparsed_function_queues (parser
);
3545 /* There are no classes being defined. */
3546 parser
->num_classes_being_defined
= 0;
3548 /* No template parameters apply. */
3549 parser
->num_template_parameter_lists
= 0;
3551 /* Not declaring an implicit function template. */
3552 parser
->auto_is_implicit_function_template_parm_p
= false;
3553 parser
->fully_implicit_function_template_p
= false;
3554 parser
->implicit_template_parms
= 0;
3555 parser
->implicit_template_scope
= 0;
3560 /* Create a cp_lexer structure which will emit the tokens in CACHE
3561 and push it onto the parser's lexer stack. This is used for delayed
3562 parsing of in-class method bodies and default arguments, and should
3563 not be confused with tentative parsing. */
3565 cp_parser_push_lexer_for_tokens (cp_parser
*parser
, cp_token_cache
*cache
)
3567 cp_lexer
*lexer
= cp_lexer_new_from_tokens (cache
);
3568 lexer
->next
= parser
->lexer
;
3569 parser
->lexer
= lexer
;
3571 /* Move the current source position to that of the first token in the
3573 cp_lexer_set_source_position_from_token (lexer
->next_token
);
3576 /* Pop the top lexer off the parser stack. This is never used for the
3577 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3579 cp_parser_pop_lexer (cp_parser
*parser
)
3581 cp_lexer
*lexer
= parser
->lexer
;
3582 parser
->lexer
= lexer
->next
;
3583 cp_lexer_destroy (lexer
);
3585 /* Put the current source position back where it was before this
3586 lexer was pushed. */
3587 cp_lexer_set_source_position_from_token (parser
->lexer
->next_token
);
3590 /* Lexical conventions [gram.lex] */
3592 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3596 cp_parser_identifier (cp_parser
* parser
)
3600 /* Look for the identifier. */
3601 token
= cp_parser_require (parser
, CPP_NAME
, RT_NAME
);
3602 /* Return the value. */
3603 return token
? token
->u
.value
: error_mark_node
;
3606 /* Parse a sequence of adjacent string constants. Returns a
3607 TREE_STRING representing the combined, nul-terminated string
3608 constant. If TRANSLATE is true, translate the string to the
3609 execution character set. If WIDE_OK is true, a wide string is
3612 C++98 [lex.string] says that if a narrow string literal token is
3613 adjacent to a wide string literal token, the behavior is undefined.
3614 However, C99 6.4.5p4 says that this results in a wide string literal.
3615 We follow C99 here, for consistency with the C front end.
3617 This code is largely lifted from lex_string() in c-lex.c.
3619 FUTURE: ObjC++ will need to handle @-strings here. */
3621 cp_parser_string_literal (cp_parser
*parser
, bool translate
, bool wide_ok
,
3622 bool lookup_udlit
= true)
3626 struct obstack str_ob
;
3627 cpp_string str
, istr
, *strs
;
3629 enum cpp_ttype type
, curr_type
;
3630 int have_suffix_p
= 0;
3632 tree suffix_id
= NULL_TREE
;
3633 bool curr_tok_is_userdef_p
= false;
3635 tok
= cp_lexer_peek_token (parser
->lexer
);
3636 if (!cp_parser_is_string_literal (tok
))
3638 cp_parser_error (parser
, "expected string-literal");
3639 return error_mark_node
;
3642 if (cpp_userdef_string_p (tok
->type
))
3644 string_tree
= USERDEF_LITERAL_VALUE (tok
->u
.value
);
3645 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3646 curr_tok_is_userdef_p
= true;
3650 string_tree
= tok
->u
.value
;
3651 curr_type
= tok
->type
;
3655 /* Try to avoid the overhead of creating and destroying an obstack
3656 for the common case of just one string. */
3657 if (!cp_parser_is_string_literal
3658 (cp_lexer_peek_nth_token (parser
->lexer
, 2)))
3660 cp_lexer_consume_token (parser
->lexer
);
3662 str
.text
= (const unsigned char *)TREE_STRING_POINTER (string_tree
);
3663 str
.len
= TREE_STRING_LENGTH (string_tree
);
3666 if (curr_tok_is_userdef_p
)
3668 suffix_id
= USERDEF_LITERAL_SUFFIX_ID (tok
->u
.value
);
3670 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3673 curr_type
= tok
->type
;
3679 gcc_obstack_init (&str_ob
);
3684 cp_lexer_consume_token (parser
->lexer
);
3686 str
.text
= (const unsigned char *)TREE_STRING_POINTER (string_tree
);
3687 str
.len
= TREE_STRING_LENGTH (string_tree
);
3689 if (curr_tok_is_userdef_p
)
3691 tree curr_suffix_id
= USERDEF_LITERAL_SUFFIX_ID (tok
->u
.value
);
3692 if (have_suffix_p
== 0)
3694 suffix_id
= curr_suffix_id
;
3697 else if (have_suffix_p
== 1
3698 && curr_suffix_id
!= suffix_id
)
3700 error ("inconsistent user-defined literal suffixes"
3701 " %qD and %qD in string literal",
3702 suffix_id
, curr_suffix_id
);
3705 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3708 curr_type
= tok
->type
;
3710 if (type
!= curr_type
)
3712 if (type
== CPP_STRING
)
3714 else if (curr_type
!= CPP_STRING
)
3715 error_at (tok
->location
,
3716 "unsupported non-standard concatenation "
3717 "of string literals");
3720 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
3722 tok
= cp_lexer_peek_token (parser
->lexer
);
3723 if (cpp_userdef_string_p (tok
->type
))
3725 string_tree
= USERDEF_LITERAL_VALUE (tok
->u
.value
);
3726 curr_type
= cpp_userdef_string_remove_type (tok
->type
);
3727 curr_tok_is_userdef_p
= true;
3731 string_tree
= tok
->u
.value
;
3732 curr_type
= tok
->type
;
3733 curr_tok_is_userdef_p
= false;
3736 while (cp_parser_is_string_literal (tok
));
3738 strs
= (cpp_string
*) obstack_finish (&str_ob
);
3741 if (type
!= CPP_STRING
&& !wide_ok
)
3743 cp_parser_error (parser
, "a wide string is invalid in this context");
3747 if ((translate
? cpp_interpret_string
: cpp_interpret_string_notranslate
)
3748 (parse_in
, strs
, count
, &istr
, type
))
3750 value
= build_string (istr
.len
, (const char *)istr
.text
);
3751 free (CONST_CAST (unsigned char *, istr
.text
));
3757 case CPP_UTF8STRING
:
3758 TREE_TYPE (value
) = char_array_type_node
;
3761 TREE_TYPE (value
) = char16_array_type_node
;
3764 TREE_TYPE (value
) = char32_array_type_node
;
3767 TREE_TYPE (value
) = wchar_array_type_node
;
3771 value
= fix_string_type (value
);
3775 tree literal
= build_userdef_literal (suffix_id
, value
,
3776 OT_NONE
, NULL_TREE
);
3778 value
= cp_parser_userdef_string_literal (literal
);
3784 /* cpp_interpret_string has issued an error. */
3785 value
= error_mark_node
;
3788 obstack_free (&str_ob
, 0);
3793 /* Look up a literal operator with the name and the exact arguments. */
3796 lookup_literal_operator (tree name
, vec
<tree
, va_gc
> *args
)
3799 decl
= lookup_name (name
);
3800 if (!decl
|| !is_overloaded_fn (decl
))
3801 return error_mark_node
;
3803 for (fns
= decl
; fns
; fns
= OVL_NEXT (fns
))
3807 tree fn
= OVL_CURRENT (fns
);
3808 tree parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
3809 if (parmtypes
!= NULL_TREE
)
3811 for (ix
= 0; ix
< vec_safe_length (args
) && parmtypes
!= NULL_TREE
;
3812 ++ix
, parmtypes
= TREE_CHAIN (parmtypes
))
3814 tree tparm
= TREE_VALUE (parmtypes
);
3815 tree targ
= TREE_TYPE ((*args
)[ix
]);
3816 bool ptr
= TYPE_PTR_P (tparm
);
3817 bool arr
= TREE_CODE (targ
) == ARRAY_TYPE
;
3818 if ((ptr
|| arr
|| !same_type_p (tparm
, targ
))
3820 || !same_type_p (TREE_TYPE (tparm
),
3825 && ix
== vec_safe_length (args
)
3826 /* May be this should be sufficient_parms_p instead,
3827 depending on how exactly should user-defined literals
3828 work in presence of default arguments on the literal
3829 operator parameters. */
3830 && parmtypes
== void_list_node
)
3835 return error_mark_node
;
3838 /* Parse a user-defined char constant. Returns a call to a user-defined
3839 literal operator taking the character as an argument. */
3842 cp_parser_userdef_char_literal (cp_parser
*parser
)
3844 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
3845 tree literal
= token
->u
.value
;
3846 tree suffix_id
= USERDEF_LITERAL_SUFFIX_ID (literal
);
3847 tree value
= USERDEF_LITERAL_VALUE (literal
);
3848 tree name
= cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id
));
3851 /* Build up a call to the user-defined operator */
3852 /* Lookup the name we got back from the id-expression. */
3853 vec
<tree
, va_gc
> *args
= make_tree_vector ();
3854 vec_safe_push (args
, value
);
3855 decl
= lookup_literal_operator (name
, args
);
3856 if (!decl
|| decl
== error_mark_node
)
3858 error ("unable to find character literal operator %qD with %qT argument",
3859 name
, TREE_TYPE (value
));
3860 release_tree_vector (args
);
3861 return error_mark_node
;
3863 result
= finish_call_expr (decl
, &args
, false, true, tf_warning_or_error
);
3864 release_tree_vector (args
);
3868 /* A subroutine of cp_parser_userdef_numeric_literal to
3869 create a char... template parameter pack from a string node. */
3872 make_char_string_pack (tree value
)
3875 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
3876 const char *str
= TREE_STRING_POINTER (value
);
3877 int i
, len
= TREE_STRING_LENGTH (value
) - 1;
3878 tree argvec
= make_tree_vec (1);
3880 /* Fill in CHARVEC with all of the parameters. */
3881 charvec
= make_tree_vec (len
);
3882 for (i
= 0; i
< len
; ++i
)
3883 TREE_VEC_ELT (charvec
, i
) = build_int_cst (char_type_node
, str
[i
]);
3885 /* Build the argument packs. */
3886 SET_ARGUMENT_PACK_ARGS (argpack
, charvec
);
3887 TREE_TYPE (argpack
) = char_type_node
;
3889 TREE_VEC_ELT (argvec
, 0) = argpack
;
3894 /* A subroutine of cp_parser_userdef_numeric_literal to
3895 create a char... template parameter pack from a string node. */
3898 make_string_pack (tree value
)
3901 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
3902 const unsigned char *str
3903 = (const unsigned char *) TREE_STRING_POINTER (value
);
3904 int sz
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value
))));
3905 int len
= TREE_STRING_LENGTH (value
) / sz
- 1;
3906 tree argvec
= make_tree_vec (2);
3908 tree str_char_type_node
= TREE_TYPE (TREE_TYPE (value
));
3909 str_char_type_node
= TYPE_MAIN_VARIANT (str_char_type_node
);
3911 /* First template parm is character type. */
3912 TREE_VEC_ELT (argvec
, 0) = str_char_type_node
;
3914 /* Fill in CHARVEC with all of the parameters. */
3915 charvec
= make_tree_vec (len
);
3916 for (int i
= 0; i
< len
; ++i
)
3917 TREE_VEC_ELT (charvec
, i
)
3918 = double_int_to_tree (str_char_type_node
,
3919 double_int::from_buffer (str
+ i
* sz
, sz
));
3921 /* Build the argument packs. */
3922 SET_ARGUMENT_PACK_ARGS (argpack
, charvec
);
3923 TREE_TYPE (argpack
) = str_char_type_node
;
3925 TREE_VEC_ELT (argvec
, 1) = argpack
;
3930 /* Parse a user-defined numeric constant. returns a call to a user-defined
3931 literal operator. */
3934 cp_parser_userdef_numeric_literal (cp_parser
*parser
)
3936 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
3937 tree literal
= token
->u
.value
;
3938 tree suffix_id
= USERDEF_LITERAL_SUFFIX_ID (literal
);
3939 tree value
= USERDEF_LITERAL_VALUE (literal
);
3940 int overflow
= USERDEF_LITERAL_OVERFLOW (literal
);
3941 tree num_string
= USERDEF_LITERAL_NUM_STRING (literal
);
3942 tree name
= cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id
));
3944 vec
<tree
, va_gc
> *args
;
3946 /* Look for a literal operator taking the exact type of numeric argument
3947 as the literal value. */
3948 args
= make_tree_vector ();
3949 vec_safe_push (args
, value
);
3950 decl
= lookup_literal_operator (name
, args
);
3951 if (decl
&& decl
!= error_mark_node
)
3953 result
= finish_call_expr (decl
, &args
, false, true,
3954 tf_warning_or_error
);
3956 if (TREE_CODE (TREE_TYPE (value
)) == INTEGER_TYPE
&& overflow
> 0)
3958 warning_at (token
->location
, OPT_Woverflow
,
3959 "integer literal exceeds range of %qT type",
3960 long_long_unsigned_type_node
);
3965 warning_at (token
->location
, OPT_Woverflow
,
3966 "floating literal exceeds range of %qT type",
3967 long_double_type_node
);
3968 else if (overflow
< 0)
3969 warning_at (token
->location
, OPT_Woverflow
,
3970 "floating literal truncated to zero");
3973 release_tree_vector (args
);
3976 release_tree_vector (args
);
3978 /* If the numeric argument didn't work, look for a raw literal
3979 operator taking a const char* argument consisting of the number
3980 in string format. */
3981 args
= make_tree_vector ();
3982 vec_safe_push (args
, num_string
);
3983 decl
= lookup_literal_operator (name
, args
);
3984 if (decl
&& decl
!= error_mark_node
)
3986 result
= finish_call_expr (decl
, &args
, false, true,
3987 tf_warning_or_error
);
3988 release_tree_vector (args
);
3991 release_tree_vector (args
);
3993 /* If the raw literal didn't work, look for a non-type template
3994 function with parameter pack char.... Call the function with
3995 template parameter characters representing the number. */
3996 args
= make_tree_vector ();
3997 decl
= lookup_literal_operator (name
, args
);
3998 if (decl
&& decl
!= error_mark_node
)
4000 tree tmpl_args
= make_char_string_pack (num_string
);
4001 decl
= lookup_template_function (decl
, tmpl_args
);
4002 result
= finish_call_expr (decl
, &args
, false, true,
4003 tf_warning_or_error
);
4004 release_tree_vector (args
);
4008 release_tree_vector (args
);
4010 error ("unable to find numeric literal operator %qD", name
);
4011 if (!cpp_get_options (parse_in
)->ext_numeric_literals
)
4012 inform (token
->location
, "use -std=gnu++11 or -fext-numeric-literals "
4013 "to enable more built-in suffixes");
4014 return error_mark_node
;
4017 /* Parse a user-defined string constant. Returns a call to a user-defined
4018 literal operator taking a character pointer and the length of the string
4022 cp_parser_userdef_string_literal (tree literal
)
4024 tree suffix_id
= USERDEF_LITERAL_SUFFIX_ID (literal
);
4025 tree name
= cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id
));
4026 tree value
= USERDEF_LITERAL_VALUE (literal
);
4027 int len
= TREE_STRING_LENGTH (value
)
4028 / TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value
)))) - 1;
4030 vec
<tree
, va_gc
> *args
;
4032 /* Build up a call to the user-defined operator. */
4033 /* Lookup the name we got back from the id-expression. */
4034 args
= make_tree_vector ();
4035 vec_safe_push (args
, value
);
4036 vec_safe_push (args
, build_int_cst (size_type_node
, len
));
4037 decl
= lookup_literal_operator (name
, args
);
4039 if (decl
&& decl
!= error_mark_node
)
4041 result
= finish_call_expr (decl
, &args
, false, true,
4042 tf_warning_or_error
);
4043 release_tree_vector (args
);
4046 release_tree_vector (args
);
4048 /* Look for a template function with typename parameter CharT
4049 and parameter pack CharT... Call the function with
4050 template parameter characters representing the string. */
4051 args
= make_tree_vector ();
4052 decl
= lookup_literal_operator (name
, args
);
4053 if (decl
&& decl
!= error_mark_node
)
4055 tree tmpl_args
= make_string_pack (value
);
4056 decl
= lookup_template_function (decl
, tmpl_args
);
4057 result
= finish_call_expr (decl
, &args
, false, true,
4058 tf_warning_or_error
);
4059 release_tree_vector (args
);
4062 release_tree_vector (args
);
4064 error ("unable to find string literal operator %qD with %qT, %qT arguments",
4065 name
, TREE_TYPE (value
), size_type_node
);
4066 return error_mark_node
;
4070 /* Basic concepts [gram.basic] */
4072 /* Parse a translation-unit.
4075 declaration-seq [opt]
4077 Returns TRUE if all went well. */
4080 cp_parser_translation_unit (cp_parser
* parser
)
4082 /* The address of the first non-permanent object on the declarator
4084 static void *declarator_obstack_base
;
4088 /* Create the declarator obstack, if necessary. */
4089 if (!cp_error_declarator
)
4091 gcc_obstack_init (&declarator_obstack
);
4092 /* Create the error declarator. */
4093 cp_error_declarator
= make_declarator (cdk_error
);
4094 /* Create the empty parameter list. */
4095 no_parameters
= make_parameter_declarator (NULL
, NULL
, NULL_TREE
);
4096 /* Remember where the base of the declarator obstack lies. */
4097 declarator_obstack_base
= obstack_next_free (&declarator_obstack
);
4100 cp_parser_declaration_seq_opt (parser
);
4102 /* If there are no tokens left then all went well. */
4103 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
4105 /* Get rid of the token array; we don't need it any more. */
4106 cp_lexer_destroy (parser
->lexer
);
4107 parser
->lexer
= NULL
;
4109 /* This file might have been a context that's implicitly extern
4110 "C". If so, pop the lang context. (Only relevant for PCH.) */
4111 if (parser
->implicit_extern_c
)
4113 pop_lang_context ();
4114 parser
->implicit_extern_c
= false;
4118 finish_translation_unit ();
4124 cp_parser_error (parser
, "expected declaration");
4128 /* Make sure the declarator obstack was fully cleaned up. */
4129 gcc_assert (obstack_next_free (&declarator_obstack
)
4130 == declarator_obstack_base
);
4132 /* All went well. */
4136 /* Return the appropriate tsubst flags for parsing, possibly in N3276
4137 decltype context. */
4139 static inline tsubst_flags_t
4140 complain_flags (bool decltype_p
)
4142 tsubst_flags_t complain
= tf_warning_or_error
;
4144 complain
|= tf_decltype
;
4148 /* We're about to parse a collection of statements. If we're currently
4149 parsing tentatively, set up a firewall so that any nested
4150 cp_parser_commit_to_tentative_parse won't affect the current context. */
4152 static cp_token_position
4153 cp_parser_start_tentative_firewall (cp_parser
*parser
)
4155 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
4158 cp_parser_parse_tentatively (parser
);
4159 cp_parser_commit_to_topmost_tentative_parse (parser
);
4160 return cp_lexer_token_position (parser
->lexer
, false);
4163 /* We've finished parsing the collection of statements. Wrap up the
4164 firewall and replace the relevant tokens with the parsed form. */
4167 cp_parser_end_tentative_firewall (cp_parser
*parser
, cp_token_position start
,
4173 /* Finish the firewall level. */
4174 cp_parser_parse_definitely (parser
);
4175 /* And remember the result of the parse for when we try again. */
4176 cp_token
*token
= cp_lexer_token_at (parser
->lexer
, start
);
4177 token
->type
= CPP_PREPARSED_EXPR
;
4178 token
->u
.value
= expr
;
4179 token
->keyword
= RID_MAX
;
4180 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
4183 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
4184 enclosing parentheses. */
4187 cp_parser_statement_expr (cp_parser
*parser
)
4189 cp_token_position start
= cp_parser_start_tentative_firewall (parser
);
4191 /* Consume the '('. */
4192 cp_lexer_consume_token (parser
->lexer
);
4193 /* Start the statement-expression. */
4194 tree expr
= begin_stmt_expr ();
4195 /* Parse the compound-statement. */
4196 cp_parser_compound_statement (parser
, expr
, false, false);
4198 expr
= finish_stmt_expr (expr
, false);
4199 /* Consume the ')'. */
4200 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
4201 cp_parser_skip_to_end_of_statement (parser
);
4203 cp_parser_end_tentative_firewall (parser
, start
, expr
);
4207 /* Expressions [gram.expr] */
4209 /* Parse a primary-expression.
4216 lambda-expression (C++11)
4221 ( compound-statement )
4222 __builtin_va_arg ( assignment-expression , type-id )
4223 __builtin_offsetof ( type-id , offsetof-expression )
4226 __has_nothrow_assign ( type-id )
4227 __has_nothrow_constructor ( type-id )
4228 __has_nothrow_copy ( type-id )
4229 __has_trivial_assign ( type-id )
4230 __has_trivial_constructor ( type-id )
4231 __has_trivial_copy ( type-id )
4232 __has_trivial_destructor ( type-id )
4233 __has_virtual_destructor ( type-id )
4234 __is_abstract ( type-id )
4235 __is_base_of ( type-id , type-id )
4236 __is_class ( type-id )
4237 __is_empty ( type-id )
4238 __is_enum ( type-id )
4239 __is_final ( type-id )
4240 __is_literal_type ( type-id )
4241 __is_pod ( type-id )
4242 __is_polymorphic ( type-id )
4243 __is_std_layout ( type-id )
4244 __is_trivial ( type-id )
4245 __is_union ( type-id )
4247 Objective-C++ Extension:
4255 ADDRESS_P is true iff this expression was immediately preceded by
4256 "&" and therefore might denote a pointer-to-member. CAST_P is true
4257 iff this expression is the target of a cast. TEMPLATE_ARG_P is
4258 true iff this expression is a template argument.
4260 Returns a representation of the expression. Upon return, *IDK
4261 indicates what kind of id-expression (if any) was present. */
4264 cp_parser_primary_expression (cp_parser
*parser
,
4267 bool template_arg_p
,
4271 cp_token
*token
= NULL
;
4273 /* Assume the primary expression is not an id-expression. */
4274 *idk
= CP_ID_KIND_NONE
;
4276 /* Peek at the next token. */
4277 token
= cp_lexer_peek_token (parser
->lexer
);
4278 switch ((int) token
->type
)
4287 user-defined-literal */
4293 case CPP_PREPARSED_EXPR
:
4294 if (TREE_CODE (token
->u
.value
) == USERDEF_LITERAL
)
4295 return cp_parser_userdef_numeric_literal (parser
);
4296 token
= cp_lexer_consume_token (parser
->lexer
);
4297 if (TREE_CODE (token
->u
.value
) == FIXED_CST
)
4299 error_at (token
->location
,
4300 "fixed-point types not supported in C++");
4301 return error_mark_node
;
4303 /* Floating-point literals are only allowed in an integral
4304 constant expression if they are cast to an integral or
4305 enumeration type. */
4306 if (TREE_CODE (token
->u
.value
) == REAL_CST
4307 && parser
->integral_constant_expression_p
4310 /* CAST_P will be set even in invalid code like "int(2.7 +
4311 ...)". Therefore, we have to check that the next token
4312 is sure to end the cast. */
4315 cp_token
*next_token
;
4317 next_token
= cp_lexer_peek_token (parser
->lexer
);
4318 if (/* The comma at the end of an
4319 enumerator-definition. */
4320 next_token
->type
!= CPP_COMMA
4321 /* The curly brace at the end of an enum-specifier. */
4322 && next_token
->type
!= CPP_CLOSE_BRACE
4323 /* The end of a statement. */
4324 && next_token
->type
!= CPP_SEMICOLON
4325 /* The end of the cast-expression. */
4326 && next_token
->type
!= CPP_CLOSE_PAREN
4327 /* The end of an array bound. */
4328 && next_token
->type
!= CPP_CLOSE_SQUARE
4329 /* The closing ">" in a template-argument-list. */
4330 && (next_token
->type
!= CPP_GREATER
4331 || parser
->greater_than_is_operator_p
)
4332 /* C++0x only: A ">>" treated like two ">" tokens,
4333 in a template-argument-list. */
4334 && (next_token
->type
!= CPP_RSHIFT
4335 || (cxx_dialect
== cxx98
)
4336 || parser
->greater_than_is_operator_p
))
4340 /* If we are within a cast, then the constraint that the
4341 cast is to an integral or enumeration type will be
4342 checked at that point. If we are not within a cast, then
4343 this code is invalid. */
4345 cp_parser_non_integral_constant_expression (parser
, NIC_FLOAT
);
4347 return token
->u
.value
;
4349 case CPP_CHAR_USERDEF
:
4350 case CPP_CHAR16_USERDEF
:
4351 case CPP_CHAR32_USERDEF
:
4352 case CPP_WCHAR_USERDEF
:
4353 return cp_parser_userdef_char_literal (parser
);
4359 case CPP_UTF8STRING
:
4360 case CPP_STRING_USERDEF
:
4361 case CPP_STRING16_USERDEF
:
4362 case CPP_STRING32_USERDEF
:
4363 case CPP_WSTRING_USERDEF
:
4364 case CPP_UTF8STRING_USERDEF
:
4365 /* ??? Should wide strings be allowed when parser->translate_strings_p
4366 is false (i.e. in attributes)? If not, we can kill the third
4367 argument to cp_parser_string_literal. */
4368 return cp_parser_string_literal (parser
,
4369 parser
->translate_strings_p
,
4372 case CPP_OPEN_PAREN
:
4373 /* If we see `( { ' then we are looking at the beginning of
4374 a GNU statement-expression. */
4375 if (cp_parser_allow_gnu_extensions_p (parser
)
4376 && cp_lexer_nth_token_is (parser
->lexer
, 2, CPP_OPEN_BRACE
))
4378 /* Statement-expressions are not allowed by the standard. */
4379 pedwarn (token
->location
, OPT_Wpedantic
,
4380 "ISO C++ forbids braced-groups within expressions");
4382 /* And they're not allowed outside of a function-body; you
4383 cannot, for example, write:
4385 int i = ({ int j = 3; j + 1; });
4387 at class or namespace scope. */
4388 if (!parser
->in_function_body
4389 || parser
->in_template_argument_list_p
)
4391 error_at (token
->location
,
4392 "statement-expressions are not allowed outside "
4393 "functions nor in template-argument lists");
4394 cp_parser_skip_to_end_of_block_or_statement (parser
);
4395 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
4396 cp_lexer_consume_token (parser
->lexer
);
4397 return error_mark_node
;
4400 return cp_parser_statement_expr (parser
);
4402 /* Otherwise it's a normal parenthesized expression. */
4405 bool saved_greater_than_is_operator_p
;
4407 /* Consume the `('. */
4408 cp_lexer_consume_token (parser
->lexer
);
4409 /* Within a parenthesized expression, a `>' token is always
4410 the greater-than operator. */
4411 saved_greater_than_is_operator_p
4412 = parser
->greater_than_is_operator_p
;
4413 parser
->greater_than_is_operator_p
= true;
4415 /* Parse the parenthesized expression. */
4416 expr
= cp_parser_expression (parser
, idk
, cast_p
, decltype_p
);
4417 /* Let the front end know that this expression was
4418 enclosed in parentheses. This matters in case, for
4419 example, the expression is of the form `A::B', since
4420 `&A::B' might be a pointer-to-member, but `&(A::B)' is
4422 expr
= finish_parenthesized_expr (expr
);
4423 /* DR 705: Wrapping an unqualified name in parentheses
4424 suppresses arg-dependent lookup. We want to pass back
4425 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4426 (c++/37862), but none of the others. */
4427 if (*idk
!= CP_ID_KIND_QUALIFIED
)
4428 *idk
= CP_ID_KIND_NONE
;
4430 /* The `>' token might be the end of a template-id or
4431 template-parameter-list now. */
4432 parser
->greater_than_is_operator_p
4433 = saved_greater_than_is_operator_p
;
4434 /* Consume the `)'. */
4435 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
4436 cp_parser_skip_to_end_of_statement (parser
);
4441 case CPP_OPEN_SQUARE
:
4443 if (c_dialect_objc ())
4445 /* We might have an Objective-C++ message. */
4446 cp_parser_parse_tentatively (parser
);
4447 tree msg
= cp_parser_objc_message_expression (parser
);
4448 /* If that works out, we're done ... */
4449 if (cp_parser_parse_definitely (parser
))
4451 /* ... else, fall though to see if it's a lambda. */
4453 tree lam
= cp_parser_lambda_expression (parser
);
4454 /* Don't warn about a failed tentative parse. */
4455 if (cp_parser_error_occurred (parser
))
4456 return error_mark_node
;
4457 maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR
);
4461 case CPP_OBJC_STRING
:
4462 if (c_dialect_objc ())
4463 /* We have an Objective-C++ string literal. */
4464 return cp_parser_objc_expression (parser
);
4465 cp_parser_error (parser
, "expected primary-expression");
4466 return error_mark_node
;
4469 switch (token
->keyword
)
4471 /* These two are the boolean literals. */
4473 cp_lexer_consume_token (parser
->lexer
);
4474 return boolean_true_node
;
4476 cp_lexer_consume_token (parser
->lexer
);
4477 return boolean_false_node
;
4479 /* The `__null' literal. */
4481 cp_lexer_consume_token (parser
->lexer
);
4484 /* The `nullptr' literal. */
4486 cp_lexer_consume_token (parser
->lexer
);
4487 return nullptr_node
;
4489 /* Recognize the `this' keyword. */
4491 cp_lexer_consume_token (parser
->lexer
);
4492 if (parser
->local_variables_forbidden_p
)
4494 error_at (token
->location
,
4495 "%<this%> may not be used in this context");
4496 return error_mark_node
;
4498 /* Pointers cannot appear in constant-expressions. */
4499 if (cp_parser_non_integral_constant_expression (parser
, NIC_THIS
))
4500 return error_mark_node
;
4501 return finish_this_expr ();
4503 /* The `operator' keyword can be the beginning of an
4508 case RID_FUNCTION_NAME
:
4509 case RID_PRETTY_FUNCTION_NAME
:
4510 case RID_C99_FUNCTION_NAME
:
4512 non_integral_constant name
;
4514 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4515 __func__ are the names of variables -- but they are
4516 treated specially. Therefore, they are handled here,
4517 rather than relying on the generic id-expression logic
4518 below. Grammatically, these names are id-expressions.
4520 Consume the token. */
4521 token
= cp_lexer_consume_token (parser
->lexer
);
4523 switch (token
->keyword
)
4525 case RID_FUNCTION_NAME
:
4526 name
= NIC_FUNC_NAME
;
4528 case RID_PRETTY_FUNCTION_NAME
:
4529 name
= NIC_PRETTY_FUNC
;
4531 case RID_C99_FUNCTION_NAME
:
4532 name
= NIC_C99_FUNC
;
4538 if (cp_parser_non_integral_constant_expression (parser
, name
))
4539 return error_mark_node
;
4541 /* Look up the name. */
4542 return finish_fname (token
->u
.value
);
4549 source_location type_location
;
4551 /* The `__builtin_va_arg' construct is used to handle
4552 `va_arg'. Consume the `__builtin_va_arg' token. */
4553 cp_lexer_consume_token (parser
->lexer
);
4554 /* Look for the opening `('. */
4555 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
4556 /* Now, parse the assignment-expression. */
4557 expression
= cp_parser_assignment_expression (parser
);
4558 /* Look for the `,'. */
4559 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
4560 type_location
= cp_lexer_peek_token (parser
->lexer
)->location
;
4561 /* Parse the type-id. */
4562 type
= cp_parser_type_id (parser
);
4563 /* Look for the closing `)'. */
4564 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
4565 /* Using `va_arg' in a constant-expression is not
4567 if (cp_parser_non_integral_constant_expression (parser
,
4569 return error_mark_node
;
4570 return build_x_va_arg (type_location
, expression
, type
);
4574 return cp_parser_builtin_offsetof (parser
);
4576 case RID_HAS_NOTHROW_ASSIGN
:
4577 case RID_HAS_NOTHROW_CONSTRUCTOR
:
4578 case RID_HAS_NOTHROW_COPY
:
4579 case RID_HAS_TRIVIAL_ASSIGN
:
4580 case RID_HAS_TRIVIAL_CONSTRUCTOR
:
4581 case RID_HAS_TRIVIAL_COPY
:
4582 case RID_HAS_TRIVIAL_DESTRUCTOR
:
4583 case RID_HAS_VIRTUAL_DESTRUCTOR
:
4584 case RID_IS_ABSTRACT
:
4585 case RID_IS_BASE_OF
:
4590 case RID_IS_LITERAL_TYPE
:
4592 case RID_IS_POLYMORPHIC
:
4593 case RID_IS_STD_LAYOUT
:
4594 case RID_IS_TRIVIAL
:
4595 case RID_IS_TRIVIALLY_ASSIGNABLE
:
4596 case RID_IS_TRIVIALLY_CONSTRUCTIBLE
:
4597 case RID_IS_TRIVIALLY_COPYABLE
:
4599 return cp_parser_trait_expr (parser
, token
->keyword
);
4601 /* Objective-C++ expressions. */
4603 case RID_AT_PROTOCOL
:
4604 case RID_AT_SELECTOR
:
4605 return cp_parser_objc_expression (parser
);
4608 if (parser
->in_function_body
4609 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
4612 error_at (token
->location
,
4613 "a template declaration cannot appear at block scope");
4614 cp_parser_skip_to_end_of_block_or_statement (parser
);
4615 return error_mark_node
;
4618 cp_parser_error (parser
, "expected primary-expression");
4619 return error_mark_node
;
4622 /* An id-expression can start with either an identifier, a
4623 `::' as the beginning of a qualified-id, or the "operator"
4627 case CPP_TEMPLATE_ID
:
4628 case CPP_NESTED_NAME_SPECIFIER
:
4632 const char *error_msg
;
4635 cp_token
*id_expr_token
;
4638 /* Parse the id-expression. */
4640 = cp_parser_id_expression (parser
,
4641 /*template_keyword_p=*/false,
4642 /*check_dependency_p=*/true,
4644 /*declarator_p=*/false,
4645 /*optional_p=*/false);
4646 if (id_expression
== error_mark_node
)
4647 return error_mark_node
;
4648 id_expr_token
= token
;
4649 token
= cp_lexer_peek_token (parser
->lexer
);
4650 done
= (token
->type
!= CPP_OPEN_SQUARE
4651 && token
->type
!= CPP_OPEN_PAREN
4652 && token
->type
!= CPP_DOT
4653 && token
->type
!= CPP_DEREF
4654 && token
->type
!= CPP_PLUS_PLUS
4655 && token
->type
!= CPP_MINUS_MINUS
);
4656 /* If we have a template-id, then no further lookup is
4657 required. If the template-id was for a template-class, we
4658 will sometimes have a TYPE_DECL at this point. */
4659 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
4660 || TREE_CODE (id_expression
) == TYPE_DECL
)
4661 decl
= id_expression
;
4662 /* Look up the name. */
4665 tree ambiguous_decls
;
4667 /* If we already know that this lookup is ambiguous, then
4668 we've already issued an error message; there's no reason
4670 if (id_expr_token
->type
== CPP_NAME
4671 && id_expr_token
->error_reported
)
4673 cp_parser_simulate_error (parser
);
4674 return error_mark_node
;
4677 decl
= cp_parser_lookup_name (parser
, id_expression
,
4680 /*is_namespace=*/false,
4681 /*check_dependency=*/true,
4683 id_expr_token
->location
);
4684 /* If the lookup was ambiguous, an error will already have
4686 if (ambiguous_decls
)
4687 return error_mark_node
;
4689 /* In Objective-C++, we may have an Objective-C 2.0
4690 dot-syntax for classes here. */
4691 if (c_dialect_objc ()
4692 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_DOT
4693 && TREE_CODE (decl
) == TYPE_DECL
4694 && objc_is_class_name (decl
))
4697 cp_lexer_consume_token (parser
->lexer
);
4698 component
= cp_parser_identifier (parser
);
4699 if (component
== error_mark_node
)
4700 return error_mark_node
;
4702 return objc_build_class_component_ref (id_expression
, component
);
4705 /* In Objective-C++, an instance variable (ivar) may be preferred
4706 to whatever cp_parser_lookup_name() found. */
4707 decl
= objc_lookup_ivar (decl
, id_expression
);
4709 /* If name lookup gives us a SCOPE_REF, then the
4710 qualifying scope was dependent. */
4711 if (TREE_CODE (decl
) == SCOPE_REF
)
4713 /* At this point, we do not know if DECL is a valid
4714 integral constant expression. We assume that it is
4715 in fact such an expression, so that code like:
4717 template <int N> struct A {
4721 is accepted. At template-instantiation time, we
4722 will check that B<N>::i is actually a constant. */
4725 /* Check to see if DECL is a local variable in a context
4726 where that is forbidden. */
4727 if (parser
->local_variables_forbidden_p
4728 && local_variable_p (decl
))
4730 /* It might be that we only found DECL because we are
4731 trying to be generous with pre-ISO scoping rules.
4732 For example, consider:
4736 for (int i = 0; i < 10; ++i) {}
4737 extern void f(int j = i);
4740 Here, name look up will originally find the out
4741 of scope `i'. We need to issue a warning message,
4742 but then use the global `i'. */
4743 decl
= check_for_out_of_scope_variable (decl
);
4744 if (local_variable_p (decl
))
4746 error_at (id_expr_token
->location
,
4747 "local variable %qD may not appear in this context",
4749 return error_mark_node
;
4754 decl
= (finish_id_expression
4755 (id_expression
, decl
, parser
->scope
,
4757 parser
->integral_constant_expression_p
,
4758 parser
->allow_non_integral_constant_expression_p
,
4759 &parser
->non_integral_constant_expression_p
,
4760 template_p
, done
, address_p
,
4763 id_expr_token
->location
));
4765 cp_parser_error (parser
, error_msg
);
4769 /* Anything else is an error. */
4771 cp_parser_error (parser
, "expected primary-expression");
4772 return error_mark_node
;
4777 cp_parser_primary_expression (cp_parser
*parser
,
4780 bool template_arg_p
,
4783 return cp_parser_primary_expression (parser
, address_p
, cast_p
, template_arg_p
,
4784 /*decltype*/false, idk
);
4787 /* Parse an id-expression.
4794 :: [opt] nested-name-specifier template [opt] unqualified-id
4796 :: operator-function-id
4799 Return a representation of the unqualified portion of the
4800 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
4801 a `::' or nested-name-specifier.
4803 Often, if the id-expression was a qualified-id, the caller will
4804 want to make a SCOPE_REF to represent the qualified-id. This
4805 function does not do this in order to avoid wastefully creating
4806 SCOPE_REFs when they are not required.
4808 If TEMPLATE_KEYWORD_P is true, then we have just seen the
4811 If CHECK_DEPENDENCY_P is false, then names are looked up inside
4812 uninstantiated templates.
4814 If *TEMPLATE_P is non-NULL, it is set to true iff the
4815 `template' keyword is used to explicitly indicate that the entity
4816 named is a template.
4818 If DECLARATOR_P is true, the id-expression is appearing as part of
4819 a declarator, rather than as part of an expression. */
4822 cp_parser_id_expression (cp_parser
*parser
,
4823 bool template_keyword_p
,
4824 bool check_dependency_p
,
4829 bool global_scope_p
;
4830 bool nested_name_specifier_p
;
4832 /* Assume the `template' keyword was not used. */
4834 *template_p
= template_keyword_p
;
4836 /* Look for the optional `::' operator. */
4838 = (cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false)
4840 /* Look for the optional nested-name-specifier. */
4841 nested_name_specifier_p
4842 = (cp_parser_nested_name_specifier_opt (parser
,
4843 /*typename_keyword_p=*/false,
4848 /* If there is a nested-name-specifier, then we are looking at
4849 the first qualified-id production. */
4850 if (nested_name_specifier_p
)
4853 tree saved_object_scope
;
4854 tree saved_qualifying_scope
;
4855 tree unqualified_id
;
4858 /* See if the next token is the `template' keyword. */
4860 template_p
= &is_template
;
4861 *template_p
= cp_parser_optional_template_keyword (parser
);
4862 /* Name lookup we do during the processing of the
4863 unqualified-id might obliterate SCOPE. */
4864 saved_scope
= parser
->scope
;
4865 saved_object_scope
= parser
->object_scope
;
4866 saved_qualifying_scope
= parser
->qualifying_scope
;
4867 /* Process the final unqualified-id. */
4868 unqualified_id
= cp_parser_unqualified_id (parser
, *template_p
,
4871 /*optional_p=*/false);
4872 /* Restore the SAVED_SCOPE for our caller. */
4873 parser
->scope
= saved_scope
;
4874 parser
->object_scope
= saved_object_scope
;
4875 parser
->qualifying_scope
= saved_qualifying_scope
;
4877 return unqualified_id
;
4879 /* Otherwise, if we are in global scope, then we are looking at one
4880 of the other qualified-id productions. */
4881 else if (global_scope_p
)
4886 /* Peek at the next token. */
4887 token
= cp_lexer_peek_token (parser
->lexer
);
4889 /* If it's an identifier, and the next token is not a "<", then
4890 we can avoid the template-id case. This is an optimization
4891 for this common case. */
4892 if (token
->type
== CPP_NAME
4893 && !cp_parser_nth_token_starts_template_argument_list_p
4895 return cp_parser_identifier (parser
);
4897 cp_parser_parse_tentatively (parser
);
4898 /* Try a template-id. */
4899 id
= cp_parser_template_id (parser
,
4900 /*template_keyword_p=*/false,
4901 /*check_dependency_p=*/true,
4904 /* If that worked, we're done. */
4905 if (cp_parser_parse_definitely (parser
))
4908 /* Peek at the next token. (Changes in the token buffer may
4909 have invalidated the pointer obtained above.) */
4910 token
= cp_lexer_peek_token (parser
->lexer
);
4912 switch (token
->type
)
4915 return cp_parser_identifier (parser
);
4918 if (token
->keyword
== RID_OPERATOR
)
4919 return cp_parser_operator_function_id (parser
);
4923 cp_parser_error (parser
, "expected id-expression");
4924 return error_mark_node
;
4928 return cp_parser_unqualified_id (parser
, template_keyword_p
,
4929 /*check_dependency_p=*/true,
4934 /* Parse an unqualified-id.
4938 operator-function-id
4939 conversion-function-id
4943 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
4944 keyword, in a construct like `A::template ...'.
4946 Returns a representation of unqualified-id. For the `identifier'
4947 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
4948 production a BIT_NOT_EXPR is returned; the operand of the
4949 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
4950 other productions, see the documentation accompanying the
4951 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
4952 names are looked up in uninstantiated templates. If DECLARATOR_P
4953 is true, the unqualified-id is appearing as part of a declarator,
4954 rather than as part of an expression. */
4957 cp_parser_unqualified_id (cp_parser
* parser
,
4958 bool template_keyword_p
,
4959 bool check_dependency_p
,
4965 /* Peek at the next token. */
4966 token
= cp_lexer_peek_token (parser
->lexer
);
4968 switch ((int) token
->type
)
4974 /* We don't know yet whether or not this will be a
4976 cp_parser_parse_tentatively (parser
);
4977 /* Try a template-id. */
4978 id
= cp_parser_template_id (parser
, template_keyword_p
,
4982 /* If it worked, we're done. */
4983 if (cp_parser_parse_definitely (parser
))
4985 /* Otherwise, it's an ordinary identifier. */
4986 return cp_parser_identifier (parser
);
4989 case CPP_TEMPLATE_ID
:
4990 return cp_parser_template_id (parser
, template_keyword_p
,
4998 tree qualifying_scope
;
5003 /* Consume the `~' token. */
5004 cp_lexer_consume_token (parser
->lexer
);
5005 /* Parse the class-name. The standard, as written, seems to
5008 template <typename T> struct S { ~S (); };
5009 template <typename T> S<T>::~S() {}
5011 is invalid, since `~' must be followed by a class-name, but
5012 `S<T>' is dependent, and so not known to be a class.
5013 That's not right; we need to look in uninstantiated
5014 templates. A further complication arises from:
5016 template <typename T> void f(T t) {
5020 Here, it is not possible to look up `T' in the scope of `T'
5021 itself. We must look in both the current scope, and the
5022 scope of the containing complete expression.
5024 Yet another issue is:
5033 The standard does not seem to say that the `S' in `~S'
5034 should refer to the type `S' and not the data member
5037 /* DR 244 says that we look up the name after the "~" in the
5038 same scope as we looked up the qualifying name. That idea
5039 isn't fully worked out; it's more complicated than that. */
5040 scope
= parser
->scope
;
5041 object_scope
= parser
->object_scope
;
5042 qualifying_scope
= parser
->qualifying_scope
;
5044 /* Check for invalid scopes. */
5045 if (scope
== error_mark_node
)
5047 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
5048 cp_lexer_consume_token (parser
->lexer
);
5049 return error_mark_node
;
5051 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
5053 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
5054 error_at (token
->location
,
5055 "scope %qT before %<~%> is not a class-name",
5057 cp_parser_simulate_error (parser
);
5058 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
5059 cp_lexer_consume_token (parser
->lexer
);
5060 return error_mark_node
;
5062 gcc_assert (!scope
|| TYPE_P (scope
));
5064 /* If the name is of the form "X::~X" it's OK even if X is a
5066 token
= cp_lexer_peek_token (parser
->lexer
);
5068 && token
->type
== CPP_NAME
5069 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
5071 && (token
->u
.value
== TYPE_IDENTIFIER (scope
)
5072 || (CLASS_TYPE_P (scope
)
5073 && constructor_name_p (token
->u
.value
, scope
))))
5075 cp_lexer_consume_token (parser
->lexer
);
5076 return build_nt (BIT_NOT_EXPR
, scope
);
5079 /* ~auto means the destructor of whatever the object is. */
5080 if (cp_parser_is_keyword (token
, RID_AUTO
))
5082 if (cxx_dialect
< cxx14
)
5083 pedwarn (input_location
, 0,
5084 "%<~auto%> only available with "
5085 "-std=c++14 or -std=gnu++14");
5086 cp_lexer_consume_token (parser
->lexer
);
5087 return build_nt (BIT_NOT_EXPR
, make_auto ());
5090 /* If there was an explicit qualification (S::~T), first look
5091 in the scope given by the qualification (i.e., S).
5093 Note: in the calls to cp_parser_class_name below we pass
5094 typename_type so that lookup finds the injected-class-name
5095 rather than the constructor. */
5097 type_decl
= NULL_TREE
;
5100 cp_parser_parse_tentatively (parser
);
5101 type_decl
= cp_parser_class_name (parser
,
5102 /*typename_keyword_p=*/false,
5103 /*template_keyword_p=*/false,
5105 /*check_dependency=*/false,
5106 /*class_head_p=*/false,
5108 if (cp_parser_parse_definitely (parser
))
5111 /* In "N::S::~S", look in "N" as well. */
5112 if (!done
&& scope
&& qualifying_scope
)
5114 cp_parser_parse_tentatively (parser
);
5115 parser
->scope
= qualifying_scope
;
5116 parser
->object_scope
= NULL_TREE
;
5117 parser
->qualifying_scope
= NULL_TREE
;
5119 = cp_parser_class_name (parser
,
5120 /*typename_keyword_p=*/false,
5121 /*template_keyword_p=*/false,
5123 /*check_dependency=*/false,
5124 /*class_head_p=*/false,
5126 if (cp_parser_parse_definitely (parser
))
5129 /* In "p->S::~T", look in the scope given by "*p" as well. */
5130 else if (!done
&& object_scope
)
5132 cp_parser_parse_tentatively (parser
);
5133 parser
->scope
= object_scope
;
5134 parser
->object_scope
= NULL_TREE
;
5135 parser
->qualifying_scope
= NULL_TREE
;
5137 = cp_parser_class_name (parser
,
5138 /*typename_keyword_p=*/false,
5139 /*template_keyword_p=*/false,
5141 /*check_dependency=*/false,
5142 /*class_head_p=*/false,
5144 if (cp_parser_parse_definitely (parser
))
5147 /* Look in the surrounding context. */
5150 parser
->scope
= NULL_TREE
;
5151 parser
->object_scope
= NULL_TREE
;
5152 parser
->qualifying_scope
= NULL_TREE
;
5153 if (processing_template_decl
)
5154 cp_parser_parse_tentatively (parser
);
5156 = cp_parser_class_name (parser
,
5157 /*typename_keyword_p=*/false,
5158 /*template_keyword_p=*/false,
5160 /*check_dependency=*/false,
5161 /*class_head_p=*/false,
5163 if (processing_template_decl
5164 && ! cp_parser_parse_definitely (parser
))
5166 /* We couldn't find a type with this name, so just accept
5167 it and check for a match at instantiation time. */
5168 type_decl
= cp_parser_identifier (parser
);
5169 if (type_decl
!= error_mark_node
)
5170 type_decl
= build_nt (BIT_NOT_EXPR
, type_decl
);
5174 /* If an error occurred, assume that the name of the
5175 destructor is the same as the name of the qualifying
5176 class. That allows us to keep parsing after running
5177 into ill-formed destructor names. */
5178 if (type_decl
== error_mark_node
&& scope
)
5179 return build_nt (BIT_NOT_EXPR
, scope
);
5180 else if (type_decl
== error_mark_node
)
5181 return error_mark_node
;
5183 /* Check that destructor name and scope match. */
5184 if (declarator_p
&& scope
&& !check_dtor_name (scope
, type_decl
))
5186 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
5187 error_at (token
->location
,
5188 "declaration of %<~%T%> as member of %qT",
5190 cp_parser_simulate_error (parser
);
5191 return error_mark_node
;
5196 A typedef-name that names a class shall not be used as the
5197 identifier in the declarator for a destructor declaration. */
5199 && !DECL_IMPLICIT_TYPEDEF_P (type_decl
)
5200 && !DECL_SELF_REFERENCE_P (type_decl
)
5201 && !cp_parser_uncommitted_to_tentative_parse_p (parser
))
5202 error_at (token
->location
,
5203 "typedef-name %qD used as destructor declarator",
5206 return build_nt (BIT_NOT_EXPR
, TREE_TYPE (type_decl
));
5210 if (token
->keyword
== RID_OPERATOR
)
5214 /* This could be a template-id, so we try that first. */
5215 cp_parser_parse_tentatively (parser
);
5216 /* Try a template-id. */
5217 id
= cp_parser_template_id (parser
, template_keyword_p
,
5218 /*check_dependency_p=*/true,
5221 /* If that worked, we're done. */
5222 if (cp_parser_parse_definitely (parser
))
5224 /* We still don't know whether we're looking at an
5225 operator-function-id or a conversion-function-id. */
5226 cp_parser_parse_tentatively (parser
);
5227 /* Try an operator-function-id. */
5228 id
= cp_parser_operator_function_id (parser
);
5229 /* If that didn't work, try a conversion-function-id. */
5230 if (!cp_parser_parse_definitely (parser
))
5231 id
= cp_parser_conversion_function_id (parser
);
5232 else if (UDLIT_OPER_P (id
))
5235 const char *name
= UDLIT_OP_SUFFIX (id
);
5236 if (name
[0] != '_' && !in_system_header_at (input_location
)
5238 warning (0, "literal operator suffixes not preceded by %<_%>"
5239 " are reserved for future standardization");
5249 cp_parser_error (parser
, "expected unqualified-id");
5250 return error_mark_node
;
5254 /* Parse an (optional) nested-name-specifier.
5256 nested-name-specifier: [C++98]
5257 class-or-namespace-name :: nested-name-specifier [opt]
5258 class-or-namespace-name :: template nested-name-specifier [opt]
5260 nested-name-specifier: [C++0x]
5263 nested-name-specifier identifier ::
5264 nested-name-specifier template [opt] simple-template-id ::
5266 PARSER->SCOPE should be set appropriately before this function is
5267 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
5268 effect. TYPE_P is TRUE if we non-type bindings should be ignored
5271 Sets PARSER->SCOPE to the class (TYPE) or namespace
5272 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
5273 it unchanged if there is no nested-name-specifier. Returns the new
5274 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
5276 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
5277 part of a declaration and/or decl-specifier. */
5280 cp_parser_nested_name_specifier_opt (cp_parser
*parser
,
5281 bool typename_keyword_p
,
5282 bool check_dependency_p
,
5284 bool is_declaration
)
5286 bool success
= false;
5287 cp_token_position start
= 0;
5290 /* Remember where the nested-name-specifier starts. */
5291 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
5293 start
= cp_lexer_token_position (parser
->lexer
, false);
5294 push_deferring_access_checks (dk_deferred
);
5301 tree saved_qualifying_scope
;
5302 bool template_keyword_p
;
5304 /* Spot cases that cannot be the beginning of a
5305 nested-name-specifier. */
5306 token
= cp_lexer_peek_token (parser
->lexer
);
5308 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
5309 the already parsed nested-name-specifier. */
5310 if (token
->type
== CPP_NESTED_NAME_SPECIFIER
)
5312 /* Grab the nested-name-specifier and continue the loop. */
5313 cp_parser_pre_parsed_nested_name_specifier (parser
);
5314 /* If we originally encountered this nested-name-specifier
5315 with IS_DECLARATION set to false, we will not have
5316 resolved TYPENAME_TYPEs, so we must do so here. */
5318 && TREE_CODE (parser
->scope
) == TYPENAME_TYPE
)
5320 new_scope
= resolve_typename_type (parser
->scope
,
5321 /*only_current_p=*/false);
5322 if (TREE_CODE (new_scope
) != TYPENAME_TYPE
)
5323 parser
->scope
= new_scope
;
5329 /* Spot cases that cannot be the beginning of a
5330 nested-name-specifier. On the second and subsequent times
5331 through the loop, we look for the `template' keyword. */
5332 if (success
&& token
->keyword
== RID_TEMPLATE
)
5334 /* A template-id can start a nested-name-specifier. */
5335 else if (token
->type
== CPP_TEMPLATE_ID
)
5337 /* DR 743: decltype can be used in a nested-name-specifier. */
5338 else if (token_is_decltype (token
))
5342 /* If the next token is not an identifier, then it is
5343 definitely not a type-name or namespace-name. */
5344 if (token
->type
!= CPP_NAME
)
5346 /* If the following token is neither a `<' (to begin a
5347 template-id), nor a `::', then we are not looking at a
5348 nested-name-specifier. */
5349 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
5351 if (token
->type
== CPP_COLON
5352 && parser
->colon_corrects_to_scope_p
5353 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_NAME
)
5355 error_at (token
->location
,
5356 "found %<:%> in nested-name-specifier, expected %<::%>");
5357 token
->type
= CPP_SCOPE
;
5360 if (token
->type
!= CPP_SCOPE
5361 && !cp_parser_nth_token_starts_template_argument_list_p
5366 /* The nested-name-specifier is optional, so we parse
5368 cp_parser_parse_tentatively (parser
);
5370 /* Look for the optional `template' keyword, if this isn't the
5371 first time through the loop. */
5373 template_keyword_p
= cp_parser_optional_template_keyword (parser
);
5375 template_keyword_p
= false;
5377 /* Save the old scope since the name lookup we are about to do
5378 might destroy it. */
5379 old_scope
= parser
->scope
;
5380 saved_qualifying_scope
= parser
->qualifying_scope
;
5381 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
5382 look up names in "X<T>::I" in order to determine that "Y" is
5383 a template. So, if we have a typename at this point, we make
5384 an effort to look through it. */
5386 && !typename_keyword_p
5388 && TREE_CODE (parser
->scope
) == TYPENAME_TYPE
)
5389 parser
->scope
= resolve_typename_type (parser
->scope
,
5390 /*only_current_p=*/false);
5391 /* Parse the qualifying entity. */
5393 = cp_parser_qualifying_entity (parser
,
5399 /* Look for the `::' token. */
5400 cp_parser_require (parser
, CPP_SCOPE
, RT_SCOPE
);
5402 /* If we found what we wanted, we keep going; otherwise, we're
5404 if (!cp_parser_parse_definitely (parser
))
5406 bool error_p
= false;
5408 /* Restore the OLD_SCOPE since it was valid before the
5409 failed attempt at finding the last
5410 class-or-namespace-name. */
5411 parser
->scope
= old_scope
;
5412 parser
->qualifying_scope
= saved_qualifying_scope
;
5414 /* If the next token is a decltype, and the one after that is a
5415 `::', then the decltype has failed to resolve to a class or
5416 enumeration type. Give this error even when parsing
5417 tentatively since it can't possibly be valid--and we're going
5418 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
5419 won't get another chance.*/
5420 if (cp_lexer_next_token_is (parser
->lexer
, CPP_DECLTYPE
)
5421 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
5424 token
= cp_lexer_consume_token (parser
->lexer
);
5425 error_at (token
->location
, "decltype evaluates to %qT, "
5426 "which is not a class or enumeration type",
5428 parser
->scope
= error_mark_node
;
5432 cp_lexer_consume_token (parser
->lexer
);
5435 if (cp_lexer_next_token_is (parser
->lexer
, CPP_TEMPLATE_ID
)
5436 && cp_lexer_nth_token_is (parser
->lexer
, 2, CPP_SCOPE
))
5438 /* If we have a non-type template-id followed by ::, it can't
5439 possibly be valid. */
5440 token
= cp_lexer_peek_token (parser
->lexer
);
5441 tree tid
= token
->u
.tree_check_value
->value
;
5442 if (TREE_CODE (tid
) == TEMPLATE_ID_EXPR
5443 && TREE_CODE (TREE_OPERAND (tid
, 0)) != IDENTIFIER_NODE
)
5445 tree tmpl
= NULL_TREE
;
5446 if (is_overloaded_fn (tid
))
5448 tree fns
= get_fns (tid
);
5449 if (!OVL_CHAIN (fns
))
5450 tmpl
= OVL_CURRENT (fns
);
5451 error_at (token
->location
, "function template-id %qD "
5452 "in nested-name-specifier", tid
);
5456 /* Variable template. */
5457 tmpl
= TREE_OPERAND (tid
, 0);
5458 gcc_assert (variable_template_p (tmpl
));
5459 error_at (token
->location
, "variable template-id %qD "
5460 "in nested-name-specifier", tid
);
5463 inform (DECL_SOURCE_LOCATION (tmpl
),
5464 "%qD declared here", tmpl
);
5466 parser
->scope
= error_mark_node
;
5470 cp_lexer_consume_token (parser
->lexer
);
5471 cp_lexer_consume_token (parser
->lexer
);
5475 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
5477 /* If the next token is an identifier, and the one after
5478 that is a `::', then any valid interpretation would have
5479 found a class-or-namespace-name. */
5480 while (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
5481 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
5483 && (cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
5486 token
= cp_lexer_consume_token (parser
->lexer
);
5489 if (!token
->error_reported
)
5492 tree ambiguous_decls
;
5494 decl
= cp_parser_lookup_name (parser
, token
->u
.value
,
5496 /*is_template=*/false,
5497 /*is_namespace=*/false,
5498 /*check_dependency=*/true,
5501 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
5502 error_at (token
->location
,
5503 "%qD used without template parameters",
5505 else if (ambiguous_decls
)
5507 // cp_parser_lookup_name has the same diagnostic,
5508 // thus make sure to emit it at most once.
5509 if (cp_parser_uncommitted_to_tentative_parse_p
5512 error_at (token
->location
,
5513 "reference to %qD is ambiguous",
5515 print_candidates (ambiguous_decls
);
5517 decl
= error_mark_node
;
5521 if (cxx_dialect
!= cxx98
)
5522 cp_parser_name_lookup_error
5523 (parser
, token
->u
.value
, decl
, NLE_NOT_CXX98
,
5526 cp_parser_name_lookup_error
5527 (parser
, token
->u
.value
, decl
, NLE_CXX98
,
5531 parser
->scope
= error_mark_node
;
5533 /* Treat this as a successful nested-name-specifier
5538 If the name found is not a class-name (clause
5539 _class_) or namespace-name (_namespace.def_), the
5540 program is ill-formed. */
5543 cp_lexer_consume_token (parser
->lexer
);
5547 /* We've found one valid nested-name-specifier. */
5549 /* Name lookup always gives us a DECL. */
5550 if (TREE_CODE (new_scope
) == TYPE_DECL
)
5551 new_scope
= TREE_TYPE (new_scope
);
5552 /* Uses of "template" must be followed by actual templates. */
5553 if (template_keyword_p
5554 && !(CLASS_TYPE_P (new_scope
)
5555 && ((CLASSTYPE_USE_TEMPLATE (new_scope
)
5556 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope
)))
5557 || CLASSTYPE_IS_TEMPLATE (new_scope
)))
5558 && !(TREE_CODE (new_scope
) == TYPENAME_TYPE
5559 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope
))
5560 == TEMPLATE_ID_EXPR
)))
5561 permerror (input_location
, TYPE_P (new_scope
)
5562 ? G_("%qT is not a template")
5563 : G_("%qD is not a template"),
5565 /* If it is a class scope, try to complete it; we are about to
5566 be looking up names inside the class. */
5567 if (TYPE_P (new_scope
)
5568 /* Since checking types for dependency can be expensive,
5569 avoid doing it if the type is already complete. */
5570 && !COMPLETE_TYPE_P (new_scope
)
5571 /* Do not try to complete dependent types. */
5572 && !dependent_type_p (new_scope
))
5574 new_scope
= complete_type (new_scope
);
5575 /* If it is a typedef to current class, use the current
5576 class instead, as the typedef won't have any names inside
5578 if (!COMPLETE_TYPE_P (new_scope
)
5579 && currently_open_class (new_scope
))
5580 new_scope
= TYPE_MAIN_VARIANT (new_scope
);
5582 /* Make sure we look in the right scope the next time through
5584 parser
->scope
= new_scope
;
5587 /* If parsing tentatively, replace the sequence of tokens that makes
5588 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
5589 token. That way, should we re-parse the token stream, we will
5590 not have to repeat the effort required to do the parse, nor will
5591 we issue duplicate error messages. */
5592 if (success
&& start
)
5596 token
= cp_lexer_token_at (parser
->lexer
, start
);
5597 /* Reset the contents of the START token. */
5598 token
->type
= CPP_NESTED_NAME_SPECIFIER
;
5599 /* Retrieve any deferred checks. Do not pop this access checks yet
5600 so the memory will not be reclaimed during token replacing below. */
5601 token
->u
.tree_check_value
= ggc_cleared_alloc
<struct tree_check
> ();
5602 token
->u
.tree_check_value
->value
= parser
->scope
;
5603 token
->u
.tree_check_value
->checks
= get_deferred_access_checks ();
5604 token
->u
.tree_check_value
->qualifying_scope
=
5605 parser
->qualifying_scope
;
5606 token
->keyword
= RID_MAX
;
5608 /* Purge all subsequent tokens. */
5609 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
5613 pop_to_parent_deferring_access_checks ();
5615 return success
? parser
->scope
: NULL_TREE
;
5618 /* Parse a nested-name-specifier. See
5619 cp_parser_nested_name_specifier_opt for details. This function
5620 behaves identically, except that it will an issue an error if no
5621 nested-name-specifier is present. */
5624 cp_parser_nested_name_specifier (cp_parser
*parser
,
5625 bool typename_keyword_p
,
5626 bool check_dependency_p
,
5628 bool is_declaration
)
5632 /* Look for the nested-name-specifier. */
5633 scope
= cp_parser_nested_name_specifier_opt (parser
,
5638 /* If it was not present, issue an error message. */
5641 cp_parser_error (parser
, "expected nested-name-specifier");
5642 parser
->scope
= NULL_TREE
;
5648 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
5649 this is either a class-name or a namespace-name (which corresponds
5650 to the class-or-namespace-name production in the grammar). For
5651 C++0x, it can also be a type-name that refers to an enumeration
5652 type or a simple-template-id.
5654 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
5655 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
5656 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
5657 TYPE_P is TRUE iff the next name should be taken as a class-name,
5658 even the same name is declared to be another entity in the same
5661 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
5662 specified by the class-or-namespace-name. If neither is found the
5663 ERROR_MARK_NODE is returned. */
5666 cp_parser_qualifying_entity (cp_parser
*parser
,
5667 bool typename_keyword_p
,
5668 bool template_keyword_p
,
5669 bool check_dependency_p
,
5671 bool is_declaration
)
5674 tree saved_qualifying_scope
;
5675 tree saved_object_scope
;
5678 bool successful_parse_p
;
5680 /* DR 743: decltype can appear in a nested-name-specifier. */
5681 if (cp_lexer_next_token_is_decltype (parser
->lexer
))
5683 scope
= cp_parser_decltype (parser
);
5684 if (TREE_CODE (scope
) != ENUMERAL_TYPE
5685 && !MAYBE_CLASS_TYPE_P (scope
))
5687 cp_parser_simulate_error (parser
);
5688 return error_mark_node
;
5690 if (TYPE_NAME (scope
))
5691 scope
= TYPE_NAME (scope
);
5695 /* Before we try to parse the class-name, we must save away the
5696 current PARSER->SCOPE since cp_parser_class_name will destroy
5698 saved_scope
= parser
->scope
;
5699 saved_qualifying_scope
= parser
->qualifying_scope
;
5700 saved_object_scope
= parser
->object_scope
;
5701 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
5702 there is no need to look for a namespace-name. */
5703 only_class_p
= template_keyword_p
5704 || (saved_scope
&& TYPE_P (saved_scope
) && cxx_dialect
== cxx98
);
5706 cp_parser_parse_tentatively (parser
);
5707 scope
= cp_parser_class_name (parser
,
5710 type_p
? class_type
: none_type
,
5712 /*class_head_p=*/false,
5714 successful_parse_p
= only_class_p
|| cp_parser_parse_definitely (parser
);
5715 /* If that didn't work and we're in C++0x mode, try for a type-name. */
5717 && cxx_dialect
!= cxx98
5718 && !successful_parse_p
)
5720 /* Restore the saved scope. */
5721 parser
->scope
= saved_scope
;
5722 parser
->qualifying_scope
= saved_qualifying_scope
;
5723 parser
->object_scope
= saved_object_scope
;
5725 /* Parse tentatively. */
5726 cp_parser_parse_tentatively (parser
);
5728 /* Parse a type-name */
5729 scope
= cp_parser_type_name (parser
);
5731 /* "If the name found does not designate a namespace or a class,
5732 enumeration, or dependent type, the program is ill-formed."
5734 We cover classes and dependent types above and namespaces below,
5735 so this code is only looking for enums. */
5736 if (!scope
|| TREE_CODE (scope
) != TYPE_DECL
5737 || TREE_CODE (TREE_TYPE (scope
)) != ENUMERAL_TYPE
)
5738 cp_parser_simulate_error (parser
);
5740 successful_parse_p
= cp_parser_parse_definitely (parser
);
5742 /* If that didn't work, try for a namespace-name. */
5743 if (!only_class_p
&& !successful_parse_p
)
5745 /* Restore the saved scope. */
5746 parser
->scope
= saved_scope
;
5747 parser
->qualifying_scope
= saved_qualifying_scope
;
5748 parser
->object_scope
= saved_object_scope
;
5749 /* If we are not looking at an identifier followed by the scope
5750 resolution operator, then this is not part of a
5751 nested-name-specifier. (Note that this function is only used
5752 to parse the components of a nested-name-specifier.) */
5753 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
)
5754 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
)
5755 return error_mark_node
;
5756 scope
= cp_parser_namespace_name (parser
);
5762 /* Return true if we are looking at a compound-literal, false otherwise. */
5765 cp_parser_compound_literal_p (cp_parser
*parser
)
5767 /* Consume the `('. */
5768 cp_lexer_consume_token (parser
->lexer
);
5770 cp_lexer_save_tokens (parser
->lexer
);
5772 /* Skip tokens until the next token is a closing parenthesis.
5773 If we find the closing `)', and the next token is a `{', then
5774 we are looking at a compound-literal. */
5775 bool compound_literal_p
5776 = (cp_parser_skip_to_closing_parenthesis (parser
, false, false,
5777 /*consume_paren=*/true)
5778 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
));
5780 /* Roll back the tokens we skipped. */
5781 cp_lexer_rollback_tokens (parser
->lexer
);
5783 return compound_literal_p
;
5786 /* Parse a postfix-expression.
5790 postfix-expression [ expression ]
5791 postfix-expression ( expression-list [opt] )
5792 simple-type-specifier ( expression-list [opt] )
5793 typename :: [opt] nested-name-specifier identifier
5794 ( expression-list [opt] )
5795 typename :: [opt] nested-name-specifier template [opt] template-id
5796 ( expression-list [opt] )
5797 postfix-expression . template [opt] id-expression
5798 postfix-expression -> template [opt] id-expression
5799 postfix-expression . pseudo-destructor-name
5800 postfix-expression -> pseudo-destructor-name
5801 postfix-expression ++
5802 postfix-expression --
5803 dynamic_cast < type-id > ( expression )
5804 static_cast < type-id > ( expression )
5805 reinterpret_cast < type-id > ( expression )
5806 const_cast < type-id > ( expression )
5807 typeid ( expression )
5813 ( type-id ) { initializer-list , [opt] }
5815 This extension is a GNU version of the C99 compound-literal
5816 construct. (The C99 grammar uses `type-name' instead of `type-id',
5817 but they are essentially the same concept.)
5819 If ADDRESS_P is true, the postfix expression is the operand of the
5820 `&' operator. CAST_P is true if this expression is the target of a
5823 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
5824 class member access expressions [expr.ref].
5826 Returns a representation of the expression. */
5829 cp_parser_postfix_expression (cp_parser
*parser
, bool address_p
, bool cast_p
,
5830 bool member_access_only_p
, bool decltype_p
,
5831 cp_id_kind
* pidk_return
)
5836 cp_id_kind idk
= CP_ID_KIND_NONE
;
5837 tree postfix_expression
= NULL_TREE
;
5838 bool is_member_access
= false;
5839 int saved_in_statement
= -1;
5841 /* Peek at the next token. */
5842 token
= cp_lexer_peek_token (parser
->lexer
);
5843 loc
= token
->location
;
5844 /* Some of the productions are determined by keywords. */
5845 keyword
= token
->keyword
;
5855 const char *saved_message
;
5856 bool saved_in_type_id_in_expr_p
;
5858 /* All of these can be handled in the same way from the point
5859 of view of parsing. Begin by consuming the token
5860 identifying the cast. */
5861 cp_lexer_consume_token (parser
->lexer
);
5863 /* New types cannot be defined in the cast. */
5864 saved_message
= parser
->type_definition_forbidden_message
;
5865 parser
->type_definition_forbidden_message
5866 = G_("types may not be defined in casts");
5868 /* Look for the opening `<'. */
5869 cp_parser_require (parser
, CPP_LESS
, RT_LESS
);
5870 /* Parse the type to which we are casting. */
5871 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
5872 parser
->in_type_id_in_expr_p
= true;
5873 type
= cp_parser_type_id (parser
);
5874 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
5875 /* Look for the closing `>'. */
5876 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
5877 /* Restore the old message. */
5878 parser
->type_definition_forbidden_message
= saved_message
;
5880 bool saved_greater_than_is_operator_p
5881 = parser
->greater_than_is_operator_p
;
5882 parser
->greater_than_is_operator_p
= true;
5884 /* And the expression which is being cast. */
5885 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
5886 expression
= cp_parser_expression (parser
, & idk
, /*cast_p=*/true);
5887 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
5889 parser
->greater_than_is_operator_p
5890 = saved_greater_than_is_operator_p
;
5892 /* Only type conversions to integral or enumeration types
5893 can be used in constant-expressions. */
5894 if (!cast_valid_in_integral_constant_expression_p (type
)
5895 && cp_parser_non_integral_constant_expression (parser
, NIC_CAST
))
5896 return error_mark_node
;
5902 = build_dynamic_cast (type
, expression
, tf_warning_or_error
);
5906 = build_static_cast (type
, expression
, tf_warning_or_error
);
5910 = build_reinterpret_cast (type
, expression
,
5911 tf_warning_or_error
);
5915 = build_const_cast (type
, expression
, tf_warning_or_error
);
5926 const char *saved_message
;
5927 bool saved_in_type_id_in_expr_p
;
5929 /* Consume the `typeid' token. */
5930 cp_lexer_consume_token (parser
->lexer
);
5931 /* Look for the `(' token. */
5932 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
5933 /* Types cannot be defined in a `typeid' expression. */
5934 saved_message
= parser
->type_definition_forbidden_message
;
5935 parser
->type_definition_forbidden_message
5936 = G_("types may not be defined in a %<typeid%> expression");
5937 /* We can't be sure yet whether we're looking at a type-id or an
5939 cp_parser_parse_tentatively (parser
);
5940 /* Try a type-id first. */
5941 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
5942 parser
->in_type_id_in_expr_p
= true;
5943 type
= cp_parser_type_id (parser
);
5944 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
5945 /* Look for the `)' token. Otherwise, we can't be sure that
5946 we're not looking at an expression: consider `typeid (int
5947 (3))', for example. */
5948 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
5949 /* If all went well, simply lookup the type-id. */
5950 if (cp_parser_parse_definitely (parser
))
5951 postfix_expression
= get_typeid (type
, tf_warning_or_error
);
5952 /* Otherwise, fall back to the expression variant. */
5957 /* Look for an expression. */
5958 expression
= cp_parser_expression (parser
, & idk
);
5959 /* Compute its typeid. */
5960 postfix_expression
= build_typeid (expression
, tf_warning_or_error
);
5961 /* Look for the `)' token. */
5962 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
5964 /* Restore the saved message. */
5965 parser
->type_definition_forbidden_message
= saved_message
;
5966 /* `typeid' may not appear in an integral constant expression. */
5967 if (cp_parser_non_integral_constant_expression (parser
, NIC_TYPEID
))
5968 return error_mark_node
;
5975 /* The syntax permitted here is the same permitted for an
5976 elaborated-type-specifier. */
5977 type
= cp_parser_elaborated_type_specifier (parser
,
5978 /*is_friend=*/false,
5979 /*is_declaration=*/false);
5980 postfix_expression
= cp_parser_functional_cast (parser
, type
);
5984 case RID_CILK_SPAWN
:
5986 cp_lexer_consume_token (parser
->lexer
);
5987 token
= cp_lexer_peek_token (parser
->lexer
);
5988 if (token
->type
== CPP_SEMICOLON
)
5990 error_at (token
->location
, "%<_Cilk_spawn%> must be followed by "
5992 postfix_expression
= error_mark_node
;
5995 else if (!current_function_decl
)
5997 error_at (token
->location
, "%<_Cilk_spawn%> may only be used "
5998 "inside a function");
5999 postfix_expression
= error_mark_node
;
6004 /* Consecutive _Cilk_spawns are not allowed in a statement. */
6005 saved_in_statement
= parser
->in_statement
;
6006 parser
->in_statement
|= IN_CILK_SPAWN
;
6008 cfun
->calls_cilk_spawn
= 1;
6009 postfix_expression
=
6010 cp_parser_postfix_expression (parser
, false, false,
6011 false, false, &idk
);
6014 error_at (token
->location
, "-fcilkplus must be enabled to use"
6015 " %<_Cilk_spawn%>");
6016 cfun
->calls_cilk_spawn
= 0;
6018 else if (saved_in_statement
& IN_CILK_SPAWN
)
6020 error_at (token
->location
, "consecutive %<_Cilk_spawn%> keywords "
6021 "are not permitted");
6022 postfix_expression
= error_mark_node
;
6023 cfun
->calls_cilk_spawn
= 0;
6027 postfix_expression
= build_cilk_spawn (token
->location
,
6028 postfix_expression
);
6029 if (postfix_expression
!= error_mark_node
)
6030 SET_EXPR_LOCATION (postfix_expression
, input_location
);
6031 parser
->in_statement
= parser
->in_statement
& ~IN_CILK_SPAWN
;
6036 case RID_BUILTIN_SHUFFLE
:
6038 vec
<tree
, va_gc
> *vec
;
6042 cp_lexer_consume_token (parser
->lexer
);
6043 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
6044 /*cast_p=*/false, /*allow_expansion_p=*/true,
6045 /*non_constant_p=*/NULL
);
6047 return error_mark_node
;
6049 FOR_EACH_VEC_ELT (*vec
, i
, p
)
6052 if (vec
->length () == 2)
6053 return build_x_vec_perm_expr (loc
, (*vec
)[0], NULL_TREE
, (*vec
)[1],
6054 tf_warning_or_error
);
6055 else if (vec
->length () == 3)
6056 return build_x_vec_perm_expr (loc
, (*vec
)[0], (*vec
)[1], (*vec
)[2],
6057 tf_warning_or_error
);
6060 error_at (loc
, "wrong number of arguments to "
6061 "%<__builtin_shuffle%>");
6062 return error_mark_node
;
6071 /* If the next thing is a simple-type-specifier, we may be
6072 looking at a functional cast. We could also be looking at
6073 an id-expression. So, we try the functional cast, and if
6074 that doesn't work we fall back to the primary-expression. */
6075 cp_parser_parse_tentatively (parser
);
6076 /* Look for the simple-type-specifier. */
6077 type
= cp_parser_simple_type_specifier (parser
,
6078 /*decl_specs=*/NULL
,
6079 CP_PARSER_FLAGS_NONE
);
6080 /* Parse the cast itself. */
6081 if (!cp_parser_error_occurred (parser
))
6083 = cp_parser_functional_cast (parser
, type
);
6084 /* If that worked, we're done. */
6085 if (cp_parser_parse_definitely (parser
))
6088 /* If the functional-cast didn't work out, try a
6089 compound-literal. */
6090 if (cp_parser_allow_gnu_extensions_p (parser
)
6091 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
6093 tree initializer
= NULL_TREE
;
6095 cp_parser_parse_tentatively (parser
);
6097 /* Avoid calling cp_parser_type_id pointlessly, see comment
6098 in cp_parser_cast_expression about c++/29234. */
6099 if (!cp_parser_compound_literal_p (parser
))
6100 cp_parser_simulate_error (parser
);
6103 /* Parse the type. */
6104 bool saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
6105 parser
->in_type_id_in_expr_p
= true;
6106 type
= cp_parser_type_id (parser
);
6107 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
6108 /* Look for the `)'. */
6109 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
6112 /* If things aren't going well, there's no need to
6114 if (!cp_parser_error_occurred (parser
))
6116 bool non_constant_p
;
6117 /* Parse the brace-enclosed initializer list. */
6118 initializer
= cp_parser_braced_list (parser
,
6121 /* If that worked, we're definitely looking at a
6122 compound-literal expression. */
6123 if (cp_parser_parse_definitely (parser
))
6125 /* Warn the user that a compound literal is not
6126 allowed in standard C++. */
6127 pedwarn (input_location
, OPT_Wpedantic
,
6128 "ISO C++ forbids compound-literals");
6129 /* For simplicity, we disallow compound literals in
6130 constant-expressions. We could
6131 allow compound literals of integer type, whose
6132 initializer was a constant, in constant
6133 expressions. Permitting that usage, as a further
6134 extension, would not change the meaning of any
6135 currently accepted programs. (Of course, as
6136 compound literals are not part of ISO C++, the
6137 standard has nothing to say.) */
6138 if (cp_parser_non_integral_constant_expression (parser
,
6141 postfix_expression
= error_mark_node
;
6144 /* Form the representation of the compound-literal. */
6146 = finish_compound_literal (type
, initializer
,
6147 tf_warning_or_error
);
6152 /* It must be a primary-expression. */
6154 = cp_parser_primary_expression (parser
, address_p
, cast_p
,
6155 /*template_arg_p=*/false,
6162 /* Note that we don't need to worry about calling build_cplus_new on a
6163 class-valued CALL_EXPR in decltype when it isn't the end of the
6164 postfix-expression; unary_complex_lvalue will take care of that for
6167 /* Keep looping until the postfix-expression is complete. */
6170 if (idk
== CP_ID_KIND_UNQUALIFIED
6171 && identifier_p (postfix_expression
)
6172 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
))
6173 /* It is not a Koenig lookup function call. */
6175 = unqualified_name_lookup_error (postfix_expression
);
6177 /* Peek at the next token. */
6178 token
= cp_lexer_peek_token (parser
->lexer
);
6180 switch (token
->type
)
6182 case CPP_OPEN_SQUARE
:
6183 if (cp_next_tokens_can_be_std_attribute_p (parser
))
6185 cp_parser_error (parser
,
6186 "two consecutive %<[%> shall "
6187 "only introduce an attribute");
6188 return error_mark_node
;
6191 = cp_parser_postfix_open_square_expression (parser
,
6195 idk
= CP_ID_KIND_NONE
;
6196 is_member_access
= false;
6199 case CPP_OPEN_PAREN
:
6200 /* postfix-expression ( expression-list [opt] ) */
6203 bool is_builtin_constant_p
;
6204 bool saved_integral_constant_expression_p
= false;
6205 bool saved_non_integral_constant_expression_p
= false;
6206 tsubst_flags_t complain
= complain_flags (decltype_p
);
6207 vec
<tree
, va_gc
> *args
;
6209 is_member_access
= false;
6211 is_builtin_constant_p
6212 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression
);
6213 if (is_builtin_constant_p
)
6215 /* The whole point of __builtin_constant_p is to allow
6216 non-constant expressions to appear as arguments. */
6217 saved_integral_constant_expression_p
6218 = parser
->integral_constant_expression_p
;
6219 saved_non_integral_constant_expression_p
6220 = parser
->non_integral_constant_expression_p
;
6221 parser
->integral_constant_expression_p
= false;
6223 args
= (cp_parser_parenthesized_expression_list
6225 /*cast_p=*/false, /*allow_expansion_p=*/true,
6226 /*non_constant_p=*/NULL
,
6227 /*want_literal_zero_p=*/warn_memset_transposed_args
));
6228 if (is_builtin_constant_p
)
6230 parser
->integral_constant_expression_p
6231 = saved_integral_constant_expression_p
;
6232 parser
->non_integral_constant_expression_p
6233 = saved_non_integral_constant_expression_p
;
6238 postfix_expression
= error_mark_node
;
6242 /* Function calls are not permitted in
6243 constant-expressions. */
6244 if (! builtin_valid_in_constant_expr_p (postfix_expression
)
6245 && cp_parser_non_integral_constant_expression (parser
,
6248 postfix_expression
= error_mark_node
;
6249 release_tree_vector (args
);
6254 if (idk
== CP_ID_KIND_UNQUALIFIED
6255 || idk
== CP_ID_KIND_TEMPLATE_ID
)
6257 if (identifier_p (postfix_expression
))
6259 if (!args
->is_empty ())
6262 if (!any_type_dependent_arguments_p (args
))
6264 = perform_koenig_lookup (postfix_expression
, args
,
6269 = unqualified_fn_lookup_error (postfix_expression
);
6271 /* We do not perform argument-dependent lookup if
6272 normal lookup finds a non-function, in accordance
6273 with the expected resolution of DR 218. */
6274 else if (!args
->is_empty ()
6275 && is_overloaded_fn (postfix_expression
))
6277 tree fn
= get_first_fn (postfix_expression
);
6278 fn
= STRIP_TEMPLATE (fn
);
6280 /* Do not do argument dependent lookup if regular
6281 lookup finds a member function or a block-scope
6282 function declaration. [basic.lookup.argdep]/3 */
6283 if (!DECL_FUNCTION_MEMBER_P (fn
)
6284 && !DECL_LOCAL_FUNCTION_P (fn
))
6287 if (!any_type_dependent_arguments_p (args
))
6289 = perform_koenig_lookup (postfix_expression
, args
,
6295 if (warn_memset_transposed_args
)
6297 if (TREE_CODE (postfix_expression
) == FUNCTION_DECL
6298 && DECL_BUILT_IN_CLASS (postfix_expression
) == BUILT_IN_NORMAL
6299 && DECL_FUNCTION_CODE (postfix_expression
) == BUILT_IN_MEMSET
6300 && vec_safe_length (args
) == 3
6301 && integer_zerop ((*args
)[2])
6302 && LITERAL_ZERO_P ((*args
)[2])
6303 && !(integer_zerop ((*args
)[1])
6304 && LITERAL_ZERO_P ((*args
)[1])))
6305 warning (OPT_Wmemset_transposed_args
,
6306 "%<memset%> used with constant zero length "
6307 "parameter; this could be due to transposed "
6310 /* Replace LITERAL_ZERO_P INTEGER_CSTs with normal ones
6311 to avoid leaking those into folder and middle-end. */
6314 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
6315 if (TREE_CODE (arg
) == INTEGER_CST
&& LITERAL_ZERO_P (arg
))
6316 (*args
)[i
] = build_int_cst (TREE_TYPE (arg
), 0);
6319 if (TREE_CODE (postfix_expression
) == COMPONENT_REF
)
6321 tree instance
= TREE_OPERAND (postfix_expression
, 0);
6322 tree fn
= TREE_OPERAND (postfix_expression
, 1);
6324 if (processing_template_decl
6325 && (type_dependent_expression_p (instance
)
6326 || (!BASELINK_P (fn
)
6327 && TREE_CODE (fn
) != FIELD_DECL
)
6328 || type_dependent_expression_p (fn
)
6329 || any_type_dependent_arguments_p (args
)))
6332 = build_nt_call_vec (postfix_expression
, args
);
6333 release_tree_vector (args
);
6337 if (BASELINK_P (fn
))
6340 = (build_new_method_call
6341 (instance
, fn
, &args
, NULL_TREE
,
6342 (idk
== CP_ID_KIND_QUALIFIED
6343 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
6350 = finish_call_expr (postfix_expression
, &args
,
6351 /*disallow_virtual=*/false,
6355 else if (TREE_CODE (postfix_expression
) == OFFSET_REF
6356 || TREE_CODE (postfix_expression
) == MEMBER_REF
6357 || TREE_CODE (postfix_expression
) == DOTSTAR_EXPR
)
6358 postfix_expression
= (build_offset_ref_call_from_tree
6359 (postfix_expression
, &args
,
6361 else if (idk
== CP_ID_KIND_QUALIFIED
)
6362 /* A call to a static class member, or a namespace-scope
6365 = finish_call_expr (postfix_expression
, &args
,
6366 /*disallow_virtual=*/true,
6370 /* All other function calls. */
6372 = finish_call_expr (postfix_expression
, &args
,
6373 /*disallow_virtual=*/false,
6377 protected_set_expr_location (postfix_expression
, token
->location
);
6379 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
6380 idk
= CP_ID_KIND_NONE
;
6382 release_tree_vector (args
);
6388 /* postfix-expression . template [opt] id-expression
6389 postfix-expression . pseudo-destructor-name
6390 postfix-expression -> template [opt] id-expression
6391 postfix-expression -> pseudo-destructor-name */
6393 /* Consume the `.' or `->' operator. */
6394 cp_lexer_consume_token (parser
->lexer
);
6397 = cp_parser_postfix_dot_deref_expression (parser
, token
->type
,
6401 is_member_access
= true;
6405 /* postfix-expression ++ */
6406 /* Consume the `++' token. */
6407 cp_lexer_consume_token (parser
->lexer
);
6408 /* Generate a representation for the complete expression. */
6410 = finish_increment_expr (postfix_expression
,
6411 POSTINCREMENT_EXPR
);
6412 /* Increments may not appear in constant-expressions. */
6413 if (cp_parser_non_integral_constant_expression (parser
, NIC_INC
))
6414 postfix_expression
= error_mark_node
;
6415 idk
= CP_ID_KIND_NONE
;
6416 is_member_access
= false;
6419 case CPP_MINUS_MINUS
:
6420 /* postfix-expression -- */
6421 /* Consume the `--' token. */
6422 cp_lexer_consume_token (parser
->lexer
);
6423 /* Generate a representation for the complete expression. */
6425 = finish_increment_expr (postfix_expression
,
6426 POSTDECREMENT_EXPR
);
6427 /* Decrements may not appear in constant-expressions. */
6428 if (cp_parser_non_integral_constant_expression (parser
, NIC_DEC
))
6429 postfix_expression
= error_mark_node
;
6430 idk
= CP_ID_KIND_NONE
;
6431 is_member_access
= false;
6435 if (pidk_return
!= NULL
)
6436 * pidk_return
= idk
;
6437 if (member_access_only_p
)
6438 return is_member_access
? postfix_expression
: error_mark_node
;
6440 return postfix_expression
;
6444 /* We should never get here. */
6446 return error_mark_node
;
6449 /* This function parses Cilk Plus array notations. If a normal array expr. is
6450 parsed then the array index is passed back to the caller through *INIT_INDEX
6451 and the function returns a NULL_TREE. If array notation expr. is parsed,
6452 then *INIT_INDEX is ignored by the caller and the function returns
6453 a tree of type ARRAY_NOTATION_REF. If some error occurred it returns
6457 cp_parser_array_notation (location_t loc
, cp_parser
*parser
, tree
*init_index
,
6460 cp_token
*token
= NULL
;
6461 tree length_index
, stride
= NULL_TREE
, value_tree
, array_type
;
6462 if (!array_value
|| array_value
== error_mark_node
)
6464 cp_parser_skip_to_end_of_statement (parser
);
6465 return error_mark_node
;
6468 array_type
= TREE_TYPE (array_value
);
6470 bool saved_colon_corrects
= parser
->colon_corrects_to_scope_p
;
6471 parser
->colon_corrects_to_scope_p
= false;
6472 token
= cp_lexer_peek_token (parser
->lexer
);
6476 cp_parser_error (parser
, "expected %<:%> or numeral");
6477 return error_mark_node
;
6479 else if (token
->type
== CPP_COLON
)
6481 /* Consume the ':'. */
6482 cp_lexer_consume_token (parser
->lexer
);
6484 /* If we are here, then we have a case like this A[:]. */
6485 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_CLOSE_SQUARE
)
6487 cp_parser_error (parser
, "expected %<]%>");
6488 cp_parser_skip_to_end_of_statement (parser
);
6489 return error_mark_node
;
6491 *init_index
= NULL_TREE
;
6493 length_index
= NULL_TREE
;
6497 /* If we are here, then there are three valid possibilities:
6499 2. ARRAY [ EXP : EXP ]
6500 3. ARRAY [ EXP : EXP : EXP ] */
6502 *init_index
= cp_parser_expression (parser
);
6503 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_COLON
)
6505 /* This indicates that we have a normal array expression. */
6506 parser
->colon_corrects_to_scope_p
= saved_colon_corrects
;
6510 /* Consume the ':'. */
6511 cp_lexer_consume_token (parser
->lexer
);
6512 length_index
= cp_parser_expression (parser
);
6513 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_COLON
)
6515 cp_lexer_consume_token (parser
->lexer
);
6516 stride
= cp_parser_expression (parser
);
6519 parser
->colon_corrects_to_scope_p
= saved_colon_corrects
;
6521 if (*init_index
== error_mark_node
|| length_index
== error_mark_node
6522 || stride
== error_mark_node
|| array_type
== error_mark_node
)
6524 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_SQUARE
)
6525 cp_lexer_consume_token (parser
->lexer
);
6526 return error_mark_node
;
6528 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
6530 value_tree
= build_array_notation_ref (loc
, array_value
, *init_index
,
6531 length_index
, stride
, array_type
);
6535 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6536 by cp_parser_builtin_offsetof. We're looking for
6538 postfix-expression [ expression ]
6539 postfix-expression [ braced-init-list ] (C++11)
6541 FOR_OFFSETOF is set if we're being called in that context, which
6542 changes how we deal with integer constant expressions. */
6545 cp_parser_postfix_open_square_expression (cp_parser
*parser
,
6546 tree postfix_expression
,
6550 tree index
= NULL_TREE
;
6551 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
6552 bool saved_greater_than_is_operator_p
;
6554 /* Consume the `[' token. */
6555 cp_lexer_consume_token (parser
->lexer
);
6557 saved_greater_than_is_operator_p
= parser
->greater_than_is_operator_p
;
6558 parser
->greater_than_is_operator_p
= true;
6560 /* Parse the index expression. */
6561 /* ??? For offsetof, there is a question of what to allow here. If
6562 offsetof is not being used in an integral constant expression context,
6563 then we *could* get the right answer by computing the value at runtime.
6564 If we are in an integral constant expression context, then we might
6565 could accept any constant expression; hard to say without analysis.
6566 Rather than open the barn door too wide right away, allow only integer
6567 constant expressions here. */
6569 index
= cp_parser_constant_expression (parser
);
6572 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
6574 bool expr_nonconst_p
;
6575 cp_lexer_set_source_position (parser
->lexer
);
6576 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6577 index
= cp_parser_braced_list (parser
, &expr_nonconst_p
);
6579 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_COLON
)
6581 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
6582 "braced list index is not allowed with array "
6584 cp_parser_skip_to_end_of_statement (parser
);
6585 return error_mark_node
;
6588 else if (flag_cilkplus
)
6590 /* Here are have these two options:
6591 ARRAY[EXP : EXP] - Array notation expr with default
6593 ARRAY[EXP : EXP : EXP] - Array Notation with user-defined
6595 tree an_exp
= cp_parser_array_notation (loc
, parser
, &index
,
6596 postfix_expression
);
6601 index
= cp_parser_expression (parser
);
6604 parser
->greater_than_is_operator_p
= saved_greater_than_is_operator_p
;
6606 /* Look for the closing `]'. */
6607 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
6609 /* Build the ARRAY_REF. */
6610 postfix_expression
= grok_array_decl (loc
, postfix_expression
,
6613 /* When not doing offsetof, array references are not permitted in
6614 constant-expressions. */
6616 && (cp_parser_non_integral_constant_expression (parser
, NIC_ARRAY_REF
)))
6617 postfix_expression
= error_mark_node
;
6619 return postfix_expression
;
6622 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6623 by cp_parser_builtin_offsetof. We're looking for
6625 postfix-expression . template [opt] id-expression
6626 postfix-expression . pseudo-destructor-name
6627 postfix-expression -> template [opt] id-expression
6628 postfix-expression -> pseudo-destructor-name
6630 FOR_OFFSETOF is set if we're being called in that context. That sorta
6631 limits what of the above we'll actually accept, but nevermind.
6632 TOKEN_TYPE is the "." or "->" token, which will already have been
6633 removed from the stream. */
6636 cp_parser_postfix_dot_deref_expression (cp_parser
*parser
,
6637 enum cpp_ttype token_type
,
6638 tree postfix_expression
,
6639 bool for_offsetof
, cp_id_kind
*idk
,
6640 location_t location
)
6644 bool pseudo_destructor_p
;
6645 tree scope
= NULL_TREE
;
6647 /* If this is a `->' operator, dereference the pointer. */
6648 if (token_type
== CPP_DEREF
)
6649 postfix_expression
= build_x_arrow (location
, postfix_expression
,
6650 tf_warning_or_error
);
6651 /* Check to see whether or not the expression is type-dependent. */
6652 dependent_p
= type_dependent_expression_p (postfix_expression
);
6653 /* The identifier following the `->' or `.' is not qualified. */
6654 parser
->scope
= NULL_TREE
;
6655 parser
->qualifying_scope
= NULL_TREE
;
6656 parser
->object_scope
= NULL_TREE
;
6657 *idk
= CP_ID_KIND_NONE
;
6659 /* Enter the scope corresponding to the type of the object
6660 given by the POSTFIX_EXPRESSION. */
6661 if (!dependent_p
&& TREE_TYPE (postfix_expression
) != NULL_TREE
)
6663 scope
= TREE_TYPE (postfix_expression
);
6664 /* According to the standard, no expression should ever have
6665 reference type. Unfortunately, we do not currently match
6666 the standard in this respect in that our internal representation
6667 of an expression may have reference type even when the standard
6668 says it does not. Therefore, we have to manually obtain the
6669 underlying type here. */
6670 scope
= non_reference (scope
);
6671 /* The type of the POSTFIX_EXPRESSION must be complete. */
6672 if (scope
== unknown_type_node
)
6674 error_at (location
, "%qE does not have class type",
6675 postfix_expression
);
6678 /* Unlike the object expression in other contexts, *this is not
6679 required to be of complete type for purposes of class member
6680 access (5.2.5) outside the member function body. */
6681 else if (postfix_expression
!= current_class_ref
6682 && !(processing_template_decl
&& scope
== current_class_type
))
6683 scope
= complete_type_or_else (scope
, NULL_TREE
);
6684 /* Let the name lookup machinery know that we are processing a
6685 class member access expression. */
6686 parser
->context
->object_type
= scope
;
6687 /* If something went wrong, we want to be able to discern that case,
6688 as opposed to the case where there was no SCOPE due to the type
6689 of expression being dependent. */
6691 scope
= error_mark_node
;
6692 /* If the SCOPE was erroneous, make the various semantic analysis
6693 functions exit quickly -- and without issuing additional error
6695 if (scope
== error_mark_node
)
6696 postfix_expression
= error_mark_node
;
6699 /* Assume this expression is not a pseudo-destructor access. */
6700 pseudo_destructor_p
= false;
6702 /* If the SCOPE is a scalar type, then, if this is a valid program,
6703 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
6704 is type dependent, it can be pseudo-destructor-name or something else.
6705 Try to parse it as pseudo-destructor-name first. */
6706 if ((scope
&& SCALAR_TYPE_P (scope
)) || dependent_p
)
6711 cp_parser_parse_tentatively (parser
);
6712 /* Parse the pseudo-destructor-name. */
6714 cp_parser_pseudo_destructor_name (parser
, postfix_expression
,
6717 && (cp_parser_error_occurred (parser
)
6718 || !SCALAR_TYPE_P (type
)))
6719 cp_parser_abort_tentative_parse (parser
);
6720 else if (cp_parser_parse_definitely (parser
))
6722 pseudo_destructor_p
= true;
6724 = finish_pseudo_destructor_expr (postfix_expression
,
6729 if (!pseudo_destructor_p
)
6731 /* If the SCOPE is not a scalar type, we are looking at an
6732 ordinary class member access expression, rather than a
6733 pseudo-destructor-name. */
6735 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
6736 /* Parse the id-expression. */
6737 name
= (cp_parser_id_expression
6739 cp_parser_optional_template_keyword (parser
),
6740 /*check_dependency_p=*/true,
6742 /*declarator_p=*/false,
6743 /*optional_p=*/false));
6744 /* In general, build a SCOPE_REF if the member name is qualified.
6745 However, if the name was not dependent and has already been
6746 resolved; there is no need to build the SCOPE_REF. For example;
6748 struct X { void f(); };
6749 template <typename T> void f(T* t) { t->X::f(); }
6751 Even though "t" is dependent, "X::f" is not and has been resolved
6752 to a BASELINK; there is no need to include scope information. */
6754 /* But we do need to remember that there was an explicit scope for
6755 virtual function calls. */
6757 *idk
= CP_ID_KIND_QUALIFIED
;
6759 /* If the name is a template-id that names a type, we will get a
6760 TYPE_DECL here. That is invalid code. */
6761 if (TREE_CODE (name
) == TYPE_DECL
)
6763 error_at (token
->location
, "invalid use of %qD", name
);
6764 postfix_expression
= error_mark_node
;
6768 if (name
!= error_mark_node
&& !BASELINK_P (name
) && parser
->scope
)
6770 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
6772 error_at (token
->location
, "%<%D::%D%> is not a class member",
6773 parser
->scope
, name
);
6774 postfix_expression
= error_mark_node
;
6777 name
= build_qualified_name (/*type=*/NULL_TREE
,
6781 parser
->scope
= NULL_TREE
;
6782 parser
->qualifying_scope
= NULL_TREE
;
6783 parser
->object_scope
= NULL_TREE
;
6785 if (parser
->scope
&& name
&& BASELINK_P (name
))
6786 adjust_result_of_qualified_name_lookup
6787 (name
, parser
->scope
, scope
);
6789 = finish_class_member_access_expr (postfix_expression
, name
,
6791 tf_warning_or_error
);
6795 /* We no longer need to look up names in the scope of the object on
6796 the left-hand side of the `.' or `->' operator. */
6797 parser
->context
->object_type
= NULL_TREE
;
6799 /* Outside of offsetof, these operators may not appear in
6800 constant-expressions. */
6802 && (cp_parser_non_integral_constant_expression
6803 (parser
, token_type
== CPP_DEREF
? NIC_ARROW
: NIC_POINT
)))
6804 postfix_expression
= error_mark_node
;
6806 return postfix_expression
;
6809 /* Cache of LITERAL_ZERO_P constants. */
6811 static GTY(()) tree literal_zeros
[itk_none
];
6813 /* Parse a parenthesized expression-list.
6816 assignment-expression
6817 expression-list, assignment-expression
6822 identifier, expression-list
6824 CAST_P is true if this expression is the target of a cast.
6826 ALLOW_EXPANSION_P is true if this expression allows expansion of an
6829 Returns a vector of trees. Each element is a representation of an
6830 assignment-expression. NULL is returned if the ( and or ) are
6831 missing. An empty, but allocated, vector is returned on no
6832 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
6833 if we are parsing an attribute list for an attribute that wants a
6834 plain identifier argument, normal_attr for an attribute that wants
6835 an expression, or non_attr if we aren't parsing an attribute list. If
6836 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
6837 not all of the expressions in the list were constant.
6838 WANT_LITERAL_ZERO_P is true if the caller is interested in
6839 LITERAL_ZERO_P INTEGER_CSTs. FIXME: once we don't fold everything
6840 immediately, this can be removed. */
6842 static vec
<tree
, va_gc
> *
6843 cp_parser_parenthesized_expression_list (cp_parser
* parser
,
6844 int is_attribute_list
,
6846 bool allow_expansion_p
,
6847 bool *non_constant_p
,
6848 bool want_literal_zero_p
)
6850 vec
<tree
, va_gc
> *expression_list
;
6851 bool fold_expr_p
= is_attribute_list
!= non_attr
;
6852 tree identifier
= NULL_TREE
;
6853 bool saved_greater_than_is_operator_p
;
6855 /* Assume all the expressions will be constant. */
6857 *non_constant_p
= false;
6859 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
6862 expression_list
= make_tree_vector ();
6864 /* Within a parenthesized expression, a `>' token is always
6865 the greater-than operator. */
6866 saved_greater_than_is_operator_p
6867 = parser
->greater_than_is_operator_p
;
6868 parser
->greater_than_is_operator_p
= true;
6870 /* Consume expressions until there are no more. */
6871 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
6876 /* At the beginning of attribute lists, check to see if the
6877 next token is an identifier. */
6878 if (is_attribute_list
== id_attr
6879 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_NAME
)
6883 /* Consume the identifier. */
6884 token
= cp_lexer_consume_token (parser
->lexer
);
6885 /* Save the identifier. */
6886 identifier
= token
->u
.value
;
6890 bool expr_non_constant_p
;
6892 /* Parse the next assignment-expression. */
6893 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
6895 /* A braced-init-list. */
6896 cp_lexer_set_source_position (parser
->lexer
);
6897 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6898 expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
6899 if (non_constant_p
&& expr_non_constant_p
)
6900 *non_constant_p
= true;
6902 else if (non_constant_p
)
6904 expr
= (cp_parser_constant_expression
6905 (parser
, /*allow_non_constant_p=*/true,
6906 &expr_non_constant_p
));
6907 if (expr_non_constant_p
)
6908 *non_constant_p
= true;
6913 cp_token
*tok
= cp_lexer_peek_token (parser
->lexer
);
6921 /* If a parameter is literal zero alone, remember it
6922 for -Wmemset-transposed-args warning. */
6923 if (integer_zerop (tok
->u
.value
)
6924 && !TREE_OVERFLOW (tok
->u
.value
)
6925 && want_literal_zero_p
6926 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
6928 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
6929 == CPP_CLOSE_PAREN
))
6932 for (i
= 0; i
< itk_none
; ++i
)
6933 if (TREE_TYPE (tok
->u
.value
) == integer_types
[i
])
6935 if (i
< itk_none
&& literal_zeros
[i
])
6936 expr
= literal_zeros
[i
];
6939 expr
= copy_node (tok
->u
.value
);
6940 LITERAL_ZERO_P (expr
) = 1;
6942 literal_zeros
[i
] = expr
;
6944 /* Consume the 0 token (or '\0', 0LL etc.). */
6945 cp_lexer_consume_token (parser
->lexer
);
6951 if (expr
== NULL_TREE
)
6952 expr
= cp_parser_assignment_expression (parser
, /*pidk=*/NULL
,
6957 expr
= instantiate_non_dependent_expr (expr
);
6959 /* If we have an ellipsis, then this is an expression
6961 if (allow_expansion_p
6962 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
6964 /* Consume the `...'. */
6965 cp_lexer_consume_token (parser
->lexer
);
6967 /* Build the argument pack. */
6968 expr
= make_pack_expansion (expr
);
6971 /* Add it to the list. We add error_mark_node
6972 expressions to the list, so that we can still tell if
6973 the correct form for a parenthesized expression-list
6974 is found. That gives better errors. */
6975 vec_safe_push (expression_list
, expr
);
6977 if (expr
== error_mark_node
)
6981 /* After the first item, attribute lists look the same as
6982 expression lists. */
6983 is_attribute_list
= non_attr
;
6986 /* If the next token isn't a `,', then we are done. */
6987 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
6990 /* Otherwise, consume the `,' and keep going. */
6991 cp_lexer_consume_token (parser
->lexer
);
6994 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
6999 /* We try and resync to an unnested comma, as that will give the
7000 user better diagnostics. */
7001 ending
= cp_parser_skip_to_closing_parenthesis (parser
,
7002 /*recovering=*/true,
7004 /*consume_paren=*/true);
7009 parser
->greater_than_is_operator_p
7010 = saved_greater_than_is_operator_p
;
7015 parser
->greater_than_is_operator_p
7016 = saved_greater_than_is_operator_p
;
7019 vec_safe_insert (expression_list
, 0, identifier
);
7021 return expression_list
;
7024 /* Parse a pseudo-destructor-name.
7026 pseudo-destructor-name:
7027 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
7028 :: [opt] nested-name-specifier template template-id :: ~ type-name
7029 :: [opt] nested-name-specifier [opt] ~ type-name
7031 If either of the first two productions is used, sets *SCOPE to the
7032 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
7033 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
7034 or ERROR_MARK_NODE if the parse fails. */
7037 cp_parser_pseudo_destructor_name (cp_parser
* parser
,
7042 bool nested_name_specifier_p
;
7045 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMPL
)
7046 && cp_lexer_nth_token_is_keyword (parser
->lexer
, 2, RID_AUTO
)
7047 && !type_dependent_expression_p (object
))
7049 if (cxx_dialect
< cxx14
)
7050 pedwarn (input_location
, 0,
7051 "%<~auto%> only available with "
7052 "-std=c++14 or -std=gnu++14");
7053 cp_lexer_consume_token (parser
->lexer
);
7054 cp_lexer_consume_token (parser
->lexer
);
7056 *type
= TREE_TYPE (object
);
7060 /* Assume that things will not work out. */
7061 *type
= error_mark_node
;
7063 /* Look for the optional `::' operator. */
7064 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/true);
7065 /* Look for the optional nested-name-specifier. */
7066 nested_name_specifier_p
7067 = (cp_parser_nested_name_specifier_opt (parser
,
7068 /*typename_keyword_p=*/false,
7069 /*check_dependency_p=*/true,
7071 /*is_declaration=*/false)
7073 /* Now, if we saw a nested-name-specifier, we might be doing the
7074 second production. */
7075 if (nested_name_specifier_p
7076 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
7078 /* Consume the `template' keyword. */
7079 cp_lexer_consume_token (parser
->lexer
);
7080 /* Parse the template-id. */
7081 cp_parser_template_id (parser
,
7082 /*template_keyword_p=*/true,
7083 /*check_dependency_p=*/false,
7085 /*is_declaration=*/true);
7086 /* Look for the `::' token. */
7087 cp_parser_require (parser
, CPP_SCOPE
, RT_SCOPE
);
7089 /* If the next token is not a `~', then there might be some
7090 additional qualification. */
7091 else if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMPL
))
7093 /* At this point, we're looking for "type-name :: ~". The type-name
7094 must not be a class-name, since this is a pseudo-destructor. So,
7095 it must be either an enum-name, or a typedef-name -- both of which
7096 are just identifiers. So, we peek ahead to check that the "::"
7097 and "~" tokens are present; if they are not, then we can avoid
7098 calling type_name. */
7099 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_NAME
7100 || cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
7101 || cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
!= CPP_COMPL
)
7103 cp_parser_error (parser
, "non-scalar type");
7107 /* Look for the type-name. */
7108 *scope
= TREE_TYPE (cp_parser_nonclass_name (parser
));
7109 if (*scope
== error_mark_node
)
7112 /* Look for the `::' token. */
7113 cp_parser_require (parser
, CPP_SCOPE
, RT_SCOPE
);
7118 /* Look for the `~'. */
7119 cp_parser_require (parser
, CPP_COMPL
, RT_COMPL
);
7121 /* Once we see the ~, this has to be a pseudo-destructor. */
7122 if (!processing_template_decl
&& !cp_parser_error_occurred (parser
))
7123 cp_parser_commit_to_topmost_tentative_parse (parser
);
7125 /* Look for the type-name again. We are not responsible for
7126 checking that it matches the first type-name. */
7127 *type
= TREE_TYPE (cp_parser_nonclass_name (parser
));
7130 /* Parse a unary-expression.
7136 unary-operator cast-expression
7137 sizeof unary-expression
7139 alignof ( type-id ) [C++0x]
7146 __extension__ cast-expression
7147 __alignof__ unary-expression
7148 __alignof__ ( type-id )
7149 alignof unary-expression [C++0x]
7150 __real__ cast-expression
7151 __imag__ cast-expression
7153 sizeof ( type-id ) { initializer-list , [opt] }
7154 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
7155 __alignof__ ( type-id ) { initializer-list , [opt] }
7157 ADDRESS_P is true iff the unary-expression is appearing as the
7158 operand of the `&' operator. CAST_P is true if this expression is
7159 the target of a cast.
7161 Returns a representation of the expression. */
7164 cp_parser_unary_expression (cp_parser
*parser
, cp_id_kind
* pidk
,
7165 bool address_p
, bool cast_p
, bool decltype_p
)
7168 enum tree_code unary_operator
;
7170 /* Peek at the next token. */
7171 token
= cp_lexer_peek_token (parser
->lexer
);
7172 /* Some keywords give away the kind of expression. */
7173 if (token
->type
== CPP_KEYWORD
)
7175 enum rid keyword
= token
->keyword
;
7184 location_t first_loc
;
7186 op
= keyword
== RID_ALIGNOF
? ALIGNOF_EXPR
: SIZEOF_EXPR
;
7187 /* Consume the token. */
7188 cp_lexer_consume_token (parser
->lexer
);
7189 first_loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
7190 /* Parse the operand. */
7191 operand
= cp_parser_sizeof_operand (parser
, keyword
);
7193 if (TYPE_P (operand
))
7194 ret
= cxx_sizeof_or_alignof_type (operand
, op
, true);
7197 /* ISO C++ defines alignof only with types, not with
7198 expressions. So pedwarn if alignof is used with a non-
7199 type expression. However, __alignof__ is ok. */
7200 if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "alignof"))
7201 pedwarn (token
->location
, OPT_Wpedantic
,
7202 "ISO C++ does not allow %<alignof%> "
7205 ret
= cxx_sizeof_or_alignof_expr (operand
, op
, true);
7207 /* For SIZEOF_EXPR, just issue diagnostics, but keep
7208 SIZEOF_EXPR with the original operand. */
7209 if (op
== SIZEOF_EXPR
&& ret
!= error_mark_node
)
7211 if (TREE_CODE (ret
) != SIZEOF_EXPR
|| TYPE_P (operand
))
7213 if (!processing_template_decl
&& TYPE_P (operand
))
7215 ret
= build_min (SIZEOF_EXPR
, size_type_node
,
7216 build1 (NOP_EXPR
, operand
,
7218 SIZEOF_EXPR_TYPE_P (ret
) = 1;
7221 ret
= build_min (SIZEOF_EXPR
, size_type_node
, operand
);
7222 TREE_SIDE_EFFECTS (ret
) = 0;
7223 TREE_READONLY (ret
) = 1;
7225 SET_EXPR_LOCATION (ret
, first_loc
);
7231 return cp_parser_new_expression (parser
);
7234 return cp_parser_delete_expression (parser
);
7238 /* The saved value of the PEDANTIC flag. */
7242 /* Save away the PEDANTIC flag. */
7243 cp_parser_extension_opt (parser
, &saved_pedantic
);
7244 /* Parse the cast-expression. */
7245 expr
= cp_parser_simple_cast_expression (parser
);
7246 /* Restore the PEDANTIC flag. */
7247 pedantic
= saved_pedantic
;
7257 /* Consume the `__real__' or `__imag__' token. */
7258 cp_lexer_consume_token (parser
->lexer
);
7259 /* Parse the cast-expression. */
7260 expression
= cp_parser_simple_cast_expression (parser
);
7261 /* Create the complete representation. */
7262 return build_x_unary_op (token
->location
,
7263 (keyword
== RID_REALPART
7264 ? REALPART_EXPR
: IMAGPART_EXPR
),
7266 tf_warning_or_error
);
7270 case RID_TRANSACTION_ATOMIC
:
7271 case RID_TRANSACTION_RELAXED
:
7272 return cp_parser_transaction_expression (parser
, keyword
);
7277 const char *saved_message
;
7278 bool saved_integral_constant_expression_p
;
7279 bool saved_non_integral_constant_expression_p
;
7280 bool saved_greater_than_is_operator_p
;
7282 cp_lexer_consume_token (parser
->lexer
);
7283 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
7285 saved_message
= parser
->type_definition_forbidden_message
;
7286 parser
->type_definition_forbidden_message
7287 = G_("types may not be defined in %<noexcept%> expressions");
7289 saved_integral_constant_expression_p
7290 = parser
->integral_constant_expression_p
;
7291 saved_non_integral_constant_expression_p
7292 = parser
->non_integral_constant_expression_p
;
7293 parser
->integral_constant_expression_p
= false;
7295 saved_greater_than_is_operator_p
7296 = parser
->greater_than_is_operator_p
;
7297 parser
->greater_than_is_operator_p
= true;
7299 ++cp_unevaluated_operand
;
7300 ++c_inhibit_evaluation_warnings
;
7301 ++cp_noexcept_operand
;
7302 expr
= cp_parser_expression (parser
);
7303 --cp_noexcept_operand
;
7304 --c_inhibit_evaluation_warnings
;
7305 --cp_unevaluated_operand
;
7307 parser
->greater_than_is_operator_p
7308 = saved_greater_than_is_operator_p
;
7310 parser
->integral_constant_expression_p
7311 = saved_integral_constant_expression_p
;
7312 parser
->non_integral_constant_expression_p
7313 = saved_non_integral_constant_expression_p
;
7315 parser
->type_definition_forbidden_message
= saved_message
;
7317 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
7318 return finish_noexcept_expr (expr
, tf_warning_or_error
);
7326 /* Look for the `:: new' and `:: delete', which also signal the
7327 beginning of a new-expression, or delete-expression,
7328 respectively. If the next token is `::', then it might be one of
7330 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
7334 /* See if the token after the `::' is one of the keywords in
7335 which we're interested. */
7336 keyword
= cp_lexer_peek_nth_token (parser
->lexer
, 2)->keyword
;
7337 /* If it's `new', we have a new-expression. */
7338 if (keyword
== RID_NEW
)
7339 return cp_parser_new_expression (parser
);
7340 /* Similarly, for `delete'. */
7341 else if (keyword
== RID_DELETE
)
7342 return cp_parser_delete_expression (parser
);
7345 /* Look for a unary operator. */
7346 unary_operator
= cp_parser_unary_operator (token
);
7347 /* The `++' and `--' operators can be handled similarly, even though
7348 they are not technically unary-operators in the grammar. */
7349 if (unary_operator
== ERROR_MARK
)
7351 if (token
->type
== CPP_PLUS_PLUS
)
7352 unary_operator
= PREINCREMENT_EXPR
;
7353 else if (token
->type
== CPP_MINUS_MINUS
)
7354 unary_operator
= PREDECREMENT_EXPR
;
7355 /* Handle the GNU address-of-label extension. */
7356 else if (cp_parser_allow_gnu_extensions_p (parser
)
7357 && token
->type
== CPP_AND_AND
)
7361 location_t loc
= token
->location
;
7363 /* Consume the '&&' token. */
7364 cp_lexer_consume_token (parser
->lexer
);
7365 /* Look for the identifier. */
7366 identifier
= cp_parser_identifier (parser
);
7367 /* Create an expression representing the address. */
7368 expression
= finish_label_address_expr (identifier
, loc
);
7369 if (cp_parser_non_integral_constant_expression (parser
,
7371 expression
= error_mark_node
;
7375 if (unary_operator
!= ERROR_MARK
)
7377 tree cast_expression
;
7378 tree expression
= error_mark_node
;
7379 non_integral_constant non_constant_p
= NIC_NONE
;
7380 location_t loc
= token
->location
;
7381 tsubst_flags_t complain
= complain_flags (decltype_p
);
7383 /* Consume the operator token. */
7384 token
= cp_lexer_consume_token (parser
->lexer
);
7385 /* Parse the cast-expression. */
7387 = cp_parser_cast_expression (parser
,
7388 unary_operator
== ADDR_EXPR
,
7392 /* Now, build an appropriate representation. */
7393 switch (unary_operator
)
7396 non_constant_p
= NIC_STAR
;
7397 expression
= build_x_indirect_ref (loc
, cast_expression
,
7403 non_constant_p
= NIC_ADDR
;
7406 expression
= build_x_unary_op (loc
, unary_operator
,
7411 case PREINCREMENT_EXPR
:
7412 case PREDECREMENT_EXPR
:
7413 non_constant_p
= unary_operator
== PREINCREMENT_EXPR
7414 ? NIC_PREINCREMENT
: NIC_PREDECREMENT
;
7416 case UNARY_PLUS_EXPR
:
7418 case TRUTH_NOT_EXPR
:
7419 expression
= finish_unary_op_expr (loc
, unary_operator
,
7420 cast_expression
, complain
);
7427 if (non_constant_p
!= NIC_NONE
7428 && cp_parser_non_integral_constant_expression (parser
,
7430 expression
= error_mark_node
;
7435 return cp_parser_postfix_expression (parser
, address_p
, cast_p
,
7436 /*member_access_only_p=*/false,
7441 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
7442 unary-operator, the corresponding tree code is returned. */
7444 static enum tree_code
7445 cp_parser_unary_operator (cp_token
* token
)
7447 switch (token
->type
)
7450 return INDIRECT_REF
;
7456 return UNARY_PLUS_EXPR
;
7462 return TRUTH_NOT_EXPR
;
7465 return BIT_NOT_EXPR
;
7472 /* Parse a new-expression.
7475 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
7476 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
7478 Returns a representation of the expression. */
7481 cp_parser_new_expression (cp_parser
* parser
)
7483 bool global_scope_p
;
7484 vec
<tree
, va_gc
> *placement
;
7486 vec
<tree
, va_gc
> *initializer
;
7487 tree nelts
= NULL_TREE
;
7490 /* Look for the optional `::' operator. */
7492 = (cp_parser_global_scope_opt (parser
,
7493 /*current_scope_valid_p=*/false)
7495 /* Look for the `new' operator. */
7496 cp_parser_require_keyword (parser
, RID_NEW
, RT_NEW
);
7497 /* There's no easy way to tell a new-placement from the
7498 `( type-id )' construct. */
7499 cp_parser_parse_tentatively (parser
);
7500 /* Look for a new-placement. */
7501 placement
= cp_parser_new_placement (parser
);
7502 /* If that didn't work out, there's no new-placement. */
7503 if (!cp_parser_parse_definitely (parser
))
7505 if (placement
!= NULL
)
7506 release_tree_vector (placement
);
7510 /* If the next token is a `(', then we have a parenthesized
7512 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
7515 const char *saved_message
= parser
->type_definition_forbidden_message
;
7517 /* Consume the `('. */
7518 cp_lexer_consume_token (parser
->lexer
);
7520 /* Parse the type-id. */
7521 parser
->type_definition_forbidden_message
7522 = G_("types may not be defined in a new-expression");
7523 type
= cp_parser_type_id (parser
);
7524 parser
->type_definition_forbidden_message
= saved_message
;
7526 /* Look for the closing `)'. */
7527 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
7528 token
= cp_lexer_peek_token (parser
->lexer
);
7529 /* There should not be a direct-new-declarator in this production,
7530 but GCC used to allowed this, so we check and emit a sensible error
7531 message for this case. */
7532 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
7534 error_at (token
->location
,
7535 "array bound forbidden after parenthesized type-id");
7536 inform (token
->location
,
7537 "try removing the parentheses around the type-id");
7538 cp_parser_direct_new_declarator (parser
);
7541 /* Otherwise, there must be a new-type-id. */
7543 type
= cp_parser_new_type_id (parser
, &nelts
);
7545 /* If the next token is a `(' or '{', then we have a new-initializer. */
7546 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
7547 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
7548 initializer
= cp_parser_new_initializer (parser
);
7552 /* A new-expression may not appear in an integral constant
7554 if (cp_parser_non_integral_constant_expression (parser
, NIC_NEW
))
7555 ret
= error_mark_node
;
7558 /* Create a representation of the new-expression. */
7559 ret
= build_new (&placement
, type
, nelts
, &initializer
, global_scope_p
,
7560 tf_warning_or_error
);
7563 if (placement
!= NULL
)
7564 release_tree_vector (placement
);
7565 if (initializer
!= NULL
)
7566 release_tree_vector (initializer
);
7571 /* Parse a new-placement.
7576 Returns the same representation as for an expression-list. */
7578 static vec
<tree
, va_gc
> *
7579 cp_parser_new_placement (cp_parser
* parser
)
7581 vec
<tree
, va_gc
> *expression_list
;
7583 /* Parse the expression-list. */
7584 expression_list
= (cp_parser_parenthesized_expression_list
7585 (parser
, non_attr
, /*cast_p=*/false,
7586 /*allow_expansion_p=*/true,
7587 /*non_constant_p=*/NULL
));
7589 return expression_list
;
7592 /* Parse a new-type-id.
7595 type-specifier-seq new-declarator [opt]
7597 Returns the TYPE allocated. If the new-type-id indicates an array
7598 type, *NELTS is set to the number of elements in the last array
7599 bound; the TYPE will not include the last array bound. */
7602 cp_parser_new_type_id (cp_parser
* parser
, tree
*nelts
)
7604 cp_decl_specifier_seq type_specifier_seq
;
7605 cp_declarator
*new_declarator
;
7606 cp_declarator
*declarator
;
7607 cp_declarator
*outer_declarator
;
7608 const char *saved_message
;
7610 /* The type-specifier sequence must not contain type definitions.
7611 (It cannot contain declarations of new types either, but if they
7612 are not definitions we will catch that because they are not
7614 saved_message
= parser
->type_definition_forbidden_message
;
7615 parser
->type_definition_forbidden_message
7616 = G_("types may not be defined in a new-type-id");
7617 /* Parse the type-specifier-seq. */
7618 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
7619 /*is_trailing_return=*/false,
7620 &type_specifier_seq
);
7621 /* Restore the old message. */
7622 parser
->type_definition_forbidden_message
= saved_message
;
7624 if (type_specifier_seq
.type
== error_mark_node
)
7625 return error_mark_node
;
7627 /* Parse the new-declarator. */
7628 new_declarator
= cp_parser_new_declarator_opt (parser
);
7630 /* Determine the number of elements in the last array dimension, if
7633 /* Skip down to the last array dimension. */
7634 declarator
= new_declarator
;
7635 outer_declarator
= NULL
;
7636 while (declarator
&& (declarator
->kind
== cdk_pointer
7637 || declarator
->kind
== cdk_ptrmem
))
7639 outer_declarator
= declarator
;
7640 declarator
= declarator
->declarator
;
7643 && declarator
->kind
== cdk_array
7644 && declarator
->declarator
7645 && declarator
->declarator
->kind
== cdk_array
)
7647 outer_declarator
= declarator
;
7648 declarator
= declarator
->declarator
;
7651 if (declarator
&& declarator
->kind
== cdk_array
)
7653 *nelts
= declarator
->u
.array
.bounds
;
7654 if (*nelts
== error_mark_node
)
7655 *nelts
= integer_one_node
;
7657 if (outer_declarator
)
7658 outer_declarator
->declarator
= declarator
->declarator
;
7660 new_declarator
= NULL
;
7663 return groktypename (&type_specifier_seq
, new_declarator
, false);
7666 /* Parse an (optional) new-declarator.
7669 ptr-operator new-declarator [opt]
7670 direct-new-declarator
7672 Returns the declarator. */
7674 static cp_declarator
*
7675 cp_parser_new_declarator_opt (cp_parser
* parser
)
7677 enum tree_code code
;
7678 tree type
, std_attributes
= NULL_TREE
;
7679 cp_cv_quals cv_quals
;
7681 /* We don't know if there's a ptr-operator next, or not. */
7682 cp_parser_parse_tentatively (parser
);
7683 /* Look for a ptr-operator. */
7684 code
= cp_parser_ptr_operator (parser
, &type
, &cv_quals
, &std_attributes
);
7685 /* If that worked, look for more new-declarators. */
7686 if (cp_parser_parse_definitely (parser
))
7688 cp_declarator
*declarator
;
7690 /* Parse another optional declarator. */
7691 declarator
= cp_parser_new_declarator_opt (parser
);
7693 declarator
= cp_parser_make_indirect_declarator
7694 (code
, type
, cv_quals
, declarator
, std_attributes
);
7699 /* If the next token is a `[', there is a direct-new-declarator. */
7700 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
7701 return cp_parser_direct_new_declarator (parser
);
7706 /* Parse a direct-new-declarator.
7708 direct-new-declarator:
7710 direct-new-declarator [constant-expression]
7714 static cp_declarator
*
7715 cp_parser_direct_new_declarator (cp_parser
* parser
)
7717 cp_declarator
*declarator
= NULL
;
7724 /* Look for the opening `['. */
7725 cp_parser_require (parser
, CPP_OPEN_SQUARE
, RT_OPEN_SQUARE
);
7727 token
= cp_lexer_peek_token (parser
->lexer
);
7728 expression
= cp_parser_expression (parser
);
7729 /* The standard requires that the expression have integral
7730 type. DR 74 adds enumeration types. We believe that the
7731 real intent is that these expressions be handled like the
7732 expression in a `switch' condition, which also allows
7733 classes with a single conversion to integral or
7734 enumeration type. */
7735 if (!processing_template_decl
)
7738 = build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
7743 error_at (token
->location
,
7744 "expression in new-declarator must have integral "
7745 "or enumeration type");
7746 expression
= error_mark_node
;
7750 /* Look for the closing `]'. */
7751 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
7753 /* Add this bound to the declarator. */
7754 declarator
= make_array_declarator (declarator
, expression
);
7756 /* If the next token is not a `[', then there are no more
7758 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_SQUARE
))
7765 /* Parse a new-initializer.
7768 ( expression-list [opt] )
7771 Returns a representation of the expression-list. */
7773 static vec
<tree
, va_gc
> *
7774 cp_parser_new_initializer (cp_parser
* parser
)
7776 vec
<tree
, va_gc
> *expression_list
;
7778 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
7781 bool expr_non_constant_p
;
7782 cp_lexer_set_source_position (parser
->lexer
);
7783 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
7784 t
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
7785 CONSTRUCTOR_IS_DIRECT_INIT (t
) = 1;
7786 expression_list
= make_tree_vector_single (t
);
7789 expression_list
= (cp_parser_parenthesized_expression_list
7790 (parser
, non_attr
, /*cast_p=*/false,
7791 /*allow_expansion_p=*/true,
7792 /*non_constant_p=*/NULL
));
7794 return expression_list
;
7797 /* Parse a delete-expression.
7800 :: [opt] delete cast-expression
7801 :: [opt] delete [ ] cast-expression
7803 Returns a representation of the expression. */
7806 cp_parser_delete_expression (cp_parser
* parser
)
7808 bool global_scope_p
;
7812 /* Look for the optional `::' operator. */
7814 = (cp_parser_global_scope_opt (parser
,
7815 /*current_scope_valid_p=*/false)
7817 /* Look for the `delete' keyword. */
7818 cp_parser_require_keyword (parser
, RID_DELETE
, RT_DELETE
);
7819 /* See if the array syntax is in use. */
7820 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
7822 /* Consume the `[' token. */
7823 cp_lexer_consume_token (parser
->lexer
);
7824 /* Look for the `]' token. */
7825 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
7826 /* Remember that this is the `[]' construct. */
7832 /* Parse the cast-expression. */
7833 expression
= cp_parser_simple_cast_expression (parser
);
7835 /* A delete-expression may not appear in an integral constant
7837 if (cp_parser_non_integral_constant_expression (parser
, NIC_DEL
))
7838 return error_mark_node
;
7840 return delete_sanity (expression
, NULL_TREE
, array_p
, global_scope_p
,
7841 tf_warning_or_error
);
7844 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
7845 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
7849 cp_parser_tokens_start_cast_expression (cp_parser
*parser
)
7851 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
7852 switch (token
->type
)
7858 case CPP_CLOSE_SQUARE
:
7859 case CPP_CLOSE_PAREN
:
7860 case CPP_CLOSE_BRACE
:
7861 case CPP_OPEN_BRACE
:
7865 case CPP_DEREF_STAR
:
7873 case CPP_GREATER_EQ
:
7894 case CPP_OPEN_PAREN
:
7895 /* In ((type ()) () the last () isn't a valid cast-expression,
7896 so the whole must be parsed as postfix-expression. */
7897 return cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
7900 case CPP_OPEN_SQUARE
:
7901 /* '[' may start a primary-expression in obj-c++ and in C++11,
7902 as a lambda-expression, eg, '(void)[]{}'. */
7903 if (cxx_dialect
>= cxx11
)
7905 return c_dialect_objc ();
7908 case CPP_MINUS_MINUS
:
7909 /* '++' and '--' may or may not start a cast-expression:
7911 struct T { void operator++(int); };
7912 void f() { (T())++; }
7925 /* Parse a cast-expression.
7929 ( type-id ) cast-expression
7931 ADDRESS_P is true iff the unary-expression is appearing as the
7932 operand of the `&' operator. CAST_P is true if this expression is
7933 the target of a cast.
7935 Returns a representation of the expression. */
7938 cp_parser_cast_expression (cp_parser
*parser
, bool address_p
, bool cast_p
,
7939 bool decltype_p
, cp_id_kind
* pidk
)
7941 /* If it's a `(', then we might be looking at a cast. */
7942 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
7944 tree type
= NULL_TREE
;
7945 tree expr
= NULL_TREE
;
7946 int cast_expression
= 0;
7947 const char *saved_message
;
7949 /* There's no way to know yet whether or not this is a cast.
7950 For example, `(int (3))' is a unary-expression, while `(int)
7951 3' is a cast. So, we resort to parsing tentatively. */
7952 cp_parser_parse_tentatively (parser
);
7953 /* Types may not be defined in a cast. */
7954 saved_message
= parser
->type_definition_forbidden_message
;
7955 parser
->type_definition_forbidden_message
7956 = G_("types may not be defined in casts");
7957 /* Consume the `('. */
7958 cp_lexer_consume_token (parser
->lexer
);
7959 /* A very tricky bit is that `(struct S) { 3 }' is a
7960 compound-literal (which we permit in C++ as an extension).
7961 But, that construct is not a cast-expression -- it is a
7962 postfix-expression. (The reason is that `(struct S) { 3 }.i'
7963 is legal; if the compound-literal were a cast-expression,
7964 you'd need an extra set of parentheses.) But, if we parse
7965 the type-id, and it happens to be a class-specifier, then we
7966 will commit to the parse at that point, because we cannot
7967 undo the action that is done when creating a new class. So,
7968 then we cannot back up and do a postfix-expression.
7970 Another tricky case is the following (c++/29234):
7972 struct S { void operator () (); };
7979 As a type-id we parse the parenthesized S()() as a function
7980 returning a function, groktypename complains and we cannot
7981 back up in this case either.
7983 Therefore, we scan ahead to the closing `)', and check to see
7984 if the tokens after the `)' can start a cast-expression. Otherwise
7985 we are dealing with an unary-expression, a postfix-expression
7988 Yet another tricky case, in C++11, is the following (c++/54891):
7992 The issue is that usually, besides the case of lambda-expressions,
7993 the parenthesized type-id cannot be followed by '[', and, eg, we
7994 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
7995 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
7996 we don't commit, we try a cast-expression, then an unary-expression.
7998 Save tokens so that we can put them back. */
7999 cp_lexer_save_tokens (parser
->lexer
);
8001 /* We may be looking at a cast-expression. */
8002 if (cp_parser_skip_to_closing_parenthesis (parser
, false, false,
8003 /*consume_paren=*/true))
8005 = cp_parser_tokens_start_cast_expression (parser
);
8007 /* Roll back the tokens we skipped. */
8008 cp_lexer_rollback_tokens (parser
->lexer
);
8009 /* If we aren't looking at a cast-expression, simulate an error so
8010 that the call to cp_parser_error_occurred below returns true. */
8011 if (!cast_expression
)
8012 cp_parser_simulate_error (parser
);
8015 bool saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
8016 parser
->in_type_id_in_expr_p
= true;
8017 /* Look for the type-id. */
8018 type
= cp_parser_type_id (parser
);
8019 /* Look for the closing `)'. */
8020 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
8021 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
8024 /* Restore the saved message. */
8025 parser
->type_definition_forbidden_message
= saved_message
;
8027 /* At this point this can only be either a cast or a
8028 parenthesized ctor such as `(T ())' that looks like a cast to
8029 function returning T. */
8030 if (!cp_parser_error_occurred (parser
))
8032 /* Only commit if the cast-expression doesn't start with
8033 '++', '--', or '[' in C++11. */
8034 if (cast_expression
> 0)
8035 cp_parser_commit_to_topmost_tentative_parse (parser
);
8037 expr
= cp_parser_cast_expression (parser
,
8038 /*address_p=*/false,
8040 /*decltype_p=*/false,
8043 if (cp_parser_parse_definitely (parser
))
8045 /* Warn about old-style casts, if so requested. */
8046 if (warn_old_style_cast
8047 && !in_system_header_at (input_location
)
8048 && !VOID_TYPE_P (type
)
8049 && current_lang_name
!= lang_name_c
)
8050 warning (OPT_Wold_style_cast
, "use of old-style cast");
8052 /* Only type conversions to integral or enumeration types
8053 can be used in constant-expressions. */
8054 if (!cast_valid_in_integral_constant_expression_p (type
)
8055 && cp_parser_non_integral_constant_expression (parser
,
8057 return error_mark_node
;
8059 /* Perform the cast. */
8060 expr
= build_c_cast (input_location
, type
, expr
);
8065 cp_parser_abort_tentative_parse (parser
);
8068 /* If we get here, then it's not a cast, so it must be a
8069 unary-expression. */
8070 return cp_parser_unary_expression (parser
, pidk
, address_p
,
8071 cast_p
, decltype_p
);
8074 /* Parse a binary expression of the general form:
8078 pm-expression .* cast-expression
8079 pm-expression ->* cast-expression
8081 multiplicative-expression:
8083 multiplicative-expression * pm-expression
8084 multiplicative-expression / pm-expression
8085 multiplicative-expression % pm-expression
8087 additive-expression:
8088 multiplicative-expression
8089 additive-expression + multiplicative-expression
8090 additive-expression - multiplicative-expression
8094 shift-expression << additive-expression
8095 shift-expression >> additive-expression
8097 relational-expression:
8099 relational-expression < shift-expression
8100 relational-expression > shift-expression
8101 relational-expression <= shift-expression
8102 relational-expression >= shift-expression
8106 relational-expression:
8107 relational-expression <? shift-expression
8108 relational-expression >? shift-expression
8110 equality-expression:
8111 relational-expression
8112 equality-expression == relational-expression
8113 equality-expression != relational-expression
8117 and-expression & equality-expression
8119 exclusive-or-expression:
8121 exclusive-or-expression ^ and-expression
8123 inclusive-or-expression:
8124 exclusive-or-expression
8125 inclusive-or-expression | exclusive-or-expression
8127 logical-and-expression:
8128 inclusive-or-expression
8129 logical-and-expression && inclusive-or-expression
8131 logical-or-expression:
8132 logical-and-expression
8133 logical-or-expression || logical-and-expression
8135 All these are implemented with a single function like:
8138 simple-cast-expression
8139 binary-expression <token> binary-expression
8141 CAST_P is true if this expression is the target of a cast.
8143 The binops_by_token map is used to get the tree codes for each <token> type.
8144 binary-expressions are associated according to a precedence table. */
8146 #define TOKEN_PRECEDENCE(token) \
8147 (((token->type == CPP_GREATER \
8148 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
8149 && !parser->greater_than_is_operator_p) \
8150 ? PREC_NOT_OPERATOR \
8151 : binops_by_token[token->type].prec)
8154 cp_parser_binary_expression (cp_parser
* parser
, bool cast_p
,
8155 bool no_toplevel_fold_p
,
8157 enum cp_parser_prec prec
,
8160 cp_parser_expression_stack stack
;
8161 cp_parser_expression_stack_entry
*sp
= &stack
[0];
8162 cp_parser_expression_stack_entry current
;
8165 enum tree_code rhs_type
;
8166 enum cp_parser_prec new_prec
, lookahead_prec
;
8169 /* Parse the first expression. */
8170 current
.lhs_type
= (cp_lexer_next_token_is (parser
->lexer
, CPP_NOT
)
8171 ? TRUTH_NOT_EXPR
: ERROR_MARK
);
8172 current
.lhs
= cp_parser_cast_expression (parser
, /*address_p=*/false,
8173 cast_p
, decltype_p
, pidk
);
8174 current
.prec
= prec
;
8176 if (cp_parser_error_occurred (parser
))
8177 return error_mark_node
;
8181 /* Get an operator token. */
8182 token
= cp_lexer_peek_token (parser
->lexer
);
8184 if (warn_cxx0x_compat
8185 && token
->type
== CPP_RSHIFT
8186 && !parser
->greater_than_is_operator_p
)
8188 if (warning_at (token
->location
, OPT_Wc__0x_compat
,
8189 "%<>>%> operator is treated"
8190 " as two right angle brackets in C++11"))
8191 inform (token
->location
,
8192 "suggest parentheses around %<>>%> expression");
8195 new_prec
= TOKEN_PRECEDENCE (token
);
8197 /* Popping an entry off the stack means we completed a subexpression:
8198 - either we found a token which is not an operator (`>' where it is not
8199 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
8200 will happen repeatedly;
8201 - or, we found an operator which has lower priority. This is the case
8202 where the recursive descent *ascends*, as in `3 * 4 + 5' after
8204 if (new_prec
<= current
.prec
)
8213 current
.tree_type
= binops_by_token
[token
->type
].tree_type
;
8214 current
.loc
= token
->location
;
8216 /* We used the operator token. */
8217 cp_lexer_consume_token (parser
->lexer
);
8219 /* For "false && x" or "true || x", x will never be executed;
8220 disable warnings while evaluating it. */
8221 if (current
.tree_type
== TRUTH_ANDIF_EXPR
)
8222 c_inhibit_evaluation_warnings
+= current
.lhs
== truthvalue_false_node
;
8223 else if (current
.tree_type
== TRUTH_ORIF_EXPR
)
8224 c_inhibit_evaluation_warnings
+= current
.lhs
== truthvalue_true_node
;
8226 /* Extract another operand. It may be the RHS of this expression
8227 or the LHS of a new, higher priority expression. */
8228 rhs_type
= (cp_lexer_next_token_is (parser
->lexer
, CPP_NOT
)
8229 ? TRUTH_NOT_EXPR
: ERROR_MARK
);
8230 rhs
= cp_parser_simple_cast_expression (parser
);
8232 /* Get another operator token. Look up its precedence to avoid
8233 building a useless (immediately popped) stack entry for common
8234 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
8235 token
= cp_lexer_peek_token (parser
->lexer
);
8236 lookahead_prec
= TOKEN_PRECEDENCE (token
);
8237 if (lookahead_prec
> new_prec
)
8239 /* ... and prepare to parse the RHS of the new, higher priority
8240 expression. Since precedence levels on the stack are
8241 monotonically increasing, we do not have to care about
8246 current
.lhs_type
= rhs_type
;
8247 current
.prec
= new_prec
;
8248 new_prec
= lookahead_prec
;
8252 lookahead_prec
= new_prec
;
8253 /* If the stack is not empty, we have parsed into LHS the right side
8254 (`4' in the example above) of an expression we had suspended.
8255 We can use the information on the stack to recover the LHS (`3')
8256 from the stack together with the tree code (`MULT_EXPR'), and
8257 the precedence of the higher level subexpression
8258 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
8259 which will be used to actually build the additive expression. */
8261 rhs_type
= current
.lhs_type
;
8266 /* Undo the disabling of warnings done above. */
8267 if (current
.tree_type
== TRUTH_ANDIF_EXPR
)
8268 c_inhibit_evaluation_warnings
-= current
.lhs
== truthvalue_false_node
;
8269 else if (current
.tree_type
== TRUTH_ORIF_EXPR
)
8270 c_inhibit_evaluation_warnings
-= current
.lhs
== truthvalue_true_node
;
8272 if (warn_logical_not_paren
8273 && TREE_CODE_CLASS (current
.tree_type
) == tcc_comparison
8274 && current
.lhs_type
== TRUTH_NOT_EXPR
8275 /* Avoid warning for !!x == y. */
8276 && (TREE_CODE (current
.lhs
) != NE_EXPR
8277 || !integer_zerop (TREE_OPERAND (current
.lhs
, 1)))
8278 && (TREE_CODE (current
.lhs
) != TRUTH_NOT_EXPR
8279 || (TREE_CODE (TREE_OPERAND (current
.lhs
, 0)) != TRUTH_NOT_EXPR
8280 /* Avoid warning for !b == y where b is boolean. */
8281 && (TREE_TYPE (TREE_OPERAND (current
.lhs
, 0)) == NULL_TREE
8282 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (current
.lhs
, 0)))
8284 /* Avoid warning for !!b == y where b is boolean. */
8285 && (!DECL_P (current
.lhs
)
8286 || TREE_TYPE (current
.lhs
) == NULL_TREE
8287 || TREE_CODE (TREE_TYPE (current
.lhs
)) != BOOLEAN_TYPE
))
8288 warn_logical_not_parentheses (current
.loc
, current
.tree_type
,
8289 maybe_constant_value (rhs
));
8292 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
8293 ERROR_MARK for everything that is not a binary expression.
8294 This makes warn_about_parentheses miss some warnings that
8295 involve unary operators. For unary expressions we should
8296 pass the correct tree_code unless the unary expression was
8297 surrounded by parentheses.
8299 if (no_toplevel_fold_p
8300 && lookahead_prec
<= current
.prec
8302 current
.lhs
= build2 (current
.tree_type
,
8303 TREE_CODE_CLASS (current
.tree_type
)
8305 ? boolean_type_node
: TREE_TYPE (current
.lhs
),
8308 current
.lhs
= build_x_binary_op (current
.loc
, current
.tree_type
,
8309 current
.lhs
, current
.lhs_type
,
8310 rhs
, rhs_type
, &overload
,
8311 complain_flags (decltype_p
));
8312 current
.lhs_type
= current
.tree_type
;
8313 if (EXPR_P (current
.lhs
))
8314 SET_EXPR_LOCATION (current
.lhs
, current
.loc
);
8316 /* If the binary operator required the use of an overloaded operator,
8317 then this expression cannot be an integral constant-expression.
8318 An overloaded operator can be used even if both operands are
8319 otherwise permissible in an integral constant-expression if at
8320 least one of the operands is of enumeration type. */
8323 && cp_parser_non_integral_constant_expression (parser
,
8325 return error_mark_node
;
8332 cp_parser_binary_expression (cp_parser
* parser
, bool cast_p
,
8333 bool no_toplevel_fold_p
,
8334 enum cp_parser_prec prec
,
8337 return cp_parser_binary_expression (parser
, cast_p
, no_toplevel_fold_p
,
8338 /*decltype*/false, prec
, pidk
);
8341 /* Parse the `? expression : assignment-expression' part of a
8342 conditional-expression. The LOGICAL_OR_EXPR is the
8343 logical-or-expression that started the conditional-expression.
8344 Returns a representation of the entire conditional-expression.
8346 This routine is used by cp_parser_assignment_expression.
8348 ? expression : assignment-expression
8352 ? : assignment-expression */
8355 cp_parser_question_colon_clause (cp_parser
* parser
, tree logical_or_expr
)
8358 tree assignment_expr
;
8359 struct cp_token
*token
;
8360 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8362 /* Consume the `?' token. */
8363 cp_lexer_consume_token (parser
->lexer
);
8364 token
= cp_lexer_peek_token (parser
->lexer
);
8365 if (cp_parser_allow_gnu_extensions_p (parser
)
8366 && token
->type
== CPP_COLON
)
8368 pedwarn (token
->location
, OPT_Wpedantic
,
8369 "ISO C++ does not allow ?: with omitted middle operand");
8370 /* Implicit true clause. */
8372 c_inhibit_evaluation_warnings
+= logical_or_expr
== truthvalue_true_node
;
8373 warn_for_omitted_condop (token
->location
, logical_or_expr
);
8377 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
8378 parser
->colon_corrects_to_scope_p
= false;
8379 /* Parse the expression. */
8380 c_inhibit_evaluation_warnings
+= logical_or_expr
== truthvalue_false_node
;
8381 expr
= cp_parser_expression (parser
);
8382 c_inhibit_evaluation_warnings
+=
8383 ((logical_or_expr
== truthvalue_true_node
)
8384 - (logical_or_expr
== truthvalue_false_node
));
8385 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
8388 /* The next token should be a `:'. */
8389 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
8390 /* Parse the assignment-expression. */
8391 assignment_expr
= cp_parser_assignment_expression (parser
);
8392 c_inhibit_evaluation_warnings
-= logical_or_expr
== truthvalue_true_node
;
8394 /* Build the conditional-expression. */
8395 return build_x_conditional_expr (loc
, logical_or_expr
,
8398 tf_warning_or_error
);
8401 /* Parse an assignment-expression.
8403 assignment-expression:
8404 conditional-expression
8405 logical-or-expression assignment-operator assignment_expression
8408 CAST_P is true if this expression is the target of a cast.
8409 DECLTYPE_P is true if this expression is the operand of decltype.
8411 Returns a representation for the expression. */
8414 cp_parser_assignment_expression (cp_parser
* parser
, cp_id_kind
* pidk
,
8415 bool cast_p
, bool decltype_p
)
8419 /* If the next token is the `throw' keyword, then we're looking at
8420 a throw-expression. */
8421 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_THROW
))
8422 expr
= cp_parser_throw_expression (parser
);
8423 /* Otherwise, it must be that we are looking at a
8424 logical-or-expression. */
8427 /* Parse the binary expressions (logical-or-expression). */
8428 expr
= cp_parser_binary_expression (parser
, cast_p
, false,
8430 PREC_NOT_OPERATOR
, pidk
);
8431 /* If the next token is a `?' then we're actually looking at a
8432 conditional-expression. */
8433 if (cp_lexer_next_token_is (parser
->lexer
, CPP_QUERY
))
8434 return cp_parser_question_colon_clause (parser
, expr
);
8437 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8439 /* If it's an assignment-operator, we're using the second
8441 enum tree_code assignment_operator
8442 = cp_parser_assignment_operator_opt (parser
);
8443 if (assignment_operator
!= ERROR_MARK
)
8445 bool non_constant_p
;
8446 location_t saved_input_location
;
8448 /* Parse the right-hand side of the assignment. */
8449 tree rhs
= cp_parser_initializer_clause (parser
, &non_constant_p
);
8451 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
8452 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
8454 /* An assignment may not appear in a
8455 constant-expression. */
8456 if (cp_parser_non_integral_constant_expression (parser
,
8458 return error_mark_node
;
8459 /* Build the assignment expression. Its default
8460 location is the location of the '=' token. */
8461 saved_input_location
= input_location
;
8462 input_location
= loc
;
8463 expr
= build_x_modify_expr (loc
, expr
,
8464 assignment_operator
,
8466 complain_flags (decltype_p
));
8467 input_location
= saved_input_location
;
8475 /* Parse an (optional) assignment-operator.
8477 assignment-operator: one of
8478 = *= /= %= += -= >>= <<= &= ^= |=
8482 assignment-operator: one of
8485 If the next token is an assignment operator, the corresponding tree
8486 code is returned, and the token is consumed. For example, for
8487 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
8488 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
8489 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
8490 operator, ERROR_MARK is returned. */
8492 static enum tree_code
8493 cp_parser_assignment_operator_opt (cp_parser
* parser
)
8498 /* Peek at the next token. */
8499 token
= cp_lexer_peek_token (parser
->lexer
);
8501 switch (token
->type
)
8512 op
= TRUNC_DIV_EXPR
;
8516 op
= TRUNC_MOD_EXPR
;
8548 /* Nothing else is an assignment operator. */
8552 /* If it was an assignment operator, consume it. */
8553 if (op
!= ERROR_MARK
)
8554 cp_lexer_consume_token (parser
->lexer
);
8559 /* Parse an expression.
8562 assignment-expression
8563 expression , assignment-expression
8565 CAST_P is true if this expression is the target of a cast.
8566 DECLTYPE_P is true if this expression is the immediate operand of decltype,
8567 except possibly parenthesized or on the RHS of a comma (N3276).
8569 Returns a representation of the expression. */
8572 cp_parser_expression (cp_parser
* parser
, cp_id_kind
* pidk
,
8573 bool cast_p
, bool decltype_p
)
8575 tree expression
= NULL_TREE
;
8576 location_t loc
= UNKNOWN_LOCATION
;
8580 tree assignment_expression
;
8582 /* Parse the next assignment-expression. */
8583 assignment_expression
8584 = cp_parser_assignment_expression (parser
, pidk
, cast_p
, decltype_p
);
8586 /* We don't create a temporary for a call that is the immediate operand
8587 of decltype or on the RHS of a comma. But when we see a comma, we
8588 need to create a temporary for a call on the LHS. */
8589 if (decltype_p
&& !processing_template_decl
8590 && TREE_CODE (assignment_expression
) == CALL_EXPR
8591 && CLASS_TYPE_P (TREE_TYPE (assignment_expression
))
8592 && cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
8593 assignment_expression
8594 = build_cplus_new (TREE_TYPE (assignment_expression
),
8595 assignment_expression
, tf_warning_or_error
);
8597 /* If this is the first assignment-expression, we can just
8600 expression
= assignment_expression
;
8602 expression
= build_x_compound_expr (loc
, expression
,
8603 assignment_expression
,
8604 complain_flags (decltype_p
));
8605 /* If the next token is not a comma, then we are done with the
8607 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
8609 /* Consume the `,'. */
8610 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8611 cp_lexer_consume_token (parser
->lexer
);
8612 /* A comma operator cannot appear in a constant-expression. */
8613 if (cp_parser_non_integral_constant_expression (parser
, NIC_COMMA
))
8614 expression
= error_mark_node
;
8620 /* Parse a constant-expression.
8622 constant-expression:
8623 conditional-expression
8625 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
8626 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
8627 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
8628 is false, NON_CONSTANT_P should be NULL. */
8631 cp_parser_constant_expression (cp_parser
* parser
,
8632 bool allow_non_constant_p
,
8633 bool *non_constant_p
)
8635 bool saved_integral_constant_expression_p
;
8636 bool saved_allow_non_integral_constant_expression_p
;
8637 bool saved_non_integral_constant_expression_p
;
8640 /* It might seem that we could simply parse the
8641 conditional-expression, and then check to see if it were
8642 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
8643 one that the compiler can figure out is constant, possibly after
8644 doing some simplifications or optimizations. The standard has a
8645 precise definition of constant-expression, and we must honor
8646 that, even though it is somewhat more restrictive.
8652 is not a legal declaration, because `(2, 3)' is not a
8653 constant-expression. The `,' operator is forbidden in a
8654 constant-expression. However, GCC's constant-folding machinery
8655 will fold this operation to an INTEGER_CST for `3'. */
8657 /* Save the old settings. */
8658 saved_integral_constant_expression_p
= parser
->integral_constant_expression_p
;
8659 saved_allow_non_integral_constant_expression_p
8660 = parser
->allow_non_integral_constant_expression_p
;
8661 saved_non_integral_constant_expression_p
= parser
->non_integral_constant_expression_p
;
8662 /* We are now parsing a constant-expression. */
8663 parser
->integral_constant_expression_p
= true;
8664 parser
->allow_non_integral_constant_expression_p
8665 = (allow_non_constant_p
|| cxx_dialect
>= cxx11
);
8666 parser
->non_integral_constant_expression_p
= false;
8667 /* Although the grammar says "conditional-expression", we parse an
8668 "assignment-expression", which also permits "throw-expression"
8669 and the use of assignment operators. In the case that
8670 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
8671 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
8672 actually essential that we look for an assignment-expression.
8673 For example, cp_parser_initializer_clauses uses this function to
8674 determine whether a particular assignment-expression is in fact
8676 expression
= cp_parser_assignment_expression (parser
);
8677 /* Restore the old settings. */
8678 parser
->integral_constant_expression_p
8679 = saved_integral_constant_expression_p
;
8680 parser
->allow_non_integral_constant_expression_p
8681 = saved_allow_non_integral_constant_expression_p
;
8682 if (cxx_dialect
>= cxx11
)
8684 /* Require an rvalue constant expression here; that's what our
8685 callers expect. Reference constant expressions are handled
8686 separately in e.g. cp_parser_template_argument. */
8687 bool is_const
= potential_rvalue_constant_expression (expression
);
8688 parser
->non_integral_constant_expression_p
= !is_const
;
8689 if (!is_const
&& !allow_non_constant_p
)
8690 require_potential_rvalue_constant_expression (expression
);
8692 if (allow_non_constant_p
)
8693 *non_constant_p
= parser
->non_integral_constant_expression_p
;
8694 parser
->non_integral_constant_expression_p
8695 = saved_non_integral_constant_expression_p
;
8700 /* Parse __builtin_offsetof.
8702 offsetof-expression:
8703 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
8705 offsetof-member-designator:
8707 | offsetof-member-designator "." id-expression
8708 | offsetof-member-designator "[" expression "]"
8709 | offsetof-member-designator "->" id-expression */
8712 cp_parser_builtin_offsetof (cp_parser
*parser
)
8714 int save_ice_p
, save_non_ice_p
;
8719 /* We're about to accept non-integral-constant things, but will
8720 definitely yield an integral constant expression. Save and
8721 restore these values around our local parsing. */
8722 save_ice_p
= parser
->integral_constant_expression_p
;
8723 save_non_ice_p
= parser
->non_integral_constant_expression_p
;
8725 /* Consume the "__builtin_offsetof" token. */
8726 cp_lexer_consume_token (parser
->lexer
);
8727 /* Consume the opening `('. */
8728 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
8729 /* Parse the type-id. */
8730 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
8731 type
= cp_parser_type_id (parser
);
8732 /* Look for the `,'. */
8733 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
8734 token
= cp_lexer_peek_token (parser
->lexer
);
8736 /* Build the (type *)null that begins the traditional offsetof macro. */
8737 expr
= build_static_cast (build_pointer_type (type
), null_pointer_node
,
8738 tf_warning_or_error
);
8740 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
8741 expr
= cp_parser_postfix_dot_deref_expression (parser
, CPP_DEREF
, expr
,
8742 true, &dummy
, token
->location
);
8745 token
= cp_lexer_peek_token (parser
->lexer
);
8746 switch (token
->type
)
8748 case CPP_OPEN_SQUARE
:
8749 /* offsetof-member-designator "[" expression "]" */
8750 expr
= cp_parser_postfix_open_square_expression (parser
, expr
,
8755 /* offsetof-member-designator "->" identifier */
8756 expr
= grok_array_decl (token
->location
, expr
,
8757 integer_zero_node
, false);
8761 /* offsetof-member-designator "." identifier */
8762 cp_lexer_consume_token (parser
->lexer
);
8763 expr
= cp_parser_postfix_dot_deref_expression (parser
, CPP_DOT
,
8768 case CPP_CLOSE_PAREN
:
8769 /* Consume the ")" token. */
8770 cp_lexer_consume_token (parser
->lexer
);
8774 /* Error. We know the following require will fail, but
8775 that gives the proper error message. */
8776 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
8777 cp_parser_skip_to_closing_parenthesis (parser
, true, false, true);
8778 expr
= error_mark_node
;
8784 expr
= finish_offsetof (expr
, loc
);
8787 parser
->integral_constant_expression_p
= save_ice_p
;
8788 parser
->non_integral_constant_expression_p
= save_non_ice_p
;
8793 /* Parse a trait expression.
8795 Returns a representation of the expression, the underlying type
8796 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
8799 cp_parser_trait_expr (cp_parser
* parser
, enum rid keyword
)
8802 tree type1
, type2
= NULL_TREE
;
8803 bool binary
= false;
8804 bool variadic
= false;
8808 case RID_HAS_NOTHROW_ASSIGN
:
8809 kind
= CPTK_HAS_NOTHROW_ASSIGN
;
8811 case RID_HAS_NOTHROW_CONSTRUCTOR
:
8812 kind
= CPTK_HAS_NOTHROW_CONSTRUCTOR
;
8814 case RID_HAS_NOTHROW_COPY
:
8815 kind
= CPTK_HAS_NOTHROW_COPY
;
8817 case RID_HAS_TRIVIAL_ASSIGN
:
8818 kind
= CPTK_HAS_TRIVIAL_ASSIGN
;
8820 case RID_HAS_TRIVIAL_CONSTRUCTOR
:
8821 kind
= CPTK_HAS_TRIVIAL_CONSTRUCTOR
;
8823 case RID_HAS_TRIVIAL_COPY
:
8824 kind
= CPTK_HAS_TRIVIAL_COPY
;
8826 case RID_HAS_TRIVIAL_DESTRUCTOR
:
8827 kind
= CPTK_HAS_TRIVIAL_DESTRUCTOR
;
8829 case RID_HAS_VIRTUAL_DESTRUCTOR
:
8830 kind
= CPTK_HAS_VIRTUAL_DESTRUCTOR
;
8832 case RID_IS_ABSTRACT
:
8833 kind
= CPTK_IS_ABSTRACT
;
8835 case RID_IS_BASE_OF
:
8836 kind
= CPTK_IS_BASE_OF
;
8840 kind
= CPTK_IS_CLASS
;
8843 kind
= CPTK_IS_EMPTY
;
8846 kind
= CPTK_IS_ENUM
;
8849 kind
= CPTK_IS_FINAL
;
8851 case RID_IS_LITERAL_TYPE
:
8852 kind
= CPTK_IS_LITERAL_TYPE
;
8857 case RID_IS_POLYMORPHIC
:
8858 kind
= CPTK_IS_POLYMORPHIC
;
8860 case RID_IS_STD_LAYOUT
:
8861 kind
= CPTK_IS_STD_LAYOUT
;
8863 case RID_IS_TRIVIAL
:
8864 kind
= CPTK_IS_TRIVIAL
;
8866 case RID_IS_TRIVIALLY_ASSIGNABLE
:
8867 kind
= CPTK_IS_TRIVIALLY_ASSIGNABLE
;
8870 case RID_IS_TRIVIALLY_CONSTRUCTIBLE
:
8871 kind
= CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
;
8874 case RID_IS_TRIVIALLY_COPYABLE
:
8875 kind
= CPTK_IS_TRIVIALLY_COPYABLE
;
8878 kind
= CPTK_IS_UNION
;
8880 case RID_UNDERLYING_TYPE
:
8881 kind
= CPTK_UNDERLYING_TYPE
;
8886 case RID_DIRECT_BASES
:
8887 kind
= CPTK_DIRECT_BASES
;
8893 /* Consume the token. */
8894 cp_lexer_consume_token (parser
->lexer
);
8896 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
8898 type1
= cp_parser_type_id (parser
);
8900 if (type1
== error_mark_node
)
8901 return error_mark_node
;
8905 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
8907 type2
= cp_parser_type_id (parser
);
8909 if (type2
== error_mark_node
)
8910 return error_mark_node
;
8914 while (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
8916 cp_lexer_consume_token (parser
->lexer
);
8917 tree elt
= cp_parser_type_id (parser
);
8918 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
8920 cp_lexer_consume_token (parser
->lexer
);
8921 elt
= make_pack_expansion (elt
);
8923 if (elt
== error_mark_node
)
8924 return error_mark_node
;
8925 type2
= tree_cons (NULL_TREE
, elt
, type2
);
8929 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
8931 /* Complete the trait expression, which may mean either processing
8932 the trait expr now or saving it for template instantiation. */
8935 case CPTK_UNDERLYING_TYPE
:
8936 return finish_underlying_type (type1
);
8938 return finish_bases (type1
, false);
8939 case CPTK_DIRECT_BASES
:
8940 return finish_bases (type1
, true);
8942 return finish_trait_expr (kind
, type1
, type2
);
8946 /* Lambdas that appear in variable initializer or default argument scope
8947 get that in their mangling, so we need to record it. We might as well
8948 use the count for function and namespace scopes as well. */
8949 static GTY(()) tree lambda_scope
;
8950 static GTY(()) int lambda_count
;
8951 typedef struct GTY(()) tree_int
8956 static GTY(()) vec
<tree_int
, va_gc
> *lambda_scope_stack
;
8959 start_lambda_scope (tree decl
)
8963 /* Once we're inside a function, we ignore other scopes and just push
8964 the function again so that popping works properly. */
8965 if (current_function_decl
&& TREE_CODE (decl
) != FUNCTION_DECL
)
8966 decl
= current_function_decl
;
8967 ti
.t
= lambda_scope
;
8968 ti
.i
= lambda_count
;
8969 vec_safe_push (lambda_scope_stack
, ti
);
8970 if (lambda_scope
!= decl
)
8972 /* Don't reset the count if we're still in the same function. */
8973 lambda_scope
= decl
;
8979 record_lambda_scope (tree lambda
)
8981 LAMBDA_EXPR_EXTRA_SCOPE (lambda
) = lambda_scope
;
8982 LAMBDA_EXPR_DISCRIMINATOR (lambda
) = lambda_count
++;
8986 finish_lambda_scope (void)
8988 tree_int
*p
= &lambda_scope_stack
->last ();
8989 if (lambda_scope
!= p
->t
)
8991 lambda_scope
= p
->t
;
8992 lambda_count
= p
->i
;
8994 lambda_scope_stack
->pop ();
8997 /* Parse a lambda expression.
9000 lambda-introducer lambda-declarator [opt] compound-statement
9002 Returns a representation of the expression. */
9005 cp_parser_lambda_expression (cp_parser
* parser
)
9007 tree lambda_expr
= build_lambda_expr ();
9010 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
9011 cp_token_position start
= 0;
9013 LAMBDA_EXPR_LOCATION (lambda_expr
) = token
->location
;
9015 if (cp_unevaluated_operand
)
9017 if (!token
->error_reported
)
9019 error_at (LAMBDA_EXPR_LOCATION (lambda_expr
),
9020 "lambda-expression in unevaluated context");
9021 token
->error_reported
= true;
9025 else if (parser
->in_template_argument_list_p
)
9027 if (!token
->error_reported
)
9029 error_at (token
->location
, "lambda-expression in template-argument");
9030 token
->error_reported
= true;
9035 /* We may be in the middle of deferred access check. Disable
9037 push_deferring_access_checks (dk_no_deferred
);
9039 cp_parser_lambda_introducer (parser
, lambda_expr
);
9041 type
= begin_lambda_type (lambda_expr
);
9042 if (type
== error_mark_node
)
9043 return error_mark_node
;
9045 record_lambda_scope (lambda_expr
);
9047 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
9048 determine_visibility (TYPE_NAME (type
));
9050 /* Now that we've started the type, add the capture fields for any
9051 explicit captures. */
9052 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
));
9055 /* Inside the class, surrounding template-parameter-lists do not apply. */
9056 unsigned int saved_num_template_parameter_lists
9057 = parser
->num_template_parameter_lists
;
9058 unsigned char in_statement
= parser
->in_statement
;
9059 bool in_switch_statement_p
= parser
->in_switch_statement_p
;
9060 bool fully_implicit_function_template_p
9061 = parser
->fully_implicit_function_template_p
;
9062 tree implicit_template_parms
= parser
->implicit_template_parms
;
9063 cp_binding_level
* implicit_template_scope
= parser
->implicit_template_scope
;
9064 bool auto_is_implicit_function_template_parm_p
9065 = parser
->auto_is_implicit_function_template_parm_p
;
9067 parser
->num_template_parameter_lists
= 0;
9068 parser
->in_statement
= 0;
9069 parser
->in_switch_statement_p
= false;
9070 parser
->fully_implicit_function_template_p
= false;
9071 parser
->implicit_template_parms
= 0;
9072 parser
->implicit_template_scope
= 0;
9073 parser
->auto_is_implicit_function_template_parm_p
= false;
9075 /* By virtue of defining a local class, a lambda expression has access to
9076 the private variables of enclosing classes. */
9078 ok
&= cp_parser_lambda_declarator_opt (parser
, lambda_expr
);
9082 if (!cp_parser_error_occurred (parser
)
9083 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
)
9084 && cp_parser_start_tentative_firewall (parser
))
9086 cp_parser_lambda_body (parser
, lambda_expr
);
9088 else if (cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
9090 if (cp_parser_skip_to_closing_brace (parser
))
9091 cp_lexer_consume_token (parser
->lexer
);
9094 /* The capture list was built up in reverse order; fix that now. */
9095 LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
)
9096 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
));
9099 maybe_add_lambda_conv_op (type
);
9101 type
= finish_struct (type
, /*attributes=*/NULL_TREE
);
9103 parser
->num_template_parameter_lists
= saved_num_template_parameter_lists
;
9104 parser
->in_statement
= in_statement
;
9105 parser
->in_switch_statement_p
= in_switch_statement_p
;
9106 parser
->fully_implicit_function_template_p
9107 = fully_implicit_function_template_p
;
9108 parser
->implicit_template_parms
= implicit_template_parms
;
9109 parser
->implicit_template_scope
= implicit_template_scope
;
9110 parser
->auto_is_implicit_function_template_parm_p
9111 = auto_is_implicit_function_template_parm_p
;
9114 pop_deferring_access_checks ();
9116 /* This field is only used during parsing of the lambda. */
9117 LAMBDA_EXPR_THIS_CAPTURE (lambda_expr
) = NULL_TREE
;
9119 /* This lambda shouldn't have any proxies left at this point. */
9120 gcc_assert (LAMBDA_EXPR_PENDING_PROXIES (lambda_expr
) == NULL
);
9121 /* And now that we're done, push proxies for an enclosing lambda. */
9122 insert_pending_capture_proxies ();
9125 lambda_expr
= build_lambda_object (lambda_expr
);
9127 lambda_expr
= error_mark_node
;
9129 cp_parser_end_tentative_firewall (parser
, start
, lambda_expr
);
9134 /* Parse the beginning of a lambda expression.
9137 [ lambda-capture [opt] ]
9139 LAMBDA_EXPR is the current representation of the lambda expression. */
9142 cp_parser_lambda_introducer (cp_parser
* parser
, tree lambda_expr
)
9144 /* Need commas after the first capture. */
9147 /* Eat the leading `['. */
9148 cp_parser_require (parser
, CPP_OPEN_SQUARE
, RT_OPEN_SQUARE
);
9150 /* Record default capture mode. "[&" "[=" "[&," "[=," */
9151 if (cp_lexer_next_token_is (parser
->lexer
, CPP_AND
)
9152 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_NAME
)
9153 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) = CPLD_REFERENCE
;
9154 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
9155 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) = CPLD_COPY
;
9157 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) != CPLD_NONE
)
9159 cp_lexer_consume_token (parser
->lexer
);
9163 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_SQUARE
))
9165 cp_token
* capture_token
;
9167 tree capture_init_expr
;
9168 cp_id_kind idk
= CP_ID_KIND_NONE
;
9169 bool explicit_init_p
= false;
9171 enum capture_kind_type
9176 enum capture_kind_type capture_kind
= BY_COPY
;
9178 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
9180 error ("expected end of capture-list");
9187 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
9189 /* Possibly capture `this'. */
9190 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_THIS
))
9192 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
9193 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_COPY
)
9194 pedwarn (loc
, 0, "explicit by-copy capture of %<this%> redundant "
9195 "with by-copy capture default");
9196 cp_lexer_consume_token (parser
->lexer
);
9197 add_capture (lambda_expr
,
9198 /*id=*/this_identifier
,
9199 /*initializer=*/finish_this_expr(),
9200 /*by_reference_p=*/false,
9205 /* Remember whether we want to capture as a reference or not. */
9206 if (cp_lexer_next_token_is (parser
->lexer
, CPP_AND
))
9208 capture_kind
= BY_REFERENCE
;
9209 cp_lexer_consume_token (parser
->lexer
);
9212 /* Get the identifier. */
9213 capture_token
= cp_lexer_peek_token (parser
->lexer
);
9214 capture_id
= cp_parser_identifier (parser
);
9216 if (capture_id
== error_mark_node
)
9217 /* Would be nice to have a cp_parser_skip_to_closing_x for general
9218 delimiters, but I modified this to stop on unnested ']' as well. It
9219 was already changed to stop on unnested '}', so the
9220 "closing_parenthesis" name is no more misleading with my change. */
9222 cp_parser_skip_to_closing_parenthesis (parser
,
9223 /*recovering=*/true,
9225 /*consume_paren=*/true);
9229 /* Find the initializer for this capture. */
9230 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
)
9231 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
9232 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
9234 bool direct
, non_constant
;
9235 /* An explicit initializer exists. */
9236 if (cxx_dialect
< cxx14
)
9237 pedwarn (input_location
, 0,
9238 "lambda capture initializers "
9239 "only available with -std=c++14 or -std=gnu++14");
9240 capture_init_expr
= cp_parser_initializer (parser
, &direct
,
9242 explicit_init_p
= true;
9243 if (capture_init_expr
== NULL_TREE
)
9245 error ("empty initializer for lambda init-capture");
9246 capture_init_expr
= error_mark_node
;
9251 const char* error_msg
;
9253 /* Turn the identifier into an id-expression. */
9255 = cp_parser_lookup_name_simple (parser
, capture_id
,
9256 capture_token
->location
);
9258 if (capture_init_expr
== error_mark_node
)
9260 unqualified_name_lookup_error (capture_id
);
9263 else if (DECL_P (capture_init_expr
)
9264 && (!VAR_P (capture_init_expr
)
9265 && TREE_CODE (capture_init_expr
) != PARM_DECL
))
9267 error_at (capture_token
->location
,
9268 "capture of non-variable %qD ",
9270 inform (0, "%q+#D declared here", capture_init_expr
);
9273 if (VAR_P (capture_init_expr
)
9274 && decl_storage_duration (capture_init_expr
) != dk_auto
)
9276 if (pedwarn (capture_token
->location
, 0, "capture of variable "
9277 "%qD with non-automatic storage duration",
9279 inform (0, "%q+#D declared here", capture_init_expr
);
9284 = finish_id_expression
9289 /*integral_constant_expression_p=*/false,
9290 /*allow_non_integral_constant_expression_p=*/false,
9291 /*non_integral_constant_expression_p=*/NULL
,
9292 /*template_p=*/false,
9294 /*address_p=*/false,
9295 /*template_arg_p=*/false,
9297 capture_token
->location
);
9299 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
9301 cp_lexer_consume_token (parser
->lexer
);
9302 capture_init_expr
= make_pack_expansion (capture_init_expr
);
9305 check_for_bare_parameter_packs (capture_init_expr
);
9308 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) != CPLD_NONE
9309 && !explicit_init_p
)
9311 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_COPY
9312 && capture_kind
== BY_COPY
)
9313 pedwarn (capture_token
->location
, 0, "explicit by-copy capture "
9314 "of %qD redundant with by-copy capture default",
9316 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_REFERENCE
9317 && capture_kind
== BY_REFERENCE
)
9318 pedwarn (capture_token
->location
, 0, "explicit by-reference "
9319 "capture of %qD redundant with by-reference capture "
9320 "default", capture_id
);
9323 add_capture (lambda_expr
,
9326 /*by_reference_p=*/capture_kind
== BY_REFERENCE
,
9330 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
9333 /* Parse the (optional) middle of a lambda expression.
9336 < template-parameter-list [opt] >
9337 ( parameter-declaration-clause [opt] )
9338 attribute-specifier [opt]
9340 exception-specification [opt]
9341 lambda-return-type-clause [opt]
9343 LAMBDA_EXPR is the current representation of the lambda expression. */
9346 cp_parser_lambda_declarator_opt (cp_parser
* parser
, tree lambda_expr
)
9348 /* 5.1.1.4 of the standard says:
9349 If a lambda-expression does not include a lambda-declarator, it is as if
9350 the lambda-declarator were ().
9351 This means an empty parameter list, no attributes, and no exception
9353 tree param_list
= void_list_node
;
9354 tree attributes
= NULL_TREE
;
9355 tree exception_spec
= NULL_TREE
;
9356 tree template_param_list
= NULL_TREE
;
9358 /* The template-parameter-list is optional, but must begin with
9359 an opening angle if present. */
9360 if (cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
9362 if (cxx_dialect
< cxx14
)
9363 pedwarn (parser
->lexer
->next_token
->location
, 0,
9364 "lambda templates are only available with "
9365 "-std=c++14 or -std=gnu++14");
9367 cp_lexer_consume_token (parser
->lexer
);
9369 template_param_list
= cp_parser_template_parameter_list (parser
);
9371 cp_parser_skip_to_end_of_template_parameter_list (parser
);
9373 /* We just processed one more parameter list. */
9374 ++parser
->num_template_parameter_lists
;
9377 /* The parameter-declaration-clause is optional (unless
9378 template-parameter-list was given), but must begin with an
9379 opening parenthesis if present. */
9380 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
9382 cp_lexer_consume_token (parser
->lexer
);
9384 begin_scope (sk_function_parms
, /*entity=*/NULL_TREE
);
9386 /* Parse parameters. */
9387 param_list
= cp_parser_parameter_declaration_clause (parser
);
9389 /* Default arguments shall not be specified in the
9390 parameter-declaration-clause of a lambda-declarator. */
9391 for (tree t
= param_list
; t
; t
= TREE_CHAIN (t
))
9392 if (TREE_PURPOSE (t
) && cxx_dialect
< cxx14
)
9393 pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t
)), OPT_Wpedantic
,
9394 "default argument specified for lambda parameter");
9396 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
9398 attributes
= cp_parser_attributes_opt (parser
);
9400 /* Parse optional `mutable' keyword. */
9401 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_MUTABLE
))
9403 cp_lexer_consume_token (parser
->lexer
);
9404 LAMBDA_EXPR_MUTABLE_P (lambda_expr
) = 1;
9407 /* Parse optional exception specification. */
9408 exception_spec
= cp_parser_exception_specification_opt (parser
);
9410 /* Parse optional trailing return type. */
9411 if (cp_lexer_next_token_is (parser
->lexer
, CPP_DEREF
))
9413 cp_lexer_consume_token (parser
->lexer
);
9414 LAMBDA_EXPR_RETURN_TYPE (lambda_expr
)
9415 = cp_parser_trailing_type_id (parser
);
9418 /* The function parameters must be in scope all the way until after the
9419 trailing-return-type in case of decltype. */
9420 pop_bindings_and_leave_scope ();
9422 else if (template_param_list
!= NULL_TREE
) // generate diagnostic
9423 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
9425 /* Create the function call operator.
9427 Messing with declarators like this is no uglier than building up the
9428 FUNCTION_DECL by hand, and this is less likely to get out of sync with
9431 cp_decl_specifier_seq return_type_specs
;
9432 cp_declarator
* declarator
;
9437 clear_decl_specs (&return_type_specs
);
9438 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr
))
9439 return_type_specs
.type
= LAMBDA_EXPR_RETURN_TYPE (lambda_expr
);
9441 /* Maybe we will deduce the return type later. */
9442 return_type_specs
.type
= make_auto ();
9444 p
= obstack_alloc (&declarator_obstack
, 0);
9446 declarator
= make_id_declarator (NULL_TREE
, ansi_opname (CALL_EXPR
),
9449 quals
= (LAMBDA_EXPR_MUTABLE_P (lambda_expr
)
9450 ? TYPE_UNQUALIFIED
: TYPE_QUAL_CONST
);
9451 declarator
= make_call_declarator (declarator
, param_list
, quals
,
9452 VIRT_SPEC_UNSPECIFIED
,
9455 /*late_return_type=*/NULL_TREE
);
9456 declarator
->id_loc
= LAMBDA_EXPR_LOCATION (lambda_expr
);
9458 fco
= grokmethod (&return_type_specs
,
9461 if (fco
!= error_mark_node
)
9463 DECL_INITIALIZED_IN_CLASS_P (fco
) = 1;
9464 DECL_ARTIFICIAL (fco
) = 1;
9465 /* Give the object parameter a different name. */
9466 DECL_NAME (DECL_ARGUMENTS (fco
)) = get_identifier ("__closure");
9467 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr
))
9468 TYPE_HAS_LATE_RETURN_TYPE (TREE_TYPE (fco
)) = 1;
9470 if (template_param_list
)
9472 fco
= finish_member_template_decl (fco
);
9473 finish_template_decl (template_param_list
);
9474 --parser
->num_template_parameter_lists
;
9476 else if (parser
->fully_implicit_function_template_p
)
9477 fco
= finish_fully_implicit_template (parser
, fco
);
9479 finish_member_declaration (fco
);
9481 obstack_free (&declarator_obstack
, p
);
9483 return (fco
!= error_mark_node
);
9487 /* Parse the body of a lambda expression, which is simply
9491 but which requires special handling.
9492 LAMBDA_EXPR is the current representation of the lambda expression. */
9495 cp_parser_lambda_body (cp_parser
* parser
, tree lambda_expr
)
9497 bool nested
= (current_function_decl
!= NULL_TREE
);
9498 bool local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
9500 push_function_context ();
9502 /* Still increment function_depth so that we don't GC in the
9503 middle of an expression. */
9505 /* Clear this in case we're in the middle of a default argument. */
9506 parser
->local_variables_forbidden_p
= false;
9508 /* Finish the function call operator
9510 + late_parsing_for_member
9511 + function_definition_after_declarator
9512 + ctor_initializer_opt_and_function_body */
9514 tree fco
= lambda_function (lambda_expr
);
9520 /* Let the front end know that we are going to be defining this
9522 start_preparsed_function (fco
,
9524 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9526 start_lambda_scope (fco
);
9527 body
= begin_function_body ();
9529 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
9532 /* Push the proxies for any explicit captures. */
9533 for (cap
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
); cap
;
9534 cap
= TREE_CHAIN (cap
))
9535 build_capture_proxy (TREE_PURPOSE (cap
));
9537 compound_stmt
= begin_compound_stmt (0);
9539 /* 5.1.1.4 of the standard says:
9540 If a lambda-expression does not include a trailing-return-type, it
9541 is as if the trailing-return-type denotes the following type:
9542 * if the compound-statement is of the form
9543 { return attribute-specifier [opt] expression ; }
9544 the type of the returned expression after lvalue-to-rvalue
9545 conversion (_conv.lval_ 4.1), array-to-pointer conversion
9546 (_conv.array_ 4.2), and function-to-pointer conversion
9548 * otherwise, void. */
9550 /* In a lambda that has neither a lambda-return-type-clause
9551 nor a deducible form, errors should be reported for return statements
9552 in the body. Since we used void as the placeholder return type, parsing
9553 the body as usual will give such desired behavior. */
9554 if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr
)
9555 && cp_lexer_peek_nth_token (parser
->lexer
, 1)->keyword
== RID_RETURN
9556 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SEMICOLON
)
9558 tree expr
= NULL_TREE
;
9559 cp_id_kind idk
= CP_ID_KIND_NONE
;
9561 /* Parse tentatively in case there's more after the initial return
9563 cp_parser_parse_tentatively (parser
);
9565 cp_parser_require_keyword (parser
, RID_RETURN
, RT_RETURN
);
9567 expr
= cp_parser_expression (parser
, &idk
);
9569 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
9570 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
9572 if (cp_parser_parse_definitely (parser
))
9574 if (!processing_template_decl
)
9575 apply_deduced_return_type (fco
, lambda_return_type (expr
));
9577 /* Will get error here if type not deduced yet. */
9578 finish_return_stmt (expr
);
9586 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_LABEL
))
9587 cp_parser_label_declaration (parser
);
9588 cp_parser_statement_seq_opt (parser
, NULL_TREE
);
9589 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
9592 finish_compound_stmt (compound_stmt
);
9595 finish_function_body (body
);
9596 finish_lambda_scope ();
9598 /* Finish the function and generate code for it if necessary. */
9599 tree fn
= finish_function (/*inline*/2);
9601 /* Only expand if the call op is not a template. */
9602 if (!DECL_TEMPLATE_INFO (fco
))
9603 expand_or_defer_fn (fn
);
9606 parser
->local_variables_forbidden_p
= local_variables_forbidden_p
;
9608 pop_function_context();
9613 /* Statements [gram.stmt.stmt] */
9615 /* Parse a statement.
9619 expression-statement
9624 declaration-statement
9631 attribute-specifier-seq (opt) expression-statement
9632 attribute-specifier-seq (opt) compound-statement
9633 attribute-specifier-seq (opt) selection-statement
9634 attribute-specifier-seq (opt) iteration-statement
9635 attribute-specifier-seq (opt) jump-statement
9636 declaration-statement
9637 attribute-specifier-seq (opt) try-block
9644 IN_COMPOUND is true when the statement is nested inside a
9645 cp_parser_compound_statement; this matters for certain pragmas.
9647 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9648 is a (possibly labeled) if statement which is not enclosed in braces
9649 and has an else clause. This is used to implement -Wparentheses. */
9652 cp_parser_statement (cp_parser
* parser
, tree in_statement_expr
,
9653 bool in_compound
, bool *if_p
)
9655 tree statement
, std_attrs
= NULL_TREE
;
9657 location_t statement_location
, attrs_location
;
9662 /* There is no statement yet. */
9663 statement
= NULL_TREE
;
9665 saved_token_sentinel
saved_tokens (parser
->lexer
);
9666 attrs_location
= cp_lexer_peek_token (parser
->lexer
)->location
;
9667 if (c_dialect_objc ())
9668 /* In obj-c++, seeing '[[' might be the either the beginning of
9669 c++11 attributes, or a nested objc-message-expression. So
9670 let's parse the c++11 attributes tentatively. */
9671 cp_parser_parse_tentatively (parser
);
9672 std_attrs
= cp_parser_std_attribute_spec_seq (parser
);
9673 if (c_dialect_objc ())
9675 if (!cp_parser_parse_definitely (parser
))
9676 std_attrs
= NULL_TREE
;
9679 /* Peek at the next token. */
9680 token
= cp_lexer_peek_token (parser
->lexer
);
9681 /* Remember the location of the first token in the statement. */
9682 statement_location
= token
->location
;
9683 /* If this is a keyword, then that will often determine what kind of
9684 statement we have. */
9685 if (token
->type
== CPP_KEYWORD
)
9687 enum rid keyword
= token
->keyword
;
9693 /* Looks like a labeled-statement with a case label.
9694 Parse the label, and then use tail recursion to parse
9696 cp_parser_label_for_labeled_statement (parser
, std_attrs
);
9701 statement
= cp_parser_selection_statement (parser
, if_p
);
9707 statement
= cp_parser_iteration_statement (parser
, false);
9713 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
9714 "-fcilkplus must be enabled to use %<_Cilk_for%>");
9715 cp_lexer_consume_token (parser
->lexer
);
9716 statement
= error_mark_node
;
9719 statement
= cp_parser_cilk_for (parser
, integer_zero_node
);
9726 statement
= cp_parser_jump_statement (parser
);
9730 cp_lexer_consume_token (parser
->lexer
);
9733 tree sync_expr
= build_cilk_sync ();
9734 SET_EXPR_LOCATION (sync_expr
,
9736 statement
= finish_expr_stmt (sync_expr
);
9740 error_at (token
->location
, "-fcilkplus must be enabled to use"
9742 statement
= error_mark_node
;
9744 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
9747 /* Objective-C++ exception-handling constructs. */
9750 case RID_AT_FINALLY
:
9751 case RID_AT_SYNCHRONIZED
:
9753 statement
= cp_parser_objc_statement (parser
);
9757 statement
= cp_parser_try_block (parser
);
9761 /* This must be a namespace alias definition. */
9762 cp_parser_declaration_statement (parser
);
9765 case RID_TRANSACTION_ATOMIC
:
9766 case RID_TRANSACTION_RELAXED
:
9767 statement
= cp_parser_transaction (parser
, keyword
);
9769 case RID_TRANSACTION_CANCEL
:
9770 statement
= cp_parser_transaction_cancel (parser
);
9774 /* It might be a keyword like `int' that can start a
9775 declaration-statement. */
9779 else if (token
->type
== CPP_NAME
)
9781 /* If the next token is a `:', then we are looking at a
9782 labeled-statement. */
9783 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
9784 if (token
->type
== CPP_COLON
)
9786 /* Looks like a labeled-statement with an ordinary label.
9787 Parse the label, and then use tail recursion to parse
9790 cp_parser_label_for_labeled_statement (parser
, std_attrs
);
9794 /* Anything that starts with a `{' must be a compound-statement. */
9795 else if (token
->type
== CPP_OPEN_BRACE
)
9796 statement
= cp_parser_compound_statement (parser
, NULL
, false, false);
9797 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
9798 a statement all its own. */
9799 else if (token
->type
== CPP_PRAGMA
)
9801 /* Only certain OpenMP pragmas are attached to statements, and thus
9802 are considered statements themselves. All others are not. In
9803 the context of a compound, accept the pragma as a "statement" and
9804 return so that we can check for a close brace. Otherwise we
9805 require a real statement and must go back and read one. */
9807 cp_parser_pragma (parser
, pragma_compound
);
9808 else if (!cp_parser_pragma (parser
, pragma_stmt
))
9812 else if (token
->type
== CPP_EOF
)
9814 cp_parser_error (parser
, "expected statement");
9818 /* Everything else must be a declaration-statement or an
9819 expression-statement. Try for the declaration-statement
9820 first, unless we are looking at a `;', in which case we know that
9821 we have an expression-statement. */
9824 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
9826 if (std_attrs
!= NULL_TREE
)
9828 /* Attributes should be parsed as part of the the
9829 declaration, so let's un-parse them. */
9830 saved_tokens
.rollback();
9831 std_attrs
= NULL_TREE
;
9834 cp_parser_parse_tentatively (parser
);
9835 /* Try to parse the declaration-statement. */
9836 cp_parser_declaration_statement (parser
);
9837 /* If that worked, we're done. */
9838 if (cp_parser_parse_definitely (parser
))
9841 /* Look for an expression-statement instead. */
9842 statement
= cp_parser_expression_statement (parser
, in_statement_expr
);
9845 /* Set the line number for the statement. */
9846 if (statement
&& STATEMENT_CODE_P (TREE_CODE (statement
)))
9847 SET_EXPR_LOCATION (statement
, statement_location
);
9849 /* Note that for now, we don't do anything with c++11 statements
9850 parsed at this level. */
9851 if (std_attrs
!= NULL_TREE
)
9852 warning_at (attrs_location
,
9854 "attributes at the beginning of statement are ignored");
9857 /* Parse the label for a labeled-statement, i.e.
9860 case constant-expression :
9864 case constant-expression ... constant-expression : statement
9866 When a label is parsed without errors, the label is added to the
9867 parse tree by the finish_* functions, so this function doesn't
9868 have to return the label. */
9871 cp_parser_label_for_labeled_statement (cp_parser
* parser
, tree attributes
)
9874 tree label
= NULL_TREE
;
9875 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
9877 /* The next token should be an identifier. */
9878 token
= cp_lexer_peek_token (parser
->lexer
);
9879 if (token
->type
!= CPP_NAME
9880 && token
->type
!= CPP_KEYWORD
)
9882 cp_parser_error (parser
, "expected labeled-statement");
9886 parser
->colon_corrects_to_scope_p
= false;
9887 switch (token
->keyword
)
9894 /* Consume the `case' token. */
9895 cp_lexer_consume_token (parser
->lexer
);
9896 /* Parse the constant-expression. */
9897 expr
= cp_parser_constant_expression (parser
);
9898 if (check_for_bare_parameter_packs (expr
))
9899 expr
= error_mark_node
;
9901 ellipsis
= cp_lexer_peek_token (parser
->lexer
);
9902 if (ellipsis
->type
== CPP_ELLIPSIS
)
9904 /* Consume the `...' token. */
9905 cp_lexer_consume_token (parser
->lexer
);
9906 expr_hi
= cp_parser_constant_expression (parser
);
9907 if (check_for_bare_parameter_packs (expr_hi
))
9908 expr_hi
= error_mark_node
;
9910 /* We don't need to emit warnings here, as the common code
9911 will do this for us. */
9914 expr_hi
= NULL_TREE
;
9916 if (parser
->in_switch_statement_p
)
9917 finish_case_label (token
->location
, expr
, expr_hi
);
9919 error_at (token
->location
,
9920 "case label %qE not within a switch statement",
9926 /* Consume the `default' token. */
9927 cp_lexer_consume_token (parser
->lexer
);
9929 if (parser
->in_switch_statement_p
)
9930 finish_case_label (token
->location
, NULL_TREE
, NULL_TREE
);
9932 error_at (token
->location
, "case label not within a switch statement");
9936 /* Anything else must be an ordinary label. */
9937 label
= finish_label_stmt (cp_parser_identifier (parser
));
9941 /* Require the `:' token. */
9942 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
9944 /* An ordinary label may optionally be followed by attributes.
9945 However, this is only permitted if the attributes are then
9946 followed by a semicolon. This is because, for backward
9947 compatibility, when parsing
9948 lab: __attribute__ ((unused)) int i;
9949 we want the attribute to attach to "i", not "lab". */
9950 if (label
!= NULL_TREE
9951 && cp_next_tokens_can_be_gnu_attribute_p (parser
))
9954 cp_parser_parse_tentatively (parser
);
9955 attrs
= cp_parser_gnu_attributes_opt (parser
);
9956 if (attrs
== NULL_TREE
9957 || cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
9958 cp_parser_abort_tentative_parse (parser
);
9959 else if (!cp_parser_parse_definitely (parser
))
9962 attributes
= chainon (attributes
, attrs
);
9965 if (attributes
!= NULL_TREE
)
9966 cplus_decl_attributes (&label
, attributes
, 0);
9968 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
9971 /* Parse an expression-statement.
9973 expression-statement:
9976 Returns the new EXPR_STMT -- or NULL_TREE if the expression
9977 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
9978 indicates whether this expression-statement is part of an
9979 expression statement. */
9982 cp_parser_expression_statement (cp_parser
* parser
, tree in_statement_expr
)
9984 tree statement
= NULL_TREE
;
9985 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
9987 /* If the next token is a ';', then there is no expression
9989 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
9991 statement
= cp_parser_expression (parser
);
9992 if (statement
== error_mark_node
9993 && !cp_parser_uncommitted_to_tentative_parse_p (parser
))
9995 cp_parser_skip_to_end_of_block_or_statement (parser
);
9996 return error_mark_node
;
10000 /* Give a helpful message for "A<T>::type t;" and the like. */
10001 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
)
10002 && !cp_parser_uncommitted_to_tentative_parse_p (parser
))
10004 if (TREE_CODE (statement
) == SCOPE_REF
)
10005 error_at (token
->location
, "need %<typename%> before %qE because "
10006 "%qT is a dependent scope",
10007 statement
, TREE_OPERAND (statement
, 0));
10008 else if (is_overloaded_fn (statement
)
10009 && DECL_CONSTRUCTOR_P (get_first_fn (statement
)))
10012 tree fn
= get_first_fn (statement
);
10013 error_at (token
->location
,
10014 "%<%T::%D%> names the constructor, not the type",
10015 DECL_CONTEXT (fn
), DECL_NAME (fn
));
10019 /* Consume the final `;'. */
10020 cp_parser_consume_semicolon_at_end_of_statement (parser
);
10022 if (in_statement_expr
10023 && cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
10024 /* This is the final expression statement of a statement
10026 statement
= finish_stmt_expr_expr (statement
, in_statement_expr
);
10027 else if (statement
)
10028 statement
= finish_expr_stmt (statement
);
10033 /* Parse a compound-statement.
10035 compound-statement:
10036 { statement-seq [opt] }
10040 compound-statement:
10041 { label-declaration-seq [opt] statement-seq [opt] }
10043 label-declaration-seq:
10045 label-declaration-seq label-declaration
10047 Returns a tree representing the statement. */
10050 cp_parser_compound_statement (cp_parser
*parser
, tree in_statement_expr
,
10051 bool in_try
, bool function_body
)
10053 tree compound_stmt
;
10055 /* Consume the `{'. */
10056 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
10057 return error_mark_node
;
10058 if (DECL_DECLARED_CONSTEXPR_P (current_function_decl
)
10059 && !function_body
&& cxx_dialect
< cxx14
)
10060 pedwarn (input_location
, OPT_Wpedantic
,
10061 "compound-statement in constexpr function");
10062 /* Begin the compound-statement. */
10063 compound_stmt
= begin_compound_stmt (in_try
? BCS_TRY_BLOCK
: 0);
10064 /* If the next keyword is `__label__' we have a label declaration. */
10065 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_LABEL
))
10066 cp_parser_label_declaration (parser
);
10067 /* Parse an (optional) statement-seq. */
10068 cp_parser_statement_seq_opt (parser
, in_statement_expr
);
10069 /* Finish the compound-statement. */
10070 finish_compound_stmt (compound_stmt
);
10071 /* Consume the `}'. */
10072 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
10074 return compound_stmt
;
10077 /* Parse an (optional) statement-seq.
10081 statement-seq [opt] statement */
10084 cp_parser_statement_seq_opt (cp_parser
* parser
, tree in_statement_expr
)
10086 /* Scan statements until there aren't any more. */
10089 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
10091 /* If we are looking at a `}', then we have run out of
10092 statements; the same is true if we have reached the end
10093 of file, or have stumbled upon a stray '@end'. */
10094 if (token
->type
== CPP_CLOSE_BRACE
10095 || token
->type
== CPP_EOF
10096 || token
->type
== CPP_PRAGMA_EOL
10097 || (token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_AT_END
))
10100 /* If we are in a compound statement and find 'else' then
10101 something went wrong. */
10102 else if (token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_ELSE
)
10104 if (parser
->in_statement
& IN_IF_STMT
)
10108 token
= cp_lexer_consume_token (parser
->lexer
);
10109 error_at (token
->location
, "%<else%> without a previous %<if%>");
10113 /* Parse the statement. */
10114 cp_parser_statement (parser
, in_statement_expr
, true, NULL
);
10118 /* Parse a selection-statement.
10120 selection-statement:
10121 if ( condition ) statement
10122 if ( condition ) statement else statement
10123 switch ( condition ) statement
10125 Returns the new IF_STMT or SWITCH_STMT.
10127 If IF_P is not NULL, *IF_P is set to indicate whether the statement
10128 is a (possibly labeled) if statement which is not enclosed in
10129 braces and has an else clause. This is used to implement
10133 cp_parser_selection_statement (cp_parser
* parser
, bool *if_p
)
10141 /* Peek at the next token. */
10142 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_SELECT
);
10144 /* See what kind of keyword it is. */
10145 keyword
= token
->keyword
;
10154 /* Look for the `('. */
10155 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
10157 cp_parser_skip_to_end_of_statement (parser
);
10158 return error_mark_node
;
10161 /* Begin the selection-statement. */
10162 if (keyword
== RID_IF
)
10163 statement
= begin_if_stmt ();
10165 statement
= begin_switch_stmt ();
10167 /* Parse the condition. */
10168 condition
= cp_parser_condition (parser
);
10169 /* Look for the `)'. */
10170 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
10171 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
10172 /*consume_paren=*/true);
10174 if (keyword
== RID_IF
)
10177 unsigned char in_statement
;
10179 /* Add the condition. */
10180 finish_if_stmt_cond (condition
, statement
);
10182 /* Parse the then-clause. */
10183 in_statement
= parser
->in_statement
;
10184 parser
->in_statement
|= IN_IF_STMT
;
10185 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
10187 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
10188 add_stmt (build_empty_stmt (loc
));
10189 cp_lexer_consume_token (parser
->lexer
);
10190 if (!cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ELSE
))
10191 warning_at (loc
, OPT_Wempty_body
, "suggest braces around "
10192 "empty body in an %<if%> statement");
10196 cp_parser_implicitly_scoped_statement (parser
, &nested_if
);
10197 parser
->in_statement
= in_statement
;
10199 finish_then_clause (statement
);
10201 /* If the next token is `else', parse the else-clause. */
10202 if (cp_lexer_next_token_is_keyword (parser
->lexer
,
10205 /* Consume the `else' keyword. */
10206 cp_lexer_consume_token (parser
->lexer
);
10207 begin_else_clause (statement
);
10208 /* Parse the else-clause. */
10209 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
10212 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
10214 OPT_Wempty_body
, "suggest braces around "
10215 "empty body in an %<else%> statement");
10216 add_stmt (build_empty_stmt (loc
));
10217 cp_lexer_consume_token (parser
->lexer
);
10220 cp_parser_implicitly_scoped_statement (parser
, NULL
);
10222 finish_else_clause (statement
);
10224 /* If we are currently parsing a then-clause, then
10225 IF_P will not be NULL. We set it to true to
10226 indicate that this if statement has an else clause.
10227 This may trigger the Wparentheses warning below
10228 when we get back up to the parent if statement. */
10234 /* This if statement does not have an else clause. If
10235 NESTED_IF is true, then the then-clause is an if
10236 statement which does have an else clause. We warn
10237 about the potential ambiguity. */
10239 warning_at (EXPR_LOCATION (statement
), OPT_Wparentheses
,
10240 "suggest explicit braces to avoid ambiguous"
10244 /* Now we're all done with the if-statement. */
10245 finish_if_stmt (statement
);
10249 bool in_switch_statement_p
;
10250 unsigned char in_statement
;
10252 /* Add the condition. */
10253 finish_switch_cond (condition
, statement
);
10255 /* Parse the body of the switch-statement. */
10256 in_switch_statement_p
= parser
->in_switch_statement_p
;
10257 in_statement
= parser
->in_statement
;
10258 parser
->in_switch_statement_p
= true;
10259 parser
->in_statement
|= IN_SWITCH_STMT
;
10260 cp_parser_implicitly_scoped_statement (parser
, NULL
);
10261 parser
->in_switch_statement_p
= in_switch_statement_p
;
10262 parser
->in_statement
= in_statement
;
10264 /* Now we're all done with the switch-statement. */
10265 finish_switch_stmt (statement
);
10273 cp_parser_error (parser
, "expected selection-statement");
10274 return error_mark_node
;
10278 /* Parse a condition.
10282 type-specifier-seq declarator = initializer-clause
10283 type-specifier-seq declarator braced-init-list
10288 type-specifier-seq declarator asm-specification [opt]
10289 attributes [opt] = assignment-expression
10291 Returns the expression that should be tested. */
10294 cp_parser_condition (cp_parser
* parser
)
10296 cp_decl_specifier_seq type_specifiers
;
10297 const char *saved_message
;
10298 int declares_class_or_enum
;
10300 /* Try the declaration first. */
10301 cp_parser_parse_tentatively (parser
);
10302 /* New types are not allowed in the type-specifier-seq for a
10304 saved_message
= parser
->type_definition_forbidden_message
;
10305 parser
->type_definition_forbidden_message
10306 = G_("types may not be defined in conditions");
10307 /* Parse the type-specifier-seq. */
10308 cp_parser_decl_specifier_seq (parser
,
10309 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR
,
10311 &declares_class_or_enum
);
10312 /* Restore the saved message. */
10313 parser
->type_definition_forbidden_message
= saved_message
;
10314 /* If all is well, we might be looking at a declaration. */
10315 if (!cp_parser_error_occurred (parser
))
10318 tree asm_specification
;
10320 cp_declarator
*declarator
;
10321 tree initializer
= NULL_TREE
;
10323 /* Parse the declarator. */
10324 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
10325 /*ctor_dtor_or_conv_p=*/NULL
,
10326 /*parenthesized_p=*/NULL
,
10327 /*member_p=*/false,
10328 /*friend_p=*/false);
10329 /* Parse the attributes. */
10330 attributes
= cp_parser_attributes_opt (parser
);
10331 /* Parse the asm-specification. */
10332 asm_specification
= cp_parser_asm_specification_opt (parser
);
10333 /* If the next token is not an `=' or '{', then we might still be
10334 looking at an expression. For example:
10338 looks like a decl-specifier-seq and a declarator -- but then
10339 there is no `=', so this is an expression. */
10340 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
)
10341 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
10342 cp_parser_simulate_error (parser
);
10344 /* If we did see an `=' or '{', then we are looking at a declaration
10346 if (cp_parser_parse_definitely (parser
))
10349 bool non_constant_p
;
10350 bool flags
= LOOKUP_ONLYCONVERTING
;
10352 /* Create the declaration. */
10353 decl
= start_decl (declarator
, &type_specifiers
,
10354 /*initialized_p=*/true,
10355 attributes
, /*prefix_attributes=*/NULL_TREE
,
10358 /* Parse the initializer. */
10359 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
10361 initializer
= cp_parser_braced_list (parser
, &non_constant_p
);
10362 CONSTRUCTOR_IS_DIRECT_INIT (initializer
) = 1;
10367 /* Consume the `='. */
10368 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
10369 initializer
= cp_parser_initializer_clause (parser
, &non_constant_p
);
10371 if (BRACE_ENCLOSED_INITIALIZER_P (initializer
))
10372 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
10374 /* Process the initializer. */
10375 cp_finish_decl (decl
,
10376 initializer
, !non_constant_p
,
10381 pop_scope (pushed_scope
);
10383 return convert_from_reference (decl
);
10386 /* If we didn't even get past the declarator successfully, we are
10387 definitely not looking at a declaration. */
10389 cp_parser_abort_tentative_parse (parser
);
10391 /* Otherwise, we are looking at an expression. */
10392 return cp_parser_expression (parser
);
10395 /* Parses a for-statement or range-for-statement until the closing ')',
10399 cp_parser_for (cp_parser
*parser
, bool ivdep
)
10401 tree init
, scope
, decl
;
10404 /* Begin the for-statement. */
10405 scope
= begin_for_scope (&init
);
10407 /* Parse the initialization. */
10408 is_range_for
= cp_parser_for_init_statement (parser
, &decl
);
10411 return cp_parser_range_for (parser
, scope
, init
, decl
, ivdep
);
10413 return cp_parser_c_for (parser
, scope
, init
, ivdep
);
10417 cp_parser_c_for (cp_parser
*parser
, tree scope
, tree init
, bool ivdep
)
10419 /* Normal for loop */
10420 tree condition
= NULL_TREE
;
10421 tree expression
= NULL_TREE
;
10424 stmt
= begin_for_stmt (scope
, init
);
10425 /* The for-init-statement has already been parsed in
10426 cp_parser_for_init_statement, so no work is needed here. */
10427 finish_for_init_stmt (stmt
);
10429 /* If there's a condition, process it. */
10430 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
10431 condition
= cp_parser_condition (parser
);
10434 cp_parser_error (parser
, "missing loop condition in loop with "
10435 "%<GCC ivdep%> pragma");
10436 condition
= error_mark_node
;
10438 finish_for_cond (condition
, stmt
, ivdep
);
10439 /* Look for the `;'. */
10440 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
10442 /* If there's an expression, process it. */
10443 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
10444 expression
= cp_parser_expression (parser
);
10445 finish_for_expr (expression
, stmt
);
10450 /* Tries to parse a range-based for-statement:
10453 decl-specifier-seq declarator : expression
10455 The decl-specifier-seq declarator and the `:' are already parsed by
10456 cp_parser_for_init_statement. If processing_template_decl it returns a
10457 newly created RANGE_FOR_STMT; if not, it is converted to a
10458 regular FOR_STMT. */
10461 cp_parser_range_for (cp_parser
*parser
, tree scope
, tree init
, tree range_decl
,
10464 tree stmt
, range_expr
;
10466 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
10468 bool expr_non_constant_p
;
10469 range_expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
10472 range_expr
= cp_parser_expression (parser
);
10474 /* If in template, STMT is converted to a normal for-statement
10475 at instantiation. If not, it is done just ahead. */
10476 if (processing_template_decl
)
10478 if (check_for_bare_parameter_packs (range_expr
))
10479 range_expr
= error_mark_node
;
10480 stmt
= begin_range_for_stmt (scope
, init
);
10482 RANGE_FOR_IVDEP (stmt
) = 1;
10483 finish_range_for_decl (stmt
, range_decl
, range_expr
);
10484 if (!type_dependent_expression_p (range_expr
)
10485 /* do_auto_deduction doesn't mess with template init-lists. */
10486 && !BRACE_ENCLOSED_INITIALIZER_P (range_expr
))
10487 do_range_for_auto_deduction (range_decl
, range_expr
);
10491 stmt
= begin_for_stmt (scope
, init
);
10492 stmt
= cp_convert_range_for (stmt
, range_decl
, range_expr
, ivdep
);
10497 /* Subroutine of cp_convert_range_for: given the initializer expression,
10498 builds up the range temporary. */
10501 build_range_temp (tree range_expr
)
10503 tree range_type
, range_temp
;
10505 /* Find out the type deduced by the declaration
10506 `auto &&__range = range_expr'. */
10507 range_type
= cp_build_reference_type (make_auto (), true);
10508 range_type
= do_auto_deduction (range_type
, range_expr
,
10509 type_uses_auto (range_type
));
10511 /* Create the __range variable. */
10512 range_temp
= build_decl (input_location
, VAR_DECL
,
10513 get_identifier ("__for_range"), range_type
);
10514 TREE_USED (range_temp
) = 1;
10515 DECL_ARTIFICIAL (range_temp
) = 1;
10520 /* Used by cp_parser_range_for in template context: we aren't going to
10521 do a full conversion yet, but we still need to resolve auto in the
10522 type of the for-range-declaration if present. This is basically
10523 a shortcut version of cp_convert_range_for. */
10526 do_range_for_auto_deduction (tree decl
, tree range_expr
)
10528 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
10531 tree begin_dummy
, end_dummy
, range_temp
, iter_type
, iter_decl
;
10532 range_temp
= convert_from_reference (build_range_temp (range_expr
));
10533 iter_type
= (cp_parser_perform_range_for_lookup
10534 (range_temp
, &begin_dummy
, &end_dummy
));
10537 iter_decl
= build_decl (input_location
, VAR_DECL
, NULL_TREE
,
10539 iter_decl
= build_x_indirect_ref (input_location
, iter_decl
, RO_NULL
,
10540 tf_warning_or_error
);
10541 TREE_TYPE (decl
) = do_auto_deduction (TREE_TYPE (decl
),
10542 iter_decl
, auto_node
);
10547 /* Converts a range-based for-statement into a normal
10548 for-statement, as per the definition.
10550 for (RANGE_DECL : RANGE_EXPR)
10553 should be equivalent to:
10556 auto &&__range = RANGE_EXPR;
10557 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
10561 RANGE_DECL = *__begin;
10566 If RANGE_EXPR is an array:
10567 BEGIN_EXPR = __range
10568 END_EXPR = __range + ARRAY_SIZE(__range)
10569 Else if RANGE_EXPR has a member 'begin' or 'end':
10570 BEGIN_EXPR = __range.begin()
10571 END_EXPR = __range.end()
10573 BEGIN_EXPR = begin(__range)
10574 END_EXPR = end(__range);
10576 If __range has a member 'begin' but not 'end', or vice versa, we must
10577 still use the second alternative (it will surely fail, however).
10578 When calling begin()/end() in the third alternative we must use
10579 argument dependent lookup, but always considering 'std' as an associated
10583 cp_convert_range_for (tree statement
, tree range_decl
, tree range_expr
,
10587 tree iter_type
, begin_expr
, end_expr
;
10588 tree condition
, expression
;
10590 if (range_decl
== error_mark_node
|| range_expr
== error_mark_node
)
10591 /* If an error happened previously do nothing or else a lot of
10592 unhelpful errors would be issued. */
10593 begin_expr
= end_expr
= iter_type
= error_mark_node
;
10598 if (TREE_CODE (range_expr
) == VAR_DECL
10599 && array_of_runtime_bound_p (TREE_TYPE (range_expr
)))
10600 /* Can't bind a reference to an array of runtime bound. */
10601 range_temp
= range_expr
;
10604 range_temp
= build_range_temp (range_expr
);
10605 pushdecl (range_temp
);
10606 cp_finish_decl (range_temp
, range_expr
,
10607 /*is_constant_init*/false, NULL_TREE
,
10608 LOOKUP_ONLYCONVERTING
);
10609 range_temp
= convert_from_reference (range_temp
);
10611 iter_type
= cp_parser_perform_range_for_lookup (range_temp
,
10612 &begin_expr
, &end_expr
);
10615 /* The new for initialization statement. */
10616 begin
= build_decl (input_location
, VAR_DECL
,
10617 get_identifier ("__for_begin"), iter_type
);
10618 TREE_USED (begin
) = 1;
10619 DECL_ARTIFICIAL (begin
) = 1;
10621 cp_finish_decl (begin
, begin_expr
,
10622 /*is_constant_init*/false, NULL_TREE
,
10623 LOOKUP_ONLYCONVERTING
);
10625 end
= build_decl (input_location
, VAR_DECL
,
10626 get_identifier ("__for_end"), iter_type
);
10627 TREE_USED (end
) = 1;
10628 DECL_ARTIFICIAL (end
) = 1;
10630 cp_finish_decl (end
, end_expr
,
10631 /*is_constant_init*/false, NULL_TREE
,
10632 LOOKUP_ONLYCONVERTING
);
10634 finish_for_init_stmt (statement
);
10636 /* The new for condition. */
10637 condition
= build_x_binary_op (input_location
, NE_EXPR
,
10640 NULL
, tf_warning_or_error
);
10641 finish_for_cond (condition
, statement
, ivdep
);
10643 /* The new increment expression. */
10644 expression
= finish_unary_op_expr (input_location
,
10645 PREINCREMENT_EXPR
, begin
,
10646 tf_warning_or_error
);
10647 finish_for_expr (expression
, statement
);
10649 /* The declaration is initialized with *__begin inside the loop body. */
10650 cp_finish_decl (range_decl
,
10651 build_x_indirect_ref (input_location
, begin
, RO_NULL
,
10652 tf_warning_or_error
),
10653 /*is_constant_init*/false, NULL_TREE
,
10654 LOOKUP_ONLYCONVERTING
);
10659 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
10660 We need to solve both at the same time because the method used
10661 depends on the existence of members begin or end.
10662 Returns the type deduced for the iterator expression. */
10665 cp_parser_perform_range_for_lookup (tree range
, tree
*begin
, tree
*end
)
10667 if (error_operand_p (range
))
10669 *begin
= *end
= error_mark_node
;
10670 return error_mark_node
;
10673 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (range
))))
10675 error ("range-based %<for%> expression of type %qT "
10676 "has incomplete type", TREE_TYPE (range
));
10677 *begin
= *end
= error_mark_node
;
10678 return error_mark_node
;
10680 if (TREE_CODE (TREE_TYPE (range
)) == ARRAY_TYPE
)
10682 /* If RANGE is an array, we will use pointer arithmetic. */
10684 *end
= build_binary_op (input_location
, PLUS_EXPR
,
10686 array_type_nelts_top (TREE_TYPE (range
)),
10688 return build_pointer_type (TREE_TYPE (TREE_TYPE (range
)));
10692 /* If it is not an array, we must do a bit of magic. */
10693 tree id_begin
, id_end
;
10694 tree member_begin
, member_end
;
10696 *begin
= *end
= error_mark_node
;
10698 id_begin
= get_identifier ("begin");
10699 id_end
= get_identifier ("end");
10700 member_begin
= lookup_member (TREE_TYPE (range
), id_begin
,
10701 /*protect=*/2, /*want_type=*/false,
10702 tf_warning_or_error
);
10703 member_end
= lookup_member (TREE_TYPE (range
), id_end
,
10704 /*protect=*/2, /*want_type=*/false,
10705 tf_warning_or_error
);
10707 if (member_begin
!= NULL_TREE
|| member_end
!= NULL_TREE
)
10709 /* Use the member functions. */
10710 if (member_begin
!= NULL_TREE
)
10711 *begin
= cp_parser_range_for_member_function (range
, id_begin
);
10713 error ("range-based %<for%> expression of type %qT has an "
10714 "%<end%> member but not a %<begin%>", TREE_TYPE (range
));
10716 if (member_end
!= NULL_TREE
)
10717 *end
= cp_parser_range_for_member_function (range
, id_end
);
10719 error ("range-based %<for%> expression of type %qT has a "
10720 "%<begin%> member but not an %<end%>", TREE_TYPE (range
));
10724 /* Use global functions with ADL. */
10725 vec
<tree
, va_gc
> *vec
;
10726 vec
= make_tree_vector ();
10728 vec_safe_push (vec
, range
);
10730 member_begin
= perform_koenig_lookup (id_begin
, vec
,
10731 tf_warning_or_error
);
10732 *begin
= finish_call_expr (member_begin
, &vec
, false, true,
10733 tf_warning_or_error
);
10734 member_end
= perform_koenig_lookup (id_end
, vec
,
10735 tf_warning_or_error
);
10736 *end
= finish_call_expr (member_end
, &vec
, false, true,
10737 tf_warning_or_error
);
10739 release_tree_vector (vec
);
10742 /* Last common checks. */
10743 if (*begin
== error_mark_node
|| *end
== error_mark_node
)
10745 /* If one of the expressions is an error do no more checks. */
10746 *begin
= *end
= error_mark_node
;
10747 return error_mark_node
;
10749 else if (type_dependent_expression_p (*begin
)
10750 || type_dependent_expression_p (*end
))
10751 /* Can happen, when, eg, in a template context, Koenig lookup
10752 can't resolve begin/end (c++/58503). */
10756 tree iter_type
= cv_unqualified (TREE_TYPE (*begin
));
10757 /* The unqualified type of the __begin and __end temporaries should
10758 be the same, as required by the multiple auto declaration. */
10759 if (!same_type_p (iter_type
, cv_unqualified (TREE_TYPE (*end
))))
10760 error ("inconsistent begin/end types in range-based %<for%> "
10761 "statement: %qT and %qT",
10762 TREE_TYPE (*begin
), TREE_TYPE (*end
));
10768 /* Helper function for cp_parser_perform_range_for_lookup.
10769 Builds a tree for RANGE.IDENTIFIER(). */
10772 cp_parser_range_for_member_function (tree range
, tree identifier
)
10775 vec
<tree
, va_gc
> *vec
;
10777 member
= finish_class_member_access_expr (range
, identifier
,
10778 false, tf_warning_or_error
);
10779 if (member
== error_mark_node
)
10780 return error_mark_node
;
10782 vec
= make_tree_vector ();
10783 res
= finish_call_expr (member
, &vec
,
10784 /*disallow_virtual=*/false,
10785 /*koenig_p=*/false,
10786 tf_warning_or_error
);
10787 release_tree_vector (vec
);
10791 /* Parse an iteration-statement.
10793 iteration-statement:
10794 while ( condition ) statement
10795 do statement while ( expression ) ;
10796 for ( for-init-statement condition [opt] ; expression [opt] )
10799 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
10802 cp_parser_iteration_statement (cp_parser
* parser
, bool ivdep
)
10807 unsigned char in_statement
;
10809 /* Peek at the next token. */
10810 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_INTERATION
);
10812 return error_mark_node
;
10814 /* Remember whether or not we are already within an iteration
10816 in_statement
= parser
->in_statement
;
10818 /* See what kind of keyword it is. */
10819 keyword
= token
->keyword
;
10826 /* Begin the while-statement. */
10827 statement
= begin_while_stmt ();
10828 /* Look for the `('. */
10829 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
10830 /* Parse the condition. */
10831 condition
= cp_parser_condition (parser
);
10832 finish_while_stmt_cond (condition
, statement
, ivdep
);
10833 /* Look for the `)'. */
10834 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
10835 /* Parse the dependent statement. */
10836 parser
->in_statement
= IN_ITERATION_STMT
;
10837 cp_parser_already_scoped_statement (parser
);
10838 parser
->in_statement
= in_statement
;
10839 /* We're done with the while-statement. */
10840 finish_while_stmt (statement
);
10848 /* Begin the do-statement. */
10849 statement
= begin_do_stmt ();
10850 /* Parse the body of the do-statement. */
10851 parser
->in_statement
= IN_ITERATION_STMT
;
10852 cp_parser_implicitly_scoped_statement (parser
, NULL
);
10853 parser
->in_statement
= in_statement
;
10854 finish_do_body (statement
);
10855 /* Look for the `while' keyword. */
10856 cp_parser_require_keyword (parser
, RID_WHILE
, RT_WHILE
);
10857 /* Look for the `('. */
10858 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
10859 /* Parse the expression. */
10860 expression
= cp_parser_expression (parser
);
10861 /* We're done with the do-statement. */
10862 finish_do_stmt (expression
, statement
, ivdep
);
10863 /* Look for the `)'. */
10864 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
10865 /* Look for the `;'. */
10866 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
10872 /* Look for the `('. */
10873 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
10875 statement
= cp_parser_for (parser
, ivdep
);
10877 /* Look for the `)'. */
10878 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
10880 /* Parse the body of the for-statement. */
10881 parser
->in_statement
= IN_ITERATION_STMT
;
10882 cp_parser_already_scoped_statement (parser
);
10883 parser
->in_statement
= in_statement
;
10885 /* We're done with the for-statement. */
10886 finish_for_stmt (statement
);
10891 cp_parser_error (parser
, "expected iteration-statement");
10892 statement
= error_mark_node
;
10899 /* Parse a for-init-statement or the declarator of a range-based-for.
10900 Returns true if a range-based-for declaration is seen.
10902 for-init-statement:
10903 expression-statement
10904 simple-declaration */
10907 cp_parser_for_init_statement (cp_parser
* parser
, tree
*decl
)
10909 /* If the next token is a `;', then we have an empty
10910 expression-statement. Grammatically, this is also a
10911 simple-declaration, but an invalid one, because it does not
10912 declare anything. Therefore, if we did not handle this case
10913 specially, we would issue an error message about an invalid
10915 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
10917 bool is_range_for
= false;
10918 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
10920 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
10921 && cp_lexer_nth_token_is (parser
->lexer
, 2, CPP_COLON
))
10923 /* N3994 -- for (id : init) ... */
10924 if (cxx_dialect
< cxx1z
)
10925 pedwarn (input_location
, 0, "range-based for loop without a "
10926 "type-specifier only available with "
10927 "-std=c++1z or -std=gnu++1z");
10928 tree name
= cp_parser_identifier (parser
);
10929 tree type
= cp_build_reference_type (make_auto (), /*rval*/true);
10930 *decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
10932 cp_lexer_consume_token (parser
->lexer
);
10936 /* A colon is used in range-based for. */
10937 parser
->colon_corrects_to_scope_p
= false;
10939 /* We're going to speculatively look for a declaration, falling back
10940 to an expression, if necessary. */
10941 cp_parser_parse_tentatively (parser
);
10942 /* Parse the declaration. */
10943 cp_parser_simple_declaration (parser
,
10944 /*function_definition_allowed_p=*/false,
10946 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
10947 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
10949 /* It is a range-for, consume the ':' */
10950 cp_lexer_consume_token (parser
->lexer
);
10951 is_range_for
= true;
10952 if (cxx_dialect
< cxx11
)
10954 pedwarn (cp_lexer_peek_token (parser
->lexer
)->location
, 0,
10955 "range-based %<for%> loops only available with "
10956 "-std=c++11 or -std=gnu++11");
10957 *decl
= error_mark_node
;
10961 /* The ';' is not consumed yet because we told
10962 cp_parser_simple_declaration not to. */
10963 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
10965 if (cp_parser_parse_definitely (parser
))
10966 return is_range_for
;
10967 /* If the tentative parse failed, then we shall need to look for an
10968 expression-statement. */
10970 /* If we are here, it is an expression-statement. */
10971 cp_parser_expression_statement (parser
, NULL_TREE
);
10975 /* Parse a jump-statement.
10980 return expression [opt] ;
10981 return braced-init-list ;
10987 goto * expression ;
10989 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
10992 cp_parser_jump_statement (cp_parser
* parser
)
10994 tree statement
= error_mark_node
;
10997 unsigned char in_statement
;
10999 /* Peek at the next token. */
11000 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_JUMP
);
11002 return error_mark_node
;
11004 /* See what kind of keyword it is. */
11005 keyword
= token
->keyword
;
11009 in_statement
= parser
->in_statement
& ~IN_IF_STMT
;
11010 switch (in_statement
)
11013 error_at (token
->location
, "break statement not within loop or switch");
11016 gcc_assert ((in_statement
& IN_SWITCH_STMT
)
11017 || in_statement
== IN_ITERATION_STMT
);
11018 statement
= finish_break_stmt ();
11019 if (in_statement
== IN_ITERATION_STMT
)
11020 break_maybe_infinite_loop ();
11023 error_at (token
->location
, "invalid exit from OpenMP structured block");
11026 error_at (token
->location
, "break statement used with OpenMP for loop");
11028 case IN_CILK_SIMD_FOR
:
11029 error_at (token
->location
, "break statement used with Cilk Plus for loop");
11032 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11036 switch (parser
->in_statement
& ~(IN_SWITCH_STMT
| IN_IF_STMT
))
11039 error_at (token
->location
, "continue statement not within a loop");
11041 case IN_CILK_SIMD_FOR
:
11042 error_at (token
->location
,
11043 "continue statement within %<#pragma simd%> loop body");
11044 /* Fall through. */
11045 case IN_ITERATION_STMT
:
11047 statement
= finish_continue_stmt ();
11050 error_at (token
->location
, "invalid exit from OpenMP structured block");
11053 gcc_unreachable ();
11055 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11061 bool expr_non_constant_p
;
11063 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
11065 cp_lexer_set_source_position (parser
->lexer
);
11066 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
11067 expr
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
11069 else if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
11070 expr
= cp_parser_expression (parser
);
11072 /* If the next token is a `;', then there is no
11075 /* Build the return-statement. */
11076 statement
= finish_return_stmt (expr
);
11077 /* Look for the final `;'. */
11078 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11083 if (parser
->in_function_body
11084 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
11086 error ("%<goto%> in %<constexpr%> function");
11087 cp_function_chain
->invalid_constexpr
= true;
11090 /* Create the goto-statement. */
11091 if (cp_lexer_next_token_is (parser
->lexer
, CPP_MULT
))
11093 /* Issue a warning about this use of a GNU extension. */
11094 pedwarn (token
->location
, OPT_Wpedantic
, "ISO C++ forbids computed gotos");
11095 /* Consume the '*' token. */
11096 cp_lexer_consume_token (parser
->lexer
);
11097 /* Parse the dependent expression. */
11098 finish_goto_stmt (cp_parser_expression (parser
));
11101 finish_goto_stmt (cp_parser_identifier (parser
));
11102 /* Look for the final `;'. */
11103 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11107 cp_parser_error (parser
, "expected jump-statement");
11114 /* Parse a declaration-statement.
11116 declaration-statement:
11117 block-declaration */
11120 cp_parser_declaration_statement (cp_parser
* parser
)
11124 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
11125 p
= obstack_alloc (&declarator_obstack
, 0);
11127 /* Parse the block-declaration. */
11128 cp_parser_block_declaration (parser
, /*statement_p=*/true);
11130 /* Free any declarators allocated. */
11131 obstack_free (&declarator_obstack
, p
);
11134 /* Some dependent statements (like `if (cond) statement'), are
11135 implicitly in their own scope. In other words, if the statement is
11136 a single statement (as opposed to a compound-statement), it is
11137 none-the-less treated as if it were enclosed in braces. Any
11138 declarations appearing in the dependent statement are out of scope
11139 after control passes that point. This function parses a statement,
11140 but ensures that is in its own scope, even if it is not a
11141 compound-statement.
11143 If IF_P is not NULL, *IF_P is set to indicate whether the statement
11144 is a (possibly labeled) if statement which is not enclosed in
11145 braces and has an else clause. This is used to implement
11148 Returns the new statement. */
11151 cp_parser_implicitly_scoped_statement (cp_parser
* parser
, bool *if_p
)
11158 /* Mark if () ; with a special NOP_EXPR. */
11159 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
11161 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
11162 cp_lexer_consume_token (parser
->lexer
);
11163 statement
= add_stmt (build_empty_stmt (loc
));
11165 /* if a compound is opened, we simply parse the statement directly. */
11166 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
11167 statement
= cp_parser_compound_statement (parser
, NULL
, false, false);
11168 /* If the token is not a `{', then we must take special action. */
11171 /* Create a compound-statement. */
11172 statement
= begin_compound_stmt (0);
11173 /* Parse the dependent-statement. */
11174 cp_parser_statement (parser
, NULL_TREE
, false, if_p
);
11175 /* Finish the dummy compound-statement. */
11176 finish_compound_stmt (statement
);
11179 /* Return the statement. */
11183 /* For some dependent statements (like `while (cond) statement'), we
11184 have already created a scope. Therefore, even if the dependent
11185 statement is a compound-statement, we do not want to create another
11189 cp_parser_already_scoped_statement (cp_parser
* parser
)
11191 /* If the token is a `{', then we must take special action. */
11192 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
11193 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
11196 /* Avoid calling cp_parser_compound_statement, so that we
11197 don't create a new scope. Do everything else by hand. */
11198 cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
);
11199 /* If the next keyword is `__label__' we have a label declaration. */
11200 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_LABEL
))
11201 cp_parser_label_declaration (parser
);
11202 /* Parse an (optional) statement-seq. */
11203 cp_parser_statement_seq_opt (parser
, NULL_TREE
);
11204 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
11208 /* Declarations [gram.dcl.dcl] */
11210 /* Parse an optional declaration-sequence.
11214 declaration-seq declaration */
11217 cp_parser_declaration_seq_opt (cp_parser
* parser
)
11223 token
= cp_lexer_peek_token (parser
->lexer
);
11225 if (token
->type
== CPP_CLOSE_BRACE
11226 || token
->type
== CPP_EOF
11227 || token
->type
== CPP_PRAGMA_EOL
)
11230 if (token
->type
== CPP_SEMICOLON
)
11232 /* A declaration consisting of a single semicolon is
11233 invalid. Allow it unless we're being pedantic. */
11234 cp_lexer_consume_token (parser
->lexer
);
11235 if (!in_system_header_at (input_location
))
11236 pedwarn (input_location
, OPT_Wpedantic
, "extra %<;%>");
11240 /* If we're entering or exiting a region that's implicitly
11241 extern "C", modify the lang context appropriately. */
11242 if (!parser
->implicit_extern_c
&& token
->implicit_extern_c
)
11244 push_lang_context (lang_name_c
);
11245 parser
->implicit_extern_c
= true;
11247 else if (parser
->implicit_extern_c
&& !token
->implicit_extern_c
)
11249 pop_lang_context ();
11250 parser
->implicit_extern_c
= false;
11253 if (token
->type
== CPP_PRAGMA
)
11255 /* A top-level declaration can consist solely of a #pragma.
11256 A nested declaration cannot, so this is done here and not
11257 in cp_parser_declaration. (A #pragma at block scope is
11258 handled in cp_parser_statement.) */
11259 cp_parser_pragma (parser
, pragma_external
);
11263 /* Parse the declaration itself. */
11264 cp_parser_declaration (parser
);
11268 /* Parse a declaration.
11272 function-definition
11273 template-declaration
11274 explicit-instantiation
11275 explicit-specialization
11276 linkage-specification
11277 namespace-definition
11282 __extension__ declaration */
11285 cp_parser_declaration (cp_parser
* parser
)
11289 int saved_pedantic
;
11291 tree attributes
= NULL_TREE
;
11293 /* Check for the `__extension__' keyword. */
11294 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
11296 /* Parse the qualified declaration. */
11297 cp_parser_declaration (parser
);
11298 /* Restore the PEDANTIC flag. */
11299 pedantic
= saved_pedantic
;
11304 /* Try to figure out what kind of declaration is present. */
11305 token1
= *cp_lexer_peek_token (parser
->lexer
);
11307 if (token1
.type
!= CPP_EOF
)
11308 token2
= *cp_lexer_peek_nth_token (parser
->lexer
, 2);
11311 token2
.type
= CPP_EOF
;
11312 token2
.keyword
= RID_MAX
;
11315 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
11316 p
= obstack_alloc (&declarator_obstack
, 0);
11318 /* If the next token is `extern' and the following token is a string
11319 literal, then we have a linkage specification. */
11320 if (token1
.keyword
== RID_EXTERN
11321 && cp_parser_is_pure_string_literal (&token2
))
11322 cp_parser_linkage_specification (parser
);
11323 /* If the next token is `template', then we have either a template
11324 declaration, an explicit instantiation, or an explicit
11326 else if (token1
.keyword
== RID_TEMPLATE
)
11328 /* `template <>' indicates a template specialization. */
11329 if (token2
.type
== CPP_LESS
11330 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_GREATER
)
11331 cp_parser_explicit_specialization (parser
);
11332 /* `template <' indicates a template declaration. */
11333 else if (token2
.type
== CPP_LESS
)
11334 cp_parser_template_declaration (parser
, /*member_p=*/false);
11335 /* Anything else must be an explicit instantiation. */
11337 cp_parser_explicit_instantiation (parser
);
11339 /* If the next token is `export', then we have a template
11341 else if (token1
.keyword
== RID_EXPORT
)
11342 cp_parser_template_declaration (parser
, /*member_p=*/false);
11343 /* If the next token is `extern', 'static' or 'inline' and the one
11344 after that is `template', we have a GNU extended explicit
11345 instantiation directive. */
11346 else if (cp_parser_allow_gnu_extensions_p (parser
)
11347 && (token1
.keyword
== RID_EXTERN
11348 || token1
.keyword
== RID_STATIC
11349 || token1
.keyword
== RID_INLINE
)
11350 && token2
.keyword
== RID_TEMPLATE
)
11351 cp_parser_explicit_instantiation (parser
);
11352 /* If the next token is `namespace', check for a named or unnamed
11353 namespace definition. */
11354 else if (token1
.keyword
== RID_NAMESPACE
11355 && (/* A named namespace definition. */
11356 (token2
.type
== CPP_NAME
11357 && (cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
11359 /* An unnamed namespace definition. */
11360 || token2
.type
== CPP_OPEN_BRACE
11361 || token2
.keyword
== RID_ATTRIBUTE
))
11362 cp_parser_namespace_definition (parser
);
11363 /* An inline (associated) namespace definition. */
11364 else if (token1
.keyword
== RID_INLINE
11365 && token2
.keyword
== RID_NAMESPACE
)
11366 cp_parser_namespace_definition (parser
);
11367 /* Objective-C++ declaration/definition. */
11368 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1
.keyword
))
11369 cp_parser_objc_declaration (parser
, NULL_TREE
);
11370 else if (c_dialect_objc ()
11371 && token1
.keyword
== RID_ATTRIBUTE
11372 && cp_parser_objc_valid_prefix_attributes (parser
, &attributes
))
11373 cp_parser_objc_declaration (parser
, attributes
);
11374 /* We must have either a block declaration or a function
11377 /* Try to parse a block-declaration, or a function-definition. */
11378 cp_parser_block_declaration (parser
, /*statement_p=*/false);
11380 /* Free any declarators allocated. */
11381 obstack_free (&declarator_obstack
, p
);
11384 /* Parse a block-declaration.
11389 namespace-alias-definition
11396 __extension__ block-declaration
11401 static_assert-declaration
11403 If STATEMENT_P is TRUE, then this block-declaration is occurring as
11404 part of a declaration-statement. */
11407 cp_parser_block_declaration (cp_parser
*parser
,
11411 int saved_pedantic
;
11413 /* Check for the `__extension__' keyword. */
11414 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
11416 /* Parse the qualified declaration. */
11417 cp_parser_block_declaration (parser
, statement_p
);
11418 /* Restore the PEDANTIC flag. */
11419 pedantic
= saved_pedantic
;
11424 /* Peek at the next token to figure out which kind of declaration is
11426 token1
= cp_lexer_peek_token (parser
->lexer
);
11428 /* If the next keyword is `asm', we have an asm-definition. */
11429 if (token1
->keyword
== RID_ASM
)
11432 cp_parser_commit_to_tentative_parse (parser
);
11433 cp_parser_asm_definition (parser
);
11435 /* If the next keyword is `namespace', we have a
11436 namespace-alias-definition. */
11437 else if (token1
->keyword
== RID_NAMESPACE
)
11438 cp_parser_namespace_alias_definition (parser
);
11439 /* If the next keyword is `using', we have a
11440 using-declaration, a using-directive, or an alias-declaration. */
11441 else if (token1
->keyword
== RID_USING
)
11446 cp_parser_commit_to_tentative_parse (parser
);
11447 /* If the token after `using' is `namespace', then we have a
11448 using-directive. */
11449 token2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
11450 if (token2
->keyword
== RID_NAMESPACE
)
11451 cp_parser_using_directive (parser
);
11452 /* If the second token after 'using' is '=', then we have an
11453 alias-declaration. */
11454 else if (cxx_dialect
>= cxx11
11455 && token2
->type
== CPP_NAME
11456 && ((cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_EQ
)
11457 || (cp_nth_tokens_can_be_attribute_p (parser
, 3))))
11458 cp_parser_alias_declaration (parser
);
11459 /* Otherwise, it's a using-declaration. */
11461 cp_parser_using_declaration (parser
,
11462 /*access_declaration_p=*/false);
11464 /* If the next keyword is `__label__' we have a misplaced label
11466 else if (token1
->keyword
== RID_LABEL
)
11468 cp_lexer_consume_token (parser
->lexer
);
11469 error_at (token1
->location
, "%<__label__%> not at the beginning of a block");
11470 cp_parser_skip_to_end_of_statement (parser
);
11471 /* If the next token is now a `;', consume it. */
11472 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
11473 cp_lexer_consume_token (parser
->lexer
);
11475 /* If the next token is `static_assert' we have a static assertion. */
11476 else if (token1
->keyword
== RID_STATIC_ASSERT
)
11477 cp_parser_static_assert (parser
, /*member_p=*/false);
11478 /* Anything else must be a simple-declaration. */
11480 cp_parser_simple_declaration (parser
, !statement_p
,
11481 /*maybe_range_for_decl*/NULL
);
11484 /* Parse a simple-declaration.
11486 simple-declaration:
11487 decl-specifier-seq [opt] init-declarator-list [opt] ;
11489 init-declarator-list:
11491 init-declarator-list , init-declarator
11493 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
11494 function-definition as a simple-declaration.
11496 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
11497 parsed declaration if it is an uninitialized single declarator not followed
11498 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
11499 if present, will not be consumed. */
11502 cp_parser_simple_declaration (cp_parser
* parser
,
11503 bool function_definition_allowed_p
,
11504 tree
*maybe_range_for_decl
)
11506 cp_decl_specifier_seq decl_specifiers
;
11507 int declares_class_or_enum
;
11508 bool saw_declarator
;
11509 location_t comma_loc
= UNKNOWN_LOCATION
;
11510 location_t init_loc
= UNKNOWN_LOCATION
;
11512 if (maybe_range_for_decl
)
11513 *maybe_range_for_decl
= NULL_TREE
;
11515 /* Defer access checks until we know what is being declared; the
11516 checks for names appearing in the decl-specifier-seq should be
11517 done as if we were in the scope of the thing being declared. */
11518 push_deferring_access_checks (dk_deferred
);
11520 /* Parse the decl-specifier-seq. We have to keep track of whether
11521 or not the decl-specifier-seq declares a named class or
11522 enumeration type, since that is the only case in which the
11523 init-declarator-list is allowed to be empty.
11527 In a simple-declaration, the optional init-declarator-list can be
11528 omitted only when declaring a class or enumeration, that is when
11529 the decl-specifier-seq contains either a class-specifier, an
11530 elaborated-type-specifier, or an enum-specifier. */
11531 cp_parser_decl_specifier_seq (parser
,
11532 CP_PARSER_FLAGS_OPTIONAL
,
11534 &declares_class_or_enum
);
11535 /* We no longer need to defer access checks. */
11536 stop_deferring_access_checks ();
11538 /* In a block scope, a valid declaration must always have a
11539 decl-specifier-seq. By not trying to parse declarators, we can
11540 resolve the declaration/expression ambiguity more quickly. */
11541 if (!function_definition_allowed_p
11542 && !decl_specifiers
.any_specifiers_p
)
11544 cp_parser_error (parser
, "expected declaration");
11548 /* If the next two tokens are both identifiers, the code is
11549 erroneous. The usual cause of this situation is code like:
11553 where "T" should name a type -- but does not. */
11554 if (!decl_specifiers
.any_type_specifiers_p
11555 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
11557 /* If parsing tentatively, we should commit; we really are
11558 looking at a declaration. */
11559 cp_parser_commit_to_tentative_parse (parser
);
11564 /* If we have seen at least one decl-specifier, and the next token
11565 is not a parenthesis, then we must be looking at a declaration.
11566 (After "int (" we might be looking at a functional cast.) */
11567 if (decl_specifiers
.any_specifiers_p
11568 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
)
11569 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
)
11570 && !cp_parser_error_occurred (parser
))
11571 cp_parser_commit_to_tentative_parse (parser
);
11573 /* Keep going until we hit the `;' at the end of the simple
11575 saw_declarator
= false;
11576 while (cp_lexer_next_token_is_not (parser
->lexer
,
11580 bool function_definition_p
;
11583 if (saw_declarator
)
11585 /* If we are processing next declarator, comma is expected */
11586 token
= cp_lexer_peek_token (parser
->lexer
);
11587 gcc_assert (token
->type
== CPP_COMMA
);
11588 cp_lexer_consume_token (parser
->lexer
);
11589 if (maybe_range_for_decl
)
11591 *maybe_range_for_decl
= error_mark_node
;
11592 if (comma_loc
== UNKNOWN_LOCATION
)
11593 comma_loc
= token
->location
;
11597 saw_declarator
= true;
11599 /* Parse the init-declarator. */
11600 decl
= cp_parser_init_declarator (parser
, &decl_specifiers
,
11602 function_definition_allowed_p
,
11603 /*member_p=*/false,
11604 declares_class_or_enum
,
11605 &function_definition_p
,
11606 maybe_range_for_decl
,
11608 /* If an error occurred while parsing tentatively, exit quickly.
11609 (That usually happens when in the body of a function; each
11610 statement is treated as a declaration-statement until proven
11612 if (cp_parser_error_occurred (parser
))
11614 /* Handle function definitions specially. */
11615 if (function_definition_p
)
11617 /* If the next token is a `,', then we are probably
11618 processing something like:
11622 which is erroneous. */
11623 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
11625 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
11626 error_at (token
->location
,
11628 " declarations and function-definitions is forbidden");
11630 /* Otherwise, we're done with the list of declarators. */
11633 pop_deferring_access_checks ();
11637 if (maybe_range_for_decl
&& *maybe_range_for_decl
== NULL_TREE
)
11638 *maybe_range_for_decl
= decl
;
11639 /* The next token should be either a `,' or a `;'. */
11640 token
= cp_lexer_peek_token (parser
->lexer
);
11641 /* If it's a `,', there are more declarators to come. */
11642 if (token
->type
== CPP_COMMA
)
11643 /* will be consumed next time around */;
11644 /* If it's a `;', we are done. */
11645 else if (token
->type
== CPP_SEMICOLON
|| maybe_range_for_decl
)
11647 /* Anything else is an error. */
11650 /* If we have already issued an error message we don't need
11651 to issue another one. */
11652 if (decl
!= error_mark_node
11653 || cp_parser_uncommitted_to_tentative_parse_p (parser
))
11654 cp_parser_error (parser
, "expected %<,%> or %<;%>");
11655 /* Skip tokens until we reach the end of the statement. */
11656 cp_parser_skip_to_end_of_statement (parser
);
11657 /* If the next token is now a `;', consume it. */
11658 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
11659 cp_lexer_consume_token (parser
->lexer
);
11662 /* After the first time around, a function-definition is not
11663 allowed -- even if it was OK at first. For example:
11668 function_definition_allowed_p
= false;
11671 /* Issue an error message if no declarators are present, and the
11672 decl-specifier-seq does not itself declare a class or
11673 enumeration: [dcl.dcl]/3. */
11674 if (!saw_declarator
)
11676 if (cp_parser_declares_only_class_p (parser
))
11678 if (!declares_class_or_enum
11679 && decl_specifiers
.type
11680 && OVERLOAD_TYPE_P (decl_specifiers
.type
))
11681 /* Ensure an error is issued anyway when finish_decltype_type,
11682 called via cp_parser_decl_specifier_seq, returns a class or
11683 an enumeration (c++/51786). */
11684 decl_specifiers
.type
= NULL_TREE
;
11685 shadow_tag (&decl_specifiers
);
11687 /* Perform any deferred access checks. */
11688 perform_deferred_access_checks (tf_warning_or_error
);
11691 /* Consume the `;'. */
11692 if (!maybe_range_for_decl
)
11693 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
11694 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
11696 if (init_loc
!= UNKNOWN_LOCATION
)
11697 error_at (init_loc
, "initializer in range-based %<for%> loop");
11698 if (comma_loc
!= UNKNOWN_LOCATION
)
11699 error_at (comma_loc
,
11700 "multiple declarations in range-based %<for%> loop");
11704 pop_deferring_access_checks ();
11707 /* Parse a decl-specifier-seq.
11709 decl-specifier-seq:
11710 decl-specifier-seq [opt] decl-specifier
11711 decl-specifier attribute-specifier-seq [opt] (C++11)
11714 storage-class-specifier
11725 Set *DECL_SPECS to a representation of the decl-specifier-seq.
11727 The parser flags FLAGS is used to control type-specifier parsing.
11729 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
11732 1: one of the decl-specifiers is an elaborated-type-specifier
11733 (i.e., a type declaration)
11734 2: one of the decl-specifiers is an enum-specifier or a
11735 class-specifier (i.e., a type definition)
11740 cp_parser_decl_specifier_seq (cp_parser
* parser
,
11741 cp_parser_flags flags
,
11742 cp_decl_specifier_seq
*decl_specs
,
11743 int* declares_class_or_enum
)
11745 bool constructor_possible_p
= !parser
->in_declarator_p
;
11746 bool found_decl_spec
= false;
11747 cp_token
*start_token
= NULL
;
11750 /* Clear DECL_SPECS. */
11751 clear_decl_specs (decl_specs
);
11753 /* Assume no class or enumeration type is declared. */
11754 *declares_class_or_enum
= 0;
11756 /* Keep reading specifiers until there are no more to read. */
11759 bool constructor_p
;
11763 /* Peek at the next token. */
11764 token
= cp_lexer_peek_token (parser
->lexer
);
11766 /* Save the first token of the decl spec list for error
11769 start_token
= token
;
11770 /* Handle attributes. */
11771 if (cp_next_tokens_can_be_attribute_p (parser
))
11773 /* Parse the attributes. */
11774 tree attrs
= cp_parser_attributes_opt (parser
);
11776 /* In a sequence of declaration specifiers, c++11 attributes
11777 appertain to the type that precede them. In that case
11780 The attribute-specifier-seq affects the type only for
11781 the declaration it appears in, not other declarations
11782 involving the same type.
11784 But for now let's force the user to position the
11785 attribute either at the beginning of the declaration or
11786 after the declarator-id, which would clearly mean that it
11787 applies to the declarator. */
11788 if (cxx11_attribute_p (attrs
))
11790 if (!found_decl_spec
)
11791 /* The c++11 attribute is at the beginning of the
11792 declaration. It appertains to the entity being
11796 if (decl_specs
->type
&& CLASS_TYPE_P (decl_specs
->type
))
11798 /* This is an attribute following a
11799 class-specifier. */
11800 if (decl_specs
->type_definition_p
)
11801 warn_misplaced_attr_for_class_type (token
->location
,
11807 decl_specs
->std_attributes
11808 = chainon (decl_specs
->std_attributes
,
11810 if (decl_specs
->locations
[ds_std_attribute
] == 0)
11811 decl_specs
->locations
[ds_std_attribute
] = token
->location
;
11817 decl_specs
->attributes
11818 = chainon (decl_specs
->attributes
,
11820 if (decl_specs
->locations
[ds_attribute
] == 0)
11821 decl_specs
->locations
[ds_attribute
] = token
->location
;
11824 /* Assume we will find a decl-specifier keyword. */
11825 found_decl_spec
= true;
11826 /* If the next token is an appropriate keyword, we can simply
11827 add it to the list. */
11828 switch (token
->keyword
)
11834 if (!at_class_scope_p ())
11836 error_at (token
->location
, "%<friend%> used outside of class");
11837 cp_lexer_purge_token (parser
->lexer
);
11842 /* Consume the token. */
11843 cp_lexer_consume_token (parser
->lexer
);
11847 case RID_CONSTEXPR
:
11849 cp_lexer_consume_token (parser
->lexer
);
11852 /* function-specifier:
11859 cp_parser_function_specifier_opt (parser
, decl_specs
);
11866 /* Consume the token. */
11867 cp_lexer_consume_token (parser
->lexer
);
11868 /* A constructor declarator cannot appear in a typedef. */
11869 constructor_possible_p
= false;
11870 /* The "typedef" keyword can only occur in a declaration; we
11871 may as well commit at this point. */
11872 cp_parser_commit_to_tentative_parse (parser
);
11874 if (decl_specs
->storage_class
!= sc_none
)
11875 decl_specs
->conflicting_specifiers_p
= true;
11878 /* storage-class-specifier:
11888 if (cxx_dialect
== cxx98
)
11890 /* Consume the token. */
11891 cp_lexer_consume_token (parser
->lexer
);
11893 /* Complain about `auto' as a storage specifier, if
11894 we're complaining about C++0x compatibility. */
11895 warning_at (token
->location
, OPT_Wc__0x_compat
, "%<auto%>"
11896 " changes meaning in C++11; please remove it");
11898 /* Set the storage class anyway. */
11899 cp_parser_set_storage_class (parser
, decl_specs
, RID_AUTO
,
11903 /* C++0x auto type-specifier. */
11904 found_decl_spec
= false;
11911 /* Consume the token. */
11912 cp_lexer_consume_token (parser
->lexer
);
11913 cp_parser_set_storage_class (parser
, decl_specs
, token
->keyword
,
11917 /* Consume the token. */
11919 cp_lexer_consume_token (parser
->lexer
);
11923 /* We did not yet find a decl-specifier yet. */
11924 found_decl_spec
= false;
11928 if (found_decl_spec
11929 && (flags
& CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR
)
11930 && token
->keyword
!= RID_CONSTEXPR
)
11931 error ("decl-specifier invalid in condition");
11934 set_and_check_decl_spec_loc (decl_specs
, ds
, token
);
11936 /* Constructors are a special case. The `S' in `S()' is not a
11937 decl-specifier; it is the beginning of the declarator. */
11939 = (!found_decl_spec
11940 && constructor_possible_p
11941 && (cp_parser_constructor_declarator_p
11942 (parser
, decl_spec_seq_has_spec_p (decl_specs
, ds_friend
))));
11944 /* If we don't have a DECL_SPEC yet, then we must be looking at
11945 a type-specifier. */
11946 if (!found_decl_spec
&& !constructor_p
)
11948 int decl_spec_declares_class_or_enum
;
11949 bool is_cv_qualifier
;
11953 = cp_parser_type_specifier (parser
, flags
,
11955 /*is_declaration=*/true,
11956 &decl_spec_declares_class_or_enum
,
11958 *declares_class_or_enum
|= decl_spec_declares_class_or_enum
;
11960 /* If this type-specifier referenced a user-defined type
11961 (a typedef, class-name, etc.), then we can't allow any
11962 more such type-specifiers henceforth.
11966 The longest sequence of decl-specifiers that could
11967 possibly be a type name is taken as the
11968 decl-specifier-seq of a declaration. The sequence shall
11969 be self-consistent as described below.
11973 As a general rule, at most one type-specifier is allowed
11974 in the complete decl-specifier-seq of a declaration. The
11975 only exceptions are the following:
11977 -- const or volatile can be combined with any other
11980 -- signed or unsigned can be combined with char, long,
11988 void g (const int Pc);
11990 Here, Pc is *not* part of the decl-specifier seq; it's
11991 the declarator. Therefore, once we see a type-specifier
11992 (other than a cv-qualifier), we forbid any additional
11993 user-defined types. We *do* still allow things like `int
11994 int' to be considered a decl-specifier-seq, and issue the
11995 error message later. */
11996 if (type_spec
&& !is_cv_qualifier
)
11997 flags
|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
;
11998 /* A constructor declarator cannot follow a type-specifier. */
12001 constructor_possible_p
= false;
12002 found_decl_spec
= true;
12003 if (!is_cv_qualifier
)
12004 decl_specs
->any_type_specifiers_p
= true;
12008 /* If we still do not have a DECL_SPEC, then there are no more
12009 decl-specifiers. */
12010 if (!found_decl_spec
)
12013 decl_specs
->any_specifiers_p
= true;
12014 /* After we see one decl-specifier, further decl-specifiers are
12015 always optional. */
12016 flags
|= CP_PARSER_FLAGS_OPTIONAL
;
12019 /* Don't allow a friend specifier with a class definition. */
12020 if (decl_spec_seq_has_spec_p (decl_specs
, ds_friend
)
12021 && (*declares_class_or_enum
& 2))
12022 error_at (decl_specs
->locations
[ds_friend
],
12023 "class definition may not be declared a friend");
12026 /* Parse an (optional) storage-class-specifier.
12028 storage-class-specifier:
12037 storage-class-specifier:
12040 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
12043 cp_parser_storage_class_specifier_opt (cp_parser
* parser
)
12045 switch (cp_lexer_peek_token (parser
->lexer
)->keyword
)
12048 if (cxx_dialect
!= cxx98
)
12050 /* Fall through for C++98. */
12057 /* Consume the token. */
12058 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
12065 /* Parse an (optional) function-specifier.
12067 function-specifier:
12072 Returns an IDENTIFIER_NODE corresponding to the keyword used.
12073 Updates DECL_SPECS, if it is non-NULL. */
12076 cp_parser_function_specifier_opt (cp_parser
* parser
,
12077 cp_decl_specifier_seq
*decl_specs
)
12079 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12080 switch (token
->keyword
)
12083 set_and_check_decl_spec_loc (decl_specs
, ds_inline
, token
);
12087 /* 14.5.2.3 [temp.mem]
12089 A member function template shall not be virtual. */
12090 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
12091 error_at (token
->location
, "templates may not be %<virtual%>");
12093 set_and_check_decl_spec_loc (decl_specs
, ds_virtual
, token
);
12097 set_and_check_decl_spec_loc (decl_specs
, ds_explicit
, token
);
12104 /* Consume the token. */
12105 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
12108 /* Parse a linkage-specification.
12110 linkage-specification:
12111 extern string-literal { declaration-seq [opt] }
12112 extern string-literal declaration */
12115 cp_parser_linkage_specification (cp_parser
* parser
)
12119 /* Look for the `extern' keyword. */
12120 cp_parser_require_keyword (parser
, RID_EXTERN
, RT_EXTERN
);
12122 /* Look for the string-literal. */
12123 linkage
= cp_parser_string_literal (parser
, false, false);
12125 /* Transform the literal into an identifier. If the literal is a
12126 wide-character string, or contains embedded NULs, then we can't
12127 handle it as the user wants. */
12128 if (strlen (TREE_STRING_POINTER (linkage
))
12129 != (size_t) (TREE_STRING_LENGTH (linkage
) - 1))
12131 cp_parser_error (parser
, "invalid linkage-specification");
12132 /* Assume C++ linkage. */
12133 linkage
= lang_name_cplusplus
;
12136 linkage
= get_identifier (TREE_STRING_POINTER (linkage
));
12138 /* We're now using the new linkage. */
12139 push_lang_context (linkage
);
12141 /* If the next token is a `{', then we're using the first
12143 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
12145 cp_ensure_no_omp_declare_simd (parser
);
12147 /* Consume the `{' token. */
12148 cp_lexer_consume_token (parser
->lexer
);
12149 /* Parse the declarations. */
12150 cp_parser_declaration_seq_opt (parser
);
12151 /* Look for the closing `}'. */
12152 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
12154 /* Otherwise, there's just one declaration. */
12157 bool saved_in_unbraced_linkage_specification_p
;
12159 saved_in_unbraced_linkage_specification_p
12160 = parser
->in_unbraced_linkage_specification_p
;
12161 parser
->in_unbraced_linkage_specification_p
= true;
12162 cp_parser_declaration (parser
);
12163 parser
->in_unbraced_linkage_specification_p
12164 = saved_in_unbraced_linkage_specification_p
;
12167 /* We're done with the linkage-specification. */
12168 pop_lang_context ();
12171 /* Parse a static_assert-declaration.
12173 static_assert-declaration:
12174 static_assert ( constant-expression , string-literal ) ;
12176 If MEMBER_P, this static_assert is a class member. */
12179 cp_parser_static_assert(cp_parser
*parser
, bool member_p
)
12184 location_t saved_loc
;
12187 /* Peek at the `static_assert' token so we can keep track of exactly
12188 where the static assertion started. */
12189 token
= cp_lexer_peek_token (parser
->lexer
);
12190 saved_loc
= token
->location
;
12192 /* Look for the `static_assert' keyword. */
12193 if (!cp_parser_require_keyword (parser
, RID_STATIC_ASSERT
,
12197 /* We know we are in a static assertion; commit to any tentative
12199 if (cp_parser_parsing_tentatively (parser
))
12200 cp_parser_commit_to_tentative_parse (parser
);
12202 /* Parse the `(' starting the static assertion condition. */
12203 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
12205 /* Parse the constant-expression. Allow a non-constant expression
12206 here in order to give better diagnostics in finish_static_assert. */
12208 cp_parser_constant_expression (parser
,
12209 /*allow_non_constant_p=*/true,
12210 /*non_constant_p=*/&dummy
);
12212 /* Parse the separating `,'. */
12213 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
12215 /* Parse the string-literal message. */
12216 message
= cp_parser_string_literal (parser
,
12217 /*translate=*/false,
12220 /* A `)' completes the static assertion. */
12221 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
12222 cp_parser_skip_to_closing_parenthesis (parser
,
12223 /*recovering=*/true,
12224 /*or_comma=*/false,
12225 /*consume_paren=*/true);
12227 /* A semicolon terminates the declaration. */
12228 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
12230 /* Complete the static assertion, which may mean either processing
12231 the static assert now or saving it for template instantiation. */
12232 finish_static_assert (condition
, message
, saved_loc
, member_p
);
12235 /* Parse the expression in decltype ( expression ). */
12238 cp_parser_decltype_expr (cp_parser
*parser
,
12239 bool &id_expression_or_member_access_p
)
12241 cp_token
*id_expr_start_token
;
12244 /* First, try parsing an id-expression. */
12245 id_expr_start_token
= cp_lexer_peek_token (parser
->lexer
);
12246 cp_parser_parse_tentatively (parser
);
12247 expr
= cp_parser_id_expression (parser
,
12248 /*template_keyword_p=*/false,
12249 /*check_dependency_p=*/true,
12250 /*template_p=*/NULL
,
12251 /*declarator_p=*/false,
12252 /*optional_p=*/false);
12254 if (!cp_parser_error_occurred (parser
) && expr
!= error_mark_node
)
12256 bool non_integral_constant_expression_p
= false;
12257 tree id_expression
= expr
;
12259 const char *error_msg
;
12261 if (identifier_p (expr
))
12262 /* Lookup the name we got back from the id-expression. */
12263 expr
= cp_parser_lookup_name_simple (parser
, expr
,
12264 id_expr_start_token
->location
);
12267 && expr
!= error_mark_node
12268 && TREE_CODE (expr
) != TYPE_DECL
12269 && (TREE_CODE (expr
) != BIT_NOT_EXPR
12270 || !TYPE_P (TREE_OPERAND (expr
, 0)))
12271 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
12273 /* Complete lookup of the id-expression. */
12274 expr
= (finish_id_expression
12275 (id_expression
, expr
, parser
->scope
, &idk
,
12276 /*integral_constant_expression_p=*/false,
12277 /*allow_non_integral_constant_expression_p=*/true,
12278 &non_integral_constant_expression_p
,
12279 /*template_p=*/false,
12281 /*address_p=*/false,
12282 /*template_arg_p=*/false,
12284 id_expr_start_token
->location
));
12286 if (expr
== error_mark_node
)
12287 /* We found an id-expression, but it was something that we
12288 should not have found. This is an error, not something
12289 we can recover from, so note that we found an
12290 id-expression and we'll recover as gracefully as
12292 id_expression_or_member_access_p
= true;
12296 && expr
!= error_mark_node
12297 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
12298 /* We have an id-expression. */
12299 id_expression_or_member_access_p
= true;
12302 if (!id_expression_or_member_access_p
)
12304 /* Abort the id-expression parse. */
12305 cp_parser_abort_tentative_parse (parser
);
12307 /* Parsing tentatively, again. */
12308 cp_parser_parse_tentatively (parser
);
12310 /* Parse a class member access. */
12311 expr
= cp_parser_postfix_expression (parser
, /*address_p=*/false,
12312 /*cast_p=*/false, /*decltype*/true,
12313 /*member_access_only_p=*/true, NULL
);
12316 && expr
!= error_mark_node
12317 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_CLOSE_PAREN
)
12318 /* We have an id-expression. */
12319 id_expression_or_member_access_p
= true;
12322 if (id_expression_or_member_access_p
)
12323 /* We have parsed the complete id-expression or member access. */
12324 cp_parser_parse_definitely (parser
);
12327 /* Abort our attempt to parse an id-expression or member access
12329 cp_parser_abort_tentative_parse (parser
);
12331 /* Parse a full expression. */
12332 expr
= cp_parser_expression (parser
, /*pidk=*/NULL
, /*cast_p=*/false,
12333 /*decltype_p=*/true);
12339 /* Parse a `decltype' type. Returns the type.
12341 simple-type-specifier:
12342 decltype ( expression )
12344 decltype ( auto ) */
12347 cp_parser_decltype (cp_parser
*parser
)
12350 bool id_expression_or_member_access_p
= false;
12351 const char *saved_message
;
12352 bool saved_integral_constant_expression_p
;
12353 bool saved_non_integral_constant_expression_p
;
12354 bool saved_greater_than_is_operator_p
;
12355 cp_token
*start_token
= cp_lexer_peek_token (parser
->lexer
);
12357 if (start_token
->type
== CPP_DECLTYPE
)
12359 /* Already parsed. */
12360 cp_lexer_consume_token (parser
->lexer
);
12361 return start_token
->u
.value
;
12364 /* Look for the `decltype' token. */
12365 if (!cp_parser_require_keyword (parser
, RID_DECLTYPE
, RT_DECLTYPE
))
12366 return error_mark_node
;
12368 /* Parse the opening `('. */
12369 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
12370 return error_mark_node
;
12372 /* decltype (auto) */
12373 if (cxx_dialect
>= cxx14
12374 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AUTO
))
12376 cp_lexer_consume_token (parser
->lexer
);
12377 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
12378 return error_mark_node
;
12379 expr
= make_decltype_auto ();
12380 AUTO_IS_DECLTYPE (expr
) = true;
12384 /* Types cannot be defined in a `decltype' expression. Save away the
12386 saved_message
= parser
->type_definition_forbidden_message
;
12388 /* And create the new one. */
12389 parser
->type_definition_forbidden_message
12390 = G_("types may not be defined in %<decltype%> expressions");
12392 /* The restrictions on constant-expressions do not apply inside
12393 decltype expressions. */
12394 saved_integral_constant_expression_p
12395 = parser
->integral_constant_expression_p
;
12396 saved_non_integral_constant_expression_p
12397 = parser
->non_integral_constant_expression_p
;
12398 parser
->integral_constant_expression_p
= false;
12400 /* Within a parenthesized expression, a `>' token is always
12401 the greater-than operator. */
12402 saved_greater_than_is_operator_p
12403 = parser
->greater_than_is_operator_p
;
12404 parser
->greater_than_is_operator_p
= true;
12406 /* Do not actually evaluate the expression. */
12407 ++cp_unevaluated_operand
;
12409 /* Do not warn about problems with the expression. */
12410 ++c_inhibit_evaluation_warnings
;
12412 expr
= cp_parser_decltype_expr (parser
, id_expression_or_member_access_p
);
12414 /* Go back to evaluating expressions. */
12415 --cp_unevaluated_operand
;
12416 --c_inhibit_evaluation_warnings
;
12418 /* The `>' token might be the end of a template-id or
12419 template-parameter-list now. */
12420 parser
->greater_than_is_operator_p
12421 = saved_greater_than_is_operator_p
;
12423 /* Restore the old message and the integral constant expression
12425 parser
->type_definition_forbidden_message
= saved_message
;
12426 parser
->integral_constant_expression_p
12427 = saved_integral_constant_expression_p
;
12428 parser
->non_integral_constant_expression_p
12429 = saved_non_integral_constant_expression_p
;
12431 /* Parse to the closing `)'. */
12432 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
12434 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
12435 /*consume_paren=*/true);
12436 return error_mark_node
;
12439 expr
= finish_decltype_type (expr
, id_expression_or_member_access_p
,
12440 tf_warning_or_error
);
12443 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
12445 start_token
->type
= CPP_DECLTYPE
;
12446 start_token
->u
.value
= expr
;
12447 start_token
->keyword
= RID_MAX
;
12448 cp_lexer_purge_tokens_after (parser
->lexer
, start_token
);
12453 /* Special member functions [gram.special] */
12455 /* Parse a conversion-function-id.
12457 conversion-function-id:
12458 operator conversion-type-id
12460 Returns an IDENTIFIER_NODE representing the operator. */
12463 cp_parser_conversion_function_id (cp_parser
* parser
)
12467 tree saved_qualifying_scope
;
12468 tree saved_object_scope
;
12469 tree pushed_scope
= NULL_TREE
;
12471 /* Look for the `operator' token. */
12472 if (!cp_parser_require_keyword (parser
, RID_OPERATOR
, RT_OPERATOR
))
12473 return error_mark_node
;
12474 /* When we parse the conversion-type-id, the current scope will be
12475 reset. However, we need that information in able to look up the
12476 conversion function later, so we save it here. */
12477 saved_scope
= parser
->scope
;
12478 saved_qualifying_scope
= parser
->qualifying_scope
;
12479 saved_object_scope
= parser
->object_scope
;
12480 /* We must enter the scope of the class so that the names of
12481 entities declared within the class are available in the
12482 conversion-type-id. For example, consider:
12489 S::operator I() { ... }
12491 In order to see that `I' is a type-name in the definition, we
12492 must be in the scope of `S'. */
12494 pushed_scope
= push_scope (saved_scope
);
12495 /* Parse the conversion-type-id. */
12496 type
= cp_parser_conversion_type_id (parser
);
12497 /* Leave the scope of the class, if any. */
12499 pop_scope (pushed_scope
);
12500 /* Restore the saved scope. */
12501 parser
->scope
= saved_scope
;
12502 parser
->qualifying_scope
= saved_qualifying_scope
;
12503 parser
->object_scope
= saved_object_scope
;
12504 /* If the TYPE is invalid, indicate failure. */
12505 if (type
== error_mark_node
)
12506 return error_mark_node
;
12507 return mangle_conv_op_name_for_type (type
);
12510 /* Parse a conversion-type-id:
12512 conversion-type-id:
12513 type-specifier-seq conversion-declarator [opt]
12515 Returns the TYPE specified. */
12518 cp_parser_conversion_type_id (cp_parser
* parser
)
12521 cp_decl_specifier_seq type_specifiers
;
12522 cp_declarator
*declarator
;
12523 tree type_specified
;
12524 const char *saved_message
;
12526 /* Parse the attributes. */
12527 attributes
= cp_parser_attributes_opt (parser
);
12529 saved_message
= parser
->type_definition_forbidden_message
;
12530 parser
->type_definition_forbidden_message
12531 = G_("types may not be defined in a conversion-type-id");
12533 /* Parse the type-specifiers. */
12534 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
12535 /*is_trailing_return=*/false,
12538 parser
->type_definition_forbidden_message
= saved_message
;
12540 /* If that didn't work, stop. */
12541 if (type_specifiers
.type
== error_mark_node
)
12542 return error_mark_node
;
12543 /* Parse the conversion-declarator. */
12544 declarator
= cp_parser_conversion_declarator_opt (parser
);
12546 type_specified
= grokdeclarator (declarator
, &type_specifiers
, TYPENAME
,
12547 /*initialized=*/0, &attributes
);
12549 cplus_decl_attributes (&type_specified
, attributes
, /*flags=*/0);
12551 /* Don't give this error when parsing tentatively. This happens to
12552 work because we always parse this definitively once. */
12553 if (! cp_parser_uncommitted_to_tentative_parse_p (parser
)
12554 && type_uses_auto (type_specified
))
12556 if (cxx_dialect
< cxx14
)
12558 error ("invalid use of %<auto%> in conversion operator");
12559 return error_mark_node
;
12561 else if (template_parm_scope_p ())
12562 warning (0, "use of %<auto%> in member template "
12563 "conversion operator can never be deduced");
12566 return type_specified
;
12569 /* Parse an (optional) conversion-declarator.
12571 conversion-declarator:
12572 ptr-operator conversion-declarator [opt]
12576 static cp_declarator
*
12577 cp_parser_conversion_declarator_opt (cp_parser
* parser
)
12579 enum tree_code code
;
12580 tree class_type
, std_attributes
= NULL_TREE
;
12581 cp_cv_quals cv_quals
;
12583 /* We don't know if there's a ptr-operator next, or not. */
12584 cp_parser_parse_tentatively (parser
);
12585 /* Try the ptr-operator. */
12586 code
= cp_parser_ptr_operator (parser
, &class_type
, &cv_quals
,
12588 /* If it worked, look for more conversion-declarators. */
12589 if (cp_parser_parse_definitely (parser
))
12591 cp_declarator
*declarator
;
12593 /* Parse another optional declarator. */
12594 declarator
= cp_parser_conversion_declarator_opt (parser
);
12596 declarator
= cp_parser_make_indirect_declarator
12597 (code
, class_type
, cv_quals
, declarator
, std_attributes
);
12605 /* Parse an (optional) ctor-initializer.
12608 : mem-initializer-list
12610 Returns TRUE iff the ctor-initializer was actually present. */
12613 cp_parser_ctor_initializer_opt (cp_parser
* parser
)
12615 /* If the next token is not a `:', then there is no
12616 ctor-initializer. */
12617 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
12619 /* Do default initialization of any bases and members. */
12620 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12621 finish_mem_initializers (NULL_TREE
);
12626 /* Consume the `:' token. */
12627 cp_lexer_consume_token (parser
->lexer
);
12628 /* And the mem-initializer-list. */
12629 cp_parser_mem_initializer_list (parser
);
12634 /* Parse a mem-initializer-list.
12636 mem-initializer-list:
12637 mem-initializer ... [opt]
12638 mem-initializer ... [opt] , mem-initializer-list */
12641 cp_parser_mem_initializer_list (cp_parser
* parser
)
12643 tree mem_initializer_list
= NULL_TREE
;
12644 tree target_ctor
= error_mark_node
;
12645 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12647 /* Let the semantic analysis code know that we are starting the
12648 mem-initializer-list. */
12649 if (!DECL_CONSTRUCTOR_P (current_function_decl
))
12650 error_at (token
->location
,
12651 "only constructors take member initializers");
12653 /* Loop through the list. */
12656 tree mem_initializer
;
12658 token
= cp_lexer_peek_token (parser
->lexer
);
12659 /* Parse the mem-initializer. */
12660 mem_initializer
= cp_parser_mem_initializer (parser
);
12661 /* If the next token is a `...', we're expanding member initializers. */
12662 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
12664 /* Consume the `...'. */
12665 cp_lexer_consume_token (parser
->lexer
);
12667 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
12668 can be expanded but members cannot. */
12669 if (mem_initializer
!= error_mark_node
12670 && !TYPE_P (TREE_PURPOSE (mem_initializer
)))
12672 error_at (token
->location
,
12673 "cannot expand initializer for member %<%D%>",
12674 TREE_PURPOSE (mem_initializer
));
12675 mem_initializer
= error_mark_node
;
12678 /* Construct the pack expansion type. */
12679 if (mem_initializer
!= error_mark_node
)
12680 mem_initializer
= make_pack_expansion (mem_initializer
);
12682 if (target_ctor
!= error_mark_node
12683 && mem_initializer
!= error_mark_node
)
12685 error ("mem-initializer for %qD follows constructor delegation",
12686 TREE_PURPOSE (mem_initializer
));
12687 mem_initializer
= error_mark_node
;
12689 /* Look for a target constructor. */
12690 if (mem_initializer
!= error_mark_node
12691 && CLASS_TYPE_P (TREE_PURPOSE (mem_initializer
))
12692 && same_type_p (TREE_PURPOSE (mem_initializer
), current_class_type
))
12694 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS
);
12695 if (mem_initializer_list
)
12697 error ("constructor delegation follows mem-initializer for %qD",
12698 TREE_PURPOSE (mem_initializer_list
));
12699 mem_initializer
= error_mark_node
;
12701 target_ctor
= mem_initializer
;
12703 /* Add it to the list, unless it was erroneous. */
12704 if (mem_initializer
!= error_mark_node
)
12706 TREE_CHAIN (mem_initializer
) = mem_initializer_list
;
12707 mem_initializer_list
= mem_initializer
;
12709 /* If the next token is not a `,', we're done. */
12710 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
12712 /* Consume the `,' token. */
12713 cp_lexer_consume_token (parser
->lexer
);
12716 /* Perform semantic analysis. */
12717 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12718 finish_mem_initializers (mem_initializer_list
);
12721 /* Parse a mem-initializer.
12724 mem-initializer-id ( expression-list [opt] )
12725 mem-initializer-id braced-init-list
12730 ( expression-list [opt] )
12732 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
12733 class) or FIELD_DECL (for a non-static data member) to initialize;
12734 the TREE_VALUE is the expression-list. An empty initialization
12735 list is represented by void_list_node. */
12738 cp_parser_mem_initializer (cp_parser
* parser
)
12740 tree mem_initializer_id
;
12741 tree expression_list
;
12743 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12745 /* Find out what is being initialized. */
12746 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
12748 permerror (token
->location
,
12749 "anachronistic old-style base class initializer");
12750 mem_initializer_id
= NULL_TREE
;
12754 mem_initializer_id
= cp_parser_mem_initializer_id (parser
);
12755 if (mem_initializer_id
== error_mark_node
)
12756 return mem_initializer_id
;
12758 member
= expand_member_init (mem_initializer_id
);
12759 if (member
&& !DECL_P (member
))
12760 in_base_initializer
= 1;
12762 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
12764 bool expr_non_constant_p
;
12765 cp_lexer_set_source_position (parser
->lexer
);
12766 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
12767 expression_list
= cp_parser_braced_list (parser
, &expr_non_constant_p
);
12768 CONSTRUCTOR_IS_DIRECT_INIT (expression_list
) = 1;
12769 expression_list
= build_tree_list (NULL_TREE
, expression_list
);
12773 vec
<tree
, va_gc
> *vec
;
12774 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
12776 /*allow_expansion_p=*/true,
12777 /*non_constant_p=*/NULL
);
12779 return error_mark_node
;
12780 expression_list
= build_tree_list_vec (vec
);
12781 release_tree_vector (vec
);
12784 if (expression_list
== error_mark_node
)
12785 return error_mark_node
;
12786 if (!expression_list
)
12787 expression_list
= void_type_node
;
12789 in_base_initializer
= 0;
12791 return member
? build_tree_list (member
, expression_list
) : error_mark_node
;
12794 /* Parse a mem-initializer-id.
12796 mem-initializer-id:
12797 :: [opt] nested-name-specifier [opt] class-name
12800 Returns a TYPE indicating the class to be initializer for the first
12801 production. Returns an IDENTIFIER_NODE indicating the data member
12802 to be initialized for the second production. */
12805 cp_parser_mem_initializer_id (cp_parser
* parser
)
12807 bool global_scope_p
;
12808 bool nested_name_specifier_p
;
12809 bool template_p
= false;
12812 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
12814 /* `typename' is not allowed in this context ([temp.res]). */
12815 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TYPENAME
))
12817 error_at (token
->location
,
12818 "keyword %<typename%> not allowed in this context (a qualified "
12819 "member initializer is implicitly a type)");
12820 cp_lexer_consume_token (parser
->lexer
);
12822 /* Look for the optional `::' operator. */
12824 = (cp_parser_global_scope_opt (parser
,
12825 /*current_scope_valid_p=*/false)
12827 /* Look for the optional nested-name-specifier. The simplest way to
12832 The keyword `typename' is not permitted in a base-specifier or
12833 mem-initializer; in these contexts a qualified name that
12834 depends on a template-parameter is implicitly assumed to be a
12837 is to assume that we have seen the `typename' keyword at this
12839 nested_name_specifier_p
12840 = (cp_parser_nested_name_specifier_opt (parser
,
12841 /*typename_keyword_p=*/true,
12842 /*check_dependency_p=*/true,
12844 /*is_declaration=*/true)
12846 if (nested_name_specifier_p
)
12847 template_p
= cp_parser_optional_template_keyword (parser
);
12848 /* If there is a `::' operator or a nested-name-specifier, then we
12849 are definitely looking for a class-name. */
12850 if (global_scope_p
|| nested_name_specifier_p
)
12851 return cp_parser_class_name (parser
,
12852 /*typename_keyword_p=*/true,
12853 /*template_keyword_p=*/template_p
,
12855 /*check_dependency_p=*/true,
12856 /*class_head_p=*/false,
12857 /*is_declaration=*/true);
12858 /* Otherwise, we could also be looking for an ordinary identifier. */
12859 cp_parser_parse_tentatively (parser
);
12860 /* Try a class-name. */
12861 id
= cp_parser_class_name (parser
,
12862 /*typename_keyword_p=*/true,
12863 /*template_keyword_p=*/false,
12865 /*check_dependency_p=*/true,
12866 /*class_head_p=*/false,
12867 /*is_declaration=*/true);
12868 /* If we found one, we're done. */
12869 if (cp_parser_parse_definitely (parser
))
12871 /* Otherwise, look for an ordinary identifier. */
12872 return cp_parser_identifier (parser
);
12875 /* Overloading [gram.over] */
12877 /* Parse an operator-function-id.
12879 operator-function-id:
12882 Returns an IDENTIFIER_NODE for the operator which is a
12883 human-readable spelling of the identifier, e.g., `operator +'. */
12886 cp_parser_operator_function_id (cp_parser
* parser
)
12888 /* Look for the `operator' keyword. */
12889 if (!cp_parser_require_keyword (parser
, RID_OPERATOR
, RT_OPERATOR
))
12890 return error_mark_node
;
12891 /* And then the name of the operator itself. */
12892 return cp_parser_operator (parser
);
12895 /* Return an identifier node for a user-defined literal operator.
12896 The suffix identifier is chained to the operator name identifier. */
12899 cp_literal_operator_id (const char* name
)
12902 char *buffer
= XNEWVEC (char, strlen (UDLIT_OP_ANSI_PREFIX
)
12903 + strlen (name
) + 10);
12904 sprintf (buffer
, UDLIT_OP_ANSI_FORMAT
, name
);
12905 identifier
= get_identifier (buffer
);
12910 /* Parse an operator.
12913 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
12914 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
12915 || ++ -- , ->* -> () []
12922 Returns an IDENTIFIER_NODE for the operator which is a
12923 human-readable spelling of the identifier, e.g., `operator +'. */
12926 cp_parser_operator (cp_parser
* parser
)
12928 tree id
= NULL_TREE
;
12932 /* Peek at the next token. */
12933 token
= cp_lexer_peek_token (parser
->lexer
);
12934 /* Figure out which operator we have. */
12935 switch (token
->type
)
12941 /* The keyword should be either `new' or `delete'. */
12942 if (token
->keyword
== RID_NEW
)
12944 else if (token
->keyword
== RID_DELETE
)
12949 /* Consume the `new' or `delete' token. */
12950 cp_lexer_consume_token (parser
->lexer
);
12952 /* Peek at the next token. */
12953 token
= cp_lexer_peek_token (parser
->lexer
);
12954 /* If it's a `[' token then this is the array variant of the
12956 if (token
->type
== CPP_OPEN_SQUARE
)
12958 /* Consume the `[' token. */
12959 cp_lexer_consume_token (parser
->lexer
);
12960 /* Look for the `]' token. */
12961 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
12962 id
= ansi_opname (op
== NEW_EXPR
12963 ? VEC_NEW_EXPR
: VEC_DELETE_EXPR
);
12965 /* Otherwise, we have the non-array variant. */
12967 id
= ansi_opname (op
);
12973 id
= ansi_opname (PLUS_EXPR
);
12977 id
= ansi_opname (MINUS_EXPR
);
12981 id
= ansi_opname (MULT_EXPR
);
12985 id
= ansi_opname (TRUNC_DIV_EXPR
);
12989 id
= ansi_opname (TRUNC_MOD_EXPR
);
12993 id
= ansi_opname (BIT_XOR_EXPR
);
12997 id
= ansi_opname (BIT_AND_EXPR
);
13001 id
= ansi_opname (BIT_IOR_EXPR
);
13005 id
= ansi_opname (BIT_NOT_EXPR
);
13009 id
= ansi_opname (TRUTH_NOT_EXPR
);
13013 id
= ansi_assopname (NOP_EXPR
);
13017 id
= ansi_opname (LT_EXPR
);
13021 id
= ansi_opname (GT_EXPR
);
13025 id
= ansi_assopname (PLUS_EXPR
);
13029 id
= ansi_assopname (MINUS_EXPR
);
13033 id
= ansi_assopname (MULT_EXPR
);
13037 id
= ansi_assopname (TRUNC_DIV_EXPR
);
13041 id
= ansi_assopname (TRUNC_MOD_EXPR
);
13045 id
= ansi_assopname (BIT_XOR_EXPR
);
13049 id
= ansi_assopname (BIT_AND_EXPR
);
13053 id
= ansi_assopname (BIT_IOR_EXPR
);
13057 id
= ansi_opname (LSHIFT_EXPR
);
13061 id
= ansi_opname (RSHIFT_EXPR
);
13064 case CPP_LSHIFT_EQ
:
13065 id
= ansi_assopname (LSHIFT_EXPR
);
13068 case CPP_RSHIFT_EQ
:
13069 id
= ansi_assopname (RSHIFT_EXPR
);
13073 id
= ansi_opname (EQ_EXPR
);
13077 id
= ansi_opname (NE_EXPR
);
13081 id
= ansi_opname (LE_EXPR
);
13084 case CPP_GREATER_EQ
:
13085 id
= ansi_opname (GE_EXPR
);
13089 id
= ansi_opname (TRUTH_ANDIF_EXPR
);
13093 id
= ansi_opname (TRUTH_ORIF_EXPR
);
13096 case CPP_PLUS_PLUS
:
13097 id
= ansi_opname (POSTINCREMENT_EXPR
);
13100 case CPP_MINUS_MINUS
:
13101 id
= ansi_opname (PREDECREMENT_EXPR
);
13105 id
= ansi_opname (COMPOUND_EXPR
);
13108 case CPP_DEREF_STAR
:
13109 id
= ansi_opname (MEMBER_REF
);
13113 id
= ansi_opname (COMPONENT_REF
);
13116 case CPP_OPEN_PAREN
:
13117 /* Consume the `('. */
13118 cp_lexer_consume_token (parser
->lexer
);
13119 /* Look for the matching `)'. */
13120 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
13121 return ansi_opname (CALL_EXPR
);
13123 case CPP_OPEN_SQUARE
:
13124 /* Consume the `['. */
13125 cp_lexer_consume_token (parser
->lexer
);
13126 /* Look for the matching `]'. */
13127 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
13128 return ansi_opname (ARRAY_REF
);
13130 case CPP_UTF8STRING
:
13131 case CPP_UTF8STRING_USERDEF
:
13137 case CPP_STRING_USERDEF
:
13138 case CPP_WSTRING_USERDEF
:
13139 case CPP_STRING16_USERDEF
:
13140 case CPP_STRING32_USERDEF
:
13142 tree str
, string_tree
;
13145 if (cxx_dialect
== cxx98
)
13146 maybe_warn_cpp0x (CPP0X_USER_DEFINED_LITERALS
);
13148 /* Consume the string. */
13149 str
= cp_parser_string_literal (parser
, /*translate=*/true,
13150 /*wide_ok=*/true, /*lookup_udlit=*/false);
13151 if (str
== error_mark_node
)
13152 return error_mark_node
;
13153 else if (TREE_CODE (str
) == USERDEF_LITERAL
)
13155 string_tree
= USERDEF_LITERAL_VALUE (str
);
13156 id
= USERDEF_LITERAL_SUFFIX_ID (str
);
13161 /* Look for the suffix identifier. */
13162 token
= cp_lexer_peek_token (parser
->lexer
);
13163 if (token
->type
== CPP_NAME
)
13164 id
= cp_parser_identifier (parser
);
13165 else if (token
->type
== CPP_KEYWORD
)
13167 error ("unexpected keyword;"
13168 " remove space between quotes and suffix identifier");
13169 return error_mark_node
;
13173 error ("expected suffix identifier");
13174 return error_mark_node
;
13177 sz
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT
13178 (TREE_TYPE (TREE_TYPE (string_tree
))));
13179 len
= TREE_STRING_LENGTH (string_tree
) / sz
- 1;
13182 error ("expected empty string after %<operator%> keyword");
13183 return error_mark_node
;
13185 if (utf8
|| TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string_tree
)))
13188 error ("invalid encoding prefix in literal operator");
13189 return error_mark_node
;
13191 if (id
!= error_mark_node
)
13193 const char *name
= IDENTIFIER_POINTER (id
);
13194 id
= cp_literal_operator_id (name
);
13200 /* Anything else is an error. */
13204 /* If we have selected an identifier, we need to consume the
13207 cp_lexer_consume_token (parser
->lexer
);
13208 /* Otherwise, no valid operator name was present. */
13211 cp_parser_error (parser
, "expected operator");
13212 id
= error_mark_node
;
13218 /* Parse a template-declaration.
13220 template-declaration:
13221 export [opt] template < template-parameter-list > declaration
13223 If MEMBER_P is TRUE, this template-declaration occurs within a
13226 The grammar rule given by the standard isn't correct. What
13227 is really meant is:
13229 template-declaration:
13230 export [opt] template-parameter-list-seq
13231 decl-specifier-seq [opt] init-declarator [opt] ;
13232 export [opt] template-parameter-list-seq
13233 function-definition
13235 template-parameter-list-seq:
13236 template-parameter-list-seq [opt]
13237 template < template-parameter-list > */
13240 cp_parser_template_declaration (cp_parser
* parser
, bool member_p
)
13242 /* Check for `export'. */
13243 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_EXPORT
))
13245 /* Consume the `export' token. */
13246 cp_lexer_consume_token (parser
->lexer
);
13247 /* Warn that we do not support `export'. */
13248 warning (0, "keyword %<export%> not implemented, and will be ignored");
13251 cp_parser_template_declaration_after_export (parser
, member_p
);
13254 /* Parse a template-parameter-list.
13256 template-parameter-list:
13258 template-parameter-list , template-parameter
13260 Returns a TREE_LIST. Each node represents a template parameter.
13261 The nodes are connected via their TREE_CHAINs. */
13264 cp_parser_template_parameter_list (cp_parser
* parser
)
13266 tree parameter_list
= NULL_TREE
;
13268 begin_template_parm_list ();
13270 /* The loop below parses the template parms. We first need to know
13271 the total number of template parms to be able to compute proper
13272 canonical types of each dependent type. So after the loop, when
13273 we know the total number of template parms,
13274 end_template_parm_list computes the proper canonical types and
13275 fixes up the dependent types accordingly. */
13280 bool is_parameter_pack
;
13281 location_t parm_loc
;
13283 /* Parse the template-parameter. */
13284 parm_loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
13285 parameter
= cp_parser_template_parameter (parser
,
13287 &is_parameter_pack
);
13288 /* Add it to the list. */
13289 if (parameter
!= error_mark_node
)
13290 parameter_list
= process_template_parm (parameter_list
,
13294 is_parameter_pack
);
13297 tree err_parm
= build_tree_list (parameter
, parameter
);
13298 parameter_list
= chainon (parameter_list
, err_parm
);
13301 /* If the next token is not a `,', we're done. */
13302 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
13304 /* Otherwise, consume the `,' token. */
13305 cp_lexer_consume_token (parser
->lexer
);
13308 return end_template_parm_list (parameter_list
);
13311 /* Parse a template-parameter.
13313 template-parameter:
13315 parameter-declaration
13317 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
13318 the parameter. The TREE_PURPOSE is the default value, if any.
13319 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
13320 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
13321 set to true iff this parameter is a parameter pack. */
13324 cp_parser_template_parameter (cp_parser
* parser
, bool *is_non_type
,
13325 bool *is_parameter_pack
)
13328 cp_parameter_declarator
*parameter_declarator
;
13329 cp_declarator
*id_declarator
;
13332 /* Assume it is a type parameter or a template parameter. */
13333 *is_non_type
= false;
13334 /* Assume it not a parameter pack. */
13335 *is_parameter_pack
= false;
13336 /* Peek at the next token. */
13337 token
= cp_lexer_peek_token (parser
->lexer
);
13338 /* If it is `class' or `template', we have a type-parameter. */
13339 if (token
->keyword
== RID_TEMPLATE
)
13340 return cp_parser_type_parameter (parser
, is_parameter_pack
);
13341 /* If it is `class' or `typename' we do not know yet whether it is a
13342 type parameter or a non-type parameter. Consider:
13344 template <typename T, typename T::X X> ...
13348 template <class C, class D*> ...
13350 Here, the first parameter is a type parameter, and the second is
13351 a non-type parameter. We can tell by looking at the token after
13352 the identifier -- if it is a `,', `=', or `>' then we have a type
13354 if (token
->keyword
== RID_TYPENAME
|| token
->keyword
== RID_CLASS
)
13356 /* Peek at the token after `class' or `typename'. */
13357 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
13358 /* If it's an ellipsis, we have a template type parameter
13360 if (token
->type
== CPP_ELLIPSIS
)
13361 return cp_parser_type_parameter (parser
, is_parameter_pack
);
13362 /* If it's an identifier, skip it. */
13363 if (token
->type
== CPP_NAME
)
13364 token
= cp_lexer_peek_nth_token (parser
->lexer
, 3);
13365 /* Now, see if the token looks like the end of a template
13367 if (token
->type
== CPP_COMMA
13368 || token
->type
== CPP_EQ
13369 || token
->type
== CPP_GREATER
)
13370 return cp_parser_type_parameter (parser
, is_parameter_pack
);
13373 /* Otherwise, it is a non-type parameter.
13377 When parsing a default template-argument for a non-type
13378 template-parameter, the first non-nested `>' is taken as the end
13379 of the template parameter-list rather than a greater-than
13381 *is_non_type
= true;
13382 parameter_declarator
13383 = cp_parser_parameter_declaration (parser
, /*template_parm_p=*/true,
13384 /*parenthesized_p=*/NULL
);
13386 if (!parameter_declarator
)
13387 return error_mark_node
;
13389 /* If the parameter declaration is marked as a parameter pack, set
13390 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
13391 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
13393 if (parameter_declarator
->declarator
13394 && parameter_declarator
->declarator
->parameter_pack_p
)
13396 *is_parameter_pack
= true;
13397 parameter_declarator
->declarator
->parameter_pack_p
= false;
13400 if (parameter_declarator
->default_argument
)
13402 /* Can happen in some cases of erroneous input (c++/34892). */
13403 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
13404 /* Consume the `...' for better error recovery. */
13405 cp_lexer_consume_token (parser
->lexer
);
13407 /* If the next token is an ellipsis, and we don't already have it
13408 marked as a parameter pack, then we have a parameter pack (that
13409 has no declarator). */
13410 else if (!*is_parameter_pack
13411 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
)
13412 && (declarator_can_be_parameter_pack
13413 (parameter_declarator
->declarator
)))
13415 /* Consume the `...'. */
13416 cp_lexer_consume_token (parser
->lexer
);
13417 maybe_warn_variadic_templates ();
13419 *is_parameter_pack
= true;
13421 /* We might end up with a pack expansion as the type of the non-type
13422 template parameter, in which case this is a non-type template
13424 else if (parameter_declarator
->decl_specifiers
.type
13425 && PACK_EXPANSION_P (parameter_declarator
->decl_specifiers
.type
))
13427 *is_parameter_pack
= true;
13428 parameter_declarator
->decl_specifiers
.type
=
13429 PACK_EXPANSION_PATTERN (parameter_declarator
->decl_specifiers
.type
);
13432 if (*is_parameter_pack
&& cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
13434 /* Parameter packs cannot have default arguments. However, a
13435 user may try to do so, so we'll parse them and give an
13436 appropriate diagnostic here. */
13438 cp_token
*start_token
= cp_lexer_peek_token (parser
->lexer
);
13440 /* Find the name of the parameter pack. */
13441 id_declarator
= parameter_declarator
->declarator
;
13442 while (id_declarator
&& id_declarator
->kind
!= cdk_id
)
13443 id_declarator
= id_declarator
->declarator
;
13445 if (id_declarator
&& id_declarator
->kind
== cdk_id
)
13446 error_at (start_token
->location
,
13447 "template parameter pack %qD cannot have a default argument",
13448 id_declarator
->u
.id
.unqualified_name
);
13450 error_at (start_token
->location
,
13451 "template parameter pack cannot have a default argument");
13453 /* Parse the default argument, but throw away the result. */
13454 cp_parser_default_argument (parser
, /*template_parm_p=*/true);
13457 parm
= grokdeclarator (parameter_declarator
->declarator
,
13458 ¶meter_declarator
->decl_specifiers
,
13459 TPARM
, /*initialized=*/0,
13460 /*attrlist=*/NULL
);
13461 if (parm
== error_mark_node
)
13462 return error_mark_node
;
13464 return build_tree_list (parameter_declarator
->default_argument
, parm
);
13467 /* Parse a type-parameter.
13470 class identifier [opt]
13471 class identifier [opt] = type-id
13472 typename identifier [opt]
13473 typename identifier [opt] = type-id
13474 template < template-parameter-list > class identifier [opt]
13475 template < template-parameter-list > class identifier [opt]
13478 GNU Extension (variadic templates):
13481 class ... identifier [opt]
13482 typename ... identifier [opt]
13484 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
13485 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
13486 the declaration of the parameter.
13488 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
13491 cp_parser_type_parameter (cp_parser
* parser
, bool *is_parameter_pack
)
13496 /* Look for a keyword to tell us what kind of parameter this is. */
13497 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_CLASS_TYPENAME_TEMPLATE
);
13499 return error_mark_node
;
13501 switch (token
->keyword
)
13507 tree default_argument
;
13509 /* If the next token is an ellipsis, we have a template
13511 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
13513 /* Consume the `...' token. */
13514 cp_lexer_consume_token (parser
->lexer
);
13515 maybe_warn_variadic_templates ();
13517 *is_parameter_pack
= true;
13520 /* If the next token is an identifier, then it names the
13522 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
13523 identifier
= cp_parser_identifier (parser
);
13525 identifier
= NULL_TREE
;
13527 /* Create the parameter. */
13528 parameter
= finish_template_type_parm (class_type_node
, identifier
);
13530 /* If the next token is an `=', we have a default argument. */
13531 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
13533 /* Consume the `=' token. */
13534 cp_lexer_consume_token (parser
->lexer
);
13535 /* Parse the default-argument. */
13536 push_deferring_access_checks (dk_no_deferred
);
13537 default_argument
= cp_parser_type_id (parser
);
13539 /* Template parameter packs cannot have default
13541 if (*is_parameter_pack
)
13544 error_at (token
->location
,
13545 "template parameter pack %qD cannot have a "
13546 "default argument", identifier
);
13548 error_at (token
->location
,
13549 "template parameter packs cannot have "
13550 "default arguments");
13551 default_argument
= NULL_TREE
;
13553 else if (check_for_bare_parameter_packs (default_argument
))
13554 default_argument
= error_mark_node
;
13555 pop_deferring_access_checks ();
13558 default_argument
= NULL_TREE
;
13560 /* Create the combined representation of the parameter and the
13561 default argument. */
13562 parameter
= build_tree_list (default_argument
, parameter
);
13569 tree default_argument
;
13571 /* Look for the `<'. */
13572 cp_parser_require (parser
, CPP_LESS
, RT_LESS
);
13573 /* Parse the template-parameter-list. */
13574 cp_parser_template_parameter_list (parser
);
13575 /* Look for the `>'. */
13576 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
13577 /* Look for the `class' or 'typename' keywords. */
13578 cp_parser_type_parameter_key (parser
);
13579 /* If the next token is an ellipsis, we have a template
13581 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
13583 /* Consume the `...' token. */
13584 cp_lexer_consume_token (parser
->lexer
);
13585 maybe_warn_variadic_templates ();
13587 *is_parameter_pack
= true;
13589 /* If the next token is an `=', then there is a
13590 default-argument. If the next token is a `>', we are at
13591 the end of the parameter-list. If the next token is a `,',
13592 then we are at the end of this parameter. */
13593 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
)
13594 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_GREATER
)
13595 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
13597 identifier
= cp_parser_identifier (parser
);
13598 /* Treat invalid names as if the parameter were nameless. */
13599 if (identifier
== error_mark_node
)
13600 identifier
= NULL_TREE
;
13603 identifier
= NULL_TREE
;
13605 /* Create the template parameter. */
13606 parameter
= finish_template_template_parm (class_type_node
,
13609 /* If the next token is an `=', then there is a
13610 default-argument. */
13611 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
13615 /* Consume the `='. */
13616 cp_lexer_consume_token (parser
->lexer
);
13617 /* Parse the id-expression. */
13618 push_deferring_access_checks (dk_no_deferred
);
13619 /* save token before parsing the id-expression, for error
13621 token
= cp_lexer_peek_token (parser
->lexer
);
13623 = cp_parser_id_expression (parser
,
13624 /*template_keyword_p=*/false,
13625 /*check_dependency_p=*/true,
13626 /*template_p=*/&is_template
,
13627 /*declarator_p=*/false,
13628 /*optional_p=*/false);
13629 if (TREE_CODE (default_argument
) == TYPE_DECL
)
13630 /* If the id-expression was a template-id that refers to
13631 a template-class, we already have the declaration here,
13632 so no further lookup is needed. */
13635 /* Look up the name. */
13637 = cp_parser_lookup_name (parser
, default_argument
,
13639 /*is_template=*/is_template
,
13640 /*is_namespace=*/false,
13641 /*check_dependency=*/true,
13642 /*ambiguous_decls=*/NULL
,
13644 /* See if the default argument is valid. */
13646 = check_template_template_default_arg (default_argument
);
13648 /* Template parameter packs cannot have default
13650 if (*is_parameter_pack
)
13653 error_at (token
->location
,
13654 "template parameter pack %qD cannot "
13655 "have a default argument",
13658 error_at (token
->location
, "template parameter packs cannot "
13659 "have default arguments");
13660 default_argument
= NULL_TREE
;
13662 pop_deferring_access_checks ();
13665 default_argument
= NULL_TREE
;
13667 /* Create the combined representation of the parameter and the
13668 default argument. */
13669 parameter
= build_tree_list (default_argument
, parameter
);
13674 gcc_unreachable ();
13681 /* Parse a template-id.
13684 template-name < template-argument-list [opt] >
13686 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
13687 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
13688 returned. Otherwise, if the template-name names a function, or set
13689 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
13690 names a class, returns a TYPE_DECL for the specialization.
13692 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
13693 uninstantiated templates. */
13696 cp_parser_template_id (cp_parser
*parser
,
13697 bool template_keyword_p
,
13698 bool check_dependency_p
,
13699 enum tag_types tag_type
,
13700 bool is_declaration
)
13706 cp_token_position start_of_id
= 0;
13707 deferred_access_check
*chk
;
13708 vec
<deferred_access_check
, va_gc
> *access_check
;
13709 cp_token
*next_token
= NULL
, *next_token_2
= NULL
;
13710 bool is_identifier
;
13712 /* If the next token corresponds to a template-id, there is no need
13714 next_token
= cp_lexer_peek_token (parser
->lexer
);
13715 if (next_token
->type
== CPP_TEMPLATE_ID
)
13717 struct tree_check
*check_value
;
13719 /* Get the stored value. */
13720 check_value
= cp_lexer_consume_token (parser
->lexer
)->u
.tree_check_value
;
13721 /* Perform any access checks that were deferred. */
13722 access_check
= check_value
->checks
;
13725 FOR_EACH_VEC_ELT (*access_check
, i
, chk
)
13726 perform_or_defer_access_check (chk
->binfo
,
13729 tf_warning_or_error
);
13731 /* Return the stored value. */
13732 return check_value
->value
;
13735 /* Avoid performing name lookup if there is no possibility of
13736 finding a template-id. */
13737 if ((next_token
->type
!= CPP_NAME
&& next_token
->keyword
!= RID_OPERATOR
)
13738 || (next_token
->type
== CPP_NAME
13739 && !cp_parser_nth_token_starts_template_argument_list_p
13742 cp_parser_error (parser
, "expected template-id");
13743 return error_mark_node
;
13746 /* Remember where the template-id starts. */
13747 if (cp_parser_uncommitted_to_tentative_parse_p (parser
))
13748 start_of_id
= cp_lexer_token_position (parser
->lexer
, false);
13750 push_deferring_access_checks (dk_deferred
);
13752 /* Parse the template-name. */
13753 is_identifier
= false;
13754 templ
= cp_parser_template_name (parser
, template_keyword_p
,
13755 check_dependency_p
,
13759 if (templ
== error_mark_node
|| is_identifier
)
13761 pop_deferring_access_checks ();
13765 /* If we find the sequence `[:' after a template-name, it's probably
13766 a digraph-typo for `< ::'. Substitute the tokens and check if we can
13767 parse correctly the argument list. */
13768 next_token
= cp_lexer_peek_token (parser
->lexer
);
13769 next_token_2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
13770 if (next_token
->type
== CPP_OPEN_SQUARE
13771 && next_token
->flags
& DIGRAPH
13772 && next_token_2
->type
== CPP_COLON
13773 && !(next_token_2
->flags
& PREV_WHITE
))
13775 cp_parser_parse_tentatively (parser
);
13776 /* Change `:' into `::'. */
13777 next_token_2
->type
= CPP_SCOPE
;
13778 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
13780 cp_lexer_consume_token (parser
->lexer
);
13782 /* Parse the arguments. */
13783 arguments
= cp_parser_enclosed_template_argument_list (parser
);
13784 if (!cp_parser_parse_definitely (parser
))
13786 /* If we couldn't parse an argument list, then we revert our changes
13787 and return simply an error. Maybe this is not a template-id
13789 next_token_2
->type
= CPP_COLON
;
13790 cp_parser_error (parser
, "expected %<<%>");
13791 pop_deferring_access_checks ();
13792 return error_mark_node
;
13794 /* Otherwise, emit an error about the invalid digraph, but continue
13795 parsing because we got our argument list. */
13796 if (permerror (next_token
->location
,
13797 "%<<::%> cannot begin a template-argument list"))
13799 static bool hint
= false;
13800 inform (next_token
->location
,
13801 "%<<:%> is an alternate spelling for %<[%>."
13802 " Insert whitespace between %<<%> and %<::%>");
13803 if (!hint
&& !flag_permissive
)
13805 inform (next_token
->location
, "(if you use %<-fpermissive%> "
13806 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
13807 "accept your code)");
13814 /* Look for the `<' that starts the template-argument-list. */
13815 if (!cp_parser_require (parser
, CPP_LESS
, RT_LESS
))
13817 pop_deferring_access_checks ();
13818 return error_mark_node
;
13820 /* Parse the arguments. */
13821 arguments
= cp_parser_enclosed_template_argument_list (parser
);
13824 /* Build a representation of the specialization. */
13825 if (identifier_p (templ
))
13826 template_id
= build_min_nt_loc (next_token
->location
,
13829 else if (DECL_TYPE_TEMPLATE_P (templ
)
13830 || DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
13832 bool entering_scope
;
13833 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
13834 template (rather than some instantiation thereof) only if
13835 is not nested within some other construct. For example, in
13836 "template <typename T> void f(T) { A<T>::", A<T> is just an
13837 instantiation of A. */
13838 entering_scope
= (template_parm_scope_p ()
13839 && cp_lexer_next_token_is (parser
->lexer
,
13842 = finish_template_type (templ
, arguments
, entering_scope
);
13844 else if (variable_template_p (templ
))
13846 template_id
= lookup_template_variable (templ
, arguments
);
13850 /* If it's not a class-template or a template-template, it should be
13851 a function-template. */
13852 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ
)
13853 || TREE_CODE (templ
) == OVERLOAD
13854 || BASELINK_P (templ
)));
13856 template_id
= lookup_template_function (templ
, arguments
);
13859 /* If parsing tentatively, replace the sequence of tokens that makes
13860 up the template-id with a CPP_TEMPLATE_ID token. That way,
13861 should we re-parse the token stream, we will not have to repeat
13862 the effort required to do the parse, nor will we issue duplicate
13863 error messages about problems during instantiation of the
13866 /* Don't do this if we had a parse error in a declarator; re-parsing
13867 might succeed if a name changes meaning (60361). */
13868 && !(cp_parser_error_occurred (parser
)
13869 && cp_parser_parsing_tentatively (parser
)
13870 && parser
->in_declarator_p
))
13872 cp_token
*token
= cp_lexer_token_at (parser
->lexer
, start_of_id
);
13874 /* Reset the contents of the START_OF_ID token. */
13875 token
->type
= CPP_TEMPLATE_ID
;
13876 /* Retrieve any deferred checks. Do not pop this access checks yet
13877 so the memory will not be reclaimed during token replacing below. */
13878 token
->u
.tree_check_value
= ggc_cleared_alloc
<struct tree_check
> ();
13879 token
->u
.tree_check_value
->value
= template_id
;
13880 token
->u
.tree_check_value
->checks
= get_deferred_access_checks ();
13881 token
->keyword
= RID_MAX
;
13883 /* Purge all subsequent tokens. */
13884 cp_lexer_purge_tokens_after (parser
->lexer
, start_of_id
);
13886 /* ??? Can we actually assume that, if template_id ==
13887 error_mark_node, we will have issued a diagnostic to the
13888 user, as opposed to simply marking the tentative parse as
13890 if (cp_parser_error_occurred (parser
) && template_id
!= error_mark_node
)
13891 error_at (token
->location
, "parse error in template argument list");
13894 pop_to_parent_deferring_access_checks ();
13895 return template_id
;
13898 /* Parse a template-name.
13903 The standard should actually say:
13907 operator-function-id
13909 A defect report has been filed about this issue.
13911 A conversion-function-id cannot be a template name because they cannot
13912 be part of a template-id. In fact, looking at this code:
13914 a.operator K<int>()
13916 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
13917 It is impossible to call a templated conversion-function-id with an
13918 explicit argument list, since the only allowed template parameter is
13919 the type to which it is converting.
13921 If TEMPLATE_KEYWORD_P is true, then we have just seen the
13922 `template' keyword, in a construction like:
13926 In that case `f' is taken to be a template-name, even though there
13927 is no way of knowing for sure.
13929 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
13930 name refers to a set of overloaded functions, at least one of which
13931 is a template, or an IDENTIFIER_NODE with the name of the template,
13932 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
13933 names are looked up inside uninstantiated templates. */
13936 cp_parser_template_name (cp_parser
* parser
,
13937 bool template_keyword_p
,
13938 bool check_dependency_p
,
13939 bool is_declaration
,
13940 enum tag_types tag_type
,
13941 bool *is_identifier
)
13946 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
13948 /* If the next token is `operator', then we have either an
13949 operator-function-id or a conversion-function-id. */
13950 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_OPERATOR
))
13952 /* We don't know whether we're looking at an
13953 operator-function-id or a conversion-function-id. */
13954 cp_parser_parse_tentatively (parser
);
13955 /* Try an operator-function-id. */
13956 identifier
= cp_parser_operator_function_id (parser
);
13957 /* If that didn't work, try a conversion-function-id. */
13958 if (!cp_parser_parse_definitely (parser
))
13960 cp_parser_error (parser
, "expected template-name");
13961 return error_mark_node
;
13964 /* Look for the identifier. */
13966 identifier
= cp_parser_identifier (parser
);
13968 /* If we didn't find an identifier, we don't have a template-id. */
13969 if (identifier
== error_mark_node
)
13970 return error_mark_node
;
13972 /* If the name immediately followed the `template' keyword, then it
13973 is a template-name. However, if the next token is not `<', then
13974 we do not treat it as a template-name, since it is not being used
13975 as part of a template-id. This enables us to handle constructs
13978 template <typename T> struct S { S(); };
13979 template <typename T> S<T>::S();
13981 correctly. We would treat `S' as a template -- if it were `S<T>'
13982 -- but we do not if there is no `<'. */
13984 if (processing_template_decl
13985 && cp_parser_nth_token_starts_template_argument_list_p (parser
, 1))
13987 /* In a declaration, in a dependent context, we pretend that the
13988 "template" keyword was present in order to improve error
13989 recovery. For example, given:
13991 template <typename T> void f(T::X<int>);
13993 we want to treat "X<int>" as a template-id. */
13995 && !template_keyword_p
13996 && parser
->scope
&& TYPE_P (parser
->scope
)
13997 && check_dependency_p
13998 && dependent_scope_p (parser
->scope
)
13999 /* Do not do this for dtors (or ctors), since they never
14000 need the template keyword before their name. */
14001 && !constructor_name_p (identifier
, parser
->scope
))
14003 cp_token_position start
= 0;
14005 /* Explain what went wrong. */
14006 error_at (token
->location
, "non-template %qD used as template",
14008 inform (token
->location
, "use %<%T::template %D%> to indicate that it is a template",
14009 parser
->scope
, identifier
);
14010 /* If parsing tentatively, find the location of the "<" token. */
14011 if (cp_parser_simulate_error (parser
))
14012 start
= cp_lexer_token_position (parser
->lexer
, true);
14013 /* Parse the template arguments so that we can issue error
14014 messages about them. */
14015 cp_lexer_consume_token (parser
->lexer
);
14016 cp_parser_enclosed_template_argument_list (parser
);
14017 /* Skip tokens until we find a good place from which to
14018 continue parsing. */
14019 cp_parser_skip_to_closing_parenthesis (parser
,
14020 /*recovering=*/true,
14022 /*consume_paren=*/false);
14023 /* If parsing tentatively, permanently remove the
14024 template argument list. That will prevent duplicate
14025 error messages from being issued about the missing
14026 "template" keyword. */
14028 cp_lexer_purge_tokens_after (parser
->lexer
, start
);
14030 *is_identifier
= true;
14034 /* If the "template" keyword is present, then there is generally
14035 no point in doing name-lookup, so we just return IDENTIFIER.
14036 But, if the qualifying scope is non-dependent then we can
14037 (and must) do name-lookup normally. */
14038 if (template_keyword_p
14040 || (TYPE_P (parser
->scope
)
14041 && dependent_type_p (parser
->scope
))))
14045 /* Look up the name. */
14046 decl
= cp_parser_lookup_name (parser
, identifier
,
14048 /*is_template=*/true,
14049 /*is_namespace=*/false,
14050 check_dependency_p
,
14051 /*ambiguous_decls=*/NULL
,
14054 decl
= strip_using_decl (decl
);
14056 /* If DECL is a template, then the name was a template-name. */
14057 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
14059 if (TREE_DEPRECATED (decl
)
14060 && deprecated_state
!= DEPRECATED_SUPPRESS
)
14061 warn_deprecated_use (decl
, NULL_TREE
);
14065 tree fn
= NULL_TREE
;
14067 /* The standard does not explicitly indicate whether a name that
14068 names a set of overloaded declarations, some of which are
14069 templates, is a template-name. However, such a name should
14070 be a template-name; otherwise, there is no way to form a
14071 template-id for the overloaded templates. */
14072 fns
= BASELINK_P (decl
) ? BASELINK_FUNCTIONS (decl
) : decl
;
14073 if (TREE_CODE (fns
) == OVERLOAD
)
14074 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
14075 if (TREE_CODE (OVL_CURRENT (fn
)) == TEMPLATE_DECL
)
14080 /* The name does not name a template. */
14081 cp_parser_error (parser
, "expected template-name");
14082 return error_mark_node
;
14086 /* If DECL is dependent, and refers to a function, then just return
14087 its name; we will look it up again during template instantiation. */
14088 if (DECL_FUNCTION_TEMPLATE_P (decl
) || !DECL_P (decl
))
14090 tree scope
= ovl_scope (decl
);
14091 if (TYPE_P (scope
) && dependent_type_p (scope
))
14098 /* Parse a template-argument-list.
14100 template-argument-list:
14101 template-argument ... [opt]
14102 template-argument-list , template-argument ... [opt]
14104 Returns a TREE_VEC containing the arguments. */
14107 cp_parser_template_argument_list (cp_parser
* parser
)
14109 tree fixed_args
[10];
14110 unsigned n_args
= 0;
14111 unsigned alloced
= 10;
14112 tree
*arg_ary
= fixed_args
;
14114 bool saved_in_template_argument_list_p
;
14116 bool saved_non_ice_p
;
14118 saved_in_template_argument_list_p
= parser
->in_template_argument_list_p
;
14119 parser
->in_template_argument_list_p
= true;
14120 /* Even if the template-id appears in an integral
14121 constant-expression, the contents of the argument list do
14123 saved_ice_p
= parser
->integral_constant_expression_p
;
14124 parser
->integral_constant_expression_p
= false;
14125 saved_non_ice_p
= parser
->non_integral_constant_expression_p
;
14126 parser
->non_integral_constant_expression_p
= false;
14128 /* Parse the arguments. */
14134 /* Consume the comma. */
14135 cp_lexer_consume_token (parser
->lexer
);
14137 /* Parse the template-argument. */
14138 argument
= cp_parser_template_argument (parser
);
14140 /* If the next token is an ellipsis, we're expanding a template
14142 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
14144 if (argument
== error_mark_node
)
14146 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
14147 error_at (token
->location
,
14148 "expected parameter pack before %<...%>");
14150 /* Consume the `...' token. */
14151 cp_lexer_consume_token (parser
->lexer
);
14153 /* Make the argument into a TYPE_PACK_EXPANSION or
14154 EXPR_PACK_EXPANSION. */
14155 argument
= make_pack_expansion (argument
);
14158 if (n_args
== alloced
)
14162 if (arg_ary
== fixed_args
)
14164 arg_ary
= XNEWVEC (tree
, alloced
);
14165 memcpy (arg_ary
, fixed_args
, sizeof (tree
) * n_args
);
14168 arg_ary
= XRESIZEVEC (tree
, arg_ary
, alloced
);
14170 arg_ary
[n_args
++] = argument
;
14172 while (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
));
14174 vec
= make_tree_vec (n_args
);
14177 TREE_VEC_ELT (vec
, n_args
) = arg_ary
[n_args
];
14179 if (arg_ary
!= fixed_args
)
14181 parser
->non_integral_constant_expression_p
= saved_non_ice_p
;
14182 parser
->integral_constant_expression_p
= saved_ice_p
;
14183 parser
->in_template_argument_list_p
= saved_in_template_argument_list_p
;
14184 #ifdef ENABLE_CHECKING
14185 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
14190 /* Parse a template-argument.
14193 assignment-expression
14197 The representation is that of an assignment-expression, type-id, or
14198 id-expression -- except that the qualified id-expression is
14199 evaluated, so that the value returned is either a DECL or an
14202 Although the standard says "assignment-expression", it forbids
14203 throw-expressions or assignments in the template argument.
14204 Therefore, we use "conditional-expression" instead. */
14207 cp_parser_template_argument (cp_parser
* parser
)
14212 bool maybe_type_id
= false;
14213 cp_token
*token
= NULL
, *argument_start_token
= NULL
;
14214 location_t loc
= 0;
14217 /* There's really no way to know what we're looking at, so we just
14218 try each alternative in order.
14222 In a template-argument, an ambiguity between a type-id and an
14223 expression is resolved to a type-id, regardless of the form of
14224 the corresponding template-parameter.
14226 Therefore, we try a type-id first. */
14227 cp_parser_parse_tentatively (parser
);
14228 argument
= cp_parser_template_type_arg (parser
);
14229 /* If there was no error parsing the type-id but the next token is a
14230 '>>', our behavior depends on which dialect of C++ we're
14231 parsing. In C++98, we probably found a typo for '> >'. But there
14232 are type-id which are also valid expressions. For instance:
14234 struct X { int operator >> (int); };
14235 template <int V> struct Foo {};
14238 Here 'X()' is a valid type-id of a function type, but the user just
14239 wanted to write the expression "X() >> 5". Thus, we remember that we
14240 found a valid type-id, but we still try to parse the argument as an
14241 expression to see what happens.
14243 In C++0x, the '>>' will be considered two separate '>'
14245 if (!cp_parser_error_occurred (parser
)
14246 && cxx_dialect
== cxx98
14247 && cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
14249 maybe_type_id
= true;
14250 cp_parser_abort_tentative_parse (parser
);
14254 /* If the next token isn't a `,' or a `>', then this argument wasn't
14255 really finished. This means that the argument is not a valid
14257 if (!cp_parser_next_token_ends_template_argument_p (parser
))
14258 cp_parser_error (parser
, "expected template-argument");
14259 /* If that worked, we're done. */
14260 if (cp_parser_parse_definitely (parser
))
14263 /* We're still not sure what the argument will be. */
14264 cp_parser_parse_tentatively (parser
);
14265 /* Try a template. */
14266 argument_start_token
= cp_lexer_peek_token (parser
->lexer
);
14267 argument
= cp_parser_id_expression (parser
,
14268 /*template_keyword_p=*/false,
14269 /*check_dependency_p=*/true,
14271 /*declarator_p=*/false,
14272 /*optional_p=*/false);
14273 /* If the next token isn't a `,' or a `>', then this argument wasn't
14274 really finished. */
14275 if (!cp_parser_next_token_ends_template_argument_p (parser
))
14276 cp_parser_error (parser
, "expected template-argument");
14277 if (!cp_parser_error_occurred (parser
))
14279 /* Figure out what is being referred to. If the id-expression
14280 was for a class template specialization, then we will have a
14281 TYPE_DECL at this point. There is no need to do name lookup
14282 at this point in that case. */
14283 if (TREE_CODE (argument
) != TYPE_DECL
)
14284 argument
= cp_parser_lookup_name (parser
, argument
,
14286 /*is_template=*/template_p
,
14287 /*is_namespace=*/false,
14288 /*check_dependency=*/true,
14289 /*ambiguous_decls=*/NULL
,
14290 argument_start_token
->location
);
14291 if (TREE_CODE (argument
) != TEMPLATE_DECL
14292 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
14293 cp_parser_error (parser
, "expected template-name");
14295 if (cp_parser_parse_definitely (parser
))
14297 if (TREE_DEPRECATED (argument
))
14298 warn_deprecated_use (argument
, NULL_TREE
);
14301 /* It must be a non-type argument. There permitted cases are given
14302 in [temp.arg.nontype]:
14304 -- an integral constant-expression of integral or enumeration
14307 -- the name of a non-type template-parameter; or
14309 -- the name of an object or function with external linkage...
14311 -- the address of an object or function with external linkage...
14313 -- a pointer to member... */
14314 /* Look for a non-type template parameter. */
14315 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
14317 cp_parser_parse_tentatively (parser
);
14318 argument
= cp_parser_primary_expression (parser
,
14319 /*address_p=*/false,
14321 /*template_arg_p=*/true,
14323 if (TREE_CODE (argument
) != TEMPLATE_PARM_INDEX
14324 || !cp_parser_next_token_ends_template_argument_p (parser
))
14325 cp_parser_simulate_error (parser
);
14326 if (cp_parser_parse_definitely (parser
))
14330 /* If the next token is "&", the argument must be the address of an
14331 object or function with external linkage. */
14332 address_p
= cp_lexer_next_token_is (parser
->lexer
, CPP_AND
);
14335 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
14336 cp_lexer_consume_token (parser
->lexer
);
14338 /* See if we might have an id-expression. */
14339 token
= cp_lexer_peek_token (parser
->lexer
);
14340 if (token
->type
== CPP_NAME
14341 || token
->keyword
== RID_OPERATOR
14342 || token
->type
== CPP_SCOPE
14343 || token
->type
== CPP_TEMPLATE_ID
14344 || token
->type
== CPP_NESTED_NAME_SPECIFIER
)
14346 cp_parser_parse_tentatively (parser
);
14347 argument
= cp_parser_primary_expression (parser
,
14350 /*template_arg_p=*/true,
14352 if (cp_parser_error_occurred (parser
)
14353 || !cp_parser_next_token_ends_template_argument_p (parser
))
14354 cp_parser_abort_tentative_parse (parser
);
14359 if (INDIRECT_REF_P (argument
))
14361 /* Strip the dereference temporarily. */
14362 gcc_assert (REFERENCE_REF_P (argument
));
14363 argument
= TREE_OPERAND (argument
, 0);
14366 /* If we're in a template, we represent a qualified-id referring
14367 to a static data member as a SCOPE_REF even if the scope isn't
14368 dependent so that we can check access control later. */
14370 if (TREE_CODE (probe
) == SCOPE_REF
)
14371 probe
= TREE_OPERAND (probe
, 1);
14374 /* A variable without external linkage might still be a
14375 valid constant-expression, so no error is issued here
14376 if the external-linkage check fails. */
14377 if (!address_p
&& !DECL_EXTERNAL_LINKAGE_P (probe
))
14378 cp_parser_simulate_error (parser
);
14380 else if (is_overloaded_fn (argument
))
14381 /* All overloaded functions are allowed; if the external
14382 linkage test does not pass, an error will be issued
14386 && (TREE_CODE (argument
) == OFFSET_REF
14387 || TREE_CODE (argument
) == SCOPE_REF
))
14388 /* A pointer-to-member. */
14390 else if (TREE_CODE (argument
) == TEMPLATE_PARM_INDEX
)
14393 cp_parser_simulate_error (parser
);
14395 if (cp_parser_parse_definitely (parser
))
14398 argument
= build_x_unary_op (loc
, ADDR_EXPR
, argument
,
14399 tf_warning_or_error
);
14401 argument
= convert_from_reference (argument
);
14406 /* If the argument started with "&", there are no other valid
14407 alternatives at this point. */
14410 cp_parser_error (parser
, "invalid non-type template argument");
14411 return error_mark_node
;
14414 /* If the argument wasn't successfully parsed as a type-id followed
14415 by '>>', the argument can only be a constant expression now.
14416 Otherwise, we try parsing the constant-expression tentatively,
14417 because the argument could really be a type-id. */
14419 cp_parser_parse_tentatively (parser
);
14420 argument
= cp_parser_constant_expression (parser
);
14422 if (!maybe_type_id
)
14424 if (!cp_parser_next_token_ends_template_argument_p (parser
))
14425 cp_parser_error (parser
, "expected template-argument");
14426 if (cp_parser_parse_definitely (parser
))
14428 /* We did our best to parse the argument as a non type-id, but that
14429 was the only alternative that matched (albeit with a '>' after
14430 it). We can assume it's just a typo from the user, and a
14431 diagnostic will then be issued. */
14432 return cp_parser_template_type_arg (parser
);
14435 /* Parse an explicit-instantiation.
14437 explicit-instantiation:
14438 template declaration
14440 Although the standard says `declaration', what it really means is:
14442 explicit-instantiation:
14443 template decl-specifier-seq [opt] declarator [opt] ;
14445 Things like `template int S<int>::i = 5, int S<double>::j;' are not
14446 supposed to be allowed. A defect report has been filed about this
14451 explicit-instantiation:
14452 storage-class-specifier template
14453 decl-specifier-seq [opt] declarator [opt] ;
14454 function-specifier template
14455 decl-specifier-seq [opt] declarator [opt] ; */
14458 cp_parser_explicit_instantiation (cp_parser
* parser
)
14460 int declares_class_or_enum
;
14461 cp_decl_specifier_seq decl_specifiers
;
14462 tree extension_specifier
= NULL_TREE
;
14464 timevar_push (TV_TEMPLATE_INST
);
14466 /* Look for an (optional) storage-class-specifier or
14467 function-specifier. */
14468 if (cp_parser_allow_gnu_extensions_p (parser
))
14470 extension_specifier
14471 = cp_parser_storage_class_specifier_opt (parser
);
14472 if (!extension_specifier
)
14473 extension_specifier
14474 = cp_parser_function_specifier_opt (parser
,
14475 /*decl_specs=*/NULL
);
14478 /* Look for the `template' keyword. */
14479 cp_parser_require_keyword (parser
, RID_TEMPLATE
, RT_TEMPLATE
);
14480 /* Let the front end know that we are processing an explicit
14482 begin_explicit_instantiation ();
14483 /* [temp.explicit] says that we are supposed to ignore access
14484 control while processing explicit instantiation directives. */
14485 push_deferring_access_checks (dk_no_check
);
14486 /* Parse a decl-specifier-seq. */
14487 cp_parser_decl_specifier_seq (parser
,
14488 CP_PARSER_FLAGS_OPTIONAL
,
14490 &declares_class_or_enum
);
14491 /* If there was exactly one decl-specifier, and it declared a class,
14492 and there's no declarator, then we have an explicit type
14494 if (declares_class_or_enum
&& cp_parser_declares_only_class_p (parser
))
14498 type
= check_tag_decl (&decl_specifiers
,
14499 /*explicit_type_instantiation_p=*/true);
14500 /* Turn access control back on for names used during
14501 template instantiation. */
14502 pop_deferring_access_checks ();
14504 do_type_instantiation (type
, extension_specifier
,
14505 /*complain=*/tf_error
);
14509 cp_declarator
*declarator
;
14512 /* Parse the declarator. */
14514 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
14515 /*ctor_dtor_or_conv_p=*/NULL
,
14516 /*parenthesized_p=*/NULL
,
14517 /*member_p=*/false,
14518 /*friend_p=*/false);
14519 if (declares_class_or_enum
& 2)
14520 cp_parser_check_for_definition_in_return_type (declarator
,
14521 decl_specifiers
.type
,
14522 decl_specifiers
.locations
[ds_type_spec
]);
14523 if (declarator
!= cp_error_declarator
)
14525 if (decl_spec_seq_has_spec_p (&decl_specifiers
, ds_inline
))
14526 permerror (decl_specifiers
.locations
[ds_inline
],
14527 "explicit instantiation shall not use"
14528 " %<inline%> specifier");
14529 if (decl_spec_seq_has_spec_p (&decl_specifiers
, ds_constexpr
))
14530 permerror (decl_specifiers
.locations
[ds_constexpr
],
14531 "explicit instantiation shall not use"
14532 " %<constexpr%> specifier");
14534 decl
= grokdeclarator (declarator
, &decl_specifiers
,
14535 NORMAL
, 0, &decl_specifiers
.attributes
);
14536 /* Turn access control back on for names used during
14537 template instantiation. */
14538 pop_deferring_access_checks ();
14539 /* Do the explicit instantiation. */
14540 do_decl_instantiation (decl
, extension_specifier
);
14544 pop_deferring_access_checks ();
14545 /* Skip the body of the explicit instantiation. */
14546 cp_parser_skip_to_end_of_statement (parser
);
14549 /* We're done with the instantiation. */
14550 end_explicit_instantiation ();
14552 cp_parser_consume_semicolon_at_end_of_statement (parser
);
14554 timevar_pop (TV_TEMPLATE_INST
);
14557 /* Parse an explicit-specialization.
14559 explicit-specialization:
14560 template < > declaration
14562 Although the standard says `declaration', what it really means is:
14564 explicit-specialization:
14565 template <> decl-specifier [opt] init-declarator [opt] ;
14566 template <> function-definition
14567 template <> explicit-specialization
14568 template <> template-declaration */
14571 cp_parser_explicit_specialization (cp_parser
* parser
)
14573 bool need_lang_pop
;
14574 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
14576 /* Look for the `template' keyword. */
14577 cp_parser_require_keyword (parser
, RID_TEMPLATE
, RT_TEMPLATE
);
14578 /* Look for the `<'. */
14579 cp_parser_require (parser
, CPP_LESS
, RT_LESS
);
14580 /* Look for the `>'. */
14581 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
14582 /* We have processed another parameter list. */
14583 ++parser
->num_template_parameter_lists
;
14586 A template ... explicit specialization ... shall not have C
14588 if (current_lang_name
== lang_name_c
)
14590 error_at (token
->location
, "template specialization with C linkage");
14591 /* Give it C++ linkage to avoid confusing other parts of the
14593 push_lang_context (lang_name_cplusplus
);
14594 need_lang_pop
= true;
14597 need_lang_pop
= false;
14598 /* Let the front end know that we are beginning a specialization. */
14599 if (!begin_specialization ())
14601 end_specialization ();
14605 /* If the next keyword is `template', we need to figure out whether
14606 or not we're looking a template-declaration. */
14607 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
14609 if (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_LESS
14610 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
!= CPP_GREATER
)
14611 cp_parser_template_declaration_after_export (parser
,
14612 /*member_p=*/false);
14614 cp_parser_explicit_specialization (parser
);
14617 /* Parse the dependent declaration. */
14618 cp_parser_single_declaration (parser
,
14620 /*member_p=*/false,
14621 /*explicit_specialization_p=*/true,
14622 /*friend_p=*/NULL
);
14623 /* We're done with the specialization. */
14624 end_specialization ();
14625 /* For the erroneous case of a template with C linkage, we pushed an
14626 implicit C++ linkage scope; exit that scope now. */
14628 pop_lang_context ();
14629 /* We're done with this parameter list. */
14630 --parser
->num_template_parameter_lists
;
14633 /* Parse a type-specifier.
14636 simple-type-specifier
14639 elaborated-type-specifier
14647 Returns a representation of the type-specifier. For a
14648 class-specifier, enum-specifier, or elaborated-type-specifier, a
14649 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
14651 The parser flags FLAGS is used to control type-specifier parsing.
14653 If IS_DECLARATION is TRUE, then this type-specifier is appearing
14654 in a decl-specifier-seq.
14656 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
14657 class-specifier, enum-specifier, or elaborated-type-specifier, then
14658 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
14659 if a type is declared; 2 if it is defined. Otherwise, it is set to
14662 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
14663 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
14664 is set to FALSE. */
14667 cp_parser_type_specifier (cp_parser
* parser
,
14668 cp_parser_flags flags
,
14669 cp_decl_specifier_seq
*decl_specs
,
14670 bool is_declaration
,
14671 int* declares_class_or_enum
,
14672 bool* is_cv_qualifier
)
14674 tree type_spec
= NULL_TREE
;
14677 cp_decl_spec ds
= ds_last
;
14679 /* Assume this type-specifier does not declare a new type. */
14680 if (declares_class_or_enum
)
14681 *declares_class_or_enum
= 0;
14682 /* And that it does not specify a cv-qualifier. */
14683 if (is_cv_qualifier
)
14684 *is_cv_qualifier
= false;
14685 /* Peek at the next token. */
14686 token
= cp_lexer_peek_token (parser
->lexer
);
14688 /* If we're looking at a keyword, we can use that to guide the
14689 production we choose. */
14690 keyword
= token
->keyword
;
14694 if ((flags
& CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS
))
14695 goto elaborated_type_specifier
;
14697 /* Look for the enum-specifier. */
14698 type_spec
= cp_parser_enum_specifier (parser
);
14699 /* If that worked, we're done. */
14702 if (declares_class_or_enum
)
14703 *declares_class_or_enum
= 2;
14705 cp_parser_set_decl_spec_type (decl_specs
,
14708 /*type_definition_p=*/true);
14712 goto elaborated_type_specifier
;
14714 /* Any of these indicate either a class-specifier, or an
14715 elaborated-type-specifier. */
14719 if ((flags
& CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS
))
14720 goto elaborated_type_specifier
;
14722 /* Parse tentatively so that we can back up if we don't find a
14723 class-specifier. */
14724 cp_parser_parse_tentatively (parser
);
14725 /* Look for the class-specifier. */
14726 type_spec
= cp_parser_class_specifier (parser
);
14727 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE
, type_spec
);
14728 /* If that worked, we're done. */
14729 if (cp_parser_parse_definitely (parser
))
14731 if (declares_class_or_enum
)
14732 *declares_class_or_enum
= 2;
14734 cp_parser_set_decl_spec_type (decl_specs
,
14737 /*type_definition_p=*/true);
14741 /* Fall through. */
14742 elaborated_type_specifier
:
14743 /* We're declaring (not defining) a class or enum. */
14744 if (declares_class_or_enum
)
14745 *declares_class_or_enum
= 1;
14747 /* Fall through. */
14749 /* Look for an elaborated-type-specifier. */
14751 = (cp_parser_elaborated_type_specifier
14753 decl_spec_seq_has_spec_p (decl_specs
, ds_friend
),
14756 cp_parser_set_decl_spec_type (decl_specs
,
14759 /*type_definition_p=*/false);
14764 if (is_cv_qualifier
)
14765 *is_cv_qualifier
= true;
14770 if (is_cv_qualifier
)
14771 *is_cv_qualifier
= true;
14776 if (is_cv_qualifier
)
14777 *is_cv_qualifier
= true;
14781 /* The `__complex__' keyword is a GNU extension. */
14789 /* Handle simple keywords. */
14794 set_and_check_decl_spec_loc (decl_specs
, ds
, token
);
14795 decl_specs
->any_specifiers_p
= true;
14797 return cp_lexer_consume_token (parser
->lexer
)->u
.value
;
14800 /* If we do not already have a type-specifier, assume we are looking
14801 at a simple-type-specifier. */
14802 type_spec
= cp_parser_simple_type_specifier (parser
,
14806 /* If we didn't find a type-specifier, and a type-specifier was not
14807 optional in this context, issue an error message. */
14808 if (!type_spec
&& !(flags
& CP_PARSER_FLAGS_OPTIONAL
))
14810 cp_parser_error (parser
, "expected type specifier");
14811 return error_mark_node
;
14817 /* Parse a simple-type-specifier.
14819 simple-type-specifier:
14820 :: [opt] nested-name-specifier [opt] type-name
14821 :: [opt] nested-name-specifier template template-id
14836 simple-type-specifier:
14838 decltype ( expression )
14841 __underlying_type ( type-id )
14845 simple-type-specifier:
14847 __typeof__ unary-expression
14848 __typeof__ ( type-id )
14849 __typeof__ ( type-id ) { initializer-list , [opt] }
14851 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
14852 appropriately updated. */
14855 cp_parser_simple_type_specifier (cp_parser
* parser
,
14856 cp_decl_specifier_seq
*decl_specs
,
14857 cp_parser_flags flags
)
14859 tree type
= NULL_TREE
;
14863 /* Peek at the next token. */
14864 token
= cp_lexer_peek_token (parser
->lexer
);
14866 /* If we're looking at a keyword, things are easy. */
14867 switch (token
->keyword
)
14871 decl_specs
->explicit_char_p
= true;
14872 type
= char_type_node
;
14875 type
= char16_type_node
;
14878 type
= char32_type_node
;
14881 type
= wchar_type_node
;
14884 type
= boolean_type_node
;
14887 set_and_check_decl_spec_loc (decl_specs
, ds_short
, token
);
14888 type
= short_integer_type_node
;
14892 decl_specs
->explicit_int_p
= true;
14893 type
= integer_type_node
;
14899 idx
= token
->keyword
- RID_INT_N_0
;
14900 if (! int_n_enabled_p
[idx
])
14904 decl_specs
->explicit_intN_p
= true;
14905 decl_specs
->int_n_idx
= idx
;
14907 type
= int_n_trees
[idx
].signed_type
;
14911 set_and_check_decl_spec_loc (decl_specs
, ds_long
, token
);
14912 type
= long_integer_type_node
;
14915 set_and_check_decl_spec_loc (decl_specs
, ds_signed
, token
);
14916 type
= integer_type_node
;
14919 set_and_check_decl_spec_loc (decl_specs
, ds_unsigned
, token
);
14920 type
= unsigned_type_node
;
14923 type
= float_type_node
;
14926 type
= double_type_node
;
14929 type
= void_type_node
;
14933 maybe_warn_cpp0x (CPP0X_AUTO
);
14934 if (parser
->auto_is_implicit_function_template_parm_p
)
14936 if (cxx_dialect
>= cxx14
)
14937 type
= synthesize_implicit_template_parm (parser
);
14939 type
= error_mark_node
;
14941 if (current_class_type
&& LAMBDA_TYPE_P (current_class_type
))
14943 if (cxx_dialect
< cxx14
)
14944 error_at (token
->location
,
14945 "use of %<auto%> in lambda parameter declaration "
14946 "only available with "
14947 "-std=c++14 or -std=gnu++14");
14949 else if (cxx_dialect
< cxx14
)
14950 error_at (token
->location
,
14951 "use of %<auto%> in parameter declaration "
14952 "only available with "
14953 "-std=c++14 or -std=gnu++14");
14955 pedwarn (token
->location
, OPT_Wpedantic
,
14956 "ISO C++ forbids use of %<auto%> in parameter "
14960 type
= make_auto ();
14964 /* Since DR 743, decltype can either be a simple-type-specifier by
14965 itself or begin a nested-name-specifier. Parsing it will replace
14966 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
14967 handling below decide what to do. */
14968 cp_parser_decltype (parser
);
14969 cp_lexer_set_token_position (parser
->lexer
, token
);
14973 /* Consume the `typeof' token. */
14974 cp_lexer_consume_token (parser
->lexer
);
14975 /* Parse the operand to `typeof'. */
14976 type
= cp_parser_sizeof_operand (parser
, RID_TYPEOF
);
14977 /* If it is not already a TYPE, take its type. */
14978 if (!TYPE_P (type
))
14979 type
= finish_typeof (type
);
14982 cp_parser_set_decl_spec_type (decl_specs
, type
,
14984 /*type_definition_p=*/false);
14988 case RID_UNDERLYING_TYPE
:
14989 type
= cp_parser_trait_expr (parser
, RID_UNDERLYING_TYPE
);
14991 cp_parser_set_decl_spec_type (decl_specs
, type
,
14993 /*type_definition_p=*/false);
14998 case RID_DIRECT_BASES
:
14999 type
= cp_parser_trait_expr (parser
, token
->keyword
);
15001 cp_parser_set_decl_spec_type (decl_specs
, type
,
15003 /*type_definition_p=*/false);
15009 /* If token is an already-parsed decltype not followed by ::,
15010 it's a simple-type-specifier. */
15011 if (token
->type
== CPP_DECLTYPE
15012 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
!= CPP_SCOPE
)
15014 type
= token
->u
.value
;
15017 cp_parser_set_decl_spec_type (decl_specs
, type
,
15019 /*type_definition_p=*/false);
15020 /* Remember that we are handling a decltype in order to
15021 implement the resolution of DR 1510 when the argument
15022 isn't instantiation dependent. */
15023 decl_specs
->decltype_p
= true;
15025 cp_lexer_consume_token (parser
->lexer
);
15029 /* If the type-specifier was for a built-in type, we're done. */
15032 /* Record the type. */
15034 && (token
->keyword
!= RID_SIGNED
15035 && token
->keyword
!= RID_UNSIGNED
15036 && token
->keyword
!= RID_SHORT
15037 && token
->keyword
!= RID_LONG
))
15038 cp_parser_set_decl_spec_type (decl_specs
,
15041 /*type_definition_p=*/false);
15043 decl_specs
->any_specifiers_p
= true;
15045 /* Consume the token. */
15046 cp_lexer_consume_token (parser
->lexer
);
15048 if (type
== error_mark_node
)
15049 return error_mark_node
;
15051 /* There is no valid C++ program where a non-template type is
15052 followed by a "<". That usually indicates that the user thought
15053 that the type was a template. */
15054 cp_parser_check_for_invalid_template_id (parser
, type
, none_type
,
15057 return TYPE_NAME (type
);
15060 /* The type-specifier must be a user-defined type. */
15061 if (!(flags
& CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
))
15066 /* Don't gobble tokens or issue error messages if this is an
15067 optional type-specifier. */
15068 if (flags
& CP_PARSER_FLAGS_OPTIONAL
)
15069 cp_parser_parse_tentatively (parser
);
15071 /* Look for the optional `::' operator. */
15073 = (cp_parser_global_scope_opt (parser
,
15074 /*current_scope_valid_p=*/false)
15076 /* Look for the nested-name specifier. */
15078 = (cp_parser_nested_name_specifier_opt (parser
,
15079 /*typename_keyword_p=*/false,
15080 /*check_dependency_p=*/true,
15082 /*is_declaration=*/false)
15084 token
= cp_lexer_peek_token (parser
->lexer
);
15085 /* If we have seen a nested-name-specifier, and the next token
15086 is `template', then we are using the template-id production. */
15088 && cp_parser_optional_template_keyword (parser
))
15090 /* Look for the template-id. */
15091 type
= cp_parser_template_id (parser
,
15092 /*template_keyword_p=*/true,
15093 /*check_dependency_p=*/true,
15095 /*is_declaration=*/false);
15096 /* If the template-id did not name a type, we are out of
15098 if (TREE_CODE (type
) != TYPE_DECL
)
15100 cp_parser_error (parser
, "expected template-id for type");
15104 /* Otherwise, look for a type-name. */
15106 type
= cp_parser_type_name (parser
);
15107 /* Keep track of all name-lookups performed in class scopes. */
15111 && TREE_CODE (type
) == TYPE_DECL
15112 && identifier_p (DECL_NAME (type
)))
15113 maybe_note_name_used_in_class (DECL_NAME (type
), type
);
15114 /* If it didn't work out, we don't have a TYPE. */
15115 if ((flags
& CP_PARSER_FLAGS_OPTIONAL
)
15116 && !cp_parser_parse_definitely (parser
))
15118 if (type
&& decl_specs
)
15119 cp_parser_set_decl_spec_type (decl_specs
, type
,
15121 /*type_definition_p=*/false);
15124 /* If we didn't get a type-name, issue an error message. */
15125 if (!type
&& !(flags
& CP_PARSER_FLAGS_OPTIONAL
))
15127 cp_parser_error (parser
, "expected type-name");
15128 return error_mark_node
;
15131 if (type
&& type
!= error_mark_node
)
15133 /* See if TYPE is an Objective-C type, and if so, parse and
15134 accept any protocol references following it. Do this before
15135 the cp_parser_check_for_invalid_template_id() call, because
15136 Objective-C types can be followed by '<...>' which would
15137 enclose protocol names rather than template arguments, and so
15138 everything is fine. */
15139 if (c_dialect_objc () && !parser
->scope
15140 && (objc_is_id (type
) || objc_is_class_name (type
)))
15142 tree protos
= cp_parser_objc_protocol_refs_opt (parser
);
15143 tree qual_type
= objc_get_protocol_qualified_type (type
, protos
);
15145 /* Clobber the "unqualified" type previously entered into
15146 DECL_SPECS with the new, improved protocol-qualified version. */
15148 decl_specs
->type
= qual_type
;
15153 /* There is no valid C++ program where a non-template type is
15154 followed by a "<". That usually indicates that the user
15155 thought that the type was a template. */
15156 cp_parser_check_for_invalid_template_id (parser
, TREE_TYPE (type
),
15164 /* Parse a type-name.
15170 simple-template-id [in c++0x]
15178 Returns a TYPE_DECL for the type. */
15181 cp_parser_type_name (cp_parser
* parser
)
15185 /* We can't know yet whether it is a class-name or not. */
15186 cp_parser_parse_tentatively (parser
);
15187 /* Try a class-name. */
15188 type_decl
= cp_parser_class_name (parser
,
15189 /*typename_keyword_p=*/false,
15190 /*template_keyword_p=*/false,
15192 /*check_dependency_p=*/true,
15193 /*class_head_p=*/false,
15194 /*is_declaration=*/false);
15195 /* If it's not a class-name, keep looking. */
15196 if (!cp_parser_parse_definitely (parser
))
15198 if (cxx_dialect
< cxx11
)
15199 /* It must be a typedef-name or an enum-name. */
15200 return cp_parser_nonclass_name (parser
);
15202 cp_parser_parse_tentatively (parser
);
15203 /* It is either a simple-template-id representing an
15204 instantiation of an alias template... */
15205 type_decl
= cp_parser_template_id (parser
,
15206 /*template_keyword_p=*/false,
15207 /*check_dependency_p=*/true,
15209 /*is_declaration=*/false);
15210 /* Note that this must be an instantiation of an alias template
15211 because [temp.names]/6 says:
15213 A template-id that names an alias template specialization
15216 Whereas [temp.names]/7 says:
15218 A simple-template-id that names a class template
15219 specialization is a class-name. */
15220 if (type_decl
!= NULL_TREE
15221 && TREE_CODE (type_decl
) == TYPE_DECL
15222 && TYPE_DECL_ALIAS_P (type_decl
))
15223 gcc_assert (DECL_TEMPLATE_INSTANTIATION (type_decl
));
15225 cp_parser_simulate_error (parser
);
15227 if (!cp_parser_parse_definitely (parser
))
15228 /* ... Or a typedef-name or an enum-name. */
15229 return cp_parser_nonclass_name (parser
);
15235 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
15243 Returns a TYPE_DECL for the type. */
15246 cp_parser_nonclass_name (cp_parser
* parser
)
15251 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
15252 identifier
= cp_parser_identifier (parser
);
15253 if (identifier
== error_mark_node
)
15254 return error_mark_node
;
15256 /* Look up the type-name. */
15257 type_decl
= cp_parser_lookup_name_simple (parser
, identifier
, token
->location
);
15259 type_decl
= strip_using_decl (type_decl
);
15261 if (TREE_CODE (type_decl
) != TYPE_DECL
15262 && (objc_is_id (identifier
) || objc_is_class_name (identifier
)))
15264 /* See if this is an Objective-C type. */
15265 tree protos
= cp_parser_objc_protocol_refs_opt (parser
);
15266 tree type
= objc_get_protocol_qualified_type (identifier
, protos
);
15268 type_decl
= TYPE_NAME (type
);
15271 /* Issue an error if we did not find a type-name. */
15272 if (TREE_CODE (type_decl
) != TYPE_DECL
15273 /* In Objective-C, we have the complication that class names are
15274 normally type names and start declarations (eg, the
15275 "NSObject" in "NSObject *object;"), but can be used in an
15276 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
15277 is an expression. So, a classname followed by a dot is not a
15278 valid type-name. */
15279 || (objc_is_class_name (TREE_TYPE (type_decl
))
15280 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_DOT
))
15282 if (!cp_parser_simulate_error (parser
))
15283 cp_parser_name_lookup_error (parser
, identifier
, type_decl
,
15284 NLE_TYPE
, token
->location
);
15285 return error_mark_node
;
15287 /* Remember that the name was used in the definition of the
15288 current class so that we can check later to see if the
15289 meaning would have been different after the class was
15290 entirely defined. */
15291 else if (type_decl
!= error_mark_node
15293 maybe_note_name_used_in_class (identifier
, type_decl
);
15298 /* Parse an elaborated-type-specifier. Note that the grammar given
15299 here incorporates the resolution to DR68.
15301 elaborated-type-specifier:
15302 class-key :: [opt] nested-name-specifier [opt] identifier
15303 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
15304 enum-key :: [opt] nested-name-specifier [opt] identifier
15305 typename :: [opt] nested-name-specifier identifier
15306 typename :: [opt] nested-name-specifier template [opt]
15311 elaborated-type-specifier:
15312 class-key attributes :: [opt] nested-name-specifier [opt] identifier
15313 class-key attributes :: [opt] nested-name-specifier [opt]
15314 template [opt] template-id
15315 enum attributes :: [opt] nested-name-specifier [opt] identifier
15317 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
15318 declared `friend'. If IS_DECLARATION is TRUE, then this
15319 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
15320 something is being declared.
15322 Returns the TYPE specified. */
15325 cp_parser_elaborated_type_specifier (cp_parser
* parser
,
15327 bool is_declaration
)
15329 enum tag_types tag_type
;
15331 tree type
= NULL_TREE
;
15332 tree attributes
= NULL_TREE
;
15334 cp_token
*token
= NULL
;
15336 /* See if we're looking at the `enum' keyword. */
15337 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ENUM
))
15339 /* Consume the `enum' token. */
15340 cp_lexer_consume_token (parser
->lexer
);
15341 /* Remember that it's an enumeration type. */
15342 tag_type
= enum_type
;
15343 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
15344 enums) is used here. */
15345 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CLASS
)
15346 || cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STRUCT
))
15348 pedwarn (input_location
, 0, "elaborated-type-specifier "
15349 "for a scoped enum must not use the %<%D%> keyword",
15350 cp_lexer_peek_token (parser
->lexer
)->u
.value
);
15351 /* Consume the `struct' or `class' and parse it anyway. */
15352 cp_lexer_consume_token (parser
->lexer
);
15354 /* Parse the attributes. */
15355 attributes
= cp_parser_attributes_opt (parser
);
15357 /* Or, it might be `typename'. */
15358 else if (cp_lexer_next_token_is_keyword (parser
->lexer
,
15361 /* Consume the `typename' token. */
15362 cp_lexer_consume_token (parser
->lexer
);
15363 /* Remember that it's a `typename' type. */
15364 tag_type
= typename_type
;
15366 /* Otherwise it must be a class-key. */
15369 tag_type
= cp_parser_class_key (parser
);
15370 if (tag_type
== none_type
)
15371 return error_mark_node
;
15372 /* Parse the attributes. */
15373 attributes
= cp_parser_attributes_opt (parser
);
15376 /* Look for the `::' operator. */
15377 globalscope
= cp_parser_global_scope_opt (parser
,
15378 /*current_scope_valid_p=*/false);
15379 /* Look for the nested-name-specifier. */
15380 if (tag_type
== typename_type
&& !globalscope
)
15382 if (!cp_parser_nested_name_specifier (parser
,
15383 /*typename_keyword_p=*/true,
15384 /*check_dependency_p=*/true,
15387 return error_mark_node
;
15390 /* Even though `typename' is not present, the proposed resolution
15391 to Core Issue 180 says that in `class A<T>::B', `B' should be
15392 considered a type-name, even if `A<T>' is dependent. */
15393 cp_parser_nested_name_specifier_opt (parser
,
15394 /*typename_keyword_p=*/true,
15395 /*check_dependency_p=*/true,
15398 /* For everything but enumeration types, consider a template-id.
15399 For an enumeration type, consider only a plain identifier. */
15400 if (tag_type
!= enum_type
)
15402 bool template_p
= false;
15405 /* Allow the `template' keyword. */
15406 template_p
= cp_parser_optional_template_keyword (parser
);
15407 /* If we didn't see `template', we don't know if there's a
15408 template-id or not. */
15410 cp_parser_parse_tentatively (parser
);
15411 /* Parse the template-id. */
15412 token
= cp_lexer_peek_token (parser
->lexer
);
15413 decl
= cp_parser_template_id (parser
, template_p
,
15414 /*check_dependency_p=*/true,
15417 /* If we didn't find a template-id, look for an ordinary
15419 if (!template_p
&& !cp_parser_parse_definitely (parser
))
15421 /* We can get here when cp_parser_template_id, called by
15422 cp_parser_class_name with tag_type == none_type, succeeds
15423 and caches a BASELINK. Then, when called again here,
15424 instead of failing and returning an error_mark_node
15425 returns it (see template/typename17.C in C++11).
15426 ??? Could we diagnose this earlier? */
15427 else if (tag_type
== typename_type
&& BASELINK_P (decl
))
15429 cp_parser_diagnose_invalid_type_name (parser
, decl
, token
->location
);
15430 type
= error_mark_node
;
15432 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
15433 in effect, then we must assume that, upon instantiation, the
15434 template will correspond to a class. */
15435 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
15436 && tag_type
== typename_type
)
15437 type
= make_typename_type (parser
->scope
, decl
,
15439 /*complain=*/tf_error
);
15440 /* If the `typename' keyword is in effect and DECL is not a type
15441 decl, then type is non existent. */
15442 else if (tag_type
== typename_type
&& TREE_CODE (decl
) != TYPE_DECL
)
15444 else if (TREE_CODE (decl
) == TYPE_DECL
)
15445 type
= check_elaborated_type_specifier (tag_type
, decl
,
15446 /*allow_template_p=*/true);
15447 else if (decl
== error_mark_node
)
15448 type
= error_mark_node
;
15453 token
= cp_lexer_peek_token (parser
->lexer
);
15454 identifier
= cp_parser_identifier (parser
);
15456 if (identifier
== error_mark_node
)
15458 parser
->scope
= NULL_TREE
;
15459 return error_mark_node
;
15462 /* For a `typename', we needn't call xref_tag. */
15463 if (tag_type
== typename_type
15464 && TREE_CODE (parser
->scope
) != NAMESPACE_DECL
)
15465 return cp_parser_make_typename_type (parser
, identifier
,
15468 /* Template parameter lists apply only if we are not within a
15469 function parameter list. */
15470 bool template_parm_lists_apply
15471 = parser
->num_template_parameter_lists
;
15472 if (template_parm_lists_apply
)
15473 for (cp_binding_level
*s
= current_binding_level
;
15474 s
&& s
->kind
!= sk_template_parms
;
15475 s
= s
->level_chain
)
15476 if (s
->kind
== sk_function_parms
)
15477 template_parm_lists_apply
= false;
15479 /* Look up a qualified name in the usual way. */
15483 tree ambiguous_decls
;
15485 decl
= cp_parser_lookup_name (parser
, identifier
,
15487 /*is_template=*/false,
15488 /*is_namespace=*/false,
15489 /*check_dependency=*/true,
15493 /* If the lookup was ambiguous, an error will already have been
15495 if (ambiguous_decls
)
15496 return error_mark_node
;
15498 /* If we are parsing friend declaration, DECL may be a
15499 TEMPLATE_DECL tree node here. However, we need to check
15500 whether this TEMPLATE_DECL results in valid code. Consider
15501 the following example:
15504 template <class T> class C {};
15507 template <class T> friend class N::C; // #1, valid code
15509 template <class T> class Y {
15510 friend class N::C; // #2, invalid code
15513 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
15514 name lookup of `N::C'. We see that friend declaration must
15515 be template for the code to be valid. Note that
15516 processing_template_decl does not work here since it is
15517 always 1 for the above two cases. */
15519 decl
= (cp_parser_maybe_treat_template_as_class
15520 (decl
, /*tag_name_p=*/is_friend
15521 && template_parm_lists_apply
));
15523 if (TREE_CODE (decl
) != TYPE_DECL
)
15525 cp_parser_diagnose_invalid_type_name (parser
,
15528 return error_mark_node
;
15531 if (TREE_CODE (TREE_TYPE (decl
)) != TYPENAME_TYPE
)
15533 bool allow_template
= (template_parm_lists_apply
15534 || DECL_SELF_REFERENCE_P (decl
));
15535 type
= check_elaborated_type_specifier (tag_type
, decl
,
15538 if (type
== error_mark_node
)
15539 return error_mark_node
;
15542 /* Forward declarations of nested types, such as
15547 are invalid unless all components preceding the final '::'
15548 are complete. If all enclosing types are complete, these
15549 declarations become merely pointless.
15551 Invalid forward declarations of nested types are errors
15552 caught elsewhere in parsing. Those that are pointless arrive
15555 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
15556 && !is_friend
&& !processing_explicit_instantiation
)
15557 warning (0, "declaration %qD does not declare anything", decl
);
15559 type
= TREE_TYPE (decl
);
15563 /* An elaborated-type-specifier sometimes introduces a new type and
15564 sometimes names an existing type. Normally, the rule is that it
15565 introduces a new type only if there is not an existing type of
15566 the same name already in scope. For example, given:
15569 void f() { struct S s; }
15571 the `struct S' in the body of `f' is the same `struct S' as in
15572 the global scope; the existing definition is used. However, if
15573 there were no global declaration, this would introduce a new
15574 local class named `S'.
15576 An exception to this rule applies to the following code:
15578 namespace N { struct S; }
15580 Here, the elaborated-type-specifier names a new type
15581 unconditionally; even if there is already an `S' in the
15582 containing scope this declaration names a new type.
15583 This exception only applies if the elaborated-type-specifier
15584 forms the complete declaration:
15588 A declaration consisting solely of `class-key identifier ;' is
15589 either a redeclaration of the name in the current scope or a
15590 forward declaration of the identifier as a class name. It
15591 introduces the name into the current scope.
15593 We are in this situation precisely when the next token is a `;'.
15595 An exception to the exception is that a `friend' declaration does
15596 *not* name a new type; i.e., given:
15598 struct S { friend struct T; };
15600 `T' is not a new type in the scope of `S'.
15602 Also, `new struct S' or `sizeof (struct S)' never results in the
15603 definition of a new type; a new type can only be declared in a
15604 declaration context. */
15610 /* Friends have special name lookup rules. */
15611 ts
= ts_within_enclosing_non_class
;
15612 else if (is_declaration
15613 && cp_lexer_next_token_is (parser
->lexer
,
15615 /* This is a `class-key identifier ;' */
15621 (template_parm_lists_apply
15622 && (cp_parser_next_token_starts_class_definition_p (parser
)
15623 || cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)));
15624 /* An unqualified name was used to reference this type, so
15625 there were no qualifying templates. */
15626 if (template_parm_lists_apply
15627 && !cp_parser_check_template_parameters (parser
,
15628 /*num_templates=*/0,
15630 /*declarator=*/NULL
))
15631 return error_mark_node
;
15632 type
= xref_tag (tag_type
, identifier
, ts
, template_p
);
15636 if (type
== error_mark_node
)
15637 return error_mark_node
;
15639 /* Allow attributes on forward declarations of classes. */
15642 if (TREE_CODE (type
) == TYPENAME_TYPE
)
15643 warning (OPT_Wattributes
,
15644 "attributes ignored on uninstantiated type");
15645 else if (tag_type
!= enum_type
&& CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
15646 && ! processing_explicit_instantiation
)
15647 warning (OPT_Wattributes
,
15648 "attributes ignored on template instantiation");
15649 else if (is_declaration
&& cp_parser_declares_only_class_p (parser
))
15650 cplus_decl_attributes (&type
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
15652 warning (OPT_Wattributes
,
15653 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
15656 if (tag_type
!= enum_type
)
15658 /* Indicate whether this class was declared as a `class' or as a
15660 if (TREE_CODE (type
) == RECORD_TYPE
)
15661 CLASSTYPE_DECLARED_CLASS (type
) = (tag_type
== class_type
);
15662 cp_parser_check_class_key (tag_type
, type
);
15665 /* A "<" cannot follow an elaborated type specifier. If that
15666 happens, the user was probably trying to form a template-id. */
15667 cp_parser_check_for_invalid_template_id (parser
, type
, tag_type
,
15673 /* Parse an enum-specifier.
15676 enum-head { enumerator-list [opt] }
15677 enum-head { enumerator-list , } [C++0x]
15680 enum-key identifier [opt] enum-base [opt]
15681 enum-key nested-name-specifier identifier enum-base [opt]
15686 enum struct [C++0x]
15689 : type-specifier-seq
15691 opaque-enum-specifier:
15692 enum-key identifier enum-base [opt] ;
15695 enum-key attributes[opt] identifier [opt] enum-base [opt]
15696 { enumerator-list [opt] }attributes[opt]
15697 enum-key attributes[opt] identifier [opt] enum-base [opt]
15698 { enumerator-list, }attributes[opt] [C++0x]
15700 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
15701 if the token stream isn't an enum-specifier after all. */
15704 cp_parser_enum_specifier (cp_parser
* parser
)
15707 tree type
= NULL_TREE
;
15709 tree nested_name_specifier
= NULL_TREE
;
15711 bool scoped_enum_p
= false;
15712 bool has_underlying_type
= false;
15713 bool nested_being_defined
= false;
15714 bool new_value_list
= false;
15715 bool is_new_type
= false;
15716 bool is_anonymous
= false;
15717 tree underlying_type
= NULL_TREE
;
15718 cp_token
*type_start_token
= NULL
;
15719 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
15721 parser
->colon_corrects_to_scope_p
= false;
15723 /* Parse tentatively so that we can back up if we don't find a
15725 cp_parser_parse_tentatively (parser
);
15727 /* Caller guarantees that the current token is 'enum', an identifier
15728 possibly follows, and the token after that is an opening brace.
15729 If we don't have an identifier, fabricate an anonymous name for
15730 the enumeration being defined. */
15731 cp_lexer_consume_token (parser
->lexer
);
15733 /* Parse the "class" or "struct", which indicates a scoped
15734 enumeration type in C++0x. */
15735 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CLASS
)
15736 || cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STRUCT
))
15738 if (cxx_dialect
< cxx11
)
15739 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS
);
15741 /* Consume the `struct' or `class' token. */
15742 cp_lexer_consume_token (parser
->lexer
);
15744 scoped_enum_p
= true;
15747 attributes
= cp_parser_attributes_opt (parser
);
15749 /* Clear the qualification. */
15750 parser
->scope
= NULL_TREE
;
15751 parser
->qualifying_scope
= NULL_TREE
;
15752 parser
->object_scope
= NULL_TREE
;
15754 /* Figure out in what scope the declaration is being placed. */
15755 prev_scope
= current_scope ();
15757 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
15759 push_deferring_access_checks (dk_no_check
);
15760 nested_name_specifier
15761 = cp_parser_nested_name_specifier_opt (parser
,
15762 /*typename_keyword_p=*/true,
15763 /*check_dependency_p=*/false,
15765 /*is_declaration=*/false);
15767 if (nested_name_specifier
)
15771 identifier
= cp_parser_identifier (parser
);
15772 name
= cp_parser_lookup_name (parser
, identifier
,
15774 /*is_template=*/false,
15775 /*is_namespace=*/false,
15776 /*check_dependency=*/true,
15777 /*ambiguous_decls=*/NULL
,
15779 if (name
&& name
!= error_mark_node
)
15781 type
= TREE_TYPE (name
);
15782 if (TREE_CODE (type
) == TYPENAME_TYPE
)
15784 /* Are template enums allowed in ISO? */
15785 if (template_parm_scope_p ())
15786 pedwarn (type_start_token
->location
, OPT_Wpedantic
,
15787 "%qD is an enumeration template", name
);
15788 /* ignore a typename reference, for it will be solved by name
15793 else if (nested_name_specifier
== error_mark_node
)
15794 /* We already issued an error. */;
15796 error_at (type_start_token
->location
,
15797 "%qD is not an enumerator-name", identifier
);
15801 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
15802 identifier
= cp_parser_identifier (parser
);
15805 identifier
= make_anon_name ();
15806 is_anonymous
= true;
15808 error_at (type_start_token
->location
,
15809 "anonymous scoped enum is not allowed");
15812 pop_deferring_access_checks ();
15814 /* Check for the `:' that denotes a specified underlying type in C++0x.
15815 Note that a ':' could also indicate a bitfield width, however. */
15816 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
15818 cp_decl_specifier_seq type_specifiers
;
15820 /* Consume the `:'. */
15821 cp_lexer_consume_token (parser
->lexer
);
15823 /* Parse the type-specifier-seq. */
15824 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
15825 /*is_trailing_return=*/false,
15828 /* At this point this is surely not elaborated type specifier. */
15829 if (!cp_parser_parse_definitely (parser
))
15832 if (cxx_dialect
< cxx11
)
15833 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS
);
15835 has_underlying_type
= true;
15837 /* If that didn't work, stop. */
15838 if (type_specifiers
.type
!= error_mark_node
)
15840 underlying_type
= grokdeclarator (NULL
, &type_specifiers
, TYPENAME
,
15841 /*initialized=*/0, NULL
);
15842 if (underlying_type
== error_mark_node
15843 || check_for_bare_parameter_packs (underlying_type
))
15844 underlying_type
= NULL_TREE
;
15848 /* Look for the `{' but don't consume it yet. */
15849 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
15851 if (cxx_dialect
< cxx11
|| (!scoped_enum_p
&& !underlying_type
))
15853 cp_parser_error (parser
, "expected %<{%>");
15854 if (has_underlying_type
)
15860 /* An opaque-enum-specifier must have a ';' here. */
15861 if ((scoped_enum_p
|| underlying_type
)
15862 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
15864 cp_parser_error (parser
, "expected %<;%> or %<{%>");
15865 if (has_underlying_type
)
15873 if (!has_underlying_type
&& !cp_parser_parse_definitely (parser
))
15876 if (nested_name_specifier
)
15878 if (CLASS_TYPE_P (nested_name_specifier
))
15880 nested_being_defined
= TYPE_BEING_DEFINED (nested_name_specifier
);
15881 TYPE_BEING_DEFINED (nested_name_specifier
) = 1;
15882 push_scope (nested_name_specifier
);
15884 else if (TREE_CODE (nested_name_specifier
) == NAMESPACE_DECL
)
15886 push_nested_namespace (nested_name_specifier
);
15890 /* Issue an error message if type-definitions are forbidden here. */
15891 if (!cp_parser_check_type_definition (parser
))
15892 type
= error_mark_node
;
15894 /* Create the new type. We do this before consuming the opening
15895 brace so the enum will be recorded as being on the line of its
15896 tag (or the 'enum' keyword, if there is no tag). */
15897 type
= start_enum (identifier
, type
, underlying_type
,
15898 scoped_enum_p
, &is_new_type
);
15900 /* If the next token is not '{' it is an opaque-enum-specifier or an
15901 elaborated-type-specifier. */
15902 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
15904 timevar_push (TV_PARSE_ENUM
);
15905 if (nested_name_specifier
15906 && nested_name_specifier
!= error_mark_node
)
15908 /* The following catches invalid code such as:
15909 enum class S<int>::E { A, B, C }; */
15910 if (!processing_specialization
15911 && CLASS_TYPE_P (nested_name_specifier
)
15912 && CLASSTYPE_USE_TEMPLATE (nested_name_specifier
))
15913 error_at (type_start_token
->location
, "cannot add an enumerator "
15914 "list to a template instantiation");
15916 if (TREE_CODE (nested_name_specifier
) == TYPENAME_TYPE
)
15918 error_at (type_start_token
->location
,
15919 "%<%T::%E%> has not been declared",
15920 TYPE_CONTEXT (nested_name_specifier
),
15921 nested_name_specifier
);
15922 type
= error_mark_node
;
15924 /* If that scope does not contain the scope in which the
15925 class was originally declared, the program is invalid. */
15926 else if (prev_scope
&& !is_ancestor (prev_scope
,
15927 nested_name_specifier
))
15929 if (at_namespace_scope_p ())
15930 error_at (type_start_token
->location
,
15931 "declaration of %qD in namespace %qD which does not "
15933 type
, prev_scope
, nested_name_specifier
);
15935 error_at (type_start_token
->location
,
15936 "declaration of %qD in %qD which does not "
15938 type
, prev_scope
, nested_name_specifier
);
15939 type
= error_mark_node
;
15944 begin_scope (sk_scoped_enum
, type
);
15946 /* Consume the opening brace. */
15947 cp_lexer_consume_token (parser
->lexer
);
15949 if (type
== error_mark_node
)
15950 ; /* Nothing to add */
15951 else if (OPAQUE_ENUM_P (type
)
15952 || (cxx_dialect
> cxx98
&& processing_specialization
))
15954 new_value_list
= true;
15955 SET_OPAQUE_ENUM_P (type
, false);
15956 DECL_SOURCE_LOCATION (TYPE_NAME (type
)) = type_start_token
->location
;
15960 error_at (type_start_token
->location
,
15961 "multiple definition of %q#T", type
);
15962 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
15963 "previous definition here");
15964 type
= error_mark_node
;
15967 if (type
== error_mark_node
)
15968 cp_parser_skip_to_end_of_block_or_statement (parser
);
15969 /* If the next token is not '}', then there are some enumerators. */
15970 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
15972 if (is_anonymous
&& !scoped_enum_p
)
15973 pedwarn (type_start_token
->location
, OPT_Wpedantic
,
15974 "ISO C++ forbids empty anonymous enum");
15977 cp_parser_enumerator_list (parser
, type
);
15979 /* Consume the final '}'. */
15980 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
15984 timevar_pop (TV_PARSE_ENUM
);
15988 /* If a ';' follows, then it is an opaque-enum-specifier
15989 and additional restrictions apply. */
15990 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
15993 error_at (type_start_token
->location
,
15994 "opaque-enum-specifier without name");
15995 else if (nested_name_specifier
)
15996 error_at (type_start_token
->location
,
15997 "opaque-enum-specifier must use a simple identifier");
16001 /* Look for trailing attributes to apply to this enumeration, and
16002 apply them if appropriate. */
16003 if (cp_parser_allow_gnu_extensions_p (parser
))
16005 tree trailing_attr
= cp_parser_gnu_attributes_opt (parser
);
16006 trailing_attr
= chainon (trailing_attr
, attributes
);
16007 cplus_decl_attributes (&type
,
16009 (int) ATTR_FLAG_TYPE_IN_PLACE
);
16012 /* Finish up the enumeration. */
16013 if (type
!= error_mark_node
)
16015 if (new_value_list
)
16016 finish_enum_value_list (type
);
16018 finish_enum (type
);
16021 if (nested_name_specifier
)
16023 if (CLASS_TYPE_P (nested_name_specifier
))
16025 TYPE_BEING_DEFINED (nested_name_specifier
) = nested_being_defined
;
16026 pop_scope (nested_name_specifier
);
16028 else if (TREE_CODE (nested_name_specifier
) == NAMESPACE_DECL
)
16030 pop_nested_namespace (nested_name_specifier
);
16034 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
16038 /* Parse an enumerator-list. The enumerators all have the indicated
16042 enumerator-definition
16043 enumerator-list , enumerator-definition */
16046 cp_parser_enumerator_list (cp_parser
* parser
, tree type
)
16050 /* Parse an enumerator-definition. */
16051 cp_parser_enumerator_definition (parser
, type
);
16053 /* If the next token is not a ',', we've reached the end of
16055 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
16057 /* Otherwise, consume the `,' and keep going. */
16058 cp_lexer_consume_token (parser
->lexer
);
16059 /* If the next token is a `}', there is a trailing comma. */
16060 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
16062 if (cxx_dialect
< cxx11
&& !in_system_header_at (input_location
))
16063 pedwarn (input_location
, OPT_Wpedantic
,
16064 "comma at end of enumerator list");
16070 /* Parse an enumerator-definition. The enumerator has the indicated
16073 enumerator-definition:
16075 enumerator = constant-expression
16081 cp_parser_enumerator_definition (cp_parser
* parser
, tree type
)
16087 /* Save the input location because we are interested in the location
16088 of the identifier and not the location of the explicit value. */
16089 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
16091 /* Look for the identifier. */
16092 identifier
= cp_parser_identifier (parser
);
16093 if (identifier
== error_mark_node
)
16096 /* If the next token is an '=', then there is an explicit value. */
16097 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
16099 /* Consume the `=' token. */
16100 cp_lexer_consume_token (parser
->lexer
);
16101 /* Parse the value. */
16102 value
= cp_parser_constant_expression (parser
);
16107 /* If we are processing a template, make sure the initializer of the
16108 enumerator doesn't contain any bare template parameter pack. */
16109 if (check_for_bare_parameter_packs (value
))
16110 value
= error_mark_node
;
16112 /* Create the enumerator. */
16113 build_enumerator (identifier
, value
, type
, loc
);
16116 /* Parse a namespace-name.
16119 original-namespace-name
16122 Returns the NAMESPACE_DECL for the namespace. */
16125 cp_parser_namespace_name (cp_parser
* parser
)
16128 tree namespace_decl
;
16130 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
16132 /* Get the name of the namespace. */
16133 identifier
= cp_parser_identifier (parser
);
16134 if (identifier
== error_mark_node
)
16135 return error_mark_node
;
16137 /* Look up the identifier in the currently active scope. Look only
16138 for namespaces, due to:
16140 [basic.lookup.udir]
16142 When looking up a namespace-name in a using-directive or alias
16143 definition, only namespace names are considered.
16147 [basic.lookup.qual]
16149 During the lookup of a name preceding the :: scope resolution
16150 operator, object, function, and enumerator names are ignored.
16152 (Note that cp_parser_qualifying_entity only calls this
16153 function if the token after the name is the scope resolution
16155 namespace_decl
= cp_parser_lookup_name (parser
, identifier
,
16157 /*is_template=*/false,
16158 /*is_namespace=*/true,
16159 /*check_dependency=*/true,
16160 /*ambiguous_decls=*/NULL
,
16162 /* If it's not a namespace, issue an error. */
16163 if (namespace_decl
== error_mark_node
16164 || TREE_CODE (namespace_decl
) != NAMESPACE_DECL
)
16166 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
16167 error_at (token
->location
, "%qD is not a namespace-name", identifier
);
16168 cp_parser_error (parser
, "expected namespace-name");
16169 namespace_decl
= error_mark_node
;
16172 return namespace_decl
;
16175 /* Parse a namespace-definition.
16177 namespace-definition:
16178 named-namespace-definition
16179 unnamed-namespace-definition
16181 named-namespace-definition:
16182 original-namespace-definition
16183 extension-namespace-definition
16185 original-namespace-definition:
16186 namespace identifier { namespace-body }
16188 extension-namespace-definition:
16189 namespace original-namespace-name { namespace-body }
16191 unnamed-namespace-definition:
16192 namespace { namespace-body } */
16195 cp_parser_namespace_definition (cp_parser
* parser
)
16197 tree identifier
, attribs
;
16198 bool has_visibility
;
16201 cp_ensure_no_omp_declare_simd (parser
);
16202 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_INLINE
))
16204 maybe_warn_cpp0x (CPP0X_INLINE_NAMESPACES
);
16206 cp_lexer_consume_token (parser
->lexer
);
16211 /* Look for the `namespace' keyword. */
16212 cp_parser_require_keyword (parser
, RID_NAMESPACE
, RT_NAMESPACE
);
16214 /* Get the name of the namespace. We do not attempt to distinguish
16215 between an original-namespace-definition and an
16216 extension-namespace-definition at this point. The semantic
16217 analysis routines are responsible for that. */
16218 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
16219 identifier
= cp_parser_identifier (parser
);
16221 identifier
= NULL_TREE
;
16223 /* Parse any specified attributes. */
16224 attribs
= cp_parser_attributes_opt (parser
);
16226 /* Look for the `{' to start the namespace. */
16227 cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
);
16228 /* Start the namespace. */
16229 push_namespace (identifier
);
16231 /* "inline namespace" is equivalent to a stub namespace definition
16232 followed by a strong using directive. */
16235 tree name_space
= current_namespace
;
16236 NAMESPACE_IS_INLINE (name_space
) = true;
16237 /* Set up namespace association. */
16238 DECL_NAMESPACE_ASSOCIATIONS (name_space
)
16239 = tree_cons (CP_DECL_CONTEXT (name_space
), NULL_TREE
,
16240 DECL_NAMESPACE_ASSOCIATIONS (name_space
));
16241 /* Import the contents of the inline namespace. */
16243 do_using_directive (name_space
);
16244 push_namespace (identifier
);
16247 has_visibility
= handle_namespace_attrs (current_namespace
, attribs
);
16249 /* Parse the body of the namespace. */
16250 cp_parser_namespace_body (parser
);
16252 if (has_visibility
)
16253 pop_visibility (1);
16255 /* Finish the namespace. */
16257 /* Look for the final `}'. */
16258 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
16261 /* Parse a namespace-body.
16264 declaration-seq [opt] */
16267 cp_parser_namespace_body (cp_parser
* parser
)
16269 cp_parser_declaration_seq_opt (parser
);
16272 /* Parse a namespace-alias-definition.
16274 namespace-alias-definition:
16275 namespace identifier = qualified-namespace-specifier ; */
16278 cp_parser_namespace_alias_definition (cp_parser
* parser
)
16281 tree namespace_specifier
;
16283 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
16285 /* Look for the `namespace' keyword. */
16286 cp_parser_require_keyword (parser
, RID_NAMESPACE
, RT_NAMESPACE
);
16287 /* Look for the identifier. */
16288 identifier
= cp_parser_identifier (parser
);
16289 if (identifier
== error_mark_node
)
16291 /* Look for the `=' token. */
16292 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
)
16293 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
16295 error_at (token
->location
, "%<namespace%> definition is not allowed here");
16296 /* Skip the definition. */
16297 cp_lexer_consume_token (parser
->lexer
);
16298 if (cp_parser_skip_to_closing_brace (parser
))
16299 cp_lexer_consume_token (parser
->lexer
);
16302 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
16303 /* Look for the qualified-namespace-specifier. */
16304 namespace_specifier
16305 = cp_parser_qualified_namespace_specifier (parser
);
16306 /* Look for the `;' token. */
16307 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16309 /* Register the alias in the symbol table. */
16310 do_namespace_alias (identifier
, namespace_specifier
);
16313 /* Parse a qualified-namespace-specifier.
16315 qualified-namespace-specifier:
16316 :: [opt] nested-name-specifier [opt] namespace-name
16318 Returns a NAMESPACE_DECL corresponding to the specified
16322 cp_parser_qualified_namespace_specifier (cp_parser
* parser
)
16324 /* Look for the optional `::'. */
16325 cp_parser_global_scope_opt (parser
,
16326 /*current_scope_valid_p=*/false);
16328 /* Look for the optional nested-name-specifier. */
16329 cp_parser_nested_name_specifier_opt (parser
,
16330 /*typename_keyword_p=*/false,
16331 /*check_dependency_p=*/true,
16333 /*is_declaration=*/true);
16335 return cp_parser_namespace_name (parser
);
16338 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
16339 access declaration.
16342 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
16343 using :: unqualified-id ;
16345 access-declaration:
16351 cp_parser_using_declaration (cp_parser
* parser
,
16352 bool access_declaration_p
)
16355 bool typename_p
= false;
16356 bool global_scope_p
;
16360 int oldcount
= errorcount
;
16361 cp_token
*diag_token
= NULL
;
16363 if (access_declaration_p
)
16365 diag_token
= cp_lexer_peek_token (parser
->lexer
);
16366 cp_parser_parse_tentatively (parser
);
16370 /* Look for the `using' keyword. */
16371 cp_parser_require_keyword (parser
, RID_USING
, RT_USING
);
16373 /* Peek at the next token. */
16374 token
= cp_lexer_peek_token (parser
->lexer
);
16375 /* See if it's `typename'. */
16376 if (token
->keyword
== RID_TYPENAME
)
16378 /* Remember that we've seen it. */
16380 /* Consume the `typename' token. */
16381 cp_lexer_consume_token (parser
->lexer
);
16385 /* Look for the optional global scope qualification. */
16387 = (cp_parser_global_scope_opt (parser
,
16388 /*current_scope_valid_p=*/false)
16391 /* If we saw `typename', or didn't see `::', then there must be a
16392 nested-name-specifier present. */
16393 if (typename_p
|| !global_scope_p
)
16395 qscope
= cp_parser_nested_name_specifier (parser
, typename_p
,
16396 /*check_dependency_p=*/true,
16398 /*is_declaration=*/true);
16399 if (!qscope
&& !cp_parser_uncommitted_to_tentative_parse_p (parser
))
16401 cp_parser_skip_to_end_of_block_or_statement (parser
);
16405 /* Otherwise, we could be in either of the two productions. In that
16406 case, treat the nested-name-specifier as optional. */
16408 qscope
= cp_parser_nested_name_specifier_opt (parser
,
16409 /*typename_keyword_p=*/false,
16410 /*check_dependency_p=*/true,
16412 /*is_declaration=*/true);
16414 qscope
= global_namespace
;
16415 else if (UNSCOPED_ENUM_P (qscope
))
16416 qscope
= CP_TYPE_CONTEXT (qscope
);
16418 if (access_declaration_p
&& cp_parser_error_occurred (parser
))
16419 /* Something has already gone wrong; there's no need to parse
16420 further. Since an error has occurred, the return value of
16421 cp_parser_parse_definitely will be false, as required. */
16422 return cp_parser_parse_definitely (parser
);
16424 token
= cp_lexer_peek_token (parser
->lexer
);
16425 /* Parse the unqualified-id. */
16426 identifier
= cp_parser_unqualified_id (parser
,
16427 /*template_keyword_p=*/false,
16428 /*check_dependency_p=*/true,
16429 /*declarator_p=*/true,
16430 /*optional_p=*/false);
16432 if (access_declaration_p
)
16434 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
16435 cp_parser_simulate_error (parser
);
16436 if (!cp_parser_parse_definitely (parser
))
16440 /* The function we call to handle a using-declaration is different
16441 depending on what scope we are in. */
16442 if (qscope
== error_mark_node
|| identifier
== error_mark_node
)
16444 else if (!identifier_p (identifier
)
16445 && TREE_CODE (identifier
) != BIT_NOT_EXPR
)
16446 /* [namespace.udecl]
16448 A using declaration shall not name a template-id. */
16449 error_at (token
->location
,
16450 "a template-id may not appear in a using-declaration");
16453 if (at_class_scope_p ())
16455 /* Create the USING_DECL. */
16456 decl
= do_class_using_decl (parser
->scope
, identifier
);
16458 if (decl
&& typename_p
)
16459 USING_DECL_TYPENAME_P (decl
) = 1;
16461 if (check_for_bare_parameter_packs (decl
))
16463 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16467 /* Add it to the list of members in this class. */
16468 finish_member_declaration (decl
);
16472 decl
= cp_parser_lookup_name_simple (parser
,
16475 if (decl
== error_mark_node
)
16476 cp_parser_name_lookup_error (parser
, identifier
,
16479 else if (check_for_bare_parameter_packs (decl
))
16481 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16484 else if (!at_namespace_scope_p ())
16485 do_local_using_decl (decl
, qscope
, identifier
);
16487 do_toplevel_using_decl (decl
, qscope
, identifier
);
16491 /* Look for the final `;'. */
16492 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16494 if (access_declaration_p
&& errorcount
== oldcount
)
16495 warning_at (diag_token
->location
, OPT_Wdeprecated
,
16496 "access declarations are deprecated "
16497 "in favour of using-declarations; "
16498 "suggestion: add the %<using%> keyword");
16503 /* Parse an alias-declaration.
16506 using identifier attribute-specifier-seq [opt] = type-id */
16509 cp_parser_alias_declaration (cp_parser
* parser
)
16511 tree id
, type
, decl
, pushed_scope
= NULL_TREE
, attributes
;
16512 location_t id_location
;
16513 cp_declarator
*declarator
;
16514 cp_decl_specifier_seq decl_specs
;
16516 const char *saved_message
= NULL
;
16518 /* Look for the `using' keyword. */
16519 cp_token
*using_token
16520 = cp_parser_require_keyword (parser
, RID_USING
, RT_USING
);
16521 if (using_token
== NULL
)
16522 return error_mark_node
;
16524 id_location
= cp_lexer_peek_token (parser
->lexer
)->location
;
16525 id
= cp_parser_identifier (parser
);
16526 if (id
== error_mark_node
)
16527 return error_mark_node
;
16529 cp_token
*attrs_token
= cp_lexer_peek_token (parser
->lexer
);
16530 attributes
= cp_parser_attributes_opt (parser
);
16531 if (attributes
== error_mark_node
)
16532 return error_mark_node
;
16534 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
16536 if (cp_parser_error_occurred (parser
))
16537 return error_mark_node
;
16539 cp_parser_commit_to_tentative_parse (parser
);
16541 /* Now we are going to parse the type-id of the declaration. */
16546 "A type-specifier-seq shall not define a class or enumeration
16547 unless it appears in the type-id of an alias-declaration (7.1.3) that
16548 is not the declaration of a template-declaration."
16550 In other words, if we currently are in an alias template, the
16551 type-id should not define a type.
16553 So let's set parser->type_definition_forbidden_message in that
16554 case; cp_parser_check_type_definition (called by
16555 cp_parser_class_specifier) will then emit an error if a type is
16556 defined in the type-id. */
16557 if (parser
->num_template_parameter_lists
)
16559 saved_message
= parser
->type_definition_forbidden_message
;
16560 parser
->type_definition_forbidden_message
=
16561 G_("types may not be defined in alias template declarations");
16564 type
= cp_parser_type_id (parser
);
16566 /* Restore the error message if need be. */
16567 if (parser
->num_template_parameter_lists
)
16568 parser
->type_definition_forbidden_message
= saved_message
;
16570 if (type
== error_mark_node
16571 || !cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
))
16573 cp_parser_skip_to_end_of_block_or_statement (parser
);
16574 return error_mark_node
;
16577 /* A typedef-name can also be introduced by an alias-declaration. The
16578 identifier following the using keyword becomes a typedef-name. It has
16579 the same semantics as if it were introduced by the typedef
16580 specifier. In particular, it does not define a new type and it shall
16581 not appear in the type-id. */
16583 clear_decl_specs (&decl_specs
);
16584 decl_specs
.type
= type
;
16585 if (attributes
!= NULL_TREE
)
16587 decl_specs
.attributes
= attributes
;
16588 set_and_check_decl_spec_loc (&decl_specs
,
16592 set_and_check_decl_spec_loc (&decl_specs
,
16595 set_and_check_decl_spec_loc (&decl_specs
,
16599 declarator
= make_id_declarator (NULL_TREE
, id
, sfk_none
);
16600 declarator
->id_loc
= id_location
;
16602 member_p
= at_class_scope_p ();
16604 decl
= grokfield (declarator
, &decl_specs
, NULL_TREE
, false,
16605 NULL_TREE
, attributes
);
16607 decl
= start_decl (declarator
, &decl_specs
, 0,
16608 attributes
, NULL_TREE
, &pushed_scope
);
16609 if (decl
== error_mark_node
)
16612 cp_finish_decl (decl
, NULL_TREE
, 0, NULL_TREE
, 0);
16615 pop_scope (pushed_scope
);
16617 /* If decl is a template, return its TEMPLATE_DECL so that it gets
16618 added into the symbol table; otherwise, return the TYPE_DECL. */
16619 if (DECL_LANG_SPECIFIC (decl
)
16620 && DECL_TEMPLATE_INFO (decl
)
16621 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
16623 decl
= DECL_TI_TEMPLATE (decl
);
16625 check_member_template (decl
);
16631 /* Parse a using-directive.
16634 using namespace :: [opt] nested-name-specifier [opt]
16635 namespace-name ; */
16638 cp_parser_using_directive (cp_parser
* parser
)
16640 tree namespace_decl
;
16643 /* Look for the `using' keyword. */
16644 cp_parser_require_keyword (parser
, RID_USING
, RT_USING
);
16645 /* And the `namespace' keyword. */
16646 cp_parser_require_keyword (parser
, RID_NAMESPACE
, RT_NAMESPACE
);
16647 /* Look for the optional `::' operator. */
16648 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false);
16649 /* And the optional nested-name-specifier. */
16650 cp_parser_nested_name_specifier_opt (parser
,
16651 /*typename_keyword_p=*/false,
16652 /*check_dependency_p=*/true,
16654 /*is_declaration=*/true);
16655 /* Get the namespace being used. */
16656 namespace_decl
= cp_parser_namespace_name (parser
);
16657 /* And any specified attributes. */
16658 attribs
= cp_parser_attributes_opt (parser
);
16659 /* Update the symbol table. */
16660 parse_using_directive (namespace_decl
, attribs
);
16661 /* Look for the final `;'. */
16662 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16665 /* Parse an asm-definition.
16668 asm ( string-literal ) ;
16673 asm volatile [opt] ( string-literal ) ;
16674 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
16675 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16676 : asm-operand-list [opt] ) ;
16677 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16678 : asm-operand-list [opt]
16679 : asm-clobber-list [opt] ) ;
16680 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
16681 : asm-clobber-list [opt]
16682 : asm-goto-list ) ; */
16685 cp_parser_asm_definition (cp_parser
* parser
)
16688 tree outputs
= NULL_TREE
;
16689 tree inputs
= NULL_TREE
;
16690 tree clobbers
= NULL_TREE
;
16691 tree labels
= NULL_TREE
;
16693 bool volatile_p
= false;
16694 bool extended_p
= false;
16695 bool invalid_inputs_p
= false;
16696 bool invalid_outputs_p
= false;
16697 bool goto_p
= false;
16698 required_token missing
= RT_NONE
;
16700 /* Look for the `asm' keyword. */
16701 cp_parser_require_keyword (parser
, RID_ASM
, RT_ASM
);
16703 if (parser
->in_function_body
16704 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
16706 error ("%<asm%> in %<constexpr%> function");
16707 cp_function_chain
->invalid_constexpr
= true;
16710 /* See if the next token is `volatile'. */
16711 if (cp_parser_allow_gnu_extensions_p (parser
)
16712 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_VOLATILE
))
16714 /* Remember that we saw the `volatile' keyword. */
16716 /* Consume the token. */
16717 cp_lexer_consume_token (parser
->lexer
);
16719 if (cp_parser_allow_gnu_extensions_p (parser
)
16720 && parser
->in_function_body
16721 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_GOTO
))
16723 /* Remember that we saw the `goto' keyword. */
16725 /* Consume the token. */
16726 cp_lexer_consume_token (parser
->lexer
);
16728 /* Look for the opening `('. */
16729 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
16731 /* Look for the string. */
16732 string
= cp_parser_string_literal (parser
, false, false);
16733 if (string
== error_mark_node
)
16735 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
16736 /*consume_paren=*/true);
16740 /* If we're allowing GNU extensions, check for the extended assembly
16741 syntax. Unfortunately, the `:' tokens need not be separated by
16742 a space in C, and so, for compatibility, we tolerate that here
16743 too. Doing that means that we have to treat the `::' operator as
16745 if (cp_parser_allow_gnu_extensions_p (parser
)
16746 && parser
->in_function_body
16747 && (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
)
16748 || cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
)))
16750 bool inputs_p
= false;
16751 bool clobbers_p
= false;
16752 bool labels_p
= false;
16754 /* The extended syntax was used. */
16757 /* Look for outputs. */
16758 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
16760 /* Consume the `:'. */
16761 cp_lexer_consume_token (parser
->lexer
);
16762 /* Parse the output-operands. */
16763 if (cp_lexer_next_token_is_not (parser
->lexer
,
16765 && cp_lexer_next_token_is_not (parser
->lexer
,
16767 && cp_lexer_next_token_is_not (parser
->lexer
,
16770 outputs
= cp_parser_asm_operand_list (parser
);
16772 if (outputs
== error_mark_node
)
16773 invalid_outputs_p
= true;
16775 /* If the next token is `::', there are no outputs, and the
16776 next token is the beginning of the inputs. */
16777 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
16778 /* The inputs are coming next. */
16781 /* Look for inputs. */
16783 || cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
16785 /* Consume the `:' or `::'. */
16786 cp_lexer_consume_token (parser
->lexer
);
16787 /* Parse the output-operands. */
16788 if (cp_lexer_next_token_is_not (parser
->lexer
,
16790 && cp_lexer_next_token_is_not (parser
->lexer
,
16792 && cp_lexer_next_token_is_not (parser
->lexer
,
16794 inputs
= cp_parser_asm_operand_list (parser
);
16796 if (inputs
== error_mark_node
)
16797 invalid_inputs_p
= true;
16799 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
16800 /* The clobbers are coming next. */
16803 /* Look for clobbers. */
16805 || cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
16808 /* Consume the `:' or `::'. */
16809 cp_lexer_consume_token (parser
->lexer
);
16810 /* Parse the clobbers. */
16811 if (cp_lexer_next_token_is_not (parser
->lexer
,
16813 && cp_lexer_next_token_is_not (parser
->lexer
,
16815 clobbers
= cp_parser_asm_clobber_list (parser
);
16818 && cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
16819 /* The labels are coming next. */
16822 /* Look for labels. */
16824 || (goto_p
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
)))
16827 /* Consume the `:' or `::'. */
16828 cp_lexer_consume_token (parser
->lexer
);
16829 /* Parse the labels. */
16830 labels
= cp_parser_asm_label_list (parser
);
16833 if (goto_p
&& !labels_p
)
16834 missing
= clobbers_p
? RT_COLON
: RT_COLON_SCOPE
;
16837 missing
= RT_COLON_SCOPE
;
16839 /* Look for the closing `)'. */
16840 if (!cp_parser_require (parser
, missing
? CPP_COLON
: CPP_CLOSE_PAREN
,
16841 missing
? missing
: RT_CLOSE_PAREN
))
16842 cp_parser_skip_to_closing_parenthesis (parser
, true, false,
16843 /*consume_paren=*/true);
16844 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
16846 if (!invalid_inputs_p
&& !invalid_outputs_p
)
16848 /* Create the ASM_EXPR. */
16849 if (parser
->in_function_body
)
16851 asm_stmt
= finish_asm_stmt (volatile_p
, string
, outputs
,
16852 inputs
, clobbers
, labels
);
16853 /* If the extended syntax was not used, mark the ASM_EXPR. */
16856 tree temp
= asm_stmt
;
16857 if (TREE_CODE (temp
) == CLEANUP_POINT_EXPR
)
16858 temp
= TREE_OPERAND (temp
, 0);
16860 ASM_INPUT_P (temp
) = 1;
16864 symtab
->finalize_toplevel_asm (string
);
16868 /* Declarators [gram.dcl.decl] */
16870 /* Parse an init-declarator.
16873 declarator initializer [opt]
16878 declarator asm-specification [opt] attributes [opt] initializer [opt]
16880 function-definition:
16881 decl-specifier-seq [opt] declarator ctor-initializer [opt]
16883 decl-specifier-seq [opt] declarator function-try-block
16887 function-definition:
16888 __extension__ function-definition
16892 function-definition:
16893 decl-specifier-seq [opt] declarator function-transaction-block
16895 The DECL_SPECIFIERS apply to this declarator. Returns a
16896 representation of the entity declared. If MEMBER_P is TRUE, then
16897 this declarator appears in a class scope. The new DECL created by
16898 this declarator is returned.
16900 The CHECKS are access checks that should be performed once we know
16901 what entity is being declared (and, therefore, what classes have
16904 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
16905 for a function-definition here as well. If the declarator is a
16906 declarator for a function-definition, *FUNCTION_DEFINITION_P will
16907 be TRUE upon return. By that point, the function-definition will
16908 have been completely parsed.
16910 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
16913 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
16914 parsed declaration if it is an uninitialized single declarator not followed
16915 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
16916 if present, will not be consumed. If returned, this declarator will be
16917 created with SD_INITIALIZED but will not call cp_finish_decl.
16919 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
16920 and there is an initializer, the pointed location_t is set to the
16921 location of the '=' or `(', or '{' in C++11 token introducing the
16925 cp_parser_init_declarator (cp_parser
* parser
,
16926 cp_decl_specifier_seq
*decl_specifiers
,
16927 vec
<deferred_access_check
, va_gc
> *checks
,
16928 bool function_definition_allowed_p
,
16930 int declares_class_or_enum
,
16931 bool* function_definition_p
,
16932 tree
* maybe_range_for_decl
,
16933 location_t
* init_loc
)
16935 cp_token
*token
= NULL
, *asm_spec_start_token
= NULL
,
16936 *attributes_start_token
= NULL
;
16937 cp_declarator
*declarator
;
16938 tree prefix_attributes
;
16939 tree attributes
= NULL
;
16940 tree asm_specification
;
16942 tree decl
= NULL_TREE
;
16944 int is_initialized
;
16945 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
16946 initialized with "= ..", CPP_OPEN_PAREN if initialized with
16948 enum cpp_ttype initialization_kind
;
16949 bool is_direct_init
= false;
16950 bool is_non_constant_init
;
16951 int ctor_dtor_or_conv_p
;
16952 bool friend_p
= cp_parser_friend_p (decl_specifiers
);
16953 tree pushed_scope
= NULL_TREE
;
16954 bool range_for_decl_p
= false;
16955 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
16956 location_t tmp_init_loc
= UNKNOWN_LOCATION
;
16958 /* Gather the attributes that were provided with the
16959 decl-specifiers. */
16960 prefix_attributes
= decl_specifiers
->attributes
;
16962 /* Assume that this is not the declarator for a function
16964 if (function_definition_p
)
16965 *function_definition_p
= false;
16967 /* Default arguments are only permitted for function parameters. */
16968 if (decl_spec_seq_has_spec_p (decl_specifiers
, ds_typedef
))
16969 parser
->default_arg_ok_p
= false;
16971 /* Defer access checks while parsing the declarator; we cannot know
16972 what names are accessible until we know what is being
16974 resume_deferring_access_checks ();
16976 /* Parse the declarator. */
16977 token
= cp_lexer_peek_token (parser
->lexer
);
16979 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
16980 &ctor_dtor_or_conv_p
,
16981 /*parenthesized_p=*/NULL
,
16982 member_p
, friend_p
);
16983 /* Gather up the deferred checks. */
16984 stop_deferring_access_checks ();
16986 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
16988 /* If the DECLARATOR was erroneous, there's no need to go
16990 if (declarator
== cp_error_declarator
)
16991 return error_mark_node
;
16993 /* Check that the number of template-parameter-lists is OK. */
16994 if (!cp_parser_check_declarator_template_parameters (parser
, declarator
,
16996 return error_mark_node
;
16998 if (declares_class_or_enum
& 2)
16999 cp_parser_check_for_definition_in_return_type (declarator
,
17000 decl_specifiers
->type
,
17001 decl_specifiers
->locations
[ds_type_spec
]);
17003 /* Figure out what scope the entity declared by the DECLARATOR is
17004 located in. `grokdeclarator' sometimes changes the scope, so
17005 we compute it now. */
17006 scope
= get_scope_of_declarator (declarator
);
17008 /* Perform any lookups in the declared type which were thought to be
17009 dependent, but are not in the scope of the declarator. */
17010 decl_specifiers
->type
17011 = maybe_update_decl_type (decl_specifiers
->type
, scope
);
17013 /* If we're allowing GNU extensions, look for an
17014 asm-specification. */
17015 if (cp_parser_allow_gnu_extensions_p (parser
))
17017 /* Look for an asm-specification. */
17018 asm_spec_start_token
= cp_lexer_peek_token (parser
->lexer
);
17019 asm_specification
= cp_parser_asm_specification_opt (parser
);
17022 asm_specification
= NULL_TREE
;
17024 /* Look for attributes. */
17025 attributes_start_token
= cp_lexer_peek_token (parser
->lexer
);
17026 attributes
= cp_parser_attributes_opt (parser
);
17028 /* Peek at the next token. */
17029 token
= cp_lexer_peek_token (parser
->lexer
);
17031 bool bogus_implicit_tmpl
= false;
17033 if (function_declarator_p (declarator
))
17035 /* Check to see if the token indicates the start of a
17036 function-definition. */
17037 if (cp_parser_token_starts_function_definition_p (token
))
17039 if (!function_definition_allowed_p
)
17041 /* If a function-definition should not appear here, issue an
17043 cp_parser_error (parser
,
17044 "a function-definition is not allowed here");
17045 return error_mark_node
;
17048 location_t func_brace_location
17049 = cp_lexer_peek_token (parser
->lexer
)->location
;
17051 /* Neither attributes nor an asm-specification are allowed
17052 on a function-definition. */
17053 if (asm_specification
)
17054 error_at (asm_spec_start_token
->location
,
17055 "an asm-specification is not allowed "
17056 "on a function-definition");
17058 error_at (attributes_start_token
->location
,
17059 "attributes are not allowed "
17060 "on a function-definition");
17061 /* This is a function-definition. */
17062 *function_definition_p
= true;
17064 /* Parse the function definition. */
17066 decl
= cp_parser_save_member_function_body (parser
,
17069 prefix_attributes
);
17072 (cp_parser_function_definition_from_specifiers_and_declarator
17073 (parser
, decl_specifiers
, prefix_attributes
, declarator
));
17075 if (decl
!= error_mark_node
&& DECL_STRUCT_FUNCTION (decl
))
17077 /* This is where the prologue starts... */
17078 DECL_STRUCT_FUNCTION (decl
)->function_start_locus
17079 = func_brace_location
;
17085 else if (parser
->fully_implicit_function_template_p
)
17087 /* A non-template declaration involving a function parameter list
17088 containing an implicit template parameter will be made into a
17089 template. If the resulting declaration is not going to be an
17090 actual function then finish the template scope here to prevent it.
17091 An error message will be issued once we have a decl to talk about.
17093 FIXME probably we should do type deduction rather than create an
17094 implicit template, but the standard currently doesn't allow it. */
17095 bogus_implicit_tmpl
= true;
17096 finish_fully_implicit_template (parser
, NULL_TREE
);
17101 Only in function declarations for constructors, destructors, and
17102 type conversions can the decl-specifier-seq be omitted.
17104 We explicitly postpone this check past the point where we handle
17105 function-definitions because we tolerate function-definitions
17106 that are missing their return types in some modes. */
17107 if (!decl_specifiers
->any_specifiers_p
&& ctor_dtor_or_conv_p
<= 0)
17109 cp_parser_error (parser
,
17110 "expected constructor, destructor, or type conversion");
17111 return error_mark_node
;
17114 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
17115 if (token
->type
== CPP_EQ
17116 || token
->type
== CPP_OPEN_PAREN
17117 || token
->type
== CPP_OPEN_BRACE
)
17119 is_initialized
= SD_INITIALIZED
;
17120 initialization_kind
= token
->type
;
17121 if (maybe_range_for_decl
)
17122 *maybe_range_for_decl
= error_mark_node
;
17123 tmp_init_loc
= token
->location
;
17124 if (init_loc
&& *init_loc
== UNKNOWN_LOCATION
)
17125 *init_loc
= tmp_init_loc
;
17127 if (token
->type
== CPP_EQ
17128 && function_declarator_p (declarator
))
17130 cp_token
*t2
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
17131 if (t2
->keyword
== RID_DEFAULT
)
17132 is_initialized
= SD_DEFAULTED
;
17133 else if (t2
->keyword
== RID_DELETE
)
17134 is_initialized
= SD_DELETED
;
17139 /* If the init-declarator isn't initialized and isn't followed by a
17140 `,' or `;', it's not a valid init-declarator. */
17141 if (token
->type
!= CPP_COMMA
17142 && token
->type
!= CPP_SEMICOLON
)
17144 if (maybe_range_for_decl
&& *maybe_range_for_decl
!= error_mark_node
)
17145 range_for_decl_p
= true;
17148 if (!maybe_range_for_decl
)
17149 cp_parser_error (parser
, "expected initializer");
17150 return error_mark_node
;
17153 is_initialized
= SD_UNINITIALIZED
;
17154 initialization_kind
= CPP_EOF
;
17157 /* Because start_decl has side-effects, we should only call it if we
17158 know we're going ahead. By this point, we know that we cannot
17159 possibly be looking at any other construct. */
17160 cp_parser_commit_to_tentative_parse (parser
);
17162 /* Enter the newly declared entry in the symbol table. If we're
17163 processing a declaration in a class-specifier, we wait until
17164 after processing the initializer. */
17167 if (parser
->in_unbraced_linkage_specification_p
)
17168 decl_specifiers
->storage_class
= sc_extern
;
17169 decl
= start_decl (declarator
, decl_specifiers
,
17170 range_for_decl_p
? SD_INITIALIZED
: is_initialized
,
17171 attributes
, prefix_attributes
, &pushed_scope
);
17172 cp_finalize_omp_declare_simd (parser
, decl
);
17173 /* Adjust location of decl if declarator->id_loc is more appropriate:
17174 set, and decl wasn't merged with another decl, in which case its
17175 location would be different from input_location, and more accurate. */
17177 && declarator
->id_loc
!= UNKNOWN_LOCATION
17178 && DECL_SOURCE_LOCATION (decl
) == input_location
)
17179 DECL_SOURCE_LOCATION (decl
) = declarator
->id_loc
;
17182 /* Enter the SCOPE. That way unqualified names appearing in the
17183 initializer will be looked up in SCOPE. */
17184 pushed_scope
= push_scope (scope
);
17186 /* Perform deferred access control checks, now that we know in which
17187 SCOPE the declared entity resides. */
17188 if (!member_p
&& decl
)
17190 tree saved_current_function_decl
= NULL_TREE
;
17192 /* If the entity being declared is a function, pretend that we
17193 are in its scope. If it is a `friend', it may have access to
17194 things that would not otherwise be accessible. */
17195 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17197 saved_current_function_decl
= current_function_decl
;
17198 current_function_decl
= decl
;
17201 /* Perform access checks for template parameters. */
17202 cp_parser_perform_template_parameter_access_checks (checks
);
17204 /* Perform the access control checks for the declarator and the
17205 decl-specifiers. */
17206 perform_deferred_access_checks (tf_warning_or_error
);
17208 /* Restore the saved value. */
17209 if (TREE_CODE (decl
) == FUNCTION_DECL
)
17210 current_function_decl
= saved_current_function_decl
;
17213 /* Parse the initializer. */
17214 initializer
= NULL_TREE
;
17215 is_direct_init
= false;
17216 is_non_constant_init
= true;
17217 if (is_initialized
)
17219 if (function_declarator_p (declarator
))
17221 if (initialization_kind
== CPP_EQ
)
17222 initializer
= cp_parser_pure_specifier (parser
);
17225 /* If the declaration was erroneous, we don't really
17226 know what the user intended, so just silently
17227 consume the initializer. */
17228 if (decl
!= error_mark_node
)
17229 error_at (tmp_init_loc
, "initializer provided for function");
17230 cp_parser_skip_to_closing_parenthesis (parser
,
17231 /*recovering=*/true,
17232 /*or_comma=*/false,
17233 /*consume_paren=*/true);
17238 /* We want to record the extra mangling scope for in-class
17239 initializers of class members and initializers of static data
17240 member templates. The former involves deferring
17241 parsing of the initializer until end of class as with default
17242 arguments. So right here we only handle the latter. */
17243 if (!member_p
&& processing_template_decl
)
17244 start_lambda_scope (decl
);
17245 initializer
= cp_parser_initializer (parser
,
17247 &is_non_constant_init
);
17248 if (!member_p
&& processing_template_decl
)
17249 finish_lambda_scope ();
17250 if (initializer
== error_mark_node
)
17251 cp_parser_skip_to_end_of_statement (parser
);
17255 /* The old parser allows attributes to appear after a parenthesized
17256 initializer. Mark Mitchell proposed removing this functionality
17257 on the GCC mailing lists on 2002-08-13. This parser accepts the
17258 attributes -- but ignores them. */
17259 if (cp_parser_allow_gnu_extensions_p (parser
)
17260 && initialization_kind
== CPP_OPEN_PAREN
)
17261 if (cp_parser_attributes_opt (parser
))
17262 warning (OPT_Wattributes
,
17263 "attributes after parenthesized initializer ignored");
17265 /* And now complain about a non-function implicit template. */
17266 if (bogus_implicit_tmpl
)
17267 error_at (DECL_SOURCE_LOCATION (decl
),
17268 "non-function %qD declared as implicit template", decl
);
17270 /* For an in-class declaration, use `grokfield' to create the
17276 pop_scope (pushed_scope
);
17277 pushed_scope
= NULL_TREE
;
17279 decl
= grokfield (declarator
, decl_specifiers
,
17280 initializer
, !is_non_constant_init
,
17281 /*asmspec=*/NULL_TREE
,
17282 chainon (attributes
, prefix_attributes
));
17283 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
17284 cp_parser_save_default_args (parser
, decl
);
17285 cp_finalize_omp_declare_simd (parser
, decl
);
17288 /* Finish processing the declaration. But, skip member
17290 if (!member_p
&& decl
&& decl
!= error_mark_node
&& !range_for_decl_p
)
17292 cp_finish_decl (decl
,
17293 initializer
, !is_non_constant_init
,
17295 /* If the initializer is in parentheses, then this is
17296 a direct-initialization, which means that an
17297 `explicit' constructor is OK. Otherwise, an
17298 `explicit' constructor cannot be used. */
17299 ((is_direct_init
|| !is_initialized
)
17300 ? LOOKUP_NORMAL
: LOOKUP_IMPLICIT
));
17302 else if ((cxx_dialect
!= cxx98
) && friend_p
17303 && decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
17304 /* Core issue #226 (C++0x only): A default template-argument
17305 shall not be specified in a friend class template
17307 check_default_tmpl_args (decl
, current_template_parms
, /*is_primary=*/true,
17308 /*is_partial=*/false, /*is_friend_decl=*/1);
17310 if (!friend_p
&& pushed_scope
)
17311 pop_scope (pushed_scope
);
17313 if (function_declarator_p (declarator
)
17314 && parser
->fully_implicit_function_template_p
)
17317 decl
= finish_fully_implicit_template (parser
, decl
);
17319 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
17325 /* Parse a declarator.
17329 ptr-operator declarator
17331 abstract-declarator:
17332 ptr-operator abstract-declarator [opt]
17333 direct-abstract-declarator
17338 attributes [opt] direct-declarator
17339 attributes [opt] ptr-operator declarator
17341 abstract-declarator:
17342 attributes [opt] ptr-operator abstract-declarator [opt]
17343 attributes [opt] direct-abstract-declarator
17345 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
17346 detect constructor, destructor or conversion operators. It is set
17347 to -1 if the declarator is a name, and +1 if it is a
17348 function. Otherwise it is set to zero. Usually you just want to
17349 test for >0, but internally the negative value is used.
17351 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
17352 a decl-specifier-seq unless it declares a constructor, destructor,
17353 or conversion. It might seem that we could check this condition in
17354 semantic analysis, rather than parsing, but that makes it difficult
17355 to handle something like `f()'. We want to notice that there are
17356 no decl-specifiers, and therefore realize that this is an
17357 expression, not a declaration.)
17359 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
17360 the declarator is a direct-declarator of the form "(...)".
17362 MEMBER_P is true iff this declarator is a member-declarator.
17364 FRIEND_P is true iff this declarator is a friend. */
17366 static cp_declarator
*
17367 cp_parser_declarator (cp_parser
* parser
,
17368 cp_parser_declarator_kind dcl_kind
,
17369 int* ctor_dtor_or_conv_p
,
17370 bool* parenthesized_p
,
17371 bool member_p
, bool friend_p
)
17373 cp_declarator
*declarator
;
17374 enum tree_code code
;
17375 cp_cv_quals cv_quals
;
17377 tree gnu_attributes
= NULL_TREE
, std_attributes
= NULL_TREE
;
17379 /* Assume this is not a constructor, destructor, or type-conversion
17381 if (ctor_dtor_or_conv_p
)
17382 *ctor_dtor_or_conv_p
= 0;
17384 if (cp_parser_allow_gnu_extensions_p (parser
))
17385 gnu_attributes
= cp_parser_gnu_attributes_opt (parser
);
17387 /* Check for the ptr-operator production. */
17388 cp_parser_parse_tentatively (parser
);
17389 /* Parse the ptr-operator. */
17390 code
= cp_parser_ptr_operator (parser
,
17395 /* If that worked, then we have a ptr-operator. */
17396 if (cp_parser_parse_definitely (parser
))
17398 /* If a ptr-operator was found, then this declarator was not
17400 if (parenthesized_p
)
17401 *parenthesized_p
= true;
17402 /* The dependent declarator is optional if we are parsing an
17403 abstract-declarator. */
17404 if (dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
17405 cp_parser_parse_tentatively (parser
);
17407 /* Parse the dependent declarator. */
17408 declarator
= cp_parser_declarator (parser
, dcl_kind
,
17409 /*ctor_dtor_or_conv_p=*/NULL
,
17410 /*parenthesized_p=*/NULL
,
17411 /*member_p=*/false,
17414 /* If we are parsing an abstract-declarator, we must handle the
17415 case where the dependent declarator is absent. */
17416 if (dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
17417 && !cp_parser_parse_definitely (parser
))
17420 declarator
= cp_parser_make_indirect_declarator
17421 (code
, class_type
, cv_quals
, declarator
, std_attributes
);
17423 /* Everything else is a direct-declarator. */
17426 if (parenthesized_p
)
17427 *parenthesized_p
= cp_lexer_next_token_is (parser
->lexer
,
17429 declarator
= cp_parser_direct_declarator (parser
, dcl_kind
,
17430 ctor_dtor_or_conv_p
,
17431 member_p
, friend_p
);
17434 if (gnu_attributes
&& declarator
&& declarator
!= cp_error_declarator
)
17435 declarator
->attributes
= gnu_attributes
;
17439 /* Parse a direct-declarator or direct-abstract-declarator.
17443 direct-declarator ( parameter-declaration-clause )
17444 cv-qualifier-seq [opt]
17445 ref-qualifier [opt]
17446 exception-specification [opt]
17447 direct-declarator [ constant-expression [opt] ]
17450 direct-abstract-declarator:
17451 direct-abstract-declarator [opt]
17452 ( parameter-declaration-clause )
17453 cv-qualifier-seq [opt]
17454 ref-qualifier [opt]
17455 exception-specification [opt]
17456 direct-abstract-declarator [opt] [ constant-expression [opt] ]
17457 ( abstract-declarator )
17459 Returns a representation of the declarator. DCL_KIND is
17460 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
17461 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
17462 we are parsing a direct-declarator. It is
17463 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
17464 of ambiguity we prefer an abstract declarator, as per
17465 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P, MEMBER_P, and FRIEND_P are
17466 as for cp_parser_declarator. */
17468 static cp_declarator
*
17469 cp_parser_direct_declarator (cp_parser
* parser
,
17470 cp_parser_declarator_kind dcl_kind
,
17471 int* ctor_dtor_or_conv_p
,
17472 bool member_p
, bool friend_p
)
17475 cp_declarator
*declarator
= NULL
;
17476 tree scope
= NULL_TREE
;
17477 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
17478 bool saved_in_declarator_p
= parser
->in_declarator_p
;
17480 tree pushed_scope
= NULL_TREE
;
17484 /* Peek at the next token. */
17485 token
= cp_lexer_peek_token (parser
->lexer
);
17486 if (token
->type
== CPP_OPEN_PAREN
)
17488 /* This is either a parameter-declaration-clause, or a
17489 parenthesized declarator. When we know we are parsing a
17490 named declarator, it must be a parenthesized declarator
17491 if FIRST is true. For instance, `(int)' is a
17492 parameter-declaration-clause, with an omitted
17493 direct-abstract-declarator. But `((*))', is a
17494 parenthesized abstract declarator. Finally, when T is a
17495 template parameter `(T)' is a
17496 parameter-declaration-clause, and not a parenthesized
17499 We first try and parse a parameter-declaration-clause,
17500 and then try a nested declarator (if FIRST is true).
17502 It is not an error for it not to be a
17503 parameter-declaration-clause, even when FIRST is
17509 The first is the declaration of a function while the
17510 second is the definition of a variable, including its
17513 Having seen only the parenthesis, we cannot know which of
17514 these two alternatives should be selected. Even more
17515 complex are examples like:
17520 The former is a function-declaration; the latter is a
17521 variable initialization.
17523 Thus again, we try a parameter-declaration-clause, and if
17524 that fails, we back out and return. */
17526 if (!first
|| dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
17529 bool is_declarator
= false;
17531 /* In a member-declarator, the only valid interpretation
17532 of a parenthesis is the start of a
17533 parameter-declaration-clause. (It is invalid to
17534 initialize a static data member with a parenthesized
17535 initializer; only the "=" form of initialization is
17538 cp_parser_parse_tentatively (parser
);
17540 /* Consume the `('. */
17541 cp_lexer_consume_token (parser
->lexer
);
17544 /* If this is going to be an abstract declarator, we're
17545 in a declarator and we can't have default args. */
17546 parser
->default_arg_ok_p
= false;
17547 parser
->in_declarator_p
= true;
17550 begin_scope (sk_function_parms
, NULL_TREE
);
17552 /* Parse the parameter-declaration-clause. */
17553 params
= cp_parser_parameter_declaration_clause (parser
);
17555 /* Consume the `)'. */
17556 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
17558 /* If all went well, parse the cv-qualifier-seq,
17559 ref-qualifier and the exception-specification. */
17560 if (member_p
|| cp_parser_parse_definitely (parser
))
17562 cp_cv_quals cv_quals
;
17563 cp_virt_specifiers virt_specifiers
;
17564 cp_ref_qualifier ref_qual
;
17565 tree exception_specification
;
17568 bool memfn
= (member_p
|| (pushed_scope
17569 && CLASS_TYPE_P (pushed_scope
)));
17571 is_declarator
= true;
17573 if (ctor_dtor_or_conv_p
)
17574 *ctor_dtor_or_conv_p
= *ctor_dtor_or_conv_p
< 0;
17577 /* Parse the cv-qualifier-seq. */
17578 cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
17579 /* Parse the ref-qualifier. */
17580 ref_qual
= cp_parser_ref_qualifier_opt (parser
);
17581 /* And the exception-specification. */
17582 exception_specification
17583 = cp_parser_exception_specification_opt (parser
);
17585 attrs
= cp_parser_std_attribute_spec_seq (parser
);
17587 /* In here, we handle cases where attribute is used after
17588 the function declaration. For example:
17589 void func (int x) __attribute__((vector(..))); */
17591 && cp_next_tokens_can_be_gnu_attribute_p (parser
))
17593 cp_parser_parse_tentatively (parser
);
17594 tree attr
= cp_parser_gnu_attributes_opt (parser
);
17595 if (cp_lexer_next_token_is_not (parser
->lexer
,
17597 && cp_lexer_next_token_is_not (parser
->lexer
,
17599 cp_parser_abort_tentative_parse (parser
);
17600 else if (!cp_parser_parse_definitely (parser
))
17603 attrs
= chainon (attr
, attrs
);
17605 late_return
= (cp_parser_late_return_type_opt
17606 (parser
, declarator
,
17607 memfn
? cv_quals
: -1));
17610 /* Parse the virt-specifier-seq. */
17611 virt_specifiers
= cp_parser_virt_specifier_seq_opt (parser
);
17613 /* Create the function-declarator. */
17614 declarator
= make_call_declarator (declarator
,
17619 exception_specification
,
17621 declarator
->std_attributes
= attrs
;
17622 /* Any subsequent parameter lists are to do with
17623 return type, so are not those of the declared
17625 parser
->default_arg_ok_p
= false;
17628 /* Remove the function parms from scope. */
17629 pop_bindings_and_leave_scope ();
17632 /* Repeat the main loop. */
17636 /* If this is the first, we can try a parenthesized
17640 bool saved_in_type_id_in_expr_p
;
17642 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
17643 parser
->in_declarator_p
= saved_in_declarator_p
;
17645 /* Consume the `('. */
17646 cp_lexer_consume_token (parser
->lexer
);
17647 /* Parse the nested declarator. */
17648 saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
17649 parser
->in_type_id_in_expr_p
= true;
17651 = cp_parser_declarator (parser
, dcl_kind
, ctor_dtor_or_conv_p
,
17652 /*parenthesized_p=*/NULL
,
17653 member_p
, friend_p
);
17654 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
17656 /* Expect a `)'. */
17657 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
17658 declarator
= cp_error_declarator
;
17659 if (declarator
== cp_error_declarator
)
17662 goto handle_declarator
;
17664 /* Otherwise, we must be done. */
17668 else if ((!first
|| dcl_kind
!= CP_PARSER_DECLARATOR_NAMED
)
17669 && token
->type
== CPP_OPEN_SQUARE
17670 && !cp_next_tokens_can_be_attribute_p (parser
))
17672 /* Parse an array-declarator. */
17673 tree bounds
, attrs
;
17675 if (ctor_dtor_or_conv_p
)
17676 *ctor_dtor_or_conv_p
= 0;
17679 parser
->default_arg_ok_p
= false;
17680 parser
->in_declarator_p
= true;
17681 /* Consume the `['. */
17682 cp_lexer_consume_token (parser
->lexer
);
17683 /* Peek at the next token. */
17684 token
= cp_lexer_peek_token (parser
->lexer
);
17685 /* If the next token is `]', then there is no
17686 constant-expression. */
17687 if (token
->type
!= CPP_CLOSE_SQUARE
)
17689 bool non_constant_p
;
17691 = cp_parser_constant_expression (parser
,
17692 /*allow_non_constant=*/true,
17694 if (!non_constant_p
)
17696 else if (error_operand_p (bounds
))
17697 /* Already gave an error. */;
17698 else if (!parser
->in_function_body
17699 || current_binding_level
->kind
== sk_function_parms
)
17701 /* Normally, the array bound must be an integral constant
17702 expression. However, as an extension, we allow VLAs
17703 in function scopes as long as they aren't part of a
17704 parameter declaration. */
17705 cp_parser_error (parser
,
17706 "array bound is not an integer constant");
17707 bounds
= error_mark_node
;
17709 else if (processing_template_decl
17710 && !type_dependent_expression_p (bounds
))
17712 /* Remember this wasn't a constant-expression. */
17713 bounds
= build_nop (TREE_TYPE (bounds
), bounds
);
17714 TREE_SIDE_EFFECTS (bounds
) = 1;
17718 bounds
= NULL_TREE
;
17719 /* Look for the closing `]'. */
17720 if (!cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
))
17722 declarator
= cp_error_declarator
;
17726 attrs
= cp_parser_std_attribute_spec_seq (parser
);
17727 declarator
= make_array_declarator (declarator
, bounds
);
17728 declarator
->std_attributes
= attrs
;
17730 else if (first
&& dcl_kind
!= CP_PARSER_DECLARATOR_ABSTRACT
)
17733 tree qualifying_scope
;
17734 tree unqualified_name
;
17736 special_function_kind sfk
;
17738 bool pack_expansion_p
= false;
17739 cp_token
*declarator_id_start_token
;
17741 /* Parse a declarator-id */
17742 abstract_ok
= (dcl_kind
== CP_PARSER_DECLARATOR_EITHER
);
17745 cp_parser_parse_tentatively (parser
);
17747 /* If we see an ellipsis, we should be looking at a
17749 if (token
->type
== CPP_ELLIPSIS
)
17751 /* Consume the `...' */
17752 cp_lexer_consume_token (parser
->lexer
);
17754 pack_expansion_p
= true;
17758 declarator_id_start_token
= cp_lexer_peek_token (parser
->lexer
);
17760 = cp_parser_declarator_id (parser
, /*optional_p=*/abstract_ok
);
17761 qualifying_scope
= parser
->scope
;
17766 if (!unqualified_name
&& pack_expansion_p
)
17768 /* Check whether an error occurred. */
17769 okay
= !cp_parser_error_occurred (parser
);
17771 /* We already consumed the ellipsis to mark a
17772 parameter pack, but we have no way to report it,
17773 so abort the tentative parse. We will be exiting
17774 immediately anyway. */
17775 cp_parser_abort_tentative_parse (parser
);
17778 okay
= cp_parser_parse_definitely (parser
);
17781 unqualified_name
= error_mark_node
;
17782 else if (unqualified_name
17783 && (qualifying_scope
17784 || (!identifier_p (unqualified_name
))))
17786 cp_parser_error (parser
, "expected unqualified-id");
17787 unqualified_name
= error_mark_node
;
17791 if (!unqualified_name
)
17793 if (unqualified_name
== error_mark_node
)
17795 declarator
= cp_error_declarator
;
17796 pack_expansion_p
= false;
17797 declarator
->parameter_pack_p
= false;
17801 attrs
= cp_parser_std_attribute_spec_seq (parser
);
17803 if (qualifying_scope
&& at_namespace_scope_p ()
17804 && TREE_CODE (qualifying_scope
) == TYPENAME_TYPE
)
17806 /* In the declaration of a member of a template class
17807 outside of the class itself, the SCOPE will sometimes
17808 be a TYPENAME_TYPE. For example, given:
17810 template <typename T>
17811 int S<T>::R::i = 3;
17813 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
17814 this context, we must resolve S<T>::R to an ordinary
17815 type, rather than a typename type.
17817 The reason we normally avoid resolving TYPENAME_TYPEs
17818 is that a specialization of `S' might render
17819 `S<T>::R' not a type. However, if `S' is
17820 specialized, then this `i' will not be used, so there
17821 is no harm in resolving the types here. */
17824 /* Resolve the TYPENAME_TYPE. */
17825 type
= resolve_typename_type (qualifying_scope
,
17826 /*only_current_p=*/false);
17827 /* If that failed, the declarator is invalid. */
17828 if (TREE_CODE (type
) == TYPENAME_TYPE
)
17830 if (typedef_variant_p (type
))
17831 error_at (declarator_id_start_token
->location
,
17832 "cannot define member of dependent typedef "
17835 error_at (declarator_id_start_token
->location
,
17836 "%<%T::%E%> is not a type",
17837 TYPE_CONTEXT (qualifying_scope
),
17838 TYPE_IDENTIFIER (qualifying_scope
));
17840 qualifying_scope
= type
;
17845 if (unqualified_name
)
17849 if (qualifying_scope
17850 && CLASS_TYPE_P (qualifying_scope
))
17851 class_type
= qualifying_scope
;
17853 class_type
= current_class_type
;
17855 if (TREE_CODE (unqualified_name
) == TYPE_DECL
)
17857 tree name_type
= TREE_TYPE (unqualified_name
);
17858 if (class_type
&& same_type_p (name_type
, class_type
))
17860 if (qualifying_scope
17861 && CLASSTYPE_USE_TEMPLATE (name_type
))
17863 error_at (declarator_id_start_token
->location
,
17864 "invalid use of constructor as a template");
17865 inform (declarator_id_start_token
->location
,
17866 "use %<%T::%D%> instead of %<%T::%D%> to "
17867 "name the constructor in a qualified name",
17869 DECL_NAME (TYPE_TI_TEMPLATE (class_type
)),
17870 class_type
, name_type
);
17871 declarator
= cp_error_declarator
;
17875 unqualified_name
= constructor_name (class_type
);
17879 /* We do not attempt to print the declarator
17880 here because we do not have enough
17881 information about its original syntactic
17883 cp_parser_error (parser
, "invalid declarator");
17884 declarator
= cp_error_declarator
;
17891 if (TREE_CODE (unqualified_name
) == BIT_NOT_EXPR
)
17892 sfk
= sfk_destructor
;
17893 else if (IDENTIFIER_TYPENAME_P (unqualified_name
))
17894 sfk
= sfk_conversion
;
17895 else if (/* There's no way to declare a constructor
17896 for an anonymous type, even if the type
17897 got a name for linkage purposes. */
17898 !TYPE_WAS_ANONYMOUS (class_type
)
17899 /* Handle correctly (c++/19200):
17913 friend void N::S();
17916 && class_type
!= qualifying_scope
)
17917 && constructor_name_p (unqualified_name
,
17920 unqualified_name
= constructor_name (class_type
);
17921 sfk
= sfk_constructor
;
17923 else if (is_overloaded_fn (unqualified_name
)
17924 && DECL_CONSTRUCTOR_P (get_first_fn
17925 (unqualified_name
)))
17926 sfk
= sfk_constructor
;
17928 if (ctor_dtor_or_conv_p
&& sfk
!= sfk_none
)
17929 *ctor_dtor_or_conv_p
= -1;
17932 declarator
= make_id_declarator (qualifying_scope
,
17935 declarator
->std_attributes
= attrs
;
17936 declarator
->id_loc
= token
->location
;
17937 declarator
->parameter_pack_p
= pack_expansion_p
;
17939 if (pack_expansion_p
)
17940 maybe_warn_variadic_templates ();
17943 handle_declarator
:;
17944 scope
= get_scope_of_declarator (declarator
);
17947 /* Any names that appear after the declarator-id for a
17948 member are looked up in the containing scope. */
17949 if (at_function_scope_p ())
17951 /* But declarations with qualified-ids can't appear in a
17953 cp_parser_error (parser
, "qualified-id in declaration");
17954 declarator
= cp_error_declarator
;
17957 pushed_scope
= push_scope (scope
);
17959 parser
->in_declarator_p
= true;
17960 if ((ctor_dtor_or_conv_p
&& *ctor_dtor_or_conv_p
)
17961 || (declarator
&& declarator
->kind
== cdk_id
))
17962 /* Default args are only allowed on function
17964 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
17966 parser
->default_arg_ok_p
= false;
17975 /* For an abstract declarator, we might wind up with nothing at this
17976 point. That's an error; the declarator is not optional. */
17978 cp_parser_error (parser
, "expected declarator");
17980 /* If we entered a scope, we must exit it now. */
17982 pop_scope (pushed_scope
);
17984 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
17985 parser
->in_declarator_p
= saved_in_declarator_p
;
17990 /* Parse a ptr-operator.
17993 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17994 * cv-qualifier-seq [opt]
17996 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
17997 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
18002 & cv-qualifier-seq [opt]
18004 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
18005 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
18006 an rvalue reference. In the case of a pointer-to-member, *TYPE is
18007 filled in with the TYPE containing the member. *CV_QUALS is
18008 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
18009 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
18010 Note that the tree codes returned by this function have nothing
18011 to do with the types of trees that will be eventually be created
18012 to represent the pointer or reference type being parsed. They are
18013 just constants with suggestive names. */
18014 static enum tree_code
18015 cp_parser_ptr_operator (cp_parser
* parser
,
18017 cp_cv_quals
*cv_quals
,
18020 enum tree_code code
= ERROR_MARK
;
18022 tree attrs
= NULL_TREE
;
18024 /* Assume that it's not a pointer-to-member. */
18026 /* And that there are no cv-qualifiers. */
18027 *cv_quals
= TYPE_UNQUALIFIED
;
18029 /* Peek at the next token. */
18030 token
= cp_lexer_peek_token (parser
->lexer
);
18032 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
18033 if (token
->type
== CPP_MULT
)
18034 code
= INDIRECT_REF
;
18035 else if (token
->type
== CPP_AND
)
18037 else if ((cxx_dialect
!= cxx98
) &&
18038 token
->type
== CPP_AND_AND
) /* C++0x only */
18039 code
= NON_LVALUE_EXPR
;
18041 if (code
!= ERROR_MARK
)
18043 /* Consume the `*', `&' or `&&'. */
18044 cp_lexer_consume_token (parser
->lexer
);
18046 /* A `*' can be followed by a cv-qualifier-seq, and so can a
18047 `&', if we are allowing GNU extensions. (The only qualifier
18048 that can legally appear after `&' is `restrict', but that is
18049 enforced during semantic analysis. */
18050 if (code
== INDIRECT_REF
18051 || cp_parser_allow_gnu_extensions_p (parser
))
18052 *cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
18054 attrs
= cp_parser_std_attribute_spec_seq (parser
);
18055 if (attributes
!= NULL
)
18056 *attributes
= attrs
;
18060 /* Try the pointer-to-member case. */
18061 cp_parser_parse_tentatively (parser
);
18062 /* Look for the optional `::' operator. */
18063 cp_parser_global_scope_opt (parser
,
18064 /*current_scope_valid_p=*/false);
18065 /* Look for the nested-name specifier. */
18066 token
= cp_lexer_peek_token (parser
->lexer
);
18067 cp_parser_nested_name_specifier (parser
,
18068 /*typename_keyword_p=*/false,
18069 /*check_dependency_p=*/true,
18071 /*is_declaration=*/false);
18072 /* If we found it, and the next token is a `*', then we are
18073 indeed looking at a pointer-to-member operator. */
18074 if (!cp_parser_error_occurred (parser
)
18075 && cp_parser_require (parser
, CPP_MULT
, RT_MULT
))
18077 /* Indicate that the `*' operator was used. */
18078 code
= INDIRECT_REF
;
18080 if (TREE_CODE (parser
->scope
) == NAMESPACE_DECL
)
18081 error_at (token
->location
, "%qD is a namespace", parser
->scope
);
18082 else if (TREE_CODE (parser
->scope
) == ENUMERAL_TYPE
)
18083 error_at (token
->location
, "cannot form pointer to member of "
18084 "non-class %q#T", parser
->scope
);
18087 /* The type of which the member is a member is given by the
18089 *type
= parser
->scope
;
18090 /* The next name will not be qualified. */
18091 parser
->scope
= NULL_TREE
;
18092 parser
->qualifying_scope
= NULL_TREE
;
18093 parser
->object_scope
= NULL_TREE
;
18094 /* Look for optional c++11 attributes. */
18095 attrs
= cp_parser_std_attribute_spec_seq (parser
);
18096 if (attributes
!= NULL
)
18097 *attributes
= attrs
;
18098 /* Look for the optional cv-qualifier-seq. */
18099 *cv_quals
= cp_parser_cv_qualifier_seq_opt (parser
);
18102 /* If that didn't work we don't have a ptr-operator. */
18103 if (!cp_parser_parse_definitely (parser
))
18104 cp_parser_error (parser
, "expected ptr-operator");
18110 /* Parse an (optional) cv-qualifier-seq.
18113 cv-qualifier cv-qualifier-seq [opt]
18124 Returns a bitmask representing the cv-qualifiers. */
18127 cp_parser_cv_qualifier_seq_opt (cp_parser
* parser
)
18129 cp_cv_quals cv_quals
= TYPE_UNQUALIFIED
;
18134 cp_cv_quals cv_qualifier
;
18136 /* Peek at the next token. */
18137 token
= cp_lexer_peek_token (parser
->lexer
);
18138 /* See if it's a cv-qualifier. */
18139 switch (token
->keyword
)
18142 cv_qualifier
= TYPE_QUAL_CONST
;
18146 cv_qualifier
= TYPE_QUAL_VOLATILE
;
18150 cv_qualifier
= TYPE_QUAL_RESTRICT
;
18154 cv_qualifier
= TYPE_UNQUALIFIED
;
18161 if (cv_quals
& cv_qualifier
)
18163 error_at (token
->location
, "duplicate cv-qualifier");
18164 cp_lexer_purge_token (parser
->lexer
);
18168 cp_lexer_consume_token (parser
->lexer
);
18169 cv_quals
|= cv_qualifier
;
18176 /* Parse an (optional) ref-qualifier
18182 Returns cp_ref_qualifier representing ref-qualifier. */
18184 static cp_ref_qualifier
18185 cp_parser_ref_qualifier_opt (cp_parser
* parser
)
18187 cp_ref_qualifier ref_qual
= REF_QUAL_NONE
;
18189 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
18190 if (cxx_dialect
< cxx11
&& cp_parser_parsing_tentatively (parser
))
18195 cp_ref_qualifier curr_ref_qual
= REF_QUAL_NONE
;
18196 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
18198 switch (token
->type
)
18201 curr_ref_qual
= REF_QUAL_LVALUE
;
18205 curr_ref_qual
= REF_QUAL_RVALUE
;
18209 curr_ref_qual
= REF_QUAL_NONE
;
18213 if (!curr_ref_qual
)
18217 error_at (token
->location
, "multiple ref-qualifiers");
18218 cp_lexer_purge_token (parser
->lexer
);
18222 ref_qual
= curr_ref_qual
;
18223 cp_lexer_consume_token (parser
->lexer
);
18230 /* Parse an (optional) virt-specifier-seq.
18232 virt-specifier-seq:
18233 virt-specifier virt-specifier-seq [opt]
18239 Returns a bitmask representing the virt-specifiers. */
18241 static cp_virt_specifiers
18242 cp_parser_virt_specifier_seq_opt (cp_parser
* parser
)
18244 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
18249 cp_virt_specifiers virt_specifier
;
18251 /* Peek at the next token. */
18252 token
= cp_lexer_peek_token (parser
->lexer
);
18253 /* See if it's a virt-specifier-qualifier. */
18254 if (token
->type
!= CPP_NAME
)
18256 if (!strcmp (IDENTIFIER_POINTER(token
->u
.value
), "override"))
18258 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS
);
18259 virt_specifier
= VIRT_SPEC_OVERRIDE
;
18261 else if (!strcmp (IDENTIFIER_POINTER(token
->u
.value
), "final"))
18263 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS
);
18264 virt_specifier
= VIRT_SPEC_FINAL
;
18266 else if (!strcmp (IDENTIFIER_POINTER(token
->u
.value
), "__final"))
18268 virt_specifier
= VIRT_SPEC_FINAL
;
18273 if (virt_specifiers
& virt_specifier
)
18275 error_at (token
->location
, "duplicate virt-specifier");
18276 cp_lexer_purge_token (parser
->lexer
);
18280 cp_lexer_consume_token (parser
->lexer
);
18281 virt_specifiers
|= virt_specifier
;
18284 return virt_specifiers
;
18287 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
18288 is in scope even though it isn't real. */
18291 inject_this_parameter (tree ctype
, cp_cv_quals quals
)
18295 if (current_class_ptr
)
18297 /* We don't clear this between NSDMIs. Is it already what we want? */
18298 tree type
= TREE_TYPE (TREE_TYPE (current_class_ptr
));
18299 if (same_type_ignoring_top_level_qualifiers_p (ctype
, type
)
18300 && cp_type_quals (type
) == quals
)
18304 this_parm
= build_this_parm (ctype
, quals
);
18305 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
18306 current_class_ptr
= NULL_TREE
;
18308 = cp_build_indirect_ref (this_parm
, RO_NULL
, tf_warning_or_error
);
18309 current_class_ptr
= this_parm
;
18312 /* Return true iff our current scope is a non-static data member
18316 parsing_nsdmi (void)
18318 /* We recognize NSDMI context by the context-less 'this' pointer set up
18319 by the function above. */
18320 if (current_class_ptr
18321 && TREE_CODE (current_class_ptr
) == PARM_DECL
18322 && DECL_CONTEXT (current_class_ptr
) == NULL_TREE
)
18327 /* Parse a late-specified return type, if any. This is not a separate
18328 non-terminal, but part of a function declarator, which looks like
18330 -> trailing-type-specifier-seq abstract-declarator(opt)
18332 Returns the type indicated by the type-id.
18334 In addition to this this parses any queued up omp declare simd
18335 clauses and Cilk Plus SIMD-enabled function's vector attributes.
18337 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
18341 cp_parser_late_return_type_opt (cp_parser
* parser
, cp_declarator
*declarator
,
18345 tree type
= NULL_TREE
;
18346 bool declare_simd_p
= (parser
->omp_declare_simd
18348 && declarator
->kind
== cdk_id
);
18350 bool cilk_simd_fn_vector_p
= (parser
->cilk_simd_fn_info
18351 && declarator
&& declarator
->kind
== cdk_id
);
18353 /* Peek at the next token. */
18354 token
= cp_lexer_peek_token (parser
->lexer
);
18355 /* A late-specified return type is indicated by an initial '->'. */
18356 if (token
->type
!= CPP_DEREF
&& !(declare_simd_p
|| cilk_simd_fn_vector_p
))
18359 tree save_ccp
= current_class_ptr
;
18360 tree save_ccr
= current_class_ref
;
18363 /* DR 1207: 'this' is in scope in the trailing return type. */
18364 inject_this_parameter (current_class_type
, quals
);
18367 if (token
->type
== CPP_DEREF
)
18369 /* Consume the ->. */
18370 cp_lexer_consume_token (parser
->lexer
);
18372 type
= cp_parser_trailing_type_id (parser
);
18375 if (cilk_simd_fn_vector_p
)
18376 declarator
->std_attributes
18377 = cp_parser_late_parsing_cilk_simd_fn_info (parser
,
18378 declarator
->std_attributes
);
18379 if (declare_simd_p
)
18380 declarator
->std_attributes
18381 = cp_parser_late_parsing_omp_declare_simd (parser
,
18382 declarator
->std_attributes
);
18386 current_class_ptr
= save_ccp
;
18387 current_class_ref
= save_ccr
;
18393 /* Parse a declarator-id.
18397 :: [opt] nested-name-specifier [opt] type-name
18399 In the `id-expression' case, the value returned is as for
18400 cp_parser_id_expression if the id-expression was an unqualified-id.
18401 If the id-expression was a qualified-id, then a SCOPE_REF is
18402 returned. The first operand is the scope (either a NAMESPACE_DECL
18403 or TREE_TYPE), but the second is still just a representation of an
18407 cp_parser_declarator_id (cp_parser
* parser
, bool optional_p
)
18410 /* The expression must be an id-expression. Assume that qualified
18411 names are the names of types so that:
18414 int S<T>::R::i = 3;
18416 will work; we must treat `S<T>::R' as the name of a type.
18417 Similarly, assume that qualified names are templates, where
18421 int S<T>::R<T>::i = 3;
18424 id
= cp_parser_id_expression (parser
,
18425 /*template_keyword_p=*/false,
18426 /*check_dependency_p=*/false,
18427 /*template_p=*/NULL
,
18428 /*declarator_p=*/true,
18430 if (id
&& BASELINK_P (id
))
18431 id
= BASELINK_FUNCTIONS (id
);
18435 /* Parse a type-id.
18438 type-specifier-seq abstract-declarator [opt]
18440 Returns the TYPE specified. */
18443 cp_parser_type_id_1 (cp_parser
* parser
, bool is_template_arg
,
18444 bool is_trailing_return
)
18446 cp_decl_specifier_seq type_specifier_seq
;
18447 cp_declarator
*abstract_declarator
;
18449 /* Parse the type-specifier-seq. */
18450 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/false,
18451 is_trailing_return
,
18452 &type_specifier_seq
);
18453 if (type_specifier_seq
.type
== error_mark_node
)
18454 return error_mark_node
;
18456 /* There might or might not be an abstract declarator. */
18457 cp_parser_parse_tentatively (parser
);
18458 /* Look for the declarator. */
18459 abstract_declarator
18460 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_ABSTRACT
, NULL
,
18461 /*parenthesized_p=*/NULL
,
18462 /*member_p=*/false,
18463 /*friend_p=*/false);
18464 /* Check to see if there really was a declarator. */
18465 if (!cp_parser_parse_definitely (parser
))
18466 abstract_declarator
= NULL
;
18468 if (type_specifier_seq
.type
18469 /* None of the valid uses of 'auto' in C++14 involve the type-id
18470 nonterminal, but it is valid in a trailing-return-type. */
18471 && !(cxx_dialect
>= cxx14
&& is_trailing_return
)
18472 && type_uses_auto (type_specifier_seq
.type
))
18474 /* A type-id with type 'auto' is only ok if the abstract declarator
18475 is a function declarator with a late-specified return type. */
18476 if (abstract_declarator
18477 && abstract_declarator
->kind
== cdk_function
18478 && abstract_declarator
->u
.function
.late_return_type
)
18482 error ("invalid use of %<auto%>");
18483 return error_mark_node
;
18487 return groktypename (&type_specifier_seq
, abstract_declarator
,
18491 static tree
cp_parser_type_id (cp_parser
*parser
)
18493 return cp_parser_type_id_1 (parser
, false, false);
18496 static tree
cp_parser_template_type_arg (cp_parser
*parser
)
18499 const char *saved_message
= parser
->type_definition_forbidden_message
;
18500 parser
->type_definition_forbidden_message
18501 = G_("types may not be defined in template arguments");
18502 r
= cp_parser_type_id_1 (parser
, true, false);
18503 parser
->type_definition_forbidden_message
= saved_message
;
18504 if (cxx_dialect
>= cxx14
&& type_uses_auto (r
))
18506 error ("invalid use of %<auto%> in template argument");
18507 r
= error_mark_node
;
18512 static tree
cp_parser_trailing_type_id (cp_parser
*parser
)
18514 return cp_parser_type_id_1 (parser
, false, true);
18517 /* Parse a type-specifier-seq.
18519 type-specifier-seq:
18520 type-specifier type-specifier-seq [opt]
18524 type-specifier-seq:
18525 attributes type-specifier-seq [opt]
18527 If IS_DECLARATION is true, we are at the start of a "condition" or
18528 exception-declaration, so we might be followed by a declarator-id.
18530 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
18531 i.e. we've just seen "->".
18533 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
18536 cp_parser_type_specifier_seq (cp_parser
* parser
,
18537 bool is_declaration
,
18538 bool is_trailing_return
,
18539 cp_decl_specifier_seq
*type_specifier_seq
)
18541 bool seen_type_specifier
= false;
18542 cp_parser_flags flags
= CP_PARSER_FLAGS_OPTIONAL
;
18543 cp_token
*start_token
= NULL
;
18545 /* Clear the TYPE_SPECIFIER_SEQ. */
18546 clear_decl_specs (type_specifier_seq
);
18548 /* In the context of a trailing return type, enum E { } is an
18549 elaborated-type-specifier followed by a function-body, not an
18551 if (is_trailing_return
)
18552 flags
|= CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS
;
18554 /* Parse the type-specifiers and attributes. */
18557 tree type_specifier
;
18558 bool is_cv_qualifier
;
18560 /* Check for attributes first. */
18561 if (cp_next_tokens_can_be_attribute_p (parser
))
18563 type_specifier_seq
->attributes
=
18564 chainon (type_specifier_seq
->attributes
,
18565 cp_parser_attributes_opt (parser
));
18569 /* record the token of the beginning of the type specifier seq,
18570 for error reporting purposes*/
18572 start_token
= cp_lexer_peek_token (parser
->lexer
);
18574 /* Look for the type-specifier. */
18575 type_specifier
= cp_parser_type_specifier (parser
,
18577 type_specifier_seq
,
18578 /*is_declaration=*/false,
18581 if (!type_specifier
)
18583 /* If the first type-specifier could not be found, this is not a
18584 type-specifier-seq at all. */
18585 if (!seen_type_specifier
)
18587 /* Set in_declarator_p to avoid skipping to the semicolon. */
18588 int in_decl
= parser
->in_declarator_p
;
18589 parser
->in_declarator_p
= true;
18591 if (cp_parser_uncommitted_to_tentative_parse_p (parser
)
18592 || !cp_parser_parse_and_diagnose_invalid_type_name (parser
))
18593 cp_parser_error (parser
, "expected type-specifier");
18595 parser
->in_declarator_p
= in_decl
;
18597 type_specifier_seq
->type
= error_mark_node
;
18600 /* If subsequent type-specifiers could not be found, the
18601 type-specifier-seq is complete. */
18605 seen_type_specifier
= true;
18606 /* The standard says that a condition can be:
18608 type-specifier-seq declarator = assignment-expression
18615 we should treat the "S" as a declarator, not as a
18616 type-specifier. The standard doesn't say that explicitly for
18617 type-specifier-seq, but it does say that for
18618 decl-specifier-seq in an ordinary declaration. Perhaps it
18619 would be clearer just to allow a decl-specifier-seq here, and
18620 then add a semantic restriction that if any decl-specifiers
18621 that are not type-specifiers appear, the program is invalid. */
18622 if (is_declaration
&& !is_cv_qualifier
)
18623 flags
|= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES
;
18627 /* Return whether the function currently being declared has an associated
18628 template parameter list. */
18631 function_being_declared_is_template_p (cp_parser
* parser
)
18633 if (!current_template_parms
|| processing_template_parmlist
)
18636 if (parser
->implicit_template_scope
)
18639 if (at_class_scope_p ()
18640 && TYPE_BEING_DEFINED (current_class_type
))
18641 return parser
->num_template_parameter_lists
!= 0;
18643 return ((int) parser
->num_template_parameter_lists
> template_class_depth
18644 (current_class_type
));
18647 /* Parse a parameter-declaration-clause.
18649 parameter-declaration-clause:
18650 parameter-declaration-list [opt] ... [opt]
18651 parameter-declaration-list , ...
18653 Returns a representation for the parameter declarations. A return
18654 value of NULL indicates a parameter-declaration-clause consisting
18655 only of an ellipsis. */
18658 cp_parser_parameter_declaration_clause (cp_parser
* parser
)
18667 int auto_is_implicit_function_template_parm_p
;
18669 parser
->auto_is_implicit_function_template_parm_p
18670 = auto_is_implicit_function_template_parm_p
;
18672 } cleanup
= { parser
, parser
->auto_is_implicit_function_template_parm_p
};
18676 if (!processing_specialization
18677 && !processing_template_parmlist
18678 && !processing_explicit_instantiation
)
18679 if (!current_function_decl
18680 || (current_class_type
&& LAMBDA_TYPE_P (current_class_type
)))
18681 parser
->auto_is_implicit_function_template_parm_p
= true;
18683 /* Peek at the next token. */
18684 token
= cp_lexer_peek_token (parser
->lexer
);
18685 /* Check for trivial parameter-declaration-clauses. */
18686 if (token
->type
== CPP_ELLIPSIS
)
18688 /* Consume the `...' token. */
18689 cp_lexer_consume_token (parser
->lexer
);
18692 else if (token
->type
== CPP_CLOSE_PAREN
)
18693 /* There are no parameters. */
18695 #ifndef NO_IMPLICIT_EXTERN_C
18696 if (in_system_header_at (input_location
)
18697 && current_class_type
== NULL
18698 && current_lang_name
== lang_name_c
)
18702 return void_list_node
;
18704 /* Check for `(void)', too, which is a special case. */
18705 else if (token
->keyword
== RID_VOID
18706 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
18707 == CPP_CLOSE_PAREN
))
18709 /* Consume the `void' token. */
18710 cp_lexer_consume_token (parser
->lexer
);
18711 /* There are no parameters. */
18712 return void_list_node
;
18715 /* Parse the parameter-declaration-list. */
18716 parameters
= cp_parser_parameter_declaration_list (parser
, &is_error
);
18717 /* If a parse error occurred while parsing the
18718 parameter-declaration-list, then the entire
18719 parameter-declaration-clause is erroneous. */
18723 /* Peek at the next token. */
18724 token
= cp_lexer_peek_token (parser
->lexer
);
18725 /* If it's a `,', the clause should terminate with an ellipsis. */
18726 if (token
->type
== CPP_COMMA
)
18728 /* Consume the `,'. */
18729 cp_lexer_consume_token (parser
->lexer
);
18730 /* Expect an ellipsis. */
18732 = (cp_parser_require (parser
, CPP_ELLIPSIS
, RT_ELLIPSIS
) != NULL
);
18734 /* It might also be `...' if the optional trailing `,' was
18736 else if (token
->type
== CPP_ELLIPSIS
)
18738 /* Consume the `...' token. */
18739 cp_lexer_consume_token (parser
->lexer
);
18740 /* And remember that we saw it. */
18744 ellipsis_p
= false;
18746 /* Finish the parameter list. */
18748 parameters
= chainon (parameters
, void_list_node
);
18753 /* Parse a parameter-declaration-list.
18755 parameter-declaration-list:
18756 parameter-declaration
18757 parameter-declaration-list , parameter-declaration
18759 Returns a representation of the parameter-declaration-list, as for
18760 cp_parser_parameter_declaration_clause. However, the
18761 `void_list_node' is never appended to the list. Upon return,
18762 *IS_ERROR will be true iff an error occurred. */
18765 cp_parser_parameter_declaration_list (cp_parser
* parser
, bool *is_error
)
18767 tree parameters
= NULL_TREE
;
18768 tree
*tail
= ¶meters
;
18769 bool saved_in_unbraced_linkage_specification_p
;
18772 /* Assume all will go well. */
18774 /* The special considerations that apply to a function within an
18775 unbraced linkage specifications do not apply to the parameters
18776 to the function. */
18777 saved_in_unbraced_linkage_specification_p
18778 = parser
->in_unbraced_linkage_specification_p
;
18779 parser
->in_unbraced_linkage_specification_p
= false;
18781 /* Look for more parameters. */
18784 cp_parameter_declarator
*parameter
;
18785 tree decl
= error_mark_node
;
18786 bool parenthesized_p
= false;
18787 int template_parm_idx
= (function_being_declared_is_template_p (parser
)?
18788 TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
18789 (current_template_parms
)) : 0);
18791 /* Parse the parameter. */
18793 = cp_parser_parameter_declaration (parser
,
18794 /*template_parm_p=*/false,
18797 /* We don't know yet if the enclosing context is deprecated, so wait
18798 and warn in grokparms if appropriate. */
18799 deprecated_state
= DEPRECATED_SUPPRESS
;
18803 /* If a function parameter pack was specified and an implicit template
18804 parameter was introduced during cp_parser_parameter_declaration,
18805 change any implicit parameters introduced into packs. */
18806 if (parser
->implicit_template_parms
18807 && parameter
->declarator
18808 && parameter
->declarator
->parameter_pack_p
)
18810 int latest_template_parm_idx
= TREE_VEC_LENGTH
18811 (INNERMOST_TEMPLATE_PARMS (current_template_parms
));
18813 if (latest_template_parm_idx
!= template_parm_idx
)
18814 parameter
->decl_specifiers
.type
= convert_generic_types_to_packs
18815 (parameter
->decl_specifiers
.type
,
18816 template_parm_idx
, latest_template_parm_idx
);
18819 decl
= grokdeclarator (parameter
->declarator
,
18820 ¶meter
->decl_specifiers
,
18822 parameter
->default_argument
!= NULL_TREE
,
18823 ¶meter
->decl_specifiers
.attributes
);
18826 deprecated_state
= DEPRECATED_NORMAL
;
18828 /* If a parse error occurred parsing the parameter declaration,
18829 then the entire parameter-declaration-list is erroneous. */
18830 if (decl
== error_mark_node
)
18833 parameters
= error_mark_node
;
18837 if (parameter
->decl_specifiers
.attributes
)
18838 cplus_decl_attributes (&decl
,
18839 parameter
->decl_specifiers
.attributes
,
18841 if (DECL_NAME (decl
))
18842 decl
= pushdecl (decl
);
18844 if (decl
!= error_mark_node
)
18846 retrofit_lang_decl (decl
);
18847 DECL_PARM_INDEX (decl
) = ++index
;
18848 DECL_PARM_LEVEL (decl
) = function_parm_depth ();
18851 /* Add the new parameter to the list. */
18852 *tail
= build_tree_list (parameter
->default_argument
, decl
);
18853 tail
= &TREE_CHAIN (*tail
);
18855 /* Peek at the next token. */
18856 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
)
18857 || cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
)
18858 /* These are for Objective-C++ */
18859 || cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
18860 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
18861 /* The parameter-declaration-list is complete. */
18863 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
18867 /* Peek at the next token. */
18868 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
18869 /* If it's an ellipsis, then the list is complete. */
18870 if (token
->type
== CPP_ELLIPSIS
)
18872 /* Otherwise, there must be more parameters. Consume the
18874 cp_lexer_consume_token (parser
->lexer
);
18875 /* When parsing something like:
18877 int i(float f, double d)
18879 we can tell after seeing the declaration for "f" that we
18880 are not looking at an initialization of a variable "i",
18881 but rather at the declaration of a function "i".
18883 Due to the fact that the parsing of template arguments
18884 (as specified to a template-id) requires backtracking we
18885 cannot use this technique when inside a template argument
18887 if (!parser
->in_template_argument_list_p
18888 && !parser
->in_type_id_in_expr_p
18889 && cp_parser_uncommitted_to_tentative_parse_p (parser
)
18890 /* However, a parameter-declaration of the form
18891 "float(f)" (which is a valid declaration of a
18892 parameter "f") can also be interpreted as an
18893 expression (the conversion of "f" to "float"). */
18894 && !parenthesized_p
)
18895 cp_parser_commit_to_tentative_parse (parser
);
18899 cp_parser_error (parser
, "expected %<,%> or %<...%>");
18900 if (!cp_parser_uncommitted_to_tentative_parse_p (parser
))
18901 cp_parser_skip_to_closing_parenthesis (parser
,
18902 /*recovering=*/true,
18903 /*or_comma=*/false,
18904 /*consume_paren=*/false);
18909 parser
->in_unbraced_linkage_specification_p
18910 = saved_in_unbraced_linkage_specification_p
;
18912 /* Reset implicit_template_scope if we are about to leave the function
18913 parameter list that introduced it. Note that for out-of-line member
18914 definitions, there will be one or more class scopes before we get to
18915 the template parameter scope. */
18917 if (cp_binding_level
*its
= parser
->implicit_template_scope
)
18918 if (cp_binding_level
*maybe_its
= current_binding_level
->level_chain
)
18920 while (maybe_its
->kind
== sk_class
)
18921 maybe_its
= maybe_its
->level_chain
;
18922 if (maybe_its
== its
)
18924 parser
->implicit_template_parms
= 0;
18925 parser
->implicit_template_scope
= 0;
18932 /* Parse a parameter declaration.
18934 parameter-declaration:
18935 decl-specifier-seq ... [opt] declarator
18936 decl-specifier-seq declarator = assignment-expression
18937 decl-specifier-seq ... [opt] abstract-declarator [opt]
18938 decl-specifier-seq abstract-declarator [opt] = assignment-expression
18940 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
18941 declares a template parameter. (In that case, a non-nested `>'
18942 token encountered during the parsing of the assignment-expression
18943 is not interpreted as a greater-than operator.)
18945 Returns a representation of the parameter, or NULL if an error
18946 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
18947 true iff the declarator is of the form "(p)". */
18949 static cp_parameter_declarator
*
18950 cp_parser_parameter_declaration (cp_parser
*parser
,
18951 bool template_parm_p
,
18952 bool *parenthesized_p
)
18954 int declares_class_or_enum
;
18955 cp_decl_specifier_seq decl_specifiers
;
18956 cp_declarator
*declarator
;
18957 tree default_argument
;
18958 cp_token
*token
= NULL
, *declarator_token_start
= NULL
;
18959 const char *saved_message
;
18961 /* In a template parameter, `>' is not an operator.
18965 When parsing a default template-argument for a non-type
18966 template-parameter, the first non-nested `>' is taken as the end
18967 of the template parameter-list rather than a greater-than
18970 /* Type definitions may not appear in parameter types. */
18971 saved_message
= parser
->type_definition_forbidden_message
;
18972 parser
->type_definition_forbidden_message
18973 = G_("types may not be defined in parameter types");
18975 /* Parse the declaration-specifiers. */
18976 cp_parser_decl_specifier_seq (parser
,
18977 CP_PARSER_FLAGS_NONE
,
18979 &declares_class_or_enum
);
18981 /* Complain about missing 'typename' or other invalid type names. */
18982 if (!decl_specifiers
.any_type_specifiers_p
18983 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
18984 decl_specifiers
.type
= error_mark_node
;
18986 /* If an error occurred, there's no reason to attempt to parse the
18987 rest of the declaration. */
18988 if (cp_parser_error_occurred (parser
))
18990 parser
->type_definition_forbidden_message
= saved_message
;
18994 /* Peek at the next token. */
18995 token
= cp_lexer_peek_token (parser
->lexer
);
18997 /* If the next token is a `)', `,', `=', `>', or `...', then there
18998 is no declarator. However, when variadic templates are enabled,
18999 there may be a declarator following `...'. */
19000 if (token
->type
== CPP_CLOSE_PAREN
19001 || token
->type
== CPP_COMMA
19002 || token
->type
== CPP_EQ
19003 || token
->type
== CPP_GREATER
)
19006 if (parenthesized_p
)
19007 *parenthesized_p
= false;
19009 /* Otherwise, there should be a declarator. */
19012 bool saved_default_arg_ok_p
= parser
->default_arg_ok_p
;
19013 parser
->default_arg_ok_p
= false;
19015 /* After seeing a decl-specifier-seq, if the next token is not a
19016 "(", there is no possibility that the code is a valid
19017 expression. Therefore, if parsing tentatively, we commit at
19019 if (!parser
->in_template_argument_list_p
19020 /* In an expression context, having seen:
19024 we cannot be sure whether we are looking at a
19025 function-type (taking a "char" as a parameter) or a cast
19026 of some object of type "char" to "int". */
19027 && !parser
->in_type_id_in_expr_p
19028 && cp_parser_uncommitted_to_tentative_parse_p (parser
)
19029 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
)
19030 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_PAREN
))
19031 cp_parser_commit_to_tentative_parse (parser
);
19032 /* Parse the declarator. */
19033 declarator_token_start
= token
;
19034 declarator
= cp_parser_declarator (parser
,
19035 CP_PARSER_DECLARATOR_EITHER
,
19036 /*ctor_dtor_or_conv_p=*/NULL
,
19038 /*member_p=*/false,
19039 /*friend_p=*/false);
19040 parser
->default_arg_ok_p
= saved_default_arg_ok_p
;
19041 /* After the declarator, allow more attributes. */
19042 decl_specifiers
.attributes
19043 = chainon (decl_specifiers
.attributes
,
19044 cp_parser_attributes_opt (parser
));
19047 /* If the next token is an ellipsis, and we have not seen a
19048 declarator name, and the type of the declarator contains parameter
19049 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
19050 a parameter pack expansion expression. Otherwise, leave the
19051 ellipsis for a C-style variadic function. */
19052 token
= cp_lexer_peek_token (parser
->lexer
);
19053 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
19055 tree type
= decl_specifiers
.type
;
19057 if (type
&& DECL_P (type
))
19058 type
= TREE_TYPE (type
);
19061 && TREE_CODE (type
) != TYPE_PACK_EXPANSION
19062 && declarator_can_be_parameter_pack (declarator
)
19063 && (!declarator
|| !declarator
->parameter_pack_p
)
19064 && uses_parameter_packs (type
))
19066 /* Consume the `...'. */
19067 cp_lexer_consume_token (parser
->lexer
);
19068 maybe_warn_variadic_templates ();
19070 /* Build a pack expansion type */
19072 declarator
->parameter_pack_p
= true;
19074 decl_specifiers
.type
= make_pack_expansion (type
);
19078 /* The restriction on defining new types applies only to the type
19079 of the parameter, not to the default argument. */
19080 parser
->type_definition_forbidden_message
= saved_message
;
19082 /* If the next token is `=', then process a default argument. */
19083 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
19085 token
= cp_lexer_peek_token (parser
->lexer
);
19086 /* If we are defining a class, then the tokens that make up the
19087 default argument must be saved and processed later. */
19088 if (!template_parm_p
&& at_class_scope_p ()
19089 && TYPE_BEING_DEFINED (current_class_type
)
19090 && !LAMBDA_TYPE_P (current_class_type
))
19091 default_argument
= cp_parser_cache_defarg (parser
, /*nsdmi=*/false);
19092 /* Outside of a class definition, we can just parse the
19093 assignment-expression. */
19096 = cp_parser_default_argument (parser
, template_parm_p
);
19098 if (!parser
->default_arg_ok_p
)
19100 if (flag_permissive
)
19101 warning (0, "deprecated use of default argument for parameter of non-function");
19104 error_at (token
->location
,
19105 "default arguments are only "
19106 "permitted for function parameters");
19107 default_argument
= NULL_TREE
;
19110 else if ((declarator
&& declarator
->parameter_pack_p
)
19111 || (decl_specifiers
.type
19112 && PACK_EXPANSION_P (decl_specifiers
.type
)))
19114 /* Find the name of the parameter pack. */
19115 cp_declarator
*id_declarator
= declarator
;
19116 while (id_declarator
&& id_declarator
->kind
!= cdk_id
)
19117 id_declarator
= id_declarator
->declarator
;
19119 if (id_declarator
&& id_declarator
->kind
== cdk_id
)
19120 error_at (declarator_token_start
->location
,
19122 ? G_("template parameter pack %qD "
19123 "cannot have a default argument")
19124 : G_("parameter pack %qD cannot have "
19125 "a default argument"),
19126 id_declarator
->u
.id
.unqualified_name
);
19128 error_at (declarator_token_start
->location
,
19130 ? G_("template parameter pack cannot have "
19131 "a default argument")
19132 : G_("parameter pack cannot have a "
19133 "default argument"));
19135 default_argument
= NULL_TREE
;
19139 default_argument
= NULL_TREE
;
19141 return make_parameter_declarator (&decl_specifiers
,
19146 /* Parse a default argument and return it.
19148 TEMPLATE_PARM_P is true if this is a default argument for a
19149 non-type template parameter. */
19151 cp_parser_default_argument (cp_parser
*parser
, bool template_parm_p
)
19153 tree default_argument
= NULL_TREE
;
19154 bool saved_greater_than_is_operator_p
;
19155 bool saved_local_variables_forbidden_p
;
19156 bool non_constant_p
, is_direct_init
;
19158 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
19160 saved_greater_than_is_operator_p
= parser
->greater_than_is_operator_p
;
19161 parser
->greater_than_is_operator_p
= !template_parm_p
;
19162 /* Local variable names (and the `this' keyword) may not
19163 appear in a default argument. */
19164 saved_local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
19165 parser
->local_variables_forbidden_p
= true;
19166 /* Parse the assignment-expression. */
19167 if (template_parm_p
)
19168 push_deferring_access_checks (dk_no_deferred
);
19169 tree saved_class_ptr
= NULL_TREE
;
19170 tree saved_class_ref
= NULL_TREE
;
19171 /* The "this" pointer is not valid in a default argument. */
19174 saved_class_ptr
= current_class_ptr
;
19175 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
19176 saved_class_ref
= current_class_ref
;
19177 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
19180 = cp_parser_initializer (parser
, &is_direct_init
, &non_constant_p
);
19181 /* Restore the "this" pointer. */
19184 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
19185 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
19187 if (BRACE_ENCLOSED_INITIALIZER_P (default_argument
))
19188 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
19189 if (template_parm_p
)
19190 pop_deferring_access_checks ();
19191 parser
->greater_than_is_operator_p
= saved_greater_than_is_operator_p
;
19192 parser
->local_variables_forbidden_p
= saved_local_variables_forbidden_p
;
19194 return default_argument
;
19197 /* Parse a function-body.
19200 compound_statement */
19203 cp_parser_function_body (cp_parser
*parser
, bool in_function_try_block
)
19205 cp_parser_compound_statement (parser
, NULL
, in_function_try_block
, true);
19208 /* Parse a ctor-initializer-opt followed by a function-body. Return
19209 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
19210 is true we are parsing a function-try-block. */
19213 cp_parser_ctor_initializer_opt_and_function_body (cp_parser
*parser
,
19214 bool in_function_try_block
)
19217 bool ctor_initializer_p
;
19218 const bool check_body_p
=
19219 DECL_CONSTRUCTOR_P (current_function_decl
)
19220 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
);
19223 /* Begin the function body. */
19224 body
= begin_function_body ();
19225 /* Parse the optional ctor-initializer. */
19226 ctor_initializer_p
= cp_parser_ctor_initializer_opt (parser
);
19228 /* If we're parsing a constexpr constructor definition, we need
19229 to check that the constructor body is indeed empty. However,
19230 before we get to cp_parser_function_body lot of junk has been
19231 generated, so we can't just check that we have an empty block.
19232 Rather we take a snapshot of the outermost block, and check whether
19233 cp_parser_function_body changed its state. */
19236 list
= cur_stmt_list
;
19237 if (STATEMENT_LIST_TAIL (list
))
19238 last
= STATEMENT_LIST_TAIL (list
)->stmt
;
19240 /* Parse the function-body. */
19241 cp_parser_function_body (parser
, in_function_try_block
);
19243 check_constexpr_ctor_body (last
, list
, /*complain=*/true);
19244 /* Finish the function body. */
19245 finish_function_body (body
);
19247 return ctor_initializer_p
;
19250 /* Parse an initializer.
19253 = initializer-clause
19254 ( expression-list )
19256 Returns an expression representing the initializer. If no
19257 initializer is present, NULL_TREE is returned.
19259 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
19260 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
19261 set to TRUE if there is no initializer present. If there is an
19262 initializer, and it is not a constant-expression, *NON_CONSTANT_P
19263 is set to true; otherwise it is set to false. */
19266 cp_parser_initializer (cp_parser
* parser
, bool* is_direct_init
,
19267 bool* non_constant_p
)
19272 /* Peek at the next token. */
19273 token
= cp_lexer_peek_token (parser
->lexer
);
19275 /* Let our caller know whether or not this initializer was
19277 *is_direct_init
= (token
->type
!= CPP_EQ
);
19278 /* Assume that the initializer is constant. */
19279 *non_constant_p
= false;
19281 if (token
->type
== CPP_EQ
)
19283 /* Consume the `='. */
19284 cp_lexer_consume_token (parser
->lexer
);
19285 /* Parse the initializer-clause. */
19286 init
= cp_parser_initializer_clause (parser
, non_constant_p
);
19288 else if (token
->type
== CPP_OPEN_PAREN
)
19290 vec
<tree
, va_gc
> *vec
;
19291 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
19293 /*allow_expansion_p=*/true,
19296 return error_mark_node
;
19297 init
= build_tree_list_vec (vec
);
19298 release_tree_vector (vec
);
19300 else if (token
->type
== CPP_OPEN_BRACE
)
19302 cp_lexer_set_source_position (parser
->lexer
);
19303 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
19304 init
= cp_parser_braced_list (parser
, non_constant_p
);
19305 CONSTRUCTOR_IS_DIRECT_INIT (init
) = 1;
19309 /* Anything else is an error. */
19310 cp_parser_error (parser
, "expected initializer");
19311 init
= error_mark_node
;
19317 /* Parse an initializer-clause.
19319 initializer-clause:
19320 assignment-expression
19323 Returns an expression representing the initializer.
19325 If the `assignment-expression' production is used the value
19326 returned is simply a representation for the expression.
19328 Otherwise, calls cp_parser_braced_list. */
19331 cp_parser_initializer_clause (cp_parser
* parser
, bool* non_constant_p
)
19335 /* Assume the expression is constant. */
19336 *non_constant_p
= false;
19338 /* If it is not a `{', then we are looking at an
19339 assignment-expression. */
19340 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
19343 = cp_parser_constant_expression (parser
,
19344 /*allow_non_constant_p=*/true,
19348 initializer
= cp_parser_braced_list (parser
, non_constant_p
);
19350 return initializer
;
19353 /* Parse a brace-enclosed initializer list.
19356 { initializer-list , [opt] }
19359 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
19360 the elements of the initializer-list (or NULL, if the last
19361 production is used). The TREE_TYPE for the CONSTRUCTOR will be
19362 NULL_TREE. There is no way to detect whether or not the optional
19363 trailing `,' was provided. NON_CONSTANT_P is as for
19364 cp_parser_initializer. */
19367 cp_parser_braced_list (cp_parser
* parser
, bool* non_constant_p
)
19371 /* Consume the `{' token. */
19372 cp_lexer_consume_token (parser
->lexer
);
19373 /* Create a CONSTRUCTOR to represent the braced-initializer. */
19374 initializer
= make_node (CONSTRUCTOR
);
19375 /* If it's not a `}', then there is a non-trivial initializer. */
19376 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_BRACE
))
19378 /* Parse the initializer list. */
19379 CONSTRUCTOR_ELTS (initializer
)
19380 = cp_parser_initializer_list (parser
, non_constant_p
);
19381 /* A trailing `,' token is allowed. */
19382 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
19383 cp_lexer_consume_token (parser
->lexer
);
19386 *non_constant_p
= false;
19387 /* Now, there should be a trailing `}'. */
19388 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
19389 TREE_TYPE (initializer
) = init_list_type_node
;
19390 return initializer
;
19393 /* Consume tokens up to, and including, the next non-nested closing `]'.
19394 Returns true iff we found a closing `]'. */
19397 cp_parser_skip_to_closing_square_bracket (cp_parser
*parser
)
19399 unsigned square_depth
= 0;
19403 cp_token
* token
= cp_lexer_peek_token (parser
->lexer
);
19405 switch (token
->type
)
19408 case CPP_PRAGMA_EOL
:
19409 /* If we've run out of tokens, then there is no closing `]'. */
19412 case CPP_OPEN_SQUARE
:
19416 case CPP_CLOSE_SQUARE
:
19417 if (!square_depth
--)
19419 cp_lexer_consume_token (parser
->lexer
);
19428 /* Consume the token. */
19429 cp_lexer_consume_token (parser
->lexer
);
19433 /* Return true if we are looking at an array-designator, false otherwise. */
19436 cp_parser_array_designator_p (cp_parser
*parser
)
19438 /* Consume the `['. */
19439 cp_lexer_consume_token (parser
->lexer
);
19441 cp_lexer_save_tokens (parser
->lexer
);
19443 /* Skip tokens until the next token is a closing square bracket.
19444 If we find the closing `]', and the next token is a `=', then
19445 we are looking at an array designator. */
19446 bool array_designator_p
19447 = (cp_parser_skip_to_closing_square_bracket (parser
)
19448 && cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
));
19450 /* Roll back the tokens we skipped. */
19451 cp_lexer_rollback_tokens (parser
->lexer
);
19453 return array_designator_p
;
19456 /* Parse an initializer-list.
19459 initializer-clause ... [opt]
19460 initializer-list , initializer-clause ... [opt]
19465 designation initializer-clause ...[opt]
19466 initializer-list , designation initializer-clause ...[opt]
19471 [ constant-expression ] =
19473 Returns a vec of constructor_elt. The VALUE of each elt is an expression
19474 for the initializer. If the INDEX of the elt is non-NULL, it is the
19475 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
19476 as for cp_parser_initializer. */
19478 static vec
<constructor_elt
, va_gc
> *
19479 cp_parser_initializer_list (cp_parser
* parser
, bool* non_constant_p
)
19481 vec
<constructor_elt
, va_gc
> *v
= NULL
;
19483 /* Assume all of the expressions are constant. */
19484 *non_constant_p
= false;
19486 /* Parse the rest of the list. */
19492 bool clause_non_constant_p
;
19494 /* If the next token is an identifier and the following one is a
19495 colon, we are looking at the GNU designated-initializer
19497 if (cp_parser_allow_gnu_extensions_p (parser
)
19498 && cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
19499 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_COLON
)
19501 /* Warn the user that they are using an extension. */
19502 pedwarn (input_location
, OPT_Wpedantic
,
19503 "ISO C++ does not allow designated initializers");
19504 /* Consume the identifier. */
19505 designator
= cp_lexer_consume_token (parser
->lexer
)->u
.value
;
19506 /* Consume the `:'. */
19507 cp_lexer_consume_token (parser
->lexer
);
19509 /* Also handle the C99 syntax, '. id ='. */
19510 else if (cp_parser_allow_gnu_extensions_p (parser
)
19511 && cp_lexer_next_token_is (parser
->lexer
, CPP_DOT
)
19512 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_NAME
19513 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_EQ
)
19515 /* Warn the user that they are using an extension. */
19516 pedwarn (input_location
, OPT_Wpedantic
,
19517 "ISO C++ does not allow C99 designated initializers");
19518 /* Consume the `.'. */
19519 cp_lexer_consume_token (parser
->lexer
);
19520 /* Consume the identifier. */
19521 designator
= cp_lexer_consume_token (parser
->lexer
)->u
.value
;
19522 /* Consume the `='. */
19523 cp_lexer_consume_token (parser
->lexer
);
19525 /* Also handle C99 array designators, '[ const ] ='. */
19526 else if (cp_parser_allow_gnu_extensions_p (parser
)
19527 && !c_dialect_objc ()
19528 && cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
19530 /* In C++11, [ could start a lambda-introducer. */
19531 bool non_const
= false;
19533 cp_parser_parse_tentatively (parser
);
19535 if (!cp_parser_array_designator_p (parser
))
19537 cp_parser_simulate_error (parser
);
19538 designator
= NULL_TREE
;
19542 designator
= cp_parser_constant_expression (parser
, true,
19544 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
19545 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
19548 if (!cp_parser_parse_definitely (parser
))
19549 designator
= NULL_TREE
;
19550 else if (non_const
)
19551 require_potential_rvalue_constant_expression (designator
);
19554 designator
= NULL_TREE
;
19556 /* Parse the initializer. */
19557 initializer
= cp_parser_initializer_clause (parser
,
19558 &clause_non_constant_p
);
19559 /* If any clause is non-constant, so is the entire initializer. */
19560 if (clause_non_constant_p
)
19561 *non_constant_p
= true;
19563 /* If we have an ellipsis, this is an initializer pack
19565 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
19567 /* Consume the `...'. */
19568 cp_lexer_consume_token (parser
->lexer
);
19570 /* Turn the initializer into an initializer expansion. */
19571 initializer
= make_pack_expansion (initializer
);
19574 /* Add it to the vector. */
19575 CONSTRUCTOR_APPEND_ELT (v
, designator
, initializer
);
19577 /* If the next token is not a comma, we have reached the end of
19579 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
19582 /* Peek at the next token. */
19583 token
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
19584 /* If the next token is a `}', then we're still done. An
19585 initializer-clause can have a trailing `,' after the
19586 initializer-list and before the closing `}'. */
19587 if (token
->type
== CPP_CLOSE_BRACE
)
19590 /* Consume the `,' token. */
19591 cp_lexer_consume_token (parser
->lexer
);
19597 /* Classes [gram.class] */
19599 /* Parse a class-name.
19605 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
19606 to indicate that names looked up in dependent types should be
19607 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
19608 keyword has been used to indicate that the name that appears next
19609 is a template. TAG_TYPE indicates the explicit tag given before
19610 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
19611 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
19612 is the class being defined in a class-head.
19614 Returns the TYPE_DECL representing the class. */
19617 cp_parser_class_name (cp_parser
*parser
,
19618 bool typename_keyword_p
,
19619 bool template_keyword_p
,
19620 enum tag_types tag_type
,
19621 bool check_dependency_p
,
19623 bool is_declaration
)
19629 tree identifier
= NULL_TREE
;
19631 /* All class-names start with an identifier. */
19632 token
= cp_lexer_peek_token (parser
->lexer
);
19633 if (token
->type
!= CPP_NAME
&& token
->type
!= CPP_TEMPLATE_ID
)
19635 cp_parser_error (parser
, "expected class-name");
19636 return error_mark_node
;
19639 /* PARSER->SCOPE can be cleared when parsing the template-arguments
19640 to a template-id, so we save it here. */
19641 scope
= parser
->scope
;
19642 if (scope
== error_mark_node
)
19643 return error_mark_node
;
19645 /* Any name names a type if we're following the `typename' keyword
19646 in a qualified name where the enclosing scope is type-dependent. */
19647 typename_p
= (typename_keyword_p
&& scope
&& TYPE_P (scope
)
19648 && dependent_type_p (scope
));
19649 /* Handle the common case (an identifier, but not a template-id)
19651 if (token
->type
== CPP_NAME
19652 && !cp_parser_nth_token_starts_template_argument_list_p (parser
, 2))
19654 cp_token
*identifier_token
;
19657 /* Look for the identifier. */
19658 identifier_token
= cp_lexer_peek_token (parser
->lexer
);
19659 ambiguous_p
= identifier_token
->error_reported
;
19660 identifier
= cp_parser_identifier (parser
);
19661 /* If the next token isn't an identifier, we are certainly not
19662 looking at a class-name. */
19663 if (identifier
== error_mark_node
)
19664 decl
= error_mark_node
;
19665 /* If we know this is a type-name, there's no need to look it
19667 else if (typename_p
)
19671 tree ambiguous_decls
;
19672 /* If we already know that this lookup is ambiguous, then
19673 we've already issued an error message; there's no reason
19677 cp_parser_simulate_error (parser
);
19678 return error_mark_node
;
19680 /* If the next token is a `::', then the name must be a type
19683 [basic.lookup.qual]
19685 During the lookup for a name preceding the :: scope
19686 resolution operator, object, function, and enumerator
19687 names are ignored. */
19688 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
19689 tag_type
= typename_type
;
19690 /* Look up the name. */
19691 decl
= cp_parser_lookup_name (parser
, identifier
,
19693 /*is_template=*/false,
19694 /*is_namespace=*/false,
19695 check_dependency_p
,
19697 identifier_token
->location
);
19698 if (ambiguous_decls
)
19700 if (cp_parser_parsing_tentatively (parser
))
19701 cp_parser_simulate_error (parser
);
19702 return error_mark_node
;
19708 /* Try a template-id. */
19709 decl
= cp_parser_template_id (parser
, template_keyword_p
,
19710 check_dependency_p
,
19713 if (decl
== error_mark_node
)
19714 return error_mark_node
;
19717 decl
= cp_parser_maybe_treat_template_as_class (decl
, class_head_p
);
19719 /* If this is a typename, create a TYPENAME_TYPE. */
19720 if (typename_p
&& decl
!= error_mark_node
)
19722 decl
= make_typename_type (scope
, decl
, typename_type
,
19723 /*complain=*/tf_error
);
19724 if (decl
!= error_mark_node
)
19725 decl
= TYPE_NAME (decl
);
19728 decl
= strip_using_decl (decl
);
19730 /* Check to see that it is really the name of a class. */
19731 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
19732 && identifier_p (TREE_OPERAND (decl
, 0))
19733 && cp_lexer_next_token_is (parser
->lexer
, CPP_SCOPE
))
19734 /* Situations like this:
19736 template <typename T> struct A {
19737 typename T::template X<int>::I i;
19740 are problematic. Is `T::template X<int>' a class-name? The
19741 standard does not seem to be definitive, but there is no other
19742 valid interpretation of the following `::'. Therefore, those
19743 names are considered class-names. */
19745 decl
= make_typename_type (scope
, decl
, tag_type
, tf_error
);
19746 if (decl
!= error_mark_node
)
19747 decl
= TYPE_NAME (decl
);
19749 else if (TREE_CODE (decl
) != TYPE_DECL
19750 || TREE_TYPE (decl
) == error_mark_node
19751 || !MAYBE_CLASS_TYPE_P (TREE_TYPE (decl
))
19752 /* In Objective-C 2.0, a classname followed by '.' starts a
19753 dot-syntax expression, and it's not a type-name. */
19754 || (c_dialect_objc ()
19755 && cp_lexer_peek_token (parser
->lexer
)->type
== CPP_DOT
19756 && objc_is_class_name (decl
)))
19757 decl
= error_mark_node
;
19759 if (decl
== error_mark_node
)
19760 cp_parser_error (parser
, "expected class-name");
19761 else if (identifier
&& !parser
->scope
)
19762 maybe_note_name_used_in_class (identifier
, decl
);
19767 /* Parse a class-specifier.
19770 class-head { member-specification [opt] }
19772 Returns the TREE_TYPE representing the class. */
19775 cp_parser_class_specifier_1 (cp_parser
* parser
)
19778 tree attributes
= NULL_TREE
;
19779 bool nested_name_specifier_p
;
19780 unsigned saved_num_template_parameter_lists
;
19781 bool saved_in_function_body
;
19782 unsigned char in_statement
;
19783 bool in_switch_statement_p
;
19784 bool saved_in_unbraced_linkage_specification_p
;
19785 tree old_scope
= NULL_TREE
;
19786 tree scope
= NULL_TREE
;
19787 cp_token
*closing_brace
;
19789 push_deferring_access_checks (dk_no_deferred
);
19791 /* Parse the class-head. */
19792 type
= cp_parser_class_head (parser
,
19793 &nested_name_specifier_p
);
19794 /* If the class-head was a semantic disaster, skip the entire body
19798 cp_parser_skip_to_end_of_block_or_statement (parser
);
19799 pop_deferring_access_checks ();
19800 return error_mark_node
;
19803 /* Look for the `{'. */
19804 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
19806 pop_deferring_access_checks ();
19807 return error_mark_node
;
19810 cp_ensure_no_omp_declare_simd (parser
);
19812 /* Issue an error message if type-definitions are forbidden here. */
19813 cp_parser_check_type_definition (parser
);
19814 /* Remember that we are defining one more class. */
19815 ++parser
->num_classes_being_defined
;
19816 /* Inside the class, surrounding template-parameter-lists do not
19818 saved_num_template_parameter_lists
19819 = parser
->num_template_parameter_lists
;
19820 parser
->num_template_parameter_lists
= 0;
19821 /* We are not in a function body. */
19822 saved_in_function_body
= parser
->in_function_body
;
19823 parser
->in_function_body
= false;
19824 /* Or in a loop. */
19825 in_statement
= parser
->in_statement
;
19826 parser
->in_statement
= 0;
19827 /* Or in a switch. */
19828 in_switch_statement_p
= parser
->in_switch_statement_p
;
19829 parser
->in_switch_statement_p
= false;
19830 /* We are not immediately inside an extern "lang" block. */
19831 saved_in_unbraced_linkage_specification_p
19832 = parser
->in_unbraced_linkage_specification_p
;
19833 parser
->in_unbraced_linkage_specification_p
= false;
19835 /* Start the class. */
19836 if (nested_name_specifier_p
)
19838 scope
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (type
));
19839 old_scope
= push_inner_scope (scope
);
19841 type
= begin_class_definition (type
);
19843 if (type
== error_mark_node
)
19844 /* If the type is erroneous, skip the entire body of the class. */
19845 cp_parser_skip_to_closing_brace (parser
);
19847 /* Parse the member-specification. */
19848 cp_parser_member_specification_opt (parser
);
19850 /* Look for the trailing `}'. */
19851 closing_brace
= cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
19852 /* Look for trailing attributes to apply to this class. */
19853 if (cp_parser_allow_gnu_extensions_p (parser
))
19854 attributes
= cp_parser_gnu_attributes_opt (parser
);
19855 if (type
!= error_mark_node
)
19856 type
= finish_struct (type
, attributes
);
19857 if (nested_name_specifier_p
)
19858 pop_inner_scope (old_scope
, scope
);
19860 /* We've finished a type definition. Check for the common syntax
19861 error of forgetting a semicolon after the definition. We need to
19862 be careful, as we can't just check for not-a-semicolon and be done
19863 with it; the user might have typed:
19865 class X { } c = ...;
19866 class X { } *p = ...;
19868 and so forth. Instead, enumerate all the possible tokens that
19869 might follow this production; if we don't see one of them, then
19870 complain and silently insert the semicolon. */
19872 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
19873 bool want_semicolon
= true;
19875 if (cp_next_tokens_can_be_std_attribute_p (parser
))
19876 /* Don't try to parse c++11 attributes here. As per the
19877 grammar, that should be a task for
19878 cp_parser_decl_specifier_seq. */
19879 want_semicolon
= false;
19881 switch (token
->type
)
19884 case CPP_SEMICOLON
:
19887 case CPP_OPEN_PAREN
:
19888 case CPP_CLOSE_PAREN
:
19890 want_semicolon
= false;
19893 /* While it's legal for type qualifiers and storage class
19894 specifiers to follow type definitions in the grammar, only
19895 compiler testsuites contain code like that. Assume that if
19896 we see such code, then what we're really seeing is a case
19900 const <type> var = ...;
19905 static <type> func (...) ...
19907 i.e. the qualifier or specifier applies to the next
19908 declaration. To do so, however, we need to look ahead one
19909 more token to see if *that* token is a type specifier.
19911 This code could be improved to handle:
19914 static const <type> var = ...; */
19916 if (keyword_is_decl_specifier (token
->keyword
))
19918 cp_token
*lookahead
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
19920 /* Handling user-defined types here would be nice, but very
19923 = (lookahead
->type
== CPP_KEYWORD
19924 && keyword_begins_type_specifier (lookahead
->keyword
));
19931 /* If we don't have a type, then something is very wrong and we
19932 shouldn't try to do anything clever. Likewise for not seeing the
19934 if (closing_brace
&& TYPE_P (type
) && want_semicolon
)
19936 cp_token_position prev
19937 = cp_lexer_previous_token_position (parser
->lexer
);
19938 cp_token
*prev_token
= cp_lexer_token_at (parser
->lexer
, prev
);
19939 location_t loc
= prev_token
->location
;
19941 if (CLASSTYPE_DECLARED_CLASS (type
))
19942 error_at (loc
, "expected %<;%> after class definition");
19943 else if (TREE_CODE (type
) == RECORD_TYPE
)
19944 error_at (loc
, "expected %<;%> after struct definition");
19945 else if (TREE_CODE (type
) == UNION_TYPE
)
19946 error_at (loc
, "expected %<;%> after union definition");
19948 gcc_unreachable ();
19950 /* Unget one token and smash it to look as though we encountered
19951 a semicolon in the input stream. */
19952 cp_lexer_set_token_position (parser
->lexer
, prev
);
19953 token
= cp_lexer_peek_token (parser
->lexer
);
19954 token
->type
= CPP_SEMICOLON
;
19955 token
->keyword
= RID_MAX
;
19959 /* If this class is not itself within the scope of another class,
19960 then we need to parse the bodies of all of the queued function
19961 definitions. Note that the queued functions defined in a class
19962 are not always processed immediately following the
19963 class-specifier for that class. Consider:
19966 struct B { void f() { sizeof (A); } };
19969 If `f' were processed before the processing of `A' were
19970 completed, there would be no way to compute the size of `A'.
19971 Note that the nesting we are interested in here is lexical --
19972 not the semantic nesting given by TYPE_CONTEXT. In particular,
19975 struct A { struct B; };
19976 struct A::B { void f() { } };
19978 there is no need to delay the parsing of `A::B::f'. */
19979 if (--parser
->num_classes_being_defined
== 0)
19982 tree class_type
= NULL_TREE
;
19983 tree pushed_scope
= NULL_TREE
;
19985 cp_default_arg_entry
*e
;
19986 tree save_ccp
, save_ccr
;
19988 /* In a first pass, parse default arguments to the functions.
19989 Then, in a second pass, parse the bodies of the functions.
19990 This two-phased approach handles cases like:
19998 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_default_args
, ix
, e
)
20001 /* If there are default arguments that have not yet been processed,
20002 take care of them now. */
20003 if (class_type
!= e
->class_type
)
20006 pop_scope (pushed_scope
);
20007 class_type
= e
->class_type
;
20008 pushed_scope
= push_scope (class_type
);
20010 /* Make sure that any template parameters are in scope. */
20011 maybe_begin_member_template_processing (decl
);
20012 /* Parse the default argument expressions. */
20013 cp_parser_late_parsing_default_args (parser
, decl
);
20014 /* Remove any template parameters from the symbol table. */
20015 maybe_end_member_template_processing ();
20017 vec_safe_truncate (unparsed_funs_with_default_args
, 0);
20018 /* Now parse any NSDMIs. */
20019 save_ccp
= current_class_ptr
;
20020 save_ccr
= current_class_ref
;
20021 FOR_EACH_VEC_SAFE_ELT (unparsed_nsdmis
, ix
, decl
)
20023 if (class_type
!= DECL_CONTEXT (decl
))
20026 pop_scope (pushed_scope
);
20027 class_type
= DECL_CONTEXT (decl
);
20028 pushed_scope
= push_scope (class_type
);
20030 inject_this_parameter (class_type
, TYPE_UNQUALIFIED
);
20031 cp_parser_late_parsing_nsdmi (parser
, decl
);
20033 vec_safe_truncate (unparsed_nsdmis
, 0);
20034 current_class_ptr
= save_ccp
;
20035 current_class_ref
= save_ccr
;
20037 pop_scope (pushed_scope
);
20039 /* Now do some post-NSDMI bookkeeping. */
20040 FOR_EACH_VEC_SAFE_ELT (unparsed_classes
, ix
, class_type
)
20041 after_nsdmi_defaulted_late_checks (class_type
);
20042 vec_safe_truncate (unparsed_classes
, 0);
20043 after_nsdmi_defaulted_late_checks (type
);
20045 /* Now parse the body of the functions. */
20048 /* OpenMP UDRs need to be parsed before all other functions. */
20049 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions
, ix
, decl
)
20050 if (DECL_OMP_DECLARE_REDUCTION_P (decl
))
20051 cp_parser_late_parsing_for_member (parser
, decl
);
20052 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions
, ix
, decl
)
20053 if (!DECL_OMP_DECLARE_REDUCTION_P (decl
))
20054 cp_parser_late_parsing_for_member (parser
, decl
);
20057 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions
, ix
, decl
)
20058 cp_parser_late_parsing_for_member (parser
, decl
);
20059 vec_safe_truncate (unparsed_funs_with_definitions
, 0);
20062 vec_safe_push (unparsed_classes
, type
);
20064 /* Put back any saved access checks. */
20065 pop_deferring_access_checks ();
20067 /* Restore saved state. */
20068 parser
->in_switch_statement_p
= in_switch_statement_p
;
20069 parser
->in_statement
= in_statement
;
20070 parser
->in_function_body
= saved_in_function_body
;
20071 parser
->num_template_parameter_lists
20072 = saved_num_template_parameter_lists
;
20073 parser
->in_unbraced_linkage_specification_p
20074 = saved_in_unbraced_linkage_specification_p
;
20080 cp_parser_class_specifier (cp_parser
* parser
)
20083 timevar_push (TV_PARSE_STRUCT
);
20084 ret
= cp_parser_class_specifier_1 (parser
);
20085 timevar_pop (TV_PARSE_STRUCT
);
20089 /* Parse a class-head.
20092 class-key identifier [opt] base-clause [opt]
20093 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
20094 class-key nested-name-specifier [opt] template-id
20097 class-virt-specifier:
20101 class-key attributes identifier [opt] base-clause [opt]
20102 class-key attributes nested-name-specifier identifier base-clause [opt]
20103 class-key attributes nested-name-specifier [opt] template-id
20106 Upon return BASES is initialized to the list of base classes (or
20107 NULL, if there are none) in the same form returned by
20108 cp_parser_base_clause.
20110 Returns the TYPE of the indicated class. Sets
20111 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
20112 involving a nested-name-specifier was used, and FALSE otherwise.
20114 Returns error_mark_node if this is not a class-head.
20116 Returns NULL_TREE if the class-head is syntactically valid, but
20117 semantically invalid in a way that means we should skip the entire
20118 body of the class. */
20121 cp_parser_class_head (cp_parser
* parser
,
20122 bool* nested_name_specifier_p
)
20124 tree nested_name_specifier
;
20125 enum tag_types class_key
;
20126 tree id
= NULL_TREE
;
20127 tree type
= NULL_TREE
;
20130 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
20131 bool template_id_p
= false;
20132 bool qualified_p
= false;
20133 bool invalid_nested_name_p
= false;
20134 bool invalid_explicit_specialization_p
= false;
20135 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
20136 tree pushed_scope
= NULL_TREE
;
20137 unsigned num_templates
;
20138 cp_token
*type_start_token
= NULL
, *nested_name_specifier_token_start
= NULL
;
20139 /* Assume no nested-name-specifier will be present. */
20140 *nested_name_specifier_p
= false;
20141 /* Assume no template parameter lists will be used in defining the
20144 parser
->colon_corrects_to_scope_p
= false;
20146 /* Look for the class-key. */
20147 class_key
= cp_parser_class_key (parser
);
20148 if (class_key
== none_type
)
20149 return error_mark_node
;
20151 /* Parse the attributes. */
20152 attributes
= cp_parser_attributes_opt (parser
);
20154 /* If the next token is `::', that is invalid -- but sometimes
20155 people do try to write:
20159 Handle this gracefully by accepting the extra qualifier, and then
20160 issuing an error about it later if this really is a
20161 class-head. If it turns out just to be an elaborated type
20162 specifier, remain silent. */
20163 if (cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false))
20164 qualified_p
= true;
20166 push_deferring_access_checks (dk_no_check
);
20168 /* Determine the name of the class. Begin by looking for an
20169 optional nested-name-specifier. */
20170 nested_name_specifier_token_start
= cp_lexer_peek_token (parser
->lexer
);
20171 nested_name_specifier
20172 = cp_parser_nested_name_specifier_opt (parser
,
20173 /*typename_keyword_p=*/false,
20174 /*check_dependency_p=*/false,
20176 /*is_declaration=*/false);
20177 /* If there was a nested-name-specifier, then there *must* be an
20179 if (nested_name_specifier
)
20181 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20182 /* Although the grammar says `identifier', it really means
20183 `class-name' or `template-name'. You are only allowed to
20184 define a class that has already been declared with this
20187 The proposed resolution for Core Issue 180 says that wherever
20188 you see `class T::X' you should treat `X' as a type-name.
20190 It is OK to define an inaccessible class; for example:
20192 class A { class B; };
20195 We do not know if we will see a class-name, or a
20196 template-name. We look for a class-name first, in case the
20197 class-name is a template-id; if we looked for the
20198 template-name first we would stop after the template-name. */
20199 cp_parser_parse_tentatively (parser
);
20200 type
= cp_parser_class_name (parser
,
20201 /*typename_keyword_p=*/false,
20202 /*template_keyword_p=*/false,
20204 /*check_dependency_p=*/false,
20205 /*class_head_p=*/true,
20206 /*is_declaration=*/false);
20207 /* If that didn't work, ignore the nested-name-specifier. */
20208 if (!cp_parser_parse_definitely (parser
))
20210 invalid_nested_name_p
= true;
20211 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20212 id
= cp_parser_identifier (parser
);
20213 if (id
== error_mark_node
)
20216 /* If we could not find a corresponding TYPE, treat this
20217 declaration like an unqualified declaration. */
20218 if (type
== error_mark_node
)
20219 nested_name_specifier
= NULL_TREE
;
20220 /* Otherwise, count the number of templates used in TYPE and its
20221 containing scopes. */
20226 for (scope
= TREE_TYPE (type
);
20227 scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
;
20228 scope
= get_containing_scope (scope
))
20230 && CLASS_TYPE_P (scope
)
20231 && CLASSTYPE_TEMPLATE_INFO (scope
)
20232 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope
))
20233 && (!CLASSTYPE_TEMPLATE_SPECIALIZATION (scope
)
20234 || uses_template_parms (CLASSTYPE_TI_ARGS (scope
))))
20238 /* Otherwise, the identifier is optional. */
20241 /* We don't know whether what comes next is a template-id,
20242 an identifier, or nothing at all. */
20243 cp_parser_parse_tentatively (parser
);
20244 /* Check for a template-id. */
20245 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20246 id
= cp_parser_template_id (parser
,
20247 /*template_keyword_p=*/false,
20248 /*check_dependency_p=*/true,
20250 /*is_declaration=*/true);
20251 /* If that didn't work, it could still be an identifier. */
20252 if (!cp_parser_parse_definitely (parser
))
20254 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
20256 type_start_token
= cp_lexer_peek_token (parser
->lexer
);
20257 id
= cp_parser_identifier (parser
);
20264 template_id_p
= true;
20269 pop_deferring_access_checks ();
20273 cp_parser_check_for_invalid_template_id (parser
, id
,
20275 type_start_token
->location
);
20277 virt_specifiers
= cp_parser_virt_specifier_seq_opt (parser
);
20279 /* If it's not a `:' or a `{' then we can't really be looking at a
20280 class-head, since a class-head only appears as part of a
20281 class-specifier. We have to detect this situation before calling
20282 xref_tag, since that has irreversible side-effects. */
20283 if (!cp_parser_next_token_starts_class_definition_p (parser
))
20285 cp_parser_error (parser
, "expected %<{%> or %<:%>");
20286 type
= error_mark_node
;
20290 /* At this point, we're going ahead with the class-specifier, even
20291 if some other problem occurs. */
20292 cp_parser_commit_to_tentative_parse (parser
);
20293 if (virt_specifiers
& VIRT_SPEC_OVERRIDE
)
20295 cp_parser_error (parser
,
20296 "cannot specify %<override%> for a class");
20297 type
= error_mark_node
;
20300 /* Issue the error about the overly-qualified name now. */
20303 cp_parser_error (parser
,
20304 "global qualification of class name is invalid");
20305 type
= error_mark_node
;
20308 else if (invalid_nested_name_p
)
20310 cp_parser_error (parser
,
20311 "qualified name does not name a class");
20312 type
= error_mark_node
;
20315 else if (nested_name_specifier
)
20319 /* Reject typedef-names in class heads. */
20320 if (!DECL_IMPLICIT_TYPEDEF_P (type
))
20322 error_at (type_start_token
->location
,
20323 "invalid class name in declaration of %qD",
20329 /* Figure out in what scope the declaration is being placed. */
20330 scope
= current_scope ();
20331 /* If that scope does not contain the scope in which the
20332 class was originally declared, the program is invalid. */
20333 if (scope
&& !is_ancestor (scope
, nested_name_specifier
))
20335 if (at_namespace_scope_p ())
20336 error_at (type_start_token
->location
,
20337 "declaration of %qD in namespace %qD which does not "
20339 type
, scope
, nested_name_specifier
);
20341 error_at (type_start_token
->location
,
20342 "declaration of %qD in %qD which does not enclose %qD",
20343 type
, scope
, nested_name_specifier
);
20349 A declarator-id shall not be qualified except for the
20350 definition of a ... nested class outside of its class
20351 ... [or] the definition or explicit instantiation of a
20352 class member of a namespace outside of its namespace. */
20353 if (scope
== nested_name_specifier
)
20355 permerror (nested_name_specifier_token_start
->location
,
20356 "extra qualification not allowed");
20357 nested_name_specifier
= NULL_TREE
;
20361 /* An explicit-specialization must be preceded by "template <>". If
20362 it is not, try to recover gracefully. */
20363 if (at_namespace_scope_p ()
20364 && parser
->num_template_parameter_lists
== 0
20367 error_at (type_start_token
->location
,
20368 "an explicit specialization must be preceded by %<template <>%>");
20369 invalid_explicit_specialization_p
= true;
20370 /* Take the same action that would have been taken by
20371 cp_parser_explicit_specialization. */
20372 ++parser
->num_template_parameter_lists
;
20373 begin_specialization ();
20375 /* There must be no "return" statements between this point and the
20376 end of this function; set "type "to the correct return value and
20377 use "goto done;" to return. */
20378 /* Make sure that the right number of template parameters were
20380 if (!cp_parser_check_template_parameters (parser
, num_templates
,
20381 type_start_token
->location
,
20382 /*declarator=*/NULL
))
20384 /* If something went wrong, there is no point in even trying to
20385 process the class-definition. */
20390 /* Look up the type. */
20393 if (TREE_CODE (id
) == TEMPLATE_ID_EXPR
20394 && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id
, 0))
20395 || TREE_CODE (TREE_OPERAND (id
, 0)) == OVERLOAD
))
20397 error_at (type_start_token
->location
,
20398 "function template %qD redeclared as a class template", id
);
20399 type
= error_mark_node
;
20403 type
= TREE_TYPE (id
);
20404 type
= maybe_process_partial_specialization (type
);
20406 if (nested_name_specifier
)
20407 pushed_scope
= push_scope (nested_name_specifier
);
20409 else if (nested_name_specifier
)
20415 template <typename T> struct S { struct T };
20416 template <typename T> struct S<T>::T { };
20418 we will get a TYPENAME_TYPE when processing the definition of
20419 `S::T'. We need to resolve it to the actual type before we
20420 try to define it. */
20421 if (TREE_CODE (TREE_TYPE (type
)) == TYPENAME_TYPE
)
20423 class_type
= resolve_typename_type (TREE_TYPE (type
),
20424 /*only_current_p=*/false);
20425 if (TREE_CODE (class_type
) != TYPENAME_TYPE
)
20426 type
= TYPE_NAME (class_type
);
20429 cp_parser_error (parser
, "could not resolve typename type");
20430 type
= error_mark_node
;
20434 if (maybe_process_partial_specialization (TREE_TYPE (type
))
20435 == error_mark_node
)
20441 class_type
= current_class_type
;
20442 /* Enter the scope indicated by the nested-name-specifier. */
20443 pushed_scope
= push_scope (nested_name_specifier
);
20444 /* Get the canonical version of this type. */
20445 type
= TYPE_MAIN_DECL (TREE_TYPE (type
));
20446 /* Call push_template_decl if it seems like we should be defining a
20447 template either from the template headers or the type we're
20448 defining, so that we diagnose both extra and missing headers. */
20449 if ((PROCESSING_REAL_TEMPLATE_DECL_P ()
20450 || CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (type
)))
20451 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type
)))
20453 type
= push_template_decl (type
);
20454 if (type
== error_mark_node
)
20461 type
= TREE_TYPE (type
);
20462 *nested_name_specifier_p
= true;
20464 else /* The name is not a nested name. */
20466 /* If the class was unnamed, create a dummy name. */
20468 id
= make_anon_name ();
20469 type
= xref_tag (class_key
, id
, /*tag_scope=*/ts_current
,
20470 parser
->num_template_parameter_lists
);
20473 /* Indicate whether this class was declared as a `class' or as a
20475 if (TREE_CODE (type
) == RECORD_TYPE
)
20476 CLASSTYPE_DECLARED_CLASS (type
) = (class_key
== class_type
);
20477 cp_parser_check_class_key (class_key
, type
);
20479 /* If this type was already complete, and we see another definition,
20480 that's an error. */
20481 if (type
!= error_mark_node
&& COMPLETE_TYPE_P (type
))
20483 error_at (type_start_token
->location
, "redefinition of %q#T",
20485 error_at (type_start_token
->location
, "previous definition of %q+#T",
20490 else if (type
== error_mark_node
)
20495 /* Apply attributes now, before any use of the class as a template
20496 argument in its base list. */
20497 cplus_decl_attributes (&type
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
20498 fixup_attribute_variants (type
);
20501 /* We will have entered the scope containing the class; the names of
20502 base classes should be looked up in that context. For example:
20504 struct A { struct B {}; struct C; };
20505 struct A::C : B {};
20509 /* Get the list of base-classes, if there is one. */
20510 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
20512 /* PR59482: enter the class scope so that base-specifiers are looked
20516 bases
= cp_parser_base_clause (parser
);
20517 /* PR59482: get out of the previously pushed class scope so that the
20518 subsequent pops pop the right thing. */
20525 /* If we're really defining a class, process the base classes.
20526 If they're invalid, fail. */
20527 if (type
&& cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
)
20528 && !xref_basetypes (type
, bases
))
20532 /* Leave the scope given by the nested-name-specifier. We will
20533 enter the class scope itself while processing the members. */
20535 pop_scope (pushed_scope
);
20537 if (invalid_explicit_specialization_p
)
20539 end_specialization ();
20540 --parser
->num_template_parameter_lists
;
20544 DECL_SOURCE_LOCATION (TYPE_NAME (type
)) = type_start_token
->location
;
20545 if (type
&& (virt_specifiers
& VIRT_SPEC_FINAL
))
20546 CLASSTYPE_FINAL (type
) = 1;
20548 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
20552 /* Parse a class-key.
20559 Returns the kind of class-key specified, or none_type to indicate
20562 static enum tag_types
20563 cp_parser_class_key (cp_parser
* parser
)
20566 enum tag_types tag_type
;
20568 /* Look for the class-key. */
20569 token
= cp_parser_require (parser
, CPP_KEYWORD
, RT_CLASS_KEY
);
20573 /* Check to see if the TOKEN is a class-key. */
20574 tag_type
= cp_parser_token_is_class_key (token
);
20576 cp_parser_error (parser
, "expected class-key");
20580 /* Parse a type-parameter-key.
20582 type-parameter-key:
20588 cp_parser_type_parameter_key (cp_parser
* parser
)
20590 /* Look for the type-parameter-key. */
20591 enum tag_types tag_type
= none_type
;
20592 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
20593 if ((tag_type
= cp_parser_token_is_type_parameter_key (token
)) != none_type
)
20595 cp_lexer_consume_token (parser
->lexer
);
20596 if (pedantic
&& tag_type
== typename_type
&& cxx_dialect
< cxx1z
)
20597 /* typename is not allowed in a template template parameter
20598 by the standard until C++1Z. */
20599 pedwarn (token
->location
, OPT_Wpedantic
,
20600 "ISO C++ forbids typename key in template template parameter;"
20601 " use -std=c++1z or -std=gnu++1z");
20604 cp_parser_error (parser
, "expected %<class%> or %<typename%>");
20609 /* Parse an (optional) member-specification.
20611 member-specification:
20612 member-declaration member-specification [opt]
20613 access-specifier : member-specification [opt] */
20616 cp_parser_member_specification_opt (cp_parser
* parser
)
20623 /* Peek at the next token. */
20624 token
= cp_lexer_peek_token (parser
->lexer
);
20625 /* If it's a `}', or EOF then we've seen all the members. */
20626 if (token
->type
== CPP_CLOSE_BRACE
20627 || token
->type
== CPP_EOF
20628 || token
->type
== CPP_PRAGMA_EOL
)
20631 /* See if this token is a keyword. */
20632 keyword
= token
->keyword
;
20636 case RID_PROTECTED
:
20638 /* Consume the access-specifier. */
20639 cp_lexer_consume_token (parser
->lexer
);
20640 /* Remember which access-specifier is active. */
20641 current_access_specifier
= token
->u
.value
;
20642 /* Look for the `:'. */
20643 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
20647 /* Accept #pragmas at class scope. */
20648 if (token
->type
== CPP_PRAGMA
)
20650 cp_parser_pragma (parser
, pragma_member
);
20654 /* Otherwise, the next construction must be a
20655 member-declaration. */
20656 cp_parser_member_declaration (parser
);
20661 /* Parse a member-declaration.
20663 member-declaration:
20664 decl-specifier-seq [opt] member-declarator-list [opt] ;
20665 function-definition ; [opt]
20666 :: [opt] nested-name-specifier template [opt] unqualified-id ;
20668 template-declaration
20671 member-declarator-list:
20673 member-declarator-list , member-declarator
20676 declarator pure-specifier [opt]
20677 declarator constant-initializer [opt]
20678 identifier [opt] : constant-expression
20682 member-declaration:
20683 __extension__ member-declaration
20686 declarator attributes [opt] pure-specifier [opt]
20687 declarator attributes [opt] constant-initializer [opt]
20688 identifier [opt] attributes [opt] : constant-expression
20692 member-declaration:
20693 static_assert-declaration */
20696 cp_parser_member_declaration (cp_parser
* parser
)
20698 cp_decl_specifier_seq decl_specifiers
;
20699 tree prefix_attributes
;
20701 int declares_class_or_enum
;
20703 cp_token
*token
= NULL
;
20704 cp_token
*decl_spec_token_start
= NULL
;
20705 cp_token
*initializer_token_start
= NULL
;
20706 int saved_pedantic
;
20707 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
20709 /* Check for the `__extension__' keyword. */
20710 if (cp_parser_extension_opt (parser
, &saved_pedantic
))
20713 cp_parser_member_declaration (parser
);
20714 /* Restore the old value of the PEDANTIC flag. */
20715 pedantic
= saved_pedantic
;
20720 /* Check for a template-declaration. */
20721 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
20723 /* An explicit specialization here is an error condition, and we
20724 expect the specialization handler to detect and report this. */
20725 if (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_LESS
20726 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
== CPP_GREATER
)
20727 cp_parser_explicit_specialization (parser
);
20729 cp_parser_template_declaration (parser
, /*member_p=*/true);
20734 /* Check for a using-declaration. */
20735 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_USING
))
20737 if (cxx_dialect
< cxx11
)
20739 /* Parse the using-declaration. */
20740 cp_parser_using_declaration (parser
,
20741 /*access_declaration_p=*/false);
20747 bool alias_decl_expected
;
20748 cp_parser_parse_tentatively (parser
);
20749 decl
= cp_parser_alias_declaration (parser
);
20750 /* Note that if we actually see the '=' token after the
20751 identifier, cp_parser_alias_declaration commits the
20752 tentative parse. In that case, we really expects an
20753 alias-declaration. Otherwise, we expect a using
20755 alias_decl_expected
=
20756 !cp_parser_uncommitted_to_tentative_parse_p (parser
);
20757 cp_parser_parse_definitely (parser
);
20759 if (alias_decl_expected
)
20760 finish_member_declaration (decl
);
20762 cp_parser_using_declaration (parser
,
20763 /*access_declaration_p=*/false);
20768 /* Check for @defs. */
20769 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_DEFS
))
20772 tree ivar_chains
= cp_parser_objc_defs_expression (parser
);
20773 ivar
= ivar_chains
;
20777 ivar
= TREE_CHAIN (member
);
20778 TREE_CHAIN (member
) = NULL_TREE
;
20779 finish_member_declaration (member
);
20784 /* If the next token is `static_assert' we have a static assertion. */
20785 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC_ASSERT
))
20787 cp_parser_static_assert (parser
, /*member_p=*/true);
20791 parser
->colon_corrects_to_scope_p
= false;
20793 if (cp_parser_using_declaration (parser
, /*access_declaration=*/true))
20796 /* Parse the decl-specifier-seq. */
20797 decl_spec_token_start
= cp_lexer_peek_token (parser
->lexer
);
20798 cp_parser_decl_specifier_seq (parser
,
20799 CP_PARSER_FLAGS_OPTIONAL
,
20801 &declares_class_or_enum
);
20802 /* Check for an invalid type-name. */
20803 if (!decl_specifiers
.any_type_specifiers_p
20804 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
20806 /* If there is no declarator, then the decl-specifier-seq should
20808 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
20810 /* If there was no decl-specifier-seq, and the next token is a
20811 `;', then we have something like:
20817 Each member-declaration shall declare at least one member
20818 name of the class. */
20819 if (!decl_specifiers
.any_specifiers_p
)
20821 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
20822 if (!in_system_header_at (token
->location
))
20823 pedwarn (token
->location
, OPT_Wpedantic
, "extra %<;%>");
20829 /* See if this declaration is a friend. */
20830 friend_p
= cp_parser_friend_p (&decl_specifiers
);
20831 /* If there were decl-specifiers, check to see if there was
20832 a class-declaration. */
20833 type
= check_tag_decl (&decl_specifiers
,
20834 /*explicit_type_instantiation_p=*/false);
20835 /* Nested classes have already been added to the class, but
20836 a `friend' needs to be explicitly registered. */
20839 /* If the `friend' keyword was present, the friend must
20840 be introduced with a class-key. */
20841 if (!declares_class_or_enum
&& cxx_dialect
< cxx11
)
20842 pedwarn (decl_spec_token_start
->location
, OPT_Wpedantic
,
20843 "in C++03 a class-key must be used "
20844 "when declaring a friend");
20847 template <typename T> struct A {
20848 friend struct A<T>::B;
20851 A<T>::B will be represented by a TYPENAME_TYPE, and
20852 therefore not recognized by check_tag_decl. */
20855 type
= decl_specifiers
.type
;
20856 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
20857 type
= TREE_TYPE (type
);
20859 if (!type
|| !TYPE_P (type
))
20860 error_at (decl_spec_token_start
->location
,
20861 "friend declaration does not name a class or "
20864 make_friend_class (current_class_type
, type
,
20865 /*complain=*/true);
20867 /* If there is no TYPE, an error message will already have
20869 else if (!type
|| type
== error_mark_node
)
20871 /* An anonymous aggregate has to be handled specially; such
20872 a declaration really declares a data member (with a
20873 particular type), as opposed to a nested class. */
20874 else if (ANON_AGGR_TYPE_P (type
))
20877 if (decl_specifiers
.storage_class
!= sc_none
)
20878 error_at (decl_spec_token_start
->location
,
20879 "a storage class on an anonymous aggregate "
20880 "in class scope is not allowed");
20882 /* Remove constructors and such from TYPE, now that we
20883 know it is an anonymous aggregate. */
20884 fixup_anonymous_aggr (type
);
20885 /* And make the corresponding data member. */
20886 decl
= build_decl (decl_spec_token_start
->location
,
20887 FIELD_DECL
, NULL_TREE
, type
);
20888 /* Add it to the class. */
20889 finish_member_declaration (decl
);
20892 cp_parser_check_access_in_redeclaration
20894 decl_spec_token_start
->location
);
20899 bool assume_semicolon
= false;
20901 /* Clear attributes from the decl_specifiers but keep them
20902 around as prefix attributes that apply them to the entity
20904 prefix_attributes
= decl_specifiers
.attributes
;
20905 decl_specifiers
.attributes
= NULL_TREE
;
20907 /* See if these declarations will be friends. */
20908 friend_p
= cp_parser_friend_p (&decl_specifiers
);
20910 /* Keep going until we hit the `;' at the end of the
20912 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
20914 tree attributes
= NULL_TREE
;
20915 tree first_attribute
;
20917 /* Peek at the next token. */
20918 token
= cp_lexer_peek_token (parser
->lexer
);
20920 /* Check for a bitfield declaration. */
20921 if (token
->type
== CPP_COLON
20922 || (token
->type
== CPP_NAME
20923 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
20929 /* Get the name of the bitfield. Note that we cannot just
20930 check TOKEN here because it may have been invalidated by
20931 the call to cp_lexer_peek_nth_token above. */
20932 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_COLON
)
20933 identifier
= cp_parser_identifier (parser
);
20935 identifier
= NULL_TREE
;
20937 /* Consume the `:' token. */
20938 cp_lexer_consume_token (parser
->lexer
);
20939 /* Get the width of the bitfield. */
20941 = cp_parser_constant_expression (parser
);
20943 /* Look for attributes that apply to the bitfield. */
20944 attributes
= cp_parser_attributes_opt (parser
);
20945 /* Remember which attributes are prefix attributes and
20947 first_attribute
= attributes
;
20948 /* Combine the attributes. */
20949 attributes
= chainon (prefix_attributes
, attributes
);
20951 /* Create the bitfield declaration. */
20952 decl
= grokbitfield (identifier
20953 ? make_id_declarator (NULL_TREE
,
20963 cp_declarator
*declarator
;
20965 tree asm_specification
;
20966 int ctor_dtor_or_conv_p
;
20968 /* Parse the declarator. */
20970 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
20971 &ctor_dtor_or_conv_p
,
20972 /*parenthesized_p=*/NULL
,
20976 /* If something went wrong parsing the declarator, make sure
20977 that we at least consume some tokens. */
20978 if (declarator
== cp_error_declarator
)
20980 /* Skip to the end of the statement. */
20981 cp_parser_skip_to_end_of_statement (parser
);
20982 /* If the next token is not a semicolon, that is
20983 probably because we just skipped over the body of
20984 a function. So, we consume a semicolon if
20985 present, but do not issue an error message if it
20987 if (cp_lexer_next_token_is (parser
->lexer
,
20989 cp_lexer_consume_token (parser
->lexer
);
20993 if (declares_class_or_enum
& 2)
20994 cp_parser_check_for_definition_in_return_type
20995 (declarator
, decl_specifiers
.type
,
20996 decl_specifiers
.locations
[ds_type_spec
]);
20998 /* Look for an asm-specification. */
20999 asm_specification
= cp_parser_asm_specification_opt (parser
);
21000 /* Look for attributes that apply to the declaration. */
21001 attributes
= cp_parser_attributes_opt (parser
);
21002 /* Remember which attributes are prefix attributes and
21004 first_attribute
= attributes
;
21005 /* Combine the attributes. */
21006 attributes
= chainon (prefix_attributes
, attributes
);
21008 /* If it's an `=', then we have a constant-initializer or a
21009 pure-specifier. It is not correct to parse the
21010 initializer before registering the member declaration
21011 since the member declaration should be in scope while
21012 its initializer is processed. However, the rest of the
21013 front end does not yet provide an interface that allows
21014 us to handle this correctly. */
21015 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
21019 A pure-specifier shall be used only in the declaration of
21020 a virtual function.
21022 A member-declarator can contain a constant-initializer
21023 only if it declares a static member of integral or
21026 Therefore, if the DECLARATOR is for a function, we look
21027 for a pure-specifier; otherwise, we look for a
21028 constant-initializer. When we call `grokfield', it will
21029 perform more stringent semantics checks. */
21030 initializer_token_start
= cp_lexer_peek_token (parser
->lexer
);
21031 if (function_declarator_p (declarator
)
21032 || (decl_specifiers
.type
21033 && TREE_CODE (decl_specifiers
.type
) == TYPE_DECL
21034 && declarator
->kind
== cdk_id
21035 && (TREE_CODE (TREE_TYPE (decl_specifiers
.type
))
21036 == FUNCTION_TYPE
)))
21037 initializer
= cp_parser_pure_specifier (parser
);
21038 else if (decl_specifiers
.storage_class
!= sc_static
)
21039 initializer
= cp_parser_save_nsdmi (parser
);
21040 else if (cxx_dialect
>= cxx11
)
21043 /* Don't require a constant rvalue in C++11, since we
21044 might want a reference constant. We'll enforce
21045 constancy later. */
21046 cp_lexer_consume_token (parser
->lexer
);
21047 /* Parse the initializer. */
21048 initializer
= cp_parser_initializer_clause (parser
,
21052 /* Parse the initializer. */
21053 initializer
= cp_parser_constant_initializer (parser
);
21055 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
)
21056 && !function_declarator_p (declarator
))
21059 if (decl_specifiers
.storage_class
!= sc_static
)
21060 initializer
= cp_parser_save_nsdmi (parser
);
21062 initializer
= cp_parser_initializer (parser
, &x
, &x
);
21064 /* Otherwise, there is no initializer. */
21066 initializer
= NULL_TREE
;
21068 /* See if we are probably looking at a function
21069 definition. We are certainly not looking at a
21070 member-declarator. Calling `grokfield' has
21071 side-effects, so we must not do it unless we are sure
21072 that we are looking at a member-declarator. */
21073 if (cp_parser_token_starts_function_definition_p
21074 (cp_lexer_peek_token (parser
->lexer
)))
21076 /* The grammar does not allow a pure-specifier to be
21077 used when a member function is defined. (It is
21078 possible that this fact is an oversight in the
21079 standard, since a pure function may be defined
21080 outside of the class-specifier. */
21081 if (initializer
&& initializer_token_start
)
21082 error_at (initializer_token_start
->location
,
21083 "pure-specifier on function-definition");
21084 decl
= cp_parser_save_member_function_body (parser
,
21088 if (parser
->fully_implicit_function_template_p
)
21089 decl
= finish_fully_implicit_template (parser
, decl
);
21090 /* If the member was not a friend, declare it here. */
21092 finish_member_declaration (decl
);
21093 /* Peek at the next token. */
21094 token
= cp_lexer_peek_token (parser
->lexer
);
21095 /* If the next token is a semicolon, consume it. */
21096 if (token
->type
== CPP_SEMICOLON
)
21097 cp_lexer_consume_token (parser
->lexer
);
21101 if (declarator
->kind
== cdk_function
)
21102 declarator
->id_loc
= token
->location
;
21103 /* Create the declaration. */
21104 decl
= grokfield (declarator
, &decl_specifiers
,
21105 initializer
, /*init_const_expr_p=*/true,
21106 asm_specification
, attributes
);
21107 if (parser
->fully_implicit_function_template_p
)
21110 finish_fully_implicit_template (parser
, 0);
21112 decl
= finish_fully_implicit_template (parser
, decl
);
21116 cp_finalize_omp_declare_simd (parser
, decl
);
21118 /* Reset PREFIX_ATTRIBUTES. */
21119 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
21120 attributes
= TREE_CHAIN (attributes
);
21122 TREE_CHAIN (attributes
) = NULL_TREE
;
21124 /* If there is any qualification still in effect, clear it
21125 now; we will be starting fresh with the next declarator. */
21126 parser
->scope
= NULL_TREE
;
21127 parser
->qualifying_scope
= NULL_TREE
;
21128 parser
->object_scope
= NULL_TREE
;
21129 /* If it's a `,', then there are more declarators. */
21130 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
21132 cp_lexer_consume_token (parser
->lexer
);
21133 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
21135 cp_token
*token
= cp_lexer_previous_token (parser
->lexer
);
21136 error_at (token
->location
,
21137 "stray %<,%> at end of member declaration");
21140 /* If the next token isn't a `;', then we have a parse error. */
21141 else if (cp_lexer_next_token_is_not (parser
->lexer
,
21144 /* The next token might be a ways away from where the
21145 actual semicolon is missing. Find the previous token
21146 and use that for our error position. */
21147 cp_token
*token
= cp_lexer_previous_token (parser
->lexer
);
21148 error_at (token
->location
,
21149 "expected %<;%> at end of member declaration");
21151 /* Assume that the user meant to provide a semicolon. If
21152 we were to cp_parser_skip_to_end_of_statement, we might
21153 skip to a semicolon inside a member function definition
21154 and issue nonsensical error messages. */
21155 assume_semicolon
= true;
21160 /* Add DECL to the list of members. */
21162 /* Explicitly include, eg, NSDMIs, for better error
21163 recovery (c++/58650). */
21164 || !DECL_DECLARES_FUNCTION_P (decl
))
21165 finish_member_declaration (decl
);
21167 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21168 cp_parser_save_default_args (parser
, decl
);
21169 else if (TREE_CODE (decl
) == FIELD_DECL
21170 && !DECL_C_BIT_FIELD (decl
)
21171 && DECL_INITIAL (decl
))
21172 /* Add DECL to the queue of NSDMI to be parsed later. */
21173 vec_safe_push (unparsed_nsdmis
, decl
);
21176 if (assume_semicolon
)
21181 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
21183 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
21186 /* Parse a pure-specifier.
21191 Returns INTEGER_ZERO_NODE if a pure specifier is found.
21192 Otherwise, ERROR_MARK_NODE is returned. */
21195 cp_parser_pure_specifier (cp_parser
* parser
)
21199 /* Look for the `=' token. */
21200 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
21201 return error_mark_node
;
21202 /* Look for the `0' token. */
21203 token
= cp_lexer_peek_token (parser
->lexer
);
21205 if (token
->type
== CPP_EOF
21206 || token
->type
== CPP_PRAGMA_EOL
)
21207 return error_mark_node
;
21209 cp_lexer_consume_token (parser
->lexer
);
21211 /* Accept = default or = delete in c++0x mode. */
21212 if (token
->keyword
== RID_DEFAULT
21213 || token
->keyword
== RID_DELETE
)
21215 maybe_warn_cpp0x (CPP0X_DEFAULTED_DELETED
);
21216 return token
->u
.value
;
21219 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
21220 if (token
->type
!= CPP_NUMBER
|| !(token
->flags
& PURE_ZERO
))
21222 cp_parser_error (parser
,
21223 "invalid pure specifier (only %<= 0%> is allowed)");
21224 cp_parser_skip_to_end_of_statement (parser
);
21225 return error_mark_node
;
21227 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
21229 error_at (token
->location
, "templates may not be %<virtual%>");
21230 return error_mark_node
;
21233 return integer_zero_node
;
21236 /* Parse a constant-initializer.
21238 constant-initializer:
21239 = constant-expression
21241 Returns a representation of the constant-expression. */
21244 cp_parser_constant_initializer (cp_parser
* parser
)
21246 /* Look for the `=' token. */
21247 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
21248 return error_mark_node
;
21250 /* It is invalid to write:
21252 struct S { static const int i = { 7 }; };
21255 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
21257 cp_parser_error (parser
,
21258 "a brace-enclosed initializer is not allowed here");
21259 /* Consume the opening brace. */
21260 cp_lexer_consume_token (parser
->lexer
);
21261 /* Skip the initializer. */
21262 cp_parser_skip_to_closing_brace (parser
);
21263 /* Look for the trailing `}'. */
21264 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
21266 return error_mark_node
;
21269 return cp_parser_constant_expression (parser
);
21272 /* Derived classes [gram.class.derived] */
21274 /* Parse a base-clause.
21277 : base-specifier-list
21279 base-specifier-list:
21280 base-specifier ... [opt]
21281 base-specifier-list , base-specifier ... [opt]
21283 Returns a TREE_LIST representing the base-classes, in the order in
21284 which they were declared. The representation of each node is as
21285 described by cp_parser_base_specifier.
21287 In the case that no bases are specified, this function will return
21288 NULL_TREE, not ERROR_MARK_NODE. */
21291 cp_parser_base_clause (cp_parser
* parser
)
21293 tree bases
= NULL_TREE
;
21295 /* Look for the `:' that begins the list. */
21296 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
21298 /* Scan the base-specifier-list. */
21303 bool pack_expansion_p
= false;
21305 /* Look for the base-specifier. */
21306 base
= cp_parser_base_specifier (parser
);
21307 /* Look for the (optional) ellipsis. */
21308 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
21310 /* Consume the `...'. */
21311 cp_lexer_consume_token (parser
->lexer
);
21313 pack_expansion_p
= true;
21316 /* Add BASE to the front of the list. */
21317 if (base
&& base
!= error_mark_node
)
21319 if (pack_expansion_p
)
21320 /* Make this a pack expansion type. */
21321 TREE_VALUE (base
) = make_pack_expansion (TREE_VALUE (base
));
21323 if (!check_for_bare_parameter_packs (TREE_VALUE (base
)))
21325 TREE_CHAIN (base
) = bases
;
21329 /* Peek at the next token. */
21330 token
= cp_lexer_peek_token (parser
->lexer
);
21331 /* If it's not a comma, then the list is complete. */
21332 if (token
->type
!= CPP_COMMA
)
21334 /* Consume the `,'. */
21335 cp_lexer_consume_token (parser
->lexer
);
21338 /* PARSER->SCOPE may still be non-NULL at this point, if the last
21339 base class had a qualified name. However, the next name that
21340 appears is certainly not qualified. */
21341 parser
->scope
= NULL_TREE
;
21342 parser
->qualifying_scope
= NULL_TREE
;
21343 parser
->object_scope
= NULL_TREE
;
21345 return nreverse (bases
);
21348 /* Parse a base-specifier.
21351 :: [opt] nested-name-specifier [opt] class-name
21352 virtual access-specifier [opt] :: [opt] nested-name-specifier
21354 access-specifier virtual [opt] :: [opt] nested-name-specifier
21357 Returns a TREE_LIST. The TREE_PURPOSE will be one of
21358 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
21359 indicate the specifiers provided. The TREE_VALUE will be a TYPE
21360 (or the ERROR_MARK_NODE) indicating the type that was specified. */
21363 cp_parser_base_specifier (cp_parser
* parser
)
21367 bool virtual_p
= false;
21368 bool duplicate_virtual_error_issued_p
= false;
21369 bool duplicate_access_error_issued_p
= false;
21370 bool class_scope_p
, template_p
;
21371 tree access
= access_default_node
;
21374 /* Process the optional `virtual' and `access-specifier'. */
21377 /* Peek at the next token. */
21378 token
= cp_lexer_peek_token (parser
->lexer
);
21379 /* Process `virtual'. */
21380 switch (token
->keyword
)
21383 /* If `virtual' appears more than once, issue an error. */
21384 if (virtual_p
&& !duplicate_virtual_error_issued_p
)
21386 cp_parser_error (parser
,
21387 "%<virtual%> specified more than once in base-specified");
21388 duplicate_virtual_error_issued_p
= true;
21393 /* Consume the `virtual' token. */
21394 cp_lexer_consume_token (parser
->lexer
);
21399 case RID_PROTECTED
:
21401 /* If more than one access specifier appears, issue an
21403 if (access
!= access_default_node
21404 && !duplicate_access_error_issued_p
)
21406 cp_parser_error (parser
,
21407 "more than one access specifier in base-specified");
21408 duplicate_access_error_issued_p
= true;
21411 access
= ridpointers
[(int) token
->keyword
];
21413 /* Consume the access-specifier. */
21414 cp_lexer_consume_token (parser
->lexer
);
21423 /* It is not uncommon to see programs mechanically, erroneously, use
21424 the 'typename' keyword to denote (dependent) qualified types
21425 as base classes. */
21426 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TYPENAME
))
21428 token
= cp_lexer_peek_token (parser
->lexer
);
21429 if (!processing_template_decl
)
21430 error_at (token
->location
,
21431 "keyword %<typename%> not allowed outside of templates");
21433 error_at (token
->location
,
21434 "keyword %<typename%> not allowed in this context "
21435 "(the base class is implicitly a type)");
21436 cp_lexer_consume_token (parser
->lexer
);
21439 /* Look for the optional `::' operator. */
21440 cp_parser_global_scope_opt (parser
, /*current_scope_valid_p=*/false);
21441 /* Look for the nested-name-specifier. The simplest way to
21446 The keyword `typename' is not permitted in a base-specifier or
21447 mem-initializer; in these contexts a qualified name that
21448 depends on a template-parameter is implicitly assumed to be a
21451 is to pretend that we have seen the `typename' keyword at this
21453 cp_parser_nested_name_specifier_opt (parser
,
21454 /*typename_keyword_p=*/true,
21455 /*check_dependency_p=*/true,
21457 /*is_declaration=*/true);
21458 /* If the base class is given by a qualified name, assume that names
21459 we see are type names or templates, as appropriate. */
21460 class_scope_p
= (parser
->scope
&& TYPE_P (parser
->scope
));
21461 template_p
= class_scope_p
&& cp_parser_optional_template_keyword (parser
);
21464 && cp_lexer_next_token_is_decltype (parser
->lexer
))
21465 /* DR 950 allows decltype as a base-specifier. */
21466 type
= cp_parser_decltype (parser
);
21469 /* Otherwise, look for the class-name. */
21470 type
= cp_parser_class_name (parser
,
21474 /*check_dependency_p=*/true,
21475 /*class_head_p=*/false,
21476 /*is_declaration=*/true);
21477 type
= TREE_TYPE (type
);
21480 if (type
== error_mark_node
)
21481 return error_mark_node
;
21483 return finish_base_specifier (type
, access
, virtual_p
);
21486 /* Exception handling [gram.exception] */
21488 /* Parse an (optional) noexcept-specification.
21490 noexcept-specification:
21491 noexcept ( constant-expression ) [opt]
21493 If no noexcept-specification is present, returns NULL_TREE.
21494 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
21495 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
21496 there are no parentheses. CONSUMED_EXPR will be set accordingly.
21497 Otherwise, returns a noexcept specification unless RETURN_COND is true,
21498 in which case a boolean condition is returned instead. */
21501 cp_parser_noexcept_specification_opt (cp_parser
* parser
,
21502 bool require_constexpr
,
21503 bool* consumed_expr
,
21507 const char *saved_message
;
21509 /* Peek at the next token. */
21510 token
= cp_lexer_peek_token (parser
->lexer
);
21512 /* Is it a noexcept-specification? */
21513 if (cp_parser_is_keyword (token
, RID_NOEXCEPT
))
21516 cp_lexer_consume_token (parser
->lexer
);
21518 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
21520 cp_lexer_consume_token (parser
->lexer
);
21522 if (require_constexpr
)
21524 /* Types may not be defined in an exception-specification. */
21525 saved_message
= parser
->type_definition_forbidden_message
;
21526 parser
->type_definition_forbidden_message
21527 = G_("types may not be defined in an exception-specification");
21529 expr
= cp_parser_constant_expression (parser
);
21531 /* Restore the saved message. */
21532 parser
->type_definition_forbidden_message
= saved_message
;
21536 expr
= cp_parser_expression (parser
);
21537 *consumed_expr
= true;
21540 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21544 expr
= boolean_true_node
;
21545 if (!require_constexpr
)
21546 *consumed_expr
= false;
21549 /* We cannot build a noexcept-spec right away because this will check
21550 that expr is a constexpr. */
21552 return build_noexcept_spec (expr
, tf_warning_or_error
);
21560 /* Parse an (optional) exception-specification.
21562 exception-specification:
21563 throw ( type-id-list [opt] )
21565 Returns a TREE_LIST representing the exception-specification. The
21566 TREE_VALUE of each node is a type. */
21569 cp_parser_exception_specification_opt (cp_parser
* parser
)
21573 const char *saved_message
;
21575 /* Peek at the next token. */
21576 token
= cp_lexer_peek_token (parser
->lexer
);
21578 /* Is it a noexcept-specification? */
21579 type_id_list
= cp_parser_noexcept_specification_opt(parser
, true, NULL
,
21581 if (type_id_list
!= NULL_TREE
)
21582 return type_id_list
;
21584 /* If it's not `throw', then there's no exception-specification. */
21585 if (!cp_parser_is_keyword (token
, RID_THROW
))
21589 /* Enable this once a lot of code has transitioned to noexcept? */
21590 if (cxx_dialect
>= cxx11
&& !in_system_header_at (input_location
))
21591 warning (OPT_Wdeprecated
, "dynamic exception specifications are "
21592 "deprecated in C++0x; use %<noexcept%> instead");
21595 /* Consume the `throw'. */
21596 cp_lexer_consume_token (parser
->lexer
);
21598 /* Look for the `('. */
21599 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21601 /* Peek at the next token. */
21602 token
= cp_lexer_peek_token (parser
->lexer
);
21603 /* If it's not a `)', then there is a type-id-list. */
21604 if (token
->type
!= CPP_CLOSE_PAREN
)
21606 /* Types may not be defined in an exception-specification. */
21607 saved_message
= parser
->type_definition_forbidden_message
;
21608 parser
->type_definition_forbidden_message
21609 = G_("types may not be defined in an exception-specification");
21610 /* Parse the type-id-list. */
21611 type_id_list
= cp_parser_type_id_list (parser
);
21612 /* Restore the saved message. */
21613 parser
->type_definition_forbidden_message
= saved_message
;
21616 type_id_list
= empty_except_spec
;
21618 /* Look for the `)'. */
21619 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21621 return type_id_list
;
21624 /* Parse an (optional) type-id-list.
21628 type-id-list , type-id ... [opt]
21630 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
21631 in the order that the types were presented. */
21634 cp_parser_type_id_list (cp_parser
* parser
)
21636 tree types
= NULL_TREE
;
21643 /* Get the next type-id. */
21644 type
= cp_parser_type_id (parser
);
21645 /* Parse the optional ellipsis. */
21646 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
21648 /* Consume the `...'. */
21649 cp_lexer_consume_token (parser
->lexer
);
21651 /* Turn the type into a pack expansion expression. */
21652 type
= make_pack_expansion (type
);
21654 /* Add it to the list. */
21655 types
= add_exception_specifier (types
, type
, /*complain=*/1);
21656 /* Peek at the next token. */
21657 token
= cp_lexer_peek_token (parser
->lexer
);
21658 /* If it is not a `,', we are done. */
21659 if (token
->type
!= CPP_COMMA
)
21661 /* Consume the `,'. */
21662 cp_lexer_consume_token (parser
->lexer
);
21665 return nreverse (types
);
21668 /* Parse a try-block.
21671 try compound-statement handler-seq */
21674 cp_parser_try_block (cp_parser
* parser
)
21678 cp_parser_require_keyword (parser
, RID_TRY
, RT_TRY
);
21679 if (parser
->in_function_body
21680 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
21681 error ("%<try%> in %<constexpr%> function");
21683 try_block
= begin_try_block ();
21684 cp_parser_compound_statement (parser
, NULL
, true, false);
21685 finish_try_block (try_block
);
21686 cp_parser_handler_seq (parser
);
21687 finish_handler_sequence (try_block
);
21692 /* Parse a function-try-block.
21694 function-try-block:
21695 try ctor-initializer [opt] function-body handler-seq */
21698 cp_parser_function_try_block (cp_parser
* parser
)
21700 tree compound_stmt
;
21702 bool ctor_initializer_p
;
21704 /* Look for the `try' keyword. */
21705 if (!cp_parser_require_keyword (parser
, RID_TRY
, RT_TRY
))
21707 /* Let the rest of the front end know where we are. */
21708 try_block
= begin_function_try_block (&compound_stmt
);
21709 /* Parse the function-body. */
21710 ctor_initializer_p
= cp_parser_ctor_initializer_opt_and_function_body
21711 (parser
, /*in_function_try_block=*/true);
21712 /* We're done with the `try' part. */
21713 finish_function_try_block (try_block
);
21714 /* Parse the handlers. */
21715 cp_parser_handler_seq (parser
);
21716 /* We're done with the handlers. */
21717 finish_function_handler_sequence (try_block
, compound_stmt
);
21719 return ctor_initializer_p
;
21722 /* Parse a handler-seq.
21725 handler handler-seq [opt] */
21728 cp_parser_handler_seq (cp_parser
* parser
)
21734 /* Parse the handler. */
21735 cp_parser_handler (parser
);
21736 /* Peek at the next token. */
21737 token
= cp_lexer_peek_token (parser
->lexer
);
21738 /* If it's not `catch' then there are no more handlers. */
21739 if (!cp_parser_is_keyword (token
, RID_CATCH
))
21744 /* Parse a handler.
21747 catch ( exception-declaration ) compound-statement */
21750 cp_parser_handler (cp_parser
* parser
)
21755 cp_parser_require_keyword (parser
, RID_CATCH
, RT_CATCH
);
21756 handler
= begin_handler ();
21757 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21758 declaration
= cp_parser_exception_declaration (parser
);
21759 finish_handler_parms (declaration
, handler
);
21760 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21761 cp_parser_compound_statement (parser
, NULL
, false, false);
21762 finish_handler (handler
);
21765 /* Parse an exception-declaration.
21767 exception-declaration:
21768 type-specifier-seq declarator
21769 type-specifier-seq abstract-declarator
21773 Returns a VAR_DECL for the declaration, or NULL_TREE if the
21774 ellipsis variant is used. */
21777 cp_parser_exception_declaration (cp_parser
* parser
)
21779 cp_decl_specifier_seq type_specifiers
;
21780 cp_declarator
*declarator
;
21781 const char *saved_message
;
21783 /* If it's an ellipsis, it's easy to handle. */
21784 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
21786 /* Consume the `...' token. */
21787 cp_lexer_consume_token (parser
->lexer
);
21791 /* Types may not be defined in exception-declarations. */
21792 saved_message
= parser
->type_definition_forbidden_message
;
21793 parser
->type_definition_forbidden_message
21794 = G_("types may not be defined in exception-declarations");
21796 /* Parse the type-specifier-seq. */
21797 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/true,
21798 /*is_trailing_return=*/false,
21800 /* If it's a `)', then there is no declarator. */
21801 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
21804 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_EITHER
,
21805 /*ctor_dtor_or_conv_p=*/NULL
,
21806 /*parenthesized_p=*/NULL
,
21807 /*member_p=*/false,
21808 /*friend_p=*/false);
21810 /* Restore the saved message. */
21811 parser
->type_definition_forbidden_message
= saved_message
;
21813 if (!type_specifiers
.any_specifiers_p
)
21814 return error_mark_node
;
21816 return grokdeclarator (declarator
, &type_specifiers
, CATCHPARM
, 1, NULL
);
21819 /* Parse a throw-expression.
21822 throw assignment-expression [opt]
21824 Returns a THROW_EXPR representing the throw-expression. */
21827 cp_parser_throw_expression (cp_parser
* parser
)
21832 cp_parser_require_keyword (parser
, RID_THROW
, RT_THROW
);
21833 token
= cp_lexer_peek_token (parser
->lexer
);
21834 /* Figure out whether or not there is an assignment-expression
21835 following the "throw" keyword. */
21836 if (token
->type
== CPP_COMMA
21837 || token
->type
== CPP_SEMICOLON
21838 || token
->type
== CPP_CLOSE_PAREN
21839 || token
->type
== CPP_CLOSE_SQUARE
21840 || token
->type
== CPP_CLOSE_BRACE
21841 || token
->type
== CPP_COLON
)
21842 expression
= NULL_TREE
;
21844 expression
= cp_parser_assignment_expression (parser
);
21846 return build_throw (expression
);
21849 /* GNU Extensions */
21851 /* Parse an (optional) asm-specification.
21854 asm ( string-literal )
21856 If the asm-specification is present, returns a STRING_CST
21857 corresponding to the string-literal. Otherwise, returns
21861 cp_parser_asm_specification_opt (cp_parser
* parser
)
21864 tree asm_specification
;
21866 /* Peek at the next token. */
21867 token
= cp_lexer_peek_token (parser
->lexer
);
21868 /* If the next token isn't the `asm' keyword, then there's no
21869 asm-specification. */
21870 if (!cp_parser_is_keyword (token
, RID_ASM
))
21873 /* Consume the `asm' token. */
21874 cp_lexer_consume_token (parser
->lexer
);
21875 /* Look for the `('. */
21876 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21878 /* Look for the string-literal. */
21879 asm_specification
= cp_parser_string_literal (parser
, false, false);
21881 /* Look for the `)'. */
21882 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21884 return asm_specification
;
21887 /* Parse an asm-operand-list.
21891 asm-operand-list , asm-operand
21894 string-literal ( expression )
21895 [ string-literal ] string-literal ( expression )
21897 Returns a TREE_LIST representing the operands. The TREE_VALUE of
21898 each node is the expression. The TREE_PURPOSE is itself a
21899 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
21900 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
21901 is a STRING_CST for the string literal before the parenthesis. Returns
21902 ERROR_MARK_NODE if any of the operands are invalid. */
21905 cp_parser_asm_operand_list (cp_parser
* parser
)
21907 tree asm_operands
= NULL_TREE
;
21908 bool invalid_operands
= false;
21912 tree string_literal
;
21916 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
21918 /* Consume the `[' token. */
21919 cp_lexer_consume_token (parser
->lexer
);
21920 /* Read the operand name. */
21921 name
= cp_parser_identifier (parser
);
21922 if (name
!= error_mark_node
)
21923 name
= build_string (IDENTIFIER_LENGTH (name
),
21924 IDENTIFIER_POINTER (name
));
21925 /* Look for the closing `]'. */
21926 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
21930 /* Look for the string-literal. */
21931 string_literal
= cp_parser_string_literal (parser
, false, false);
21933 /* Look for the `('. */
21934 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
21935 /* Parse the expression. */
21936 expression
= cp_parser_expression (parser
);
21937 /* Look for the `)'. */
21938 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
21940 if (name
== error_mark_node
21941 || string_literal
== error_mark_node
21942 || expression
== error_mark_node
)
21943 invalid_operands
= true;
21945 /* Add this operand to the list. */
21946 asm_operands
= tree_cons (build_tree_list (name
, string_literal
),
21949 /* If the next token is not a `,', there are no more
21951 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
21953 /* Consume the `,'. */
21954 cp_lexer_consume_token (parser
->lexer
);
21957 return invalid_operands
? error_mark_node
: nreverse (asm_operands
);
21960 /* Parse an asm-clobber-list.
21964 asm-clobber-list , string-literal
21966 Returns a TREE_LIST, indicating the clobbers in the order that they
21967 appeared. The TREE_VALUE of each node is a STRING_CST. */
21970 cp_parser_asm_clobber_list (cp_parser
* parser
)
21972 tree clobbers
= NULL_TREE
;
21976 tree string_literal
;
21978 /* Look for the string literal. */
21979 string_literal
= cp_parser_string_literal (parser
, false, false);
21980 /* Add it to the list. */
21981 clobbers
= tree_cons (NULL_TREE
, string_literal
, clobbers
);
21982 /* If the next token is not a `,', then the list is
21984 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
21986 /* Consume the `,' token. */
21987 cp_lexer_consume_token (parser
->lexer
);
21993 /* Parse an asm-label-list.
21997 asm-label-list , identifier
21999 Returns a TREE_LIST, indicating the labels in the order that they
22000 appeared. The TREE_VALUE of each node is a label. */
22003 cp_parser_asm_label_list (cp_parser
* parser
)
22005 tree labels
= NULL_TREE
;
22009 tree identifier
, label
, name
;
22011 /* Look for the identifier. */
22012 identifier
= cp_parser_identifier (parser
);
22013 if (!error_operand_p (identifier
))
22015 label
= lookup_label (identifier
);
22016 if (TREE_CODE (label
) == LABEL_DECL
)
22018 TREE_USED (label
) = 1;
22019 check_goto (label
);
22020 name
= build_string (IDENTIFIER_LENGTH (identifier
),
22021 IDENTIFIER_POINTER (identifier
));
22022 labels
= tree_cons (name
, label
, labels
);
22025 /* If the next token is not a `,', then the list is
22027 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
22029 /* Consume the `,' token. */
22030 cp_lexer_consume_token (parser
->lexer
);
22033 return nreverse (labels
);
22036 /* Return TRUE iff the next tokens in the stream are possibly the
22037 beginning of a GNU extension attribute. */
22040 cp_next_tokens_can_be_gnu_attribute_p (cp_parser
*parser
)
22042 return cp_nth_tokens_can_be_gnu_attribute_p (parser
, 1);
22045 /* Return TRUE iff the next tokens in the stream are possibly the
22046 beginning of a standard C++-11 attribute specifier. */
22049 cp_next_tokens_can_be_std_attribute_p (cp_parser
*parser
)
22051 return cp_nth_tokens_can_be_std_attribute_p (parser
, 1);
22054 /* Return TRUE iff the next Nth tokens in the stream are possibly the
22055 beginning of a standard C++-11 attribute specifier. */
22058 cp_nth_tokens_can_be_std_attribute_p (cp_parser
*parser
, size_t n
)
22060 cp_token
*token
= cp_lexer_peek_nth_token (parser
->lexer
, n
);
22062 return (cxx_dialect
>= cxx11
22063 && ((token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_ALIGNAS
)
22064 || (token
->type
== CPP_OPEN_SQUARE
22065 && (token
= cp_lexer_peek_nth_token (parser
->lexer
, n
+ 1))
22066 && token
->type
== CPP_OPEN_SQUARE
)));
22069 /* Return TRUE iff the next Nth tokens in the stream are possibly the
22070 beginning of a GNU extension attribute. */
22073 cp_nth_tokens_can_be_gnu_attribute_p (cp_parser
*parser
, size_t n
)
22075 cp_token
*token
= cp_lexer_peek_nth_token (parser
->lexer
, n
);
22077 return token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_ATTRIBUTE
;
22080 /* Return true iff the next tokens can be the beginning of either a
22081 GNU attribute list, or a standard C++11 attribute sequence. */
22084 cp_next_tokens_can_be_attribute_p (cp_parser
*parser
)
22086 return (cp_next_tokens_can_be_gnu_attribute_p (parser
)
22087 || cp_next_tokens_can_be_std_attribute_p (parser
));
22090 /* Return true iff the next Nth tokens can be the beginning of either
22091 a GNU attribute list, or a standard C++11 attribute sequence. */
22094 cp_nth_tokens_can_be_attribute_p (cp_parser
*parser
, size_t n
)
22096 return (cp_nth_tokens_can_be_gnu_attribute_p (parser
, n
)
22097 || cp_nth_tokens_can_be_std_attribute_p (parser
, n
));
22100 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
22101 of GNU attributes, or return NULL. */
22104 cp_parser_attributes_opt (cp_parser
*parser
)
22106 if (cp_next_tokens_can_be_gnu_attribute_p (parser
))
22107 return cp_parser_gnu_attributes_opt (parser
);
22108 return cp_parser_std_attribute_spec_seq (parser
);
22111 #define CILK_SIMD_FN_CLAUSE_MASK \
22112 ((OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_VECTORLENGTH) \
22113 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_LINEAR) \
22114 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_UNIFORM) \
22115 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_MASK) \
22116 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_NOMASK))
22118 /* Parses the Cilk Plus SIMD-enabled function's attribute. Syntax:
22119 vector [(<clauses>)] */
22122 cp_parser_cilk_simd_fn_vector_attrs (cp_parser
*parser
, cp_token
*v_token
)
22124 bool first_p
= parser
->cilk_simd_fn_info
== NULL
;
22125 cp_token
*token
= v_token
;
22128 parser
->cilk_simd_fn_info
= XNEW (cp_omp_declare_simd_data
);
22129 parser
->cilk_simd_fn_info
->error_seen
= false;
22130 parser
->cilk_simd_fn_info
->fndecl_seen
= false;
22131 parser
->cilk_simd_fn_info
->tokens
= vNULL
;
22133 int paren_scope
= 0;
22134 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
22136 cp_lexer_consume_token (parser
->lexer
);
22137 v_token
= cp_lexer_peek_token (parser
->lexer
);
22140 while (paren_scope
> 0)
22142 token
= cp_lexer_peek_token (parser
->lexer
);
22143 if (token
->type
== CPP_OPEN_PAREN
)
22145 else if (token
->type
== CPP_CLOSE_PAREN
)
22147 /* Do not push the last ')' */
22148 if (!(token
->type
== CPP_CLOSE_PAREN
&& paren_scope
== 0))
22149 cp_lexer_consume_token (parser
->lexer
);
22152 token
->type
= CPP_PRAGMA_EOL
;
22153 parser
->lexer
->next_token
= token
;
22154 cp_lexer_consume_token (parser
->lexer
);
22156 struct cp_token_cache
*cp
22157 = cp_token_cache_new (v_token
, cp_lexer_peek_token (parser
->lexer
));
22158 parser
->cilk_simd_fn_info
->tokens
.safe_push (cp
);
22161 /* Parse an (optional) series of attributes.
22164 attributes attribute
22167 __attribute__ (( attribute-list [opt] ))
22169 The return value is as for cp_parser_gnu_attribute_list. */
22172 cp_parser_gnu_attributes_opt (cp_parser
* parser
)
22174 tree attributes
= NULL_TREE
;
22179 tree attribute_list
;
22182 /* Peek at the next token. */
22183 token
= cp_lexer_peek_token (parser
->lexer
);
22184 /* If it's not `__attribute__', then we're done. */
22185 if (token
->keyword
!= RID_ATTRIBUTE
)
22188 /* Consume the `__attribute__' keyword. */
22189 cp_lexer_consume_token (parser
->lexer
);
22190 /* Look for the two `(' tokens. */
22191 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
22192 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
22194 /* Peek at the next token. */
22195 token
= cp_lexer_peek_token (parser
->lexer
);
22196 if (token
->type
!= CPP_CLOSE_PAREN
)
22197 /* Parse the attribute-list. */
22198 attribute_list
= cp_parser_gnu_attribute_list (parser
);
22200 /* If the next token is a `)', then there is no attribute
22202 attribute_list
= NULL
;
22204 /* Look for the two `)' tokens. */
22205 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
22207 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
22210 cp_parser_skip_to_end_of_statement (parser
);
22212 /* Add these new attributes to the list. */
22213 attributes
= chainon (attributes
, attribute_list
);
22219 /* Returns true of NAME is an IDENTIFIER_NODE with identiifer "vector,"
22220 "__vector" or "__vector__." */
22223 is_cilkplus_vector_p (tree name
)
22225 if (flag_cilkplus
&& is_attribute_p ("vector", name
))
22230 /* Parse a GNU attribute-list.
22234 attribute-list , attribute
22238 identifier ( identifier )
22239 identifier ( identifier , expression-list )
22240 identifier ( expression-list )
22242 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
22243 to an attribute. The TREE_PURPOSE of each node is the identifier
22244 indicating which attribute is in use. The TREE_VALUE represents
22245 the arguments, if any. */
22248 cp_parser_gnu_attribute_list (cp_parser
* parser
)
22250 tree attribute_list
= NULL_TREE
;
22251 bool save_translate_strings_p
= parser
->translate_strings_p
;
22253 parser
->translate_strings_p
= false;
22260 /* Look for the identifier. We also allow keywords here; for
22261 example `__attribute__ ((const))' is legal. */
22262 token
= cp_lexer_peek_token (parser
->lexer
);
22263 if (token
->type
== CPP_NAME
22264 || token
->type
== CPP_KEYWORD
)
22266 tree arguments
= NULL_TREE
;
22268 /* Consume the token, but save it since we need it for the
22269 SIMD enabled function parsing. */
22270 cp_token
*id_token
= cp_lexer_consume_token (parser
->lexer
);
22272 /* Save away the identifier that indicates which attribute
22274 identifier
= (token
->type
== CPP_KEYWORD
)
22275 /* For keywords, use the canonical spelling, not the
22276 parsed identifier. */
22277 ? ridpointers
[(int) token
->keyword
]
22278 : id_token
->u
.value
;
22280 attribute
= build_tree_list (identifier
, NULL_TREE
);
22282 /* Peek at the next token. */
22283 token
= cp_lexer_peek_token (parser
->lexer
);
22284 /* If it's an `(', then parse the attribute arguments. */
22285 if (token
->type
== CPP_OPEN_PAREN
)
22287 vec
<tree
, va_gc
> *vec
;
22288 int attr_flag
= (attribute_takes_identifier_p (identifier
)
22289 ? id_attr
: normal_attr
);
22290 if (is_cilkplus_vector_p (identifier
))
22292 cp_parser_cilk_simd_fn_vector_attrs (parser
, id_token
);
22296 vec
= cp_parser_parenthesized_expression_list
22297 (parser
, attr_flag
, /*cast_p=*/false,
22298 /*allow_expansion_p=*/false,
22299 /*non_constant_p=*/NULL
);
22301 arguments
= error_mark_node
;
22304 arguments
= build_tree_list_vec (vec
);
22305 release_tree_vector (vec
);
22307 /* Save the arguments away. */
22308 TREE_VALUE (attribute
) = arguments
;
22310 else if (is_cilkplus_vector_p (identifier
))
22312 cp_parser_cilk_simd_fn_vector_attrs (parser
, id_token
);
22316 if (arguments
!= error_mark_node
)
22318 /* Add this attribute to the list. */
22319 TREE_CHAIN (attribute
) = attribute_list
;
22320 attribute_list
= attribute
;
22323 token
= cp_lexer_peek_token (parser
->lexer
);
22325 /* Now, look for more attributes. If the next token isn't a
22326 `,', we're done. */
22327 if (token
->type
!= CPP_COMMA
)
22330 /* Consume the comma and keep going. */
22331 cp_lexer_consume_token (parser
->lexer
);
22333 parser
->translate_strings_p
= save_translate_strings_p
;
22335 /* We built up the list in reverse order. */
22336 return nreverse (attribute_list
);
22339 /* Parse a standard C++11 attribute.
22341 The returned representation is a TREE_LIST which TREE_PURPOSE is
22342 the scoped name of the attribute, and the TREE_VALUE is its
22345 Note that the scoped name of the attribute is itself a TREE_LIST
22346 which TREE_PURPOSE is the namespace of the attribute, and
22347 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
22348 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
22349 and which TREE_PURPOSE is directly the attribute name.
22351 Clients of the attribute code should use get_attribute_namespace
22352 and get_attribute_name to get the actual namespace and name of
22353 attributes, regardless of their being GNU or C++11 attributes.
22356 attribute-token attribute-argument-clause [opt]
22360 attribute-scoped-token
22362 attribute-scoped-token:
22363 attribute-namespace :: identifier
22365 attribute-namespace:
22368 attribute-argument-clause:
22369 ( balanced-token-seq )
22371 balanced-token-seq:
22372 balanced-token [opt]
22373 balanced-token-seq balanced-token
22376 ( balanced-token-seq )
22377 [ balanced-token-seq ]
22378 { balanced-token-seq }. */
22381 cp_parser_std_attribute (cp_parser
*parser
)
22383 tree attribute
, attr_ns
= NULL_TREE
, attr_id
= NULL_TREE
, arguments
;
22386 /* First, parse name of the the attribute, a.k.a
22387 attribute-token. */
22389 token
= cp_lexer_peek_token (parser
->lexer
);
22390 if (token
->type
== CPP_NAME
)
22391 attr_id
= token
->u
.value
;
22392 else if (token
->type
== CPP_KEYWORD
)
22393 attr_id
= ridpointers
[(int) token
->keyword
];
22394 else if (token
->flags
& NAMED_OP
)
22395 attr_id
= get_identifier (cpp_type2name (token
->type
, token
->flags
));
22397 if (attr_id
== NULL_TREE
)
22400 cp_lexer_consume_token (parser
->lexer
);
22402 token
= cp_lexer_peek_token (parser
->lexer
);
22403 if (token
->type
== CPP_SCOPE
)
22405 /* We are seeing a scoped attribute token. */
22407 cp_lexer_consume_token (parser
->lexer
);
22410 token
= cp_lexer_consume_token (parser
->lexer
);
22411 if (token
->type
== CPP_NAME
)
22412 attr_id
= token
->u
.value
;
22413 else if (token
->type
== CPP_KEYWORD
)
22414 attr_id
= ridpointers
[(int) token
->keyword
];
22417 error_at (token
->location
,
22418 "expected an identifier for the attribute name");
22419 return error_mark_node
;
22421 attribute
= build_tree_list (build_tree_list (attr_ns
, attr_id
),
22423 token
= cp_lexer_peek_token (parser
->lexer
);
22427 attribute
= build_tree_list (build_tree_list (NULL_TREE
, attr_id
),
22429 /* C++11 noreturn attribute is equivalent to GNU's. */
22430 if (is_attribute_p ("noreturn", attr_id
))
22431 TREE_PURPOSE (TREE_PURPOSE (attribute
)) = get_identifier ("gnu");
22432 /* C++14 deprecated attribute is equivalent to GNU's. */
22433 else if (cxx_dialect
>= cxx11
&& is_attribute_p ("deprecated", attr_id
))
22435 if (cxx_dialect
== cxx11
)
22436 pedwarn (token
->location
, OPT_Wpedantic
,
22437 "%<deprecated%> is a C++14 feature;"
22438 " use %<gnu::deprecated%>");
22439 TREE_PURPOSE (TREE_PURPOSE (attribute
)) = get_identifier ("gnu");
22443 /* Now parse the optional argument clause of the attribute. */
22445 if (token
->type
!= CPP_OPEN_PAREN
)
22449 vec
<tree
, va_gc
> *vec
;
22450 int attr_flag
= normal_attr
;
22452 if (attr_ns
== get_identifier ("gnu")
22453 && attribute_takes_identifier_p (attr_id
))
22454 /* A GNU attribute that takes an identifier in parameter. */
22455 attr_flag
= id_attr
;
22457 vec
= cp_parser_parenthesized_expression_list
22458 (parser
, attr_flag
, /*cast_p=*/false,
22459 /*allow_expansion_p=*/true,
22460 /*non_constant_p=*/NULL
);
22462 arguments
= error_mark_node
;
22465 arguments
= build_tree_list_vec (vec
);
22466 release_tree_vector (vec
);
22469 if (arguments
== error_mark_node
)
22470 attribute
= error_mark_node
;
22472 TREE_VALUE (attribute
) = arguments
;
22478 /* Parse a list of standard C++-11 attributes.
22482 attribute-list , attribute[opt]
22484 attribute-list , attribute ...
22488 cp_parser_std_attribute_list (cp_parser
*parser
)
22490 tree attributes
= NULL_TREE
, attribute
= NULL_TREE
;
22491 cp_token
*token
= NULL
;
22495 attribute
= cp_parser_std_attribute (parser
);
22496 if (attribute
== error_mark_node
)
22498 if (attribute
!= NULL_TREE
)
22500 TREE_CHAIN (attribute
) = attributes
;
22501 attributes
= attribute
;
22503 token
= cp_lexer_peek_token (parser
->lexer
);
22504 if (token
->type
!= CPP_COMMA
)
22506 cp_lexer_consume_token (parser
->lexer
);
22508 attributes
= nreverse (attributes
);
22512 /* Parse a standard C++-11 attribute specifier.
22514 attribute-specifier:
22515 [ [ attribute-list ] ]
22516 alignment-specifier
22518 alignment-specifier:
22519 alignas ( type-id ... [opt] )
22520 alignas ( alignment-expression ... [opt] ). */
22523 cp_parser_std_attribute_spec (cp_parser
*parser
)
22525 tree attributes
= NULL_TREE
;
22526 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
22528 if (token
->type
== CPP_OPEN_SQUARE
22529 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_OPEN_SQUARE
)
22531 cp_lexer_consume_token (parser
->lexer
);
22532 cp_lexer_consume_token (parser
->lexer
);
22534 attributes
= cp_parser_std_attribute_list (parser
);
22536 if (!cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
)
22537 || !cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
))
22538 cp_parser_skip_to_end_of_statement (parser
);
22540 /* Warn about parsing c++11 attribute in non-c++1 mode, only
22541 when we are sure that we have actually parsed them. */
22542 maybe_warn_cpp0x (CPP0X_ATTRIBUTES
);
22548 /* Look for an alignment-specifier. */
22550 token
= cp_lexer_peek_token (parser
->lexer
);
22552 if (token
->type
!= CPP_KEYWORD
22553 || token
->keyword
!= RID_ALIGNAS
)
22556 cp_lexer_consume_token (parser
->lexer
);
22557 maybe_warn_cpp0x (CPP0X_ATTRIBUTES
);
22559 if (cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
) == NULL
)
22561 cp_parser_error (parser
, "expected %<(%>");
22562 return error_mark_node
;
22565 cp_parser_parse_tentatively (parser
);
22566 alignas_expr
= cp_parser_type_id (parser
);
22568 if (!cp_parser_parse_definitely (parser
))
22570 gcc_assert (alignas_expr
== error_mark_node
22571 || alignas_expr
== NULL_TREE
);
22574 cp_parser_assignment_expression (parser
);
22575 if (alignas_expr
== error_mark_node
)
22576 cp_parser_skip_to_end_of_statement (parser
);
22577 if (alignas_expr
== NULL_TREE
22578 || alignas_expr
== error_mark_node
)
22579 return alignas_expr
;
22582 if (cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
) == NULL
)
22584 cp_parser_error (parser
, "expected %<)%>");
22585 return error_mark_node
;
22588 alignas_expr
= cxx_alignas_expr (alignas_expr
);
22590 /* Build the C++-11 representation of an 'aligned'
22593 build_tree_list (build_tree_list (get_identifier ("gnu"),
22594 get_identifier ("aligned")),
22595 build_tree_list (NULL_TREE
, alignas_expr
));
22601 /* Parse a standard C++-11 attribute-specifier-seq.
22603 attribute-specifier-seq:
22604 attribute-specifier-seq [opt] attribute-specifier
22608 cp_parser_std_attribute_spec_seq (cp_parser
*parser
)
22610 tree attr_specs
= NULL
;
22614 tree attr_spec
= cp_parser_std_attribute_spec (parser
);
22615 if (attr_spec
== NULL_TREE
)
22617 if (attr_spec
== error_mark_node
)
22618 return error_mark_node
;
22620 TREE_CHAIN (attr_spec
) = attr_specs
;
22621 attr_specs
= attr_spec
;
22624 attr_specs
= nreverse (attr_specs
);
22628 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
22629 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
22630 current value of the PEDANTIC flag, regardless of whether or not
22631 the `__extension__' keyword is present. The caller is responsible
22632 for restoring the value of the PEDANTIC flag. */
22635 cp_parser_extension_opt (cp_parser
* parser
, int* saved_pedantic
)
22637 /* Save the old value of the PEDANTIC flag. */
22638 *saved_pedantic
= pedantic
;
22640 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_EXTENSION
))
22642 /* Consume the `__extension__' token. */
22643 cp_lexer_consume_token (parser
->lexer
);
22644 /* We're not being pedantic while the `__extension__' keyword is
22654 /* Parse a label declaration.
22657 __label__ label-declarator-seq ;
22659 label-declarator-seq:
22660 identifier , label-declarator-seq
22664 cp_parser_label_declaration (cp_parser
* parser
)
22666 /* Look for the `__label__' keyword. */
22667 cp_parser_require_keyword (parser
, RID_LABEL
, RT_LABEL
);
22673 /* Look for an identifier. */
22674 identifier
= cp_parser_identifier (parser
);
22675 /* If we failed, stop. */
22676 if (identifier
== error_mark_node
)
22678 /* Declare it as a label. */
22679 finish_label_decl (identifier
);
22680 /* If the next token is a `;', stop. */
22681 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
22683 /* Look for the `,' separating the label declarations. */
22684 cp_parser_require (parser
, CPP_COMMA
, RT_COMMA
);
22687 /* Look for the final `;'. */
22688 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
22691 /* Support Functions */
22693 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
22694 NAME should have one of the representations used for an
22695 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
22696 is returned. If PARSER->SCOPE is a dependent type, then a
22697 SCOPE_REF is returned.
22699 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
22700 returned; the name was already resolved when the TEMPLATE_ID_EXPR
22701 was formed. Abstractly, such entities should not be passed to this
22702 function, because they do not need to be looked up, but it is
22703 simpler to check for this special case here, rather than at the
22706 In cases not explicitly covered above, this function returns a
22707 DECL, OVERLOAD, or baselink representing the result of the lookup.
22708 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
22711 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
22712 (e.g., "struct") that was used. In that case bindings that do not
22713 refer to types are ignored.
22715 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
22718 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
22721 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
22724 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
22725 TREE_LIST of candidates if name-lookup results in an ambiguity, and
22726 NULL_TREE otherwise. */
22729 cp_parser_lookup_name (cp_parser
*parser
, tree name
,
22730 enum tag_types tag_type
,
22733 bool check_dependency
,
22734 tree
*ambiguous_decls
,
22735 location_t name_location
)
22738 tree object_type
= parser
->context
->object_type
;
22740 /* Assume that the lookup will be unambiguous. */
22741 if (ambiguous_decls
)
22742 *ambiguous_decls
= NULL_TREE
;
22744 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
22745 no longer valid. Note that if we are parsing tentatively, and
22746 the parse fails, OBJECT_TYPE will be automatically restored. */
22747 parser
->context
->object_type
= NULL_TREE
;
22749 if (name
== error_mark_node
)
22750 return error_mark_node
;
22752 /* A template-id has already been resolved; there is no lookup to
22754 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
22756 if (BASELINK_P (name
))
22758 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name
))
22759 == TEMPLATE_ID_EXPR
);
22763 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
22764 it should already have been checked to make sure that the name
22765 used matches the type being destroyed. */
22766 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
22770 /* Figure out to which type this destructor applies. */
22772 type
= parser
->scope
;
22773 else if (object_type
)
22774 type
= object_type
;
22776 type
= current_class_type
;
22777 /* If that's not a class type, there is no destructor. */
22778 if (!type
|| !CLASS_TYPE_P (type
))
22779 return error_mark_node
;
22780 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
22781 lazily_declare_fn (sfk_destructor
, type
);
22782 if (!CLASSTYPE_DESTRUCTORS (type
))
22783 return error_mark_node
;
22784 /* If it was a class type, return the destructor. */
22785 return CLASSTYPE_DESTRUCTORS (type
);
22788 /* By this point, the NAME should be an ordinary identifier. If
22789 the id-expression was a qualified name, the qualifying scope is
22790 stored in PARSER->SCOPE at this point. */
22791 gcc_assert (identifier_p (name
));
22793 /* Perform the lookup. */
22798 if (parser
->scope
== error_mark_node
)
22799 return error_mark_node
;
22801 /* If the SCOPE is dependent, the lookup must be deferred until
22802 the template is instantiated -- unless we are explicitly
22803 looking up names in uninstantiated templates. Even then, we
22804 cannot look up the name if the scope is not a class type; it
22805 might, for example, be a template type parameter. */
22806 dependent_p
= (TYPE_P (parser
->scope
)
22807 && dependent_scope_p (parser
->scope
));
22808 if ((check_dependency
|| !CLASS_TYPE_P (parser
->scope
))
22810 /* Defer lookup. */
22811 decl
= error_mark_node
;
22814 tree pushed_scope
= NULL_TREE
;
22816 /* If PARSER->SCOPE is a dependent type, then it must be a
22817 class type, and we must not be checking dependencies;
22818 otherwise, we would have processed this lookup above. So
22819 that PARSER->SCOPE is not considered a dependent base by
22820 lookup_member, we must enter the scope here. */
22822 pushed_scope
= push_scope (parser
->scope
);
22824 /* If the PARSER->SCOPE is a template specialization, it
22825 may be instantiated during name lookup. In that case,
22826 errors may be issued. Even if we rollback the current
22827 tentative parse, those errors are valid. */
22828 decl
= lookup_qualified_name (parser
->scope
, name
,
22829 tag_type
!= none_type
,
22830 /*complain=*/true);
22832 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
22833 lookup result and the nested-name-specifier nominates a class C:
22834 * if the name specified after the nested-name-specifier, when
22835 looked up in C, is the injected-class-name of C (Clause 9), or
22836 * if the name specified after the nested-name-specifier is the
22837 same as the identifier or the simple-template-id's template-
22838 name in the last component of the nested-name-specifier,
22839 the name is instead considered to name the constructor of
22840 class C. [ Note: for example, the constructor is not an
22841 acceptable lookup result in an elaborated-type-specifier so
22842 the constructor would not be used in place of the
22843 injected-class-name. --end note ] Such a constructor name
22844 shall be used only in the declarator-id of a declaration that
22845 names a constructor or in a using-declaration. */
22846 if (tag_type
== none_type
22847 && DECL_SELF_REFERENCE_P (decl
)
22848 && same_type_p (DECL_CONTEXT (decl
), parser
->scope
))
22849 decl
= lookup_qualified_name (parser
->scope
, ctor_identifier
,
22850 tag_type
!= none_type
,
22851 /*complain=*/true);
22853 /* If we have a single function from a using decl, pull it out. */
22854 if (TREE_CODE (decl
) == OVERLOAD
22855 && !really_overloaded_fn (decl
))
22856 decl
= OVL_FUNCTION (decl
);
22859 pop_scope (pushed_scope
);
22862 /* If the scope is a dependent type and either we deferred lookup or
22863 we did lookup but didn't find the name, rememeber the name. */
22864 if (decl
== error_mark_node
&& TYPE_P (parser
->scope
)
22865 && dependent_type_p (parser
->scope
))
22871 /* The resolution to Core Issue 180 says that `struct
22872 A::B' should be considered a type-name, even if `A'
22874 type
= make_typename_type (parser
->scope
, name
, tag_type
,
22875 /*complain=*/tf_error
);
22876 if (type
!= error_mark_node
)
22877 decl
= TYPE_NAME (type
);
22879 else if (is_template
22880 && (cp_parser_next_token_ends_template_argument_p (parser
)
22881 || cp_lexer_next_token_is (parser
->lexer
,
22883 decl
= make_unbound_class_template (parser
->scope
,
22885 /*complain=*/tf_error
);
22887 decl
= build_qualified_name (/*type=*/NULL_TREE
,
22888 parser
->scope
, name
,
22891 parser
->qualifying_scope
= parser
->scope
;
22892 parser
->object_scope
= NULL_TREE
;
22894 else if (object_type
)
22896 /* Look up the name in the scope of the OBJECT_TYPE, unless the
22897 OBJECT_TYPE is not a class. */
22898 if (CLASS_TYPE_P (object_type
))
22899 /* If the OBJECT_TYPE is a template specialization, it may
22900 be instantiated during name lookup. In that case, errors
22901 may be issued. Even if we rollback the current tentative
22902 parse, those errors are valid. */
22903 decl
= lookup_member (object_type
,
22906 tag_type
!= none_type
,
22907 tf_warning_or_error
);
22912 /* Look it up in the enclosing context. */
22913 decl
= lookup_name_real (name
, tag_type
!= none_type
,
22915 /*block_p=*/true, is_namespace
, 0);
22916 parser
->object_scope
= object_type
;
22917 parser
->qualifying_scope
= NULL_TREE
;
22921 decl
= lookup_name_real (name
, tag_type
!= none_type
,
22923 /*block_p=*/true, is_namespace
, 0);
22924 parser
->qualifying_scope
= NULL_TREE
;
22925 parser
->object_scope
= NULL_TREE
;
22928 /* If the lookup failed, let our caller know. */
22929 if (!decl
|| decl
== error_mark_node
)
22930 return error_mark_node
;
22932 /* Pull out the template from an injected-class-name (or multiple). */
22934 decl
= maybe_get_template_decl_from_type_decl (decl
);
22936 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
22937 if (TREE_CODE (decl
) == TREE_LIST
)
22939 if (ambiguous_decls
)
22940 *ambiguous_decls
= decl
;
22941 /* The error message we have to print is too complicated for
22942 cp_parser_error, so we incorporate its actions directly. */
22943 if (!cp_parser_simulate_error (parser
))
22945 error_at (name_location
, "reference to %qD is ambiguous",
22947 print_candidates (decl
);
22949 return error_mark_node
;
22952 gcc_assert (DECL_P (decl
)
22953 || TREE_CODE (decl
) == OVERLOAD
22954 || TREE_CODE (decl
) == SCOPE_REF
22955 || TREE_CODE (decl
) == UNBOUND_CLASS_TEMPLATE
22956 || BASELINK_P (decl
));
22958 /* If we have resolved the name of a member declaration, check to
22959 see if the declaration is accessible. When the name resolves to
22960 set of overloaded functions, accessibility is checked when
22961 overload resolution is done.
22963 During an explicit instantiation, access is not checked at all,
22964 as per [temp.explicit]. */
22966 check_accessibility_of_qualified_id (decl
, object_type
, parser
->scope
);
22968 maybe_record_typedef_use (decl
);
22973 /* Like cp_parser_lookup_name, but for use in the typical case where
22974 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
22975 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
22978 cp_parser_lookup_name_simple (cp_parser
* parser
, tree name
, location_t location
)
22980 return cp_parser_lookup_name (parser
, name
,
22982 /*is_template=*/false,
22983 /*is_namespace=*/false,
22984 /*check_dependency=*/true,
22985 /*ambiguous_decls=*/NULL
,
22989 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
22990 the current context, return the TYPE_DECL. If TAG_NAME_P is
22991 true, the DECL indicates the class being defined in a class-head,
22992 or declared in an elaborated-type-specifier.
22994 Otherwise, return DECL. */
22997 cp_parser_maybe_treat_template_as_class (tree decl
, bool tag_name_p
)
22999 /* If the TEMPLATE_DECL is being declared as part of a class-head,
23000 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
23003 template <typename T> struct B;
23006 template <typename T> struct A::B {};
23008 Similarly, in an elaborated-type-specifier:
23010 namespace N { struct X{}; }
23013 template <typename T> friend struct N::X;
23016 However, if the DECL refers to a class type, and we are in
23017 the scope of the class, then the name lookup automatically
23018 finds the TYPE_DECL created by build_self_reference rather
23019 than a TEMPLATE_DECL. For example, in:
23021 template <class T> struct S {
23025 there is no need to handle such case. */
23027 if (DECL_CLASS_TEMPLATE_P (decl
) && tag_name_p
)
23028 return DECL_TEMPLATE_RESULT (decl
);
23033 /* If too many, or too few, template-parameter lists apply to the
23034 declarator, issue an error message. Returns TRUE if all went well,
23035 and FALSE otherwise. */
23038 cp_parser_check_declarator_template_parameters (cp_parser
* parser
,
23039 cp_declarator
*declarator
,
23040 location_t declarator_location
)
23042 switch (declarator
->kind
)
23046 unsigned num_templates
= 0;
23047 tree scope
= declarator
->u
.id
.qualifying_scope
;
23050 num_templates
= num_template_headers_for_class (scope
);
23051 else if (TREE_CODE (declarator
->u
.id
.unqualified_name
)
23052 == TEMPLATE_ID_EXPR
)
23053 /* If the DECLARATOR has the form `X<y>' then it uses one
23054 additional level of template parameters. */
23057 return cp_parser_check_template_parameters
23058 (parser
, num_templates
, declarator_location
, declarator
);
23064 case cdk_reference
:
23066 return (cp_parser_check_declarator_template_parameters
23067 (parser
, declarator
->declarator
, declarator_location
));
23073 gcc_unreachable ();
23078 /* NUM_TEMPLATES were used in the current declaration. If that is
23079 invalid, return FALSE and issue an error messages. Otherwise,
23080 return TRUE. If DECLARATOR is non-NULL, then we are checking a
23081 declarator and we can print more accurate diagnostics. */
23084 cp_parser_check_template_parameters (cp_parser
* parser
,
23085 unsigned num_templates
,
23086 location_t location
,
23087 cp_declarator
*declarator
)
23089 /* If there are the same number of template classes and parameter
23090 lists, that's OK. */
23091 if (parser
->num_template_parameter_lists
== num_templates
)
23093 /* If there are more, but only one more, then we are referring to a
23094 member template. That's OK too. */
23095 if (parser
->num_template_parameter_lists
== num_templates
+ 1)
23097 /* If there are more template classes than parameter lists, we have
23100 template <class T> void S<T>::R<T>::f (); */
23101 if (parser
->num_template_parameter_lists
< num_templates
)
23103 if (declarator
&& !current_function_decl
)
23104 error_at (location
, "specializing member %<%T::%E%> "
23105 "requires %<template<>%> syntax",
23106 declarator
->u
.id
.qualifying_scope
,
23107 declarator
->u
.id
.unqualified_name
);
23108 else if (declarator
)
23109 error_at (location
, "invalid declaration of %<%T::%E%>",
23110 declarator
->u
.id
.qualifying_scope
,
23111 declarator
->u
.id
.unqualified_name
);
23113 error_at (location
, "too few template-parameter-lists");
23116 /* Otherwise, there are too many template parameter lists. We have
23119 template <class T> template <class U> void S::f(); */
23120 error_at (location
, "too many template-parameter-lists");
23124 /* Parse an optional `::' token indicating that the following name is
23125 from the global namespace. If so, PARSER->SCOPE is set to the
23126 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
23127 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
23128 Returns the new value of PARSER->SCOPE, if the `::' token is
23129 present, and NULL_TREE otherwise. */
23132 cp_parser_global_scope_opt (cp_parser
* parser
, bool current_scope_valid_p
)
23136 /* Peek at the next token. */
23137 token
= cp_lexer_peek_token (parser
->lexer
);
23138 /* If we're looking at a `::' token then we're starting from the
23139 global namespace, not our current location. */
23140 if (token
->type
== CPP_SCOPE
)
23142 /* Consume the `::' token. */
23143 cp_lexer_consume_token (parser
->lexer
);
23144 /* Set the SCOPE so that we know where to start the lookup. */
23145 parser
->scope
= global_namespace
;
23146 parser
->qualifying_scope
= global_namespace
;
23147 parser
->object_scope
= NULL_TREE
;
23149 return parser
->scope
;
23151 else if (!current_scope_valid_p
)
23153 parser
->scope
= NULL_TREE
;
23154 parser
->qualifying_scope
= NULL_TREE
;
23155 parser
->object_scope
= NULL_TREE
;
23161 /* Returns TRUE if the upcoming token sequence is the start of a
23162 constructor declarator. If FRIEND_P is true, the declarator is
23163 preceded by the `friend' specifier. */
23166 cp_parser_constructor_declarator_p (cp_parser
*parser
, bool friend_p
)
23168 bool constructor_p
;
23169 bool outside_class_specifier_p
;
23170 tree nested_name_specifier
;
23171 cp_token
*next_token
;
23173 /* The common case is that this is not a constructor declarator, so
23174 try to avoid doing lots of work if at all possible. It's not
23175 valid declare a constructor at function scope. */
23176 if (parser
->in_function_body
)
23178 /* And only certain tokens can begin a constructor declarator. */
23179 next_token
= cp_lexer_peek_token (parser
->lexer
);
23180 if (next_token
->type
!= CPP_NAME
23181 && next_token
->type
!= CPP_SCOPE
23182 && next_token
->type
!= CPP_NESTED_NAME_SPECIFIER
23183 && next_token
->type
!= CPP_TEMPLATE_ID
)
23186 /* Parse tentatively; we are going to roll back all of the tokens
23188 cp_parser_parse_tentatively (parser
);
23189 /* Assume that we are looking at a constructor declarator. */
23190 constructor_p
= true;
23192 /* Look for the optional `::' operator. */
23193 cp_parser_global_scope_opt (parser
,
23194 /*current_scope_valid_p=*/false);
23195 /* Look for the nested-name-specifier. */
23196 nested_name_specifier
23197 = (cp_parser_nested_name_specifier_opt (parser
,
23198 /*typename_keyword_p=*/false,
23199 /*check_dependency_p=*/false,
23201 /*is_declaration=*/false));
23203 outside_class_specifier_p
= (!at_class_scope_p ()
23204 || !TYPE_BEING_DEFINED (current_class_type
)
23207 /* Outside of a class-specifier, there must be a
23208 nested-name-specifier. */
23209 if (!nested_name_specifier
&& outside_class_specifier_p
)
23210 constructor_p
= false;
23211 else if (nested_name_specifier
== error_mark_node
)
23212 constructor_p
= false;
23214 /* If we have a class scope, this is easy; DR 147 says that S::S always
23215 names the constructor, and no other qualified name could. */
23216 if (constructor_p
&& nested_name_specifier
23217 && CLASS_TYPE_P (nested_name_specifier
))
23219 tree id
= cp_parser_unqualified_id (parser
,
23220 /*template_keyword_p=*/false,
23221 /*check_dependency_p=*/false,
23222 /*declarator_p=*/true,
23223 /*optional_p=*/false);
23224 if (is_overloaded_fn (id
))
23225 id
= DECL_NAME (get_first_fn (id
));
23226 if (!constructor_name_p (id
, nested_name_specifier
))
23227 constructor_p
= false;
23229 /* If we still think that this might be a constructor-declarator,
23230 look for a class-name. */
23231 else if (constructor_p
)
23235 template <typename T> struct S {
23239 we must recognize that the nested `S' names a class. */
23241 type_decl
= cp_parser_class_name (parser
,
23242 /*typename_keyword_p=*/false,
23243 /*template_keyword_p=*/false,
23245 /*check_dependency_p=*/false,
23246 /*class_head_p=*/false,
23247 /*is_declaration=*/false);
23248 /* If there was no class-name, then this is not a constructor.
23249 Otherwise, if we are in a class-specifier and we aren't
23250 handling a friend declaration, check that its type matches
23251 current_class_type (c++/38313). Note: error_mark_node
23252 is left alone for error recovery purposes. */
23253 constructor_p
= (!cp_parser_error_occurred (parser
)
23254 && (outside_class_specifier_p
23255 || type_decl
== error_mark_node
23256 || same_type_p (current_class_type
,
23257 TREE_TYPE (type_decl
))));
23259 /* If we're still considering a constructor, we have to see a `(',
23260 to begin the parameter-declaration-clause, followed by either a
23261 `)', an `...', or a decl-specifier. We need to check for a
23262 type-specifier to avoid being fooled into thinking that:
23266 is a constructor. (It is actually a function named `f' that
23267 takes one parameter (of type `int') and returns a value of type
23270 && !cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
23271 constructor_p
= false;
23274 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
)
23275 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_ELLIPSIS
)
23276 /* A parameter declaration begins with a decl-specifier,
23277 which is either the "attribute" keyword, a storage class
23278 specifier, or (usually) a type-specifier. */
23279 && !cp_lexer_next_token_is_decl_specifier_keyword (parser
->lexer
))
23282 tree pushed_scope
= NULL_TREE
;
23283 unsigned saved_num_template_parameter_lists
;
23285 /* Names appearing in the type-specifier should be looked up
23286 in the scope of the class. */
23287 if (current_class_type
)
23291 type
= TREE_TYPE (type_decl
);
23292 if (TREE_CODE (type
) == TYPENAME_TYPE
)
23294 type
= resolve_typename_type (type
,
23295 /*only_current_p=*/false);
23296 if (TREE_CODE (type
) == TYPENAME_TYPE
)
23298 cp_parser_abort_tentative_parse (parser
);
23302 pushed_scope
= push_scope (type
);
23305 /* Inside the constructor parameter list, surrounding
23306 template-parameter-lists do not apply. */
23307 saved_num_template_parameter_lists
23308 = parser
->num_template_parameter_lists
;
23309 parser
->num_template_parameter_lists
= 0;
23311 /* Look for the type-specifier. */
23312 cp_parser_type_specifier (parser
,
23313 CP_PARSER_FLAGS_NONE
,
23314 /*decl_specs=*/NULL
,
23315 /*is_declarator=*/true,
23316 /*declares_class_or_enum=*/NULL
,
23317 /*is_cv_qualifier=*/NULL
);
23319 parser
->num_template_parameter_lists
23320 = saved_num_template_parameter_lists
;
23322 /* Leave the scope of the class. */
23324 pop_scope (pushed_scope
);
23326 constructor_p
= !cp_parser_error_occurred (parser
);
23330 /* We did not really want to consume any tokens. */
23331 cp_parser_abort_tentative_parse (parser
);
23333 return constructor_p
;
23336 /* Parse the definition of the function given by the DECL_SPECIFIERS,
23337 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
23338 they must be performed once we are in the scope of the function.
23340 Returns the function defined. */
23343 cp_parser_function_definition_from_specifiers_and_declarator
23344 (cp_parser
* parser
,
23345 cp_decl_specifier_seq
*decl_specifiers
,
23347 const cp_declarator
*declarator
)
23352 /* Begin the function-definition. */
23353 success_p
= start_function (decl_specifiers
, declarator
, attributes
);
23355 /* The things we're about to see are not directly qualified by any
23356 template headers we've seen thus far. */
23357 reset_specialization ();
23359 /* If there were names looked up in the decl-specifier-seq that we
23360 did not check, check them now. We must wait until we are in the
23361 scope of the function to perform the checks, since the function
23362 might be a friend. */
23363 perform_deferred_access_checks (tf_warning_or_error
);
23367 cp_finalize_omp_declare_simd (parser
, current_function_decl
);
23368 parser
->omp_declare_simd
= NULL
;
23373 /* Skip the entire function. */
23374 cp_parser_skip_to_end_of_block_or_statement (parser
);
23375 fn
= error_mark_node
;
23377 else if (DECL_INITIAL (current_function_decl
) != error_mark_node
)
23379 /* Seen already, skip it. An error message has already been output. */
23380 cp_parser_skip_to_end_of_block_or_statement (parser
);
23381 fn
= current_function_decl
;
23382 current_function_decl
= NULL_TREE
;
23383 /* If this is a function from a class, pop the nested class. */
23384 if (current_class_name
)
23385 pop_nested_class ();
23390 if (DECL_DECLARED_INLINE_P (current_function_decl
))
23391 tv
= TV_PARSE_INLINE
;
23393 tv
= TV_PARSE_FUNC
;
23395 fn
= cp_parser_function_definition_after_declarator (parser
,
23396 /*inline_p=*/false);
23403 /* Parse the part of a function-definition that follows the
23404 declarator. INLINE_P is TRUE iff this function is an inline
23405 function defined within a class-specifier.
23407 Returns the function defined. */
23410 cp_parser_function_definition_after_declarator (cp_parser
* parser
,
23414 bool ctor_initializer_p
= false;
23415 bool saved_in_unbraced_linkage_specification_p
;
23416 bool saved_in_function_body
;
23417 unsigned saved_num_template_parameter_lists
;
23419 bool fully_implicit_function_template_p
23420 = parser
->fully_implicit_function_template_p
;
23421 parser
->fully_implicit_function_template_p
= false;
23422 tree implicit_template_parms
23423 = parser
->implicit_template_parms
;
23424 parser
->implicit_template_parms
= 0;
23425 cp_binding_level
* implicit_template_scope
23426 = parser
->implicit_template_scope
;
23427 parser
->implicit_template_scope
= 0;
23429 saved_in_function_body
= parser
->in_function_body
;
23430 parser
->in_function_body
= true;
23431 /* If the next token is `return', then the code may be trying to
23432 make use of the "named return value" extension that G++ used to
23434 token
= cp_lexer_peek_token (parser
->lexer
);
23435 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_RETURN
))
23437 /* Consume the `return' keyword. */
23438 cp_lexer_consume_token (parser
->lexer
);
23439 /* Look for the identifier that indicates what value is to be
23441 cp_parser_identifier (parser
);
23442 /* Issue an error message. */
23443 error_at (token
->location
,
23444 "named return values are no longer supported");
23445 /* Skip tokens until we reach the start of the function body. */
23448 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
23449 if (token
->type
== CPP_OPEN_BRACE
23450 || token
->type
== CPP_EOF
23451 || token
->type
== CPP_PRAGMA_EOL
)
23453 cp_lexer_consume_token (parser
->lexer
);
23456 /* The `extern' in `extern "C" void f () { ... }' does not apply to
23457 anything declared inside `f'. */
23458 saved_in_unbraced_linkage_specification_p
23459 = parser
->in_unbraced_linkage_specification_p
;
23460 parser
->in_unbraced_linkage_specification_p
= false;
23461 /* Inside the function, surrounding template-parameter-lists do not
23463 saved_num_template_parameter_lists
23464 = parser
->num_template_parameter_lists
;
23465 parser
->num_template_parameter_lists
= 0;
23467 start_lambda_scope (current_function_decl
);
23469 /* If the next token is `try', `__transaction_atomic', or
23470 `__transaction_relaxed`, then we are looking at either function-try-block
23471 or function-transaction-block. Note that all of these include the
23473 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRANSACTION_ATOMIC
))
23474 ctor_initializer_p
= cp_parser_function_transaction (parser
,
23475 RID_TRANSACTION_ATOMIC
);
23476 else if (cp_lexer_next_token_is_keyword (parser
->lexer
,
23477 RID_TRANSACTION_RELAXED
))
23478 ctor_initializer_p
= cp_parser_function_transaction (parser
,
23479 RID_TRANSACTION_RELAXED
);
23480 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRY
))
23481 ctor_initializer_p
= cp_parser_function_try_block (parser
);
23483 ctor_initializer_p
= cp_parser_ctor_initializer_opt_and_function_body
23484 (parser
, /*in_function_try_block=*/false);
23486 finish_lambda_scope ();
23488 /* Finish the function. */
23489 fn
= finish_function ((ctor_initializer_p
? 1 : 0) |
23490 (inline_p
? 2 : 0));
23491 /* Generate code for it, if necessary. */
23492 expand_or_defer_fn (fn
);
23493 /* Restore the saved values. */
23494 parser
->in_unbraced_linkage_specification_p
23495 = saved_in_unbraced_linkage_specification_p
;
23496 parser
->num_template_parameter_lists
23497 = saved_num_template_parameter_lists
;
23498 parser
->in_function_body
= saved_in_function_body
;
23500 parser
->fully_implicit_function_template_p
23501 = fully_implicit_function_template_p
;
23502 parser
->implicit_template_parms
23503 = implicit_template_parms
;
23504 parser
->implicit_template_scope
23505 = implicit_template_scope
;
23507 if (parser
->fully_implicit_function_template_p
)
23508 finish_fully_implicit_template (parser
, /*member_decl_opt=*/0);
23513 /* Parse a template-declaration, assuming that the `export' (and
23514 `extern') keywords, if present, has already been scanned. MEMBER_P
23515 is as for cp_parser_template_declaration. */
23518 cp_parser_template_declaration_after_export (cp_parser
* parser
, bool member_p
)
23520 tree decl
= NULL_TREE
;
23521 vec
<deferred_access_check
, va_gc
> *checks
;
23522 tree parameter_list
;
23523 bool friend_p
= false;
23524 bool need_lang_pop
;
23527 /* Look for the `template' keyword. */
23528 token
= cp_lexer_peek_token (parser
->lexer
);
23529 if (!cp_parser_require_keyword (parser
, RID_TEMPLATE
, RT_TEMPLATE
))
23533 if (!cp_parser_require (parser
, CPP_LESS
, RT_LESS
))
23535 if (at_class_scope_p () && current_function_decl
)
23537 /* 14.5.2.2 [temp.mem]
23539 A local class shall not have member templates. */
23540 error_at (token
->location
,
23541 "invalid declaration of member template in local class");
23542 cp_parser_skip_to_end_of_block_or_statement (parser
);
23547 A template ... shall not have C linkage. */
23548 if (current_lang_name
== lang_name_c
)
23550 error_at (token
->location
, "template with C linkage");
23551 /* Give it C++ linkage to avoid confusing other parts of the
23553 push_lang_context (lang_name_cplusplus
);
23554 need_lang_pop
= true;
23557 need_lang_pop
= false;
23559 /* We cannot perform access checks on the template parameter
23560 declarations until we know what is being declared, just as we
23561 cannot check the decl-specifier list. */
23562 push_deferring_access_checks (dk_deferred
);
23564 /* If the next token is `>', then we have an invalid
23565 specialization. Rather than complain about an invalid template
23566 parameter, issue an error message here. */
23567 if (cp_lexer_next_token_is (parser
->lexer
, CPP_GREATER
))
23569 cp_parser_error (parser
, "invalid explicit specialization");
23570 begin_specialization ();
23571 parameter_list
= NULL_TREE
;
23575 /* Parse the template parameters. */
23576 parameter_list
= cp_parser_template_parameter_list (parser
);
23579 /* Get the deferred access checks from the parameter list. These
23580 will be checked once we know what is being declared, as for a
23581 member template the checks must be performed in the scope of the
23582 class containing the member. */
23583 checks
= get_deferred_access_checks ();
23585 /* Look for the `>'. */
23586 cp_parser_skip_to_end_of_template_parameter_list (parser
);
23587 /* We just processed one more parameter list. */
23588 ++parser
->num_template_parameter_lists
;
23589 /* If the next token is `template', there are more template
23591 if (cp_lexer_next_token_is_keyword (parser
->lexer
,
23593 cp_parser_template_declaration_after_export (parser
, member_p
);
23594 else if (cxx_dialect
>= cxx11
23595 && cp_lexer_next_token_is_keyword (parser
->lexer
, RID_USING
))
23596 decl
= cp_parser_alias_declaration (parser
);
23599 /* There are no access checks when parsing a template, as we do not
23600 know if a specialization will be a friend. */
23601 push_deferring_access_checks (dk_no_check
);
23602 token
= cp_lexer_peek_token (parser
->lexer
);
23603 decl
= cp_parser_single_declaration (parser
,
23606 /*explicit_specialization_p=*/false,
23608 pop_deferring_access_checks ();
23610 /* If this is a member template declaration, let the front
23612 if (member_p
&& !friend_p
&& decl
)
23614 if (TREE_CODE (decl
) == TYPE_DECL
)
23615 cp_parser_check_access_in_redeclaration (decl
, token
->location
);
23617 decl
= finish_member_template_decl (decl
);
23619 else if (friend_p
&& decl
23620 && DECL_DECLARES_TYPE_P (decl
))
23621 make_friend_class (current_class_type
, TREE_TYPE (decl
),
23622 /*complain=*/true);
23624 /* We are done with the current parameter list. */
23625 --parser
->num_template_parameter_lists
;
23627 pop_deferring_access_checks ();
23630 finish_template_decl (parameter_list
);
23632 /* Check the template arguments for a literal operator template. */
23634 && DECL_DECLARES_FUNCTION_P (decl
)
23635 && UDLIT_OPER_P (DECL_NAME (decl
)))
23638 if (parameter_list
== NULL_TREE
)
23642 int num_parms
= TREE_VEC_LENGTH (parameter_list
);
23643 if (num_parms
== 1)
23645 tree parm_list
= TREE_VEC_ELT (parameter_list
, 0);
23646 tree parm
= INNERMOST_TEMPLATE_PARMS (parm_list
);
23647 if (TREE_TYPE (parm
) != char_type_node
23648 || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
23651 else if (num_parms
== 2 && cxx_dialect
>= cxx14
)
23653 tree parm_type
= TREE_VEC_ELT (parameter_list
, 0);
23654 tree type
= INNERMOST_TEMPLATE_PARMS (parm_type
);
23655 tree parm_list
= TREE_VEC_ELT (parameter_list
, 1);
23656 tree parm
= INNERMOST_TEMPLATE_PARMS (parm_list
);
23657 if (TREE_TYPE (parm
) != TREE_TYPE (type
)
23658 || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
23666 if (cxx_dialect
>= cxx14
)
23667 error ("literal operator template %qD has invalid parameter list."
23668 " Expected non-type template argument pack <char...>"
23669 " or <typename CharT, CharT...>",
23672 error ("literal operator template %qD has invalid parameter list."
23673 " Expected non-type template argument pack <char...>",
23677 /* Register member declarations. */
23678 if (member_p
&& !friend_p
&& decl
&& !DECL_CLASS_TEMPLATE_P (decl
))
23679 finish_member_declaration (decl
);
23680 /* For the erroneous case of a template with C linkage, we pushed an
23681 implicit C++ linkage scope; exit that scope now. */
23683 pop_lang_context ();
23684 /* If DECL is a function template, we must return to parse it later.
23685 (Even though there is no definition, there might be default
23686 arguments that need handling.) */
23687 if (member_p
&& decl
23688 && DECL_DECLARES_FUNCTION_P (decl
))
23689 vec_safe_push (unparsed_funs_with_definitions
, decl
);
23692 /* Perform the deferred access checks from a template-parameter-list.
23693 CHECKS is a TREE_LIST of access checks, as returned by
23694 get_deferred_access_checks. */
23697 cp_parser_perform_template_parameter_access_checks (vec
<deferred_access_check
, va_gc
> *checks
)
23699 ++processing_template_parmlist
;
23700 perform_access_checks (checks
, tf_warning_or_error
);
23701 --processing_template_parmlist
;
23704 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
23705 `function-definition' sequence that follows a template header.
23706 If MEMBER_P is true, this declaration appears in a class scope.
23708 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
23709 *FRIEND_P is set to TRUE iff the declaration is a friend. */
23712 cp_parser_single_declaration (cp_parser
* parser
,
23713 vec
<deferred_access_check
, va_gc
> *checks
,
23715 bool explicit_specialization_p
,
23718 int declares_class_or_enum
;
23719 tree decl
= NULL_TREE
;
23720 cp_decl_specifier_seq decl_specifiers
;
23721 bool function_definition_p
= false;
23722 cp_token
*decl_spec_token_start
;
23724 /* This function is only used when processing a template
23726 gcc_assert (innermost_scope_kind () == sk_template_parms
23727 || innermost_scope_kind () == sk_template_spec
);
23729 /* Defer access checks until we know what is being declared. */
23730 push_deferring_access_checks (dk_deferred
);
23732 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
23734 decl_spec_token_start
= cp_lexer_peek_token (parser
->lexer
);
23735 cp_parser_decl_specifier_seq (parser
,
23736 CP_PARSER_FLAGS_OPTIONAL
,
23738 &declares_class_or_enum
);
23740 *friend_p
= cp_parser_friend_p (&decl_specifiers
);
23742 /* There are no template typedefs. */
23743 if (decl_spec_seq_has_spec_p (&decl_specifiers
, ds_typedef
))
23745 error_at (decl_spec_token_start
->location
,
23746 "template declaration of %<typedef%>");
23747 decl
= error_mark_node
;
23750 /* Gather up the access checks that occurred the
23751 decl-specifier-seq. */
23752 stop_deferring_access_checks ();
23754 /* Check for the declaration of a template class. */
23755 if (declares_class_or_enum
)
23757 if (cp_parser_declares_only_class_p (parser
))
23759 decl
= shadow_tag (&decl_specifiers
);
23764 friend template <typename T> struct A<T>::B;
23767 A<T>::B will be represented by a TYPENAME_TYPE, and
23768 therefore not recognized by shadow_tag. */
23769 if (friend_p
&& *friend_p
23771 && decl_specifiers
.type
23772 && TYPE_P (decl_specifiers
.type
))
23773 decl
= decl_specifiers
.type
;
23775 if (decl
&& decl
!= error_mark_node
)
23776 decl
= TYPE_NAME (decl
);
23778 decl
= error_mark_node
;
23780 /* Perform access checks for template parameters. */
23781 cp_parser_perform_template_parameter_access_checks (checks
);
23785 /* Complain about missing 'typename' or other invalid type names. */
23786 if (!decl_specifiers
.any_type_specifiers_p
23787 && cp_parser_parse_and_diagnose_invalid_type_name (parser
))
23789 /* cp_parser_parse_and_diagnose_invalid_type_name calls
23790 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
23791 the rest of this declaration. */
23792 decl
= error_mark_node
;
23796 /* If it's not a template class, try for a template function. If
23797 the next token is a `;', then this declaration does not declare
23798 anything. But, if there were errors in the decl-specifiers, then
23799 the error might well have come from an attempted class-specifier.
23800 In that case, there's no need to warn about a missing declarator. */
23802 && (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
)
23803 || decl_specifiers
.type
!= error_mark_node
))
23805 decl
= cp_parser_init_declarator (parser
,
23808 /*function_definition_allowed_p=*/true,
23810 declares_class_or_enum
,
23811 &function_definition_p
,
23814 /* 7.1.1-1 [dcl.stc]
23816 A storage-class-specifier shall not be specified in an explicit
23817 specialization... */
23819 && explicit_specialization_p
23820 && decl_specifiers
.storage_class
!= sc_none
)
23822 error_at (decl_spec_token_start
->location
,
23823 "explicit template specialization cannot have a storage class");
23824 decl
= error_mark_node
;
23827 if (decl
&& VAR_P (decl
))
23828 check_template_variable (decl
);
23831 /* Look for a trailing `;' after the declaration. */
23832 if (!function_definition_p
23833 && (decl
== error_mark_node
23834 || !cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
)))
23835 cp_parser_skip_to_end_of_block_or_statement (parser
);
23838 pop_deferring_access_checks ();
23840 /* Clear any current qualification; whatever comes next is the start
23841 of something new. */
23842 parser
->scope
= NULL_TREE
;
23843 parser
->qualifying_scope
= NULL_TREE
;
23844 parser
->object_scope
= NULL_TREE
;
23849 /* Parse a cast-expression that is not the operand of a unary "&". */
23852 cp_parser_simple_cast_expression (cp_parser
*parser
)
23854 return cp_parser_cast_expression (parser
, /*address_p=*/false,
23855 /*cast_p=*/false, /*decltype*/false, NULL
);
23858 /* Parse a functional cast to TYPE. Returns an expression
23859 representing the cast. */
23862 cp_parser_functional_cast (cp_parser
* parser
, tree type
)
23864 vec
<tree
, va_gc
> *vec
;
23865 tree expression_list
;
23870 type
= error_mark_node
;
23872 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
23874 cp_lexer_set_source_position (parser
->lexer
);
23875 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
23876 expression_list
= cp_parser_braced_list (parser
, &nonconst_p
);
23877 CONSTRUCTOR_IS_DIRECT_INIT (expression_list
) = 1;
23878 if (TREE_CODE (type
) == TYPE_DECL
)
23879 type
= TREE_TYPE (type
);
23880 return finish_compound_literal (type
, expression_list
,
23881 tf_warning_or_error
);
23885 vec
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
23887 /*allow_expansion_p=*/true,
23888 /*non_constant_p=*/NULL
);
23890 expression_list
= error_mark_node
;
23893 expression_list
= build_tree_list_vec (vec
);
23894 release_tree_vector (vec
);
23897 cast
= build_functional_cast (type
, expression_list
,
23898 tf_warning_or_error
);
23899 /* [expr.const]/1: In an integral constant expression "only type
23900 conversions to integral or enumeration type can be used". */
23901 if (TREE_CODE (type
) == TYPE_DECL
)
23902 type
= TREE_TYPE (type
);
23903 if (cast
!= error_mark_node
23904 && !cast_valid_in_integral_constant_expression_p (type
)
23905 && cp_parser_non_integral_constant_expression (parser
,
23907 return error_mark_node
;
23911 /* Save the tokens that make up the body of a member function defined
23912 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
23913 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
23914 specifiers applied to the declaration. Returns the FUNCTION_DECL
23915 for the member function. */
23918 cp_parser_save_member_function_body (cp_parser
* parser
,
23919 cp_decl_specifier_seq
*decl_specifiers
,
23920 cp_declarator
*declarator
,
23927 /* Create the FUNCTION_DECL. */
23928 fn
= grokmethod (decl_specifiers
, declarator
, attributes
);
23929 cp_finalize_omp_declare_simd (parser
, fn
);
23930 /* If something went badly wrong, bail out now. */
23931 if (fn
== error_mark_node
)
23933 /* If there's a function-body, skip it. */
23934 if (cp_parser_token_starts_function_definition_p
23935 (cp_lexer_peek_token (parser
->lexer
)))
23936 cp_parser_skip_to_end_of_block_or_statement (parser
);
23937 return error_mark_node
;
23940 /* Remember it, if there default args to post process. */
23941 cp_parser_save_default_args (parser
, fn
);
23943 /* Save away the tokens that make up the body of the
23945 first
= parser
->lexer
->next_token
;
23946 /* Handle function try blocks. */
23947 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRY
))
23948 cp_lexer_consume_token (parser
->lexer
);
23949 /* We can have braced-init-list mem-initializers before the fn body. */
23950 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
23952 cp_lexer_consume_token (parser
->lexer
);
23953 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_BRACE
))
23955 /* cache_group will stop after an un-nested { } pair, too. */
23956 if (cp_parser_cache_group (parser
, CPP_CLOSE_PAREN
, /*depth=*/0))
23959 /* variadic mem-inits have ... after the ')'. */
23960 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
23961 cp_lexer_consume_token (parser
->lexer
);
23964 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
23965 /* Handle function try blocks. */
23966 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CATCH
))
23967 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
23968 last
= parser
->lexer
->next_token
;
23970 /* Save away the inline definition; we will process it when the
23971 class is complete. */
23972 DECL_PENDING_INLINE_INFO (fn
) = cp_token_cache_new (first
, last
);
23973 DECL_PENDING_INLINE_P (fn
) = 1;
23975 /* We need to know that this was defined in the class, so that
23976 friend templates are handled correctly. */
23977 DECL_INITIALIZED_IN_CLASS_P (fn
) = 1;
23979 /* Add FN to the queue of functions to be parsed later. */
23980 vec_safe_push (unparsed_funs_with_definitions
, fn
);
23985 /* Save the tokens that make up the in-class initializer for a non-static
23986 data member. Returns a DEFAULT_ARG. */
23989 cp_parser_save_nsdmi (cp_parser
* parser
)
23991 return cp_parser_cache_defarg (parser
, /*nsdmi=*/true);
23994 /* Parse a template-argument-list, as well as the trailing ">" (but
23995 not the opening "<"). See cp_parser_template_argument_list for the
23999 cp_parser_enclosed_template_argument_list (cp_parser
* parser
)
24003 tree saved_qualifying_scope
;
24004 tree saved_object_scope
;
24005 bool saved_greater_than_is_operator_p
;
24006 int saved_unevaluated_operand
;
24007 int saved_inhibit_evaluation_warnings
;
24011 When parsing a template-id, the first non-nested `>' is taken as
24012 the end of the template-argument-list rather than a greater-than
24014 saved_greater_than_is_operator_p
24015 = parser
->greater_than_is_operator_p
;
24016 parser
->greater_than_is_operator_p
= false;
24017 /* Parsing the argument list may modify SCOPE, so we save it
24019 saved_scope
= parser
->scope
;
24020 saved_qualifying_scope
= parser
->qualifying_scope
;
24021 saved_object_scope
= parser
->object_scope
;
24022 /* We need to evaluate the template arguments, even though this
24023 template-id may be nested within a "sizeof". */
24024 saved_unevaluated_operand
= cp_unevaluated_operand
;
24025 cp_unevaluated_operand
= 0;
24026 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
24027 c_inhibit_evaluation_warnings
= 0;
24028 /* Parse the template-argument-list itself. */
24029 if (cp_lexer_next_token_is (parser
->lexer
, CPP_GREATER
)
24030 || cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
24031 arguments
= NULL_TREE
;
24033 arguments
= cp_parser_template_argument_list (parser
);
24034 /* Look for the `>' that ends the template-argument-list. If we find
24035 a '>>' instead, it's probably just a typo. */
24036 if (cp_lexer_next_token_is (parser
->lexer
, CPP_RSHIFT
))
24038 if (cxx_dialect
!= cxx98
)
24040 /* In C++0x, a `>>' in a template argument list or cast
24041 expression is considered to be two separate `>'
24042 tokens. So, change the current token to a `>', but don't
24043 consume it: it will be consumed later when the outer
24044 template argument list (or cast expression) is parsed.
24045 Note that this replacement of `>' for `>>' is necessary
24046 even if we are parsing tentatively: in the tentative
24047 case, after calling
24048 cp_parser_enclosed_template_argument_list we will always
24049 throw away all of the template arguments and the first
24050 closing `>', either because the template argument list
24051 was erroneous or because we are replacing those tokens
24052 with a CPP_TEMPLATE_ID token. The second `>' (which will
24053 not have been thrown away) is needed either to close an
24054 outer template argument list or to complete a new-style
24056 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
24057 token
->type
= CPP_GREATER
;
24059 else if (!saved_greater_than_is_operator_p
)
24061 /* If we're in a nested template argument list, the '>>' has
24062 to be a typo for '> >'. We emit the error message, but we
24063 continue parsing and we push a '>' as next token, so that
24064 the argument list will be parsed correctly. Note that the
24065 global source location is still on the token before the
24066 '>>', so we need to say explicitly where we want it. */
24067 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
24068 error_at (token
->location
, "%<>>%> should be %<> >%> "
24069 "within a nested template argument list");
24071 token
->type
= CPP_GREATER
;
24075 /* If this is not a nested template argument list, the '>>'
24076 is a typo for '>'. Emit an error message and continue.
24077 Same deal about the token location, but here we can get it
24078 right by consuming the '>>' before issuing the diagnostic. */
24079 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
24080 error_at (token
->location
,
24081 "spurious %<>>%>, use %<>%> to terminate "
24082 "a template argument list");
24086 cp_parser_skip_to_end_of_template_parameter_list (parser
);
24087 /* The `>' token might be a greater-than operator again now. */
24088 parser
->greater_than_is_operator_p
24089 = saved_greater_than_is_operator_p
;
24090 /* Restore the SAVED_SCOPE. */
24091 parser
->scope
= saved_scope
;
24092 parser
->qualifying_scope
= saved_qualifying_scope
;
24093 parser
->object_scope
= saved_object_scope
;
24094 cp_unevaluated_operand
= saved_unevaluated_operand
;
24095 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
24100 /* MEMBER_FUNCTION is a member function, or a friend. If default
24101 arguments, or the body of the function have not yet been parsed,
24105 cp_parser_late_parsing_for_member (cp_parser
* parser
, tree member_function
)
24107 timevar_push (TV_PARSE_INMETH
);
24108 /* If this member is a template, get the underlying
24110 if (DECL_FUNCTION_TEMPLATE_P (member_function
))
24111 member_function
= DECL_TEMPLATE_RESULT (member_function
);
24113 /* There should not be any class definitions in progress at this
24114 point; the bodies of members are only parsed outside of all class
24116 gcc_assert (parser
->num_classes_being_defined
== 0);
24117 /* While we're parsing the member functions we might encounter more
24118 classes. We want to handle them right away, but we don't want
24119 them getting mixed up with functions that are currently in the
24121 push_unparsed_function_queues (parser
);
24123 /* Make sure that any template parameters are in scope. */
24124 maybe_begin_member_template_processing (member_function
);
24126 /* If the body of the function has not yet been parsed, parse it
24128 if (DECL_PENDING_INLINE_P (member_function
))
24130 tree function_scope
;
24131 cp_token_cache
*tokens
;
24133 /* The function is no longer pending; we are processing it. */
24134 tokens
= DECL_PENDING_INLINE_INFO (member_function
);
24135 DECL_PENDING_INLINE_INFO (member_function
) = NULL
;
24136 DECL_PENDING_INLINE_P (member_function
) = 0;
24138 /* If this is a local class, enter the scope of the containing
24140 function_scope
= current_function_decl
;
24141 if (function_scope
)
24142 push_function_context ();
24144 /* Push the body of the function onto the lexer stack. */
24145 cp_parser_push_lexer_for_tokens (parser
, tokens
);
24147 /* Let the front end know that we going to be defining this
24149 start_preparsed_function (member_function
, NULL_TREE
,
24150 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
24152 /* Don't do access checking if it is a templated function. */
24153 if (processing_template_decl
)
24154 push_deferring_access_checks (dk_no_check
);
24156 /* #pragma omp declare reduction needs special parsing. */
24157 if (DECL_OMP_DECLARE_REDUCTION_P (member_function
))
24159 parser
->lexer
->in_pragma
= true;
24160 cp_parser_omp_declare_reduction_exprs (member_function
, parser
);
24161 finish_function (/*inline*/2);
24162 cp_check_omp_declare_reduction (member_function
);
24165 /* Now, parse the body of the function. */
24166 cp_parser_function_definition_after_declarator (parser
,
24167 /*inline_p=*/true);
24169 if (processing_template_decl
)
24170 pop_deferring_access_checks ();
24172 /* Leave the scope of the containing function. */
24173 if (function_scope
)
24174 pop_function_context ();
24175 cp_parser_pop_lexer (parser
);
24178 /* Remove any template parameters from the symbol table. */
24179 maybe_end_member_template_processing ();
24181 /* Restore the queue. */
24182 pop_unparsed_function_queues (parser
);
24183 timevar_pop (TV_PARSE_INMETH
);
24186 /* If DECL contains any default args, remember it on the unparsed
24187 functions queue. */
24190 cp_parser_save_default_args (cp_parser
* parser
, tree decl
)
24194 for (probe
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
24196 probe
= TREE_CHAIN (probe
))
24197 if (TREE_PURPOSE (probe
))
24199 cp_default_arg_entry entry
= {current_class_type
, decl
};
24200 vec_safe_push (unparsed_funs_with_default_args
, entry
);
24205 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
24206 which is either a FIELD_DECL or PARM_DECL. Parse it and return
24207 the result. For a PARM_DECL, PARMTYPE is the corresponding type
24208 from the parameter-type-list. */
24211 cp_parser_late_parse_one_default_arg (cp_parser
*parser
, tree decl
,
24212 tree default_arg
, tree parmtype
)
24214 cp_token_cache
*tokens
;
24218 if (default_arg
== error_mark_node
)
24219 return error_mark_node
;
24221 /* Push the saved tokens for the default argument onto the parser's
24223 tokens
= DEFARG_TOKENS (default_arg
);
24224 cp_parser_push_lexer_for_tokens (parser
, tokens
);
24226 start_lambda_scope (decl
);
24228 /* Parse the default argument. */
24229 parsed_arg
= cp_parser_initializer (parser
, &dummy
, &dummy
);
24230 if (BRACE_ENCLOSED_INITIALIZER_P (parsed_arg
))
24231 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
24233 finish_lambda_scope ();
24235 if (parsed_arg
== error_mark_node
)
24236 cp_parser_skip_to_end_of_statement (parser
);
24238 if (!processing_template_decl
)
24240 /* In a non-template class, check conversions now. In a template,
24241 we'll wait and instantiate these as needed. */
24242 if (TREE_CODE (decl
) == PARM_DECL
)
24243 parsed_arg
= check_default_argument (parmtype
, parsed_arg
,
24244 tf_warning_or_error
);
24246 parsed_arg
= digest_nsdmi_init (decl
, parsed_arg
);
24249 /* If the token stream has not been completely used up, then
24250 there was extra junk after the end of the default
24252 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
24254 if (TREE_CODE (decl
) == PARM_DECL
)
24255 cp_parser_error (parser
, "expected %<,%>");
24257 cp_parser_error (parser
, "expected %<;%>");
24260 /* Revert to the main lexer. */
24261 cp_parser_pop_lexer (parser
);
24266 /* FIELD is a non-static data member with an initializer which we saved for
24267 later; parse it now. */
24270 cp_parser_late_parsing_nsdmi (cp_parser
*parser
, tree field
)
24274 maybe_begin_member_template_processing (field
);
24276 push_unparsed_function_queues (parser
);
24277 def
= cp_parser_late_parse_one_default_arg (parser
, field
,
24278 DECL_INITIAL (field
),
24280 pop_unparsed_function_queues (parser
);
24282 maybe_end_member_template_processing ();
24284 DECL_INITIAL (field
) = def
;
24287 /* FN is a FUNCTION_DECL which may contains a parameter with an
24288 unparsed DEFAULT_ARG. Parse the default args now. This function
24289 assumes that the current scope is the scope in which the default
24290 argument should be processed. */
24293 cp_parser_late_parsing_default_args (cp_parser
*parser
, tree fn
)
24295 bool saved_local_variables_forbidden_p
;
24296 tree parm
, parmdecl
;
24298 /* While we're parsing the default args, we might (due to the
24299 statement expression extension) encounter more classes. We want
24300 to handle them right away, but we don't want them getting mixed
24301 up with default args that are currently in the queue. */
24302 push_unparsed_function_queues (parser
);
24304 /* Local variable names (and the `this' keyword) may not appear
24305 in a default argument. */
24306 saved_local_variables_forbidden_p
= parser
->local_variables_forbidden_p
;
24307 parser
->local_variables_forbidden_p
= true;
24309 push_defarg_context (fn
);
24311 for (parm
= TYPE_ARG_TYPES (TREE_TYPE (fn
)),
24312 parmdecl
= DECL_ARGUMENTS (fn
);
24313 parm
&& parm
!= void_list_node
;
24314 parm
= TREE_CHAIN (parm
),
24315 parmdecl
= DECL_CHAIN (parmdecl
))
24317 tree default_arg
= TREE_PURPOSE (parm
);
24319 vec
<tree
, va_gc
> *insts
;
24326 if (TREE_CODE (default_arg
) != DEFAULT_ARG
)
24327 /* This can happen for a friend declaration for a function
24328 already declared with default arguments. */
24332 = cp_parser_late_parse_one_default_arg (parser
, parmdecl
,
24334 TREE_VALUE (parm
));
24335 if (parsed_arg
== error_mark_node
)
24340 TREE_PURPOSE (parm
) = parsed_arg
;
24342 /* Update any instantiations we've already created. */
24343 for (insts
= DEFARG_INSTANTIATIONS (default_arg
), ix
= 0;
24344 vec_safe_iterate (insts
, ix
, ©
); ix
++)
24345 TREE_PURPOSE (copy
) = parsed_arg
;
24348 pop_defarg_context ();
24350 /* Make sure no default arg is missing. */
24351 check_default_args (fn
);
24353 /* Restore the state of local_variables_forbidden_p. */
24354 parser
->local_variables_forbidden_p
= saved_local_variables_forbidden_p
;
24356 /* Restore the queue. */
24357 pop_unparsed_function_queues (parser
);
24360 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
24362 sizeof ... ( identifier )
24364 where the 'sizeof' token has already been consumed. */
24367 cp_parser_sizeof_pack (cp_parser
*parser
)
24369 /* Consume the `...'. */
24370 cp_lexer_consume_token (parser
->lexer
);
24371 maybe_warn_variadic_templates ();
24373 bool paren
= cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
);
24375 cp_lexer_consume_token (parser
->lexer
);
24377 permerror (cp_lexer_peek_token (parser
->lexer
)->location
,
24378 "%<sizeof...%> argument must be surrounded by parentheses");
24380 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
24381 tree name
= cp_parser_identifier (parser
);
24382 if (name
== error_mark_node
)
24383 return error_mark_node
;
24384 /* The name is not qualified. */
24385 parser
->scope
= NULL_TREE
;
24386 parser
->qualifying_scope
= NULL_TREE
;
24387 parser
->object_scope
= NULL_TREE
;
24388 tree expr
= cp_parser_lookup_name_simple (parser
, name
, token
->location
);
24389 if (expr
== error_mark_node
)
24390 cp_parser_name_lookup_error (parser
, name
, expr
, NLE_NULL
,
24392 if (TREE_CODE (expr
) == TYPE_DECL
)
24393 expr
= TREE_TYPE (expr
);
24394 else if (TREE_CODE (expr
) == CONST_DECL
)
24395 expr
= DECL_INITIAL (expr
);
24396 expr
= make_pack_expansion (expr
);
24399 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
24404 /* Parse the operand of `sizeof' (or a similar operator). Returns
24405 either a TYPE or an expression, depending on the form of the
24406 input. The KEYWORD indicates which kind of expression we have
24410 cp_parser_sizeof_operand (cp_parser
* parser
, enum rid keyword
)
24412 tree expr
= NULL_TREE
;
24413 const char *saved_message
;
24415 bool saved_integral_constant_expression_p
;
24416 bool saved_non_integral_constant_expression_p
;
24418 /* If it's a `...', then we are computing the length of a parameter
24420 if (keyword
== RID_SIZEOF
24421 && cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
24422 return cp_parser_sizeof_pack (parser
);
24424 /* Types cannot be defined in a `sizeof' expression. Save away the
24426 saved_message
= parser
->type_definition_forbidden_message
;
24427 /* And create the new one. */
24428 tmp
= concat ("types may not be defined in %<",
24429 IDENTIFIER_POINTER (ridpointers
[keyword
]),
24430 "%> expressions", NULL
);
24431 parser
->type_definition_forbidden_message
= tmp
;
24433 /* The restrictions on constant-expressions do not apply inside
24434 sizeof expressions. */
24435 saved_integral_constant_expression_p
24436 = parser
->integral_constant_expression_p
;
24437 saved_non_integral_constant_expression_p
24438 = parser
->non_integral_constant_expression_p
;
24439 parser
->integral_constant_expression_p
= false;
24441 /* Do not actually evaluate the expression. */
24442 ++cp_unevaluated_operand
;
24443 ++c_inhibit_evaluation_warnings
;
24444 /* If it's a `(', then we might be looking at the type-id
24446 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
24448 tree type
= NULL_TREE
;
24450 /* We can't be sure yet whether we're looking at a type-id or an
24452 cp_parser_parse_tentatively (parser
);
24453 /* Note: as a GNU Extension, compound literals are considered
24454 postfix-expressions as they are in C99, so they are valid
24455 arguments to sizeof. See comment in cp_parser_cast_expression
24457 if (cp_parser_compound_literal_p (parser
))
24458 cp_parser_simulate_error (parser
);
24461 bool saved_in_type_id_in_expr_p
= parser
->in_type_id_in_expr_p
;
24462 parser
->in_type_id_in_expr_p
= true;
24463 /* Look for the type-id. */
24464 type
= cp_parser_type_id (parser
);
24465 /* Look for the closing `)'. */
24466 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
24467 parser
->in_type_id_in_expr_p
= saved_in_type_id_in_expr_p
;
24470 /* If all went well, then we're done. */
24471 if (cp_parser_parse_definitely (parser
))
24473 cp_decl_specifier_seq decl_specs
;
24475 /* Build a trivial decl-specifier-seq. */
24476 clear_decl_specs (&decl_specs
);
24477 decl_specs
.type
= type
;
24479 /* Call grokdeclarator to figure out what type this is. */
24480 expr
= grokdeclarator (NULL
,
24484 /*attrlist=*/NULL
);
24488 /* If the type-id production did not work out, then we must be
24489 looking at the unary-expression production. */
24491 expr
= cp_parser_unary_expression (parser
);
24493 /* Go back to evaluating expressions. */
24494 --cp_unevaluated_operand
;
24495 --c_inhibit_evaluation_warnings
;
24497 /* Free the message we created. */
24499 /* And restore the old one. */
24500 parser
->type_definition_forbidden_message
= saved_message
;
24501 parser
->integral_constant_expression_p
24502 = saved_integral_constant_expression_p
;
24503 parser
->non_integral_constant_expression_p
24504 = saved_non_integral_constant_expression_p
;
24509 /* If the current declaration has no declarator, return true. */
24512 cp_parser_declares_only_class_p (cp_parser
*parser
)
24514 /* If the next token is a `;' or a `,' then there is no
24516 return (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
24517 || cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
));
24520 /* Update the DECL_SPECS to reflect the storage class indicated by
24524 cp_parser_set_storage_class (cp_parser
*parser
,
24525 cp_decl_specifier_seq
*decl_specs
,
24529 cp_storage_class storage_class
;
24531 if (parser
->in_unbraced_linkage_specification_p
)
24533 error_at (token
->location
, "invalid use of %qD in linkage specification",
24534 ridpointers
[keyword
]);
24537 else if (decl_specs
->storage_class
!= sc_none
)
24539 decl_specs
->conflicting_specifiers_p
= true;
24543 if ((keyword
== RID_EXTERN
|| keyword
== RID_STATIC
)
24544 && decl_spec_seq_has_spec_p (decl_specs
, ds_thread
)
24545 && decl_specs
->gnu_thread_keyword_p
)
24547 pedwarn (decl_specs
->locations
[ds_thread
], 0,
24548 "%<__thread%> before %qD", ridpointers
[keyword
]);
24554 storage_class
= sc_auto
;
24557 storage_class
= sc_register
;
24560 storage_class
= sc_static
;
24563 storage_class
= sc_extern
;
24566 storage_class
= sc_mutable
;
24569 gcc_unreachable ();
24571 decl_specs
->storage_class
= storage_class
;
24572 set_and_check_decl_spec_loc (decl_specs
, ds_storage_class
, token
);
24574 /* A storage class specifier cannot be applied alongside a typedef
24575 specifier. If there is a typedef specifier present then set
24576 conflicting_specifiers_p which will trigger an error later
24577 on in grokdeclarator. */
24578 if (decl_spec_seq_has_spec_p (decl_specs
, ds_typedef
))
24579 decl_specs
->conflicting_specifiers_p
= true;
24582 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
24583 is true, the type is a class or enum definition. */
24586 cp_parser_set_decl_spec_type (cp_decl_specifier_seq
*decl_specs
,
24589 bool type_definition_p
)
24591 decl_specs
->any_specifiers_p
= true;
24593 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
24594 (with, for example, in "typedef int wchar_t;") we remember that
24595 this is what happened. In system headers, we ignore these
24596 declarations so that G++ can work with system headers that are not
24598 if (decl_spec_seq_has_spec_p (decl_specs
, ds_typedef
)
24599 && !type_definition_p
24600 && (type_spec
== boolean_type_node
24601 || type_spec
== char16_type_node
24602 || type_spec
== char32_type_node
24603 || type_spec
== wchar_type_node
)
24604 && (decl_specs
->type
24605 || decl_spec_seq_has_spec_p (decl_specs
, ds_long
)
24606 || decl_spec_seq_has_spec_p (decl_specs
, ds_short
)
24607 || decl_spec_seq_has_spec_p (decl_specs
, ds_unsigned
)
24608 || decl_spec_seq_has_spec_p (decl_specs
, ds_signed
)))
24610 decl_specs
->redefined_builtin_type
= type_spec
;
24611 set_and_check_decl_spec_loc (decl_specs
,
24612 ds_redefined_builtin_type_spec
,
24614 if (!decl_specs
->type
)
24616 decl_specs
->type
= type_spec
;
24617 decl_specs
->type_definition_p
= false;
24618 set_and_check_decl_spec_loc (decl_specs
,ds_type_spec
, token
);
24621 else if (decl_specs
->type
)
24622 decl_specs
->multiple_types_p
= true;
24625 decl_specs
->type
= type_spec
;
24626 decl_specs
->type_definition_p
= type_definition_p
;
24627 decl_specs
->redefined_builtin_type
= NULL_TREE
;
24628 set_and_check_decl_spec_loc (decl_specs
, ds_type_spec
, token
);
24632 /* True iff TOKEN is the GNU keyword __thread. */
24635 token_is__thread (cp_token
*token
)
24637 gcc_assert (token
->keyword
== RID_THREAD
);
24638 return !strcmp (IDENTIFIER_POINTER (token
->u
.value
), "__thread");
24641 /* Set the location for a declarator specifier and check if it is
24644 DECL_SPECS is the sequence of declarator specifiers onto which to
24647 DS is the single declarator specifier to set which location is to
24648 be set onto the existing sequence of declarators.
24650 LOCATION is the location for the declarator specifier to
24654 set_and_check_decl_spec_loc (cp_decl_specifier_seq
*decl_specs
,
24655 cp_decl_spec ds
, cp_token
*token
)
24657 gcc_assert (ds
< ds_last
);
24659 if (decl_specs
== NULL
)
24662 source_location location
= token
->location
;
24664 if (decl_specs
->locations
[ds
] == 0)
24666 decl_specs
->locations
[ds
] = location
;
24667 if (ds
== ds_thread
)
24668 decl_specs
->gnu_thread_keyword_p
= token_is__thread (token
);
24674 if (decl_specs
->locations
[ds_long_long
] != 0)
24675 error_at (location
,
24676 "%<long long long%> is too long for GCC");
24679 decl_specs
->locations
[ds_long_long
] = location
;
24680 pedwarn_cxx98 (location
,
24682 "ISO C++ 1998 does not support %<long long%>");
24685 else if (ds
== ds_thread
)
24687 bool gnu
= token_is__thread (token
);
24688 if (gnu
!= decl_specs
->gnu_thread_keyword_p
)
24689 error_at (location
,
24690 "both %<__thread%> and %<thread_local%> specified");
24692 error_at (location
, "duplicate %qD", token
->u
.value
);
24696 static const char *const decl_spec_names
[] = {
24713 error_at (location
,
24714 "duplicate %qs", decl_spec_names
[ds
]);
24719 /* Return true iff the declarator specifier DS is present in the
24720 sequence of declarator specifiers DECL_SPECS. */
24723 decl_spec_seq_has_spec_p (const cp_decl_specifier_seq
* decl_specs
,
24726 gcc_assert (ds
< ds_last
);
24728 if (decl_specs
== NULL
)
24731 return decl_specs
->locations
[ds
] != 0;
24734 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
24735 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
24738 cp_parser_friend_p (const cp_decl_specifier_seq
*decl_specifiers
)
24740 return decl_spec_seq_has_spec_p (decl_specifiers
, ds_friend
);
24743 /* Issue an error message indicating that TOKEN_DESC was expected.
24744 If KEYWORD is true, it indicated this function is called by
24745 cp_parser_require_keword and the required token can only be
24746 a indicated keyword. */
24749 cp_parser_required_error (cp_parser
*parser
,
24750 required_token token_desc
,
24753 switch (token_desc
)
24756 cp_parser_error (parser
, "expected %<new%>");
24759 cp_parser_error (parser
, "expected %<delete%>");
24762 cp_parser_error (parser
, "expected %<return%>");
24765 cp_parser_error (parser
, "expected %<while%>");
24768 cp_parser_error (parser
, "expected %<extern%>");
24770 case RT_STATIC_ASSERT
:
24771 cp_parser_error (parser
, "expected %<static_assert%>");
24774 cp_parser_error (parser
, "expected %<decltype%>");
24777 cp_parser_error (parser
, "expected %<operator%>");
24780 cp_parser_error (parser
, "expected %<class%>");
24783 cp_parser_error (parser
, "expected %<template%>");
24786 cp_parser_error (parser
, "expected %<namespace%>");
24789 cp_parser_error (parser
, "expected %<using%>");
24792 cp_parser_error (parser
, "expected %<asm%>");
24795 cp_parser_error (parser
, "expected %<try%>");
24798 cp_parser_error (parser
, "expected %<catch%>");
24801 cp_parser_error (parser
, "expected %<throw%>");
24804 cp_parser_error (parser
, "expected %<__label__%>");
24807 cp_parser_error (parser
, "expected %<@try%>");
24809 case RT_AT_SYNCHRONIZED
:
24810 cp_parser_error (parser
, "expected %<@synchronized%>");
24813 cp_parser_error (parser
, "expected %<@throw%>");
24815 case RT_TRANSACTION_ATOMIC
:
24816 cp_parser_error (parser
, "expected %<__transaction_atomic%>");
24818 case RT_TRANSACTION_RELAXED
:
24819 cp_parser_error (parser
, "expected %<__transaction_relaxed%>");
24826 switch (token_desc
)
24829 cp_parser_error (parser
, "expected %<;%>");
24831 case RT_OPEN_PAREN
:
24832 cp_parser_error (parser
, "expected %<(%>");
24834 case RT_CLOSE_BRACE
:
24835 cp_parser_error (parser
, "expected %<}%>");
24837 case RT_OPEN_BRACE
:
24838 cp_parser_error (parser
, "expected %<{%>");
24840 case RT_CLOSE_SQUARE
:
24841 cp_parser_error (parser
, "expected %<]%>");
24843 case RT_OPEN_SQUARE
:
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 %<>%>");
24859 cp_parser_error (parser
, "expected %<=%>");
24862 cp_parser_error (parser
, "expected %<...%>");
24865 cp_parser_error (parser
, "expected %<*%>");
24868 cp_parser_error (parser
, "expected %<~%>");
24871 cp_parser_error (parser
, "expected %<:%>");
24873 case RT_COLON_SCOPE
:
24874 cp_parser_error (parser
, "expected %<:%> or %<::%>");
24876 case RT_CLOSE_PAREN
:
24877 cp_parser_error (parser
, "expected %<)%>");
24879 case RT_COMMA_CLOSE_PAREN
:
24880 cp_parser_error (parser
, "expected %<,%> or %<)%>");
24882 case RT_PRAGMA_EOL
:
24883 cp_parser_error (parser
, "expected end of line");
24886 cp_parser_error (parser
, "expected identifier");
24889 cp_parser_error (parser
, "expected selection-statement");
24891 case RT_INTERATION
:
24892 cp_parser_error (parser
, "expected iteration-statement");
24895 cp_parser_error (parser
, "expected jump-statement");
24898 cp_parser_error (parser
, "expected class-key");
24900 case RT_CLASS_TYPENAME_TEMPLATE
:
24901 cp_parser_error (parser
,
24902 "expected %<class%>, %<typename%>, or %<template%>");
24905 gcc_unreachable ();
24909 gcc_unreachable ();
24914 /* If the next token is of the indicated TYPE, consume it. Otherwise,
24915 issue an error message indicating that TOKEN_DESC was expected.
24917 Returns the token consumed, if the token had the appropriate type.
24918 Otherwise, returns NULL. */
24921 cp_parser_require (cp_parser
* parser
,
24922 enum cpp_ttype type
,
24923 required_token token_desc
)
24925 if (cp_lexer_next_token_is (parser
->lexer
, type
))
24926 return cp_lexer_consume_token (parser
->lexer
);
24929 /* Output the MESSAGE -- unless we're parsing tentatively. */
24930 if (!cp_parser_simulate_error (parser
))
24931 cp_parser_required_error (parser
, token_desc
, /*keyword=*/false);
24936 /* An error message is produced if the next token is not '>'.
24937 All further tokens are skipped until the desired token is
24938 found or '{', '}', ';' or an unbalanced ')' or ']'. */
24941 cp_parser_skip_to_end_of_template_parameter_list (cp_parser
* parser
)
24943 /* Current level of '< ... >'. */
24944 unsigned level
= 0;
24945 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
24946 unsigned nesting_depth
= 0;
24948 /* Are we ready, yet? If not, issue error message. */
24949 if (cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
))
24952 /* Skip tokens until the desired token is found. */
24955 /* Peek at the next token. */
24956 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
24959 if (!nesting_depth
)
24964 if (cxx_dialect
== cxx98
)
24965 /* C++0x views the `>>' operator as two `>' tokens, but
24968 else if (!nesting_depth
&& level
-- == 0)
24970 /* We've hit a `>>' where the first `>' closes the
24971 template argument list, and the second `>' is
24972 spurious. Just consume the `>>' and stop; we've
24973 already produced at least one error. */
24974 cp_lexer_consume_token (parser
->lexer
);
24977 /* Fall through for C++0x, so we handle the second `>' in
24981 if (!nesting_depth
&& level
-- == 0)
24983 /* We've reached the token we want, consume it and stop. */
24984 cp_lexer_consume_token (parser
->lexer
);
24989 case CPP_OPEN_PAREN
:
24990 case CPP_OPEN_SQUARE
:
24994 case CPP_CLOSE_PAREN
:
24995 case CPP_CLOSE_SQUARE
:
24996 if (nesting_depth
-- == 0)
25001 case CPP_PRAGMA_EOL
:
25002 case CPP_SEMICOLON
:
25003 case CPP_OPEN_BRACE
:
25004 case CPP_CLOSE_BRACE
:
25005 /* The '>' was probably forgotten, don't look further. */
25012 /* Consume this token. */
25013 cp_lexer_consume_token (parser
->lexer
);
25017 /* If the next token is the indicated keyword, consume it. Otherwise,
25018 issue an error message indicating that TOKEN_DESC was expected.
25020 Returns the token consumed, if the token had the appropriate type.
25021 Otherwise, returns NULL. */
25024 cp_parser_require_keyword (cp_parser
* parser
,
25026 required_token token_desc
)
25028 cp_token
*token
= cp_parser_require (parser
, CPP_KEYWORD
, token_desc
);
25030 if (token
&& token
->keyword
!= keyword
)
25032 cp_parser_required_error (parser
, token_desc
, /*keyword=*/true);
25039 /* Returns TRUE iff TOKEN is a token that can begin the body of a
25040 function-definition. */
25043 cp_parser_token_starts_function_definition_p (cp_token
* token
)
25045 return (/* An ordinary function-body begins with an `{'. */
25046 token
->type
== CPP_OPEN_BRACE
25047 /* A ctor-initializer begins with a `:'. */
25048 || token
->type
== CPP_COLON
25049 /* A function-try-block begins with `try'. */
25050 || token
->keyword
== RID_TRY
25051 /* A function-transaction-block begins with `__transaction_atomic'
25052 or `__transaction_relaxed'. */
25053 || token
->keyword
== RID_TRANSACTION_ATOMIC
25054 || token
->keyword
== RID_TRANSACTION_RELAXED
25055 /* The named return value extension begins with `return'. */
25056 || token
->keyword
== RID_RETURN
);
25059 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
25063 cp_parser_next_token_starts_class_definition_p (cp_parser
*parser
)
25067 token
= cp_lexer_peek_token (parser
->lexer
);
25068 return (token
->type
== CPP_OPEN_BRACE
25069 || (token
->type
== CPP_COLON
25070 && !parser
->colon_doesnt_start_class_def_p
));
25073 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
25074 C++0x) ending a template-argument. */
25077 cp_parser_next_token_ends_template_argument_p (cp_parser
*parser
)
25081 token
= cp_lexer_peek_token (parser
->lexer
);
25082 return (token
->type
== CPP_COMMA
25083 || token
->type
== CPP_GREATER
25084 || token
->type
== CPP_ELLIPSIS
25085 || ((cxx_dialect
!= cxx98
) && token
->type
== CPP_RSHIFT
));
25088 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
25089 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
25092 cp_parser_nth_token_starts_template_argument_list_p (cp_parser
* parser
,
25097 token
= cp_lexer_peek_nth_token (parser
->lexer
, n
);
25098 if (token
->type
== CPP_LESS
)
25100 /* Check for the sequence `<::' in the original code. It would be lexed as
25101 `[:', where `[' is a digraph, and there is no whitespace before
25103 if (token
->type
== CPP_OPEN_SQUARE
&& token
->flags
& DIGRAPH
)
25106 token2
= cp_lexer_peek_nth_token (parser
->lexer
, n
+1);
25107 if (token2
->type
== CPP_COLON
&& !(token2
->flags
& PREV_WHITE
))
25113 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
25114 or none_type otherwise. */
25116 static enum tag_types
25117 cp_parser_token_is_class_key (cp_token
* token
)
25119 switch (token
->keyword
)
25124 return record_type
;
25133 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
25134 or none_type otherwise or if the token is null. */
25136 static enum tag_types
25137 cp_parser_token_is_type_parameter_key (cp_token
* token
)
25142 switch (token
->keyword
)
25147 return typename_type
;
25154 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
25157 cp_parser_check_class_key (enum tag_types class_key
, tree type
)
25159 if (type
== error_mark_node
)
25161 if ((TREE_CODE (type
) == UNION_TYPE
) != (class_key
== union_type
))
25163 if (permerror (input_location
, "%qs tag used in naming %q#T",
25164 class_key
== union_type
? "union"
25165 : class_key
== record_type
? "struct" : "class",
25167 inform (DECL_SOURCE_LOCATION (TYPE_NAME (type
)),
25168 "%q#T was previously declared here", type
);
25172 /* Issue an error message if DECL is redeclared with different
25173 access than its original declaration [class.access.spec/3].
25174 This applies to nested classes and nested class templates.
25178 cp_parser_check_access_in_redeclaration (tree decl
, location_t location
)
25180 if (!decl
|| !CLASS_TYPE_P (TREE_TYPE (decl
)))
25183 if ((TREE_PRIVATE (decl
)
25184 != (current_access_specifier
== access_private_node
))
25185 || (TREE_PROTECTED (decl
)
25186 != (current_access_specifier
== access_protected_node
)))
25187 error_at (location
, "%qD redeclared with different access", decl
);
25190 /* Look for the `template' keyword, as a syntactic disambiguator.
25191 Return TRUE iff it is present, in which case it will be
25195 cp_parser_optional_template_keyword (cp_parser
*parser
)
25197 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TEMPLATE
))
25199 /* In C++98 the `template' keyword can only be used within templates;
25200 outside templates the parser can always figure out what is a
25201 template and what is not. In C++11, per the resolution of DR 468,
25202 `template' is allowed in cases where it is not strictly necessary. */
25203 if (!processing_template_decl
25204 && pedantic
&& cxx_dialect
== cxx98
)
25206 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
25207 pedwarn (token
->location
, OPT_Wpedantic
,
25208 "in C++98 %<template%> (as a disambiguator) is only "
25209 "allowed within templates");
25210 /* If this part of the token stream is rescanned, the same
25211 error message would be generated. So, we purge the token
25212 from the stream. */
25213 cp_lexer_purge_token (parser
->lexer
);
25218 /* Consume the `template' keyword. */
25219 cp_lexer_consume_token (parser
->lexer
);
25226 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
25227 set PARSER->SCOPE, and perform other related actions. */
25230 cp_parser_pre_parsed_nested_name_specifier (cp_parser
*parser
)
25233 struct tree_check
*check_value
;
25234 deferred_access_check
*chk
;
25235 vec
<deferred_access_check
, va_gc
> *checks
;
25237 /* Get the stored value. */
25238 check_value
= cp_lexer_consume_token (parser
->lexer
)->u
.tree_check_value
;
25239 /* Perform any access checks that were deferred. */
25240 checks
= check_value
->checks
;
25243 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
25244 perform_or_defer_access_check (chk
->binfo
,
25246 chk
->diag_decl
, tf_warning_or_error
);
25248 /* Set the scope from the stored value. */
25249 parser
->scope
= check_value
->value
;
25250 parser
->qualifying_scope
= check_value
->qualifying_scope
;
25251 parser
->object_scope
= NULL_TREE
;
25254 /* Consume tokens up through a non-nested END token. Returns TRUE if we
25255 encounter the end of a block before what we were looking for. */
25258 cp_parser_cache_group (cp_parser
*parser
,
25259 enum cpp_ttype end
,
25264 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
25266 /* Abort a parenthesized expression if we encounter a semicolon. */
25267 if ((end
== CPP_CLOSE_PAREN
|| depth
== 0)
25268 && token
->type
== CPP_SEMICOLON
)
25270 /* If we've reached the end of the file, stop. */
25271 if (token
->type
== CPP_EOF
25272 || (end
!= CPP_PRAGMA_EOL
25273 && token
->type
== CPP_PRAGMA_EOL
))
25275 if (token
->type
== CPP_CLOSE_BRACE
&& depth
== 0)
25276 /* We've hit the end of an enclosing block, so there's been some
25277 kind of syntax error. */
25280 /* Consume the token. */
25281 cp_lexer_consume_token (parser
->lexer
);
25282 /* See if it starts a new group. */
25283 if (token
->type
== CPP_OPEN_BRACE
)
25285 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, depth
+ 1);
25286 /* In theory this should probably check end == '}', but
25287 cp_parser_save_member_function_body needs it to exit
25288 after either '}' or ')' when called with ')'. */
25292 else if (token
->type
== CPP_OPEN_PAREN
)
25294 cp_parser_cache_group (parser
, CPP_CLOSE_PAREN
, depth
+ 1);
25295 if (depth
== 0 && end
== CPP_CLOSE_PAREN
)
25298 else if (token
->type
== CPP_PRAGMA
)
25299 cp_parser_cache_group (parser
, CPP_PRAGMA_EOL
, depth
+ 1);
25300 else if (token
->type
== end
)
25305 /* Like above, for caching a default argument or NSDMI. Both of these are
25306 terminated by a non-nested comma, but it can be unclear whether or not a
25307 comma is nested in a template argument list unless we do more parsing.
25308 In order to handle this ambiguity, when we encounter a ',' after a '<'
25309 we try to parse what follows as a parameter-declaration-list (in the
25310 case of a default argument) or a member-declarator (in the case of an
25311 NSDMI). If that succeeds, then we stop caching. */
25314 cp_parser_cache_defarg (cp_parser
*parser
, bool nsdmi
)
25316 unsigned depth
= 0;
25317 int maybe_template_id
= 0;
25318 cp_token
*first_token
;
25320 tree default_argument
;
25322 /* Add tokens until we have processed the entire default
25323 argument. We add the range [first_token, token). */
25324 first_token
= cp_lexer_peek_token (parser
->lexer
);
25325 if (first_token
->type
== CPP_OPEN_BRACE
)
25327 /* For list-initialization, this is straightforward. */
25328 cp_parser_cache_group (parser
, CPP_CLOSE_BRACE
, /*depth=*/0);
25329 token
= cp_lexer_peek_token (parser
->lexer
);
25335 /* Peek at the next token. */
25336 token
= cp_lexer_peek_token (parser
->lexer
);
25337 /* What we do depends on what token we have. */
25338 switch (token
->type
)
25340 /* In valid code, a default argument must be
25341 immediately followed by a `,' `)', or `...'. */
25343 if (depth
== 0 && maybe_template_id
)
25345 /* If we've seen a '<', we might be in a
25346 template-argument-list. Until Core issue 325 is
25347 resolved, we don't know how this situation ought
25348 to be handled, so try to DTRT. We check whether
25349 what comes after the comma is a valid parameter
25350 declaration list. If it is, then the comma ends
25351 the default argument; otherwise the default
25352 argument continues. */
25353 bool error
= false;
25355 /* Set ITALP so cp_parser_parameter_declaration_list
25356 doesn't decide to commit to this parse. */
25357 bool saved_italp
= parser
->in_template_argument_list_p
;
25358 parser
->in_template_argument_list_p
= true;
25360 cp_parser_parse_tentatively (parser
);
25361 cp_lexer_consume_token (parser
->lexer
);
25365 int ctor_dtor_or_conv_p
;
25366 cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
25367 &ctor_dtor_or_conv_p
,
25368 /*parenthesized_p=*/NULL
,
25370 /*friend_p=*/false);
25374 begin_scope (sk_function_parms
, NULL_TREE
);
25375 cp_parser_parameter_declaration_list (parser
, &error
);
25376 pop_bindings_and_leave_scope ();
25378 if (!cp_parser_error_occurred (parser
) && !error
)
25380 cp_parser_abort_tentative_parse (parser
);
25382 parser
->in_template_argument_list_p
= saved_italp
;
25385 case CPP_CLOSE_PAREN
:
25387 /* If we run into a non-nested `;', `}', or `]',
25388 then the code is invalid -- but the default
25389 argument is certainly over. */
25390 case CPP_SEMICOLON
:
25391 case CPP_CLOSE_BRACE
:
25392 case CPP_CLOSE_SQUARE
:
25394 /* Handle correctly int n = sizeof ... ( p ); */
25395 && token
->type
!= CPP_ELLIPSIS
)
25397 /* Update DEPTH, if necessary. */
25398 else if (token
->type
== CPP_CLOSE_PAREN
25399 || token
->type
== CPP_CLOSE_BRACE
25400 || token
->type
== CPP_CLOSE_SQUARE
)
25404 case CPP_OPEN_PAREN
:
25405 case CPP_OPEN_SQUARE
:
25406 case CPP_OPEN_BRACE
:
25412 /* This might be the comparison operator, or it might
25413 start a template argument list. */
25414 ++maybe_template_id
;
25418 if (cxx_dialect
== cxx98
)
25420 /* Fall through for C++0x, which treats the `>>'
25421 operator like two `>' tokens in certain
25427 /* This might be an operator, or it might close a
25428 template argument list. But if a previous '<'
25429 started a template argument list, this will have
25430 closed it, so we can't be in one anymore. */
25431 maybe_template_id
-= 1 + (token
->type
== CPP_RSHIFT
);
25432 if (maybe_template_id
< 0)
25433 maybe_template_id
= 0;
25437 /* If we run out of tokens, issue an error message. */
25439 case CPP_PRAGMA_EOL
:
25440 error_at (token
->location
, "file ends in default argument");
25446 /* In these cases, we should look for template-ids.
25447 For example, if the default argument is
25448 `X<int, double>()', we need to do name lookup to
25449 figure out whether or not `X' is a template; if
25450 so, the `,' does not end the default argument.
25452 That is not yet done. */
25459 /* If we've reached the end, stop. */
25463 /* Add the token to the token block. */
25464 token
= cp_lexer_consume_token (parser
->lexer
);
25467 /* Create a DEFAULT_ARG to represent the unparsed default
25469 default_argument
= make_node (DEFAULT_ARG
);
25470 DEFARG_TOKENS (default_argument
)
25471 = cp_token_cache_new (first_token
, token
);
25472 DEFARG_INSTANTIATIONS (default_argument
) = NULL
;
25474 return default_argument
;
25477 /* Begin parsing tentatively. We always save tokens while parsing
25478 tentatively so that if the tentative parsing fails we can restore the
25482 cp_parser_parse_tentatively (cp_parser
* parser
)
25484 /* Enter a new parsing context. */
25485 parser
->context
= cp_parser_context_new (parser
->context
);
25486 /* Begin saving tokens. */
25487 cp_lexer_save_tokens (parser
->lexer
);
25488 /* In order to avoid repetitive access control error messages,
25489 access checks are queued up until we are no longer parsing
25491 push_deferring_access_checks (dk_deferred
);
25494 /* Commit to the currently active tentative parse. */
25497 cp_parser_commit_to_tentative_parse (cp_parser
* parser
)
25499 cp_parser_context
*context
;
25502 /* Mark all of the levels as committed. */
25503 lexer
= parser
->lexer
;
25504 for (context
= parser
->context
; context
->next
; context
= context
->next
)
25506 if (context
->status
== CP_PARSER_STATUS_KIND_COMMITTED
)
25508 context
->status
= CP_PARSER_STATUS_KIND_COMMITTED
;
25509 while (!cp_lexer_saving_tokens (lexer
))
25510 lexer
= lexer
->next
;
25511 cp_lexer_commit_tokens (lexer
);
25515 /* Commit to the topmost currently active tentative parse.
25517 Note that this function shouldn't be called when there are
25518 irreversible side-effects while in a tentative state. For
25519 example, we shouldn't create a permanent entry in the symbol
25520 table, or issue an error message that might not apply if the
25521 tentative parse is aborted. */
25524 cp_parser_commit_to_topmost_tentative_parse (cp_parser
* parser
)
25526 cp_parser_context
*context
= parser
->context
;
25527 cp_lexer
*lexer
= parser
->lexer
;
25531 if (context
->status
== CP_PARSER_STATUS_KIND_COMMITTED
)
25533 context
->status
= CP_PARSER_STATUS_KIND_COMMITTED
;
25535 while (!cp_lexer_saving_tokens (lexer
))
25536 lexer
= lexer
->next
;
25537 cp_lexer_commit_tokens (lexer
);
25541 /* Abort the currently active tentative parse. All consumed tokens
25542 will be rolled back, and no diagnostics will be issued. */
25545 cp_parser_abort_tentative_parse (cp_parser
* parser
)
25547 gcc_assert (parser
->context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
25548 || errorcount
> 0);
25549 cp_parser_simulate_error (parser
);
25550 /* Now, pretend that we want to see if the construct was
25551 successfully parsed. */
25552 cp_parser_parse_definitely (parser
);
25555 /* Stop parsing tentatively. If a parse error has occurred, restore the
25556 token stream. Otherwise, commit to the tokens we have consumed.
25557 Returns true if no error occurred; false otherwise. */
25560 cp_parser_parse_definitely (cp_parser
* parser
)
25562 bool error_occurred
;
25563 cp_parser_context
*context
;
25565 /* Remember whether or not an error occurred, since we are about to
25566 destroy that information. */
25567 error_occurred
= cp_parser_error_occurred (parser
);
25568 /* Remove the topmost context from the stack. */
25569 context
= parser
->context
;
25570 parser
->context
= context
->next
;
25571 /* If no parse errors occurred, commit to the tentative parse. */
25572 if (!error_occurred
)
25574 /* Commit to the tokens read tentatively, unless that was
25576 if (context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
)
25577 cp_lexer_commit_tokens (parser
->lexer
);
25579 pop_to_parent_deferring_access_checks ();
25581 /* Otherwise, if errors occurred, roll back our state so that things
25582 are just as they were before we began the tentative parse. */
25585 cp_lexer_rollback_tokens (parser
->lexer
);
25586 pop_deferring_access_checks ();
25588 /* Add the context to the front of the free list. */
25589 context
->next
= cp_parser_context_free_list
;
25590 cp_parser_context_free_list
= context
;
25592 return !error_occurred
;
25595 /* Returns true if we are parsing tentatively and are not committed to
25596 this tentative parse. */
25599 cp_parser_uncommitted_to_tentative_parse_p (cp_parser
* parser
)
25601 return (cp_parser_parsing_tentatively (parser
)
25602 && parser
->context
->status
!= CP_PARSER_STATUS_KIND_COMMITTED
);
25605 /* Returns nonzero iff an error has occurred during the most recent
25606 tentative parse. */
25609 cp_parser_error_occurred (cp_parser
* parser
)
25611 return (cp_parser_parsing_tentatively (parser
)
25612 && parser
->context
->status
== CP_PARSER_STATUS_KIND_ERROR
);
25615 /* Returns nonzero if GNU extensions are allowed. */
25618 cp_parser_allow_gnu_extensions_p (cp_parser
* parser
)
25620 return parser
->allow_gnu_extensions_p
;
25623 /* Objective-C++ Productions */
25626 /* Parse an Objective-C expression, which feeds into a primary-expression
25630 objc-message-expression
25631 objc-string-literal
25632 objc-encode-expression
25633 objc-protocol-expression
25634 objc-selector-expression
25636 Returns a tree representation of the expression. */
25639 cp_parser_objc_expression (cp_parser
* parser
)
25641 /* Try to figure out what kind of declaration is present. */
25642 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
25646 case CPP_OPEN_SQUARE
:
25647 return cp_parser_objc_message_expression (parser
);
25649 case CPP_OBJC_STRING
:
25650 kwd
= cp_lexer_consume_token (parser
->lexer
);
25651 return objc_build_string_object (kwd
->u
.value
);
25654 switch (kwd
->keyword
)
25656 case RID_AT_ENCODE
:
25657 return cp_parser_objc_encode_expression (parser
);
25659 case RID_AT_PROTOCOL
:
25660 return cp_parser_objc_protocol_expression (parser
);
25662 case RID_AT_SELECTOR
:
25663 return cp_parser_objc_selector_expression (parser
);
25669 error_at (kwd
->location
,
25670 "misplaced %<@%D%> Objective-C++ construct",
25672 cp_parser_skip_to_end_of_block_or_statement (parser
);
25675 return error_mark_node
;
25678 /* Parse an Objective-C message expression.
25680 objc-message-expression:
25681 [ objc-message-receiver objc-message-args ]
25683 Returns a representation of an Objective-C message. */
25686 cp_parser_objc_message_expression (cp_parser
* parser
)
25688 tree receiver
, messageargs
;
25690 cp_lexer_consume_token (parser
->lexer
); /* Eat '['. */
25691 receiver
= cp_parser_objc_message_receiver (parser
);
25692 messageargs
= cp_parser_objc_message_args (parser
);
25693 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
25695 return objc_build_message_expr (receiver
, messageargs
);
25698 /* Parse an objc-message-receiver.
25700 objc-message-receiver:
25702 simple-type-specifier
25704 Returns a representation of the type or expression. */
25707 cp_parser_objc_message_receiver (cp_parser
* parser
)
25711 /* An Objective-C message receiver may be either (1) a type
25712 or (2) an expression. */
25713 cp_parser_parse_tentatively (parser
);
25714 rcv
= cp_parser_expression (parser
);
25716 /* If that worked out, fine. */
25717 if (cp_parser_parse_definitely (parser
))
25720 cp_parser_parse_tentatively (parser
);
25721 rcv
= cp_parser_simple_type_specifier (parser
,
25722 /*decl_specs=*/NULL
,
25723 CP_PARSER_FLAGS_NONE
);
25725 if (cp_parser_parse_definitely (parser
))
25726 return objc_get_class_reference (rcv
);
25728 cp_parser_error (parser
, "objective-c++ message receiver expected");
25729 return error_mark_node
;
25732 /* Parse the arguments and selectors comprising an Objective-C message.
25737 objc-selector-args , objc-comma-args
25739 objc-selector-args:
25740 objc-selector [opt] : assignment-expression
25741 objc-selector-args objc-selector [opt] : assignment-expression
25744 assignment-expression
25745 objc-comma-args , assignment-expression
25747 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
25748 selector arguments and TREE_VALUE containing a list of comma
25752 cp_parser_objc_message_args (cp_parser
* parser
)
25754 tree sel_args
= NULL_TREE
, addl_args
= NULL_TREE
;
25755 bool maybe_unary_selector_p
= true;
25756 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
25758 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
)
25760 tree selector
= NULL_TREE
, arg
;
25762 if (token
->type
!= CPP_COLON
)
25763 selector
= cp_parser_objc_selector (parser
);
25765 /* Detect if we have a unary selector. */
25766 if (maybe_unary_selector_p
25767 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
25768 return build_tree_list (selector
, NULL_TREE
);
25770 maybe_unary_selector_p
= false;
25771 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
25772 arg
= cp_parser_assignment_expression (parser
);
25775 = chainon (sel_args
,
25776 build_tree_list (selector
, arg
));
25778 token
= cp_lexer_peek_token (parser
->lexer
);
25781 /* Handle non-selector arguments, if any. */
25782 while (token
->type
== CPP_COMMA
)
25786 cp_lexer_consume_token (parser
->lexer
);
25787 arg
= cp_parser_assignment_expression (parser
);
25790 = chainon (addl_args
,
25791 build_tree_list (NULL_TREE
, arg
));
25793 token
= cp_lexer_peek_token (parser
->lexer
);
25796 if (sel_args
== NULL_TREE
&& addl_args
== NULL_TREE
)
25798 cp_parser_error (parser
, "objective-c++ message argument(s) are expected");
25799 return build_tree_list (error_mark_node
, error_mark_node
);
25802 return build_tree_list (sel_args
, addl_args
);
25805 /* Parse an Objective-C encode expression.
25807 objc-encode-expression:
25808 @encode objc-typename
25810 Returns an encoded representation of the type argument. */
25813 cp_parser_objc_encode_expression (cp_parser
* parser
)
25818 cp_lexer_consume_token (parser
->lexer
); /* Eat '@encode'. */
25819 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25820 token
= cp_lexer_peek_token (parser
->lexer
);
25821 type
= complete_type (cp_parser_type_id (parser
));
25822 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25826 error_at (token
->location
,
25827 "%<@encode%> must specify a type as an argument");
25828 return error_mark_node
;
25831 /* This happens if we find @encode(T) (where T is a template
25832 typename or something dependent on a template typename) when
25833 parsing a template. In that case, we can't compile it
25834 immediately, but we rather create an AT_ENCODE_EXPR which will
25835 need to be instantiated when the template is used.
25837 if (dependent_type_p (type
))
25839 tree value
= build_min (AT_ENCODE_EXPR
, size_type_node
, type
);
25840 TREE_READONLY (value
) = 1;
25844 return objc_build_encode_expr (type
);
25847 /* Parse an Objective-C @defs expression. */
25850 cp_parser_objc_defs_expression (cp_parser
*parser
)
25854 cp_lexer_consume_token (parser
->lexer
); /* Eat '@defs'. */
25855 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25856 name
= cp_parser_identifier (parser
);
25857 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25859 return objc_get_class_ivars (name
);
25862 /* Parse an Objective-C protocol expression.
25864 objc-protocol-expression:
25865 @protocol ( identifier )
25867 Returns a representation of the protocol expression. */
25870 cp_parser_objc_protocol_expression (cp_parser
* parser
)
25874 cp_lexer_consume_token (parser
->lexer
); /* Eat '@protocol'. */
25875 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25876 proto
= cp_parser_identifier (parser
);
25877 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25879 return objc_build_protocol_expr (proto
);
25882 /* Parse an Objective-C selector expression.
25884 objc-selector-expression:
25885 @selector ( objc-method-signature )
25887 objc-method-signature:
25893 objc-selector-seq objc-selector :
25895 Returns a representation of the method selector. */
25898 cp_parser_objc_selector_expression (cp_parser
* parser
)
25900 tree sel_seq
= NULL_TREE
;
25901 bool maybe_unary_selector_p
= true;
25903 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
25905 cp_lexer_consume_token (parser
->lexer
); /* Eat '@selector'. */
25906 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
25907 token
= cp_lexer_peek_token (parser
->lexer
);
25909 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
25910 || token
->type
== CPP_SCOPE
)
25912 tree selector
= NULL_TREE
;
25914 if (token
->type
!= CPP_COLON
25915 || token
->type
== CPP_SCOPE
)
25916 selector
= cp_parser_objc_selector (parser
);
25918 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
)
25919 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_SCOPE
))
25921 /* Detect if we have a unary selector. */
25922 if (maybe_unary_selector_p
)
25924 sel_seq
= selector
;
25925 goto finish_selector
;
25929 cp_parser_error (parser
, "expected %<:%>");
25932 maybe_unary_selector_p
= false;
25933 token
= cp_lexer_consume_token (parser
->lexer
);
25935 if (token
->type
== CPP_SCOPE
)
25938 = chainon (sel_seq
,
25939 build_tree_list (selector
, NULL_TREE
));
25941 = chainon (sel_seq
,
25942 build_tree_list (NULL_TREE
, NULL_TREE
));
25946 = chainon (sel_seq
,
25947 build_tree_list (selector
, NULL_TREE
));
25949 token
= cp_lexer_peek_token (parser
->lexer
);
25953 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
25955 return objc_build_selector_expr (loc
, sel_seq
);
25958 /* Parse a list of identifiers.
25960 objc-identifier-list:
25962 objc-identifier-list , identifier
25964 Returns a TREE_LIST of identifier nodes. */
25967 cp_parser_objc_identifier_list (cp_parser
* parser
)
25973 identifier
= cp_parser_identifier (parser
);
25974 if (identifier
== error_mark_node
)
25975 return error_mark_node
;
25977 list
= build_tree_list (NULL_TREE
, identifier
);
25978 sep
= cp_lexer_peek_token (parser
->lexer
);
25980 while (sep
->type
== CPP_COMMA
)
25982 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
25983 identifier
= cp_parser_identifier (parser
);
25984 if (identifier
== error_mark_node
)
25987 list
= chainon (list
, build_tree_list (NULL_TREE
,
25989 sep
= cp_lexer_peek_token (parser
->lexer
);
25995 /* Parse an Objective-C alias declaration.
25997 objc-alias-declaration:
25998 @compatibility_alias identifier identifier ;
26000 This function registers the alias mapping with the Objective-C front end.
26001 It returns nothing. */
26004 cp_parser_objc_alias_declaration (cp_parser
* parser
)
26008 cp_lexer_consume_token (parser
->lexer
); /* Eat '@compatibility_alias'. */
26009 alias
= cp_parser_identifier (parser
);
26010 orig
= cp_parser_identifier (parser
);
26011 objc_declare_alias (alias
, orig
);
26012 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26015 /* Parse an Objective-C class forward-declaration.
26017 objc-class-declaration:
26018 @class objc-identifier-list ;
26020 The function registers the forward declarations with the Objective-C
26021 front end. It returns nothing. */
26024 cp_parser_objc_class_declaration (cp_parser
* parser
)
26026 cp_lexer_consume_token (parser
->lexer
); /* Eat '@class'. */
26031 id
= cp_parser_identifier (parser
);
26032 if (id
== error_mark_node
)
26035 objc_declare_class (id
);
26037 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
26038 cp_lexer_consume_token (parser
->lexer
);
26042 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26045 /* Parse a list of Objective-C protocol references.
26047 objc-protocol-refs-opt:
26048 objc-protocol-refs [opt]
26050 objc-protocol-refs:
26051 < objc-identifier-list >
26053 Returns a TREE_LIST of identifiers, if any. */
26056 cp_parser_objc_protocol_refs_opt (cp_parser
* parser
)
26058 tree protorefs
= NULL_TREE
;
26060 if(cp_lexer_next_token_is (parser
->lexer
, CPP_LESS
))
26062 cp_lexer_consume_token (parser
->lexer
); /* Eat '<'. */
26063 protorefs
= cp_parser_objc_identifier_list (parser
);
26064 cp_parser_require (parser
, CPP_GREATER
, RT_GREATER
);
26070 /* Parse a Objective-C visibility specification. */
26073 cp_parser_objc_visibility_spec (cp_parser
* parser
)
26075 cp_token
*vis
= cp_lexer_peek_token (parser
->lexer
);
26077 switch (vis
->keyword
)
26079 case RID_AT_PRIVATE
:
26080 objc_set_visibility (OBJC_IVAR_VIS_PRIVATE
);
26082 case RID_AT_PROTECTED
:
26083 objc_set_visibility (OBJC_IVAR_VIS_PROTECTED
);
26085 case RID_AT_PUBLIC
:
26086 objc_set_visibility (OBJC_IVAR_VIS_PUBLIC
);
26088 case RID_AT_PACKAGE
:
26089 objc_set_visibility (OBJC_IVAR_VIS_PACKAGE
);
26095 /* Eat '@private'/'@protected'/'@public'. */
26096 cp_lexer_consume_token (parser
->lexer
);
26099 /* Parse an Objective-C method type. Return 'true' if it is a class
26100 (+) method, and 'false' if it is an instance (-) method. */
26103 cp_parser_objc_method_type (cp_parser
* parser
)
26105 if (cp_lexer_consume_token (parser
->lexer
)->type
== CPP_PLUS
)
26111 /* Parse an Objective-C protocol qualifier. */
26114 cp_parser_objc_protocol_qualifiers (cp_parser
* parser
)
26116 tree quals
= NULL_TREE
, node
;
26117 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26119 node
= token
->u
.value
;
26121 while (node
&& identifier_p (node
)
26122 && (node
== ridpointers
[(int) RID_IN
]
26123 || node
== ridpointers
[(int) RID_OUT
]
26124 || node
== ridpointers
[(int) RID_INOUT
]
26125 || node
== ridpointers
[(int) RID_BYCOPY
]
26126 || node
== ridpointers
[(int) RID_BYREF
]
26127 || node
== ridpointers
[(int) RID_ONEWAY
]))
26129 quals
= tree_cons (NULL_TREE
, node
, quals
);
26130 cp_lexer_consume_token (parser
->lexer
);
26131 token
= cp_lexer_peek_token (parser
->lexer
);
26132 node
= token
->u
.value
;
26138 /* Parse an Objective-C typename. */
26141 cp_parser_objc_typename (cp_parser
* parser
)
26143 tree type_name
= NULL_TREE
;
26145 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
26147 tree proto_quals
, cp_type
= NULL_TREE
;
26149 cp_lexer_consume_token (parser
->lexer
); /* Eat '('. */
26150 proto_quals
= cp_parser_objc_protocol_qualifiers (parser
);
26152 /* An ObjC type name may consist of just protocol qualifiers, in which
26153 case the type shall default to 'id'. */
26154 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
26156 cp_type
= cp_parser_type_id (parser
);
26158 /* If the type could not be parsed, an error has already
26159 been produced. For error recovery, behave as if it had
26160 not been specified, which will use the default type
26162 if (cp_type
== error_mark_node
)
26164 cp_type
= NULL_TREE
;
26165 /* We need to skip to the closing parenthesis as
26166 cp_parser_type_id() does not seem to do it for
26168 cp_parser_skip_to_closing_parenthesis (parser
,
26169 /*recovering=*/true,
26170 /*or_comma=*/false,
26171 /*consume_paren=*/false);
26175 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
26176 type_name
= build_tree_list (proto_quals
, cp_type
);
26182 /* Check to see if TYPE refers to an Objective-C selector name. */
26185 cp_parser_objc_selector_p (enum cpp_ttype type
)
26187 return (type
== CPP_NAME
|| type
== CPP_KEYWORD
26188 || type
== CPP_AND_AND
|| type
== CPP_AND_EQ
|| type
== CPP_AND
26189 || type
== CPP_OR
|| type
== CPP_COMPL
|| type
== CPP_NOT
26190 || type
== CPP_NOT_EQ
|| type
== CPP_OR_OR
|| type
== CPP_OR_EQ
26191 || type
== CPP_XOR
|| type
== CPP_XOR_EQ
);
26194 /* Parse an Objective-C selector. */
26197 cp_parser_objc_selector (cp_parser
* parser
)
26199 cp_token
*token
= cp_lexer_consume_token (parser
->lexer
);
26201 if (!cp_parser_objc_selector_p (token
->type
))
26203 error_at (token
->location
, "invalid Objective-C++ selector name");
26204 return error_mark_node
;
26207 /* C++ operator names are allowed to appear in ObjC selectors. */
26208 switch (token
->type
)
26210 case CPP_AND_AND
: return get_identifier ("and");
26211 case CPP_AND_EQ
: return get_identifier ("and_eq");
26212 case CPP_AND
: return get_identifier ("bitand");
26213 case CPP_OR
: return get_identifier ("bitor");
26214 case CPP_COMPL
: return get_identifier ("compl");
26215 case CPP_NOT
: return get_identifier ("not");
26216 case CPP_NOT_EQ
: return get_identifier ("not_eq");
26217 case CPP_OR_OR
: return get_identifier ("or");
26218 case CPP_OR_EQ
: return get_identifier ("or_eq");
26219 case CPP_XOR
: return get_identifier ("xor");
26220 case CPP_XOR_EQ
: return get_identifier ("xor_eq");
26221 default: return token
->u
.value
;
26225 /* Parse an Objective-C params list. */
26228 cp_parser_objc_method_keyword_params (cp_parser
* parser
, tree
* attributes
)
26230 tree params
= NULL_TREE
;
26231 bool maybe_unary_selector_p
= true;
26232 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26234 while (cp_parser_objc_selector_p (token
->type
) || token
->type
== CPP_COLON
)
26236 tree selector
= NULL_TREE
, type_name
, identifier
;
26237 tree parm_attr
= NULL_TREE
;
26239 if (token
->keyword
== RID_ATTRIBUTE
)
26242 if (token
->type
!= CPP_COLON
)
26243 selector
= cp_parser_objc_selector (parser
);
26245 /* Detect if we have a unary selector. */
26246 if (maybe_unary_selector_p
26247 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
26249 params
= selector
; /* Might be followed by attributes. */
26253 maybe_unary_selector_p
= false;
26254 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
26256 /* Something went quite wrong. There should be a colon
26257 here, but there is not. Stop parsing parameters. */
26260 type_name
= cp_parser_objc_typename (parser
);
26261 /* New ObjC allows attributes on parameters too. */
26262 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ATTRIBUTE
))
26263 parm_attr
= cp_parser_attributes_opt (parser
);
26264 identifier
= cp_parser_identifier (parser
);
26268 objc_build_keyword_decl (selector
,
26273 token
= cp_lexer_peek_token (parser
->lexer
);
26276 if (params
== NULL_TREE
)
26278 cp_parser_error (parser
, "objective-c++ method declaration is expected");
26279 return error_mark_node
;
26282 /* We allow tail attributes for the method. */
26283 if (token
->keyword
== RID_ATTRIBUTE
)
26285 *attributes
= cp_parser_attributes_opt (parser
);
26286 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
26287 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
26289 cp_parser_error (parser
,
26290 "method attributes must be specified at the end");
26291 return error_mark_node
;
26294 if (params
== NULL_TREE
)
26296 cp_parser_error (parser
, "objective-c++ method declaration is expected");
26297 return error_mark_node
;
26302 /* Parse the non-keyword Objective-C params. */
26305 cp_parser_objc_method_tail_params_opt (cp_parser
* parser
, bool *ellipsisp
,
26308 tree params
= make_node (TREE_LIST
);
26309 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26310 *ellipsisp
= false; /* Initially, assume no ellipsis. */
26312 while (token
->type
== CPP_COMMA
)
26314 cp_parameter_declarator
*parmdecl
;
26317 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
26318 token
= cp_lexer_peek_token (parser
->lexer
);
26320 if (token
->type
== CPP_ELLIPSIS
)
26322 cp_lexer_consume_token (parser
->lexer
); /* Eat '...'. */
26324 token
= cp_lexer_peek_token (parser
->lexer
);
26328 /* TODO: parse attributes for tail parameters. */
26329 parmdecl
= cp_parser_parameter_declaration (parser
, false, NULL
);
26330 parm
= grokdeclarator (parmdecl
->declarator
,
26331 &parmdecl
->decl_specifiers
,
26332 PARM
, /*initialized=*/0,
26333 /*attrlist=*/NULL
);
26335 chainon (params
, build_tree_list (NULL_TREE
, parm
));
26336 token
= cp_lexer_peek_token (parser
->lexer
);
26339 /* We allow tail attributes for the method. */
26340 if (token
->keyword
== RID_ATTRIBUTE
)
26342 if (*attributes
== NULL_TREE
)
26344 *attributes
= cp_parser_attributes_opt (parser
);
26345 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
)
26346 || cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
26350 /* We have an error, but parse the attributes, so that we can
26352 *attributes
= cp_parser_attributes_opt (parser
);
26354 cp_parser_error (parser
,
26355 "method attributes must be specified at the end");
26356 return error_mark_node
;
26362 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
26365 cp_parser_objc_interstitial_code (cp_parser
* parser
)
26367 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26369 /* If the next token is `extern' and the following token is a string
26370 literal, then we have a linkage specification. */
26371 if (token
->keyword
== RID_EXTERN
26372 && cp_parser_is_pure_string_literal
26373 (cp_lexer_peek_nth_token (parser
->lexer
, 2)))
26374 cp_parser_linkage_specification (parser
);
26375 /* Handle #pragma, if any. */
26376 else if (token
->type
== CPP_PRAGMA
)
26377 cp_parser_pragma (parser
, pragma_objc_icode
);
26378 /* Allow stray semicolons. */
26379 else if (token
->type
== CPP_SEMICOLON
)
26380 cp_lexer_consume_token (parser
->lexer
);
26381 /* Mark methods as optional or required, when building protocols. */
26382 else if (token
->keyword
== RID_AT_OPTIONAL
)
26384 cp_lexer_consume_token (parser
->lexer
);
26385 objc_set_method_opt (true);
26387 else if (token
->keyword
== RID_AT_REQUIRED
)
26389 cp_lexer_consume_token (parser
->lexer
);
26390 objc_set_method_opt (false);
26392 else if (token
->keyword
== RID_NAMESPACE
)
26393 cp_parser_namespace_definition (parser
);
26394 /* Other stray characters must generate errors. */
26395 else if (token
->type
== CPP_OPEN_BRACE
|| token
->type
== CPP_CLOSE_BRACE
)
26397 cp_lexer_consume_token (parser
->lexer
);
26398 error ("stray %qs between Objective-C++ methods",
26399 token
->type
== CPP_OPEN_BRACE
? "{" : "}");
26401 /* Finally, try to parse a block-declaration, or a function-definition. */
26403 cp_parser_block_declaration (parser
, /*statement_p=*/false);
26406 /* Parse a method signature. */
26409 cp_parser_objc_method_signature (cp_parser
* parser
, tree
* attributes
)
26411 tree rettype
, kwdparms
, optparms
;
26412 bool ellipsis
= false;
26413 bool is_class_method
;
26415 is_class_method
= cp_parser_objc_method_type (parser
);
26416 rettype
= cp_parser_objc_typename (parser
);
26417 *attributes
= NULL_TREE
;
26418 kwdparms
= cp_parser_objc_method_keyword_params (parser
, attributes
);
26419 if (kwdparms
== error_mark_node
)
26420 return error_mark_node
;
26421 optparms
= cp_parser_objc_method_tail_params_opt (parser
, &ellipsis
, attributes
);
26422 if (optparms
== error_mark_node
)
26423 return error_mark_node
;
26425 return objc_build_method_signature (is_class_method
, rettype
, kwdparms
, optparms
, ellipsis
);
26429 cp_parser_objc_method_maybe_bad_prefix_attributes (cp_parser
* parser
)
26432 cp_lexer_save_tokens (parser
->lexer
);
26433 tattr
= cp_parser_attributes_opt (parser
);
26434 gcc_assert (tattr
) ;
26436 /* If the attributes are followed by a method introducer, this is not allowed.
26437 Dump the attributes and flag the situation. */
26438 if (cp_lexer_next_token_is (parser
->lexer
, CPP_PLUS
)
26439 || cp_lexer_next_token_is (parser
->lexer
, CPP_MINUS
))
26442 /* Otherwise, the attributes introduce some interstitial code, possibly so
26443 rewind to allow that check. */
26444 cp_lexer_rollback_tokens (parser
->lexer
);
26448 /* Parse an Objective-C method prototype list. */
26451 cp_parser_objc_method_prototype_list (cp_parser
* parser
)
26453 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26455 while (token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26457 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
)
26459 tree attributes
, sig
;
26460 bool is_class_method
;
26461 if (token
->type
== CPP_PLUS
)
26462 is_class_method
= true;
26464 is_class_method
= false;
26465 sig
= cp_parser_objc_method_signature (parser
, &attributes
);
26466 if (sig
== error_mark_node
)
26468 cp_parser_skip_to_end_of_block_or_statement (parser
);
26469 token
= cp_lexer_peek_token (parser
->lexer
);
26472 objc_add_method_declaration (is_class_method
, sig
, attributes
);
26473 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26475 else if (token
->keyword
== RID_AT_PROPERTY
)
26476 cp_parser_objc_at_property_declaration (parser
);
26477 else if (token
->keyword
== RID_ATTRIBUTE
26478 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser
))
26479 warning_at (cp_lexer_peek_token (parser
->lexer
)->location
,
26481 "prefix attributes are ignored for methods");
26483 /* Allow for interspersed non-ObjC++ code. */
26484 cp_parser_objc_interstitial_code (parser
);
26486 token
= cp_lexer_peek_token (parser
->lexer
);
26489 if (token
->type
!= CPP_EOF
)
26490 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
26492 cp_parser_error (parser
, "expected %<@end%>");
26494 objc_finish_interface ();
26497 /* Parse an Objective-C method definition list. */
26500 cp_parser_objc_method_definition_list (cp_parser
* parser
)
26502 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26504 while (token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26508 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
)
26511 tree sig
, attribute
;
26512 bool is_class_method
;
26513 if (token
->type
== CPP_PLUS
)
26514 is_class_method
= true;
26516 is_class_method
= false;
26517 push_deferring_access_checks (dk_deferred
);
26518 sig
= cp_parser_objc_method_signature (parser
, &attribute
);
26519 if (sig
== error_mark_node
)
26521 cp_parser_skip_to_end_of_block_or_statement (parser
);
26522 token
= cp_lexer_peek_token (parser
->lexer
);
26525 objc_start_method_definition (is_class_method
, sig
, attribute
,
26528 /* For historical reasons, we accept an optional semicolon. */
26529 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
26530 cp_lexer_consume_token (parser
->lexer
);
26532 ptk
= cp_lexer_peek_token (parser
->lexer
);
26533 if (!(ptk
->type
== CPP_PLUS
|| ptk
->type
== CPP_MINUS
26534 || ptk
->type
== CPP_EOF
|| ptk
->keyword
== RID_AT_END
))
26536 perform_deferred_access_checks (tf_warning_or_error
);
26537 stop_deferring_access_checks ();
26538 meth
= cp_parser_function_definition_after_declarator (parser
,
26540 pop_deferring_access_checks ();
26541 objc_finish_method_definition (meth
);
26544 /* The following case will be removed once @synthesize is
26545 completely implemented. */
26546 else if (token
->keyword
== RID_AT_PROPERTY
)
26547 cp_parser_objc_at_property_declaration (parser
);
26548 else if (token
->keyword
== RID_AT_SYNTHESIZE
)
26549 cp_parser_objc_at_synthesize_declaration (parser
);
26550 else if (token
->keyword
== RID_AT_DYNAMIC
)
26551 cp_parser_objc_at_dynamic_declaration (parser
);
26552 else if (token
->keyword
== RID_ATTRIBUTE
26553 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser
))
26554 warning_at (token
->location
, OPT_Wattributes
,
26555 "prefix attributes are ignored for methods");
26557 /* Allow for interspersed non-ObjC++ code. */
26558 cp_parser_objc_interstitial_code (parser
);
26560 token
= cp_lexer_peek_token (parser
->lexer
);
26563 if (token
->type
!= CPP_EOF
)
26564 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
26566 cp_parser_error (parser
, "expected %<@end%>");
26568 objc_finish_implementation ();
26571 /* Parse Objective-C ivars. */
26574 cp_parser_objc_class_ivars (cp_parser
* parser
)
26576 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
26578 if (token
->type
!= CPP_OPEN_BRACE
)
26579 return; /* No ivars specified. */
26581 cp_lexer_consume_token (parser
->lexer
); /* Eat '{'. */
26582 token
= cp_lexer_peek_token (parser
->lexer
);
26584 while (token
->type
!= CPP_CLOSE_BRACE
26585 && token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26587 cp_decl_specifier_seq declspecs
;
26588 int decl_class_or_enum_p
;
26589 tree prefix_attributes
;
26591 cp_parser_objc_visibility_spec (parser
);
26593 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
26596 cp_parser_decl_specifier_seq (parser
,
26597 CP_PARSER_FLAGS_OPTIONAL
,
26599 &decl_class_or_enum_p
);
26601 /* auto, register, static, extern, mutable. */
26602 if (declspecs
.storage_class
!= sc_none
)
26604 cp_parser_error (parser
, "invalid type for instance variable");
26605 declspecs
.storage_class
= sc_none
;
26608 /* thread_local. */
26609 if (decl_spec_seq_has_spec_p (&declspecs
, ds_thread
))
26611 cp_parser_error (parser
, "invalid type for instance variable");
26612 declspecs
.locations
[ds_thread
] = 0;
26616 if (decl_spec_seq_has_spec_p (&declspecs
, ds_typedef
))
26618 cp_parser_error (parser
, "invalid type for instance variable");
26619 declspecs
.locations
[ds_typedef
] = 0;
26622 prefix_attributes
= declspecs
.attributes
;
26623 declspecs
.attributes
= NULL_TREE
;
26625 /* Keep going until we hit the `;' at the end of the
26627 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
26629 tree width
= NULL_TREE
, attributes
, first_attribute
, decl
;
26630 cp_declarator
*declarator
= NULL
;
26631 int ctor_dtor_or_conv_p
;
26633 /* Check for a (possibly unnamed) bitfield declaration. */
26634 token
= cp_lexer_peek_token (parser
->lexer
);
26635 if (token
->type
== CPP_COLON
)
26638 if (token
->type
== CPP_NAME
26639 && (cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
26642 /* Get the name of the bitfield. */
26643 declarator
= make_id_declarator (NULL_TREE
,
26644 cp_parser_identifier (parser
),
26648 cp_lexer_consume_token (parser
->lexer
); /* Eat ':'. */
26649 /* Get the width of the bitfield. */
26651 = cp_parser_constant_expression (parser
);
26655 /* Parse the declarator. */
26657 = cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
26658 &ctor_dtor_or_conv_p
,
26659 /*parenthesized_p=*/NULL
,
26660 /*member_p=*/false,
26661 /*friend_p=*/false);
26664 /* Look for attributes that apply to the ivar. */
26665 attributes
= cp_parser_attributes_opt (parser
);
26666 /* Remember which attributes are prefix attributes and
26668 first_attribute
= attributes
;
26669 /* Combine the attributes. */
26670 attributes
= chainon (prefix_attributes
, attributes
);
26673 /* Create the bitfield declaration. */
26674 decl
= grokbitfield (declarator
, &declspecs
,
26678 decl
= grokfield (declarator
, &declspecs
,
26679 NULL_TREE
, /*init_const_expr_p=*/false,
26680 NULL_TREE
, attributes
);
26682 /* Add the instance variable. */
26683 if (decl
!= error_mark_node
&& decl
!= NULL_TREE
)
26684 objc_add_instance_variable (decl
);
26686 /* Reset PREFIX_ATTRIBUTES. */
26687 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
26688 attributes
= TREE_CHAIN (attributes
);
26690 TREE_CHAIN (attributes
) = NULL_TREE
;
26692 token
= cp_lexer_peek_token (parser
->lexer
);
26694 if (token
->type
== CPP_COMMA
)
26696 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
26702 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26703 token
= cp_lexer_peek_token (parser
->lexer
);
26706 if (token
->keyword
== RID_AT_END
)
26707 cp_parser_error (parser
, "expected %<}%>");
26709 /* Do not consume the RID_AT_END, so it will be read again as terminating
26710 the @interface of @implementation. */
26711 if (token
->keyword
!= RID_AT_END
&& token
->type
!= CPP_EOF
)
26712 cp_lexer_consume_token (parser
->lexer
); /* Eat '}'. */
26714 /* For historical reasons, we accept an optional semicolon. */
26715 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
26716 cp_lexer_consume_token (parser
->lexer
);
26719 /* Parse an Objective-C protocol declaration. */
26722 cp_parser_objc_protocol_declaration (cp_parser
* parser
, tree attributes
)
26724 tree proto
, protorefs
;
26727 cp_lexer_consume_token (parser
->lexer
); /* Eat '@protocol'. */
26728 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
26730 tok
= cp_lexer_peek_token (parser
->lexer
);
26731 error_at (tok
->location
, "identifier expected after %<@protocol%>");
26732 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26736 /* See if we have a forward declaration or a definition. */
26737 tok
= cp_lexer_peek_nth_token (parser
->lexer
, 2);
26739 /* Try a forward declaration first. */
26740 if (tok
->type
== CPP_COMMA
|| tok
->type
== CPP_SEMICOLON
)
26746 id
= cp_parser_identifier (parser
);
26747 if (id
== error_mark_node
)
26750 objc_declare_protocol (id
, attributes
);
26752 if(cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
26753 cp_lexer_consume_token (parser
->lexer
);
26757 cp_parser_consume_semicolon_at_end_of_statement (parser
);
26760 /* Ok, we got a full-fledged definition (or at least should). */
26763 proto
= cp_parser_identifier (parser
);
26764 protorefs
= cp_parser_objc_protocol_refs_opt (parser
);
26765 objc_start_protocol (proto
, protorefs
, attributes
);
26766 cp_parser_objc_method_prototype_list (parser
);
26770 /* Parse an Objective-C superclass or category. */
26773 cp_parser_objc_superclass_or_category (cp_parser
*parser
,
26776 tree
*categ
, bool *is_class_extension
)
26778 cp_token
*next
= cp_lexer_peek_token (parser
->lexer
);
26780 *super
= *categ
= NULL_TREE
;
26781 *is_class_extension
= false;
26782 if (next
->type
== CPP_COLON
)
26784 cp_lexer_consume_token (parser
->lexer
); /* Eat ':'. */
26785 *super
= cp_parser_identifier (parser
);
26787 else if (next
->type
== CPP_OPEN_PAREN
)
26789 cp_lexer_consume_token (parser
->lexer
); /* Eat '('. */
26791 /* If there is no category name, and this is an @interface, we
26792 have a class extension. */
26793 if (iface_p
&& cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
26795 *categ
= NULL_TREE
;
26796 *is_class_extension
= true;
26799 *categ
= cp_parser_identifier (parser
);
26801 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
26805 /* Parse an Objective-C class interface. */
26808 cp_parser_objc_class_interface (cp_parser
* parser
, tree attributes
)
26810 tree name
, super
, categ
, protos
;
26811 bool is_class_extension
;
26813 cp_lexer_consume_token (parser
->lexer
); /* Eat '@interface'. */
26814 name
= cp_parser_identifier (parser
);
26815 if (name
== error_mark_node
)
26817 /* It's hard to recover because even if valid @interface stuff
26818 is to follow, we can't compile it (or validate it) if we
26819 don't even know which class it refers to. Let's assume this
26820 was a stray '@interface' token in the stream and skip it.
26824 cp_parser_objc_superclass_or_category (parser
, true, &super
, &categ
,
26825 &is_class_extension
);
26826 protos
= cp_parser_objc_protocol_refs_opt (parser
);
26828 /* We have either a class or a category on our hands. */
26829 if (categ
|| is_class_extension
)
26830 objc_start_category_interface (name
, categ
, protos
, attributes
);
26833 objc_start_class_interface (name
, super
, protos
, attributes
);
26834 /* Handle instance variable declarations, if any. */
26835 cp_parser_objc_class_ivars (parser
);
26836 objc_continue_interface ();
26839 cp_parser_objc_method_prototype_list (parser
);
26842 /* Parse an Objective-C class implementation. */
26845 cp_parser_objc_class_implementation (cp_parser
* parser
)
26847 tree name
, super
, categ
;
26848 bool is_class_extension
;
26850 cp_lexer_consume_token (parser
->lexer
); /* Eat '@implementation'. */
26851 name
= cp_parser_identifier (parser
);
26852 if (name
== error_mark_node
)
26854 /* It's hard to recover because even if valid @implementation
26855 stuff is to follow, we can't compile it (or validate it) if
26856 we don't even know which class it refers to. Let's assume
26857 this was a stray '@implementation' token in the stream and
26862 cp_parser_objc_superclass_or_category (parser
, false, &super
, &categ
,
26863 &is_class_extension
);
26865 /* We have either a class or a category on our hands. */
26867 objc_start_category_implementation (name
, categ
);
26870 objc_start_class_implementation (name
, super
);
26871 /* Handle instance variable declarations, if any. */
26872 cp_parser_objc_class_ivars (parser
);
26873 objc_continue_implementation ();
26876 cp_parser_objc_method_definition_list (parser
);
26879 /* Consume the @end token and finish off the implementation. */
26882 cp_parser_objc_end_implementation (cp_parser
* parser
)
26884 cp_lexer_consume_token (parser
->lexer
); /* Eat '@end'. */
26885 objc_finish_implementation ();
26888 /* Parse an Objective-C declaration. */
26891 cp_parser_objc_declaration (cp_parser
* parser
, tree attributes
)
26893 /* Try to figure out what kind of declaration is present. */
26894 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
26897 switch (kwd
->keyword
)
26902 error_at (kwd
->location
, "attributes may not be specified before"
26903 " the %<@%D%> Objective-C++ keyword",
26907 case RID_AT_IMPLEMENTATION
:
26908 warning_at (kwd
->location
, OPT_Wattributes
,
26909 "prefix attributes are ignored before %<@%D%>",
26916 switch (kwd
->keyword
)
26919 cp_parser_objc_alias_declaration (parser
);
26922 cp_parser_objc_class_declaration (parser
);
26924 case RID_AT_PROTOCOL
:
26925 cp_parser_objc_protocol_declaration (parser
, attributes
);
26927 case RID_AT_INTERFACE
:
26928 cp_parser_objc_class_interface (parser
, attributes
);
26930 case RID_AT_IMPLEMENTATION
:
26931 cp_parser_objc_class_implementation (parser
);
26934 cp_parser_objc_end_implementation (parser
);
26937 error_at (kwd
->location
, "misplaced %<@%D%> Objective-C++ construct",
26939 cp_parser_skip_to_end_of_block_or_statement (parser
);
26943 /* Parse an Objective-C try-catch-finally statement.
26945 objc-try-catch-finally-stmt:
26946 @try compound-statement objc-catch-clause-seq [opt]
26947 objc-finally-clause [opt]
26949 objc-catch-clause-seq:
26950 objc-catch-clause objc-catch-clause-seq [opt]
26953 @catch ( objc-exception-declaration ) compound-statement
26955 objc-finally-clause:
26956 @finally compound-statement
26958 objc-exception-declaration:
26959 parameter-declaration
26962 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
26966 PS: This function is identical to c_parser_objc_try_catch_finally_statement
26967 for C. Keep them in sync. */
26970 cp_parser_objc_try_catch_finally_statement (cp_parser
*parser
)
26972 location_t location
;
26975 cp_parser_require_keyword (parser
, RID_AT_TRY
, RT_AT_TRY
);
26976 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
26977 objc_maybe_warn_exceptions (location
);
26978 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
26979 node, lest it get absorbed into the surrounding block. */
26980 stmt
= push_stmt_list ();
26981 cp_parser_compound_statement (parser
, NULL
, false, false);
26982 objc_begin_try_stmt (location
, pop_stmt_list (stmt
));
26984 while (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_CATCH
))
26986 cp_parameter_declarator
*parm
;
26987 tree parameter_declaration
= error_mark_node
;
26988 bool seen_open_paren
= false;
26990 cp_lexer_consume_token (parser
->lexer
);
26991 if (cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
26992 seen_open_paren
= true;
26993 if (cp_lexer_next_token_is (parser
->lexer
, CPP_ELLIPSIS
))
26995 /* We have "@catch (...)" (where the '...' are literally
26996 what is in the code). Skip the '...'.
26997 parameter_declaration is set to NULL_TREE, and
26998 objc_being_catch_clauses() knows that that means
27000 cp_lexer_consume_token (parser
->lexer
);
27001 parameter_declaration
= NULL_TREE
;
27005 /* We have "@catch (NSException *exception)" or something
27006 like that. Parse the parameter declaration. */
27007 parm
= cp_parser_parameter_declaration (parser
, false, NULL
);
27009 parameter_declaration
= error_mark_node
;
27011 parameter_declaration
= grokdeclarator (parm
->declarator
,
27012 &parm
->decl_specifiers
,
27013 PARM
, /*initialized=*/0,
27014 /*attrlist=*/NULL
);
27016 if (seen_open_paren
)
27017 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
27020 /* If there was no open parenthesis, we are recovering from
27021 an error, and we are trying to figure out what mistake
27022 the user has made. */
27024 /* If there is an immediate closing parenthesis, the user
27025 probably forgot the opening one (ie, they typed "@catch
27026 NSException *e)". Parse the closing parenthesis and keep
27028 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
27029 cp_lexer_consume_token (parser
->lexer
);
27031 /* If these is no immediate closing parenthesis, the user
27032 probably doesn't know that parenthesis are required at
27033 all (ie, they typed "@catch NSException *e"). So, just
27034 forget about the closing parenthesis and keep going. */
27036 objc_begin_catch_clause (parameter_declaration
);
27037 cp_parser_compound_statement (parser
, NULL
, false, false);
27038 objc_finish_catch_clause ();
27040 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AT_FINALLY
))
27042 cp_lexer_consume_token (parser
->lexer
);
27043 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
27044 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
27045 node, lest it get absorbed into the surrounding block. */
27046 stmt
= push_stmt_list ();
27047 cp_parser_compound_statement (parser
, NULL
, false, false);
27048 objc_build_finally_clause (location
, pop_stmt_list (stmt
));
27051 return objc_finish_try_stmt ();
27054 /* Parse an Objective-C synchronized statement.
27056 objc-synchronized-stmt:
27057 @synchronized ( expression ) compound-statement
27059 Returns NULL_TREE. */
27062 cp_parser_objc_synchronized_statement (cp_parser
*parser
)
27064 location_t location
;
27067 cp_parser_require_keyword (parser
, RID_AT_SYNCHRONIZED
, RT_AT_SYNCHRONIZED
);
27069 location
= cp_lexer_peek_token (parser
->lexer
)->location
;
27070 objc_maybe_warn_exceptions (location
);
27071 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
27072 lock
= cp_parser_expression (parser
);
27073 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
27075 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
27076 node, lest it get absorbed into the surrounding block. */
27077 stmt
= push_stmt_list ();
27078 cp_parser_compound_statement (parser
, NULL
, false, false);
27080 return objc_build_synchronized (location
, lock
, pop_stmt_list (stmt
));
27083 /* Parse an Objective-C throw statement.
27086 @throw assignment-expression [opt] ;
27088 Returns a constructed '@throw' statement. */
27091 cp_parser_objc_throw_statement (cp_parser
*parser
)
27093 tree expr
= NULL_TREE
;
27094 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27096 cp_parser_require_keyword (parser
, RID_AT_THROW
, RT_AT_THROW
);
27098 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
27099 expr
= cp_parser_expression (parser
);
27101 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27103 return objc_build_throw_stmt (loc
, expr
);
27106 /* Parse an Objective-C statement. */
27109 cp_parser_objc_statement (cp_parser
* parser
)
27111 /* Try to figure out what kind of declaration is present. */
27112 cp_token
*kwd
= cp_lexer_peek_token (parser
->lexer
);
27114 switch (kwd
->keyword
)
27117 return cp_parser_objc_try_catch_finally_statement (parser
);
27118 case RID_AT_SYNCHRONIZED
:
27119 return cp_parser_objc_synchronized_statement (parser
);
27121 return cp_parser_objc_throw_statement (parser
);
27123 error_at (kwd
->location
, "misplaced %<@%D%> Objective-C++ construct",
27125 cp_parser_skip_to_end_of_block_or_statement (parser
);
27128 return error_mark_node
;
27131 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
27132 look ahead to see if an objc keyword follows the attributes. This
27133 is to detect the use of prefix attributes on ObjC @interface and
27137 cp_parser_objc_valid_prefix_attributes (cp_parser
* parser
, tree
*attrib
)
27139 cp_lexer_save_tokens (parser
->lexer
);
27140 *attrib
= cp_parser_attributes_opt (parser
);
27141 gcc_assert (*attrib
);
27142 if (OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser
->lexer
)->keyword
))
27144 cp_lexer_commit_tokens (parser
->lexer
);
27147 cp_lexer_rollback_tokens (parser
->lexer
);
27151 /* This routine is a minimal replacement for
27152 c_parser_struct_declaration () used when parsing the list of
27153 types/names or ObjC++ properties. For example, when parsing the
27156 @property (readonly) int a, b, c;
27158 this function is responsible for parsing "int a, int b, int c" and
27159 returning the declarations as CHAIN of DECLs.
27161 TODO: Share this code with cp_parser_objc_class_ivars. It's very
27162 similar parsing. */
27164 cp_parser_objc_struct_declaration (cp_parser
*parser
)
27166 tree decls
= NULL_TREE
;
27167 cp_decl_specifier_seq declspecs
;
27168 int decl_class_or_enum_p
;
27169 tree prefix_attributes
;
27171 cp_parser_decl_specifier_seq (parser
,
27172 CP_PARSER_FLAGS_NONE
,
27174 &decl_class_or_enum_p
);
27176 if (declspecs
.type
== error_mark_node
)
27177 return error_mark_node
;
27179 /* auto, register, static, extern, mutable. */
27180 if (declspecs
.storage_class
!= sc_none
)
27182 cp_parser_error (parser
, "invalid type for property");
27183 declspecs
.storage_class
= sc_none
;
27186 /* thread_local. */
27187 if (decl_spec_seq_has_spec_p (&declspecs
, ds_thread
))
27189 cp_parser_error (parser
, "invalid type for property");
27190 declspecs
.locations
[ds_thread
] = 0;
27194 if (decl_spec_seq_has_spec_p (&declspecs
, ds_typedef
))
27196 cp_parser_error (parser
, "invalid type for property");
27197 declspecs
.locations
[ds_typedef
] = 0;
27200 prefix_attributes
= declspecs
.attributes
;
27201 declspecs
.attributes
= NULL_TREE
;
27203 /* Keep going until we hit the `;' at the end of the declaration. */
27204 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
27206 tree attributes
, first_attribute
, decl
;
27207 cp_declarator
*declarator
;
27210 /* Parse the declarator. */
27211 declarator
= cp_parser_declarator (parser
, CP_PARSER_DECLARATOR_NAMED
,
27212 NULL
, NULL
, false, false);
27214 /* Look for attributes that apply to the ivar. */
27215 attributes
= cp_parser_attributes_opt (parser
);
27216 /* Remember which attributes are prefix attributes and
27218 first_attribute
= attributes
;
27219 /* Combine the attributes. */
27220 attributes
= chainon (prefix_attributes
, attributes
);
27222 decl
= grokfield (declarator
, &declspecs
,
27223 NULL_TREE
, /*init_const_expr_p=*/false,
27224 NULL_TREE
, attributes
);
27226 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
27227 return error_mark_node
;
27229 /* Reset PREFIX_ATTRIBUTES. */
27230 while (attributes
&& TREE_CHAIN (attributes
) != first_attribute
)
27231 attributes
= TREE_CHAIN (attributes
);
27233 TREE_CHAIN (attributes
) = NULL_TREE
;
27235 DECL_CHAIN (decl
) = decls
;
27238 token
= cp_lexer_peek_token (parser
->lexer
);
27239 if (token
->type
== CPP_COMMA
)
27241 cp_lexer_consume_token (parser
->lexer
); /* Eat ','. */
27250 /* Parse an Objective-C @property declaration. The syntax is:
27252 objc-property-declaration:
27253 '@property' objc-property-attributes[opt] struct-declaration ;
27255 objc-property-attributes:
27256 '(' objc-property-attribute-list ')'
27258 objc-property-attribute-list:
27259 objc-property-attribute
27260 objc-property-attribute-list, objc-property-attribute
27262 objc-property-attribute
27263 'getter' = identifier
27264 'setter' = identifier
27273 @property NSString *name;
27274 @property (readonly) id object;
27275 @property (retain, nonatomic, getter=getTheName) id name;
27276 @property int a, b, c;
27278 PS: This function is identical to
27279 c_parser_objc_at_property_declaration for C. Keep them in sync. */
27281 cp_parser_objc_at_property_declaration (cp_parser
*parser
)
27283 /* The following variables hold the attributes of the properties as
27284 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
27285 seen. When we see an attribute, we set them to 'true' (if they
27286 are boolean properties) or to the identifier (if they have an
27287 argument, ie, for getter and setter). Note that here we only
27288 parse the list of attributes, check the syntax and accumulate the
27289 attributes that we find. objc_add_property_declaration() will
27290 then process the information. */
27291 bool property_assign
= false;
27292 bool property_copy
= false;
27293 tree property_getter_ident
= NULL_TREE
;
27294 bool property_nonatomic
= false;
27295 bool property_readonly
= false;
27296 bool property_readwrite
= false;
27297 bool property_retain
= false;
27298 tree property_setter_ident
= NULL_TREE
;
27300 /* 'properties' is the list of properties that we read. Usually a
27301 single one, but maybe more (eg, in "@property int a, b, c;" there
27306 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27308 cp_lexer_consume_token (parser
->lexer
); /* Eat '@property'. */
27310 /* Parse the optional attribute list... */
27311 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
27314 cp_lexer_consume_token (parser
->lexer
);
27318 bool syntax_error
= false;
27319 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
27322 if (token
->type
!= CPP_NAME
)
27324 cp_parser_error (parser
, "expected identifier");
27327 keyword
= C_RID_CODE (token
->u
.value
);
27328 cp_lexer_consume_token (parser
->lexer
);
27331 case RID_ASSIGN
: property_assign
= true; break;
27332 case RID_COPY
: property_copy
= true; break;
27333 case RID_NONATOMIC
: property_nonatomic
= true; break;
27334 case RID_READONLY
: property_readonly
= true; break;
27335 case RID_READWRITE
: property_readwrite
= true; break;
27336 case RID_RETAIN
: property_retain
= true; break;
27340 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
))
27342 if (keyword
== RID_GETTER
)
27343 cp_parser_error (parser
,
27344 "missing %<=%> (after %<getter%> attribute)");
27346 cp_parser_error (parser
,
27347 "missing %<=%> (after %<setter%> attribute)");
27348 syntax_error
= true;
27351 cp_lexer_consume_token (parser
->lexer
); /* eat the = */
27352 if (!cp_parser_objc_selector_p (cp_lexer_peek_token (parser
->lexer
)->type
))
27354 cp_parser_error (parser
, "expected identifier");
27355 syntax_error
= true;
27358 if (keyword
== RID_SETTER
)
27360 if (property_setter_ident
!= NULL_TREE
)
27362 cp_parser_error (parser
, "the %<setter%> attribute may only be specified once");
27363 cp_lexer_consume_token (parser
->lexer
);
27366 property_setter_ident
= cp_parser_objc_selector (parser
);
27367 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COLON
))
27368 cp_parser_error (parser
, "setter name must terminate with %<:%>");
27370 cp_lexer_consume_token (parser
->lexer
);
27374 if (property_getter_ident
!= NULL_TREE
)
27376 cp_parser_error (parser
, "the %<getter%> attribute may only be specified once");
27377 cp_lexer_consume_token (parser
->lexer
);
27380 property_getter_ident
= cp_parser_objc_selector (parser
);
27384 cp_parser_error (parser
, "unknown property attribute");
27385 syntax_error
= true;
27392 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
27393 cp_lexer_consume_token (parser
->lexer
);
27398 /* FIXME: "@property (setter, assign);" will generate a spurious
27399 "error: expected ‘)’ before ‘,’ token". This is because
27400 cp_parser_require, unlike the C counterpart, will produce an
27401 error even if we are in error recovery. */
27402 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
27404 cp_parser_skip_to_closing_parenthesis (parser
,
27405 /*recovering=*/true,
27406 /*or_comma=*/false,
27407 /*consume_paren=*/true);
27411 /* ... and the property declaration(s). */
27412 properties
= cp_parser_objc_struct_declaration (parser
);
27414 if (properties
== error_mark_node
)
27416 cp_parser_skip_to_end_of_statement (parser
);
27417 /* If the next token is now a `;', consume it. */
27418 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
27419 cp_lexer_consume_token (parser
->lexer
);
27423 if (properties
== NULL_TREE
)
27424 cp_parser_error (parser
, "expected identifier");
27427 /* Comma-separated properties are chained together in
27428 reverse order; add them one by one. */
27429 properties
= nreverse (properties
);
27431 for (; properties
; properties
= TREE_CHAIN (properties
))
27432 objc_add_property_declaration (loc
, copy_node (properties
),
27433 property_readonly
, property_readwrite
,
27434 property_assign
, property_retain
,
27435 property_copy
, property_nonatomic
,
27436 property_getter_ident
, property_setter_ident
);
27439 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27442 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
27444 objc-synthesize-declaration:
27445 @synthesize objc-synthesize-identifier-list ;
27447 objc-synthesize-identifier-list:
27448 objc-synthesize-identifier
27449 objc-synthesize-identifier-list, objc-synthesize-identifier
27451 objc-synthesize-identifier
27453 identifier = identifier
27456 @synthesize MyProperty;
27457 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
27459 PS: This function is identical to c_parser_objc_at_synthesize_declaration
27460 for C. Keep them in sync.
27463 cp_parser_objc_at_synthesize_declaration (cp_parser
*parser
)
27465 tree list
= NULL_TREE
;
27467 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27469 cp_lexer_consume_token (parser
->lexer
); /* Eat '@synthesize'. */
27472 tree property
, ivar
;
27473 property
= cp_parser_identifier (parser
);
27474 if (property
== error_mark_node
)
27476 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27479 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EQ
))
27481 cp_lexer_consume_token (parser
->lexer
);
27482 ivar
= cp_parser_identifier (parser
);
27483 if (ivar
== error_mark_node
)
27485 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27491 list
= chainon (list
, build_tree_list (ivar
, property
));
27492 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
27493 cp_lexer_consume_token (parser
->lexer
);
27497 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27498 objc_add_synthesize_declaration (loc
, list
);
27501 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
27503 objc-dynamic-declaration:
27504 @dynamic identifier-list ;
27507 @dynamic MyProperty;
27508 @dynamic MyProperty, AnotherProperty;
27510 PS: This function is identical to c_parser_objc_at_dynamic_declaration
27511 for C. Keep them in sync.
27514 cp_parser_objc_at_dynamic_declaration (cp_parser
*parser
)
27516 tree list
= NULL_TREE
;
27518 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27520 cp_lexer_consume_token (parser
->lexer
); /* Eat '@dynamic'. */
27524 property
= cp_parser_identifier (parser
);
27525 if (property
== error_mark_node
)
27527 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27530 list
= chainon (list
, build_tree_list (NULL
, property
));
27531 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
27532 cp_lexer_consume_token (parser
->lexer
);
27536 cp_parser_consume_semicolon_at_end_of_statement (parser
);
27537 objc_add_dynamic_declaration (loc
, list
);
27541 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 parsing routines. */
27543 /* Returns name of the next clause.
27544 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
27545 the token is not consumed. Otherwise appropriate pragma_omp_clause is
27546 returned and the token is consumed. */
27548 static pragma_omp_clause
27549 cp_parser_omp_clause_name (cp_parser
*parser
)
27551 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
27553 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_IF
))
27554 result
= PRAGMA_OMP_CLAUSE_IF
;
27555 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_DEFAULT
))
27556 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
27557 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_DELETE
))
27558 result
= PRAGMA_OACC_CLAUSE_DELETE
;
27559 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_PRIVATE
))
27560 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
27561 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
27562 result
= PRAGMA_OMP_CLAUSE_FOR
;
27563 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
27565 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
27566 const char *p
= IDENTIFIER_POINTER (id
);
27571 if (!strcmp ("aligned", p
))
27572 result
= PRAGMA_OMP_CLAUSE_ALIGNED
;
27573 else if (!strcmp ("async", p
))
27574 result
= PRAGMA_OACC_CLAUSE_ASYNC
;
27577 if (!strcmp ("collapse", p
))
27578 result
= PRAGMA_OMP_CLAUSE_COLLAPSE
;
27579 else if (!strcmp ("copy", p
))
27580 result
= PRAGMA_OACC_CLAUSE_COPY
;
27581 else if (!strcmp ("copyin", p
))
27582 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
27583 else if (!strcmp ("copyout", p
))
27584 result
= PRAGMA_OACC_CLAUSE_COPYOUT
;
27585 else if (!strcmp ("copyprivate", p
))
27586 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
27587 else if (!strcmp ("create", p
))
27588 result
= PRAGMA_OACC_CLAUSE_CREATE
;
27591 if (!strcmp ("depend", p
))
27592 result
= PRAGMA_OMP_CLAUSE_DEPEND
;
27593 else if (!strcmp ("device", p
))
27594 result
= PRAGMA_OMP_CLAUSE_DEVICE
;
27595 else if (!strcmp ("deviceptr", p
))
27596 result
= PRAGMA_OACC_CLAUSE_DEVICEPTR
;
27597 else if (!strcmp ("dist_schedule", p
))
27598 result
= PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
;
27601 if (!strcmp ("final", p
))
27602 result
= PRAGMA_OMP_CLAUSE_FINAL
;
27603 else if (!strcmp ("firstprivate", p
))
27604 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
27605 else if (!strcmp ("from", p
))
27606 result
= PRAGMA_OMP_CLAUSE_FROM
;
27609 if (!strcmp ("host", p
))
27610 result
= PRAGMA_OACC_CLAUSE_HOST
;
27613 if (!strcmp ("inbranch", p
))
27614 result
= PRAGMA_OMP_CLAUSE_INBRANCH
;
27617 if (!strcmp ("lastprivate", p
))
27618 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
27619 else if (!strcmp ("linear", p
))
27620 result
= PRAGMA_OMP_CLAUSE_LINEAR
;
27623 if (!strcmp ("map", p
))
27624 result
= PRAGMA_OMP_CLAUSE_MAP
;
27625 else if (!strcmp ("mergeable", p
))
27626 result
= PRAGMA_OMP_CLAUSE_MERGEABLE
;
27627 else if (flag_cilkplus
&& !strcmp ("mask", p
))
27628 result
= PRAGMA_CILK_CLAUSE_MASK
;
27631 if (!strcmp ("notinbranch", p
))
27632 result
= PRAGMA_OMP_CLAUSE_NOTINBRANCH
;
27633 else if (!strcmp ("nowait", p
))
27634 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
27635 else if (flag_cilkplus
&& !strcmp ("nomask", p
))
27636 result
= PRAGMA_CILK_CLAUSE_NOMASK
;
27637 else if (!strcmp ("num_gangs", p
))
27638 result
= PRAGMA_OACC_CLAUSE_NUM_GANGS
;
27639 else if (!strcmp ("num_teams", p
))
27640 result
= PRAGMA_OMP_CLAUSE_NUM_TEAMS
;
27641 else if (!strcmp ("num_threads", p
))
27642 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
27643 else if (!strcmp ("num_workers", p
))
27644 result
= PRAGMA_OACC_CLAUSE_NUM_WORKERS
;
27647 if (!strcmp ("ordered", p
))
27648 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
27651 if (!strcmp ("parallel", p
))
27652 result
= PRAGMA_OMP_CLAUSE_PARALLEL
;
27653 else if (!strcmp ("present", p
))
27654 result
= PRAGMA_OACC_CLAUSE_PRESENT
;
27655 else if (!strcmp ("present_or_copy", p
)
27656 || !strcmp ("pcopy", p
))
27657 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY
;
27658 else if (!strcmp ("present_or_copyin", p
)
27659 || !strcmp ("pcopyin", p
))
27660 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN
;
27661 else if (!strcmp ("present_or_copyout", p
)
27662 || !strcmp ("pcopyout", p
))
27663 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT
;
27664 else if (!strcmp ("present_or_create", p
)
27665 || !strcmp ("pcreate", p
))
27666 result
= PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE
;
27667 else if (!strcmp ("proc_bind", p
))
27668 result
= PRAGMA_OMP_CLAUSE_PROC_BIND
;
27671 if (!strcmp ("reduction", p
))
27672 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
27675 if (!strcmp ("safelen", p
))
27676 result
= PRAGMA_OMP_CLAUSE_SAFELEN
;
27677 else if (!strcmp ("schedule", p
))
27678 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
27679 else if (!strcmp ("sections", p
))
27680 result
= PRAGMA_OMP_CLAUSE_SECTIONS
;
27681 else if (!strcmp ("self", p
))
27682 result
= PRAGMA_OACC_CLAUSE_SELF
;
27683 else if (!strcmp ("shared", p
))
27684 result
= PRAGMA_OMP_CLAUSE_SHARED
;
27685 else if (!strcmp ("simdlen", p
))
27686 result
= PRAGMA_OMP_CLAUSE_SIMDLEN
;
27689 if (!strcmp ("taskgroup", p
))
27690 result
= PRAGMA_OMP_CLAUSE_TASKGROUP
;
27691 else if (!strcmp ("thread_limit", p
))
27692 result
= PRAGMA_OMP_CLAUSE_THREAD_LIMIT
;
27693 else if (!strcmp ("to", p
))
27694 result
= PRAGMA_OMP_CLAUSE_TO
;
27697 if (!strcmp ("uniform", p
))
27698 result
= PRAGMA_OMP_CLAUSE_UNIFORM
;
27699 else if (!strcmp ("untied", p
))
27700 result
= PRAGMA_OMP_CLAUSE_UNTIED
;
27703 if (!strcmp ("vector_length", p
))
27704 result
= PRAGMA_OACC_CLAUSE_VECTOR_LENGTH
;
27705 else if (flag_cilkplus
&& !strcmp ("vectorlength", p
))
27706 result
= PRAGMA_CILK_CLAUSE_VECTORLENGTH
;
27709 if (!strcmp ("wait", p
))
27710 result
= PRAGMA_OACC_CLAUSE_WAIT
;
27715 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
27716 cp_lexer_consume_token (parser
->lexer
);
27721 /* Validate that a clause of the given type does not already exist. */
27724 check_no_duplicate_clause (tree clauses
, enum omp_clause_code code
,
27725 const char *name
, location_t location
)
27729 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
27730 if (OMP_CLAUSE_CODE (c
) == code
)
27732 error_at (location
, "too many %qs clauses", name
);
27740 variable-list , identifier
27742 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
27743 colon). An opening parenthesis will have been consumed by the caller.
27745 If KIND is nonzero, create the appropriate node and install the decl
27746 in OMP_CLAUSE_DECL and add the node to the head of the list.
27748 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
27749 return the list created.
27751 COLON can be NULL if only closing parenthesis should end the list,
27752 or pointer to bool which will receive false if the list is terminated
27753 by closing parenthesis or true if the list is terminated by colon. */
27756 cp_parser_omp_var_list_no_open (cp_parser
*parser
, enum omp_clause_code kind
,
27757 tree list
, bool *colon
)
27760 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
27763 parser
->colon_corrects_to_scope_p
= false;
27770 token
= cp_lexer_peek_token (parser
->lexer
);
27771 name
= cp_parser_id_expression (parser
, /*template_p=*/false,
27772 /*check_dependency_p=*/true,
27773 /*template_p=*/NULL
,
27774 /*declarator_p=*/false,
27775 /*optional_p=*/false);
27776 if (name
== error_mark_node
)
27779 decl
= cp_parser_lookup_name_simple (parser
, name
, token
->location
);
27780 if (decl
== error_mark_node
)
27781 cp_parser_name_lookup_error (parser
, name
, decl
, NLE_NULL
,
27783 else if (kind
!= 0)
27787 case OMP_CLAUSE__CACHE_
:
27788 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_OPEN_SQUARE
)
27790 error_at (token
->location
, "expected %<[%>");
27791 decl
= error_mark_node
;
27794 /* FALL THROUGH. */
27795 case OMP_CLAUSE_MAP
:
27796 case OMP_CLAUSE_FROM
:
27797 case OMP_CLAUSE_TO
:
27798 case OMP_CLAUSE_DEPEND
:
27799 while (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_SQUARE
))
27801 tree low_bound
= NULL_TREE
, length
= NULL_TREE
;
27803 parser
->colon_corrects_to_scope_p
= false;
27804 cp_lexer_consume_token (parser
->lexer
);
27805 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
27806 low_bound
= cp_parser_expression (parser
);
27808 parser
->colon_corrects_to_scope_p
27809 = saved_colon_corrects_to_scope_p
;
27810 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_SQUARE
))
27811 length
= integer_one_node
;
27814 /* Look for `:'. */
27815 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
27817 if (!cp_lexer_next_token_is (parser
->lexer
,
27819 length
= cp_parser_expression (parser
);
27821 /* Look for the closing `]'. */
27822 if (!cp_parser_require (parser
, CPP_CLOSE_SQUARE
,
27826 if (kind
== OMP_CLAUSE__CACHE_
)
27828 if (TREE_CODE (low_bound
) != INTEGER_CST
27829 && !TREE_READONLY (low_bound
))
27831 error_at (token
->location
,
27832 "%qD is not a constant", low_bound
);
27833 decl
= error_mark_node
;
27836 if (TREE_CODE (length
) != INTEGER_CST
27837 && !TREE_READONLY (length
))
27839 error_at (token
->location
,
27840 "%qD is not a constant", length
);
27841 decl
= error_mark_node
;
27845 decl
= tree_cons (low_bound
, length
, decl
);
27852 tree u
= build_omp_clause (token
->location
, kind
);
27853 OMP_CLAUSE_DECL (u
) = decl
;
27854 OMP_CLAUSE_CHAIN (u
) = list
;
27858 list
= tree_cons (decl
, NULL_TREE
, list
);
27861 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_COMMA
))
27863 cp_lexer_consume_token (parser
->lexer
);
27867 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
27869 if (colon
!= NULL
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COLON
))
27872 cp_parser_require (parser
, CPP_COLON
, RT_COLON
);
27876 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
27880 /* Try to resync to an unnested comma. Copied from
27881 cp_parser_parenthesized_expression_list. */
27884 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
27885 ending
= cp_parser_skip_to_closing_parenthesis (parser
,
27886 /*recovering=*/true,
27888 /*consume_paren=*/true);
27896 /* Similarly, but expect leading and trailing parenthesis. This is a very
27897 common case for omp clauses. */
27900 cp_parser_omp_var_list (cp_parser
*parser
, enum omp_clause_code kind
, tree list
)
27902 if (cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
27903 return cp_parser_omp_var_list_no_open (parser
, kind
, list
, NULL
);
27908 copy ( variable-list )
27909 copyin ( variable-list )
27910 copyout ( variable-list )
27911 create ( variable-list )
27912 delete ( variable-list )
27913 present ( variable-list )
27914 present_or_copy ( variable-list )
27915 pcopy ( variable-list )
27916 present_or_copyin ( variable-list )
27917 pcopyin ( variable-list )
27918 present_or_copyout ( variable-list )
27919 pcopyout ( variable-list )
27920 present_or_create ( variable-list )
27921 pcreate ( variable-list ) */
27924 cp_parser_oacc_data_clause (cp_parser
*parser
, pragma_omp_clause c_kind
,
27927 enum gomp_map_kind kind
;
27930 case PRAGMA_OACC_CLAUSE_COPY
:
27931 kind
= GOMP_MAP_FORCE_TOFROM
;
27933 case PRAGMA_OACC_CLAUSE_COPYIN
:
27934 kind
= GOMP_MAP_FORCE_TO
;
27936 case PRAGMA_OACC_CLAUSE_COPYOUT
:
27937 kind
= GOMP_MAP_FORCE_FROM
;
27939 case PRAGMA_OACC_CLAUSE_CREATE
:
27940 kind
= GOMP_MAP_FORCE_ALLOC
;
27942 case PRAGMA_OACC_CLAUSE_DELETE
:
27943 kind
= GOMP_MAP_FORCE_DEALLOC
;
27945 case PRAGMA_OACC_CLAUSE_DEVICE
:
27946 kind
= GOMP_MAP_FORCE_TO
;
27948 case PRAGMA_OACC_CLAUSE_HOST
:
27949 case PRAGMA_OACC_CLAUSE_SELF
:
27950 kind
= GOMP_MAP_FORCE_FROM
;
27952 case PRAGMA_OACC_CLAUSE_PRESENT
:
27953 kind
= GOMP_MAP_FORCE_PRESENT
;
27955 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY
:
27956 kind
= GOMP_MAP_TOFROM
;
27958 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN
:
27959 kind
= GOMP_MAP_TO
;
27961 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT
:
27962 kind
= GOMP_MAP_FROM
;
27964 case PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE
:
27965 kind
= GOMP_MAP_ALLOC
;
27968 gcc_unreachable ();
27971 nl
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_MAP
, list
);
27973 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
27974 OMP_CLAUSE_SET_MAP_KIND (c
, kind
);
27980 deviceptr ( variable-list ) */
27983 cp_parser_oacc_data_clause_deviceptr (cp_parser
*parser
, tree list
)
27985 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
27988 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
27989 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
27990 variable-list must only allow for pointer variables. */
27991 vars
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_ERROR
, NULL
);
27992 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
27994 tree v
= TREE_PURPOSE (t
);
27996 /* FIXME diagnostics: Ideally we should keep individual
27997 locations for all the variables in the var list to make the
27998 following errors more precise. Perhaps
27999 c_parser_omp_var_list_parens should construct a list of
28000 locations to go along with the var list. */
28002 if (TREE_CODE (v
) != VAR_DECL
)
28003 error_at (loc
, "%qD is not a variable", v
);
28004 else if (TREE_TYPE (v
) == error_mark_node
)
28006 else if (!POINTER_TYPE_P (TREE_TYPE (v
)))
28007 error_at (loc
, "%qD is not a pointer variable", v
);
28009 tree u
= build_omp_clause (loc
, OMP_CLAUSE_MAP
);
28010 OMP_CLAUSE_SET_MAP_KIND (u
, GOMP_MAP_FORCE_DEVICEPTR
);
28011 OMP_CLAUSE_DECL (u
) = v
;
28012 OMP_CLAUSE_CHAIN (u
) = list
;
28020 vector_length ( expression ) */
28023 cp_parser_oacc_clause_vector_length (cp_parser
*parser
, tree list
)
28026 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28027 bool error
= false;
28029 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28032 t
= cp_parser_condition (parser
);
28033 if (t
== error_mark_node
|| !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
28035 error_at (location
, "expected positive integer expression");
28039 if (error
|| !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28041 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28042 /*or_comma=*/false,
28043 /*consume_paren=*/true);
28047 check_no_duplicate_clause (list
, OMP_CLAUSE_VECTOR_LENGTH
, "vector_length",
28050 c
= build_omp_clause (location
, OMP_CLAUSE_VECTOR_LENGTH
);
28051 OMP_CLAUSE_VECTOR_LENGTH_EXPR (c
) = t
;
28052 OMP_CLAUSE_CHAIN (c
) = list
;
28059 Parse wait clause or directive parameters. */
28062 cp_parser_oacc_wait_list (cp_parser
*parser
, location_t clause_loc
, tree list
)
28064 vec
<tree
, va_gc
> *args
;
28067 args
= cp_parser_parenthesized_expression_list (parser
, non_attr
,
28069 /*allow_expansion_p=*/true,
28070 /*non_constant_p=*/NULL
);
28072 if (args
== NULL
|| args
->length () == 0)
28074 cp_parser_error (parser
, "expected integer expression before ')'");
28076 release_tree_vector (args
);
28080 args_tree
= build_tree_list_vec (args
);
28082 release_tree_vector (args
);
28084 for (t
= args_tree
; t
; t
= TREE_CHAIN (t
))
28086 tree targ
= TREE_VALUE (t
);
28088 if (targ
!= error_mark_node
)
28090 if (!INTEGRAL_TYPE_P (TREE_TYPE (targ
)))
28091 error ("%<wait%> expression must be integral");
28094 tree c
= build_omp_clause (clause_loc
, OMP_CLAUSE_WAIT
);
28096 mark_rvalue_use (targ
);
28097 OMP_CLAUSE_DECL (c
) = targ
;
28098 OMP_CLAUSE_CHAIN (c
) = list
;
28108 wait ( int-expr-list ) */
28111 cp_parser_oacc_clause_wait (cp_parser
*parser
, tree list
)
28113 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28115 if (cp_lexer_peek_token (parser
->lexer
)->type
!= CPP_OPEN_PAREN
)
28118 list
= cp_parser_oacc_wait_list (parser
, location
, list
);
28124 collapse ( constant-expression ) */
28127 cp_parser_omp_clause_collapse (cp_parser
*parser
, tree list
, location_t location
)
28133 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
28134 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28137 num
= cp_parser_constant_expression (parser
);
28139 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28140 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28141 /*or_comma=*/false,
28142 /*consume_paren=*/true);
28144 if (num
== error_mark_node
)
28146 num
= fold_non_dependent_expr (num
);
28147 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
28148 || !tree_fits_shwi_p (num
)
28149 || (n
= tree_to_shwi (num
)) <= 0
28152 error_at (loc
, "collapse argument needs positive constant integer expression");
28156 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse", location
);
28157 c
= build_omp_clause (loc
, OMP_CLAUSE_COLLAPSE
);
28158 OMP_CLAUSE_CHAIN (c
) = list
;
28159 OMP_CLAUSE_COLLAPSE_EXPR (c
) = num
;
28165 default ( shared | none ) */
28168 cp_parser_omp_clause_default (cp_parser
*parser
, tree list
, location_t location
)
28170 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
28173 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28175 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
28177 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28178 const char *p
= IDENTIFIER_POINTER (id
);
28183 if (strcmp ("none", p
) != 0)
28185 kind
= OMP_CLAUSE_DEFAULT_NONE
;
28189 if (strcmp ("shared", p
) != 0)
28191 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
28198 cp_lexer_consume_token (parser
->lexer
);
28203 cp_parser_error (parser
, "expected %<none%> or %<shared%>");
28206 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28207 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28208 /*or_comma=*/false,
28209 /*consume_paren=*/true);
28211 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
28214 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default", location
);
28215 c
= build_omp_clause (location
, OMP_CLAUSE_DEFAULT
);
28216 OMP_CLAUSE_CHAIN (c
) = list
;
28217 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
28223 final ( expression ) */
28226 cp_parser_omp_clause_final (cp_parser
*parser
, tree list
, location_t location
)
28230 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28233 t
= cp_parser_condition (parser
);
28235 if (t
== error_mark_node
28236 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28237 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28238 /*or_comma=*/false,
28239 /*consume_paren=*/true);
28241 check_no_duplicate_clause (list
, OMP_CLAUSE_FINAL
, "final", location
);
28243 c
= build_omp_clause (location
, OMP_CLAUSE_FINAL
);
28244 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
28245 OMP_CLAUSE_CHAIN (c
) = list
;
28251 if ( expression ) */
28254 cp_parser_omp_clause_if (cp_parser
*parser
, tree list
, location_t location
)
28258 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28261 t
= cp_parser_condition (parser
);
28263 if (t
== error_mark_node
28264 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28265 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28266 /*or_comma=*/false,
28267 /*consume_paren=*/true);
28269 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if", location
);
28271 c
= build_omp_clause (location
, OMP_CLAUSE_IF
);
28272 OMP_CLAUSE_IF_EXPR (c
) = t
;
28273 OMP_CLAUSE_CHAIN (c
) = list
;
28282 cp_parser_omp_clause_mergeable (cp_parser
* /*parser*/,
28283 tree list
, location_t location
)
28287 check_no_duplicate_clause (list
, OMP_CLAUSE_MERGEABLE
, "mergeable",
28290 c
= build_omp_clause (location
, OMP_CLAUSE_MERGEABLE
);
28291 OMP_CLAUSE_CHAIN (c
) = list
;
28299 cp_parser_omp_clause_nowait (cp_parser
* /*parser*/,
28300 tree list
, location_t location
)
28304 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait", location
);
28306 c
= build_omp_clause (location
, OMP_CLAUSE_NOWAIT
);
28307 OMP_CLAUSE_CHAIN (c
) = list
;
28312 num_gangs ( expression ) */
28315 cp_parser_omp_clause_num_gangs (cp_parser
*parser
, tree list
)
28318 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28320 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28323 t
= cp_parser_condition (parser
);
28325 if (t
== error_mark_node
28326 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28327 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28328 /*or_comma=*/false,
28329 /*consume_paren=*/true);
28331 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
28333 error_at (location
, "expected positive integer expression");
28337 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_GANGS
, "num_gangs", location
);
28339 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_GANGS
);
28340 OMP_CLAUSE_NUM_GANGS_EXPR (c
) = t
;
28341 OMP_CLAUSE_CHAIN (c
) = list
;
28348 num_threads ( expression ) */
28351 cp_parser_omp_clause_num_threads (cp_parser
*parser
, tree list
,
28352 location_t location
)
28356 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28359 t
= cp_parser_expression (parser
);
28361 if (t
== error_mark_node
28362 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28363 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28364 /*or_comma=*/false,
28365 /*consume_paren=*/true);
28367 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
,
28368 "num_threads", location
);
28370 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_THREADS
);
28371 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
28372 OMP_CLAUSE_CHAIN (c
) = list
;
28378 num_workers ( expression ) */
28381 cp_parser_omp_clause_num_workers (cp_parser
*parser
, tree list
)
28384 location_t location
= cp_lexer_peek_token (parser
->lexer
)->location
;
28386 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28389 t
= cp_parser_condition (parser
);
28391 if (t
== error_mark_node
28392 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28393 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28394 /*or_comma=*/false,
28395 /*consume_paren=*/true);
28397 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
28399 error_at (location
, "expected positive integer expression");
28403 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_WORKERS
, "num_gangs",
28406 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_WORKERS
);
28407 OMP_CLAUSE_NUM_WORKERS_EXPR (c
) = t
;
28408 OMP_CLAUSE_CHAIN (c
) = list
;
28418 cp_parser_omp_clause_ordered (cp_parser
* /*parser*/,
28419 tree list
, location_t location
)
28423 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
,
28424 "ordered", location
);
28426 c
= build_omp_clause (location
, OMP_CLAUSE_ORDERED
);
28427 OMP_CLAUSE_CHAIN (c
) = list
;
28432 reduction ( reduction-operator : variable-list )
28434 reduction-operator:
28435 One of: + * - & ^ | && ||
28439 reduction-operator:
28440 One of: + * - & ^ | && || min max
28444 reduction-operator:
28445 One of: + * - & ^ | && ||
28449 cp_parser_omp_clause_reduction (cp_parser
*parser
, tree list
)
28451 enum tree_code code
= ERROR_MARK
;
28452 tree nlist
, c
, id
= NULL_TREE
;
28454 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28457 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
28459 case CPP_PLUS
: code
= PLUS_EXPR
; break;
28460 case CPP_MULT
: code
= MULT_EXPR
; break;
28461 case CPP_MINUS
: code
= MINUS_EXPR
; break;
28462 case CPP_AND
: code
= BIT_AND_EXPR
; break;
28463 case CPP_XOR
: code
= BIT_XOR_EXPR
; break;
28464 case CPP_OR
: code
= BIT_IOR_EXPR
; break;
28465 case CPP_AND_AND
: code
= TRUTH_ANDIF_EXPR
; break;
28466 case CPP_OR_OR
: code
= TRUTH_ORIF_EXPR
; break;
28470 if (code
!= ERROR_MARK
)
28471 cp_lexer_consume_token (parser
->lexer
);
28474 bool saved_colon_corrects_to_scope_p
;
28475 saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
28476 parser
->colon_corrects_to_scope_p
= false;
28477 id
= cp_parser_id_expression (parser
, /*template_p=*/false,
28478 /*check_dependency_p=*/true,
28479 /*template_p=*/NULL
,
28480 /*declarator_p=*/false,
28481 /*optional_p=*/false);
28482 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
28483 if (identifier_p (id
))
28485 const char *p
= IDENTIFIER_POINTER (id
);
28487 if (strcmp (p
, "min") == 0)
28489 else if (strcmp (p
, "max") == 0)
28491 else if (id
== ansi_opname (PLUS_EXPR
))
28493 else if (id
== ansi_opname (MULT_EXPR
))
28495 else if (id
== ansi_opname (MINUS_EXPR
))
28497 else if (id
== ansi_opname (BIT_AND_EXPR
))
28498 code
= BIT_AND_EXPR
;
28499 else if (id
== ansi_opname (BIT_IOR_EXPR
))
28500 code
= BIT_IOR_EXPR
;
28501 else if (id
== ansi_opname (BIT_XOR_EXPR
))
28502 code
= BIT_XOR_EXPR
;
28503 else if (id
== ansi_opname (TRUTH_ANDIF_EXPR
))
28504 code
= TRUTH_ANDIF_EXPR
;
28505 else if (id
== ansi_opname (TRUTH_ORIF_EXPR
))
28506 code
= TRUTH_ORIF_EXPR
;
28507 id
= omp_reduction_id (code
, id
, NULL_TREE
);
28508 tree scope
= parser
->scope
;
28510 id
= build_qualified_name (NULL_TREE
, scope
, id
, false);
28511 parser
->scope
= NULL_TREE
;
28512 parser
->qualifying_scope
= NULL_TREE
;
28513 parser
->object_scope
= NULL_TREE
;
28517 error ("invalid reduction-identifier");
28519 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28520 /*or_comma=*/false,
28521 /*consume_paren=*/true);
28526 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
28529 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_REDUCTION
, list
,
28531 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28533 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
28534 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = id
;
28541 schedule ( schedule-kind )
28542 schedule ( schedule-kind , expression )
28545 static | dynamic | guided | runtime | auto */
28548 cp_parser_omp_clause_schedule (cp_parser
*parser
, tree list
, location_t location
)
28552 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28555 c
= build_omp_clause (location
, OMP_CLAUSE_SCHEDULE
);
28557 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
28559 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28560 const char *p
= IDENTIFIER_POINTER (id
);
28565 if (strcmp ("dynamic", p
) != 0)
28567 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
28571 if (strcmp ("guided", p
) != 0)
28573 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
28577 if (strcmp ("runtime", p
) != 0)
28579 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
28586 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC
))
28587 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
28588 else if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_AUTO
))
28589 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_AUTO
;
28592 cp_lexer_consume_token (parser
->lexer
);
28594 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
28597 cp_lexer_consume_token (parser
->lexer
);
28599 token
= cp_lexer_peek_token (parser
->lexer
);
28600 t
= cp_parser_assignment_expression (parser
);
28602 if (t
== error_mark_node
)
28604 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
28605 error_at (token
->location
, "schedule %<runtime%> does not take "
28606 "a %<chunk_size%> parameter");
28607 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_AUTO
)
28608 error_at (token
->location
, "schedule %<auto%> does not take "
28609 "a %<chunk_size%> parameter");
28611 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
28613 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28616 else if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_COMMA_CLOSE_PAREN
))
28619 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule", location
);
28620 OMP_CLAUSE_CHAIN (c
) = list
;
28624 cp_parser_error (parser
, "invalid schedule kind");
28626 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28627 /*or_comma=*/false,
28628 /*consume_paren=*/true);
28636 cp_parser_omp_clause_untied (cp_parser
* /*parser*/,
28637 tree list
, location_t location
)
28641 check_no_duplicate_clause (list
, OMP_CLAUSE_UNTIED
, "untied", location
);
28643 c
= build_omp_clause (location
, OMP_CLAUSE_UNTIED
);
28644 OMP_CLAUSE_CHAIN (c
) = list
;
28653 cp_parser_omp_clause_branch (cp_parser
* /*parser*/, enum omp_clause_code code
,
28654 tree list
, location_t location
)
28656 check_no_duplicate_clause (list
, code
, omp_clause_code_name
[code
], location
);
28657 tree c
= build_omp_clause (location
, code
);
28658 OMP_CLAUSE_CHAIN (c
) = list
;
28669 cp_parser_omp_clause_cancelkind (cp_parser
* /*parser*/,
28670 enum omp_clause_code code
,
28671 tree list
, location_t location
)
28673 tree c
= build_omp_clause (location
, code
);
28674 OMP_CLAUSE_CHAIN (c
) = list
;
28679 num_teams ( expression ) */
28682 cp_parser_omp_clause_num_teams (cp_parser
*parser
, tree list
,
28683 location_t location
)
28687 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28690 t
= cp_parser_expression (parser
);
28692 if (t
== error_mark_node
28693 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28694 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28695 /*or_comma=*/false,
28696 /*consume_paren=*/true);
28698 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_TEAMS
,
28699 "num_teams", location
);
28701 c
= build_omp_clause (location
, OMP_CLAUSE_NUM_TEAMS
);
28702 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = t
;
28703 OMP_CLAUSE_CHAIN (c
) = list
;
28709 thread_limit ( expression ) */
28712 cp_parser_omp_clause_thread_limit (cp_parser
*parser
, tree list
,
28713 location_t location
)
28717 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28720 t
= cp_parser_expression (parser
);
28722 if (t
== error_mark_node
28723 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28724 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28725 /*or_comma=*/false,
28726 /*consume_paren=*/true);
28728 check_no_duplicate_clause (list
, OMP_CLAUSE_THREAD_LIMIT
,
28729 "thread_limit", location
);
28731 c
= build_omp_clause (location
, OMP_CLAUSE_THREAD_LIMIT
);
28732 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = t
;
28733 OMP_CLAUSE_CHAIN (c
) = list
;
28739 aligned ( variable-list )
28740 aligned ( variable-list : constant-expression ) */
28743 cp_parser_omp_clause_aligned (cp_parser
*parser
, tree list
)
28745 tree nlist
, c
, alignment
= NULL_TREE
;
28748 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28751 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_ALIGNED
, list
,
28756 alignment
= cp_parser_constant_expression (parser
);
28758 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28759 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28760 /*or_comma=*/false,
28761 /*consume_paren=*/true);
28763 if (alignment
== error_mark_node
)
28764 alignment
= NULL_TREE
;
28767 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28768 OMP_CLAUSE_ALIGNED_ALIGNMENT (c
) = alignment
;
28774 linear ( variable-list )
28775 linear ( variable-list : expression ) */
28778 cp_parser_omp_clause_linear (cp_parser
*parser
, tree list
,
28779 bool is_cilk_simd_fn
)
28781 tree nlist
, c
, step
= integer_one_node
;
28784 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28787 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_LINEAR
, list
,
28792 step
= cp_parser_expression (parser
);
28794 if (is_cilk_simd_fn
&& TREE_CODE (step
) == PARM_DECL
)
28796 sorry ("using parameters for %<linear%> step is not supported yet");
28797 step
= integer_one_node
;
28799 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28800 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28801 /*or_comma=*/false,
28802 /*consume_paren=*/true);
28804 if (step
== error_mark_node
)
28808 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28809 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
28815 safelen ( constant-expression ) */
28818 cp_parser_omp_clause_safelen (cp_parser
*parser
, tree list
,
28819 location_t location
)
28823 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28826 t
= cp_parser_constant_expression (parser
);
28828 if (t
== error_mark_node
28829 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28830 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28831 /*or_comma=*/false,
28832 /*consume_paren=*/true);
28834 check_no_duplicate_clause (list
, OMP_CLAUSE_SAFELEN
, "safelen", location
);
28836 c
= build_omp_clause (location
, OMP_CLAUSE_SAFELEN
);
28837 OMP_CLAUSE_SAFELEN_EXPR (c
) = t
;
28838 OMP_CLAUSE_CHAIN (c
) = list
;
28844 simdlen ( constant-expression ) */
28847 cp_parser_omp_clause_simdlen (cp_parser
*parser
, tree list
,
28848 location_t location
)
28852 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28855 t
= cp_parser_constant_expression (parser
);
28857 if (t
== error_mark_node
28858 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28859 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28860 /*or_comma=*/false,
28861 /*consume_paren=*/true);
28863 check_no_duplicate_clause (list
, OMP_CLAUSE_SIMDLEN
, "simdlen", location
);
28865 c
= build_omp_clause (location
, OMP_CLAUSE_SIMDLEN
);
28866 OMP_CLAUSE_SIMDLEN_EXPR (c
) = t
;
28867 OMP_CLAUSE_CHAIN (c
) = list
;
28873 depend ( depend-kind : variable-list )
28876 in | out | inout */
28879 cp_parser_omp_clause_depend (cp_parser
*parser
, tree list
)
28882 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_INOUT
;
28884 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28887 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
28889 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28890 const char *p
= IDENTIFIER_POINTER (id
);
28892 if (strcmp ("in", p
) == 0)
28893 kind
= OMP_CLAUSE_DEPEND_IN
;
28894 else if (strcmp ("inout", p
) == 0)
28895 kind
= OMP_CLAUSE_DEPEND_INOUT
;
28896 else if (strcmp ("out", p
) == 0)
28897 kind
= OMP_CLAUSE_DEPEND_OUT
;
28904 cp_lexer_consume_token (parser
->lexer
);
28905 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
28908 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_DEPEND
, list
,
28911 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28912 OMP_CLAUSE_DEPEND_KIND (c
) = kind
;
28917 cp_parser_error (parser
, "invalid depend kind");
28919 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28920 /*or_comma=*/false,
28921 /*consume_paren=*/true);
28926 map ( map-kind : variable-list )
28927 map ( variable-list )
28930 alloc | to | from | tofrom */
28933 cp_parser_omp_clause_map (cp_parser
*parser
, tree list
)
28936 enum gomp_map_kind kind
= GOMP_MAP_TOFROM
;
28938 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28941 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
)
28942 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_COLON
)
28944 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
28945 const char *p
= IDENTIFIER_POINTER (id
);
28947 if (strcmp ("alloc", p
) == 0)
28948 kind
= GOMP_MAP_ALLOC
;
28949 else if (strcmp ("to", p
) == 0)
28950 kind
= GOMP_MAP_TO
;
28951 else if (strcmp ("from", p
) == 0)
28952 kind
= GOMP_MAP_FROM
;
28953 else if (strcmp ("tofrom", p
) == 0)
28954 kind
= GOMP_MAP_TOFROM
;
28957 cp_parser_error (parser
, "invalid map kind");
28958 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28959 /*or_comma=*/false,
28960 /*consume_paren=*/true);
28963 cp_lexer_consume_token (parser
->lexer
);
28964 cp_lexer_consume_token (parser
->lexer
);
28967 nlist
= cp_parser_omp_var_list_no_open (parser
, OMP_CLAUSE_MAP
, list
,
28970 for (c
= nlist
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
28971 OMP_CLAUSE_SET_MAP_KIND (c
, kind
);
28977 device ( expression ) */
28980 cp_parser_omp_clause_device (cp_parser
*parser
, tree list
,
28981 location_t location
)
28985 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
28988 t
= cp_parser_expression (parser
);
28990 if (t
== error_mark_node
28991 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
28992 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
28993 /*or_comma=*/false,
28994 /*consume_paren=*/true);
28996 check_no_duplicate_clause (list
, OMP_CLAUSE_DEVICE
,
28997 "device", location
);
28999 c
= build_omp_clause (location
, OMP_CLAUSE_DEVICE
);
29000 OMP_CLAUSE_DEVICE_ID (c
) = t
;
29001 OMP_CLAUSE_CHAIN (c
) = list
;
29007 dist_schedule ( static )
29008 dist_schedule ( static , expression ) */
29011 cp_parser_omp_clause_dist_schedule (cp_parser
*parser
, tree list
,
29012 location_t location
)
29016 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
29019 c
= build_omp_clause (location
, OMP_CLAUSE_DIST_SCHEDULE
);
29021 if (!cp_lexer_next_token_is_keyword (parser
->lexer
, RID_STATIC
))
29023 cp_lexer_consume_token (parser
->lexer
);
29025 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
29027 cp_lexer_consume_token (parser
->lexer
);
29029 t
= cp_parser_assignment_expression (parser
);
29031 if (t
== error_mark_node
)
29033 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
) = t
;
29035 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
29038 else if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_COMMA_CLOSE_PAREN
))
29041 check_no_duplicate_clause (list
, OMP_CLAUSE_DIST_SCHEDULE
, "dist_schedule",
29043 OMP_CLAUSE_CHAIN (c
) = list
;
29047 cp_parser_error (parser
, "invalid dist_schedule kind");
29049 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
29050 /*or_comma=*/false,
29051 /*consume_paren=*/true);
29056 proc_bind ( proc-bind-kind )
29059 master | close | spread */
29062 cp_parser_omp_clause_proc_bind (cp_parser
*parser
, tree list
,
29063 location_t location
)
29066 enum omp_clause_proc_bind_kind kind
;
29068 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
29071 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29073 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29074 const char *p
= IDENTIFIER_POINTER (id
);
29076 if (strcmp ("master", p
) == 0)
29077 kind
= OMP_CLAUSE_PROC_BIND_MASTER
;
29078 else if (strcmp ("close", p
) == 0)
29079 kind
= OMP_CLAUSE_PROC_BIND_CLOSE
;
29080 else if (strcmp ("spread", p
) == 0)
29081 kind
= OMP_CLAUSE_PROC_BIND_SPREAD
;
29088 cp_lexer_consume_token (parser
->lexer
);
29089 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_COMMA_CLOSE_PAREN
))
29092 c
= build_omp_clause (location
, OMP_CLAUSE_PROC_BIND
);
29093 check_no_duplicate_clause (list
, OMP_CLAUSE_PROC_BIND
, "proc_bind",
29095 OMP_CLAUSE_PROC_BIND_KIND (c
) = kind
;
29096 OMP_CLAUSE_CHAIN (c
) = list
;
29100 cp_parser_error (parser
, "invalid depend kind");
29102 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
29103 /*or_comma=*/false,
29104 /*consume_paren=*/true);
29109 async [( int-expr )] */
29112 cp_parser_oacc_clause_async (cp_parser
*parser
, tree list
)
29115 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
29117 t
= build_int_cst (integer_type_node
, GOMP_ASYNC_NOVAL
);
29119 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
29121 cp_lexer_consume_token (parser
->lexer
);
29123 t
= cp_parser_expression (parser
);
29124 if (t
== error_mark_node
29125 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
29126 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
29127 /*or_comma=*/false,
29128 /*consume_paren=*/true);
29131 check_no_duplicate_clause (list
, OMP_CLAUSE_ASYNC
, "async", loc
);
29133 c
= build_omp_clause (loc
, OMP_CLAUSE_ASYNC
);
29134 OMP_CLAUSE_ASYNC_EXPR (c
) = t
;
29135 OMP_CLAUSE_CHAIN (c
) = list
;
29141 /* Parse all OpenACC clauses. The set clauses allowed by the directive
29142 is a bitmask in MASK. Return the list of clauses found. */
29145 cp_parser_oacc_all_clauses (cp_parser
*parser
, omp_clause_mask mask
,
29146 const char *where
, cp_token
*pragma_tok
,
29147 bool finish_p
= true)
29149 tree clauses
= NULL
;
29152 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
29155 pragma_omp_clause c_kind
;
29156 const char *c_name
;
29157 tree prev
= clauses
;
29159 if (!first
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
29160 cp_lexer_consume_token (parser
->lexer
);
29162 here
= cp_lexer_peek_token (parser
->lexer
)->location
;
29163 c_kind
= cp_parser_omp_clause_name (parser
);
29167 case PRAGMA_OACC_CLAUSE_ASYNC
:
29168 clauses
= cp_parser_oacc_clause_async (parser
, clauses
);
29171 case PRAGMA_OACC_CLAUSE_COLLAPSE
:
29172 clauses
= cp_parser_omp_clause_collapse (parser
, clauses
, here
);
29173 c_name
= "collapse";
29175 case PRAGMA_OACC_CLAUSE_COPY
:
29176 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29179 case PRAGMA_OACC_CLAUSE_COPYIN
:
29180 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29183 case PRAGMA_OACC_CLAUSE_COPYOUT
:
29184 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29185 c_name
= "copyout";
29187 case PRAGMA_OACC_CLAUSE_CREATE
:
29188 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29191 case PRAGMA_OACC_CLAUSE_DELETE
:
29192 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29195 case PRAGMA_OACC_CLAUSE_DEVICE
:
29196 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29199 case PRAGMA_OACC_CLAUSE_DEVICEPTR
:
29200 clauses
= cp_parser_oacc_data_clause_deviceptr (parser
, clauses
);
29201 c_name
= "deviceptr";
29203 case PRAGMA_OACC_CLAUSE_HOST
:
29204 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29207 case PRAGMA_OACC_CLAUSE_IF
:
29208 clauses
= cp_parser_omp_clause_if (parser
, clauses
, here
);
29211 case PRAGMA_OACC_CLAUSE_NUM_GANGS
:
29212 clauses
= cp_parser_omp_clause_num_gangs (parser
, clauses
);
29213 c_name
= "num_gangs";
29215 case PRAGMA_OACC_CLAUSE_NUM_WORKERS
:
29216 clauses
= cp_parser_omp_clause_num_workers (parser
, clauses
);
29217 c_name
= "num_workers";
29219 case PRAGMA_OACC_CLAUSE_PRESENT
:
29220 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29221 c_name
= "present";
29223 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY
:
29224 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29225 c_name
= "present_or_copy";
29227 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN
:
29228 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29229 c_name
= "present_or_copyin";
29231 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT
:
29232 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29233 c_name
= "present_or_copyout";
29235 case PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE
:
29236 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29237 c_name
= "present_or_create";
29239 case PRAGMA_OACC_CLAUSE_REDUCTION
:
29240 clauses
= cp_parser_omp_clause_reduction (parser
, clauses
);
29241 c_name
= "reduction";
29243 case PRAGMA_OACC_CLAUSE_SELF
:
29244 clauses
= cp_parser_oacc_data_clause (parser
, c_kind
, clauses
);
29247 case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH
:
29248 clauses
= cp_parser_oacc_clause_vector_length (parser
, clauses
);
29249 c_name
= "vector_length";
29251 case PRAGMA_OACC_CLAUSE_WAIT
:
29252 clauses
= cp_parser_oacc_clause_wait (parser
, clauses
);
29256 cp_parser_error (parser
, "expected %<#pragma acc%> clause");
29262 if (((mask
>> c_kind
) & 1) == 0)
29264 /* Remove the invalid clause(s) from the list to avoid
29265 confusing the rest of the compiler. */
29267 error_at (here
, "%qs is not valid for %qs", c_name
, where
);
29272 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
29275 return finish_omp_clauses (clauses
);
29280 /* Parse all OpenMP clauses. The set clauses allowed by the directive
29281 is a bitmask in MASK. Return the list of clauses found; the result
29282 of clause default goes in *pdefault. */
29285 cp_parser_omp_all_clauses (cp_parser
*parser
, omp_clause_mask mask
,
29286 const char *where
, cp_token
*pragma_tok
,
29287 bool finish_p
= true)
29289 tree clauses
= NULL
;
29291 cp_token
*token
= NULL
;
29292 bool cilk_simd_fn
= false;
29294 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
29296 pragma_omp_clause c_kind
;
29297 const char *c_name
;
29298 tree prev
= clauses
;
29300 if (!first
&& cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
29301 cp_lexer_consume_token (parser
->lexer
);
29303 token
= cp_lexer_peek_token (parser
->lexer
);
29304 c_kind
= cp_parser_omp_clause_name (parser
);
29308 case PRAGMA_OMP_CLAUSE_COLLAPSE
:
29309 clauses
= cp_parser_omp_clause_collapse (parser
, clauses
,
29311 c_name
= "collapse";
29313 case PRAGMA_OMP_CLAUSE_COPYIN
:
29314 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_COPYIN
, clauses
);
29317 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
29318 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_COPYPRIVATE
,
29320 c_name
= "copyprivate";
29322 case PRAGMA_OMP_CLAUSE_DEFAULT
:
29323 clauses
= cp_parser_omp_clause_default (parser
, clauses
,
29325 c_name
= "default";
29327 case PRAGMA_OMP_CLAUSE_FINAL
:
29328 clauses
= cp_parser_omp_clause_final (parser
, clauses
, token
->location
);
29331 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
29332 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_FIRSTPRIVATE
,
29334 c_name
= "firstprivate";
29336 case PRAGMA_OMP_CLAUSE_IF
:
29337 clauses
= cp_parser_omp_clause_if (parser
, clauses
, token
->location
);
29340 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
29341 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_LASTPRIVATE
,
29343 c_name
= "lastprivate";
29345 case PRAGMA_OMP_CLAUSE_MERGEABLE
:
29346 clauses
= cp_parser_omp_clause_mergeable (parser
, clauses
,
29348 c_name
= "mergeable";
29350 case PRAGMA_OMP_CLAUSE_NOWAIT
:
29351 clauses
= cp_parser_omp_clause_nowait (parser
, clauses
, token
->location
);
29354 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
29355 clauses
= cp_parser_omp_clause_num_threads (parser
, clauses
,
29357 c_name
= "num_threads";
29359 case PRAGMA_OMP_CLAUSE_ORDERED
:
29360 clauses
= cp_parser_omp_clause_ordered (parser
, clauses
,
29362 c_name
= "ordered";
29364 case PRAGMA_OMP_CLAUSE_PRIVATE
:
29365 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_PRIVATE
,
29367 c_name
= "private";
29369 case PRAGMA_OMP_CLAUSE_REDUCTION
:
29370 clauses
= cp_parser_omp_clause_reduction (parser
, clauses
);
29371 c_name
= "reduction";
29373 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
29374 clauses
= cp_parser_omp_clause_schedule (parser
, clauses
,
29376 c_name
= "schedule";
29378 case PRAGMA_OMP_CLAUSE_SHARED
:
29379 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_SHARED
,
29383 case PRAGMA_OMP_CLAUSE_UNTIED
:
29384 clauses
= cp_parser_omp_clause_untied (parser
, clauses
,
29388 case PRAGMA_OMP_CLAUSE_INBRANCH
:
29389 case PRAGMA_CILK_CLAUSE_MASK
:
29390 clauses
= cp_parser_omp_clause_branch (parser
, OMP_CLAUSE_INBRANCH
,
29391 clauses
, token
->location
);
29392 c_name
= "inbranch";
29394 case PRAGMA_OMP_CLAUSE_NOTINBRANCH
:
29395 case PRAGMA_CILK_CLAUSE_NOMASK
:
29396 clauses
= cp_parser_omp_clause_branch (parser
,
29397 OMP_CLAUSE_NOTINBRANCH
,
29398 clauses
, token
->location
);
29399 c_name
= "notinbranch";
29401 case PRAGMA_OMP_CLAUSE_PARALLEL
:
29402 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_PARALLEL
,
29403 clauses
, token
->location
);
29404 c_name
= "parallel";
29408 error_at (token
->location
, "%qs must be the first clause of %qs",
29413 case PRAGMA_OMP_CLAUSE_FOR
:
29414 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_FOR
,
29415 clauses
, token
->location
);
29418 goto clause_not_first
;
29420 case PRAGMA_OMP_CLAUSE_SECTIONS
:
29421 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_SECTIONS
,
29422 clauses
, token
->location
);
29423 c_name
= "sections";
29425 goto clause_not_first
;
29427 case PRAGMA_OMP_CLAUSE_TASKGROUP
:
29428 clauses
= cp_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_TASKGROUP
,
29429 clauses
, token
->location
);
29430 c_name
= "taskgroup";
29432 goto clause_not_first
;
29434 case PRAGMA_OMP_CLAUSE_TO
:
29435 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_TO
,
29439 case PRAGMA_OMP_CLAUSE_FROM
:
29440 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_FROM
,
29444 case PRAGMA_OMP_CLAUSE_UNIFORM
:
29445 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_UNIFORM
,
29447 c_name
= "uniform";
29449 case PRAGMA_OMP_CLAUSE_NUM_TEAMS
:
29450 clauses
= cp_parser_omp_clause_num_teams (parser
, clauses
,
29452 c_name
= "num_teams";
29454 case PRAGMA_OMP_CLAUSE_THREAD_LIMIT
:
29455 clauses
= cp_parser_omp_clause_thread_limit (parser
, clauses
,
29457 c_name
= "thread_limit";
29459 case PRAGMA_OMP_CLAUSE_ALIGNED
:
29460 clauses
= cp_parser_omp_clause_aligned (parser
, clauses
);
29461 c_name
= "aligned";
29463 case PRAGMA_OMP_CLAUSE_LINEAR
:
29464 if (((mask
>> PRAGMA_CILK_CLAUSE_VECTORLENGTH
) & 1) != 0)
29465 cilk_simd_fn
= true;
29466 clauses
= cp_parser_omp_clause_linear (parser
, clauses
, cilk_simd_fn
);
29469 case PRAGMA_OMP_CLAUSE_DEPEND
:
29470 clauses
= cp_parser_omp_clause_depend (parser
, clauses
);
29473 case PRAGMA_OMP_CLAUSE_MAP
:
29474 clauses
= cp_parser_omp_clause_map (parser
, clauses
);
29477 case PRAGMA_OMP_CLAUSE_DEVICE
:
29478 clauses
= cp_parser_omp_clause_device (parser
, clauses
,
29482 case PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
:
29483 clauses
= cp_parser_omp_clause_dist_schedule (parser
, clauses
,
29485 c_name
= "dist_schedule";
29487 case PRAGMA_OMP_CLAUSE_PROC_BIND
:
29488 clauses
= cp_parser_omp_clause_proc_bind (parser
, clauses
,
29490 c_name
= "proc_bind";
29492 case PRAGMA_OMP_CLAUSE_SAFELEN
:
29493 clauses
= cp_parser_omp_clause_safelen (parser
, clauses
,
29495 c_name
= "safelen";
29497 case PRAGMA_OMP_CLAUSE_SIMDLEN
:
29498 clauses
= cp_parser_omp_clause_simdlen (parser
, clauses
,
29500 c_name
= "simdlen";
29502 case PRAGMA_CILK_CLAUSE_VECTORLENGTH
:
29503 clauses
= cp_parser_cilk_simd_vectorlength (parser
, clauses
, true);
29504 c_name
= "simdlen";
29507 cp_parser_error (parser
, "expected %<#pragma omp%> clause");
29513 if (((mask
>> c_kind
) & 1) == 0)
29515 /* Remove the invalid clause(s) from the list to avoid
29516 confusing the rest of the compiler. */
29518 error_at (token
->location
, "%qs is not valid for %qs", c_name
, where
);
29522 /* In Cilk Plus SIMD enabled functions there is no pragma_token, so
29523 no reason to skip to the end. */
29524 if (!(flag_cilkplus
&& pragma_tok
== NULL
))
29525 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
29527 return finish_omp_clauses (clauses
);
29535 In practice, we're also interested in adding the statement to an
29536 outer node. So it is convenient if we work around the fact that
29537 cp_parser_statement calls add_stmt. */
29540 cp_parser_begin_omp_structured_block (cp_parser
*parser
)
29542 unsigned save
= parser
->in_statement
;
29544 /* Only move the values to IN_OMP_BLOCK if they weren't false.
29545 This preserves the "not within loop or switch" style error messages
29546 for nonsense cases like
29552 if (parser
->in_statement
)
29553 parser
->in_statement
= IN_OMP_BLOCK
;
29559 cp_parser_end_omp_structured_block (cp_parser
*parser
, unsigned save
)
29561 parser
->in_statement
= save
;
29565 cp_parser_omp_structured_block (cp_parser
*parser
)
29567 tree stmt
= begin_omp_structured_block ();
29568 unsigned int save
= cp_parser_begin_omp_structured_block (parser
);
29570 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
29572 cp_parser_end_omp_structured_block (parser
, save
);
29573 return finish_omp_structured_block (stmt
);
29577 # pragma omp atomic new-line
29581 x binop= expr | x++ | ++x | x-- | --x
29583 +, *, -, /, &, ^, |, <<, >>
29585 where x is an lvalue expression with scalar type.
29588 # pragma omp atomic new-line
29591 # pragma omp atomic read new-line
29594 # pragma omp atomic write new-line
29597 # pragma omp atomic update new-line
29600 # pragma omp atomic capture new-line
29603 # pragma omp atomic capture new-line
29611 expression-stmt | x = x binop expr
29613 v = expression-stmt
29615 { v = x; update-stmt; } | { update-stmt; v = x; }
29619 expression-stmt | x = x binop expr | x = expr binop x
29623 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
29625 where x and v are lvalue expressions with scalar type. */
29628 cp_parser_omp_atomic (cp_parser
*parser
, cp_token
*pragma_tok
)
29630 tree lhs
= NULL_TREE
, rhs
= NULL_TREE
, v
= NULL_TREE
, lhs1
= NULL_TREE
;
29631 tree rhs1
= NULL_TREE
, orig_lhs
;
29632 enum tree_code code
= OMP_ATOMIC
, opcode
= NOP_EXPR
;
29633 bool structured_block
= false;
29634 bool seq_cst
= false;
29636 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29638 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29639 const char *p
= IDENTIFIER_POINTER (id
);
29641 if (!strcmp (p
, "seq_cst"))
29644 cp_lexer_consume_token (parser
->lexer
);
29645 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
)
29646 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_NAME
)
29647 cp_lexer_consume_token (parser
->lexer
);
29650 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29652 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29653 const char *p
= IDENTIFIER_POINTER (id
);
29655 if (!strcmp (p
, "read"))
29656 code
= OMP_ATOMIC_READ
;
29657 else if (!strcmp (p
, "write"))
29659 else if (!strcmp (p
, "update"))
29661 else if (!strcmp (p
, "capture"))
29662 code
= OMP_ATOMIC_CAPTURE_NEW
;
29666 cp_lexer_consume_token (parser
->lexer
);
29670 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
)
29671 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
== CPP_NAME
)
29672 cp_lexer_consume_token (parser
->lexer
);
29674 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
29676 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
29677 const char *p
= IDENTIFIER_POINTER (id
);
29679 if (!strcmp (p
, "seq_cst"))
29682 cp_lexer_consume_token (parser
->lexer
);
29686 cp_parser_require_pragma_eol (parser
, pragma_tok
);
29690 case OMP_ATOMIC_READ
:
29691 case NOP_EXPR
: /* atomic write */
29692 v
= cp_parser_unary_expression (parser
);
29693 if (v
== error_mark_node
)
29695 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
29697 if (code
== NOP_EXPR
)
29698 lhs
= cp_parser_expression (parser
);
29700 lhs
= cp_parser_unary_expression (parser
);
29701 if (lhs
== error_mark_node
)
29703 if (code
== NOP_EXPR
)
29705 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
29713 case OMP_ATOMIC_CAPTURE_NEW
:
29714 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
29716 cp_lexer_consume_token (parser
->lexer
);
29717 structured_block
= true;
29721 v
= cp_parser_unary_expression (parser
);
29722 if (v
== error_mark_node
)
29724 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
29732 lhs
= cp_parser_unary_expression (parser
);
29734 switch (TREE_CODE (lhs
))
29739 case POSTINCREMENT_EXPR
:
29740 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
29741 code
= OMP_ATOMIC_CAPTURE_OLD
;
29743 case PREINCREMENT_EXPR
:
29744 lhs
= TREE_OPERAND (lhs
, 0);
29745 opcode
= PLUS_EXPR
;
29746 rhs
= integer_one_node
;
29749 case POSTDECREMENT_EXPR
:
29750 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
29751 code
= OMP_ATOMIC_CAPTURE_OLD
;
29753 case PREDECREMENT_EXPR
:
29754 lhs
= TREE_OPERAND (lhs
, 0);
29755 opcode
= MINUS_EXPR
;
29756 rhs
= integer_one_node
;
29759 case COMPOUND_EXPR
:
29760 if (TREE_CODE (TREE_OPERAND (lhs
, 0)) == SAVE_EXPR
29761 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == COMPOUND_EXPR
29762 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0)) == MODIFY_EXPR
29763 && TREE_OPERAND (TREE_OPERAND (lhs
, 1), 1) == TREE_OPERAND (lhs
, 0)
29764 && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
29765 (TREE_OPERAND (lhs
, 1), 0), 0)))
29767 /* Undo effects of boolean_increment for post {in,de}crement. */
29768 lhs
= TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0);
29771 if (TREE_CODE (lhs
) == MODIFY_EXPR
29772 && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) == BOOLEAN_TYPE
)
29774 /* Undo effects of boolean_increment. */
29775 if (integer_onep (TREE_OPERAND (lhs
, 1)))
29777 /* This is pre or post increment. */
29778 rhs
= TREE_OPERAND (lhs
, 1);
29779 lhs
= TREE_OPERAND (lhs
, 0);
29781 if (code
== OMP_ATOMIC_CAPTURE_NEW
29782 && !structured_block
29783 && TREE_CODE (orig_lhs
) == COMPOUND_EXPR
)
29784 code
= OMP_ATOMIC_CAPTURE_OLD
;
29790 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
29793 opcode
= MULT_EXPR
;
29796 opcode
= TRUNC_DIV_EXPR
;
29799 opcode
= PLUS_EXPR
;
29802 opcode
= MINUS_EXPR
;
29804 case CPP_LSHIFT_EQ
:
29805 opcode
= LSHIFT_EXPR
;
29807 case CPP_RSHIFT_EQ
:
29808 opcode
= RSHIFT_EXPR
;
29811 opcode
= BIT_AND_EXPR
;
29814 opcode
= BIT_IOR_EXPR
;
29817 opcode
= BIT_XOR_EXPR
;
29820 enum cp_parser_prec oprec
;
29822 cp_lexer_consume_token (parser
->lexer
);
29823 cp_parser_parse_tentatively (parser
);
29824 rhs1
= cp_parser_simple_cast_expression (parser
);
29825 if (rhs1
== error_mark_node
)
29827 cp_parser_abort_tentative_parse (parser
);
29828 cp_parser_simple_cast_expression (parser
);
29831 token
= cp_lexer_peek_token (parser
->lexer
);
29832 if (token
->type
!= CPP_SEMICOLON
&& !cp_tree_equal (lhs
, rhs1
))
29834 cp_parser_abort_tentative_parse (parser
);
29835 cp_parser_parse_tentatively (parser
);
29836 rhs
= cp_parser_binary_expression (parser
, false, true,
29837 PREC_NOT_OPERATOR
, NULL
);
29838 if (rhs
== error_mark_node
)
29840 cp_parser_abort_tentative_parse (parser
);
29841 cp_parser_binary_expression (parser
, false, true,
29842 PREC_NOT_OPERATOR
, NULL
);
29845 switch (TREE_CODE (rhs
))
29848 case TRUNC_DIV_EXPR
:
29857 if (cp_tree_equal (lhs
, TREE_OPERAND (rhs
, 1)))
29859 if (cp_parser_parse_definitely (parser
))
29861 opcode
= TREE_CODE (rhs
);
29862 rhs1
= TREE_OPERAND (rhs
, 0);
29863 rhs
= TREE_OPERAND (rhs
, 1);
29873 cp_parser_abort_tentative_parse (parser
);
29874 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_OLD
)
29876 rhs
= cp_parser_expression (parser
);
29877 if (rhs
== error_mark_node
)
29883 cp_parser_error (parser
,
29884 "invalid form of %<#pragma omp atomic%>");
29887 if (!cp_parser_parse_definitely (parser
))
29889 switch (token
->type
)
29891 case CPP_SEMICOLON
:
29892 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
29894 code
= OMP_ATOMIC_CAPTURE_OLD
;
29899 cp_lexer_consume_token (parser
->lexer
);
29902 else if (structured_block
)
29909 cp_parser_error (parser
,
29910 "invalid form of %<#pragma omp atomic%>");
29913 opcode
= MULT_EXPR
;
29916 opcode
= TRUNC_DIV_EXPR
;
29919 opcode
= PLUS_EXPR
;
29922 opcode
= MINUS_EXPR
;
29925 opcode
= LSHIFT_EXPR
;
29928 opcode
= RSHIFT_EXPR
;
29931 opcode
= BIT_AND_EXPR
;
29934 opcode
= BIT_IOR_EXPR
;
29937 opcode
= BIT_XOR_EXPR
;
29940 cp_parser_error (parser
,
29941 "invalid operator for %<#pragma omp atomic%>");
29944 oprec
= TOKEN_PRECEDENCE (token
);
29945 gcc_assert (oprec
!= PREC_NOT_OPERATOR
);
29946 if (commutative_tree_code (opcode
))
29947 oprec
= (enum cp_parser_prec
) (oprec
- 1);
29948 cp_lexer_consume_token (parser
->lexer
);
29949 rhs
= cp_parser_binary_expression (parser
, false, false,
29951 if (rhs
== error_mark_node
)
29956 cp_parser_error (parser
,
29957 "invalid operator for %<#pragma omp atomic%>");
29960 cp_lexer_consume_token (parser
->lexer
);
29962 rhs
= cp_parser_expression (parser
);
29963 if (rhs
== error_mark_node
)
29968 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
29970 if (!cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
))
29972 v
= cp_parser_unary_expression (parser
);
29973 if (v
== error_mark_node
)
29975 if (!cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
29977 lhs1
= cp_parser_unary_expression (parser
);
29978 if (lhs1
== error_mark_node
)
29981 if (structured_block
)
29983 cp_parser_consume_semicolon_at_end_of_statement (parser
);
29984 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
29987 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
, seq_cst
);
29988 if (!structured_block
)
29989 cp_parser_consume_semicolon_at_end_of_statement (parser
);
29993 cp_parser_skip_to_end_of_block_or_statement (parser
);
29994 if (structured_block
)
29996 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
29997 cp_lexer_consume_token (parser
->lexer
);
29998 else if (code
== OMP_ATOMIC_CAPTURE_NEW
)
30000 cp_parser_skip_to_end_of_block_or_statement (parser
);
30001 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
30002 cp_lexer_consume_token (parser
->lexer
);
30009 # pragma omp barrier new-line */
30012 cp_parser_omp_barrier (cp_parser
*parser
, cp_token
*pragma_tok
)
30014 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30015 finish_omp_barrier ();
30019 # pragma omp critical [(name)] new-line
30020 structured-block */
30023 cp_parser_omp_critical (cp_parser
*parser
, cp_token
*pragma_tok
)
30025 tree stmt
, name
= NULL
;
30027 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
30029 cp_lexer_consume_token (parser
->lexer
);
30031 name
= cp_parser_identifier (parser
);
30033 if (name
== error_mark_node
30034 || !cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
30035 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
30036 /*or_comma=*/false,
30037 /*consume_paren=*/true);
30038 if (name
== error_mark_node
)
30041 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30043 stmt
= cp_parser_omp_structured_block (parser
);
30044 return c_finish_omp_critical (input_location
, stmt
, name
);
30048 # pragma omp flush flush-vars[opt] new-line
30051 ( variable-list ) */
30054 cp_parser_omp_flush (cp_parser
*parser
, cp_token
*pragma_tok
)
30056 if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
))
30057 (void) cp_parser_omp_var_list (parser
, OMP_CLAUSE_ERROR
, NULL
);
30058 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30060 finish_omp_flush ();
30063 /* Helper function, to parse omp for increment expression. */
30066 cp_parser_omp_for_cond (cp_parser
*parser
, tree decl
, enum tree_code code
)
30068 tree cond
= cp_parser_binary_expression (parser
, false, true,
30069 PREC_NOT_OPERATOR
, NULL
);
30070 if (cond
== error_mark_node
30071 || cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
30073 cp_parser_skip_to_end_of_statement (parser
);
30074 return error_mark_node
;
30077 switch (TREE_CODE (cond
))
30085 if (code
== CILK_SIMD
|| code
== CILK_FOR
)
30087 /* Fall through: OpenMP disallows NE_EXPR. */
30089 return error_mark_node
;
30092 /* If decl is an iterator, preserve LHS and RHS of the relational
30093 expr until finish_omp_for. */
30095 && (type_dependent_expression_p (decl
)
30096 || CLASS_TYPE_P (TREE_TYPE (decl
))))
30099 return build_x_binary_op (input_location
, TREE_CODE (cond
),
30100 TREE_OPERAND (cond
, 0), ERROR_MARK
,
30101 TREE_OPERAND (cond
, 1), ERROR_MARK
,
30102 /*overload=*/NULL
, tf_warning_or_error
);
30105 /* Helper function, to parse omp for increment expression. */
30108 cp_parser_omp_for_incr (cp_parser
*parser
, tree decl
)
30110 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
30116 if (token
->type
== CPP_PLUS_PLUS
|| token
->type
== CPP_MINUS_MINUS
)
30118 op
= (token
->type
== CPP_PLUS_PLUS
30119 ? PREINCREMENT_EXPR
: PREDECREMENT_EXPR
);
30120 cp_lexer_consume_token (parser
->lexer
);
30121 lhs
= cp_parser_simple_cast_expression (parser
);
30123 return error_mark_node
;
30124 return build2 (op
, TREE_TYPE (decl
), decl
, NULL_TREE
);
30127 lhs
= cp_parser_primary_expression (parser
, false, false, false, &idk
);
30129 return error_mark_node
;
30131 token
= cp_lexer_peek_token (parser
->lexer
);
30132 if (token
->type
== CPP_PLUS_PLUS
|| token
->type
== CPP_MINUS_MINUS
)
30134 op
= (token
->type
== CPP_PLUS_PLUS
30135 ? POSTINCREMENT_EXPR
: POSTDECREMENT_EXPR
);
30136 cp_lexer_consume_token (parser
->lexer
);
30137 return build2 (op
, TREE_TYPE (decl
), decl
, NULL_TREE
);
30140 op
= cp_parser_assignment_operator_opt (parser
);
30141 if (op
== ERROR_MARK
)
30142 return error_mark_node
;
30144 if (op
!= NOP_EXPR
)
30146 rhs
= cp_parser_assignment_expression (parser
);
30147 rhs
= build2 (op
, TREE_TYPE (decl
), decl
, rhs
);
30148 return build2 (MODIFY_EXPR
, TREE_TYPE (decl
), decl
, rhs
);
30151 lhs
= cp_parser_binary_expression (parser
, false, false,
30152 PREC_ADDITIVE_EXPRESSION
, NULL
);
30153 token
= cp_lexer_peek_token (parser
->lexer
);
30154 decl_first
= lhs
== decl
;
30157 if (token
->type
!= CPP_PLUS
30158 && token
->type
!= CPP_MINUS
)
30159 return error_mark_node
;
30163 op
= token
->type
== CPP_PLUS
? PLUS_EXPR
: MINUS_EXPR
;
30164 cp_lexer_consume_token (parser
->lexer
);
30165 rhs
= cp_parser_binary_expression (parser
, false, false,
30166 PREC_ADDITIVE_EXPRESSION
, NULL
);
30167 token
= cp_lexer_peek_token (parser
->lexer
);
30168 if (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
|| decl_first
)
30170 if (lhs
== NULL_TREE
)
30172 if (op
== PLUS_EXPR
)
30175 lhs
= build_x_unary_op (input_location
, NEGATE_EXPR
, rhs
,
30176 tf_warning_or_error
);
30179 lhs
= build_x_binary_op (input_location
, op
, lhs
, ERROR_MARK
, rhs
,
30180 ERROR_MARK
, NULL
, tf_warning_or_error
);
30183 while (token
->type
== CPP_PLUS
|| token
->type
== CPP_MINUS
);
30187 if (rhs
!= decl
|| op
== MINUS_EXPR
)
30188 return error_mark_node
;
30189 rhs
= build2 (op
, TREE_TYPE (decl
), lhs
, decl
);
30192 rhs
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), decl
, lhs
);
30194 return build2 (MODIFY_EXPR
, TREE_TYPE (decl
), decl
, rhs
);
30197 /* Parse the initialization statement of either an OpenMP for loop or
30198 a Cilk Plus for loop.
30200 Return true if the resulting construct should have an
30201 OMP_CLAUSE_PRIVATE added to it. */
30204 cp_parser_omp_for_loop_init (cp_parser
*parser
,
30205 enum tree_code code
,
30206 tree
&this_pre_body
,
30207 vec
<tree
, va_gc
> *for_block
,
30212 if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
30215 bool add_private_clause
= false;
30217 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
30221 integer-type var = lb
30222 random-access-iterator-type var = lb
30223 pointer-type var = lb
30225 cp_decl_specifier_seq type_specifiers
;
30227 /* First, try to parse as an initialized declaration. See
30228 cp_parser_condition, from whence the bulk of this is copied. */
30230 cp_parser_parse_tentatively (parser
);
30231 cp_parser_type_specifier_seq (parser
, /*is_declaration=*/true,
30232 /*is_trailing_return=*/false,
30234 if (cp_parser_parse_definitely (parser
))
30236 /* If parsing a type specifier seq succeeded, then this
30237 MUST be a initialized declaration. */
30238 tree asm_specification
, attributes
;
30239 cp_declarator
*declarator
;
30241 declarator
= cp_parser_declarator (parser
,
30242 CP_PARSER_DECLARATOR_NAMED
,
30243 /*ctor_dtor_or_conv_p=*/NULL
,
30244 /*parenthesized_p=*/NULL
,
30245 /*member_p=*/false,
30246 /*friend_p=*/false);
30247 attributes
= cp_parser_attributes_opt (parser
);
30248 asm_specification
= cp_parser_asm_specification_opt (parser
);
30250 if (declarator
== cp_error_declarator
)
30251 cp_parser_skip_to_end_of_statement (parser
);
30255 tree pushed_scope
, auto_node
;
30257 decl
= start_decl (declarator
, &type_specifiers
,
30258 SD_INITIALIZED
, attributes
,
30259 /*prefix_attributes=*/NULL_TREE
,
30262 auto_node
= type_uses_auto (TREE_TYPE (decl
));
30263 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_EQ
))
30265 if (cp_lexer_next_token_is (parser
->lexer
,
30268 if (code
!= CILK_SIMD
&& code
!= CILK_FOR
)
30269 error ("parenthesized initialization is not allowed in "
30270 "OpenMP %<for%> loop");
30272 error ("parenthesized initialization is "
30273 "not allowed in for-loop");
30276 /* Trigger an error. */
30277 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
30279 init
= error_mark_node
;
30280 cp_parser_skip_to_end_of_statement (parser
);
30282 else if (CLASS_TYPE_P (TREE_TYPE (decl
))
30283 || type_dependent_expression_p (decl
)
30286 bool is_direct_init
, is_non_constant_init
;
30288 init
= cp_parser_initializer (parser
,
30290 &is_non_constant_init
);
30295 = do_auto_deduction (TREE_TYPE (decl
), init
,
30298 if (!CLASS_TYPE_P (TREE_TYPE (decl
))
30299 && !type_dependent_expression_p (decl
))
30303 cp_finish_decl (decl
, init
, !is_non_constant_init
,
30305 LOOKUP_ONLYCONVERTING
);
30306 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
30308 vec_safe_push (for_block
, this_pre_body
);
30312 init
= pop_stmt_list (this_pre_body
);
30313 this_pre_body
= NULL_TREE
;
30318 cp_lexer_consume_token (parser
->lexer
);
30319 init
= cp_parser_assignment_expression (parser
);
30322 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
)
30323 init
= error_mark_node
;
30325 cp_finish_decl (decl
, NULL_TREE
,
30326 /*init_const_expr_p=*/false,
30328 LOOKUP_ONLYCONVERTING
);
30332 pop_scope (pushed_scope
);
30338 /* If parsing a type specifier sequence failed, then
30339 this MUST be a simple expression. */
30340 if (code
== CILK_FOR
)
30341 error ("%<_Cilk_for%> allows expression instead of declaration only "
30342 "in C, not in C++");
30343 cp_parser_parse_tentatively (parser
);
30344 decl
= cp_parser_primary_expression (parser
, false, false,
30346 if (!cp_parser_error_occurred (parser
)
30349 && CLASS_TYPE_P (TREE_TYPE (decl
)))
30353 cp_parser_parse_definitely (parser
);
30354 cp_parser_require (parser
, CPP_EQ
, RT_EQ
);
30355 rhs
= cp_parser_assignment_expression (parser
);
30356 finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs
),
30359 tf_warning_or_error
));
30360 add_private_clause
= true;
30365 cp_parser_abort_tentative_parse (parser
);
30366 init
= cp_parser_expression (parser
);
30369 if (TREE_CODE (init
) == MODIFY_EXPR
30370 || TREE_CODE (init
) == MODOP_EXPR
)
30371 real_decl
= TREE_OPERAND (init
, 0);
30375 return add_private_clause
;
30378 /* Parse the restricted form of the for statement allowed by OpenMP. */
30381 cp_parser_omp_for_loop (cp_parser
*parser
, enum tree_code code
, tree clauses
,
30384 tree init
, cond
, incr
, body
, decl
, pre_body
= NULL_TREE
, ret
;
30385 tree real_decl
, initv
, condv
, incrv
, declv
;
30386 tree this_pre_body
, cl
;
30387 location_t loc_first
;
30388 bool collapse_err
= false;
30389 int i
, collapse
= 1, nbraces
= 0;
30390 vec
<tree
, va_gc
> *for_block
= make_tree_vector ();
30392 for (cl
= clauses
; cl
; cl
= OMP_CLAUSE_CHAIN (cl
))
30393 if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_COLLAPSE
)
30394 collapse
= tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (cl
));
30396 gcc_assert (collapse
>= 1);
30398 declv
= make_tree_vec (collapse
);
30399 initv
= make_tree_vec (collapse
);
30400 condv
= make_tree_vec (collapse
);
30401 incrv
= make_tree_vec (collapse
);
30403 loc_first
= cp_lexer_peek_token (parser
->lexer
)->location
;
30405 for (i
= 0; i
< collapse
; i
++)
30407 int bracecount
= 0;
30408 bool add_private_clause
= false;
30411 if (code
!= CILK_FOR
30412 && !cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
30414 cp_parser_error (parser
, "for statement expected");
30417 if (code
== CILK_FOR
30418 && !cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CILK_FOR
))
30420 cp_parser_error (parser
, "_Cilk_for statement expected");
30423 loc
= cp_lexer_consume_token (parser
->lexer
)->location
;
30425 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
30428 init
= decl
= real_decl
= NULL
;
30429 this_pre_body
= push_stmt_list ();
30432 |= cp_parser_omp_for_loop_init (parser
, code
,
30433 this_pre_body
, for_block
,
30434 init
, decl
, real_decl
);
30436 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
30439 this_pre_body
= pop_stmt_list (this_pre_body
);
30443 pre_body
= push_stmt_list ();
30445 add_stmt (this_pre_body
);
30446 pre_body
= pop_stmt_list (pre_body
);
30449 pre_body
= this_pre_body
;
30454 if (cclauses
!= NULL
30455 && cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
] != NULL
30456 && real_decl
!= NULL_TREE
)
30459 for (c
= &cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
]; *c
; )
30460 if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_FIRSTPRIVATE
30461 && OMP_CLAUSE_DECL (*c
) == real_decl
)
30463 error_at (loc
, "iteration variable %qD"
30464 " should not be firstprivate", real_decl
);
30465 *c
= OMP_CLAUSE_CHAIN (*c
);
30467 else if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_LASTPRIVATE
30468 && OMP_CLAUSE_DECL (*c
) == real_decl
)
30470 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
30471 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
30472 tree l
= build_omp_clause (loc
, OMP_CLAUSE_LASTPRIVATE
);
30473 OMP_CLAUSE_DECL (l
) = real_decl
;
30474 CP_OMP_CLAUSE_INFO (l
) = CP_OMP_CLAUSE_INFO (*c
);
30475 if (code
== OMP_SIMD
)
30477 OMP_CLAUSE_CHAIN (l
) = cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
30478 cclauses
[C_OMP_CLAUSE_SPLIT_FOR
] = l
;
30482 OMP_CLAUSE_CHAIN (l
) = clauses
;
30485 OMP_CLAUSE_SET_CODE (*c
, OMP_CLAUSE_SHARED
);
30486 CP_OMP_CLAUSE_INFO (*c
) = NULL
;
30487 add_private_clause
= false;
30491 if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_PRIVATE
30492 && OMP_CLAUSE_DECL (*c
) == real_decl
)
30493 add_private_clause
= false;
30494 c
= &OMP_CLAUSE_CHAIN (*c
);
30498 if (add_private_clause
)
30501 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
30503 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
30504 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
30505 && OMP_CLAUSE_DECL (c
) == decl
)
30507 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
30508 && OMP_CLAUSE_DECL (c
) == decl
)
30509 error_at (loc
, "iteration variable %qD "
30510 "should not be firstprivate",
30512 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
30513 && OMP_CLAUSE_DECL (c
) == decl
)
30514 error_at (loc
, "iteration variable %qD should not be reduction",
30519 c
= build_omp_clause (loc
, OMP_CLAUSE_PRIVATE
);
30520 OMP_CLAUSE_DECL (c
) = decl
;
30521 c
= finish_omp_clauses (c
);
30524 OMP_CLAUSE_CHAIN (c
) = clauses
;
30531 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_SEMICOLON
))
30532 cond
= cp_parser_omp_for_cond (parser
, decl
, code
);
30533 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
30536 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_CLOSE_PAREN
))
30538 /* If decl is an iterator, preserve the operator on decl
30539 until finish_omp_for. */
30541 && ((processing_template_decl
30542 && !POINTER_TYPE_P (TREE_TYPE (real_decl
)))
30543 || CLASS_TYPE_P (TREE_TYPE (real_decl
))))
30544 incr
= cp_parser_omp_for_incr (parser
, real_decl
);
30546 incr
= cp_parser_expression (parser
);
30547 if (CAN_HAVE_LOCATION_P (incr
) && !EXPR_HAS_LOCATION (incr
))
30548 SET_EXPR_LOCATION (incr
, input_location
);
30551 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
30552 cp_parser_skip_to_closing_parenthesis (parser
, /*recovering=*/true,
30553 /*or_comma=*/false,
30554 /*consume_paren=*/true);
30556 TREE_VEC_ELT (declv
, i
) = decl
;
30557 TREE_VEC_ELT (initv
, i
) = init
;
30558 TREE_VEC_ELT (condv
, i
) = cond
;
30559 TREE_VEC_ELT (incrv
, i
) = incr
;
30561 if (i
== collapse
- 1)
30564 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
30565 in between the collapsed for loops to be still considered perfectly
30566 nested. Hopefully the final version clarifies this.
30567 For now handle (multiple) {'s and empty statements. */
30568 cp_parser_parse_tentatively (parser
);
30571 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
30573 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_BRACE
))
30575 cp_lexer_consume_token (parser
->lexer
);
30578 else if (bracecount
30579 && cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
30580 cp_lexer_consume_token (parser
->lexer
);
30583 loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30584 error_at (loc
, "not enough collapsed for loops");
30585 collapse_err
= true;
30586 cp_parser_abort_tentative_parse (parser
);
30595 cp_parser_parse_definitely (parser
);
30596 nbraces
+= bracecount
;
30600 /* Note that we saved the original contents of this flag when we entered
30601 the structured block, and so we don't need to re-save it here. */
30602 if (code
== CILK_SIMD
|| code
== CILK_FOR
)
30603 parser
->in_statement
= IN_CILK_SIMD_FOR
;
30605 parser
->in_statement
= IN_OMP_FOR
;
30607 /* Note that the grammar doesn't call for a structured block here,
30608 though the loop as a whole is a structured block. */
30609 body
= push_stmt_list ();
30610 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
30611 body
= pop_stmt_list (body
);
30613 if (declv
== NULL_TREE
)
30616 ret
= finish_omp_for (loc_first
, code
, declv
, initv
, condv
, incrv
, body
,
30617 pre_body
, clauses
);
30621 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_BRACE
))
30623 cp_lexer_consume_token (parser
->lexer
);
30626 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_SEMICOLON
))
30627 cp_lexer_consume_token (parser
->lexer
);
30632 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
30633 "collapsed loops not perfectly nested");
30635 collapse_err
= true;
30636 cp_parser_statement_seq_opt (parser
, NULL
);
30637 if (cp_lexer_next_token_is (parser
->lexer
, CPP_EOF
))
30642 while (!for_block
->is_empty ())
30643 add_stmt (pop_stmt_list (for_block
->pop ()));
30644 release_tree_vector (for_block
);
30649 /* Helper function for OpenMP parsing, split clauses and call
30650 finish_omp_clauses on each of the set of clauses afterwards. */
30653 cp_omp_split_clauses (location_t loc
, enum tree_code code
,
30654 omp_clause_mask mask
, tree clauses
, tree
*cclauses
)
30657 c_omp_split_clauses (loc
, code
, mask
, clauses
, cclauses
);
30658 for (i
= 0; i
< C_OMP_CLAUSE_SPLIT_COUNT
; i
++)
30660 cclauses
[i
] = finish_omp_clauses (cclauses
[i
]);
30664 #pragma omp simd simd-clause[optseq] new-line
30667 #define OMP_SIMD_CLAUSE_MASK \
30668 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
30669 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
30670 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
30671 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30672 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30673 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30674 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30677 cp_parser_omp_simd (cp_parser
*parser
, cp_token
*pragma_tok
,
30678 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30680 tree clauses
, sb
, ret
;
30682 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30684 strcat (p_name
, " simd");
30685 mask
|= OMP_SIMD_CLAUSE_MASK
;
30686 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_ORDERED
);
30688 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
30692 cp_omp_split_clauses (loc
, OMP_SIMD
, mask
, clauses
, cclauses
);
30693 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SIMD
];
30696 sb
= begin_omp_structured_block ();
30697 save
= cp_parser_begin_omp_structured_block (parser
);
30699 ret
= cp_parser_omp_for_loop (parser
, OMP_SIMD
, clauses
, cclauses
);
30701 cp_parser_end_omp_structured_block (parser
, save
);
30702 add_stmt (finish_omp_structured_block (sb
));
30708 #pragma omp for for-clause[optseq] new-line
30712 #pragma omp for simd for-simd-clause[optseq] new-line
30715 #define OMP_FOR_CLAUSE_MASK \
30716 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30717 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30718 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30719 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30720 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
30721 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
30722 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
30723 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30726 cp_parser_omp_for (cp_parser
*parser
, cp_token
*pragma_tok
,
30727 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30729 tree clauses
, sb
, ret
;
30731 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30733 strcat (p_name
, " for");
30734 mask
|= OMP_FOR_CLAUSE_MASK
;
30736 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
30738 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
30740 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
30741 const char *p
= IDENTIFIER_POINTER (id
);
30743 if (strcmp (p
, "simd") == 0)
30745 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
30746 if (cclauses
== NULL
)
30747 cclauses
= cclauses_buf
;
30749 cp_lexer_consume_token (parser
->lexer
);
30750 if (!flag_openmp
) /* flag_openmp_simd */
30751 return cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
30753 sb
= begin_omp_structured_block ();
30754 save
= cp_parser_begin_omp_structured_block (parser
);
30755 ret
= cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
30757 cp_parser_end_omp_structured_block (parser
, save
);
30758 tree body
= finish_omp_structured_block (sb
);
30761 ret
= make_node (OMP_FOR
);
30762 TREE_TYPE (ret
) = void_type_node
;
30763 OMP_FOR_BODY (ret
) = body
;
30764 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
30765 SET_EXPR_LOCATION (ret
, loc
);
30770 if (!flag_openmp
) /* flag_openmp_simd */
30772 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30776 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
30780 cp_omp_split_clauses (loc
, OMP_FOR
, mask
, clauses
, cclauses
);
30781 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
30784 sb
= begin_omp_structured_block ();
30785 save
= cp_parser_begin_omp_structured_block (parser
);
30787 ret
= cp_parser_omp_for_loop (parser
, OMP_FOR
, clauses
, cclauses
);
30789 cp_parser_end_omp_structured_block (parser
, save
);
30790 add_stmt (finish_omp_structured_block (sb
));
30796 # pragma omp master new-line
30797 structured-block */
30800 cp_parser_omp_master (cp_parser
*parser
, cp_token
*pragma_tok
)
30802 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30803 return c_finish_omp_master (input_location
,
30804 cp_parser_omp_structured_block (parser
));
30808 # pragma omp ordered new-line
30809 structured-block */
30812 cp_parser_omp_ordered (cp_parser
*parser
, cp_token
*pragma_tok
)
30814 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30815 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30816 return c_finish_omp_ordered (loc
, cp_parser_omp_structured_block (parser
));
30822 { section-sequence }
30825 section-directive[opt] structured-block
30826 section-sequence section-directive structured-block */
30829 cp_parser_omp_sections_scope (cp_parser
*parser
)
30831 tree stmt
, substmt
;
30832 bool error_suppress
= false;
30835 if (!cp_parser_require (parser
, CPP_OPEN_BRACE
, RT_OPEN_BRACE
))
30838 stmt
= push_stmt_list ();
30840 if (cp_lexer_peek_token (parser
->lexer
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
30842 substmt
= cp_parser_omp_structured_block (parser
);
30843 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
30844 add_stmt (substmt
);
30849 tok
= cp_lexer_peek_token (parser
->lexer
);
30850 if (tok
->type
== CPP_CLOSE_BRACE
)
30852 if (tok
->type
== CPP_EOF
)
30855 if (tok
->pragma_kind
== PRAGMA_OMP_SECTION
)
30857 cp_lexer_consume_token (parser
->lexer
);
30858 cp_parser_require_pragma_eol (parser
, tok
);
30859 error_suppress
= false;
30861 else if (!error_suppress
)
30863 cp_parser_error (parser
, "expected %<#pragma omp section%> or %<}%>");
30864 error_suppress
= true;
30867 substmt
= cp_parser_omp_structured_block (parser
);
30868 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
30869 add_stmt (substmt
);
30871 cp_parser_require (parser
, CPP_CLOSE_BRACE
, RT_CLOSE_BRACE
);
30873 substmt
= pop_stmt_list (stmt
);
30875 stmt
= make_node (OMP_SECTIONS
);
30876 TREE_TYPE (stmt
) = void_type_node
;
30877 OMP_SECTIONS_BODY (stmt
) = substmt
;
30884 # pragma omp sections sections-clause[optseq] newline
30887 #define OMP_SECTIONS_CLAUSE_MASK \
30888 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30889 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30890 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30891 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30892 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
30895 cp_parser_omp_sections (cp_parser
*parser
, cp_token
*pragma_tok
,
30896 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30899 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30901 strcat (p_name
, " sections");
30902 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
30904 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
30906 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
30910 cp_omp_split_clauses (loc
, OMP_SECTIONS
, mask
, clauses
, cclauses
);
30911 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SECTIONS
];
30914 ret
= cp_parser_omp_sections_scope (parser
);
30916 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
30922 # pragma omp parallel parallel-clause[optseq] new-line
30924 # pragma omp parallel for parallel-for-clause[optseq] new-line
30926 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
30930 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
30931 structured-block */
30933 #define OMP_PARALLEL_CLAUSE_MASK \
30934 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
30935 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30936 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30937 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
30938 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
30939 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
30940 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30941 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
30942 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
30945 cp_parser_omp_parallel (cp_parser
*parser
, cp_token
*pragma_tok
,
30946 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
30948 tree stmt
, clauses
, block
;
30950 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
30952 strcat (p_name
, " parallel");
30953 mask
|= OMP_PARALLEL_CLAUSE_MASK
;
30955 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_FOR
))
30957 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
30958 if (cclauses
== NULL
)
30959 cclauses
= cclauses_buf
;
30961 cp_lexer_consume_token (parser
->lexer
);
30962 if (!flag_openmp
) /* flag_openmp_simd */
30963 return cp_parser_omp_for (parser
, pragma_tok
, p_name
, mask
, cclauses
);
30964 block
= begin_omp_parallel ();
30965 save
= cp_parser_begin_omp_structured_block (parser
);
30966 tree ret
= cp_parser_omp_for (parser
, pragma_tok
, p_name
, mask
, cclauses
);
30967 cp_parser_end_omp_structured_block (parser
, save
);
30968 stmt
= finish_omp_parallel (cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
30970 if (ret
== NULL_TREE
)
30972 OMP_PARALLEL_COMBINED (stmt
) = 1;
30977 error_at (loc
, "expected %<for%> after %qs", p_name
);
30978 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
30981 else if (!flag_openmp
) /* flag_openmp_simd */
30983 cp_parser_require_pragma_eol (parser
, pragma_tok
);
30986 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
30988 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
30989 const char *p
= IDENTIFIER_POINTER (id
);
30990 if (strcmp (p
, "sections") == 0)
30992 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
30993 cclauses
= cclauses_buf
;
30995 cp_lexer_consume_token (parser
->lexer
);
30996 block
= begin_omp_parallel ();
30997 save
= cp_parser_begin_omp_structured_block (parser
);
30998 cp_parser_omp_sections (parser
, pragma_tok
, p_name
, mask
, cclauses
);
30999 cp_parser_end_omp_structured_block (parser
, save
);
31000 stmt
= finish_omp_parallel (cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
31002 OMP_PARALLEL_COMBINED (stmt
) = 1;
31007 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
);
31009 block
= begin_omp_parallel ();
31010 save
= cp_parser_begin_omp_structured_block (parser
);
31011 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31012 cp_parser_end_omp_structured_block (parser
, save
);
31013 stmt
= finish_omp_parallel (clauses
, block
);
31018 # pragma omp single single-clause[optseq] new-line
31019 structured-block */
31021 #define OMP_SINGLE_CLAUSE_MASK \
31022 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31023 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31024 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
31025 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
31028 cp_parser_omp_single (cp_parser
*parser
, cp_token
*pragma_tok
)
31030 tree stmt
= make_node (OMP_SINGLE
);
31031 TREE_TYPE (stmt
) = void_type_node
;
31033 OMP_SINGLE_CLAUSES (stmt
)
31034 = cp_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
31035 "#pragma omp single", pragma_tok
);
31036 OMP_SINGLE_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31038 return add_stmt (stmt
);
31042 # pragma omp task task-clause[optseq] new-line
31043 structured-block */
31045 #define OMP_TASK_CLAUSE_MASK \
31046 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
31047 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
31048 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
31049 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31050 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31051 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
31052 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
31053 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
31054 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND))
31057 cp_parser_omp_task (cp_parser
*parser
, cp_token
*pragma_tok
)
31059 tree clauses
, block
;
31062 clauses
= cp_parser_omp_all_clauses (parser
, OMP_TASK_CLAUSE_MASK
,
31063 "#pragma omp task", pragma_tok
);
31064 block
= begin_omp_task ();
31065 save
= cp_parser_begin_omp_structured_block (parser
);
31066 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31067 cp_parser_end_omp_structured_block (parser
, save
);
31068 return finish_omp_task (clauses
, block
);
31072 # pragma omp taskwait new-line */
31075 cp_parser_omp_taskwait (cp_parser
*parser
, cp_token
*pragma_tok
)
31077 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31078 finish_omp_taskwait ();
31082 # pragma omp taskyield new-line */
31085 cp_parser_omp_taskyield (cp_parser
*parser
, cp_token
*pragma_tok
)
31087 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31088 finish_omp_taskyield ();
31092 # pragma omp taskgroup new-line
31093 structured-block */
31096 cp_parser_omp_taskgroup (cp_parser
*parser
, cp_token
*pragma_tok
)
31098 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31099 return c_finish_omp_taskgroup (input_location
,
31100 cp_parser_omp_structured_block (parser
));
31105 # pragma omp threadprivate (variable-list) */
31108 cp_parser_omp_threadprivate (cp_parser
*parser
, cp_token
*pragma_tok
)
31112 vars
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_ERROR
, NULL
);
31113 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31115 finish_omp_threadprivate (vars
);
31119 # pragma omp cancel cancel-clause[optseq] new-line */
31121 #define OMP_CANCEL_CLAUSE_MASK \
31122 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
31123 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
31124 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
31125 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
31126 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31129 cp_parser_omp_cancel (cp_parser
*parser
, cp_token
*pragma_tok
)
31131 tree clauses
= cp_parser_omp_all_clauses (parser
, OMP_CANCEL_CLAUSE_MASK
,
31132 "#pragma omp cancel", pragma_tok
);
31133 finish_omp_cancel (clauses
);
31137 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
31139 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
31140 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
31141 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
31142 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
31143 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
31146 cp_parser_omp_cancellation_point (cp_parser
*parser
, cp_token
*pragma_tok
)
31149 bool point_seen
= false;
31151 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31153 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31154 const char *p
= IDENTIFIER_POINTER (id
);
31156 if (strcmp (p
, "point") == 0)
31158 cp_lexer_consume_token (parser
->lexer
);
31164 cp_parser_error (parser
, "expected %<point%>");
31165 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31169 clauses
= cp_parser_omp_all_clauses (parser
,
31170 OMP_CANCELLATION_POINT_CLAUSE_MASK
,
31171 "#pragma omp cancellation point",
31173 finish_omp_cancellation_point (clauses
);
31177 #pragma omp distribute distribute-clause[optseq] new-line
31180 #define OMP_DISTRIBUTE_CLAUSE_MASK \
31181 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31182 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31183 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
31184 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
31187 cp_parser_omp_distribute (cp_parser
*parser
, cp_token
*pragma_tok
,
31188 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
31190 tree clauses
, sb
, ret
;
31192 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
31194 strcat (p_name
, " distribute");
31195 mask
|= OMP_DISTRIBUTE_CLAUSE_MASK
;
31197 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31199 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31200 const char *p
= IDENTIFIER_POINTER (id
);
31202 bool parallel
= false;
31204 if (strcmp (p
, "simd") == 0)
31207 parallel
= strcmp (p
, "parallel") == 0;
31208 if (parallel
|| simd
)
31210 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
31211 if (cclauses
== NULL
)
31212 cclauses
= cclauses_buf
;
31213 cp_lexer_consume_token (parser
->lexer
);
31214 if (!flag_openmp
) /* flag_openmp_simd */
31217 return cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
31220 return cp_parser_omp_parallel (parser
, pragma_tok
, p_name
, mask
,
31223 sb
= begin_omp_structured_block ();
31224 save
= cp_parser_begin_omp_structured_block (parser
);
31226 ret
= cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
,
31229 ret
= cp_parser_omp_parallel (parser
, pragma_tok
, p_name
, mask
,
31231 cp_parser_end_omp_structured_block (parser
, save
);
31232 tree body
= finish_omp_structured_block (sb
);
31235 ret
= make_node (OMP_DISTRIBUTE
);
31236 TREE_TYPE (ret
) = void_type_node
;
31237 OMP_FOR_BODY (ret
) = body
;
31238 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
31239 SET_EXPR_LOCATION (ret
, loc
);
31244 if (!flag_openmp
) /* flag_openmp_simd */
31246 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31250 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
31254 cp_omp_split_clauses (loc
, OMP_DISTRIBUTE
, mask
, clauses
, cclauses
);
31255 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
31258 sb
= begin_omp_structured_block ();
31259 save
= cp_parser_begin_omp_structured_block (parser
);
31261 ret
= cp_parser_omp_for_loop (parser
, OMP_DISTRIBUTE
, clauses
, NULL
);
31263 cp_parser_end_omp_structured_block (parser
, save
);
31264 add_stmt (finish_omp_structured_block (sb
));
31270 # pragma omp teams teams-clause[optseq] new-line
31271 structured-block */
31273 #define OMP_TEAMS_CLAUSE_MASK \
31274 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31275 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31276 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
31277 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
31278 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
31279 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
31280 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
31283 cp_parser_omp_teams (cp_parser
*parser
, cp_token
*pragma_tok
,
31284 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
31286 tree clauses
, sb
, ret
;
31288 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
31290 strcat (p_name
, " teams");
31291 mask
|= OMP_TEAMS_CLAUSE_MASK
;
31293 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31295 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31296 const char *p
= IDENTIFIER_POINTER (id
);
31297 if (strcmp (p
, "distribute") == 0)
31299 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
31300 if (cclauses
== NULL
)
31301 cclauses
= cclauses_buf
;
31303 cp_lexer_consume_token (parser
->lexer
);
31304 if (!flag_openmp
) /* flag_openmp_simd */
31305 return cp_parser_omp_distribute (parser
, pragma_tok
, p_name
, mask
,
31307 sb
= begin_omp_structured_block ();
31308 save
= cp_parser_begin_omp_structured_block (parser
);
31309 ret
= cp_parser_omp_distribute (parser
, pragma_tok
, p_name
, mask
,
31311 cp_parser_end_omp_structured_block (parser
, save
);
31312 tree body
= finish_omp_structured_block (sb
);
31315 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
31316 ret
= make_node (OMP_TEAMS
);
31317 TREE_TYPE (ret
) = void_type_node
;
31318 OMP_TEAMS_CLAUSES (ret
) = clauses
;
31319 OMP_TEAMS_BODY (ret
) = body
;
31320 return add_stmt (ret
);
31323 if (!flag_openmp
) /* flag_openmp_simd */
31325 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31329 clauses
= cp_parser_omp_all_clauses (parser
, mask
, p_name
, pragma_tok
,
31333 cp_omp_split_clauses (loc
, OMP_TEAMS
, mask
, clauses
, cclauses
);
31334 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
31337 tree stmt
= make_node (OMP_TEAMS
);
31338 TREE_TYPE (stmt
) = void_type_node
;
31339 OMP_TEAMS_CLAUSES (stmt
) = clauses
;
31340 OMP_TEAMS_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31342 return add_stmt (stmt
);
31346 # pragma omp target data target-data-clause[optseq] new-line
31347 structured-block */
31349 #define OMP_TARGET_DATA_CLAUSE_MASK \
31350 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
31352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31355 cp_parser_omp_target_data (cp_parser
*parser
, cp_token
*pragma_tok
)
31357 tree stmt
= make_node (OMP_TARGET_DATA
);
31358 TREE_TYPE (stmt
) = void_type_node
;
31360 OMP_TARGET_DATA_CLAUSES (stmt
)
31361 = cp_parser_omp_all_clauses (parser
, OMP_TARGET_DATA_CLAUSE_MASK
,
31362 "#pragma omp target data", pragma_tok
);
31363 keep_next_level (true);
31364 OMP_TARGET_DATA_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31366 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31367 return add_stmt (stmt
);
31371 # pragma omp target update target-update-clause[optseq] new-line */
31373 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
31374 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
31375 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
31376 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31377 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31380 cp_parser_omp_target_update (cp_parser
*parser
, cp_token
*pragma_tok
,
31381 enum pragma_context context
)
31383 if (context
== pragma_stmt
)
31385 error_at (pragma_tok
->location
,
31386 "%<#pragma omp target update%> may only be "
31387 "used in compound statements");
31388 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31393 = cp_parser_omp_all_clauses (parser
, OMP_TARGET_UPDATE_CLAUSE_MASK
,
31394 "#pragma omp target update", pragma_tok
);
31395 if (find_omp_clause (clauses
, OMP_CLAUSE_TO
) == NULL_TREE
31396 && find_omp_clause (clauses
, OMP_CLAUSE_FROM
) == NULL_TREE
)
31398 error_at (pragma_tok
->location
,
31399 "%<#pragma omp target update must contain at least one "
31400 "%<from%> or %<to%> clauses");
31404 tree stmt
= make_node (OMP_TARGET_UPDATE
);
31405 TREE_TYPE (stmt
) = void_type_node
;
31406 OMP_TARGET_UPDATE_CLAUSES (stmt
) = clauses
;
31407 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31413 # pragma omp target target-clause[optseq] new-line
31414 structured-block */
31416 #define OMP_TARGET_CLAUSE_MASK \
31417 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31418 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
31419 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31422 cp_parser_omp_target (cp_parser
*parser
, cp_token
*pragma_tok
,
31423 enum pragma_context context
)
31425 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
31427 cp_parser_error (parser
, "expected declaration specifiers");
31428 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31432 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31434 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31435 const char *p
= IDENTIFIER_POINTER (id
);
31437 if (strcmp (p
, "teams") == 0)
31439 tree cclauses
[C_OMP_CLAUSE_SPLIT_COUNT
];
31440 char p_name
[sizeof ("#pragma omp target teams distribute "
31441 "parallel for simd")];
31443 cp_lexer_consume_token (parser
->lexer
);
31444 strcpy (p_name
, "#pragma omp target");
31445 if (!flag_openmp
) /* flag_openmp_simd */
31447 tree stmt
= cp_parser_omp_teams (parser
, pragma_tok
, p_name
,
31448 OMP_TARGET_CLAUSE_MASK
,
31450 return stmt
!= NULL_TREE
;
31452 keep_next_level (true);
31453 tree sb
= begin_omp_structured_block ();
31454 unsigned save
= cp_parser_begin_omp_structured_block (parser
);
31455 tree ret
= cp_parser_omp_teams (parser
, pragma_tok
, p_name
,
31456 OMP_TARGET_CLAUSE_MASK
, cclauses
);
31457 cp_parser_end_omp_structured_block (parser
, save
);
31458 tree body
= finish_omp_structured_block (sb
);
31459 if (ret
== NULL_TREE
)
31461 tree stmt
= make_node (OMP_TARGET
);
31462 TREE_TYPE (stmt
) = void_type_node
;
31463 OMP_TARGET_CLAUSES (stmt
) = cclauses
[C_OMP_CLAUSE_SPLIT_TARGET
];
31464 OMP_TARGET_BODY (stmt
) = body
;
31468 else if (!flag_openmp
) /* flag_openmp_simd */
31470 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31473 else if (strcmp (p
, "data") == 0)
31475 cp_lexer_consume_token (parser
->lexer
);
31476 cp_parser_omp_target_data (parser
, pragma_tok
);
31479 else if (strcmp (p
, "update") == 0)
31481 cp_lexer_consume_token (parser
->lexer
);
31482 return cp_parser_omp_target_update (parser
, pragma_tok
, context
);
31486 tree stmt
= make_node (OMP_TARGET
);
31487 TREE_TYPE (stmt
) = void_type_node
;
31489 OMP_TARGET_CLAUSES (stmt
)
31490 = cp_parser_omp_all_clauses (parser
, OMP_TARGET_CLAUSE_MASK
,
31491 "#pragma omp target", pragma_tok
);
31492 keep_next_level (true);
31493 OMP_TARGET_BODY (stmt
) = cp_parser_omp_structured_block (parser
);
31495 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31501 # pragma acc cache (variable-list) new-line
31505 cp_parser_oacc_cache (cp_parser
*parser
, cp_token
*pragma_tok
)
31507 tree stmt
, clauses
;
31509 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE__CACHE_
, NULL_TREE
);
31510 clauses
= finish_omp_clauses (clauses
);
31512 cp_parser_require_pragma_eol (parser
, cp_lexer_peek_token (parser
->lexer
));
31514 stmt
= make_node (OACC_CACHE
);
31515 TREE_TYPE (stmt
) = void_type_node
;
31516 OACC_CACHE_CLAUSES (stmt
) = clauses
;
31517 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31524 # pragma acc data oacc-data-clause[optseq] new-line
31525 structured-block */
31527 #define OACC_DATA_CLAUSE_MASK \
31528 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31529 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31530 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31531 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31532 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31533 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31534 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31535 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31536 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31537 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31538 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE))
31541 cp_parser_oacc_data (cp_parser
*parser
, cp_token
*pragma_tok
)
31543 tree stmt
, clauses
, block
;
31546 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_DATA_CLAUSE_MASK
,
31547 "#pragma acc data", pragma_tok
);
31549 block
= begin_omp_parallel ();
31550 save
= cp_parser_begin_omp_structured_block (parser
);
31551 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31552 cp_parser_end_omp_structured_block (parser
, save
);
31553 stmt
= finish_oacc_data (clauses
, block
);
31558 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
31562 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
31564 LOC is the location of the #pragma token.
31567 #define OACC_ENTER_DATA_CLAUSE_MASK \
31568 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31569 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31570 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31571 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31572 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31573 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31574 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
31576 #define OACC_EXIT_DATA_CLAUSE_MASK \
31577 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31578 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31579 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31580 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
31581 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
31584 cp_parser_oacc_enter_exit_data (cp_parser
*parser
, cp_token
*pragma_tok
,
31587 tree stmt
, clauses
;
31589 if (cp_lexer_next_token_is (parser
->lexer
, CPP_PRAGMA_EOL
)
31590 || cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
31592 cp_parser_error (parser
, enter
31593 ? "expected %<data%> in %<#pragma acc enter data%>"
31594 : "expected %<data%> in %<#pragma acc exit data%>");
31595 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31600 IDENTIFIER_POINTER (cp_lexer_peek_token (parser
->lexer
)->u
.value
);
31601 if (strcmp (p
, "data") != 0)
31603 cp_parser_error (parser
, "invalid pragma");
31604 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31608 cp_lexer_consume_token (parser
->lexer
);
31611 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_ENTER_DATA_CLAUSE_MASK
,
31612 "#pragma acc enter data", pragma_tok
);
31614 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_EXIT_DATA_CLAUSE_MASK
,
31615 "#pragma acc exit data", pragma_tok
);
31617 if (find_omp_clause (clauses
, OMP_CLAUSE_MAP
) == NULL_TREE
)
31619 error_at (pragma_tok
->location
,
31620 "%<#pragma acc enter data%> has no data movement clause");
31624 stmt
= enter
? make_node (OACC_ENTER_DATA
) : make_node (OACC_EXIT_DATA
);
31625 TREE_TYPE (stmt
) = void_type_node
;
31627 OACC_ENTER_DATA_CLAUSES (stmt
) = clauses
;
31629 OACC_EXIT_DATA_CLAUSES (stmt
) = clauses
;
31630 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31636 # pragma acc kernels oacc-kernels-clause[optseq] new-line
31637 structured-block */
31639 #define OACC_KERNELS_CLAUSE_MASK \
31640 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31641 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31642 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31643 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31644 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31645 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31646 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31647 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31648 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31649 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31650 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31651 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31652 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31655 cp_parser_oacc_kernels (cp_parser
*parser
, cp_token
*pragma_tok
)
31657 tree stmt
, clauses
, block
;
31660 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_KERNELS_CLAUSE_MASK
,
31661 "#pragma acc kernels", pragma_tok
);
31663 block
= begin_omp_parallel ();
31664 save
= cp_parser_begin_omp_structured_block (parser
);
31665 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31666 cp_parser_end_omp_structured_block (parser
, save
);
31667 stmt
= finish_oacc_kernels (clauses
, block
);
31672 # pragma acc loop oacc-loop-clause[optseq] new-line
31673 structured-block */
31675 #define OACC_LOOP_CLAUSE_MASK \
31676 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
31677 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION))
31680 cp_parser_oacc_loop (cp_parser
*parser
, cp_token
*pragma_tok
)
31682 tree stmt
, clauses
, block
;
31685 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_LOOP_CLAUSE_MASK
,
31686 "#pragma acc loop", pragma_tok
);
31688 block
= begin_omp_structured_block ();
31689 save
= cp_parser_begin_omp_structured_block (parser
);
31690 stmt
= cp_parser_omp_for_loop (parser
, OACC_LOOP
, clauses
, NULL
);
31691 cp_parser_end_omp_structured_block (parser
, save
);
31692 add_stmt (finish_omp_structured_block (block
));
31697 # pragma acc parallel oacc-parallel-clause[optseq] new-line
31698 structured-block */
31700 #define OACC_PARALLEL_CLAUSE_MASK \
31701 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31702 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31703 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31704 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31705 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31706 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31707 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31708 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
31709 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
31710 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31711 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31712 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31713 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31714 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31715 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
31716 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
31717 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31720 cp_parser_oacc_parallel (cp_parser
*parser
, cp_token
*pragma_tok
)
31722 tree stmt
, clauses
, block
;
31725 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_PARALLEL_CLAUSE_MASK
,
31726 "#pragma acc parallel", pragma_tok
);
31728 block
= begin_omp_parallel ();
31729 save
= cp_parser_begin_omp_structured_block (parser
);
31730 cp_parser_statement (parser
, NULL_TREE
, false, NULL
);
31731 cp_parser_end_omp_structured_block (parser
, save
);
31732 stmt
= finish_oacc_parallel (clauses
, block
);
31737 # pragma acc update oacc-update-clause[optseq] new-line
31740 #define OACC_UPDATE_CLAUSE_MASK \
31741 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
31743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
31744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31745 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
31746 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31749 cp_parser_oacc_update (cp_parser
*parser
, cp_token
*pragma_tok
)
31751 tree stmt
, clauses
;
31753 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_UPDATE_CLAUSE_MASK
,
31754 "#pragma acc update", pragma_tok
);
31756 if (find_omp_clause (clauses
, OMP_CLAUSE_MAP
) == NULL_TREE
)
31758 error_at (pragma_tok
->location
,
31759 "%<#pragma acc update%> must contain at least one "
31760 "%<device%> or %<host/self%> clause");
31764 stmt
= make_node (OACC_UPDATE
);
31765 TREE_TYPE (stmt
) = void_type_node
;
31766 OACC_UPDATE_CLAUSES (stmt
) = clauses
;
31767 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
31773 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
31775 LOC is the location of the #pragma token.
31778 #define OACC_WAIT_CLAUSE_MASK \
31779 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
31782 cp_parser_oacc_wait (cp_parser
*parser
, cp_token
*pragma_tok
)
31784 tree clauses
, list
= NULL_TREE
, stmt
= NULL_TREE
;
31785 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
31787 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
31788 list
= cp_parser_oacc_wait_list (parser
, loc
, list
);
31790 clauses
= cp_parser_oacc_all_clauses (parser
, OACC_WAIT_CLAUSE_MASK
,
31791 "#pragma acc wait", pragma_tok
);
31793 stmt
= c_finish_oacc_wait (loc
, list
, clauses
);
31799 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
31801 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
31802 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
31803 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
31804 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
31805 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
31806 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
31807 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
31810 cp_parser_omp_declare_simd (cp_parser
*parser
, cp_token
*pragma_tok
,
31811 enum pragma_context context
)
31813 bool first_p
= parser
->omp_declare_simd
== NULL
;
31814 cp_omp_declare_simd_data data
;
31817 data
.error_seen
= false;
31818 data
.fndecl_seen
= false;
31819 data
.tokens
= vNULL
;
31820 parser
->omp_declare_simd
= &data
;
31822 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
)
31823 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_EOF
))
31824 cp_lexer_consume_token (parser
->lexer
);
31825 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
31826 parser
->omp_declare_simd
->error_seen
= true;
31827 cp_parser_require_pragma_eol (parser
, pragma_tok
);
31828 struct cp_token_cache
*cp
31829 = cp_token_cache_new (pragma_tok
, cp_lexer_peek_token (parser
->lexer
));
31830 parser
->omp_declare_simd
->tokens
.safe_push (cp
);
31833 while (cp_lexer_next_token_is (parser
->lexer
, CPP_PRAGMA
))
31834 cp_parser_pragma (parser
, context
);
31837 case pragma_external
:
31838 cp_parser_declaration (parser
);
31840 case pragma_member
:
31841 cp_parser_member_declaration (parser
);
31843 case pragma_objc_icode
:
31844 cp_parser_block_declaration (parser
, /*statement_p=*/false);
31847 cp_parser_declaration_statement (parser
);
31850 if (parser
->omp_declare_simd
31851 && !parser
->omp_declare_simd
->error_seen
31852 && !parser
->omp_declare_simd
->fndecl_seen
)
31853 error_at (pragma_tok
->location
,
31854 "%<#pragma omp declare simd%> not immediately followed by "
31855 "function declaration or definition");
31856 data
.tokens
.release ();
31857 parser
->omp_declare_simd
= NULL
;
31861 /* Handles the delayed parsing of the Cilk Plus SIMD-enabled function.
31862 This function is modelled similar to the late parsing of omp declare
31866 cp_parser_late_parsing_cilk_simd_fn_info (cp_parser
*parser
, tree attrs
)
31868 struct cp_token_cache
*ce
;
31869 cp_omp_declare_simd_data
*info
= parser
->cilk_simd_fn_info
;
31872 if (parser
->omp_declare_simd
!= NULL
)
31874 error ("%<#pragma omp declare simd%> cannot be used in the same function"
31875 " marked as a Cilk Plus SIMD-enabled function");
31876 XDELETE (parser
->cilk_simd_fn_info
);
31877 parser
->cilk_simd_fn_info
= NULL
;
31880 if (!info
->error_seen
&& info
->fndecl_seen
)
31882 error ("vector attribute not immediately followed by a single function"
31883 " declaration or definition");
31884 info
->error_seen
= true;
31886 if (info
->error_seen
)
31889 FOR_EACH_VEC_ELT (info
->tokens
, ii
, ce
)
31893 cp_parser_push_lexer_for_tokens (parser
, ce
);
31894 parser
->lexer
->in_pragma
= true;
31895 cl
= cp_parser_omp_all_clauses (parser
, CILK_SIMD_FN_CLAUSE_MASK
,
31896 "SIMD-enabled functions attribute",
31898 cp_parser_pop_lexer (parser
);
31900 cl
= tree_cons (NULL_TREE
, cl
, NULL_TREE
);
31902 c
= build_tree_list (get_identifier ("cilk simd function"), NULL_TREE
);
31903 TREE_CHAIN (c
) = attrs
;
31906 c
= build_tree_list (get_identifier ("omp declare simd"), cl
);
31907 TREE_CHAIN (c
) = attrs
;
31908 if (processing_template_decl
)
31909 ATTR_IS_DEPENDENT (c
) = 1;
31912 info
->fndecl_seen
= true;
31913 XDELETE (parser
->cilk_simd_fn_info
);
31914 parser
->cilk_simd_fn_info
= NULL
;
31918 /* Finalize #pragma omp declare simd clauses after direct declarator has
31919 been parsed, and put that into "omp declare simd" attribute. */
31922 cp_parser_late_parsing_omp_declare_simd (cp_parser
*parser
, tree attrs
)
31924 struct cp_token_cache
*ce
;
31925 cp_omp_declare_simd_data
*data
= parser
->omp_declare_simd
;
31928 if (!data
->error_seen
&& data
->fndecl_seen
)
31930 error ("%<#pragma omp declare simd%> not immediately followed by "
31931 "a single function declaration or definition");
31932 data
->error_seen
= true;
31935 if (data
->error_seen
)
31938 FOR_EACH_VEC_ELT (data
->tokens
, i
, ce
)
31942 cp_parser_push_lexer_for_tokens (parser
, ce
);
31943 parser
->lexer
->in_pragma
= true;
31944 gcc_assert (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_PRAGMA
);
31945 cp_token
*pragma_tok
= cp_lexer_consume_token (parser
->lexer
);
31946 cp_lexer_consume_token (parser
->lexer
);
31947 cl
= cp_parser_omp_all_clauses (parser
, OMP_DECLARE_SIMD_CLAUSE_MASK
,
31948 "#pragma omp declare simd", pragma_tok
);
31949 cp_parser_pop_lexer (parser
);
31951 cl
= tree_cons (NULL_TREE
, cl
, NULL_TREE
);
31952 c
= build_tree_list (get_identifier ("omp declare simd"), cl
);
31953 TREE_CHAIN (c
) = attrs
;
31954 if (processing_template_decl
)
31955 ATTR_IS_DEPENDENT (c
) = 1;
31959 data
->fndecl_seen
= true;
31965 # pragma omp declare target new-line
31966 declarations and definitions
31967 # pragma omp end declare target new-line */
31970 cp_parser_omp_declare_target (cp_parser
*parser
, cp_token
*pragma_tok
)
31972 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
31973 scope_chain
->omp_declare_target_attribute
++;
31977 cp_parser_omp_end_declare_target (cp_parser
*parser
, cp_token
*pragma_tok
)
31979 const char *p
= "";
31980 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31982 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31983 p
= IDENTIFIER_POINTER (id
);
31985 if (strcmp (p
, "declare") == 0)
31987 cp_lexer_consume_token (parser
->lexer
);
31989 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
31991 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
31992 p
= IDENTIFIER_POINTER (id
);
31994 if (strcmp (p
, "target") == 0)
31995 cp_lexer_consume_token (parser
->lexer
);
31998 cp_parser_error (parser
, "expected %<target%>");
31999 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32005 cp_parser_error (parser
, "expected %<declare%>");
32006 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32009 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32010 if (!scope_chain
->omp_declare_target_attribute
)
32011 error_at (pragma_tok
->location
,
32012 "%<#pragma omp end declare target%> without corresponding "
32013 "%<#pragma omp declare target%>");
32015 scope_chain
->omp_declare_target_attribute
--;
32018 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
32019 expression and optional initializer clause of
32020 #pragma omp declare reduction. We store the expression(s) as
32021 either 3, 6 or 7 special statements inside of the artificial function's
32022 body. The first two statements are DECL_EXPRs for the artificial
32023 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
32024 expression that uses those variables.
32025 If there was any INITIALIZER clause, this is followed by further statements,
32026 the fourth and fifth statements are DECL_EXPRs for the artificial
32027 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
32028 constructor variant (first token after open paren is not omp_priv),
32029 then the sixth statement is a statement with the function call expression
32030 that uses the OMP_PRIV and optionally OMP_ORIG variable.
32031 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
32032 to initialize the OMP_PRIV artificial variable and there is seventh
32033 statement, a DECL_EXPR of the OMP_PRIV statement again. */
32036 cp_parser_omp_declare_reduction_exprs (tree fndecl
, cp_parser
*parser
)
32038 tree type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
32039 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
32040 type
= TREE_TYPE (type
);
32041 tree omp_out
= build_lang_decl (VAR_DECL
, get_identifier ("omp_out"), type
);
32042 DECL_ARTIFICIAL (omp_out
) = 1;
32043 pushdecl (omp_out
);
32044 add_decl_expr (omp_out
);
32045 tree omp_in
= build_lang_decl (VAR_DECL
, get_identifier ("omp_in"), type
);
32046 DECL_ARTIFICIAL (omp_in
) = 1;
32048 add_decl_expr (omp_in
);
32050 tree omp_priv
= NULL_TREE
, omp_orig
= NULL_TREE
, initializer
= NULL_TREE
;
32052 keep_next_level (true);
32053 tree block
= begin_omp_structured_block ();
32054 combiner
= cp_parser_expression (parser
);
32055 finish_expr_stmt (combiner
);
32056 block
= finish_omp_structured_block (block
);
32059 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
32062 const char *p
= "";
32063 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
32065 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
32066 p
= IDENTIFIER_POINTER (id
);
32069 if (strcmp (p
, "initializer") == 0)
32071 cp_lexer_consume_token (parser
->lexer
);
32072 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
32076 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
32078 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
32079 p
= IDENTIFIER_POINTER (id
);
32082 omp_priv
= build_lang_decl (VAR_DECL
, get_identifier ("omp_priv"), type
);
32083 DECL_ARTIFICIAL (omp_priv
) = 1;
32084 pushdecl (omp_priv
);
32085 add_decl_expr (omp_priv
);
32086 omp_orig
= build_lang_decl (VAR_DECL
, get_identifier ("omp_orig"), type
);
32087 DECL_ARTIFICIAL (omp_orig
) = 1;
32088 pushdecl (omp_orig
);
32089 add_decl_expr (omp_orig
);
32091 keep_next_level (true);
32092 block
= begin_omp_structured_block ();
32095 if (strcmp (p
, "omp_priv") == 0)
32097 bool is_direct_init
, is_non_constant_init
;
32099 cp_lexer_consume_token (parser
->lexer
);
32100 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
32101 if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
)
32102 || (cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
32103 && cp_lexer_peek_nth_token (parser
->lexer
, 2)->type
32105 && cp_lexer_peek_nth_token (parser
->lexer
, 3)->type
32106 == CPP_CLOSE_PAREN
))
32108 finish_omp_structured_block (block
);
32109 error ("invalid initializer clause");
32112 initializer
= cp_parser_initializer (parser
, &is_direct_init
,
32113 &is_non_constant_init
);
32114 cp_finish_decl (omp_priv
, initializer
, !is_non_constant_init
,
32115 NULL_TREE
, LOOKUP_ONLYCONVERTING
);
32119 cp_parser_parse_tentatively (parser
);
32120 tree fn_name
= cp_parser_id_expression (parser
, /*template_p=*/false,
32121 /*check_dependency_p=*/true,
32122 /*template_p=*/NULL
,
32123 /*declarator_p=*/false,
32124 /*optional_p=*/false);
32125 vec
<tree
, va_gc
> *args
;
32126 if (fn_name
== error_mark_node
32127 || cp_parser_error_occurred (parser
)
32128 || !cp_lexer_next_token_is (parser
->lexer
, CPP_OPEN_PAREN
)
32129 || ((args
= cp_parser_parenthesized_expression_list
32130 (parser
, non_attr
, /*cast_p=*/false,
32131 /*allow_expansion_p=*/true,
32132 /*non_constant_p=*/NULL
)),
32133 cp_parser_error_occurred (parser
)))
32135 finish_omp_structured_block (block
);
32136 cp_parser_abort_tentative_parse (parser
);
32137 cp_parser_error (parser
, "expected id-expression (arguments)");
32142 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
32143 if (arg
== omp_priv
32144 || (TREE_CODE (arg
) == ADDR_EXPR
32145 && TREE_OPERAND (arg
, 0) == omp_priv
))
32147 cp_parser_abort_tentative_parse (parser
);
32148 if (arg
== NULL_TREE
)
32149 error ("one of the initializer call arguments should be %<omp_priv%>"
32150 " or %<&omp_priv%>");
32151 initializer
= cp_parser_postfix_expression (parser
, false, false, false,
32153 finish_expr_stmt (initializer
);
32156 block
= finish_omp_structured_block (block
);
32157 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
32161 add_decl_expr (omp_orig
);
32163 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
32167 if (!cp_lexer_next_token_is (parser
->lexer
, CPP_PRAGMA_EOL
))
32168 cp_parser_required_error (parser
, RT_PRAGMA_EOL
, /*keyword=*/false);
32174 #pragma omp declare reduction (reduction-id : typename-list : expression) \
32175 initializer-clause[opt] new-line
32177 initializer-clause:
32178 initializer (omp_priv initializer)
32179 initializer (function-name (argument-list)) */
32182 cp_parser_omp_declare_reduction (cp_parser
*parser
, cp_token
*pragma_tok
,
32183 enum pragma_context
)
32185 auto_vec
<tree
> types
;
32186 enum tree_code reduc_code
= ERROR_MARK
;
32187 tree reduc_id
= NULL_TREE
, orig_reduc_id
= NULL_TREE
, type
;
32189 cp_token
*first_token
;
32190 cp_token_cache
*cp
;
32194 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
32195 p
= obstack_alloc (&declarator_obstack
, 0);
32197 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
32200 switch (cp_lexer_peek_token (parser
->lexer
)->type
)
32203 reduc_code
= PLUS_EXPR
;
32206 reduc_code
= MULT_EXPR
;
32209 reduc_code
= MINUS_EXPR
;
32212 reduc_code
= BIT_AND_EXPR
;
32215 reduc_code
= BIT_XOR_EXPR
;
32218 reduc_code
= BIT_IOR_EXPR
;
32221 reduc_code
= TRUTH_ANDIF_EXPR
;
32224 reduc_code
= TRUTH_ORIF_EXPR
;
32227 reduc_id
= orig_reduc_id
= cp_parser_identifier (parser
);
32230 cp_parser_error (parser
, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
32231 "%<|%>, %<&&%>, %<||%> or identifier");
32235 if (reduc_code
!= ERROR_MARK
)
32236 cp_lexer_consume_token (parser
->lexer
);
32238 reduc_id
= omp_reduction_id (reduc_code
, reduc_id
, NULL_TREE
);
32239 if (reduc_id
== error_mark_node
)
32242 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
))
32245 /* Types may not be defined in declare reduction type list. */
32246 const char *saved_message
;
32247 saved_message
= parser
->type_definition_forbidden_message
;
32248 parser
->type_definition_forbidden_message
32249 = G_("types may not be defined in declare reduction type list");
32250 bool saved_colon_corrects_to_scope_p
;
32251 saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
32252 parser
->colon_corrects_to_scope_p
= false;
32253 bool saved_colon_doesnt_start_class_def_p
;
32254 saved_colon_doesnt_start_class_def_p
32255 = parser
->colon_doesnt_start_class_def_p
;
32256 parser
->colon_doesnt_start_class_def_p
= true;
32260 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
32261 type
= cp_parser_type_id (parser
);
32262 if (type
== error_mark_node
)
32264 else if (ARITHMETIC_TYPE_P (type
)
32265 && (orig_reduc_id
== NULL_TREE
32266 || (TREE_CODE (type
) != COMPLEX_TYPE
32267 && (strcmp (IDENTIFIER_POINTER (orig_reduc_id
),
32269 || strcmp (IDENTIFIER_POINTER (orig_reduc_id
),
32271 error_at (loc
, "predeclared arithmetic type %qT in "
32272 "%<#pragma omp declare reduction%>", type
);
32273 else if (TREE_CODE (type
) == FUNCTION_TYPE
32274 || TREE_CODE (type
) == METHOD_TYPE
32275 || TREE_CODE (type
) == ARRAY_TYPE
)
32276 error_at (loc
, "function or array type %qT in "
32277 "%<#pragma omp declare reduction%>", type
);
32278 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
32279 error_at (loc
, "reference type %qT in "
32280 "%<#pragma omp declare reduction%>", type
);
32281 else if (TYPE_QUALS_NO_ADDR_SPACE (type
))
32282 error_at (loc
, "const, volatile or __restrict qualified type %qT in "
32283 "%<#pragma omp declare reduction%>", type
);
32285 types
.safe_push (type
);
32287 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
32288 cp_lexer_consume_token (parser
->lexer
);
32293 /* Restore the saved message. */
32294 parser
->type_definition_forbidden_message
= saved_message
;
32295 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
32296 parser
->colon_doesnt_start_class_def_p
32297 = saved_colon_doesnt_start_class_def_p
;
32299 if (!cp_parser_require (parser
, CPP_COLON
, RT_COLON
)
32300 || types
.is_empty ())
32303 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32307 first_token
= cp_lexer_peek_token (parser
->lexer
);
32310 FOR_EACH_VEC_ELT (types
, i
, type
)
32313 = build_function_type_list (void_type_node
,
32314 cp_build_reference_type (type
, false),
32316 tree this_reduc_id
= reduc_id
;
32317 if (!dependent_type_p (type
))
32318 this_reduc_id
= omp_reduction_id (ERROR_MARK
, reduc_id
, type
);
32319 tree fndecl
= build_lang_decl (FUNCTION_DECL
, this_reduc_id
, fntype
);
32320 DECL_SOURCE_LOCATION (fndecl
) = pragma_tok
->location
;
32321 DECL_ARTIFICIAL (fndecl
) = 1;
32322 DECL_EXTERNAL (fndecl
) = 1;
32323 DECL_DECLARED_INLINE_P (fndecl
) = 1;
32324 DECL_IGNORED_P (fndecl
) = 1;
32325 DECL_OMP_DECLARE_REDUCTION_P (fndecl
) = 1;
32326 DECL_ATTRIBUTES (fndecl
)
32327 = tree_cons (get_identifier ("gnu_inline"), NULL_TREE
,
32328 DECL_ATTRIBUTES (fndecl
));
32329 if (processing_template_decl
)
32330 fndecl
= push_template_decl (fndecl
);
32331 bool block_scope
= false;
32332 tree block
= NULL_TREE
;
32333 if (current_function_decl
)
32335 block_scope
= true;
32336 DECL_CONTEXT (fndecl
) = global_namespace
;
32337 if (!processing_template_decl
)
32340 else if (current_class_type
)
32344 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
)
32345 && cp_lexer_next_token_is_not (parser
->lexer
, CPP_EOF
))
32346 cp_lexer_consume_token (parser
->lexer
);
32347 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
))
32349 cp
= cp_token_cache_new (first_token
,
32350 cp_lexer_peek_nth_token (parser
->lexer
,
32353 DECL_STATIC_FUNCTION_P (fndecl
) = 1;
32354 finish_member_declaration (fndecl
);
32355 DECL_PENDING_INLINE_INFO (fndecl
) = cp
;
32356 DECL_PENDING_INLINE_P (fndecl
) = 1;
32357 vec_safe_push (unparsed_funs_with_definitions
, fndecl
);
32362 DECL_CONTEXT (fndecl
) = current_namespace
;
32366 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
32368 block
= begin_omp_structured_block ();
32371 cp_parser_push_lexer_for_tokens (parser
, cp
);
32372 parser
->lexer
->in_pragma
= true;
32374 if (!cp_parser_omp_declare_reduction_exprs (fndecl
, parser
))
32377 finish_function (0);
32379 DECL_CONTEXT (fndecl
) = current_function_decl
;
32381 cp_parser_pop_lexer (parser
);
32385 cp_parser_pop_lexer (parser
);
32387 finish_function (0);
32390 DECL_CONTEXT (fndecl
) = current_function_decl
;
32391 block
= finish_omp_structured_block (block
);
32392 if (TREE_CODE (block
) == BIND_EXPR
)
32393 DECL_SAVED_TREE (fndecl
) = BIND_EXPR_BODY (block
);
32394 else if (TREE_CODE (block
) == STATEMENT_LIST
)
32395 DECL_SAVED_TREE (fndecl
) = block
;
32396 if (processing_template_decl
)
32397 add_decl_expr (fndecl
);
32399 cp_check_omp_declare_reduction (fndecl
);
32400 if (cp
== NULL
&& types
.length () > 1)
32401 cp
= cp_token_cache_new (first_token
,
32402 cp_lexer_peek_nth_token (parser
->lexer
, 2));
32403 if (errs
!= errorcount
)
32407 cp_parser_require_pragma_eol (parser
, pragma_tok
);
32410 /* Free any declarators allocated. */
32411 obstack_free (&declarator_obstack
, p
);
32415 #pragma omp declare simd declare-simd-clauses[optseq] new-line
32416 #pragma omp declare reduction (reduction-id : typename-list : expression) \
32417 initializer-clause[opt] new-line
32418 #pragma omp declare target new-line */
32421 cp_parser_omp_declare (cp_parser
*parser
, cp_token
*pragma_tok
,
32422 enum pragma_context context
)
32424 if (cp_lexer_next_token_is (parser
->lexer
, CPP_NAME
))
32426 tree id
= cp_lexer_peek_token (parser
->lexer
)->u
.value
;
32427 const char *p
= IDENTIFIER_POINTER (id
);
32429 if (strcmp (p
, "simd") == 0)
32431 cp_lexer_consume_token (parser
->lexer
);
32432 cp_parser_omp_declare_simd (parser
, pragma_tok
,
32436 cp_ensure_no_omp_declare_simd (parser
);
32437 if (strcmp (p
, "reduction") == 0)
32439 cp_lexer_consume_token (parser
->lexer
);
32440 cp_parser_omp_declare_reduction (parser
, pragma_tok
,
32444 if (!flag_openmp
) /* flag_openmp_simd */
32446 cp_parser_require_pragma_eol (parser
, pragma_tok
);
32449 if (strcmp (p
, "target") == 0)
32451 cp_lexer_consume_token (parser
->lexer
);
32452 cp_parser_omp_declare_target (parser
, pragma_tok
);
32456 cp_parser_error (parser
, "expected %<simd%> or %<reduction%> "
32458 cp_parser_require_pragma_eol (parser
, pragma_tok
);
32461 /* Main entry point to OpenMP statement pragmas. */
32464 cp_parser_omp_construct (cp_parser
*parser
, cp_token
*pragma_tok
)
32467 char p_name
[sizeof "#pragma omp teams distribute parallel for simd"];
32468 omp_clause_mask
mask (0);
32470 switch (pragma_tok
->pragma_kind
)
32472 case PRAGMA_OACC_CACHE
:
32473 stmt
= cp_parser_oacc_cache (parser
, pragma_tok
);
32475 case PRAGMA_OACC_DATA
:
32476 stmt
= cp_parser_oacc_data (parser
, pragma_tok
);
32478 case PRAGMA_OACC_ENTER_DATA
:
32479 stmt
= cp_parser_oacc_enter_exit_data (parser
, pragma_tok
, true);
32481 case PRAGMA_OACC_EXIT_DATA
:
32482 stmt
= cp_parser_oacc_enter_exit_data (parser
, pragma_tok
, false);
32484 case PRAGMA_OACC_KERNELS
:
32485 stmt
= cp_parser_oacc_kernels (parser
, pragma_tok
);
32487 case PRAGMA_OACC_LOOP
:
32488 stmt
= cp_parser_oacc_loop (parser
, pragma_tok
);
32490 case PRAGMA_OACC_PARALLEL
:
32491 stmt
= cp_parser_oacc_parallel (parser
, pragma_tok
);
32493 case PRAGMA_OACC_UPDATE
:
32494 stmt
= cp_parser_oacc_update (parser
, pragma_tok
);
32496 case PRAGMA_OACC_WAIT
:
32497 stmt
= cp_parser_oacc_wait (parser
, pragma_tok
);
32499 case PRAGMA_OMP_ATOMIC
:
32500 cp_parser_omp_atomic (parser
, pragma_tok
);
32502 case PRAGMA_OMP_CRITICAL
:
32503 stmt
= cp_parser_omp_critical (parser
, pragma_tok
);
32505 case PRAGMA_OMP_DISTRIBUTE
:
32506 strcpy (p_name
, "#pragma omp");
32507 stmt
= cp_parser_omp_distribute (parser
, pragma_tok
, p_name
, mask
, NULL
);
32509 case PRAGMA_OMP_FOR
:
32510 strcpy (p_name
, "#pragma omp");
32511 stmt
= cp_parser_omp_for (parser
, pragma_tok
, p_name
, mask
, NULL
);
32513 case PRAGMA_OMP_MASTER
:
32514 stmt
= cp_parser_omp_master (parser
, pragma_tok
);
32516 case PRAGMA_OMP_ORDERED
:
32517 stmt
= cp_parser_omp_ordered (parser
, pragma_tok
);
32519 case PRAGMA_OMP_PARALLEL
:
32520 strcpy (p_name
, "#pragma omp");
32521 stmt
= cp_parser_omp_parallel (parser
, pragma_tok
, p_name
, mask
, NULL
);
32523 case PRAGMA_OMP_SECTIONS
:
32524 strcpy (p_name
, "#pragma omp");
32525 stmt
= cp_parser_omp_sections (parser
, pragma_tok
, p_name
, mask
, NULL
);
32527 case PRAGMA_OMP_SIMD
:
32528 strcpy (p_name
, "#pragma omp");
32529 stmt
= cp_parser_omp_simd (parser
, pragma_tok
, p_name
, mask
, NULL
);
32531 case PRAGMA_OMP_SINGLE
:
32532 stmt
= cp_parser_omp_single (parser
, pragma_tok
);
32534 case PRAGMA_OMP_TASK
:
32535 stmt
= cp_parser_omp_task (parser
, pragma_tok
);
32537 case PRAGMA_OMP_TASKGROUP
:
32538 stmt
= cp_parser_omp_taskgroup (parser
, pragma_tok
);
32540 case PRAGMA_OMP_TEAMS
:
32541 strcpy (p_name
, "#pragma omp");
32542 stmt
= cp_parser_omp_teams (parser
, pragma_tok
, p_name
, mask
, NULL
);
32545 gcc_unreachable ();
32549 SET_EXPR_LOCATION (stmt
, pragma_tok
->location
);
32552 /* Transactional Memory parsing routines. */
32554 /* Parse a transaction attribute.
32560 ??? Simplify this when C++0x bracket attributes are
32561 implemented properly. */
32564 cp_parser_txn_attribute_opt (cp_parser
*parser
)
32567 tree attr_name
, attr
= NULL
;
32569 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_ATTRIBUTE
))
32570 return cp_parser_attributes_opt (parser
);
32572 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_OPEN_SQUARE
))
32574 cp_lexer_consume_token (parser
->lexer
);
32575 if (!cp_parser_require (parser
, CPP_OPEN_SQUARE
, RT_OPEN_SQUARE
))
32578 token
= cp_lexer_peek_token (parser
->lexer
);
32579 if (token
->type
== CPP_NAME
|| token
->type
== CPP_KEYWORD
)
32581 token
= cp_lexer_consume_token (parser
->lexer
);
32583 attr_name
= (token
->type
== CPP_KEYWORD
32584 /* For keywords, use the canonical spelling,
32585 not the parsed identifier. */
32586 ? ridpointers
[(int) token
->keyword
]
32588 attr
= build_tree_list (attr_name
, NULL_TREE
);
32591 cp_parser_error (parser
, "expected identifier");
32593 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
32595 cp_parser_require (parser
, CPP_CLOSE_SQUARE
, RT_CLOSE_SQUARE
);
32599 /* Parse a __transaction_atomic or __transaction_relaxed statement.
32601 transaction-statement:
32602 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
32604 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
32608 cp_parser_transaction (cp_parser
*parser
, enum rid keyword
)
32610 unsigned char old_in
= parser
->in_transaction
;
32611 unsigned char this_in
= 1, new_in
;
32613 tree stmt
, attrs
, noex
;
32615 gcc_assert (keyword
== RID_TRANSACTION_ATOMIC
32616 || keyword
== RID_TRANSACTION_RELAXED
);
32617 token
= cp_parser_require_keyword (parser
, keyword
,
32618 (keyword
== RID_TRANSACTION_ATOMIC
? RT_TRANSACTION_ATOMIC
32619 : RT_TRANSACTION_RELAXED
));
32620 gcc_assert (token
!= NULL
);
32622 if (keyword
== RID_TRANSACTION_RELAXED
)
32623 this_in
|= TM_STMT_ATTR_RELAXED
;
32626 attrs
= cp_parser_txn_attribute_opt (parser
);
32628 this_in
|= parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
);
32631 /* Parse a noexcept specification. */
32632 noex
= cp_parser_noexcept_specification_opt (parser
, true, NULL
, true);
32634 /* Keep track if we're in the lexical scope of an outer transaction. */
32635 new_in
= this_in
| (old_in
& TM_STMT_ATTR_OUTER
);
32637 stmt
= begin_transaction_stmt (token
->location
, NULL
, this_in
);
32639 parser
->in_transaction
= new_in
;
32640 cp_parser_compound_statement (parser
, NULL
, false, false);
32641 parser
->in_transaction
= old_in
;
32643 finish_transaction_stmt (stmt
, NULL
, this_in
, noex
);
32648 /* Parse a __transaction_atomic or __transaction_relaxed expression.
32650 transaction-expression:
32651 __transaction_atomic txn-noexcept-spec[opt] ( expression )
32652 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
32656 cp_parser_transaction_expression (cp_parser
*parser
, enum rid keyword
)
32658 unsigned char old_in
= parser
->in_transaction
;
32659 unsigned char this_in
= 1;
32664 gcc_assert (keyword
== RID_TRANSACTION_ATOMIC
32665 || keyword
== RID_TRANSACTION_RELAXED
);
32668 error (keyword
== RID_TRANSACTION_RELAXED
32669 ? G_("%<__transaction_relaxed%> without transactional memory "
32671 : G_("%<__transaction_atomic%> without transactional memory "
32672 "support enabled"));
32674 token
= cp_parser_require_keyword (parser
, keyword
,
32675 (keyword
== RID_TRANSACTION_ATOMIC
? RT_TRANSACTION_ATOMIC
32676 : RT_TRANSACTION_RELAXED
));
32677 gcc_assert (token
!= NULL
);
32679 if (keyword
== RID_TRANSACTION_RELAXED
)
32680 this_in
|= TM_STMT_ATTR_RELAXED
;
32682 /* Set this early. This might mean that we allow transaction_cancel in
32683 an expression that we find out later actually has to be a constexpr.
32684 However, we expect that cxx_constant_value will be able to deal with
32685 this; also, if the noexcept has no constexpr, then what we parse next
32686 really is a transaction's body. */
32687 parser
->in_transaction
= this_in
;
32689 /* Parse a noexcept specification. */
32690 noex
= cp_parser_noexcept_specification_opt (parser
, false, &noex_expr
,
32693 if (!noex
|| !noex_expr
32694 || cp_lexer_peek_token (parser
->lexer
)->type
== CPP_OPEN_PAREN
)
32696 cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
);
32698 expr
= cp_parser_expression (parser
);
32699 expr
= finish_parenthesized_expr (expr
);
32701 cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
);
32705 /* The only expression that is available got parsed for the noexcept
32706 already. noexcept is true then. */
32708 noex
= boolean_true_node
;
32711 expr
= build_transaction_expr (token
->location
, expr
, this_in
, noex
);
32712 parser
->in_transaction
= old_in
;
32714 if (cp_parser_non_integral_constant_expression (parser
, NIC_TRANSACTION
))
32715 return error_mark_node
;
32717 return (flag_tm
? expr
: error_mark_node
);
32720 /* Parse a function-transaction-block.
32722 function-transaction-block:
32723 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
32725 __transaction_atomic txn-attribute[opt] function-try-block
32726 __transaction_relaxed ctor-initializer[opt] function-body
32727 __transaction_relaxed function-try-block
32731 cp_parser_function_transaction (cp_parser
*parser
, enum rid keyword
)
32733 unsigned char old_in
= parser
->in_transaction
;
32734 unsigned char new_in
= 1;
32735 tree compound_stmt
, stmt
, attrs
;
32736 bool ctor_initializer_p
;
32739 gcc_assert (keyword
== RID_TRANSACTION_ATOMIC
32740 || keyword
== RID_TRANSACTION_RELAXED
);
32741 token
= cp_parser_require_keyword (parser
, keyword
,
32742 (keyword
== RID_TRANSACTION_ATOMIC
? RT_TRANSACTION_ATOMIC
32743 : RT_TRANSACTION_RELAXED
));
32744 gcc_assert (token
!= NULL
);
32746 if (keyword
== RID_TRANSACTION_RELAXED
)
32747 new_in
|= TM_STMT_ATTR_RELAXED
;
32750 attrs
= cp_parser_txn_attribute_opt (parser
);
32752 new_in
|= parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
);
32755 stmt
= begin_transaction_stmt (token
->location
, &compound_stmt
, new_in
);
32757 parser
->in_transaction
= new_in
;
32759 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_TRY
))
32760 ctor_initializer_p
= cp_parser_function_try_block (parser
);
32762 ctor_initializer_p
= cp_parser_ctor_initializer_opt_and_function_body
32763 (parser
, /*in_function_try_block=*/false);
32765 parser
->in_transaction
= old_in
;
32767 finish_transaction_stmt (stmt
, compound_stmt
, new_in
, NULL_TREE
);
32769 return ctor_initializer_p
;
32772 /* Parse a __transaction_cancel statement.
32775 __transaction_cancel txn-attribute[opt] ;
32776 __transaction_cancel txn-attribute[opt] throw-expression ;
32778 ??? Cancel and throw is not yet implemented. */
32781 cp_parser_transaction_cancel (cp_parser
*parser
)
32784 bool is_outer
= false;
32787 token
= cp_parser_require_keyword (parser
, RID_TRANSACTION_CANCEL
,
32788 RT_TRANSACTION_CANCEL
);
32789 gcc_assert (token
!= NULL
);
32791 attrs
= cp_parser_txn_attribute_opt (parser
);
32793 is_outer
= (parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
) != 0);
32795 /* ??? Parse cancel-and-throw here. */
32797 cp_parser_require (parser
, CPP_SEMICOLON
, RT_SEMICOLON
);
32801 error_at (token
->location
, "%<__transaction_cancel%> without "
32802 "transactional memory support enabled");
32803 return error_mark_node
;
32805 else if (parser
->in_transaction
& TM_STMT_ATTR_RELAXED
)
32807 error_at (token
->location
, "%<__transaction_cancel%> within a "
32808 "%<__transaction_relaxed%>");
32809 return error_mark_node
;
32813 if ((parser
->in_transaction
& TM_STMT_ATTR_OUTER
) == 0
32814 && !is_tm_may_cancel_outer (current_function_decl
))
32816 error_at (token
->location
, "outer %<__transaction_cancel%> not "
32817 "within outer %<__transaction_atomic%>");
32818 error_at (token
->location
,
32819 " or a %<transaction_may_cancel_outer%> function");
32820 return error_mark_node
;
32823 else if (parser
->in_transaction
== 0)
32825 error_at (token
->location
, "%<__transaction_cancel%> not within "
32826 "%<__transaction_atomic%>");
32827 return error_mark_node
;
32830 stmt
= build_tm_abort_call (token
->location
, is_outer
);
32838 static GTY (()) cp_parser
*the_parser
;
32841 /* Special handling for the first token or line in the file. The first
32842 thing in the file might be #pragma GCC pch_preprocess, which loads a
32843 PCH file, which is a GC collection point. So we need to handle this
32844 first pragma without benefit of an existing lexer structure.
32846 Always returns one token to the caller in *FIRST_TOKEN. This is
32847 either the true first token of the file, or the first token after
32848 the initial pragma. */
32851 cp_parser_initial_pragma (cp_token
*first_token
)
32855 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32856 if (first_token
->pragma_kind
!= PRAGMA_GCC_PCH_PREPROCESS
)
32859 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32860 if (first_token
->type
== CPP_STRING
)
32862 name
= first_token
->u
.value
;
32864 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32865 if (first_token
->type
!= CPP_PRAGMA_EOL
)
32866 error_at (first_token
->location
,
32867 "junk at end of %<#pragma GCC pch_preprocess%>");
32870 error_at (first_token
->location
, "expected string literal");
32872 /* Skip to the end of the pragma. */
32873 while (first_token
->type
!= CPP_PRAGMA_EOL
&& first_token
->type
!= CPP_EOF
)
32874 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32876 /* Now actually load the PCH file. */
32878 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
32880 /* Read one more token to return to our caller. We have to do this
32881 after reading the PCH file in, since its pointers have to be
32883 cp_lexer_get_preprocessor_token (NULL
, first_token
);
32886 /* Parses the grainsize pragma for the _Cilk_for statement.
32888 #pragma cilk grainsize = <VALUE>. */
32891 cp_parser_cilk_grainsize (cp_parser
*parser
, cp_token
*pragma_tok
)
32893 if (cp_parser_require (parser
, CPP_EQ
, RT_EQ
))
32895 tree exp
= cp_parser_binary_expression (parser
, false, false,
32896 PREC_NOT_OPERATOR
, NULL
);
32897 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32898 if (!exp
|| exp
== error_mark_node
)
32900 error_at (pragma_tok
->location
, "invalid grainsize for _Cilk_for");
32904 /* Make sure the next token is _Cilk_for, it is invalid otherwise. */
32905 if (cp_lexer_next_token_is_keyword (parser
->lexer
, RID_CILK_FOR
))
32906 cp_parser_cilk_for (parser
, exp
);
32908 warning_at (cp_lexer_peek_token (parser
->lexer
)->location
, 0,
32909 "%<#pragma cilk grainsize%> is not followed by "
32913 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
32916 /* Normal parsing of a pragma token. Here we can (and must) use the
32920 cp_parser_pragma (cp_parser
*parser
, enum pragma_context context
)
32922 cp_token
*pragma_tok
;
32925 pragma_tok
= cp_lexer_consume_token (parser
->lexer
);
32926 gcc_assert (pragma_tok
->type
== CPP_PRAGMA
);
32927 parser
->lexer
->in_pragma
= true;
32929 id
= pragma_tok
->pragma_kind
;
32930 if (id
!= PRAGMA_OMP_DECLARE_REDUCTION
)
32931 cp_ensure_no_omp_declare_simd (parser
);
32934 case PRAGMA_GCC_PCH_PREPROCESS
:
32935 error_at (pragma_tok
->location
,
32936 "%<#pragma GCC pch_preprocess%> must be first");
32939 case PRAGMA_OMP_BARRIER
:
32942 case pragma_compound
:
32943 cp_parser_omp_barrier (parser
, pragma_tok
);
32946 error_at (pragma_tok
->location
, "%<#pragma omp barrier%> may only be "
32947 "used in compound statements");
32954 case PRAGMA_OMP_FLUSH
:
32957 case pragma_compound
:
32958 cp_parser_omp_flush (parser
, pragma_tok
);
32961 error_at (pragma_tok
->location
, "%<#pragma omp flush%> may only be "
32962 "used in compound statements");
32969 case PRAGMA_OMP_TASKWAIT
:
32972 case pragma_compound
:
32973 cp_parser_omp_taskwait (parser
, pragma_tok
);
32976 error_at (pragma_tok
->location
,
32977 "%<#pragma omp taskwait%> may only be "
32978 "used in compound statements");
32985 case PRAGMA_OMP_TASKYIELD
:
32988 case pragma_compound
:
32989 cp_parser_omp_taskyield (parser
, pragma_tok
);
32992 error_at (pragma_tok
->location
,
32993 "%<#pragma omp taskyield%> may only be "
32994 "used in compound statements");
33001 case PRAGMA_OMP_CANCEL
:
33004 case pragma_compound
:
33005 cp_parser_omp_cancel (parser
, pragma_tok
);
33008 error_at (pragma_tok
->location
,
33009 "%<#pragma omp cancel%> may only be "
33010 "used in compound statements");
33017 case PRAGMA_OMP_CANCELLATION_POINT
:
33020 case pragma_compound
:
33021 cp_parser_omp_cancellation_point (parser
, pragma_tok
);
33024 error_at (pragma_tok
->location
,
33025 "%<#pragma omp cancellation point%> may only be "
33026 "used in compound statements");
33033 case PRAGMA_OMP_THREADPRIVATE
:
33034 cp_parser_omp_threadprivate (parser
, pragma_tok
);
33037 case PRAGMA_OMP_DECLARE_REDUCTION
:
33038 cp_parser_omp_declare (parser
, pragma_tok
, context
);
33041 case PRAGMA_OACC_CACHE
:
33042 case PRAGMA_OACC_DATA
:
33043 case PRAGMA_OACC_ENTER_DATA
:
33044 case PRAGMA_OACC_EXIT_DATA
:
33045 case PRAGMA_OACC_KERNELS
:
33046 case PRAGMA_OACC_PARALLEL
:
33047 case PRAGMA_OACC_LOOP
:
33048 case PRAGMA_OACC_UPDATE
:
33049 case PRAGMA_OACC_WAIT
:
33050 case PRAGMA_OMP_ATOMIC
:
33051 case PRAGMA_OMP_CRITICAL
:
33052 case PRAGMA_OMP_DISTRIBUTE
:
33053 case PRAGMA_OMP_FOR
:
33054 case PRAGMA_OMP_MASTER
:
33055 case PRAGMA_OMP_ORDERED
:
33056 case PRAGMA_OMP_PARALLEL
:
33057 case PRAGMA_OMP_SECTIONS
:
33058 case PRAGMA_OMP_SIMD
:
33059 case PRAGMA_OMP_SINGLE
:
33060 case PRAGMA_OMP_TASK
:
33061 case PRAGMA_OMP_TASKGROUP
:
33062 case PRAGMA_OMP_TEAMS
:
33063 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
33065 cp_parser_omp_construct (parser
, pragma_tok
);
33068 case PRAGMA_OMP_TARGET
:
33069 return cp_parser_omp_target (parser
, pragma_tok
, context
);
33071 case PRAGMA_OMP_END_DECLARE_TARGET
:
33072 cp_parser_omp_end_declare_target (parser
, pragma_tok
);
33075 case PRAGMA_OMP_SECTION
:
33076 error_at (pragma_tok
->location
,
33077 "%<#pragma omp section%> may only be used in "
33078 "%<#pragma omp sections%> construct");
33083 if (context
== pragma_external
)
33085 error_at (pragma_tok
->location
,
33086 "%<#pragma GCC ivdep%> must be inside a function");
33089 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
33091 tok
= cp_lexer_peek_token (the_parser
->lexer
);
33092 if (tok
->type
!= CPP_KEYWORD
33093 || (tok
->keyword
!= RID_FOR
&& tok
->keyword
!= RID_WHILE
33094 && tok
->keyword
!= RID_DO
))
33096 cp_parser_error (parser
, "for, while or do statement expected");
33099 cp_parser_iteration_statement (parser
, true);
33103 case PRAGMA_CILK_SIMD
:
33104 if (context
== pragma_external
)
33106 error_at (pragma_tok
->location
,
33107 "%<#pragma simd%> must be inside a function");
33110 cp_parser_cilk_simd (parser
, pragma_tok
);
33113 case PRAGMA_CILK_GRAINSIZE
:
33114 if (context
== pragma_external
)
33116 error_at (pragma_tok
->location
,
33117 "%<#pragma cilk grainsize%> must be inside a function");
33121 /* Ignore the pragma if Cilk Plus is not enabled. */
33124 cp_parser_cilk_grainsize (parser
, pragma_tok
);
33129 error_at (pragma_tok
->location
, "-fcilkplus must be enabled to use "
33130 "%<#pragma cilk grainsize%>");
33135 gcc_assert (id
>= PRAGMA_FIRST_EXTERNAL
);
33136 c_invoke_pragma_handler (id
);
33140 cp_parser_error (parser
, "expected declaration specifiers");
33144 cp_parser_skip_to_pragma_eol (parser
, pragma_tok
);
33148 /* The interface the pragma parsers have to the lexer. */
33151 pragma_lex (tree
*value
)
33154 enum cpp_ttype ret
;
33156 tok
= cp_lexer_peek_token (the_parser
->lexer
);
33159 *value
= tok
->u
.value
;
33161 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
33163 else if (ret
== CPP_STRING
)
33164 *value
= cp_parser_string_literal (the_parser
, false, false);
33167 cp_lexer_consume_token (the_parser
->lexer
);
33168 if (ret
== CPP_KEYWORD
)
33176 /* External interface. */
33178 /* Parse one entire translation unit. */
33181 c_parse_file (void)
33183 static bool already_called
= false;
33185 if (already_called
)
33186 fatal_error (input_location
,
33187 "inter-module optimizations not implemented for C++");
33188 already_called
= true;
33190 the_parser
= cp_parser_new ();
33191 push_deferring_access_checks (flag_access_control
33192 ? dk_no_deferred
: dk_no_check
);
33193 cp_parser_translation_unit (the_parser
);
33197 /* Parses the Cilk Plus #pragma simd and SIMD-enabled function attribute's
33198 vectorlength clause:
33200 vectorlength ( constant-expression ) */
33203 cp_parser_cilk_simd_vectorlength (cp_parser
*parser
, tree clauses
,
33206 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
33208 /* The vectorlength clause in #pragma simd behaves exactly like OpenMP's
33209 safelen clause. Thus, vectorlength is represented as OMP 4.0
33210 safelen. For SIMD-enabled function it is represented by OMP 4.0
33213 check_no_duplicate_clause (clauses
, OMP_CLAUSE_SAFELEN
, "vectorlength",
33216 check_no_duplicate_clause (clauses
, OMP_CLAUSE_SIMDLEN
, "vectorlength",
33219 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
33220 return error_mark_node
;
33222 expr
= cp_parser_constant_expression (parser
);
33223 expr
= maybe_constant_value (expr
);
33225 /* If expr == error_mark_node, then don't emit any errors nor
33226 create a clause. if any of the above functions returns
33227 error mark node then they would have emitted an error message. */
33228 if (expr
== error_mark_node
)
33230 else if (!TREE_TYPE (expr
)
33231 || !TREE_CONSTANT (expr
)
33232 || !INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
33233 error_at (loc
, "vectorlength must be an integer constant");
33234 else if (TREE_CONSTANT (expr
)
33235 && exact_log2 (TREE_INT_CST_LOW (expr
)) == -1)
33236 error_at (loc
, "vectorlength must be a power of 2");
33242 c
= build_omp_clause (loc
, OMP_CLAUSE_SAFELEN
);
33243 OMP_CLAUSE_SAFELEN_EXPR (c
) = expr
;
33244 OMP_CLAUSE_CHAIN (c
) = clauses
;
33249 c
= build_omp_clause (loc
, OMP_CLAUSE_SIMDLEN
);
33250 OMP_CLAUSE_SIMDLEN_EXPR (c
) = expr
;
33251 OMP_CLAUSE_CHAIN (c
) = clauses
;
33256 if (!cp_parser_require (parser
, CPP_CLOSE_PAREN
, RT_CLOSE_PAREN
))
33257 return error_mark_node
;
33261 /* Handles the Cilk Plus #pragma simd linear clause.
33263 linear ( simd-linear-variable-list )
33265 simd-linear-variable-list:
33266 simd-linear-variable
33267 simd-linear-variable-list , simd-linear-variable
33269 simd-linear-variable:
33271 id-expression : simd-linear-step
33274 conditional-expression */
33277 cp_parser_cilk_simd_linear (cp_parser
*parser
, tree clauses
)
33279 location_t loc
= cp_lexer_peek_token (parser
->lexer
)->location
;
33281 if (!cp_parser_require (parser
, CPP_OPEN_PAREN
, RT_OPEN_PAREN
))
33283 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
33285 cp_parser_error (parser
, "expected identifier");
33286 cp_parser_skip_to_closing_parenthesis (parser
, false, false, true);
33287 return error_mark_node
;
33290 bool saved_colon_corrects_to_scope_p
= parser
->colon_corrects_to_scope_p
;
33291 parser
->colon_corrects_to_scope_p
= false;
33294 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
33295 if (cp_lexer_next_token_is_not (parser
->lexer
, CPP_NAME
))
33297 cp_parser_error (parser
, "expected variable-name");
33298 clauses
= error_mark_node
;
33302 tree var_name
= cp_parser_id_expression (parser
, false, true, NULL
,
33304 tree decl
= cp_parser_lookup_name_simple (parser
, var_name
,
33306 if (decl
== error_mark_node
)
33308 cp_parser_name_lookup_error (parser
, var_name
, decl
, NLE_NULL
,
33310 clauses
= error_mark_node
;
33314 tree e
= NULL_TREE
;
33315 tree step_size
= integer_one_node
;
33317 /* If present, parse the linear step. Otherwise, assume the default
33319 if (cp_lexer_peek_token (parser
->lexer
)->type
== CPP_COLON
)
33321 cp_lexer_consume_token (parser
->lexer
);
33323 e
= cp_parser_assignment_expression (parser
);
33324 e
= maybe_constant_value (e
);
33326 if (e
== error_mark_node
)
33328 /* If an error has occurred, then the whole pragma is
33329 considered ill-formed. Thus, no reason to keep
33331 clauses
= error_mark_node
;
33334 else if (type_dependent_expression_p (e
)
33335 || value_dependent_expression_p (e
)
33337 && INTEGRAL_TYPE_P (TREE_TYPE (e
))
33338 && (TREE_CONSTANT (e
)
33342 cp_parser_error (parser
,
33343 "step size must be an integer constant "
33344 "expression or an integer variable");
33347 /* Use the OMP_CLAUSE_LINEAR, which has the same semantics. */
33348 tree l
= build_omp_clause (loc
, OMP_CLAUSE_LINEAR
);
33349 OMP_CLAUSE_DECL (l
) = decl
;
33350 OMP_CLAUSE_LINEAR_STEP (l
) = step_size
;
33351 OMP_CLAUSE_CHAIN (l
) = clauses
;
33354 if (cp_lexer_next_token_is (parser
->lexer
, CPP_COMMA
))
33355 cp_lexer_consume_token (parser
->lexer
);
33356 else if (cp_lexer_next_token_is (parser
->lexer
, CPP_CLOSE_PAREN
))
33360 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
33361 "expected %<,%> or %<)%> after %qE", decl
);
33362 clauses
= error_mark_node
;
33366 parser
->colon_corrects_to_scope_p
= saved_colon_corrects_to_scope_p
;
33367 cp_parser_skip_to_closing_parenthesis (parser
, false, false, true);
33371 /* Returns the name of the next clause. If the clause is not
33372 recognized, then PRAGMA_CILK_CLAUSE_NONE is returned and the next
33373 token is not consumed. Otherwise, the appropriate enum from the
33374 pragma_simd_clause is returned and the token is consumed. */
33376 static pragma_omp_clause
33377 cp_parser_cilk_simd_clause_name (cp_parser
*parser
)
33379 pragma_omp_clause clause_type
;
33380 cp_token
*token
= cp_lexer_peek_token (parser
->lexer
);
33382 if (token
->keyword
== RID_PRIVATE
)
33383 clause_type
= PRAGMA_CILK_CLAUSE_PRIVATE
;
33384 else if (!token
->u
.value
|| token
->type
!= CPP_NAME
)
33385 return PRAGMA_CILK_CLAUSE_NONE
;
33386 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "vectorlength"))
33387 clause_type
= PRAGMA_CILK_CLAUSE_VECTORLENGTH
;
33388 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "linear"))
33389 clause_type
= PRAGMA_CILK_CLAUSE_LINEAR
;
33390 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "firstprivate"))
33391 clause_type
= PRAGMA_CILK_CLAUSE_FIRSTPRIVATE
;
33392 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "lastprivate"))
33393 clause_type
= PRAGMA_CILK_CLAUSE_LASTPRIVATE
;
33394 else if (!strcmp (IDENTIFIER_POINTER (token
->u
.value
), "reduction"))
33395 clause_type
= PRAGMA_CILK_CLAUSE_REDUCTION
;
33397 return PRAGMA_CILK_CLAUSE_NONE
;
33399 cp_lexer_consume_token (parser
->lexer
);
33400 return clause_type
;
33403 /* Parses all the #pragma simd clauses. Returns a list of clauses found. */
33406 cp_parser_cilk_simd_all_clauses (cp_parser
*parser
, cp_token
*pragma_token
)
33408 tree clauses
= NULL_TREE
;
33410 while (cp_lexer_next_token_is_not (parser
->lexer
, CPP_PRAGMA_EOL
)
33411 && clauses
!= error_mark_node
)
33413 pragma_omp_clause c_kind
;
33414 c_kind
= cp_parser_cilk_simd_clause_name (parser
);
33415 if (c_kind
== PRAGMA_CILK_CLAUSE_VECTORLENGTH
)
33416 clauses
= cp_parser_cilk_simd_vectorlength (parser
, clauses
, false);
33417 else if (c_kind
== PRAGMA_CILK_CLAUSE_LINEAR
)
33418 clauses
= cp_parser_cilk_simd_linear (parser
, clauses
);
33419 else if (c_kind
== PRAGMA_CILK_CLAUSE_PRIVATE
)
33420 /* Use the OpenMP 4.0 equivalent function. */
33421 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_PRIVATE
, clauses
);
33422 else if (c_kind
== PRAGMA_CILK_CLAUSE_FIRSTPRIVATE
)
33423 /* Use the OpenMP 4.0 equivalent function. */
33424 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_FIRSTPRIVATE
,
33426 else if (c_kind
== PRAGMA_CILK_CLAUSE_LASTPRIVATE
)
33427 /* Use the OMP 4.0 equivalent function. */
33428 clauses
= cp_parser_omp_var_list (parser
, OMP_CLAUSE_LASTPRIVATE
,
33430 else if (c_kind
== PRAGMA_CILK_CLAUSE_REDUCTION
)
33431 /* Use the OMP 4.0 equivalent function. */
33432 clauses
= cp_parser_omp_clause_reduction (parser
, clauses
);
33435 clauses
= error_mark_node
;
33436 cp_parser_error (parser
, "expected %<#pragma simd%> clause");
33441 cp_parser_skip_to_pragma_eol (parser
, pragma_token
);
33443 if (clauses
== error_mark_node
)
33444 return error_mark_node
;
33446 return c_finish_cilk_clauses (clauses
);
33449 /* Main entry-point for parsing Cilk Plus <#pragma simd> for loops. */
33452 cp_parser_cilk_simd (cp_parser
*parser
, cp_token
*pragma_token
)
33454 tree clauses
= cp_parser_cilk_simd_all_clauses (parser
, pragma_token
);
33456 if (clauses
== error_mark_node
)
33459 if (cp_lexer_next_token_is_not_keyword (parser
->lexer
, RID_FOR
))
33461 error_at (cp_lexer_peek_token (parser
->lexer
)->location
,
33462 "for statement expected");
33466 tree sb
= begin_omp_structured_block ();
33467 int save
= cp_parser_begin_omp_structured_block (parser
);
33468 tree ret
= cp_parser_omp_for_loop (parser
, CILK_SIMD
, clauses
, NULL
);
33470 cpp_validate_cilk_plus_loop (OMP_FOR_BODY (ret
));
33471 cp_parser_end_omp_structured_block (parser
, save
);
33472 add_stmt (finish_omp_structured_block (sb
));
33475 /* Main entry-point for parsing Cilk Plus _Cilk_for
33476 loops. The return value is error_mark_node
33477 when errors happen and CILK_FOR tree on success. */
33480 cp_parser_cilk_for (cp_parser
*parser
, tree grain
)
33482 if (cp_lexer_next_token_is_not_keyword (parser
->lexer
, RID_CILK_FOR
))
33483 gcc_unreachable ();
33485 tree sb
= begin_omp_structured_block ();
33486 int save
= cp_parser_begin_omp_structured_block (parser
);
33488 tree clauses
= build_omp_clause (EXPR_LOCATION (grain
), OMP_CLAUSE_SCHEDULE
);
33489 OMP_CLAUSE_SCHEDULE_KIND (clauses
) = OMP_CLAUSE_SCHEDULE_CILKFOR
;
33490 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clauses
) = grain
;
33491 clauses
= finish_omp_clauses (clauses
);
33493 tree ret
= cp_parser_omp_for_loop (parser
, CILK_FOR
, clauses
, NULL
);
33495 cpp_validate_cilk_plus_loop (ret
);
33497 ret
= error_mark_node
;
33499 cp_parser_end_omp_structured_block (parser
, save
);
33500 add_stmt (finish_omp_structured_block (sb
));
33504 /* Create an identifier for a generic parameter type (a synthesized
33505 template parameter implied by `auto' or a concept identifier). */
33507 static GTY(()) int generic_parm_count
;
33509 make_generic_type_name ()
33512 sprintf (buf
, "auto:%d", ++generic_parm_count
);
33513 return get_identifier (buf
);
33516 /* Predicate that behaves as is_auto_or_concept but matches the parent
33517 node of the generic type rather than the generic type itself. This
33518 allows for type transformation in add_implicit_template_parms. */
33521 tree_type_is_auto_or_concept (const_tree t
)
33523 return TREE_TYPE (t
) && is_auto_or_concept (TREE_TYPE (t
));
33526 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
33527 (creating a new template parameter list if necessary). Returns the newly
33528 created template type parm. */
33531 synthesize_implicit_template_parm (cp_parser
*parser
)
33533 gcc_assert (current_binding_level
->kind
== sk_function_parms
);
33535 /* We are either continuing a function template that already contains implicit
33536 template parameters, creating a new fully-implicit function template, or
33537 extending an existing explicit function template with implicit template
33540 cp_binding_level
*const entry_scope
= current_binding_level
;
33542 bool become_template
= false;
33543 cp_binding_level
*parent_scope
= 0;
33545 if (parser
->implicit_template_scope
)
33547 gcc_assert (parser
->implicit_template_parms
);
33549 current_binding_level
= parser
->implicit_template_scope
;
33553 /* Roll back to the existing template parameter scope (in the case of
33554 extending an explicit function template) or introduce a new template
33555 parameter scope ahead of the function parameter scope (or class scope
33556 in the case of out-of-line member definitions). The function scope is
33557 added back after template parameter synthesis below. */
33559 cp_binding_level
*scope
= entry_scope
;
33561 while (scope
->kind
== sk_function_parms
)
33563 parent_scope
= scope
;
33564 scope
= scope
->level_chain
;
33566 if (current_class_type
&& !LAMBDA_TYPE_P (current_class_type
))
33568 /* If not defining a class, then any class scope is a scope level in
33569 an out-of-line member definition. In this case simply wind back
33570 beyond the first such scope to inject the template parameter list.
33571 Otherwise wind back to the class being defined. The latter can
33572 occur in class member friend declarations such as:
33578 friend void A::foo (auto);
33581 The template parameter list synthesized for the friend declaration
33582 must be injected in the scope of 'B'. This can also occur in
33583 erroneous cases such as:
33589 void B::foo (auto) {}
33592 Here the attempted definition of 'B::foo' within 'A' is ill-formed
33593 but, nevertheless, the template parameter list synthesized for the
33594 declarator should be injected into the scope of 'A' as if the
33595 ill-formed template was specified explicitly. */
33597 while (scope
->kind
== sk_class
&& !scope
->defining_class_p
)
33599 parent_scope
= scope
;
33600 scope
= scope
->level_chain
;
33604 current_binding_level
= scope
;
33606 if (scope
->kind
!= sk_template_parms
33607 || !function_being_declared_is_template_p (parser
))
33609 /* Introduce a new template parameter list for implicit template
33612 become_template
= true;
33614 parser
->implicit_template_scope
33615 = begin_scope (sk_template_parms
, NULL
);
33617 ++processing_template_decl
;
33619 parser
->fully_implicit_function_template_p
= true;
33620 ++parser
->num_template_parameter_lists
;
33624 /* Synthesize implicit template parameters at the end of the explicit
33625 template parameter list. */
33627 gcc_assert (current_template_parms
);
33629 parser
->implicit_template_scope
= scope
;
33631 tree v
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
33632 parser
->implicit_template_parms
33633 = TREE_VEC_ELT (v
, TREE_VEC_LENGTH (v
) - 1);
33637 /* Synthesize a new template parameter and track the current template
33638 parameter chain with implicit_template_parms. */
33640 tree synth_id
= make_generic_type_name ();
33641 tree synth_tmpl_parm
= finish_template_type_parm (class_type_node
,
33644 = process_template_parm (parser
->implicit_template_parms
,
33646 build_tree_list (NULL_TREE
, synth_tmpl_parm
),
33647 /*non_type=*/false,
33648 /*param_pack=*/false);
33651 if (parser
->implicit_template_parms
)
33652 parser
->implicit_template_parms
33653 = TREE_CHAIN (parser
->implicit_template_parms
);
33655 parser
->implicit_template_parms
= new_parm
;
33657 tree new_type
= TREE_TYPE (getdecls ());
33659 /* If creating a fully implicit function template, start the new implicit
33660 template parameter list with this synthesized type, otherwise grow the
33661 current template parameter list. */
33663 if (become_template
)
33665 parent_scope
->level_chain
= current_binding_level
;
33667 tree new_parms
= make_tree_vec (1);
33668 TREE_VEC_ELT (new_parms
, 0) = parser
->implicit_template_parms
;
33669 current_template_parms
= tree_cons (size_int (processing_template_decl
),
33670 new_parms
, current_template_parms
);
33674 tree
& new_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
33675 int new_parm_idx
= TREE_VEC_LENGTH (new_parms
);
33676 new_parms
= grow_tree_vec (new_parms
, new_parm_idx
+ 1);
33677 TREE_VEC_ELT (new_parms
, new_parm_idx
) = parser
->implicit_template_parms
;
33680 current_binding_level
= entry_scope
;
33685 /* Finish the declaration of a fully implicit function template. Such a
33686 template has no explicit template parameter list so has not been through the
33687 normal template head and tail processing. synthesize_implicit_template_parm
33688 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
33689 provided if the declaration is a class member such that its template
33690 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
33691 form is returned. Otherwise NULL_TREE is returned. */
33694 finish_fully_implicit_template (cp_parser
*parser
, tree member_decl_opt
)
33696 gcc_assert (parser
->fully_implicit_function_template_p
);
33698 if (member_decl_opt
&& member_decl_opt
!= error_mark_node
33699 && DECL_VIRTUAL_P (member_decl_opt
))
33701 error_at (DECL_SOURCE_LOCATION (member_decl_opt
),
33702 "implicit templates may not be %<virtual%>");
33703 DECL_VIRTUAL_P (member_decl_opt
) = false;
33706 if (member_decl_opt
)
33707 member_decl_opt
= finish_member_template_decl (member_decl_opt
);
33708 end_template_decl ();
33710 parser
->fully_implicit_function_template_p
= false;
33711 --parser
->num_template_parameter_lists
;
33713 return member_decl_opt
;
33716 #include "gt-cp-parser.h"