Branch data Line data Source code
1 : : /* -*- C++ -*- Parser.
2 : : Copyright (C) 2000-2024 Free Software Foundation, Inc.
3 : : Written by Mark Mitchell <mark@codesourcery.com>.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it
8 : : under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
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.
16 : :
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/>. */
20 : :
21 : : #include "config.h"
22 : : #define INCLUDE_MEMORY
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "cp-tree.h"
26 : : #include "c-family/c-common.h"
27 : : #include "timevar.h"
28 : : #include "stringpool.h"
29 : : #include "cgraph.h"
30 : : #include "print-tree.h"
31 : : #include "attribs.h"
32 : : #include "trans-mem.h"
33 : : #include "intl.h"
34 : : #include "decl.h"
35 : : #include "c-family/c-objc.h"
36 : : #include "plugin.h"
37 : : #include "tree-pretty-print.h"
38 : : #include "parser.h"
39 : : #include "gomp-constants.h"
40 : : #include "omp-general.h"
41 : : #include "omp-offload.h"
42 : : #include "c-family/c-indentation.h"
43 : : #include "context.h"
44 : : #include "gcc-rich-location.h"
45 : : #include "tree-iterator.h"
46 : : #include "cp-name-hint.h"
47 : : #include "memmodel.h"
48 : : #include "c-family/known-headers.h"
49 : : #include "contracts.h"
50 : : #include "bitmap.h"
51 : : #include "builtins.h"
52 : :
53 : :
54 : : /* The lexer. */
55 : :
56 : : /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
57 : : and c-lex.cc) and the C++ parser. */
58 : :
59 : : /* The various kinds of non integral constant we encounter. */
60 : : enum non_integral_constant {
61 : : NIC_NONE,
62 : : /* floating-point literal */
63 : : NIC_FLOAT,
64 : : /* %<this%> */
65 : : NIC_THIS,
66 : : /* %<__FUNCTION__%> */
67 : : NIC_FUNC_NAME,
68 : : /* %<__PRETTY_FUNCTION__%> */
69 : : NIC_PRETTY_FUNC,
70 : : /* %<__func__%> */
71 : : NIC_C99_FUNC,
72 : : /* "%<va_arg%> */
73 : : NIC_VA_ARG,
74 : : /* a cast */
75 : : NIC_CAST,
76 : : /* %<typeid%> operator */
77 : : NIC_TYPEID,
78 : : /* non-constant compound literals */
79 : : NIC_NCC,
80 : : /* a function call */
81 : : NIC_FUNC_CALL,
82 : : /* an increment */
83 : : NIC_INC,
84 : : /* an decrement */
85 : : NIC_DEC,
86 : : /* an array reference */
87 : : NIC_ARRAY_REF,
88 : : /* %<->%> */
89 : : NIC_ARROW,
90 : : /* %<.%> */
91 : : NIC_POINT,
92 : : /* the address of a label */
93 : : NIC_ADDR_LABEL,
94 : : /* %<*%> */
95 : : NIC_STAR,
96 : : /* %<&%> */
97 : : NIC_ADDR,
98 : : /* %<++%> */
99 : : NIC_PREINCREMENT,
100 : : /* %<--%> */
101 : : NIC_PREDECREMENT,
102 : : /* %<new%> */
103 : : NIC_NEW,
104 : : /* %<delete%> */
105 : : NIC_DEL,
106 : : /* calls to overloaded operators */
107 : : NIC_OVERLOADED,
108 : : /* an assignment */
109 : : NIC_ASSIGNMENT,
110 : : /* a comma operator */
111 : : NIC_COMMA,
112 : : /* a call to a constructor */
113 : : NIC_CONSTRUCTOR,
114 : : /* a transaction expression */
115 : : NIC_TRANSACTION
116 : : };
117 : :
118 : : /* The various kinds of errors about name-lookup failing. */
119 : : enum name_lookup_error {
120 : : /* NULL */
121 : : NLE_NULL,
122 : : /* is not a type */
123 : : NLE_TYPE,
124 : : /* is not a class or namespace */
125 : : NLE_CXX98,
126 : : /* is not a class, namespace, or enumeration */
127 : : NLE_NOT_CXX98
128 : : };
129 : :
130 : : /* The various kinds of required token */
131 : : enum required_token {
132 : : RT_NONE,
133 : : RT_SEMICOLON, /* ';' */
134 : : RT_OPEN_PAREN, /* '(' */
135 : : RT_CLOSE_BRACE, /* '}' */
136 : : RT_OPEN_BRACE, /* '{' */
137 : : RT_CLOSE_SQUARE, /* ']' */
138 : : RT_OPEN_SQUARE, /* '[' */
139 : : RT_COMMA, /* ',' */
140 : : RT_SCOPE, /* '::' */
141 : : RT_LESS, /* '<' */
142 : : RT_GREATER, /* '>' */
143 : : RT_EQ, /* '=' */
144 : : RT_ELLIPSIS, /* '...' */
145 : : RT_MULT, /* '*' */
146 : : RT_COMPL, /* '~' */
147 : : RT_COLON, /* ':' */
148 : : RT_COLON_SCOPE, /* ':' or '::' */
149 : : RT_CLOSE_PAREN, /* ')' */
150 : : RT_COMMA_CLOSE_PAREN, /* ',' or ')' */
151 : : RT_PRAGMA_EOL, /* end of line */
152 : : RT_NAME, /* identifier */
153 : :
154 : : /* The type is CPP_KEYWORD */
155 : : RT_NEW, /* new */
156 : : RT_DELETE, /* delete */
157 : : RT_RETURN, /* return */
158 : : RT_WHILE, /* while */
159 : : RT_EXTERN, /* extern */
160 : : RT_STATIC_ASSERT, /* static_assert */
161 : : RT_DECLTYPE, /* decltype */
162 : : RT_OPERATOR, /* operator */
163 : : RT_CLASS, /* class */
164 : : RT_TEMPLATE, /* template */
165 : : RT_NAMESPACE, /* namespace */
166 : : RT_USING, /* using */
167 : : RT_ASM, /* asm */
168 : : RT_TRY, /* try */
169 : : RT_CATCH, /* catch */
170 : : RT_THROW, /* throw */
171 : : RT_AUTO, /* auto */
172 : : RT_LABEL, /* __label__ */
173 : : RT_AT_TRY, /* @try */
174 : : RT_AT_SYNCHRONIZED, /* @synchronized */
175 : : RT_AT_THROW, /* @throw */
176 : :
177 : : RT_SELECT, /* selection-statement */
178 : : RT_ITERATION, /* iteration-statement */
179 : : RT_JUMP, /* jump-statement */
180 : : RT_CLASS_KEY, /* class-key */
181 : : RT_CLASS_TYPENAME_TEMPLATE, /* class, typename, or template */
182 : : RT_TRANSACTION_ATOMIC, /* __transaction_atomic */
183 : : RT_TRANSACTION_RELAXED, /* __transaction_relaxed */
184 : : RT_TRANSACTION_CANCEL, /* __transaction_cancel */
185 : :
186 : : RT_CO_YIELD /* co_yield */
187 : : };
188 : :
189 : : /* RAII wrapper for parser->in_type_id_in_expr_p, setting it on creation and
190 : : reverting it on destruction. */
191 : :
192 : : class type_id_in_expr_sentinel
193 : : {
194 : : cp_parser *parser;
195 : : bool saved;
196 : : public:
197 : 3126876 : type_id_in_expr_sentinel (cp_parser *parser, bool set = true)
198 : 3126876 : : parser (parser),
199 : 3126876 : saved (parser->in_type_id_in_expr_p)
200 : 3126876 : { parser->in_type_id_in_expr_p = set; }
201 : 3126876 : ~type_id_in_expr_sentinel ()
202 : 3126876 : { parser->in_type_id_in_expr_p = saved; }
203 : : };
204 : :
205 : : /* Prototypes. */
206 : :
207 : : static cp_lexer *cp_lexer_new_main
208 : : (void);
209 : : static cp_lexer *cp_lexer_new_from_tokens
210 : : (cp_token_cache *tokens);
211 : : static void cp_lexer_destroy
212 : : (cp_lexer *);
213 : : static int cp_lexer_saving_tokens
214 : : (const cp_lexer *);
215 : : static cp_token *cp_lexer_token_at
216 : : (cp_lexer *, cp_token_position);
217 : : static void cp_lexer_get_preprocessor_token
218 : : (unsigned, cp_token *);
219 : : static inline cp_token *cp_lexer_peek_token
220 : : (cp_lexer *);
221 : : static cp_token *cp_lexer_peek_nth_token
222 : : (cp_lexer *, size_t);
223 : : static inline bool cp_lexer_next_token_is
224 : : (cp_lexer *, enum cpp_ttype);
225 : : static bool cp_lexer_next_token_is_not
226 : : (cp_lexer *, enum cpp_ttype);
227 : : static bool cp_lexer_next_token_is_keyword
228 : : (cp_lexer *, enum rid);
229 : : static cp_token *cp_lexer_consume_token
230 : : (cp_lexer *);
231 : : static void cp_lexer_purge_token
232 : : (cp_lexer *);
233 : : static void cp_lexer_purge_tokens_after
234 : : (cp_lexer *, cp_token_position);
235 : : static void cp_lexer_save_tokens
236 : : (cp_lexer *);
237 : : static void cp_lexer_commit_tokens
238 : : (cp_lexer *);
239 : : static void cp_lexer_rollback_tokens
240 : : (cp_lexer *);
241 : : static void cp_lexer_print_token
242 : : (FILE *, cp_token *);
243 : : static inline bool cp_lexer_debugging_p
244 : : (cp_lexer *);
245 : : static void cp_lexer_start_debugging
246 : : (cp_lexer *) ATTRIBUTE_UNUSED;
247 : : static void cp_lexer_stop_debugging
248 : : (cp_lexer *) ATTRIBUTE_UNUSED;
249 : : static const cp_trait *cp_lexer_peek_trait
250 : : (cp_lexer *);
251 : : static const cp_trait *cp_lexer_peek_trait_expr
252 : : (cp_lexer *);
253 : : static const cp_trait *cp_lexer_peek_trait_type
254 : : (cp_lexer *);
255 : :
256 : : static cp_token_cache *cp_token_cache_new
257 : : (cp_token *, cp_token *);
258 : : static tree cp_parser_late_noexcept_specifier
259 : : (cp_parser *, tree);
260 : : static void noexcept_override_late_checks
261 : : (tree);
262 : :
263 : : static void cp_parser_initial_pragma
264 : : (cp_token *);
265 : :
266 : : static bool cp_parser_omp_declare_reduction_exprs
267 : : (tree, cp_parser *);
268 : : static void cp_finalize_oacc_routine
269 : : (cp_parser *, tree, bool);
270 : :
271 : : static void check_omp_intervening_code
272 : : (cp_parser *);
273 : :
274 : :
275 : : /* Manifest constants. */
276 : : #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
277 : : #define CP_SAVED_TOKEN_STACK 5
278 : :
279 : : /* Variables. */
280 : :
281 : : /* The stream to which debugging output should be written. */
282 : : static FILE *cp_lexer_debug_stream;
283 : :
284 : : /* Nonzero if we are parsing an unevaluated operand: an operand to
285 : : sizeof, typeof, or alignof. */
286 : : int cp_unevaluated_operand;
287 : :
288 : : /* Dump up to NUM tokens in BUFFER to FILE starting with token
289 : : START_TOKEN. If START_TOKEN is NULL, the dump starts with the
290 : : first token in BUFFER. If NUM is 0, dump all the tokens. If
291 : : CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
292 : : highlighted by surrounding it in [[ ]]. */
293 : :
294 : : static void
295 : 0 : cp_lexer_dump_tokens (FILE *file, vec<cp_token, va_gc> *buffer,
296 : : cp_token *start_token, unsigned num,
297 : : cp_token *curr_token)
298 : : {
299 : 0 : unsigned i, nprinted;
300 : 0 : cp_token *token;
301 : 0 : bool do_print;
302 : :
303 : 0 : fprintf (file, "%u tokens\n", vec_safe_length (buffer));
304 : :
305 : 0 : if (buffer == NULL)
306 : 0 : return;
307 : :
308 : 0 : if (num == 0)
309 : 0 : num = buffer->length ();
310 : :
311 : 0 : if (start_token == NULL)
312 : 0 : start_token = buffer->address ();
313 : :
314 : 0 : if (start_token > buffer->address ())
315 : : {
316 : 0 : cp_lexer_print_token (file, &(*buffer)[0]);
317 : 0 : fprintf (file, " ... ");
318 : : }
319 : :
320 : : do_print = false;
321 : : nprinted = 0;
322 : 0 : for (i = 0; buffer->iterate (i, &token) && nprinted < num; i++)
323 : : {
324 : 0 : if (token == start_token)
325 : : do_print = true;
326 : :
327 : 0 : if (!do_print)
328 : 0 : continue;
329 : :
330 : 0 : nprinted++;
331 : 0 : if (token == curr_token)
332 : 0 : fprintf (file, "[[");
333 : :
334 : 0 : cp_lexer_print_token (file, token);
335 : :
336 : 0 : if (token == curr_token)
337 : 0 : fprintf (file, "]]");
338 : :
339 : 0 : switch (token->type)
340 : : {
341 : 0 : case CPP_SEMICOLON:
342 : 0 : case CPP_OPEN_BRACE:
343 : 0 : case CPP_CLOSE_BRACE:
344 : 0 : case CPP_EOF:
345 : 0 : fputc ('\n', file);
346 : 0 : break;
347 : :
348 : 0 : default:
349 : 0 : fputc (' ', file);
350 : : }
351 : : }
352 : :
353 : 0 : if (i == num && i < buffer->length ())
354 : : {
355 : 0 : fprintf (file, " ... ");
356 : 0 : cp_lexer_print_token (file, &buffer->last ());
357 : : }
358 : :
359 : 0 : fprintf (file, "\n");
360 : : }
361 : :
362 : :
363 : : /* Dump all tokens in BUFFER to stderr. */
364 : :
365 : : void
366 : 0 : cp_lexer_debug_tokens (vec<cp_token, va_gc> *buffer)
367 : : {
368 : 0 : cp_lexer_dump_tokens (stderr, buffer, NULL, 0, NULL);
369 : 0 : }
370 : :
371 : : DEBUG_FUNCTION void
372 : 0 : debug (vec<cp_token, va_gc> &ref)
373 : : {
374 : 0 : cp_lexer_dump_tokens (stderr, &ref, NULL, 0, NULL);
375 : 0 : }
376 : :
377 : : DEBUG_FUNCTION void
378 : 0 : debug (vec<cp_token, va_gc> *ptr)
379 : : {
380 : 0 : if (ptr)
381 : 0 : debug (*ptr);
382 : : else
383 : 0 : fprintf (stderr, "<nil>\n");
384 : 0 : }
385 : :
386 : :
387 : : /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
388 : : description for T. */
389 : :
390 : : static void
391 : 0 : cp_debug_print_tree_if_set (FILE *file, const char *desc, tree t)
392 : : {
393 : 0 : if (t)
394 : : {
395 : 0 : fprintf (file, "%s: ", desc);
396 : 0 : print_node_brief (file, "", t, 0);
397 : : }
398 : 0 : }
399 : :
400 : :
401 : : /* Dump parser context C to FILE. */
402 : :
403 : : static void
404 : 0 : cp_debug_print_context (FILE *file, cp_parser_context *c)
405 : : {
406 : 0 : const char *status_s[] = { "OK", "ERROR", "COMMITTED" };
407 : 0 : fprintf (file, "{ status = %s, scope = ", status_s[c->status]);
408 : 0 : print_node_brief (file, "", c->object_type, 0);
409 : 0 : fprintf (file, "}\n");
410 : 0 : }
411 : :
412 : :
413 : : /* Print the stack of parsing contexts to FILE starting with FIRST. */
414 : :
415 : : static void
416 : 0 : cp_debug_print_context_stack (FILE *file, cp_parser_context *first)
417 : : {
418 : 0 : unsigned i;
419 : 0 : cp_parser_context *c;
420 : :
421 : 0 : fprintf (file, "Parsing context stack:\n");
422 : 0 : for (i = 0, c = first; c; c = c->next, i++)
423 : : {
424 : 0 : fprintf (file, "\t#%u: ", i);
425 : 0 : cp_debug_print_context (file, c);
426 : : }
427 : 0 : }
428 : :
429 : :
430 : : /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
431 : :
432 : : static void
433 : 0 : cp_debug_print_flag (FILE *file, const char *desc, bool flag)
434 : : {
435 : 0 : if (flag)
436 : 0 : fprintf (file, "%s: true\n", desc);
437 : 0 : }
438 : :
439 : :
440 : : /* Print an unparsed function entry UF to FILE. */
441 : :
442 : : static void
443 : 0 : cp_debug_print_unparsed_function (FILE *file, cp_unparsed_functions_entry *uf)
444 : : {
445 : 0 : unsigned i;
446 : 0 : cp_default_arg_entry *default_arg_fn;
447 : 0 : tree fn;
448 : :
449 : 0 : fprintf (file, "\tFunctions with default args:\n");
450 : 0 : for (i = 0;
451 : 0 : vec_safe_iterate (uf->funs_with_default_args, i, &default_arg_fn);
452 : : i++)
453 : : {
454 : 0 : fprintf (file, "\t\tClass type: ");
455 : 0 : print_node_brief (file, "", default_arg_fn->class_type, 0);
456 : 0 : fprintf (file, "\t\tDeclaration: ");
457 : 0 : print_node_brief (file, "", default_arg_fn->decl, 0);
458 : 0 : fprintf (file, "\n");
459 : : }
460 : :
461 : 0 : fprintf (file, "\n\tFunctions with definitions that require "
462 : : "post-processing\n\t\t");
463 : 0 : for (i = 0; vec_safe_iterate (uf->funs_with_definitions, i, &fn); i++)
464 : : {
465 : 0 : print_node_brief (file, "", fn, 0);
466 : 0 : fprintf (file, " ");
467 : : }
468 : 0 : fprintf (file, "\n");
469 : :
470 : 0 : fprintf (file, "\n\tNon-static data members with initializers that require "
471 : : "post-processing\n\t\t");
472 : 0 : for (i = 0; vec_safe_iterate (uf->nsdmis, i, &fn); i++)
473 : : {
474 : 0 : print_node_brief (file, "", fn, 0);
475 : 0 : fprintf (file, " ");
476 : : }
477 : 0 : fprintf (file, "\n");
478 : 0 : }
479 : :
480 : :
481 : : /* Print the stack of unparsed member functions S to FILE. */
482 : :
483 : : static void
484 : 0 : cp_debug_print_unparsed_queues (FILE *file,
485 : : vec<cp_unparsed_functions_entry, va_gc> *s)
486 : : {
487 : 0 : unsigned i;
488 : 0 : cp_unparsed_functions_entry *uf;
489 : :
490 : 0 : fprintf (file, "Unparsed functions\n");
491 : 0 : for (i = 0; vec_safe_iterate (s, i, &uf); i++)
492 : : {
493 : 0 : fprintf (file, "#%u:\n", i);
494 : 0 : cp_debug_print_unparsed_function (file, uf);
495 : : }
496 : 0 : }
497 : :
498 : :
499 : : /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
500 : : the given PARSER. If FILE is NULL, the output is printed on stderr. */
501 : :
502 : : static void
503 : 0 : cp_debug_parser_tokens (FILE *file, cp_parser *parser, int window_size)
504 : : {
505 : 0 : cp_token *next_token, *first_token, *start_token;
506 : :
507 : 0 : if (file == NULL)
508 : 0 : file = stderr;
509 : :
510 : 0 : next_token = parser->lexer->next_token;
511 : 0 : first_token = parser->lexer->buffer->address ();
512 : 0 : start_token = (next_token > first_token + window_size / 2)
513 : 0 : ? next_token - window_size / 2
514 : : : first_token;
515 : 0 : cp_lexer_dump_tokens (file, parser->lexer->buffer, start_token, window_size,
516 : : next_token);
517 : 0 : }
518 : :
519 : :
520 : : /* Dump debugging information for the given PARSER. If FILE is NULL,
521 : : the output is printed on stderr. */
522 : :
523 : : void
524 : 0 : cp_debug_parser (FILE *file, cp_parser *parser)
525 : : {
526 : 0 : const size_t window_size = 20;
527 : 0 : cp_token *token;
528 : 0 : expanded_location eloc;
529 : :
530 : 0 : if (file == NULL)
531 : 0 : file = stderr;
532 : :
533 : 0 : fprintf (file, "Parser state\n\n");
534 : 0 : fprintf (file, "Number of tokens: %u\n",
535 : 0 : vec_safe_length (parser->lexer->buffer));
536 : 0 : cp_debug_print_tree_if_set (file, "Lookup scope", parser->scope);
537 : 0 : cp_debug_print_tree_if_set (file, "Object scope",
538 : : parser->object_scope);
539 : 0 : cp_debug_print_tree_if_set (file, "Qualifying scope",
540 : : parser->qualifying_scope);
541 : 0 : cp_debug_print_context_stack (file, parser->context);
542 : 0 : cp_debug_print_flag (file, "Allow GNU extensions",
543 : 0 : parser->allow_gnu_extensions_p);
544 : 0 : cp_debug_print_flag (file, "'>' token is greater-than",
545 : 0 : parser->greater_than_is_operator_p);
546 : 0 : cp_debug_print_flag (file, "Default args allowed in current "
547 : 0 : "parameter list", parser->default_arg_ok_p);
548 : 0 : cp_debug_print_flag (file, "Parsing integral constant-expression",
549 : 0 : parser->integral_constant_expression_p);
550 : 0 : cp_debug_print_flag (file, "Allow non-constant expression in current "
551 : : "constant-expression",
552 : 0 : parser->allow_non_integral_constant_expression_p);
553 : 0 : cp_debug_print_flag (file, "Seen non-constant expression",
554 : 0 : parser->non_integral_constant_expression_p);
555 : 0 : cp_debug_print_flag (file, "Local names forbidden in current context",
556 : 0 : (parser->local_variables_forbidden_p
557 : : & LOCAL_VARS_FORBIDDEN));
558 : 0 : cp_debug_print_flag (file, "'this' forbidden in current context",
559 : 0 : (parser->local_variables_forbidden_p
560 : : & THIS_FORBIDDEN));
561 : 0 : cp_debug_print_flag (file, "In unbraced linkage specification",
562 : 0 : parser->in_unbraced_linkage_specification_p);
563 : 0 : cp_debug_print_flag (file, "In unbraced export declaration",
564 : 0 : parser->in_unbraced_export_declaration_p);
565 : 0 : cp_debug_print_flag (file, "Parsing a declarator",
566 : 0 : parser->in_declarator_p);
567 : 0 : cp_debug_print_flag (file, "In template argument list",
568 : 0 : parser->in_template_argument_list_p);
569 : 0 : cp_debug_print_flag (file, "Parsing an iteration statement",
570 : 0 : parser->in_statement & IN_ITERATION_STMT);
571 : 0 : cp_debug_print_flag (file, "Parsing a switch statement",
572 : 0 : parser->in_statement & IN_SWITCH_STMT);
573 : 0 : cp_debug_print_flag (file, "Parsing a structured OpenMP block",
574 : 0 : parser->in_statement & IN_OMP_BLOCK);
575 : 0 : cp_debug_print_flag (file, "Parsing an OpenMP loop",
576 : 0 : parser->in_statement & IN_OMP_FOR);
577 : 0 : cp_debug_print_flag (file, "Parsing an if statement",
578 : 0 : parser->in_statement & IN_IF_STMT);
579 : 0 : cp_debug_print_flag (file, "Parsing a type-id in an expression "
580 : 0 : "context", parser->in_type_id_in_expr_p);
581 : 0 : cp_debug_print_flag (file, "String expressions should be translated "
582 : : "to execution character set",
583 : 0 : parser->translate_strings_p);
584 : 0 : cp_debug_print_flag (file, "Parsing function body outside of a "
585 : 0 : "local class", parser->in_function_body);
586 : 0 : cp_debug_print_flag (file, "Auto correct a colon to a scope operator",
587 : 0 : parser->colon_corrects_to_scope_p);
588 : 0 : cp_debug_print_flag (file, "Colon doesn't start a class definition",
589 : 0 : parser->colon_doesnt_start_class_def_p);
590 : 0 : cp_debug_print_flag (file, "Parsing an Objective-C++ message context",
591 : 0 : parser->objective_c_message_context_p);
592 : 0 : if (parser->type_definition_forbidden_message)
593 : 0 : fprintf (file, "Error message for forbidden type definitions: %s %s\n",
594 : : parser->type_definition_forbidden_message,
595 : 0 : parser->type_definition_forbidden_message_arg
596 : : ? parser->type_definition_forbidden_message_arg : "<none>");
597 : 0 : cp_debug_print_unparsed_queues (file, parser->unparsed_queues);
598 : 0 : fprintf (file, "Number of class definitions in progress: %u\n",
599 : : parser->num_classes_being_defined);
600 : 0 : fprintf (file, "Number of template parameter lists for the current "
601 : : "declaration: %u\n", parser->num_template_parameter_lists);
602 : 0 : cp_debug_parser_tokens (file, parser, window_size);
603 : 0 : token = parser->lexer->next_token;
604 : 0 : fprintf (file, "Next token to parse:\n");
605 : 0 : fprintf (file, "\tToken: ");
606 : 0 : cp_lexer_print_token (file, token);
607 : 0 : eloc = expand_location (token->location);
608 : 0 : fprintf (file, "\n\tFile: %s\n", eloc.file);
609 : 0 : fprintf (file, "\tLine: %d\n", eloc.line);
610 : 0 : fprintf (file, "\tColumn: %d\n", eloc.column);
611 : 0 : }
612 : :
613 : : DEBUG_FUNCTION void
614 : 0 : debug (cp_parser &ref)
615 : : {
616 : 0 : cp_debug_parser (stderr, &ref);
617 : 0 : }
618 : :
619 : : DEBUG_FUNCTION void
620 : 0 : debug (cp_parser *ptr)
621 : : {
622 : 0 : if (ptr)
623 : 0 : debug (*ptr);
624 : : else
625 : 0 : fprintf (stderr, "<nil>\n");
626 : 0 : }
627 : :
628 : : /* Allocate memory for a new lexer object and return it. */
629 : :
630 : : static cp_lexer *
631 : 93977 : cp_lexer_alloc (void)
632 : : {
633 : : /* Allocate the memory. */
634 : 93977 : cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();
635 : :
636 : : /* Initially we are not debugging. */
637 : 93977 : lexer->debugging_p = false;
638 : :
639 : 93977 : lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
640 : :
641 : : /* Create the buffer. */
642 : 93977 : vec_alloc (lexer->buffer, CP_LEXER_BUFFER_SIZE);
643 : :
644 : 93977 : return lexer;
645 : : }
646 : :
647 : : /* Return TRUE if token is the start of a module declaration that will be
648 : : terminated by a CPP_PRAGMA_EOL token. */
649 : : static inline bool
650 : 117676679 : cp_token_is_module_directive (cp_token *token)
651 : : {
652 : 117676679 : return token->keyword == RID__EXPORT
653 : 117676673 : || token->keyword == RID__MODULE
654 : 117674757 : || token->keyword == RID__IMPORT;
655 : : }
656 : :
657 : : /* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
658 : : PRAGMA_NONE. */
659 : :
660 : : static enum pragma_kind
661 : 4397270 : cp_parser_pragma_kind (cp_token *token)
662 : : {
663 : 4397270 : if (token->type != CPP_PRAGMA)
664 : : return PRAGMA_NONE;
665 : : /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
666 : 4306346 : return (enum pragma_kind) TREE_INT_CST_LOW (token->u.value);
667 : : }
668 : :
669 : : /* Handle early pragmas such as #pragma GCC diagnostic, which needs to be done
670 : : during preprocessing for the case of preprocessing-related diagnostics. This
671 : : is called immediately after pushing the CPP_PRAGMA_EOL token onto
672 : : lexer->buffer. */
673 : :
674 : : static void
675 : 2136652 : cp_lexer_handle_early_pragma (cp_lexer *lexer)
676 : : {
677 : 2136652 : const auto first_token = lexer->buffer->address ();
678 : 2136652 : const auto last_token = first_token + lexer->buffer->length () - 1;
679 : :
680 : : /* Back up to the start of the pragma so pragma_lex () can parse it when
681 : : c-pragma lib asks it to. */
682 : 2136652 : auto begin = last_token;
683 : 2136652 : gcc_assert (begin->type == CPP_PRAGMA_EOL);
684 : 7734888 : while (begin->type != CPP_PRAGMA)
685 : : {
686 : 5602069 : if (cp_token_is_module_directive (begin))
687 : : return;
688 : 5598236 : gcc_assert (begin != first_token);
689 : 5598236 : --begin;
690 : : }
691 : 2132819 : gcc_assert (!lexer->next_token);
692 : 2132819 : gcc_assert (!lexer->last_token);
693 : 2132819 : lexer->next_token = begin;
694 : 2132819 : lexer->last_token = last_token;
695 : :
696 : : /* Dispatch it. */
697 : 2132819 : const unsigned int id
698 : 2132819 : = cp_parser_pragma_kind (cp_lexer_consume_token (lexer));
699 : 2132819 : if (id >= PRAGMA_FIRST_EXTERNAL)
700 : 2080758 : c_invoke_early_pragma_handler (id);
701 : :
702 : : /* Reset to normal state. */
703 : 2132819 : lexer->next_token = lexer->last_token = nullptr;
704 : : }
705 : :
706 : : /* The parser. */
707 : : static cp_parser *cp_parser_new (cp_lexer *);
708 : : static GTY (()) cp_parser *the_parser;
709 : :
710 : : /* Create a new main C++ lexer, the lexer that gets tokens from the
711 : : preprocessor, and also create the main parser. */
712 : :
713 : : static cp_lexer *
714 : 90929 : cp_lexer_new_main (void)
715 : : {
716 : 90929 : cp_token token;
717 : :
718 : : /* It's possible that parsing the first pragma will load a PCH file,
719 : : which is a GC collection point. So we have to do that before
720 : : allocating any memory. */
721 : 90929 : cp_lexer_get_preprocessor_token (C_LEX_STRING_NO_JOIN, &token);
722 : 90897 : cp_parser_initial_pragma (&token);
723 : 90897 : c_common_no_more_pch ();
724 : :
725 : 90897 : cp_lexer *lexer = cp_lexer_alloc ();
726 : : /* Put the first token in the buffer. */
727 : 90897 : cp_token *tok = lexer->buffer->quick_push (token);
728 : :
729 : 90897 : uintptr_t filter = 0;
730 : 90897 : if (modules_p ())
731 : 3547 : filter = module_token_cdtor (parse_in, filter);
732 : :
733 : : /* Create the parser now, so we can use it to handle early pragmas. */
734 : 90897 : gcc_assert (!the_parser);
735 : 90897 : the_parser = cp_parser_new (lexer);
736 : :
737 : : /* Get the remaining tokens from the preprocessor. */
738 : 7582081652 : while (tok->type != CPP_EOF)
739 : : {
740 : 7581990757 : if (filter)
741 : : /* Process the previous token. */
742 : 35908240 : module_token_lang (tok->type, tok->keyword, tok->u.value,
743 : : tok->location, filter);
744 : :
745 : : /* Check for early pragmas that need to be handled now. */
746 : 7581990757 : if (tok->type == CPP_PRAGMA_EOL)
747 : 2136652 : cp_lexer_handle_early_pragma (lexer);
748 : :
749 : 7581990757 : tok = vec_safe_push (lexer->buffer, cp_token ());
750 : 7581990757 : cp_lexer_get_preprocessor_token (C_LEX_STRING_NO_JOIN, tok);
751 : : }
752 : :
753 : 90895 : lexer->next_token = lexer->buffer->address ();
754 : 90895 : lexer->last_token = lexer->next_token
755 : 90895 : + lexer->buffer->length ()
756 : 90895 : - 1;
757 : :
758 : 90895 : if (lexer->buffer->length () != 1)
759 : : {
760 : : /* Set the EOF token's location to be the just after the previous
761 : : token's range. That way 'at-eof' diagnostics point at something
762 : : meaninful. */
763 : 90220 : auto range = get_range_from_loc (line_table, tok[-1].location);
764 : 90220 : tok[0].location
765 : 90220 : = linemap_position_for_loc_and_offset (line_table, range.m_finish, 1);
766 : : }
767 : :
768 : 90895 : if (filter)
769 : 3547 : module_token_cdtor (parse_in, filter);
770 : :
771 : : /* Subsequent preprocessor diagnostics should use compiler
772 : : diagnostic functions to get the compiler source location. */
773 : 90892 : override_libcpp_locations = true;
774 : :
775 : 90892 : maybe_check_all_macros (parse_in);
776 : :
777 : : /* If we processed any #pragma GCC target directives, we handled them early so
778 : : any macros they defined would be effective during preprocessing. Now, we
779 : : need to reset to the default state to begin compilation, and we will
780 : : process them again at the correct time as needed. */
781 : 90892 : c_reset_target_pragmas ();
782 : :
783 : 90892 : gcc_assert (!lexer->next_token->purged_p);
784 : 90892 : return lexer;
785 : : }
786 : :
787 : : /* Create a lexer and parser to be used during preprocess-only mode.
788 : : This will be filled with tokens to parse when needed by pragma_lex (). */
789 : : void
790 : 1152 : c_init_preprocess ()
791 : : {
792 : 1152 : gcc_assert (!the_parser);
793 : 1152 : the_parser = cp_parser_new (cp_lexer_alloc ());
794 : 1152 : }
795 : :
796 : : /* Create a new lexer whose token stream is primed with the tokens in
797 : : CACHE. When these tokens are exhausted, no new tokens will be read. */
798 : :
799 : : static cp_lexer *
800 : 72605996 : cp_lexer_new_from_tokens (cp_token_cache *cache)
801 : : {
802 : 72605996 : cp_token *first = cache->first;
803 : 72605996 : cp_token *last = cache->last;
804 : 72605996 : cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();
805 : :
806 : : /* We do not own the buffer. */
807 : 72605996 : lexer->buffer = NULL;
808 : :
809 : : /* Insert an EOF token. */
810 : 72605996 : lexer->saved_type = last->type;
811 : 72605996 : lexer->saved_keyword = last->keyword;
812 : 72605996 : last->type = CPP_EOF;
813 : 72605996 : last->keyword = RID_MAX;
814 : :
815 : 72605996 : lexer->next_token = first;
816 : 72605996 : lexer->last_token = last;
817 : :
818 : 72605996 : lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
819 : :
820 : : /* Initially we are not debugging. */
821 : 72605996 : lexer->debugging_p = false;
822 : :
823 : 72605996 : gcc_assert (!lexer->next_token->purged_p
824 : : && !lexer->last_token->purged_p);
825 : 72605996 : return lexer;
826 : : }
827 : :
828 : : /* Frees all resources associated with LEXER. */
829 : :
830 : : static void
831 : 72698517 : cp_lexer_destroy (cp_lexer *lexer)
832 : : {
833 : 72698517 : if (lexer->buffer)
834 : 92521 : vec_free (lexer->buffer);
835 : : else
836 : : {
837 : : /* Restore the token we overwrite with EOF. */
838 : 72605996 : lexer->last_token->type = lexer->saved_type;
839 : 72605996 : lexer->last_token->keyword = lexer->saved_keyword;
840 : : }
841 : 72698517 : lexer->saved_tokens.release ();
842 : 72698517 : ggc_free (lexer);
843 : 72698517 : }
844 : :
845 : : /* This needs to be set to TRUE before the lexer-debugging infrastructure can
846 : : be used. The point of this flag is to help the compiler to fold away calls
847 : : to cp_lexer_debugging_p within this source file at compile time, when the
848 : : lexer is not being debugged. */
849 : :
850 : : #define LEXER_DEBUGGING_ENABLED_P false
851 : :
852 : : /* Returns nonzero if debugging information should be output. */
853 : :
854 : : static inline bool
855 : : cp_lexer_debugging_p (cp_lexer *lexer)
856 : : {
857 : : if (!LEXER_DEBUGGING_ENABLED_P)
858 : : return false;
859 : :
860 : : return lexer->debugging_p;
861 : : }
862 : :
863 : :
864 : : static inline cp_token_position
865 : 1080602042 : cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
866 : : {
867 : 1080602042 : return lexer->next_token - previous_p;
868 : : }
869 : :
870 : : static inline cp_token *
871 : : cp_lexer_token_at (cp_lexer * /*lexer*/, cp_token_position pos)
872 : : {
873 : : return pos;
874 : : }
875 : :
876 : : static inline void
877 : 3012654 : cp_lexer_set_token_position (cp_lexer *lexer, cp_token_position pos)
878 : : {
879 : 3012654 : lexer->next_token = cp_lexer_token_at (lexer, pos);
880 : 2848323 : }
881 : :
882 : : static inline cp_token_position
883 : 1080588347 : cp_lexer_previous_token_position (cp_lexer *lexer)
884 : : {
885 : 1080588347 : return cp_lexer_token_position (lexer, true);
886 : : }
887 : :
888 : : static inline cp_token *
889 : 1080585016 : cp_lexer_previous_token (cp_lexer *lexer)
890 : : {
891 : 1080585016 : cp_token_position tp = cp_lexer_previous_token_position (lexer);
892 : :
893 : : /* Skip past purged tokens. */
894 : 1089149120 : while (tp->purged_p)
895 : : {
896 : 15789801 : gcc_assert (tp != vec_safe_address (lexer->buffer));
897 : 8564104 : tp--;
898 : : }
899 : :
900 : 1080585016 : return cp_lexer_token_at (lexer, tp);
901 : : }
902 : :
903 : : /* Same as above, but return NULL when the lexer doesn't own the token
904 : : buffer or if the next_token is at the start of the token
905 : : vector or if all previous tokens are purged. */
906 : :
907 : : static cp_token *
908 : 3389 : cp_lexer_safe_previous_token (cp_lexer *lexer)
909 : : {
910 : 3389 : if (lexer->buffer
911 : 3389 : && lexer->next_token != lexer->buffer->address ())
912 : : {
913 : 3241 : cp_token_position tp = cp_lexer_previous_token_position (lexer);
914 : :
915 : : /* Skip past purged tokens. */
916 : 3484 : while (tp->purged_p)
917 : : {
918 : 243 : if (tp == lexer->buffer->address ())
919 : : return NULL;
920 : 243 : tp--;
921 : : }
922 : : return cp_lexer_token_at (lexer, tp);
923 : : }
924 : :
925 : : return NULL;
926 : : }
927 : :
928 : : /* Overload for make_location, taking the lexer to mean the location of the
929 : : previous token. */
930 : :
931 : : static inline location_t
932 : 373625819 : make_location (location_t caret, location_t start, cp_lexer *lexer)
933 : : {
934 : 373625819 : cp_token *t = cp_lexer_previous_token (lexer);
935 : 373625819 : return make_location (caret, start, t->location);
936 : : }
937 : :
938 : : /* Overload for make_location taking tokens instead of locations. */
939 : :
940 : : static inline location_t
941 : 12 : make_location (cp_token *caret, cp_token *start, cp_token *end)
942 : : {
943 : 12 : return make_location (caret->location, start->location, end->location);
944 : : }
945 : :
946 : : /* nonzero if we are presently saving tokens. */
947 : :
948 : : static inline int
949 : 371343068 : cp_lexer_saving_tokens (const cp_lexer* lexer)
950 : : {
951 : 742686136 : return lexer->saved_tokens.length () != 0;
952 : : }
953 : :
954 : : /* Store the next token from the preprocessor in *TOKEN. Return true
955 : : if we reach EOF. If LEXER is NULL, assume we are handling an
956 : : initial #pragma pch_preprocess, and thus want the lexer to return
957 : : processed strings.
958 : :
959 : : Diagnostics issued from this function must have their controlling option (if
960 : : any) in c.opt annotated as a libcpp option via the CppReason property. */
961 : :
962 : : static void
963 : 7582095329 : cp_lexer_get_preprocessor_token (unsigned flags, cp_token *token)
964 : : {
965 : 7582095329 : static int is_extern_c = 0;
966 : :
967 : : /* Get a new token from the preprocessor. */
968 : 7582095329 : token->type
969 : 7582095329 : = c_lex_with_flags (&token->u.value, &token->location, &token->flags,
970 : : flags);
971 : 7582095295 : token->keyword = RID_MAX;
972 : 7582095295 : token->purged_p = false;
973 : 7582095295 : token->error_reported = false;
974 : 7582095295 : token->tree_check_p = false;
975 : : /* Usually never see a zero, but just in case ... */
976 : 7582095295 : token->main_source_p = line_table->depth <= 1;
977 : :
978 : : /* On some systems, some header files are surrounded by an
979 : : implicit extern "C" block. Set a flag in the token if it
980 : : comes from such a header. */
981 : 7582095295 : is_extern_c += pending_lang_change;
982 : 7582095295 : pending_lang_change = 0;
983 : 7582095295 : token->implicit_extern_c = is_extern_c > 0;
984 : :
985 : : /* Check to see if this token is a keyword. */
986 : 7582095295 : if (token->type == CPP_NAME)
987 : : {
988 : 3532034057 : if (IDENTIFIER_KEYWORD_P (token->u.value))
989 : : {
990 : : /* Mark this token as a keyword. */
991 : 1246456293 : token->type = CPP_KEYWORD;
992 : : /* Record which keyword. */
993 : 1246456293 : token->keyword = C_RID_CODE (token->u.value);
994 : : }
995 : : else
996 : : {
997 : 2285577764 : if (warn_cxx11_compat
998 : 2155780 : && ((C_RID_CODE (token->u.value) >= RID_FIRST_CXX11
999 : 2155780 : && C_RID_CODE (token->u.value) <= RID_LAST_CXX11)
1000 : : /* These are outside the CXX11 range. */
1001 : 2155768 : || C_RID_CODE (token->u.value) == RID_ALIGNOF
1002 : 2155766 : || C_RID_CODE (token->u.value) == RID_ALIGNAS
1003 : 2155764 : || C_RID_CODE (token->u.value)== RID_THREAD))
1004 : : {
1005 : : /* Warn about the C++11 keyword (but still treat it as
1006 : : an identifier). */
1007 : 18 : warning_at (token->location, OPT_Wc__11_compat,
1008 : : "identifier %qE is a keyword in C++11",
1009 : : token->u.value);
1010 : :
1011 : : /* Clear out the C_RID_CODE so we don't warn about this
1012 : : particular identifier-turned-keyword again. */
1013 : 18 : C_SET_RID_CODE (token->u.value, RID_MAX);
1014 : : }
1015 : 2285577764 : if (warn_cxx20_compat
1016 : 30854320 : && C_RID_CODE (token->u.value) >= RID_FIRST_CXX20
1017 : 26540 : && C_RID_CODE (token->u.value) <= RID_LAST_CXX20)
1018 : : {
1019 : : /* Warn about the C++20 keyword (but still treat it as
1020 : : an identifier). */
1021 : 17 : warning_at (token->location, OPT_Wc__20_compat,
1022 : : "identifier %qE is a keyword in C++20",
1023 : : token->u.value);
1024 : :
1025 : : /* Clear out the C_RID_CODE so we don't warn about this
1026 : : particular identifier-turned-keyword again. */
1027 : 17 : C_SET_RID_CODE (token->u.value, RID_MAX);
1028 : : }
1029 : :
1030 : 2285577764 : token->keyword = RID_MAX;
1031 : : }
1032 : : }
1033 : 4050061238 : else if (token->type == CPP_AT_NAME)
1034 : : {
1035 : : /* This only happens in Objective-C++; it must be a keyword. */
1036 : 0 : token->type = CPP_KEYWORD;
1037 : 0 : switch (C_RID_CODE (token->u.value))
1038 : : {
1039 : : /* Replace 'class' with '@class', 'private' with '@private',
1040 : : etc. This prevents confusion with the C++ keyword
1041 : : 'class', and makes the tokens consistent with other
1042 : : Objective-C 'AT' keywords. For example '@class' is
1043 : : reported as RID_AT_CLASS which is consistent with
1044 : : '@synchronized', which is reported as
1045 : : RID_AT_SYNCHRONIZED.
1046 : : */
1047 : 0 : case RID_CLASS: token->keyword = RID_AT_CLASS; break;
1048 : 0 : case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
1049 : 0 : case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
1050 : 0 : case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
1051 : 0 : case RID_THROW: token->keyword = RID_AT_THROW; break;
1052 : 0 : case RID_TRY: token->keyword = RID_AT_TRY; break;
1053 : 0 : case RID_CATCH: token->keyword = RID_AT_CATCH; break;
1054 : 0 : case RID_SYNCHRONIZED: token->keyword = RID_AT_SYNCHRONIZED; break;
1055 : 0 : default: token->keyword = C_RID_CODE (token->u.value);
1056 : : }
1057 : : }
1058 : 7582095295 : }
1059 : :
1060 : : /* Update the globals input_location and the input file stack from TOKEN. */
1061 : : static inline void
1062 : 13276248544 : cp_lexer_set_source_position_from_token (cp_token *token)
1063 : : {
1064 : 13276248544 : input_location = token->location;
1065 : 2006 : }
1066 : :
1067 : : /* Update the globals input_location and the input file stack from LEXER. */
1068 : : static inline void
1069 : 6212218 : cp_lexer_set_source_position (cp_lexer *lexer)
1070 : : {
1071 : 6212218 : cp_token *token = cp_lexer_peek_token (lexer);
1072 : 6212218 : cp_lexer_set_source_position_from_token (token);
1073 : : }
1074 : :
1075 : : /* Return a pointer to the next token in the token stream, but do not
1076 : : consume it. */
1077 : :
1078 : : static inline cp_token *
1079 : 85963993955 : cp_lexer_peek_token (cp_lexer *lexer)
1080 : : {
1081 : 85963993955 : if (cp_lexer_debugging_p (lexer))
1082 : : {
1083 : : fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
1084 : : cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
1085 : : putc ('\n', cp_lexer_debug_stream);
1086 : : }
1087 : 85963994486 : return lexer->next_token;
1088 : : }
1089 : :
1090 : : /* Return true if the next token has the indicated TYPE. */
1091 : :
1092 : : static inline bool
1093 : 25986473997 : cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
1094 : : {
1095 : 27990920089 : return cp_lexer_peek_token (lexer)->type == type;
1096 : : }
1097 : :
1098 : : /* Return true if the next token does not have the indicated TYPE. */
1099 : :
1100 : : static inline bool
1101 : 5796517267 : cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
1102 : : {
1103 : 6162044926 : return !cp_lexer_next_token_is (lexer, type);
1104 : : }
1105 : :
1106 : : /* Return true if the next token is the indicated KEYWORD. */
1107 : :
1108 : : static inline bool
1109 : 3379712103 : cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
1110 : : {
1111 : 4670463744 : return cp_lexer_peek_token (lexer)->keyword == keyword;
1112 : : }
1113 : :
1114 : : static inline bool
1115 : 1097023714 : cp_lexer_nth_token_is (cp_lexer* lexer, size_t n, enum cpp_ttype type)
1116 : : {
1117 : 249 : return cp_lexer_peek_nth_token (lexer, n)->type == type;
1118 : : }
1119 : :
1120 : : static inline bool
1121 : 325758526 : cp_lexer_nth_token_is_keyword (cp_lexer* lexer, size_t n, enum rid keyword)
1122 : : {
1123 : 334808198 : return cp_lexer_peek_nth_token (lexer, n)->keyword == keyword;
1124 : : }
1125 : :
1126 : : /* Return true if KEYWORD can start a decl-specifier. */
1127 : :
1128 : : bool
1129 : 17962115 : cp_keyword_starts_decl_specifier_p (enum rid keyword)
1130 : : {
1131 : 17962115 : switch (keyword)
1132 : : {
1133 : : /* auto specifier: storage-class-specifier in C++,
1134 : : simple-type-specifier in C++0x. */
1135 : : case RID_AUTO:
1136 : : /* Storage classes. */
1137 : : case RID_REGISTER:
1138 : : case RID_STATIC:
1139 : : case RID_EXTERN:
1140 : : case RID_MUTABLE:
1141 : : case RID_THREAD:
1142 : : /* Elaborated type specifiers. */
1143 : : case RID_ENUM:
1144 : : case RID_CLASS:
1145 : : case RID_STRUCT:
1146 : : case RID_UNION:
1147 : : case RID_TYPENAME:
1148 : : /* Simple type specifiers. */
1149 : : case RID_CHAR:
1150 : : case RID_CHAR8:
1151 : : case RID_CHAR16:
1152 : : case RID_CHAR32:
1153 : : case RID_WCHAR:
1154 : : case RID_BOOL:
1155 : : case RID_SHORT:
1156 : : case RID_INT:
1157 : : case RID_LONG:
1158 : : case RID_SIGNED:
1159 : : case RID_UNSIGNED:
1160 : : case RID_FLOAT:
1161 : : case RID_DOUBLE:
1162 : : CASE_RID_FLOATN_NX:
1163 : : case RID_VOID:
1164 : : /* CV qualifiers. */
1165 : : case RID_CONST:
1166 : : case RID_VOLATILE:
1167 : : /* Function specifiers. */
1168 : : case RID_EXPLICIT:
1169 : : case RID_VIRTUAL:
1170 : : /* friend/typdef/inline specifiers. */
1171 : : case RID_FRIEND:
1172 : : case RID_TYPEDEF:
1173 : : case RID_INLINE:
1174 : : /* GNU extensions. */
1175 : : case RID_TYPEOF:
1176 : : /* C++11 extensions. */
1177 : : case RID_DECLTYPE:
1178 : : case RID_CONSTEXPR:
1179 : : /* C++20 extensions. */
1180 : : case RID_CONSTINIT:
1181 : : case RID_CONSTEVAL:
1182 : : return true;
1183 : :
1184 : 11091389 : default:
1185 : 11091389 : if (keyword >= RID_FIRST_INT_N
1186 : : && keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
1187 : 0 : && int_n_enabled_p[keyword - RID_FIRST_INT_N])
1188 : : return true;
1189 : : return false;
1190 : : }
1191 : : }
1192 : :
1193 : : /* Peeks the corresponding built-in trait if the first token is
1194 : : a built-in trait and the second token is either `(' or `<' depending
1195 : : on the trait. Otherwise, returns nullptr. */
1196 : :
1197 : : static const cp_trait *
1198 : 3095009180 : cp_lexer_peek_trait (cp_lexer *lexer)
1199 : : {
1200 : 3095009180 : const cp_token *token1 = cp_lexer_peek_token (lexer);
1201 : 3095009180 : if (token1->type == CPP_NAME
1202 : 2177800613 : && UNLIKELY (IDENTIFIER_TRAIT_P (token1->u.value)))
1203 : : {
1204 : 5802619 : const cp_trait &trait = cp_traits[IDENTIFIER_CP_INDEX (token1->u.value)];
1205 : 5802619 : const bool is_pack_element = (trait.kind == CPTK_TYPE_PACK_ELEMENT);
1206 : :
1207 : : /* Check if the subsequent token is a `<' token to
1208 : : __type_pack_element or is a `(' token to everything else. */
1209 : 5802619 : const cp_token *token2 = cp_lexer_peek_nth_token (lexer, 2);
1210 : 5802619 : if (is_pack_element && token2->type != CPP_LESS)
1211 : : return nullptr;
1212 : 5789134 : if (!is_pack_element && token2->type != CPP_OPEN_PAREN)
1213 : : return nullptr;
1214 : :
1215 : 5516609 : return &trait;
1216 : : }
1217 : : return nullptr;
1218 : : }
1219 : :
1220 : : /* Similarly, but only if the token is an expression-yielding
1221 : : built-in trait. */
1222 : :
1223 : : static const cp_trait *
1224 : 510915899 : cp_lexer_peek_trait_expr (cp_lexer *lexer)
1225 : : {
1226 : 510915899 : const cp_trait *trait = cp_lexer_peek_trait (lexer);
1227 : 510915899 : if (trait && !trait->type)
1228 : 2185661 : return trait;
1229 : :
1230 : : return nullptr;
1231 : : }
1232 : :
1233 : : /* Similarly, but only if the token is a type-yielding
1234 : : built-in trait. */
1235 : :
1236 : : static const cp_trait *
1237 : 2584093281 : cp_lexer_peek_trait_type (cp_lexer *lexer)
1238 : : {
1239 : 2584093281 : const cp_trait *trait = cp_lexer_peek_trait (lexer);
1240 : 2584093281 : if (trait && trait->type)
1241 : 158463 : return trait;
1242 : :
1243 : : return nullptr;
1244 : : }
1245 : :
1246 : : /* Return true if the next token is a keyword for a decl-specifier. */
1247 : :
1248 : : static bool
1249 : 17593041 : cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
1250 : : {
1251 : 17593041 : cp_token *token;
1252 : :
1253 : 17593041 : if (cp_lexer_peek_trait_type (lexer))
1254 : : return true;
1255 : :
1256 : 17593041 : token = cp_lexer_peek_token (lexer);
1257 : 17593041 : return cp_keyword_starts_decl_specifier_p (token->keyword);
1258 : : }
1259 : :
1260 : : /* Returns TRUE iff the token T begins a decltype type. */
1261 : :
1262 : : static bool
1263 : 5034445069 : token_is_decltype (cp_token *t)
1264 : : {
1265 : 5034445069 : return (t->keyword == RID_DECLTYPE
1266 : 5034364911 : || t->type == CPP_DECLTYPE);
1267 : : }
1268 : :
1269 : : /* Returns TRUE iff the next token begins a decltype type. */
1270 : :
1271 : : static bool
1272 : 424741468 : cp_lexer_next_token_is_decltype (cp_lexer *lexer)
1273 : : {
1274 : 424741468 : cp_token *t = cp_lexer_peek_token (lexer);
1275 : 0 : return token_is_decltype (t);
1276 : : }
1277 : :
1278 : : /* Called when processing a token with tree_check_value; perform or defer the
1279 : : associated checks and return the value. */
1280 : :
1281 : : static tree
1282 : 433437901 : saved_checks_value (struct tree_check *check_value)
1283 : : {
1284 : : /* Perform any access checks that were deferred. */
1285 : 433437901 : vec<deferred_access_check, va_gc> *checks;
1286 : 433437901 : deferred_access_check *chk;
1287 : 433437901 : checks = check_value->checks;
1288 : 433437901 : if (checks)
1289 : : {
1290 : : int i;
1291 : 15805644 : FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
1292 : 8472765 : perform_or_defer_access_check (chk->binfo,
1293 : : chk->decl,
1294 : : chk->diag_decl, tf_warning_or_error);
1295 : : }
1296 : : /* Return the stored value. */
1297 : 433437901 : return check_value->value;
1298 : : }
1299 : :
1300 : : /* Return a pointer to the Nth token in the token stream. If N is 1,
1301 : : then this is precisely equivalent to cp_lexer_peek_token (except
1302 : : that it is not inline). One would like to disallow that case, but
1303 : : there is one case (cp_parser_nth_token_starts_template_id) where
1304 : : the caller passes a variable for N and it might be 1. */
1305 : :
1306 : : static cp_token *
1307 : 19659730879 : cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
1308 : : {
1309 : 19659730879 : cp_token *token;
1310 : :
1311 : : /* N is 1-based, not zero-based. */
1312 : 19659730879 : gcc_assert (n > 0);
1313 : :
1314 : 19659730879 : if (cp_lexer_debugging_p (lexer))
1315 : : fprintf (cp_lexer_debug_stream,
1316 : : "cp_lexer: peeking ahead " HOST_SIZE_T_PRINT_DEC " at token: ",
1317 : : (fmt_size_t) n);
1318 : :
1319 : 19659730879 : --n;
1320 : 19659730879 : token = lexer->next_token;
1321 : 33775280235 : while (n && token->type != CPP_EOF)
1322 : : {
1323 : 14115549356 : ++token;
1324 : 14115549356 : if (!token->purged_p)
1325 : 12919111159 : --n;
1326 : : }
1327 : :
1328 : 19659730879 : if (cp_lexer_debugging_p (lexer))
1329 : : {
1330 : : cp_lexer_print_token (cp_lexer_debug_stream, token);
1331 : : putc ('\n', cp_lexer_debug_stream);
1332 : : }
1333 : :
1334 : 19659730879 : return token;
1335 : : }
1336 : :
1337 : : /* Return the next token, and advance the lexer's next_token pointer
1338 : : to point to the next non-purged token. */
1339 : :
1340 : : static cp_token *
1341 : 13124485524 : cp_lexer_consume_token (cp_lexer* lexer)
1342 : : {
1343 : 13124485524 : cp_token *token = lexer->next_token;
1344 : :
1345 : 15056728654 : do
1346 : : {
1347 : 15056728654 : gcc_assert (token->type != CPP_EOF);
1348 : 15056728654 : lexer->next_token++;
1349 : : }
1350 : 15056728654 : while (lexer->next_token->purged_p);
1351 : :
1352 : 13124485524 : cp_lexer_set_source_position_from_token (token);
1353 : :
1354 : : /* Provide debugging output. */
1355 : 13124485524 : if (cp_lexer_debugging_p (lexer))
1356 : : {
1357 : : fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
1358 : : cp_lexer_print_token (cp_lexer_debug_stream, token);
1359 : : putc ('\n', cp_lexer_debug_stream);
1360 : : }
1361 : :
1362 : 13124485524 : return token;
1363 : : }
1364 : :
1365 : : /* Permanently remove the next token from the token stream, and
1366 : : advance the next_token pointer to refer to the next non-purged
1367 : : token. */
1368 : :
1369 : : static void
1370 : 43 : cp_lexer_purge_token (cp_lexer *lexer)
1371 : : {
1372 : 43 : cp_token *tok = lexer->next_token;
1373 : :
1374 : 43 : gcc_assert (tok->type != CPP_EOF);
1375 : 43 : tok->purged_p = true;
1376 : 43 : tok->location = UNKNOWN_LOCATION;
1377 : 43 : tok->u.value = NULL_TREE;
1378 : 43 : tok->keyword = RID_MAX;
1379 : :
1380 : 43 : do
1381 : 43 : tok++;
1382 : 43 : while (tok->purged_p);
1383 : 43 : lexer->next_token = tok;
1384 : 43 : }
1385 : :
1386 : : /* Permanently remove all tokens after TOK, up to, but not
1387 : : including, the token that will be returned next by
1388 : : cp_lexer_peek_token. */
1389 : :
1390 : : static void
1391 : 320621282 : cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
1392 : : {
1393 : 320621282 : cp_token *peek = lexer->next_token;
1394 : :
1395 : 320621282 : gcc_assert (tok < peek);
1396 : :
1397 : 1671638566 : for (tok++; tok != peek; tok++)
1398 : : {
1399 : 1351017284 : tok->purged_p = true;
1400 : 1351017284 : tok->location = UNKNOWN_LOCATION;
1401 : 1351017284 : tok->u.value = NULL_TREE;
1402 : 1351017284 : tok->keyword = RID_MAX;
1403 : : }
1404 : 320621282 : }
1405 : :
1406 : : /* Begin saving tokens. All tokens consumed after this point will be
1407 : : preserved. */
1408 : :
1409 : : static void
1410 : 13879183149 : cp_lexer_save_tokens (cp_lexer* lexer)
1411 : : {
1412 : : /* Provide debugging output. */
1413 : 13879183149 : if (cp_lexer_debugging_p (lexer))
1414 : : fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
1415 : :
1416 : 0 : lexer->saved_tokens.safe_push (lexer->next_token);
1417 : 0 : }
1418 : :
1419 : : /* Commit to the portion of the token stream most recently saved. */
1420 : :
1421 : : static void
1422 : 3922412458 : cp_lexer_commit_tokens (cp_lexer* lexer)
1423 : : {
1424 : : /* Provide debugging output. */
1425 : 3922412458 : if (cp_lexer_debugging_p (lexer))
1426 : : fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
1427 : :
1428 : 0 : lexer->saved_tokens.pop ();
1429 : 3757884194 : }
1430 : :
1431 : : /* Return all tokens saved since the last call to cp_lexer_save_tokens
1432 : : to the token stream. Stop saving tokens. */
1433 : :
1434 : : static void
1435 : 9956770649 : cp_lexer_rollback_tokens (cp_lexer* lexer)
1436 : : {
1437 : : /* Provide debugging output. */
1438 : 9956770649 : if (cp_lexer_debugging_p (lexer))
1439 : : fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
1440 : :
1441 : 0 : lexer->next_token = lexer->saved_tokens.pop ();
1442 : 6 : }
1443 : :
1444 : : /* Determines what saved_token_sentinel does when going out of scope. */
1445 : :
1446 : : enum saved_token_sentinel_mode {
1447 : : STS_COMMIT,
1448 : : STS_ROLLBACK,
1449 : : STS_DONOTHING
1450 : : };
1451 : :
1452 : : /* RAII wrapper around the above functions, with sanity checking (the token
1453 : : stream should be the same at the point of instantiation as it is at the
1454 : : point of destruction).
1455 : :
1456 : : Creating a variable saves tokens. MODE determines what happens when the
1457 : : object is destroyed. STS_COMMIT commits tokens (default),
1458 : : STS_ROLLBACK rolls-back and STS_DONOTHING does nothing. Calling
1459 : : rollback() will immediately roll-back tokens and set MODE to
1460 : : STS_DONOTHING. */
1461 : :
1462 : : struct saved_token_sentinel
1463 : : {
1464 : : cp_lexer *lexer;
1465 : : unsigned len;
1466 : : saved_token_sentinel_mode mode;
1467 : 286623432 : saved_token_sentinel (cp_lexer *_lexer,
1468 : : saved_token_sentinel_mode _mode = STS_COMMIT)
1469 : 286623432 : : lexer (_lexer), mode (_mode)
1470 : : {
1471 : 286623432 : len = lexer->saved_tokens.length ();
1472 : 286623432 : cp_lexer_save_tokens (lexer);
1473 : 286623432 : }
1474 : 328557 : void rollback ()
1475 : : {
1476 : 328557 : cp_lexer_rollback_tokens (lexer);
1477 : 328557 : cp_lexer_set_source_position_from_token
1478 : 328557 : (cp_lexer_previous_token (lexer));
1479 : 328557 : mode = STS_DONOTHING;
1480 : 328557 : }
1481 : 286623408 : ~saved_token_sentinel ()
1482 : : {
1483 : 286623408 : if (mode == STS_COMMIT)
1484 : 286294836 : cp_lexer_commit_tokens (lexer);
1485 : 328572 : else if (mode == STS_ROLLBACK)
1486 : 109719 : rollback ();
1487 : :
1488 : 573246816 : gcc_assert (lexer->saved_tokens.length () == len);
1489 : 286623408 : }
1490 : : };
1491 : :
1492 : : /* Print a representation of the TOKEN on the STREAM. */
1493 : :
1494 : : static void
1495 : 0 : cp_lexer_print_token (FILE * stream, cp_token *token)
1496 : : {
1497 : : /* We don't use cpp_type2name here because the parser defines
1498 : : a few tokens of its own. */
1499 : 0 : static const char *const token_names[] = {
1500 : : /* cpplib-defined token types */
1501 : : #define OP(e, s) #e,
1502 : : #define TK(e, s) #e,
1503 : : TTYPE_TABLE
1504 : : #undef OP
1505 : : #undef TK
1506 : : /* C++ parser token types - see "Manifest constants", above. */
1507 : : "KEYWORD",
1508 : : "TEMPLATE_ID",
1509 : : "NESTED_NAME_SPECIFIER",
1510 : : };
1511 : :
1512 : : /* For some tokens, print the associated data. */
1513 : 0 : switch (token->type)
1514 : : {
1515 : 0 : case CPP_KEYWORD:
1516 : : /* Some keywords have a value that is not an IDENTIFIER_NODE.
1517 : : For example, `struct' is mapped to an INTEGER_CST. */
1518 : 0 : if (!identifier_p (token->u.value))
1519 : : break;
1520 : : /* fall through */
1521 : 0 : case CPP_NAME:
1522 : 0 : fputs (IDENTIFIER_POINTER (token->u.value), stream);
1523 : 0 : break;
1524 : :
1525 : 0 : case CPP_STRING:
1526 : 0 : case CPP_STRING16:
1527 : 0 : case CPP_STRING32:
1528 : 0 : case CPP_WSTRING:
1529 : 0 : case CPP_UTF8STRING:
1530 : 0 : fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
1531 : 0 : break;
1532 : :
1533 : 0 : case CPP_NUMBER:
1534 : 0 : print_generic_expr (stream, token->u.value);
1535 : 0 : break;
1536 : :
1537 : 0 : default:
1538 : : /* If we have a name for the token, print it out. Otherwise, we
1539 : : simply give the numeric code. */
1540 : 0 : if (token->type < ARRAY_SIZE(token_names))
1541 : 0 : fputs (token_names[token->type], stream);
1542 : : else
1543 : 0 : fprintf (stream, "[%d]", token->type);
1544 : : break;
1545 : : }
1546 : 0 : }
1547 : :
1548 : : DEBUG_FUNCTION void
1549 : 0 : debug (cp_token &ref)
1550 : : {
1551 : 0 : cp_lexer_print_token (stderr, &ref);
1552 : 0 : fprintf (stderr, "\n");
1553 : 0 : }
1554 : :
1555 : : DEBUG_FUNCTION void
1556 : 0 : debug (cp_token *ptr)
1557 : : {
1558 : 0 : if (ptr)
1559 : 0 : debug (*ptr);
1560 : : else
1561 : 0 : fprintf (stderr, "<nil>\n");
1562 : 0 : }
1563 : :
1564 : :
1565 : : /* Start emitting debugging information. */
1566 : :
1567 : : static void
1568 : 0 : cp_lexer_start_debugging (cp_lexer* lexer)
1569 : : {
1570 : 0 : if (!LEXER_DEBUGGING_ENABLED_P)
1571 : 0 : fatal_error (input_location,
1572 : : "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");
1573 : :
1574 : : lexer->debugging_p = true;
1575 : : cp_lexer_debug_stream = stderr;
1576 : : }
1577 : :
1578 : : /* Stop emitting debugging information. */
1579 : :
1580 : : static void
1581 : 0 : cp_lexer_stop_debugging (cp_lexer* lexer)
1582 : : {
1583 : 0 : if (!LEXER_DEBUGGING_ENABLED_P)
1584 : 0 : fatal_error (input_location,
1585 : : "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");
1586 : :
1587 : : lexer->debugging_p = false;
1588 : : cp_lexer_debug_stream = NULL;
1589 : : }
1590 : :
1591 : : /* Create a new cp_token_cache, representing a range of tokens. */
1592 : :
1593 : : static cp_token_cache *
1594 : 72609237 : cp_token_cache_new (cp_token *first, cp_token *last)
1595 : : {
1596 : 0 : cp_token_cache *cache = ggc_alloc<cp_token_cache> ();
1597 : 72609237 : cache->first = first;
1598 : 72609237 : cache->last = last;
1599 : 72609237 : return cache;
1600 : : }
1601 : :
1602 : : /* Diagnose if #pragma omp declare simd isn't followed immediately
1603 : : by function declaration or definition. */
1604 : :
1605 : : static inline void
1606 : 31823844 : cp_ensure_no_omp_declare_simd (cp_parser *parser)
1607 : : {
1608 : 31823844 : if (parser->omp_declare_simd && !parser->omp_declare_simd->error_seen)
1609 : : {
1610 : 81 : error ("%<#pragma omp declare %s%> not immediately followed by "
1611 : : "function declaration or definition",
1612 : 81 : parser->omp_declare_simd->variant_p ? "variant" : "simd");
1613 : 81 : parser->omp_declare_simd = NULL;
1614 : : }
1615 : 31823844 : }
1616 : :
1617 : : /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1618 : : and put that into "omp declare simd" attribute. */
1619 : :
1620 : : static inline void
1621 : 264038077 : cp_finalize_omp_declare_simd (cp_parser *parser, tree fndecl)
1622 : : {
1623 : 264038077 : if (UNLIKELY (parser->omp_declare_simd != NULL))
1624 : : {
1625 : 1848 : if (fndecl == error_mark_node)
1626 : : {
1627 : 0 : parser->omp_declare_simd = NULL;
1628 : 0 : return;
1629 : : }
1630 : 1848 : if (TREE_CODE (fndecl) != FUNCTION_DECL)
1631 : : {
1632 : 36 : cp_ensure_no_omp_declare_simd (parser);
1633 : 36 : return;
1634 : : }
1635 : : }
1636 : : }
1637 : :
1638 : : /* Similarly, but for use in declaration parsing functions
1639 : : which call cp_parser_handle_directive_omp_attributes. */
1640 : :
1641 : : static inline void
1642 : 548971794 : cp_finalize_omp_declare_simd (cp_parser *parser, cp_omp_declare_simd_data *data)
1643 : : {
1644 : 548971794 : if (parser->omp_declare_simd != data)
1645 : : return;
1646 : :
1647 : 177 : if (!parser->omp_declare_simd->error_seen
1648 : 177 : && !parser->omp_declare_simd->fndecl_seen)
1649 : 3 : error_at (parser->omp_declare_simd->loc,
1650 : : "%<declare %s%> directive not immediately followed by "
1651 : : "function declaration or definition",
1652 : 3 : parser->omp_declare_simd->variant_p ? "variant" : "simd");
1653 : 177 : parser->omp_declare_simd = NULL;
1654 : : }
1655 : :
1656 : : /* Diagnose if #pragma acc routine isn't followed immediately by function
1657 : : declaration or definition. */
1658 : :
1659 : : static inline void
1660 : 29693847 : cp_ensure_no_oacc_routine (cp_parser *parser)
1661 : : {
1662 : 29693847 : if (parser->oacc_routine && !parser->oacc_routine->error_seen)
1663 : : {
1664 : 66 : error_at (parser->oacc_routine->loc,
1665 : : "%<#pragma acc routine%> not immediately followed by "
1666 : : "function declaration or definition");
1667 : 66 : parser->oacc_routine = NULL;
1668 : : }
1669 : 29693847 : }
1670 : :
1671 : : /* Decl-specifiers. */
1672 : :
1673 : : /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1674 : :
1675 : : static void
1676 : 1090877909 : clear_decl_specs (cp_decl_specifier_seq *decl_specs)
1677 : : {
1678 : 1090877909 : memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
1679 : 90892 : }
1680 : :
1681 : : /* Declarators. */
1682 : :
1683 : : /* Nothing other than the parser should be creating declarators;
1684 : : declarators are a semi-syntactic representation of C++ entities.
1685 : : Other parts of the front end that need to create entities (like
1686 : : VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1687 : :
1688 : : static cp_declarator *make_call_declarator
1689 : : (cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, cp_ref_qualifier,
1690 : : tree, tree, tree, tree, tree, location_t);
1691 : : static cp_declarator *make_array_declarator
1692 : : (cp_declarator *, tree, tree);
1693 : : static cp_declarator *make_pointer_declarator
1694 : : (cp_cv_quals, cp_declarator *, tree);
1695 : : static cp_declarator *make_reference_declarator
1696 : : (cp_cv_quals, cp_declarator *, bool, tree);
1697 : : static cp_declarator *make_ptrmem_declarator
1698 : : (cp_cv_quals, tree, cp_declarator *, tree);
1699 : :
1700 : : /* An erroneous declarator. */
1701 : : static cp_declarator *cp_error_declarator;
1702 : :
1703 : : /* The obstack on which declarators and related data structures are
1704 : : allocated. */
1705 : : static struct obstack declarator_obstack;
1706 : :
1707 : : /* Alloc BYTES from the declarator memory pool. */
1708 : :
1709 : : static inline void *
1710 : 1114467700 : alloc_declarator (size_t bytes)
1711 : : {
1712 : 1114467700 : return obstack_alloc (&declarator_obstack, bytes);
1713 : : }
1714 : :
1715 : : /* Allocate a declarator of the indicated KIND. Clear fields that are
1716 : : common to all declarators. */
1717 : :
1718 : : static cp_declarator *
1719 : 847949945 : make_declarator (cp_declarator_kind kind)
1720 : : {
1721 : 847949945 : cp_declarator *declarator;
1722 : :
1723 : 847949945 : declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
1724 : 847949945 : declarator->kind = kind;
1725 : 847949945 : declarator->parenthesized = UNKNOWN_LOCATION;
1726 : 847949945 : declarator->attributes = NULL_TREE;
1727 : 847949945 : declarator->std_attributes = NULL_TREE;
1728 : 847949945 : declarator->declarator = NULL;
1729 : 847949945 : declarator->parameter_pack_p = false;
1730 : 847949945 : declarator->id_loc = UNKNOWN_LOCATION;
1731 : 847949945 : declarator->init_loc = UNKNOWN_LOCATION;
1732 : :
1733 : 847949945 : return declarator;
1734 : : }
1735 : :
1736 : : /* Make a declarator for a generalized identifier. If
1737 : : QUALIFYING_SCOPE is non-NULL, the identifier is
1738 : : QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1739 : : UNQUALIFIED_NAME. SFK indicates the kind of special function this
1740 : : is, if any. */
1741 : :
1742 : : static cp_declarator *
1743 : 506963209 : make_id_declarator (tree qualifying_scope, tree unqualified_name,
1744 : : special_function_kind sfk, location_t id_location)
1745 : : {
1746 : 506963209 : cp_declarator *declarator;
1747 : :
1748 : : /* It is valid to write:
1749 : :
1750 : : class C { void f(); };
1751 : : typedef C D;
1752 : : void D::f();
1753 : :
1754 : : The standard is not clear about whether `typedef const C D' is
1755 : : legal; as of 2002-09-15 the committee is considering that
1756 : : question. EDG 3.0 allows that syntax. Therefore, we do as
1757 : : well. */
1758 : 506963209 : if (qualifying_scope && TYPE_P (qualifying_scope))
1759 : 9239039 : qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
1760 : :
1761 : 506963209 : gcc_assert (identifier_p (unqualified_name)
1762 : : || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
1763 : : || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
1764 : :
1765 : 506963209 : declarator = make_declarator (cdk_id);
1766 : 506963209 : declarator->u.id.qualifying_scope = qualifying_scope;
1767 : 506963209 : declarator->u.id.unqualified_name = unqualified_name;
1768 : 506963209 : declarator->u.id.sfk = sfk;
1769 : 506963209 : declarator->id_loc = id_location;
1770 : :
1771 : 506963209 : return declarator;
1772 : : }
1773 : :
1774 : : /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1775 : : of modifiers such as const or volatile to apply to the pointer
1776 : : type, represented as identifiers. ATTRIBUTES represent the attributes that
1777 : : appertain to the pointer or reference. */
1778 : :
1779 : : cp_declarator *
1780 : 59404448 : make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1781 : : tree attributes)
1782 : : {
1783 : 59404448 : cp_declarator *declarator;
1784 : :
1785 : 59404448 : declarator = make_declarator (cdk_pointer);
1786 : 59404448 : declarator->declarator = target;
1787 : 59404448 : declarator->u.pointer.qualifiers = cv_qualifiers;
1788 : 59404448 : declarator->u.pointer.class_type = NULL_TREE;
1789 : 59404448 : if (target)
1790 : : {
1791 : 50472367 : declarator->id_loc = target->id_loc;
1792 : 50472367 : declarator->parameter_pack_p = target->parameter_pack_p;
1793 : 50472367 : target->parameter_pack_p = false;
1794 : : }
1795 : : else
1796 : 8932081 : declarator->parameter_pack_p = false;
1797 : :
1798 : 59404448 : declarator->std_attributes = attributes;
1799 : :
1800 : 59404448 : return declarator;
1801 : : }
1802 : :
1803 : : /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1804 : : represent the attributes that appertain to the pointer or
1805 : : reference. */
1806 : :
1807 : : cp_declarator *
1808 : 111252965 : make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1809 : : bool rvalue_ref, tree attributes)
1810 : : {
1811 : 111252965 : cp_declarator *declarator;
1812 : :
1813 : 111252965 : declarator = make_declarator (cdk_reference);
1814 : 111252965 : declarator->declarator = target;
1815 : 111252965 : declarator->u.reference.qualifiers = cv_qualifiers;
1816 : 111252965 : declarator->u.reference.rvalue_ref = rvalue_ref;
1817 : 111252965 : if (target)
1818 : : {
1819 : 87202267 : declarator->id_loc = target->id_loc;
1820 : 87202267 : declarator->parameter_pack_p = target->parameter_pack_p;
1821 : 87202267 : target->parameter_pack_p = false;
1822 : : }
1823 : : else
1824 : 24050698 : declarator->parameter_pack_p = false;
1825 : :
1826 : 111252965 : declarator->std_attributes = attributes;
1827 : :
1828 : 111252965 : return declarator;
1829 : : }
1830 : :
1831 : : /* Like make_pointer_declarator -- but for a pointer to a non-static
1832 : : member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1833 : : appertain to the pointer or reference. */
1834 : :
1835 : : cp_declarator *
1836 : 1158240 : make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
1837 : : cp_declarator *pointee,
1838 : : tree attributes)
1839 : : {
1840 : 1158240 : cp_declarator *declarator;
1841 : :
1842 : 1158240 : declarator = make_declarator (cdk_ptrmem);
1843 : 1158240 : declarator->declarator = pointee;
1844 : 1158240 : declarator->u.pointer.qualifiers = cv_qualifiers;
1845 : 1158240 : declarator->u.pointer.class_type = class_type;
1846 : :
1847 : 1158240 : if (pointee)
1848 : : {
1849 : 371568 : declarator->parameter_pack_p = pointee->parameter_pack_p;
1850 : 371568 : pointee->parameter_pack_p = false;
1851 : : }
1852 : : else
1853 : 786672 : declarator->parameter_pack_p = false;
1854 : :
1855 : 1158240 : declarator->std_attributes = attributes;
1856 : :
1857 : 1158240 : return declarator;
1858 : : }
1859 : :
1860 : : /* Make a declarator for the function given by TARGET, with the
1861 : : indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1862 : : "const"-qualified member function. The EXCEPTION_SPECIFICATION
1863 : : indicates what exceptions can be thrown. STD_ATTRS contains
1864 : : attributes that appertain to the function type. */
1865 : :
1866 : : cp_declarator *
1867 : 165844662 : make_call_declarator (cp_declarator *target,
1868 : : tree parms,
1869 : : cp_cv_quals cv_qualifiers,
1870 : : cp_virt_specifiers virt_specifiers,
1871 : : cp_ref_qualifier ref_qualifier,
1872 : : tree tx_qualifier,
1873 : : tree exception_specification,
1874 : : tree late_return_type,
1875 : : tree requires_clause,
1876 : : tree std_attrs,
1877 : : location_t parens_loc)
1878 : : {
1879 : 165844662 : cp_declarator *declarator;
1880 : :
1881 : 165844662 : declarator = make_declarator (cdk_function);
1882 : 165844662 : declarator->declarator = target;
1883 : 165844662 : declarator->u.function.parameters = parms;
1884 : 165844662 : declarator->u.function.qualifiers = cv_qualifiers;
1885 : 165844662 : declarator->u.function.virt_specifiers = virt_specifiers;
1886 : 165844662 : declarator->u.function.ref_qualifier = ref_qualifier;
1887 : 165844662 : declarator->u.function.tx_qualifier = tx_qualifier;
1888 : 165844662 : declarator->u.function.exception_specification = exception_specification;
1889 : 165844662 : declarator->u.function.late_return_type = late_return_type;
1890 : 165844662 : declarator->u.function.requires_clause = requires_clause;
1891 : 165844662 : declarator->u.function.parens_loc = parens_loc;
1892 : 165844662 : if (target)
1893 : : {
1894 : 165361585 : declarator->id_loc = target->id_loc;
1895 : 165361585 : declarator->parameter_pack_p = target->parameter_pack_p;
1896 : 165361585 : target->parameter_pack_p = false;
1897 : : }
1898 : : else
1899 : 483077 : declarator->parameter_pack_p = false;
1900 : :
1901 : 165844662 : declarator->std_attributes = std_attrs;
1902 : :
1903 : 165844662 : return declarator;
1904 : : }
1905 : :
1906 : : /* Make a declarator for an array of BOUNDS elements, each of which is
1907 : : defined by ELEMENT. STD_ATTRS contains attributes that appertain to
1908 : : the array type. */
1909 : :
1910 : : cp_declarator *
1911 : 3176024 : make_array_declarator (cp_declarator *element, tree bounds, tree std_attrs)
1912 : : {
1913 : 3176024 : cp_declarator *declarator;
1914 : :
1915 : 3176024 : declarator = make_declarator (cdk_array);
1916 : 3176024 : declarator->declarator = element;
1917 : 3176024 : declarator->u.array.bounds = bounds;
1918 : 3176024 : if (element)
1919 : : {
1920 : 2711851 : declarator->id_loc = element->id_loc;
1921 : 2711851 : declarator->parameter_pack_p = element->parameter_pack_p;
1922 : 2711851 : element->parameter_pack_p = false;
1923 : : }
1924 : : else
1925 : 464173 : declarator->parameter_pack_p = false;
1926 : :
1927 : 3176024 : declarator->std_attributes = std_attrs;
1928 : :
1929 : 3176024 : return declarator;
1930 : : }
1931 : :
1932 : : /* Determine whether the declarator we've seen so far can be a
1933 : : parameter pack, when followed by an ellipsis. */
1934 : : static bool
1935 : 1401014 : declarator_can_be_parameter_pack (cp_declarator *declarator)
1936 : : {
1937 : 1401014 : if (declarator && declarator->parameter_pack_p)
1938 : : /* We already saw an ellipsis. */
1939 : : return false;
1940 : :
1941 : : /* Search for a declarator name, or any other declarator that goes
1942 : : after the point where the ellipsis could appear in a parameter
1943 : : pack. If we find any of these, then this declarator cannot be
1944 : : made into a parameter pack. */
1945 : : bool found = false;
1946 : 1539254 : while (declarator && !found)
1947 : : {
1948 : 138240 : switch ((int)declarator->kind)
1949 : : {
1950 : : case cdk_id:
1951 : : case cdk_array:
1952 : : case cdk_decomp:
1953 : : found = true;
1954 : : break;
1955 : :
1956 : : case cdk_error:
1957 : : return true;
1958 : :
1959 : 138237 : default:
1960 : 138237 : declarator = declarator->declarator;
1961 : 138237 : break;
1962 : : }
1963 : : }
1964 : :
1965 : : return !found;
1966 : : }
1967 : :
1968 : : cp_parameter_declarator *no_parameters;
1969 : :
1970 : : /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1971 : : DECLARATOR and DEFAULT_ARGUMENT. */
1972 : :
1973 : : cp_parameter_declarator *
1974 : 266517755 : make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1975 : : cp_declarator *declarator,
1976 : : tree default_argument,
1977 : : location_t loc,
1978 : : bool template_parameter_pack_p = false)
1979 : : {
1980 : 266517755 : cp_parameter_declarator *parameter;
1981 : :
1982 : 266517755 : parameter = ((cp_parameter_declarator *)
1983 : 266517755 : alloc_declarator (sizeof (cp_parameter_declarator)));
1984 : 266517755 : parameter->next = NULL;
1985 : 266517755 : if (decl_specifiers)
1986 : 266426863 : parameter->decl_specifiers = *decl_specifiers;
1987 : : else
1988 : 90892 : clear_decl_specs (¶meter->decl_specifiers);
1989 : 266517755 : parameter->declarator = declarator;
1990 : 266517755 : parameter->default_argument = default_argument;
1991 : 266517755 : parameter->template_parameter_pack_p = template_parameter_pack_p;
1992 : 266517755 : parameter->loc = loc;
1993 : :
1994 : 266517755 : return parameter;
1995 : : }
1996 : :
1997 : : /* Returns true iff DECLARATOR is a declaration for a function. */
1998 : :
1999 : : static bool
2000 : 407224804 : function_declarator_p (const cp_declarator *declarator)
2001 : : {
2002 : 458475629 : while (declarator)
2003 : : {
2004 : 458475629 : if (declarator->kind == cdk_function
2005 : 181972284 : && declarator->declarator->kind == cdk_id)
2006 : : return true;
2007 : 276731659 : if (declarator->kind == cdk_id
2008 : 51250825 : || declarator->kind == cdk_decomp
2009 : 51250825 : || declarator->kind == cdk_error)
2010 : : return false;
2011 : 51250825 : declarator = declarator->declarator;
2012 : : }
2013 : : return false;
2014 : : }
2015 : :
2016 : : /* The parser. */
2017 : :
2018 : : /* Overview
2019 : : --------
2020 : :
2021 : : A cp_parser parses the token stream as specified by the C++
2022 : : grammar. Its job is purely parsing, not semantic analysis. For
2023 : : example, the parser breaks the token stream into declarators,
2024 : : expressions, statements, and other similar syntactic constructs.
2025 : : It does not check that the types of the expressions on either side
2026 : : of an assignment-statement are compatible, or that a function is
2027 : : not declared with a parameter of type `void'.
2028 : :
2029 : : The parser invokes routines elsewhere in the compiler to perform
2030 : : semantic analysis and to build up the abstract syntax tree for the
2031 : : code processed.
2032 : :
2033 : : The parser (and the template instantiation code, which is, in a
2034 : : way, a close relative of parsing) are the only parts of the
2035 : : compiler that should be calling push_scope and pop_scope, or
2036 : : related functions. The parser (and template instantiation code)
2037 : : keeps track of what scope is presently active; everything else
2038 : : should simply honor that. (The code that generates static
2039 : : initializers may also need to set the scope, in order to check
2040 : : access control correctly when emitting the initializers.)
2041 : :
2042 : : Methodology
2043 : : -----------
2044 : :
2045 : : The parser is of the standard recursive-descent variety. Upcoming
2046 : : tokens in the token stream are examined in order to determine which
2047 : : production to use when parsing a non-terminal. Some C++ constructs
2048 : : require arbitrary look ahead to disambiguate. For example, it is
2049 : : impossible, in the general case, to tell whether a statement is an
2050 : : expression or declaration without scanning the entire statement.
2051 : : Therefore, the parser is capable of "parsing tentatively." When the
2052 : : parser is not sure what construct comes next, it enters this mode.
2053 : : Then, while we attempt to parse the construct, the parser queues up
2054 : : error messages, rather than issuing them immediately, and saves the
2055 : : tokens it consumes. If the construct is parsed successfully, the
2056 : : parser "commits", i.e., it issues any queued error messages and
2057 : : the tokens that were being preserved are permanently discarded.
2058 : : If, however, the construct is not parsed successfully, the parser
2059 : : rolls back its state completely so that it can resume parsing using
2060 : : a different alternative.
2061 : :
2062 : : Future Improvements
2063 : : -------------------
2064 : :
2065 : : The performance of the parser could probably be improved substantially.
2066 : : We could often eliminate the need to parse tentatively by looking ahead
2067 : : a little bit. In some places, this approach might not entirely eliminate
2068 : : the need to parse tentatively, but it might still speed up the average
2069 : : case. */
2070 : :
2071 : : /* Flags that are passed to some parsing functions. These values can
2072 : : be bitwise-ored together. */
2073 : :
2074 : : enum
2075 : : {
2076 : : /* No flags. */
2077 : : CP_PARSER_FLAGS_NONE = 0x0,
2078 : : /* The construct is optional. If it is not present, then no error
2079 : : should be issued. */
2080 : : CP_PARSER_FLAGS_OPTIONAL = 0x1,
2081 : : /* When parsing a type-specifier, treat user-defined type-names
2082 : : as non-type identifiers. */
2083 : : CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2,
2084 : : /* When parsing a type-specifier, do not try to parse a class-specifier
2085 : : or enum-specifier. */
2086 : : CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS = 0x4,
2087 : : /* When parsing a decl-specifier-seq, only allow type-specifier or
2088 : : constexpr. */
2089 : : CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8,
2090 : : /* When parsing a decl-specifier-seq, only allow mutable, constexpr or
2091 : : for C++20 consteval or for C++23 static. */
2092 : : CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR = 0x10,
2093 : : /* When parsing a decl-specifier-seq, allow missing typename. */
2094 : : CP_PARSER_FLAGS_TYPENAME_OPTIONAL = 0x20,
2095 : : /* When parsing of the noexcept-specifier should be delayed. */
2096 : : CP_PARSER_FLAGS_DELAY_NOEXCEPT = 0x40,
2097 : : /* When parsing a consteval declarator. */
2098 : : CP_PARSER_FLAGS_CONSTEVAL = 0x80,
2099 : : /* When parsing a parameter declaration. */
2100 : : CP_PARSER_FLAGS_PARAMETER = 0x100
2101 : : };
2102 : :
2103 : : /* This type is used for parameters and variables which hold
2104 : : combinations of the above flags. */
2105 : : typedef int cp_parser_flags;
2106 : :
2107 : : /* The different kinds of declarators we want to parse. */
2108 : :
2109 : : enum cp_parser_declarator_kind
2110 : : {
2111 : : /* We want an abstract declarator. */
2112 : : CP_PARSER_DECLARATOR_ABSTRACT,
2113 : : /* We want a named declarator. */
2114 : : CP_PARSER_DECLARATOR_NAMED,
2115 : : /* We don't mind, but the name must be an unqualified-id. */
2116 : : CP_PARSER_DECLARATOR_EITHER
2117 : : };
2118 : :
2119 : : /* The precedence values used to parse binary expressions. The minimum value
2120 : : of PREC must be 1, because zero is reserved to quickly discriminate
2121 : : binary operators from other tokens. */
2122 : :
2123 : : enum cp_parser_prec
2124 : : {
2125 : : PREC_NOT_OPERATOR,
2126 : : PREC_LOGICAL_OR_EXPRESSION,
2127 : : PREC_LOGICAL_AND_EXPRESSION,
2128 : : PREC_INCLUSIVE_OR_EXPRESSION,
2129 : : PREC_EXCLUSIVE_OR_EXPRESSION,
2130 : : PREC_AND_EXPRESSION,
2131 : : PREC_EQUALITY_EXPRESSION,
2132 : : PREC_RELATIONAL_EXPRESSION,
2133 : : PREC_SPACESHIP_EXPRESSION,
2134 : : PREC_SHIFT_EXPRESSION,
2135 : : PREC_ADDITIVE_EXPRESSION,
2136 : : PREC_MULTIPLICATIVE_EXPRESSION,
2137 : : PREC_PM_EXPRESSION,
2138 : : NUM_PREC_VALUES = PREC_PM_EXPRESSION
2139 : : };
2140 : :
2141 : : /* A mapping from a token type to a corresponding tree node type, with a
2142 : : precedence value. */
2143 : :
2144 : : struct cp_parser_binary_operations_map_node
2145 : : {
2146 : : /* The token type. */
2147 : : enum cpp_ttype token_type;
2148 : : /* The corresponding tree code. */
2149 : : enum tree_code tree_type;
2150 : : /* The precedence of this operator. */
2151 : : enum cp_parser_prec prec;
2152 : : };
2153 : :
2154 : 9070395156 : struct cp_parser_expression_stack_entry
2155 : : {
2156 : : /* Left hand side of the binary operation we are currently
2157 : : parsing. */
2158 : : cp_expr lhs;
2159 : : /* Original tree code for left hand side, if it was a binary
2160 : : expression itself (used for -Wparentheses). */
2161 : : enum tree_code lhs_type;
2162 : : /* Tree code for the binary operation we are parsing. */
2163 : : enum tree_code tree_type;
2164 : : /* Precedence of the binary operation we are parsing. */
2165 : : enum cp_parser_prec prec;
2166 : : /* Location of the binary operation we are parsing. */
2167 : : location_t loc;
2168 : : /* Flags from the operator token. */
2169 : : unsigned char flags;
2170 : : };
2171 : :
2172 : : /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
2173 : : entries because precedence levels on the stack are monotonically
2174 : : increasing. */
2175 : : typedef struct cp_parser_expression_stack_entry
2176 : : cp_parser_expression_stack[NUM_PREC_VALUES];
2177 : :
2178 : : /* Used for parsing OMP for loops.
2179 : :
2180 : : Some notes on flags used for context:
2181 : : parser->omp_for_parse_state is non-null anywhere inside the OMP FOR
2182 : : construct, except for the final-loop-body.
2183 : : The want_nested_loop flag is true if inside a {} sequence where
2184 : : a loop-nest (or another {} sequence containing a loop-nest) is expected,
2185 : : but has not yet been seen. It's false when parsing intervening code
2186 : : statements or their substatements that cannot contain a loop-nest.
2187 : : The in_intervening_code flag is true when parsing any intervening code,
2188 : : including substatements, and whether or not want_nested_loop is true.
2189 : :
2190 : : And, about error handling:
2191 : : The saw_intervening_code flag is set if the loop is not perfectly
2192 : : nested, even in the usual case where this is not an error.
2193 : : perfect_nesting_fail is set if an error has been diagnosed because an
2194 : : imperfectly-nested loop was found where a perfectly-nested one is
2195 : : required (we diagnose this only once).
2196 : : fail is set if any kind of structural error in the loop nest
2197 : : has been found and diagnosed.
2198 : : */
2199 : : struct omp_for_parse_data {
2200 : : enum tree_code code;
2201 : : tree declv, condv, incrv, initv;
2202 : : tree pre_body;
2203 : : tree orig_declv;
2204 : : auto_vec<tree, 4> orig_inits;
2205 : : int count; /* Expected nesting depth. */
2206 : : int depth; /* Current nesting depth. */
2207 : : location_t for_loc;
2208 : : releasing_vec init_blockv;
2209 : : releasing_vec body_blockv;
2210 : : releasing_vec init_placeholderv;
2211 : : releasing_vec body_placeholderv;
2212 : : bool ordered : 1;
2213 : : bool inscan : 1;
2214 : : bool want_nested_loop : 1;
2215 : : bool in_intervening_code : 1;
2216 : : bool saw_intervening_code : 1;
2217 : : bool perfect_nesting_fail : 1;
2218 : : bool fail : 1;
2219 : : tree clauses;
2220 : : tree *cclauses;
2221 : : tree ordered_cl;
2222 : : };
2223 : :
2224 : : /* Prototypes. */
2225 : :
2226 : : /* Constructors and destructors. */
2227 : :
2228 : : static cp_parser_context *cp_parser_context_new
2229 : : (cp_parser_context *);
2230 : :
2231 : : /* Class variables. */
2232 : :
2233 : : static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
2234 : :
2235 : : /* The operator-precedence table used by cp_parser_binary_expression.
2236 : : Transformed into an associative array (binops_by_token) by
2237 : : cp_parser_new. */
2238 : :
2239 : : static const cp_parser_binary_operations_map_node binops[] = {
2240 : : { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
2241 : : { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
2242 : :
2243 : : { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
2244 : : { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
2245 : : { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
2246 : :
2247 : : { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
2248 : : { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
2249 : :
2250 : : { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
2251 : : { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
2252 : :
2253 : : { CPP_SPACESHIP, SPACESHIP_EXPR, PREC_SPACESHIP_EXPRESSION },
2254 : :
2255 : : { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
2256 : : { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
2257 : : { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
2258 : : { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
2259 : :
2260 : : { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
2261 : : { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
2262 : :
2263 : : { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
2264 : :
2265 : : { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
2266 : :
2267 : : { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
2268 : :
2269 : : { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
2270 : :
2271 : : { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
2272 : : };
2273 : :
2274 : : /* The same as binops, but initialized by cp_parser_new so that
2275 : : binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
2276 : : for speed. */
2277 : : static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
2278 : :
2279 : : /* Constructors and destructors. */
2280 : :
2281 : : /* Construct a new context. The context below this one on the stack
2282 : : is given by NEXT. */
2283 : :
2284 : : static cp_parser_context *
2285 : 13480640479 : cp_parser_context_new (cp_parser_context* next)
2286 : : {
2287 : 13480640479 : cp_parser_context *context;
2288 : :
2289 : : /* Allocate the storage. */
2290 : 13480640479 : if (cp_parser_context_free_list != NULL)
2291 : : {
2292 : : /* Pull the first entry from the free list. */
2293 : 13477468843 : context = cp_parser_context_free_list;
2294 : 13477468843 : cp_parser_context_free_list = context->next;
2295 : 13477468843 : memset (context, 0, sizeof (*context));
2296 : : }
2297 : : else
2298 : 3171636 : context = ggc_cleared_alloc<cp_parser_context> ();
2299 : :
2300 : : /* No errors have occurred yet in this context. */
2301 : 13480640479 : context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
2302 : : /* If this is not the bottommost context, copy information that we
2303 : : need from the previous context. */
2304 : 13480640479 : if (next)
2305 : : {
2306 : : /* If, in the NEXT context, we are parsing an `x->' or `x.'
2307 : : expression, then we are parsing one in this context, too. */
2308 : 13480548430 : context->object_type = next->object_type;
2309 : : /* Thread the stack. */
2310 : 13480548430 : context->next = next;
2311 : : }
2312 : :
2313 : 13480640479 : return context;
2314 : : }
2315 : :
2316 : : /* Managing the unparsed function queues. */
2317 : :
2318 : : #define unparsed_funs_with_default_args \
2319 : : parser->unparsed_queues->last ().funs_with_default_args
2320 : : #define unparsed_funs_with_definitions \
2321 : : parser->unparsed_queues->last ().funs_with_definitions
2322 : : #define unparsed_nsdmis \
2323 : : parser->unparsed_queues->last ().nsdmis
2324 : : #define unparsed_noexcepts \
2325 : : parser->unparsed_queues->last ().noexcepts
2326 : : #define unparsed_contracts \
2327 : : parser->unparsed_queues->last ().contracts
2328 : :
2329 : : static void
2330 : 88717119 : push_unparsed_function_queues (cp_parser *parser)
2331 : : {
2332 : 88717119 : cp_unparsed_functions_entry e
2333 : 88717119 : = { NULL, make_tree_vector (), NULL, NULL, NULL };
2334 : 88717119 : vec_safe_push (parser->unparsed_queues, e);
2335 : 88717119 : }
2336 : :
2337 : : static void
2338 : 88625070 : pop_unparsed_function_queues (cp_parser *parser)
2339 : : {
2340 : 88625070 : release_tree_vector (unparsed_funs_with_definitions);
2341 : 88625070 : parser->unparsed_queues->pop ();
2342 : 88625070 : }
2343 : :
2344 : : /* Prototypes. */
2345 : :
2346 : : /* Routines to parse various constructs.
2347 : :
2348 : : Those that return `tree' will return the error_mark_node (rather
2349 : : than NULL_TREE) if a parse error occurs, unless otherwise noted.
2350 : : Sometimes, they will return an ordinary node if error-recovery was
2351 : : attempted, even though a parse error occurred. So, to check
2352 : : whether or not a parse error occurred, you should always use
2353 : : cp_parser_error_occurred. If the construct is optional (indicated
2354 : : either by an `_opt' in the name of the function that does the
2355 : : parsing or via a FLAGS parameter), then NULL_TREE is returned if
2356 : : the construct is not present. */
2357 : :
2358 : : /* Lexical conventions [gram.lex] */
2359 : :
2360 : : static tree finish_userdef_string_literal
2361 : : (tree);
2362 : :
2363 : : /* Basic concepts [gram.basic] */
2364 : :
2365 : : static void cp_parser_translation_unit (cp_parser *);
2366 : :
2367 : : /* Expressions [gram.expr] */
2368 : :
2369 : : static cp_expr cp_parser_primary_expression
2370 : : (cp_parser *, bool, bool, bool, cp_id_kind *);
2371 : : static cp_expr cp_parser_id_expression
2372 : : (cp_parser *, bool, bool, bool *, bool, bool);
2373 : : static cp_expr cp_parser_unqualified_id
2374 : : (cp_parser *, bool, bool, bool, bool);
2375 : : static tree cp_parser_nested_name_specifier_opt
2376 : : (cp_parser *, bool, bool, bool, bool, bool = false);
2377 : : static tree cp_parser_nested_name_specifier
2378 : : (cp_parser *, bool, bool, bool, bool);
2379 : : static tree cp_parser_qualifying_entity
2380 : : (cp_parser *, bool, bool, bool, bool, bool);
2381 : : static cp_expr cp_parser_postfix_expression
2382 : : (cp_parser *, bool, bool, bool, bool, cp_id_kind *);
2383 : : static tree cp_parser_postfix_open_square_expression
2384 : : (cp_parser *, tree, bool, bool);
2385 : : static tree cp_parser_postfix_dot_deref_expression
2386 : : (cp_parser *, enum cpp_ttype, cp_expr, bool, cp_id_kind *, location_t);
2387 : : static vec<tree, va_gc> *cp_parser_parenthesized_expression_list
2388 : : (cp_parser *, int, bool, bool, bool *, location_t * = NULL,
2389 : : bool = false);
2390 : : /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2391 : : enum { non_attr = 0, normal_attr = 1, id_attr = 2, assume_attr = 3,
2392 : : uneval_string_attr = 4 };
2393 : : static void cp_parser_pseudo_destructor_name
2394 : : (cp_parser *, tree, tree *, tree *);
2395 : : static cp_expr cp_parser_unary_expression
2396 : : (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false, bool = false);
2397 : : static enum tree_code cp_parser_unary_operator
2398 : : (cp_token *);
2399 : : static tree cp_parser_has_attribute_expression
2400 : : (cp_parser *);
2401 : : static tree cp_parser_new_expression
2402 : : (cp_parser *);
2403 : : static vec<tree, va_gc> *cp_parser_new_placement
2404 : : (cp_parser *);
2405 : : static tree cp_parser_new_type_id
2406 : : (cp_parser *, tree *);
2407 : : static cp_declarator *cp_parser_new_declarator_opt
2408 : : (cp_parser *);
2409 : : static cp_declarator *cp_parser_direct_new_declarator
2410 : : (cp_parser *);
2411 : : static vec<tree, va_gc> *cp_parser_new_initializer
2412 : : (cp_parser *);
2413 : : static tree cp_parser_delete_expression
2414 : : (cp_parser *);
2415 : : static cp_expr cp_parser_cast_expression
2416 : : (cp_parser *, bool, bool, bool, cp_id_kind *);
2417 : : static cp_expr cp_parser_binary_expression
2418 : : (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
2419 : : static tree cp_parser_question_colon_clause
2420 : : (cp_parser *, cp_expr);
2421 : : static cp_expr cp_parser_conditional_expression (cp_parser *);
2422 : : static cp_expr cp_parser_assignment_expression
2423 : : (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
2424 : : static enum tree_code cp_parser_assignment_operator_opt
2425 : : (cp_parser *);
2426 : : static cp_expr cp_parser_expression
2427 : : (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false, bool = false);
2428 : : static cp_expr cp_parser_constant_expression
2429 : : (cp_parser *, int = 0, bool * = NULL, bool = false);
2430 : : static cp_expr cp_parser_builtin_offsetof
2431 : : (cp_parser *);
2432 : : static cp_expr cp_parser_lambda_expression
2433 : : (cp_parser *);
2434 : : static void cp_parser_lambda_introducer
2435 : : (cp_parser *, tree);
2436 : : static bool cp_parser_lambda_declarator_opt
2437 : : (cp_parser *, tree);
2438 : : static void cp_parser_lambda_body
2439 : : (cp_parser *, tree);
2440 : :
2441 : : /* Statements [gram.stmt.stmt] */
2442 : :
2443 : : static void cp_parser_statement
2444 : : (cp_parser *, tree, bool, bool *, vec<tree> * = NULL, location_t * = NULL);
2445 : : static void cp_parser_label_for_labeled_statement
2446 : : (cp_parser *, tree);
2447 : : static tree cp_parser_expression_statement
2448 : : (cp_parser *, tree);
2449 : : static tree cp_parser_compound_statement
2450 : : (cp_parser *, tree, int, bool);
2451 : : static void cp_parser_statement_seq_opt
2452 : : (cp_parser *, tree);
2453 : : static tree cp_parser_selection_statement
2454 : : (cp_parser *, bool *, vec<tree> *);
2455 : : static tree cp_parser_condition
2456 : : (cp_parser *, enum rid);
2457 : : static tree cp_parser_iteration_statement
2458 : : (cp_parser *, bool *, bool, tree, bool);
2459 : : static bool cp_parser_init_statement
2460 : : (cp_parser *, tree *decl);
2461 : : static tree cp_parser_for
2462 : : (cp_parser *, bool, tree, bool);
2463 : : static tree cp_parser_c_for
2464 : : (cp_parser *, tree, tree, bool, tree, bool);
2465 : : static tree cp_parser_range_for
2466 : : (cp_parser *, tree, tree, tree, bool, tree, bool, bool);
2467 : : static void do_range_for_auto_deduction
2468 : : (tree, tree, cp_decomp *);
2469 : : static tree cp_parser_perform_range_for_lookup
2470 : : (tree, tree *, tree *);
2471 : : static tree cp_parser_range_for_member_function
2472 : : (tree, tree);
2473 : : static tree cp_parser_jump_statement
2474 : : (cp_parser *, tree &);
2475 : : static void cp_parser_declaration_statement
2476 : : (cp_parser *);
2477 : :
2478 : : static tree cp_parser_implicitly_scoped_statement
2479 : : (cp_parser *, bool *, const token_indent_info &, vec<tree> * = NULL);
2480 : : static void cp_parser_already_scoped_statement
2481 : : (cp_parser *, bool *, const token_indent_info &);
2482 : :
2483 : : /* State of module-declaration parsing. */
2484 : : enum module_parse
2485 : : {
2486 : : MP_NOT_MODULE, /* Not a module. */
2487 : :
2488 : : _MP_UNUSED,
2489 : :
2490 : : MP_FIRST, /* First declaration of TU. */
2491 : : MP_GLOBAL, /* Global Module Fragment. */
2492 : :
2493 : : MP_PURVIEW_IMPORTS, /* Imports of a module. */
2494 : : MP_PURVIEW, /* Purview of a named module. */
2495 : :
2496 : : MP_PRIVATE_IMPORTS, /* Imports of a Private Module Fragment. */
2497 : : MP_PRIVATE, /* Private Module Fragment. */
2498 : : };
2499 : :
2500 : : static module_parse cp_parser_module_declaration
2501 : : (cp_parser *parser, module_parse, bool exporting);
2502 : : static void cp_parser_import_declaration
2503 : : (cp_parser *parser, module_parse, bool exporting);
2504 : :
2505 : : /* Declarations [gram.dcl.dcl] */
2506 : :
2507 : : static void cp_parser_declaration_seq_opt
2508 : : (cp_parser *);
2509 : : static void cp_parser_declaration
2510 : : (cp_parser *, tree);
2511 : : static void cp_parser_toplevel_declaration
2512 : : (cp_parser *);
2513 : : static void cp_parser_block_declaration
2514 : : (cp_parser *, bool);
2515 : : static void cp_parser_simple_declaration
2516 : : (cp_parser *, bool, tree *);
2517 : : static void cp_parser_decl_specifier_seq
2518 : : (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
2519 : : static tree cp_parser_storage_class_specifier_opt
2520 : : (cp_parser *);
2521 : : static tree cp_parser_function_specifier_opt
2522 : : (cp_parser *, cp_decl_specifier_seq *);
2523 : : static tree cp_parser_type_specifier
2524 : : (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
2525 : : int *, bool *);
2526 : : static tree cp_parser_simple_type_specifier
2527 : : (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
2528 : : static tree cp_parser_placeholder_type_specifier
2529 : : (cp_parser *, location_t, tree, bool);
2530 : : static tree cp_parser_type_name
2531 : : (cp_parser *, bool);
2532 : : static tree cp_parser_nonclass_name
2533 : : (cp_parser* parser);
2534 : : static tree cp_parser_elaborated_type_specifier
2535 : : (cp_parser *, bool, bool);
2536 : : static tree cp_parser_enum_specifier
2537 : : (cp_parser *);
2538 : : static void cp_parser_enumerator_list
2539 : : (cp_parser *, tree);
2540 : : static void cp_parser_enumerator_definition
2541 : : (cp_parser *, tree);
2542 : : static tree cp_parser_namespace_name
2543 : : (cp_parser *);
2544 : : static void cp_parser_namespace_definition
2545 : : (cp_parser *);
2546 : : static void cp_parser_namespace_body
2547 : : (cp_parser *);
2548 : : static tree cp_parser_qualified_namespace_specifier
2549 : : (cp_parser *);
2550 : : static void cp_parser_namespace_alias_definition
2551 : : (cp_parser *);
2552 : : static bool cp_parser_using_declaration
2553 : : (cp_parser *, bool);
2554 : : static void cp_parser_using_directive
2555 : : (cp_parser *);
2556 : : static void cp_parser_using_enum
2557 : : (cp_parser *);
2558 : : static tree cp_parser_alias_declaration
2559 : : (cp_parser *);
2560 : : static void cp_parser_asm_definition
2561 : : (cp_parser *);
2562 : : static void cp_parser_linkage_specification
2563 : : (cp_parser *, tree);
2564 : : static void cp_parser_static_assert
2565 : : (cp_parser *, bool);
2566 : : static tree cp_parser_decltype
2567 : : (cp_parser *);
2568 : : static tree cp_parser_decomposition_declaration
2569 : : (cp_parser *, cp_decl_specifier_seq *, tree *, location_t *, enum rid);
2570 : :
2571 : : /* Declarators [gram.dcl.decl] */
2572 : :
2573 : : static tree cp_parser_init_declarator
2574 : : (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *,
2575 : : vec<deferred_access_check, va_gc> *, bool, bool, int, bool *, tree *,
2576 : : location_t *, tree *);
2577 : : static cp_declarator *cp_parser_declarator
2578 : : (cp_parser *, cp_parser_declarator_kind, cp_parser_flags, int *, bool *,
2579 : : bool, bool, bool);
2580 : : static cp_declarator *cp_parser_direct_declarator
2581 : : (cp_parser *, cp_parser_declarator_kind, cp_parser_flags, int *, bool, bool,
2582 : : bool);
2583 : : static enum tree_code cp_parser_ptr_operator
2584 : : (cp_parser *, tree *, cp_cv_quals *, tree *);
2585 : : static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2586 : : (cp_parser *);
2587 : : static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2588 : : (cp_parser *);
2589 : : static cp_ref_qualifier cp_parser_ref_qualifier_opt
2590 : : (cp_parser *);
2591 : : static tree cp_parser_tx_qualifier_opt
2592 : : (cp_parser *);
2593 : : static tree cp_parser_late_return_type_opt
2594 : : (cp_parser *, cp_declarator *, tree &);
2595 : : static tree cp_parser_declarator_id
2596 : : (cp_parser *, bool);
2597 : : static tree cp_parser_type_id
2598 : : (cp_parser *, cp_parser_flags = CP_PARSER_FLAGS_NONE, location_t * = NULL);
2599 : : static tree cp_parser_template_type_arg
2600 : : (cp_parser *);
2601 : : static tree cp_parser_trailing_type_id (cp_parser *);
2602 : : static tree cp_parser_type_id_1
2603 : : (cp_parser *, cp_parser_flags, bool, bool, location_t *);
2604 : : static void cp_parser_type_specifier_seq
2605 : : (cp_parser *, cp_parser_flags, bool, bool, cp_decl_specifier_seq *);
2606 : : static tree cp_parser_parameter_declaration_clause
2607 : : (cp_parser *, cp_parser_flags, bool);
2608 : : static tree cp_parser_parameter_declaration_list
2609 : : (cp_parser *, cp_parser_flags, auto_vec<tree> *);
2610 : : static cp_parameter_declarator *cp_parser_parameter_declaration
2611 : : (cp_parser *, cp_parser_flags, bool, bool *);
2612 : : static tree cp_parser_default_argument
2613 : : (cp_parser *, bool);
2614 : : static void cp_parser_function_body
2615 : : (cp_parser *, bool);
2616 : : static tree cp_parser_initializer
2617 : : (cp_parser *, bool * = nullptr, bool * = nullptr, bool = false);
2618 : : static cp_expr cp_parser_initializer_clause
2619 : : (cp_parser *, bool * = nullptr);
2620 : : static cp_expr cp_parser_braced_list
2621 : : (cp_parser*, bool * = nullptr);
2622 : : static vec<constructor_elt, va_gc> *cp_parser_initializer_list
2623 : : (cp_parser *, bool *, bool *);
2624 : :
2625 : : static void cp_parser_ctor_initializer_opt_and_function_body
2626 : : (cp_parser *, bool);
2627 : :
2628 : : static tree cp_parser_late_parsing_omp_declare_simd
2629 : : (cp_parser *, tree);
2630 : :
2631 : : static tree cp_parser_late_parsing_oacc_routine
2632 : : (cp_parser *, tree);
2633 : :
2634 : : static tree synthesize_implicit_template_parm
2635 : : (cp_parser *, tree);
2636 : : static tree finish_fully_implicit_template
2637 : : (cp_parser *, tree);
2638 : : static void abort_fully_implicit_template
2639 : : (cp_parser *);
2640 : :
2641 : : /* Classes [gram.class] */
2642 : :
2643 : : static tree cp_parser_class_name
2644 : : (cp_parser *, bool, bool, enum tag_types, bool, bool, bool, bool = false);
2645 : : static tree cp_parser_class_specifier
2646 : : (cp_parser *);
2647 : : static tree cp_parser_class_head
2648 : : (cp_parser *, bool *);
2649 : : static enum tag_types cp_parser_class_key
2650 : : (cp_parser *);
2651 : : static void cp_parser_type_parameter_key
2652 : : (cp_parser* parser);
2653 : : static void cp_parser_member_specification_opt
2654 : : (cp_parser *);
2655 : : static void cp_parser_member_declaration
2656 : : (cp_parser *);
2657 : : static tree cp_parser_pure_specifier
2658 : : (cp_parser *);
2659 : : static tree cp_parser_constant_initializer
2660 : : (cp_parser *);
2661 : :
2662 : : /* Derived classes [gram.class.derived] */
2663 : :
2664 : : static tree cp_parser_base_clause
2665 : : (cp_parser *);
2666 : : static tree cp_parser_base_specifier
2667 : : (cp_parser *);
2668 : :
2669 : : /* Special member functions [gram.special] */
2670 : :
2671 : : static tree cp_parser_conversion_function_id
2672 : : (cp_parser *);
2673 : : static tree cp_parser_conversion_type_id
2674 : : (cp_parser *);
2675 : : static cp_declarator *cp_parser_conversion_declarator_opt
2676 : : (cp_parser *);
2677 : : static void cp_parser_ctor_initializer_opt
2678 : : (cp_parser *);
2679 : : static void cp_parser_mem_initializer_list
2680 : : (cp_parser *);
2681 : : static tree cp_parser_mem_initializer
2682 : : (cp_parser *);
2683 : : static tree cp_parser_mem_initializer_id
2684 : : (cp_parser *);
2685 : :
2686 : : /* Overloading [gram.over] */
2687 : :
2688 : : static cp_expr cp_parser_operator_function_id
2689 : : (cp_parser *);
2690 : : static cp_expr cp_parser_operator
2691 : : (cp_parser *, location_t);
2692 : :
2693 : : /* Templates [gram.temp] */
2694 : :
2695 : : static void cp_parser_template_declaration
2696 : : (cp_parser *, bool);
2697 : : static tree cp_parser_template_parameter_list
2698 : : (cp_parser *);
2699 : : static tree cp_parser_template_parameter
2700 : : (cp_parser *, bool *, bool *);
2701 : : static tree cp_parser_type_parameter
2702 : : (cp_parser *, bool *);
2703 : : static tree cp_parser_template_id
2704 : : (cp_parser *, bool, bool, enum tag_types, bool);
2705 : : static tree cp_parser_template_id_expr
2706 : : (cp_parser *, bool, bool, bool);
2707 : : static tree cp_parser_template_name
2708 : : (cp_parser *, bool, bool, bool, enum tag_types, bool *);
2709 : : static tree cp_parser_template_argument_list
2710 : : (cp_parser *);
2711 : : static tree cp_parser_template_argument
2712 : : (cp_parser *);
2713 : : static void cp_parser_explicit_instantiation
2714 : : (cp_parser *);
2715 : : static void cp_parser_explicit_specialization
2716 : : (cp_parser *);
2717 : :
2718 : : /* Exception handling [gram.except] */
2719 : :
2720 : : static tree cp_parser_try_block
2721 : : (cp_parser *);
2722 : : static void cp_parser_function_try_block
2723 : : (cp_parser *);
2724 : : static void cp_parser_handler_seq
2725 : : (cp_parser *);
2726 : : static void cp_parser_handler
2727 : : (cp_parser *);
2728 : : static tree cp_parser_exception_declaration
2729 : : (cp_parser *);
2730 : : static tree cp_parser_throw_expression
2731 : : (cp_parser *);
2732 : : static tree cp_parser_exception_specification_opt
2733 : : (cp_parser *, cp_parser_flags);
2734 : : static tree cp_parser_type_id_list
2735 : : (cp_parser *);
2736 : : static tree cp_parser_noexcept_specification_opt
2737 : : (cp_parser *, cp_parser_flags, bool, bool *, bool);
2738 : :
2739 : : /* GNU Extensions */
2740 : :
2741 : : static tree cp_parser_asm_specification_opt
2742 : : (cp_parser *);
2743 : : static tree cp_parser_asm_operand_list
2744 : : (cp_parser *);
2745 : : static tree cp_parser_asm_clobber_list
2746 : : (cp_parser *);
2747 : : static tree cp_parser_asm_label_list
2748 : : (cp_parser *);
2749 : : static bool cp_next_tokens_can_be_attribute_p
2750 : : (cp_parser *);
2751 : : static bool cp_next_tokens_can_be_gnu_attribute_p
2752 : : (cp_parser *);
2753 : : static bool cp_next_tokens_can_be_std_attribute_p
2754 : : (cp_parser *);
2755 : : static bool cp_nth_tokens_can_be_std_attribute_p
2756 : : (cp_parser *, size_t);
2757 : : static bool cp_nth_tokens_can_be_gnu_attribute_p
2758 : : (cp_parser *, size_t);
2759 : : static bool cp_nth_tokens_can_be_attribute_p
2760 : : (cp_parser *, size_t);
2761 : : static tree cp_parser_attributes_opt
2762 : : (cp_parser *);
2763 : : static tree cp_parser_gnu_attributes_opt
2764 : : (cp_parser *);
2765 : : static tree cp_parser_gnu_attribute_list
2766 : : (cp_parser *, bool = false);
2767 : : static tree cp_parser_std_attribute
2768 : : (cp_parser *, tree);
2769 : : static tree cp_parser_std_attribute_spec
2770 : : (cp_parser *);
2771 : : static tree cp_parser_std_attribute_spec_seq
2772 : : (cp_parser *);
2773 : : static size_t cp_parser_skip_std_attribute_spec_seq
2774 : : (cp_parser *, size_t);
2775 : : static size_t cp_parser_skip_attributes_opt
2776 : : (cp_parser *, size_t);
2777 : : static bool cp_parser_extension_opt
2778 : : (cp_parser *, int *);
2779 : : static void cp_parser_label_declaration
2780 : : (cp_parser *);
2781 : :
2782 : : /* Concept Extensions */
2783 : :
2784 : : static tree cp_parser_concept_definition
2785 : : (cp_parser *);
2786 : : static tree cp_parser_constraint_expression
2787 : : (cp_parser *);
2788 : : static tree cp_parser_requires_clause_opt
2789 : : (cp_parser *, bool);
2790 : : static tree cp_parser_requires_expression
2791 : : (cp_parser *);
2792 : : static tree cp_parser_requirement_parameter_list
2793 : : (cp_parser *);
2794 : : static tree cp_parser_requirement_body
2795 : : (cp_parser *);
2796 : : static tree cp_parser_requirement_seq
2797 : : (cp_parser *);
2798 : : static tree cp_parser_requirement
2799 : : (cp_parser *);
2800 : : static tree cp_parser_simple_requirement
2801 : : (cp_parser *);
2802 : : static tree cp_parser_compound_requirement
2803 : : (cp_parser *);
2804 : : static tree cp_parser_type_requirement
2805 : : (cp_parser *);
2806 : : static tree cp_parser_nested_requirement
2807 : : (cp_parser *);
2808 : :
2809 : : /* Transactional Memory Extensions */
2810 : :
2811 : : static tree cp_parser_transaction
2812 : : (cp_parser *, cp_token *);
2813 : : static tree cp_parser_transaction_expression
2814 : : (cp_parser *, enum rid);
2815 : : static void cp_parser_function_transaction
2816 : : (cp_parser *, enum rid);
2817 : : static tree cp_parser_transaction_cancel
2818 : : (cp_parser *);
2819 : :
2820 : : /* Coroutine extensions. */
2821 : :
2822 : : static tree cp_parser_yield_expression
2823 : : (cp_parser *);
2824 : :
2825 : : /* Contracts */
2826 : :
2827 : : static void cp_parser_late_contract_condition
2828 : : (cp_parser *, tree, tree);
2829 : :
2830 : : enum pragma_context {
2831 : : pragma_external,
2832 : : pragma_member,
2833 : : pragma_objc_icode,
2834 : : pragma_stmt,
2835 : : pragma_compound
2836 : : };
2837 : : static bool cp_parser_pragma
2838 : : (cp_parser *, enum pragma_context, bool *);
2839 : :
2840 : : /* Objective-C++ Productions */
2841 : :
2842 : : static tree cp_parser_objc_message_receiver
2843 : : (cp_parser *);
2844 : : static tree cp_parser_objc_message_args
2845 : : (cp_parser *);
2846 : : static tree cp_parser_objc_message_expression
2847 : : (cp_parser *);
2848 : : static cp_expr cp_parser_objc_encode_expression
2849 : : (cp_parser *);
2850 : : static tree cp_parser_objc_defs_expression
2851 : : (cp_parser *);
2852 : : static tree cp_parser_objc_protocol_expression
2853 : : (cp_parser *);
2854 : : static tree cp_parser_objc_selector_expression
2855 : : (cp_parser *);
2856 : : static cp_expr cp_parser_objc_expression
2857 : : (cp_parser *);
2858 : : static bool cp_parser_objc_selector_p
2859 : : (enum cpp_ttype);
2860 : : static tree cp_parser_objc_selector
2861 : : (cp_parser *);
2862 : : static tree cp_parser_objc_protocol_refs_opt
2863 : : (cp_parser *);
2864 : : static void cp_parser_objc_declaration
2865 : : (cp_parser *, tree);
2866 : : static tree cp_parser_objc_statement
2867 : : (cp_parser *);
2868 : : static bool cp_parser_objc_valid_prefix_attributes
2869 : : (cp_parser *, tree *);
2870 : : static void cp_parser_objc_at_property_declaration
2871 : : (cp_parser *) ;
2872 : : static void cp_parser_objc_at_synthesize_declaration
2873 : : (cp_parser *) ;
2874 : : static void cp_parser_objc_at_dynamic_declaration
2875 : : (cp_parser *) ;
2876 : : static tree cp_parser_objc_struct_declaration
2877 : : (cp_parser *) ;
2878 : :
2879 : : /* Utility Routines */
2880 : :
2881 : : static cp_expr cp_parser_lookup_name
2882 : : (cp_parser *, tree, enum tag_types, int, bool, bool, tree *, location_t);
2883 : : static tree cp_parser_lookup_name_simple
2884 : : (cp_parser *, tree, location_t);
2885 : : static tree cp_parser_maybe_treat_template_as_class
2886 : : (tree, bool);
2887 : : static bool cp_parser_check_declarator_template_parameters
2888 : : (cp_parser *, cp_declarator *, location_t);
2889 : : static bool cp_parser_check_template_parameters
2890 : : (cp_parser *, unsigned, bool, location_t, cp_declarator *);
2891 : : static cp_expr cp_parser_simple_cast_expression
2892 : : (cp_parser *);
2893 : : static tree cp_parser_global_scope_opt
2894 : : (cp_parser *, bool);
2895 : : static bool cp_parser_constructor_declarator_p
2896 : : (cp_parser *, cp_parser_flags, bool);
2897 : : static tree cp_parser_function_definition_from_specifiers_and_declarator
2898 : : (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
2899 : : static tree cp_parser_function_definition_after_declarator
2900 : : (cp_parser *, bool);
2901 : : static bool cp_parser_template_declaration_after_export
2902 : : (cp_parser *, bool);
2903 : : static void cp_parser_perform_template_parameter_access_checks
2904 : : (vec<deferred_access_check, va_gc> *);
2905 : : static tree cp_parser_single_declaration
2906 : : (cp_parser *, vec<deferred_access_check, va_gc> *, bool, bool, bool *);
2907 : : static cp_expr cp_parser_functional_cast
2908 : : (cp_parser *, tree);
2909 : : static tree cp_parser_save_member_function_body
2910 : : (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
2911 : : static tree cp_parser_save_nsdmi
2912 : : (cp_parser *);
2913 : : static tree cp_parser_enclosed_template_argument_list
2914 : : (cp_parser *);
2915 : : static void cp_parser_save_default_args
2916 : : (cp_parser *, tree);
2917 : : static void cp_parser_late_parsing_for_member
2918 : : (cp_parser *, tree);
2919 : : static tree cp_parser_late_parse_one_default_arg
2920 : : (cp_parser *, tree, tree, tree);
2921 : : static void cp_parser_late_parsing_nsdmi
2922 : : (cp_parser *, tree);
2923 : : static void cp_parser_late_parsing_default_args
2924 : : (cp_parser *, tree);
2925 : : static tree cp_parser_sizeof_operand
2926 : : (cp_parser *, enum rid);
2927 : : static cp_expr cp_parser_trait
2928 : : (cp_parser *, const cp_trait *);
2929 : : static bool cp_parser_declares_only_class_p
2930 : : (cp_parser *);
2931 : : static void cp_parser_set_storage_class
2932 : : (cp_parser *, cp_decl_specifier_seq *, enum rid, cp_token *);
2933 : : static void cp_parser_set_decl_spec_type
2934 : : (cp_decl_specifier_seq *, tree, cp_token *, bool);
2935 : : static void set_and_check_decl_spec_loc
2936 : : (cp_decl_specifier_seq *decl_specs,
2937 : : cp_decl_spec ds, cp_token *);
2938 : : static bool cp_parser_friend_p
2939 : : (const cp_decl_specifier_seq *);
2940 : : static void cp_parser_required_error
2941 : : (cp_parser *, required_token, bool, location_t);
2942 : : static cp_token *cp_parser_require
2943 : : (cp_parser *, enum cpp_ttype, required_token, location_t = UNKNOWN_LOCATION);
2944 : : static cp_token *cp_parser_require_keyword
2945 : : (cp_parser *, enum rid, required_token);
2946 : : static bool cp_parser_token_starts_function_definition_p
2947 : : (cp_token *);
2948 : : static bool cp_parser_next_token_starts_class_definition_p
2949 : : (cp_parser *);
2950 : : static bool cp_parser_next_token_ends_template_argument_p
2951 : : (cp_parser *);
2952 : : static bool cp_parser_nth_token_starts_template_argument_list_p
2953 : : (cp_parser *, size_t);
2954 : : static enum tag_types cp_parser_token_is_class_key
2955 : : (cp_token *);
2956 : : static enum tag_types cp_parser_token_is_type_parameter_key
2957 : : (cp_token *);
2958 : : static void cp_parser_maybe_warn_enum_key (cp_parser *, location_t, tree, rid);
2959 : : static void cp_parser_check_class_key
2960 : : (cp_parser *, location_t, enum tag_types, tree type, bool, bool);
2961 : : static void cp_parser_check_access_in_redeclaration
2962 : : (tree type, location_t location);
2963 : : static bool cp_parser_optional_template_keyword
2964 : : (cp_parser *);
2965 : : static void cp_parser_pre_parsed_nested_name_specifier
2966 : : (cp_parser *);
2967 : : static bool cp_parser_cache_group
2968 : : (cp_parser *, enum cpp_ttype, unsigned);
2969 : : static tree cp_parser_cache_defarg
2970 : : (cp_parser *parser, bool nsdmi);
2971 : : static void cp_parser_parse_tentatively
2972 : : (cp_parser *);
2973 : : static void cp_parser_commit_to_tentative_parse
2974 : : (cp_parser *);
2975 : : static void cp_parser_commit_to_topmost_tentative_parse
2976 : : (cp_parser *);
2977 : : static void cp_parser_abort_tentative_parse
2978 : : (cp_parser *);
2979 : : static bool cp_parser_parse_definitely
2980 : : (cp_parser *);
2981 : : static inline bool cp_parser_parsing_tentatively
2982 : : (cp_parser *);
2983 : : static bool cp_parser_uncommitted_to_tentative_parse_p
2984 : : (cp_parser *);
2985 : : static void cp_parser_error
2986 : : (cp_parser *, const char *);
2987 : : static void cp_parser_name_lookup_error
2988 : : (cp_parser *, tree, tree, name_lookup_error, location_t);
2989 : : static bool cp_parser_simulate_error
2990 : : (cp_parser *);
2991 : : static bool cp_parser_check_type_definition
2992 : : (cp_parser *);
2993 : : static void cp_parser_check_for_definition_in_return_type
2994 : : (cp_declarator *, tree, location_t type_location);
2995 : : static void cp_parser_check_for_invalid_template_id
2996 : : (cp_parser *, tree, enum tag_types, location_t location);
2997 : : static bool cp_parser_non_integral_constant_expression
2998 : : (cp_parser *, non_integral_constant);
2999 : : static void cp_parser_diagnose_invalid_type_name
3000 : : (cp_parser *, tree, location_t);
3001 : : static bool cp_parser_parse_and_diagnose_invalid_type_name
3002 : : (cp_parser *);
3003 : : static int cp_parser_skip_to_closing_parenthesis
3004 : : (cp_parser *, bool, bool, bool);
3005 : : static void cp_parser_skip_to_end_of_statement
3006 : : (cp_parser *);
3007 : : static void cp_parser_consume_semicolon_at_end_of_statement
3008 : : (cp_parser *);
3009 : : static void cp_parser_skip_to_end_of_block_or_statement
3010 : : (cp_parser *);
3011 : : static bool cp_parser_skip_to_closing_brace
3012 : : (cp_parser *);
3013 : : static bool cp_parser_skip_entire_template_parameter_list
3014 : : (cp_parser *);
3015 : : static void cp_parser_require_end_of_template_parameter_list
3016 : : (cp_parser *);
3017 : : static bool cp_parser_skip_to_end_of_template_parameter_list
3018 : : (cp_parser *);
3019 : : static void cp_parser_skip_to_pragma_eol
3020 : : (cp_parser*, cp_token *);
3021 : : static bool cp_parser_error_occurred
3022 : : (cp_parser *);
3023 : : static bool cp_parser_allow_gnu_extensions_p
3024 : : (cp_parser *);
3025 : : static bool cp_parser_is_pure_string_literal
3026 : : (cp_token *);
3027 : : static bool cp_parser_is_string_literal
3028 : : (cp_token *);
3029 : : static bool cp_parser_is_keyword
3030 : : (cp_token *, enum rid);
3031 : : static tree cp_parser_make_typename_type
3032 : : (cp_parser *, tree, location_t location);
3033 : : static cp_declarator * cp_parser_make_indirect_declarator
3034 : : (enum tree_code, tree, cp_cv_quals, cp_declarator *, tree);
3035 : : static bool cp_parser_compound_literal_p
3036 : : (cp_parser *);
3037 : : static bool cp_parser_array_designator_p
3038 : : (cp_parser *);
3039 : : static bool cp_parser_init_statement_p
3040 : : (cp_parser *);
3041 : : static bool cp_parser_skip_up_to_closing_square_bracket
3042 : : (cp_parser *);
3043 : : static bool cp_parser_skip_to_closing_square_bracket
3044 : : (cp_parser *);
3045 : : static size_t cp_parser_skip_balanced_tokens (cp_parser *, size_t);
3046 : : static bool cp_parser_next_tokens_can_be_canon_loop (cp_parser *,
3047 : : enum tree_code, bool);
3048 : : static tree cp_parser_omp_loop_nest (cp_parser *, bool *);
3049 : :
3050 : : // -------------------------------------------------------------------------- //
3051 : : // Unevaluated Operand Guard
3052 : : //
3053 : : // Implementation of an RAII helper for unevaluated operand parsing.
3054 : 92975828 : cp_unevaluated::cp_unevaluated ()
3055 : : {
3056 : 92975828 : ++cp_unevaluated_operand;
3057 : 92975828 : ++c_inhibit_evaluation_warnings;
3058 : 92975828 : }
3059 : :
3060 : 92970428 : cp_unevaluated::~cp_unevaluated ()
3061 : : {
3062 : 92970428 : --c_inhibit_evaluation_warnings;
3063 : 92970428 : --cp_unevaluated_operand;
3064 : 92970428 : }
3065 : :
3066 : : // -------------------------------------------------------------------------- //
3067 : : // Tentative Parsing
3068 : :
3069 : : /* Returns nonzero if we are parsing tentatively. */
3070 : :
3071 : : static inline bool
3072 : 37680468911 : cp_parser_parsing_tentatively (cp_parser* parser)
3073 : : {
3074 : 37680468911 : return parser->context->next != NULL;
3075 : : }
3076 : :
3077 : : /* Returns nonzero if TOKEN is a string literal. */
3078 : :
3079 : : static bool
3080 : 79421955 : cp_parser_is_pure_string_literal (cp_token* token)
3081 : : {
3082 : 52748140 : return (token->type == CPP_STRING ||
3083 : 52747440 : token->type == CPP_STRING16 ||
3084 : 52746723 : token->type == CPP_STRING32 ||
3085 : 132049474 : token->type == CPP_WSTRING ||
3086 : 79421955 : token->type == CPP_UTF8STRING);
3087 : : }
3088 : :
3089 : : /* Returns nonzero if TOKEN is a string literal
3090 : : of a user-defined string literal. */
3091 : :
3092 : : static bool
3093 : 39211620 : cp_parser_is_string_literal (cp_token* token)
3094 : : {
3095 : 56263138 : return (cp_parser_is_pure_string_literal (token) ||
3096 : 17051518 : token->type == CPP_STRING_USERDEF ||
3097 : 16506829 : token->type == CPP_STRING16_USERDEF ||
3098 : 16506713 : token->type == CPP_STRING32_USERDEF ||
3099 : 55718260 : token->type == CPP_WSTRING_USERDEF ||
3100 : 39211620 : token->type == CPP_UTF8STRING_USERDEF);
3101 : : }
3102 : :
3103 : : /* Returns nonzero if TOKEN is the indicated KEYWORD. */
3104 : :
3105 : : static bool
3106 : 543709328 : cp_parser_is_keyword (cp_token* token, enum rid keyword)
3107 : : {
3108 : 543709328 : return token->keyword == keyword;
3109 : : }
3110 : :
3111 : : /* Helper function for cp_parser_error.
3112 : : Having peeked a token of kind TOK1_KIND that might signify
3113 : : a conflict marker, peek successor tokens to determine
3114 : : if we actually do have a conflict marker.
3115 : : Specifically, we consider a run of 7 '<', '=' or '>' characters
3116 : : at the start of a line as a conflict marker.
3117 : : These come through the lexer as three pairs and a single,
3118 : : e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
3119 : : If it returns true, *OUT_LOC is written to with the location/range
3120 : : of the marker. */
3121 : :
3122 : : static bool
3123 : 102 : cp_lexer_peek_conflict_marker (cp_lexer *lexer, enum cpp_ttype tok1_kind,
3124 : : location_t *out_loc)
3125 : : {
3126 : 102 : cp_token *token2 = cp_lexer_peek_nth_token (lexer, 2);
3127 : 102 : if (token2->type != tok1_kind)
3128 : : return false;
3129 : 87 : cp_token *token3 = cp_lexer_peek_nth_token (lexer, 3);
3130 : 87 : if (token3->type != tok1_kind)
3131 : : return false;
3132 : 78 : cp_token *token4 = cp_lexer_peek_nth_token (lexer, 4);
3133 : 78 : if (token4->type != conflict_marker_get_final_tok_kind (tok1_kind))
3134 : : return false;
3135 : :
3136 : : /* It must be at the start of the line. */
3137 : 57 : location_t start_loc = cp_lexer_peek_token (lexer)->location;
3138 : 57 : if (LOCATION_COLUMN (start_loc) != 1)
3139 : : return false;
3140 : :
3141 : : /* We have a conflict marker. Construct a location of the form:
3142 : : <<<<<<<
3143 : : ^~~~~~~
3144 : : with start == caret, finishing at the end of the marker. */
3145 : 48 : location_t finish_loc = get_finish (token4->location);
3146 : 48 : *out_loc = make_location (start_loc, start_loc, finish_loc);
3147 : :
3148 : 48 : return true;
3149 : : }
3150 : :
3151 : : /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
3152 : : RT_CLOSE_PAREN. */
3153 : :
3154 : : static const char *
3155 : 168 : get_matching_symbol (required_token token_desc)
3156 : : {
3157 : 168 : switch (token_desc)
3158 : : {
3159 : 0 : default:
3160 : 0 : gcc_unreachable ();
3161 : : return "";
3162 : : case RT_CLOSE_BRACE:
3163 : : return "{";
3164 : 51 : case RT_CLOSE_PAREN:
3165 : 51 : return "(";
3166 : : }
3167 : : }
3168 : :
3169 : : /* Attempt to convert TOKEN_DESC from a required_token to an
3170 : : enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
3171 : :
3172 : : static enum cpp_ttype
3173 : 2481 : get_required_cpp_ttype (required_token token_desc)
3174 : : {
3175 : 0 : switch (token_desc)
3176 : : {
3177 : : case RT_SEMICOLON:
3178 : : return CPP_SEMICOLON;
3179 : : case RT_OPEN_PAREN:
3180 : : return CPP_OPEN_PAREN;
3181 : : case RT_CLOSE_BRACE:
3182 : : return CPP_CLOSE_BRACE;
3183 : : case RT_OPEN_BRACE:
3184 : : return CPP_OPEN_BRACE;
3185 : : case RT_CLOSE_SQUARE:
3186 : : return CPP_CLOSE_SQUARE;
3187 : : case RT_OPEN_SQUARE:
3188 : : return CPP_OPEN_SQUARE;
3189 : : case RT_COMMA:
3190 : : return CPP_COMMA;
3191 : : case RT_COLON:
3192 : : return CPP_COLON;
3193 : : case RT_CLOSE_PAREN:
3194 : : return CPP_CLOSE_PAREN;
3195 : :
3196 : : default:
3197 : : /* Use CPP_EOF as a "no completions possible" code. */
3198 : : return CPP_EOF;
3199 : : }
3200 : : }
3201 : :
3202 : :
3203 : : /* Subroutine of cp_parser_error and cp_parser_required_error.
3204 : :
3205 : : Issue a diagnostic of the form
3206 : : FILE:LINE: MESSAGE before TOKEN
3207 : : where TOKEN is the next token in the input stream. MESSAGE
3208 : : (specified by the caller) is usually of the form "expected
3209 : : OTHER-TOKEN".
3210 : :
3211 : : This bypasses the check for tentative passing, and potentially
3212 : : adds material needed by cp_parser_required_error.
3213 : :
3214 : : If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
3215 : : suggesting insertion of the missing token.
3216 : :
3217 : : Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
3218 : : have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
3219 : : location. */
3220 : :
3221 : : static void
3222 : 6241 : cp_parser_error_1 (cp_parser* parser, const char* gmsgid,
3223 : : required_token missing_token_desc,
3224 : : location_t matching_location)
3225 : : {
3226 : 6241 : cp_token *token = cp_lexer_peek_token (parser->lexer);
3227 : : /* This diagnostic makes more sense if it is tagged to the line
3228 : : of the token we just peeked at. */
3229 : 6241 : cp_lexer_set_source_position_from_token (token);
3230 : :
3231 : 6241 : if (token->type == CPP_PRAGMA)
3232 : : {
3233 : 15 : error_at (token->location,
3234 : : "%<#pragma%> is not allowed here");
3235 : 15 : cp_parser_skip_to_pragma_eol (parser, token);
3236 : 87 : return;
3237 : : }
3238 : :
3239 : 6226 : if (cp_token_is_module_directive (token))
3240 : : {
3241 : 9 : auto_diagnostic_group d;
3242 : 9 : error_at (token->location, "unexpected module directive");
3243 : 9 : if (token->keyword != RID__EXPORT)
3244 : 6 : inform (token->location, "perhaps insert a line break after"
3245 : : " %qs, or other disambiguation, to prevent this being"
3246 : : " considered a module control-line",
3247 : : (token->keyword == RID__MODULE) ? "module" : "import");
3248 : 9 : cp_parser_skip_to_pragma_eol (parser, token);
3249 : 9 : return;
3250 : 9 : }
3251 : :
3252 : : /* If this is actually a conflict marker, report it as such. */
3253 : 6217 : if (token->type == CPP_LSHIFT
3254 : 6217 : || token->type == CPP_RSHIFT
3255 : 6151 : || token->type == CPP_EQ_EQ)
3256 : : {
3257 : 102 : location_t loc;
3258 : 102 : if (cp_lexer_peek_conflict_marker (parser->lexer, token->type, &loc))
3259 : : {
3260 : 48 : error_at (loc, "version control conflict marker in file");
3261 : 48 : expanded_location token_exploc = expand_location (token->location);
3262 : : /* Consume tokens until the end of the source line. */
3263 : 492 : for (;;)
3264 : : {
3265 : 270 : cp_lexer_consume_token (parser->lexer);
3266 : 270 : cp_token *next = cp_lexer_peek_token (parser->lexer);
3267 : 270 : if (next->type == CPP_EOF)
3268 : : break;
3269 : 264 : if (next->location == UNKNOWN_LOCATION
3270 : 264 : || loc == UNKNOWN_LOCATION)
3271 : : break;
3272 : :
3273 : 264 : expanded_location next_exploc = expand_location (next->location);
3274 : 264 : if (next_exploc.file != token_exploc.file)
3275 : : break;
3276 : 264 : if (next_exploc.line != token_exploc.line)
3277 : : break;
3278 : 222 : }
3279 : 48 : return;
3280 : : }
3281 : : }
3282 : :
3283 : 6169 : auto_diagnostic_group d;
3284 : 6169 : gcc_rich_location richloc (input_location);
3285 : :
3286 : 6169 : bool added_matching_location = false;
3287 : :
3288 : 6169 : if (missing_token_desc != RT_NONE)
3289 : 2607 : if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
3290 : : {
3291 : : /* Potentially supply a fix-it hint, suggesting to add the
3292 : : missing token immediately after the *previous* token.
3293 : : This may move the primary location within richloc. */
3294 : 2481 : enum cpp_ttype ttype = get_required_cpp_ttype (missing_token_desc);
3295 : 2481 : location_t prev_token_loc = prev_token->location;
3296 : 2481 : maybe_suggest_missing_token_insertion (&richloc, ttype,
3297 : : prev_token_loc);
3298 : :
3299 : : /* If matching_location != UNKNOWN_LOCATION, highlight it.
3300 : : Attempt to consolidate diagnostics by printing it as a
3301 : : secondary range within the main diagnostic. */
3302 : 2481 : if (matching_location != UNKNOWN_LOCATION)
3303 : 979 : added_matching_location
3304 : 979 : = richloc.add_location_if_nearby (*global_dc,
3305 : : matching_location);
3306 : : }
3307 : :
3308 : : /* If we were parsing a string-literal and there is an unknown name
3309 : : token right after, then check to see if that could also have been
3310 : : a literal string by checking the name against a list of known
3311 : : standard string literal constants defined in header files. If
3312 : : there is one, then add that as an hint to the error message. */
3313 : 6169 : name_hint h;
3314 : 6169 : if (token->type == CPP_NAME)
3315 : 782 : if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
3316 : 760 : if (cp_parser_is_string_literal (prev_token))
3317 : : {
3318 : 19 : tree name = token->u.value;
3319 : 19 : const char *token_name = IDENTIFIER_POINTER (name);
3320 : 19 : const char *header_hint
3321 : 19 : = get_cp_stdlib_header_for_string_macro_name (token_name);
3322 : 19 : if (header_hint != NULL)
3323 : 32 : h = name_hint (NULL, new suggest_missing_header (token->location,
3324 : : token_name,
3325 : 16 : header_hint));
3326 : : }
3327 : :
3328 : : /* Actually emit the error. */
3329 : 6169 : c_parse_error (gmsgid,
3330 : : /* Because c_parser_error does not understand
3331 : : CPP_KEYWORD, keywords are treated like
3332 : : identifiers. */
3333 : 6169 : (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
3334 : 6169 : token->u.value, token->flags, &richloc);
3335 : :
3336 : 6169 : if (missing_token_desc != RT_NONE)
3337 : : {
3338 : : /* If we weren't able to consolidate matching_location, then
3339 : : print it as a secondary diagnostic. */
3340 : 2607 : if (matching_location != UNKNOWN_LOCATION
3341 : 2607 : && !added_matching_location)
3342 : 168 : inform (matching_location, "to match this %qs",
3343 : : get_matching_symbol (missing_token_desc));
3344 : : }
3345 : 6169 : }
3346 : :
3347 : : /* If not parsing tentatively, issue a diagnostic of the form
3348 : : FILE:LINE: MESSAGE before TOKEN
3349 : : where TOKEN is the next token in the input stream. MESSAGE
3350 : : (specified by the caller) is usually of the form "expected
3351 : : OTHER-TOKEN". */
3352 : :
3353 : : static void
3354 : 6794647224 : cp_parser_error (cp_parser* parser, const char* gmsgid)
3355 : : {
3356 : 13589294448 : if (!cp_parser_simulate_error (parser))
3357 : 3628 : cp_parser_error_1 (parser, gmsgid, RT_NONE, UNKNOWN_LOCATION);
3358 : 6794647224 : }
3359 : :
3360 : : /* Issue an error about name-lookup failing. NAME is the
3361 : : IDENTIFIER_NODE DECL is the result of
3362 : : the lookup (as returned from cp_parser_lookup_name). DESIRED is
3363 : : the thing that we hoped to find. */
3364 : :
3365 : : static void
3366 : 297 : cp_parser_name_lookup_error (cp_parser* parser,
3367 : : tree name,
3368 : : tree decl,
3369 : : name_lookup_error desired,
3370 : : location_t location)
3371 : : {
3372 : : /* If name lookup completely failed, tell the user that NAME was not
3373 : : declared. */
3374 : 297 : if (decl == error_mark_node)
3375 : : {
3376 : 254 : if (parser->scope && parser->scope != global_namespace)
3377 : 36 : error_at (location, "%<%E::%E%> has not been declared",
3378 : : parser->scope, name);
3379 : 218 : else if (parser->scope == global_namespace)
3380 : 0 : error_at (location, "%<::%E%> has not been declared", name);
3381 : 218 : else if (parser->object_scope
3382 : 218 : && !CLASS_TYPE_P (parser->object_scope))
3383 : 0 : error_at (location, "request for member %qE in non-class type %qT",
3384 : : name, parser->object_scope);
3385 : 218 : else if (parser->object_scope)
3386 : 0 : error_at (location, "%<%T::%E%> has not been declared",
3387 : : parser->object_scope, name);
3388 : : else
3389 : 218 : error_at (location, "%qE has not been declared", name);
3390 : : }
3391 : 43 : else if (parser->scope && parser->scope != global_namespace)
3392 : : {
3393 : 17 : switch (desired)
3394 : : {
3395 : 17 : case NLE_TYPE:
3396 : 17 : error_at (location, "%<%E::%E%> is not a type",
3397 : : parser->scope, name);
3398 : 17 : break;
3399 : 0 : case NLE_CXX98:
3400 : 0 : error_at (location, "%<%E::%E%> is not a class or namespace",
3401 : : parser->scope, name);
3402 : 0 : break;
3403 : 0 : case NLE_NOT_CXX98:
3404 : 0 : error_at (location,
3405 : : "%<%E::%E%> is not a class, namespace, or enumeration",
3406 : : parser->scope, name);
3407 : 0 : break;
3408 : 0 : default:
3409 : 0 : gcc_unreachable ();
3410 : :
3411 : : }
3412 : : }
3413 : 26 : else if (parser->scope == global_namespace)
3414 : : {
3415 : 0 : switch (desired)
3416 : : {
3417 : 0 : case NLE_TYPE:
3418 : 0 : error_at (location, "%<::%E%> is not a type", name);
3419 : 0 : break;
3420 : 0 : case NLE_CXX98:
3421 : 0 : error_at (location, "%<::%E%> is not a class or namespace", name);
3422 : 0 : break;
3423 : 0 : case NLE_NOT_CXX98:
3424 : 0 : error_at (location,
3425 : : "%<::%E%> is not a class, namespace, or enumeration",
3426 : : name);
3427 : 0 : break;
3428 : 0 : default:
3429 : 0 : gcc_unreachable ();
3430 : : }
3431 : : }
3432 : : else
3433 : : {
3434 : 26 : switch (desired)
3435 : : {
3436 : 12 : case NLE_TYPE:
3437 : 12 : error_at (location, "%qE is not a type", name);
3438 : 12 : break;
3439 : 5 : case NLE_CXX98:
3440 : 5 : error_at (location, "%qE is not a class or namespace", name);
3441 : 5 : break;
3442 : 9 : case NLE_NOT_CXX98:
3443 : 9 : error_at (location,
3444 : : "%qE is not a class, namespace, or enumeration", name);
3445 : 9 : break;
3446 : 0 : default:
3447 : 0 : gcc_unreachable ();
3448 : : }
3449 : : }
3450 : 297 : }
3451 : :
3452 : : /* If we are parsing tentatively, remember that an error has occurred
3453 : : during this tentative parse. Returns true if the error was
3454 : : simulated; false if a message should be issued by the caller. */
3455 : :
3456 : : static bool
3457 : 11743379222 : cp_parser_simulate_error (cp_parser* parser)
3458 : : {
3459 : 3628 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3460 : : {
3461 : 11743369749 : parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
3462 : 8803149748 : return true;
3463 : : }
3464 : : return false;
3465 : : }
3466 : :
3467 : : /* This function is called when a type is defined. If type
3468 : : definitions are forbidden at this point, an error message is
3469 : : issued. */
3470 : :
3471 : : static bool
3472 : 25448911 : cp_parser_check_type_definition (cp_parser* parser)
3473 : : {
3474 : : /* If types are forbidden here, issue a message. */
3475 : 0 : if (parser->type_definition_forbidden_message)
3476 : : {
3477 : : /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3478 : : or %qs in the message need to be interpreted. */
3479 : 21 : error (parser->type_definition_forbidden_message,
3480 : : parser->type_definition_forbidden_message_arg);
3481 : 112 : return false;
3482 : : }
3483 : : return true;
3484 : : }
3485 : :
3486 : : /* This function is called when the DECLARATOR is processed. The TYPE
3487 : : was a type defined in the decl-specifiers. If it is invalid to
3488 : : define a type in the decl-specifiers for DECLARATOR, an error is
3489 : : issued. TYPE_LOCATION is the location of TYPE and is used
3490 : : for error reporting. */
3491 : :
3492 : : static void
3493 : 778734 : cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
3494 : : tree type, location_t type_location)
3495 : : {
3496 : : /* [dcl.fct] forbids type definitions in return types.
3497 : : Unfortunately, it's not easy to know whether or not we are
3498 : : processing a return type until after the fact. */
3499 : 778734 : while (declarator
3500 : 779257 : && (declarator->kind == cdk_pointer
3501 : : || declarator->kind == cdk_reference
3502 : 779257 : || declarator->kind == cdk_ptrmem))
3503 : 523 : declarator = declarator->declarator;
3504 : 778734 : if (declarator
3505 : 778734 : && declarator->kind == cdk_function)
3506 : : {
3507 : 24 : auto_diagnostic_group d;
3508 : 24 : error_at (type_location,
3509 : : "new types may not be defined in a return type");
3510 : 24 : inform (type_location,
3511 : : "(perhaps a semicolon is missing after the definition of %qT)",
3512 : : type);
3513 : 24 : }
3514 : 778734 : }
3515 : :
3516 : : /* A type-specifier (TYPE) has been parsed which cannot be followed by
3517 : : "<" in any valid C++ program. If the next token is indeed "<",
3518 : : issue a message warning the user about what appears to be an
3519 : : invalid attempt to form a template-id. LOCATION is the location
3520 : : of the type-specifier (TYPE) */
3521 : :
3522 : : static void
3523 : 916910858 : cp_parser_check_for_invalid_template_id (cp_parser* parser,
3524 : : tree type,
3525 : : enum tag_types tag_type,
3526 : : location_t location)
3527 : : {
3528 : 916910858 : cp_token_position start = 0;
3529 : :
3530 : 916910858 : if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3531 : : {
3532 : 101 : if (TREE_CODE (type) == TYPE_DECL)
3533 : 57 : type = TREE_TYPE (type);
3534 : 101 : if (TYPE_P (type) && !template_placeholder_p (type))
3535 : 63 : error_at (location, "%qT is not a template", type);
3536 : 38 : else if (identifier_p (type))
3537 : : {
3538 : 38 : if (tag_type != none_type)
3539 : 38 : error_at (location, "%qE is not a class template", type);
3540 : : else
3541 : 0 : error_at (location, "%qE is not a template", type);
3542 : : }
3543 : : else
3544 : 0 : error_at (location, "invalid template-id");
3545 : : /* Remember the location of the invalid "<". */
3546 : 267 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3547 : 65 : start = cp_lexer_token_position (parser->lexer, true);
3548 : : /* Consume the "<". */
3549 : 101 : cp_lexer_consume_token (parser->lexer);
3550 : : /* Parse the template arguments. */
3551 : 101 : cp_parser_enclosed_template_argument_list (parser);
3552 : : /* Permanently remove the invalid template arguments so that
3553 : : this error message is not issued again. */
3554 : 101 : if (start)
3555 : 65 : cp_lexer_purge_tokens_after (parser->lexer, start);
3556 : : }
3557 : 916910858 : }
3558 : :
3559 : : /* If parsing an integral constant-expression, issue an error message
3560 : : about the fact that THING appeared and return true. Otherwise,
3561 : : return false. In either case, set
3562 : : PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3563 : :
3564 : : static bool
3565 : 434346105 : cp_parser_non_integral_constant_expression (cp_parser *parser,
3566 : : non_integral_constant thing)
3567 : : {
3568 : 434346105 : parser->non_integral_constant_expression_p = true;
3569 : 434346105 : if (parser->integral_constant_expression_p)
3570 : : {
3571 : 79901961 : if (!parser->allow_non_integral_constant_expression_p)
3572 : : {
3573 : 57 : const char *msg = NULL;
3574 : 57 : switch (thing)
3575 : : {
3576 : 10 : case NIC_FLOAT:
3577 : 10 : pedwarn (input_location, OPT_Wpedantic,
3578 : : "ISO C++ forbids using a floating-point literal "
3579 : : "in a constant-expression");
3580 : 10 : return true;
3581 : 14 : case NIC_CAST:
3582 : 14 : error ("a cast to a type other than an integral or "
3583 : : "enumeration type cannot appear in a "
3584 : : "constant-expression");
3585 : 14 : return true;
3586 : 1 : case NIC_TYPEID:
3587 : 1 : error ("%<typeid%> operator "
3588 : : "cannot appear in a constant-expression");
3589 : 1 : return true;
3590 : 0 : case NIC_NCC:
3591 : 0 : error ("non-constant compound literals "
3592 : : "cannot appear in a constant-expression");
3593 : 0 : return true;
3594 : 4 : case NIC_FUNC_CALL:
3595 : 4 : error ("a function call "
3596 : : "cannot appear in a constant-expression");
3597 : 4 : return true;
3598 : 0 : case NIC_INC:
3599 : 0 : error ("an increment "
3600 : : "cannot appear in a constant-expression");
3601 : 0 : return true;
3602 : 0 : case NIC_DEC:
3603 : 0 : error ("an decrement "
3604 : : "cannot appear in a constant-expression");
3605 : 0 : return true;
3606 : 5 : case NIC_ARRAY_REF:
3607 : 5 : error ("an array reference "
3608 : : "cannot appear in a constant-expression");
3609 : 5 : return true;
3610 : 2 : case NIC_ADDR_LABEL:
3611 : 2 : error ("the address of a label "
3612 : : "cannot appear in a constant-expression");
3613 : 2 : return true;
3614 : 0 : case NIC_OVERLOADED:
3615 : 0 : error ("calls to overloaded operators "
3616 : : "cannot appear in a constant-expression");
3617 : 0 : return true;
3618 : 1 : case NIC_ASSIGNMENT:
3619 : 1 : error ("an assignment cannot appear in a constant-expression");
3620 : 1 : return true;
3621 : 2 : case NIC_COMMA:
3622 : 2 : error ("a comma operator "
3623 : : "cannot appear in a constant-expression");
3624 : 2 : return true;
3625 : 1 : case NIC_CONSTRUCTOR:
3626 : 1 : error ("a call to a constructor "
3627 : : "cannot appear in a constant-expression");
3628 : 1 : return true;
3629 : 0 : case NIC_TRANSACTION:
3630 : 0 : error ("a transaction expression "
3631 : : "cannot appear in a constant-expression");
3632 : 0 : return true;
3633 : : case NIC_THIS:
3634 : : msg = "this";
3635 : : break;
3636 : 1 : case NIC_FUNC_NAME:
3637 : 1 : msg = "__FUNCTION__";
3638 : 1 : break;
3639 : 1 : case NIC_PRETTY_FUNC:
3640 : 1 : msg = "__PRETTY_FUNCTION__";
3641 : 1 : break;
3642 : 1 : case NIC_C99_FUNC:
3643 : 1 : msg = "__func__";
3644 : 1 : break;
3645 : 0 : case NIC_VA_ARG:
3646 : 0 : msg = "va_arg";
3647 : 0 : break;
3648 : 1 : case NIC_ARROW:
3649 : 1 : msg = "->";
3650 : 1 : break;
3651 : 1 : case NIC_POINT:
3652 : 1 : msg = ".";
3653 : 1 : break;
3654 : 4 : case NIC_STAR:
3655 : 4 : msg = "*";
3656 : 4 : break;
3657 : 8 : case NIC_ADDR:
3658 : 8 : msg = "&";
3659 : 8 : break;
3660 : 0 : case NIC_PREINCREMENT:
3661 : 0 : msg = "++";
3662 : 0 : break;
3663 : 0 : case NIC_PREDECREMENT:
3664 : 0 : msg = "--";
3665 : 0 : break;
3666 : 0 : case NIC_NEW:
3667 : 0 : msg = "new";
3668 : 0 : break;
3669 : 0 : case NIC_DEL:
3670 : 0 : msg = "delete";
3671 : 0 : break;
3672 : 0 : default:
3673 : 0 : gcc_unreachable ();
3674 : : }
3675 : 17 : if (msg)
3676 : 17 : error ("%qs cannot appear in a constant-expression", msg);
3677 : 17 : return true;
3678 : : }
3679 : : }
3680 : : return false;
3681 : : }
3682 : :
3683 : : /* Emit a diagnostic for an invalid type name. This function commits
3684 : : to the current active tentative parse, if any. (Otherwise, the
3685 : : problematic construct might be encountered again later, resulting
3686 : : in duplicate error messages.) LOCATION is the location of ID. */
3687 : :
3688 : : static void
3689 : 766 : cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree id,
3690 : : location_t location)
3691 : : {
3692 : 766 : tree decl, ambiguous_decls;
3693 : 766 : cp_parser_commit_to_tentative_parse (parser);
3694 : : /* Try to lookup the identifier. */
3695 : 766 : decl = cp_parser_lookup_name (parser, id, none_type,
3696 : : /*is_template=*/false,
3697 : : /*is_namespace=*/false,
3698 : : /*check_dependency=*/true,
3699 : : &ambiguous_decls, location);
3700 : 766 : if (ambiguous_decls)
3701 : : /* If the lookup was ambiguous, an error will already have
3702 : : been issued. */
3703 : 18 : return;
3704 : : /* If the lookup found a template-name, it means that the user forgot
3705 : : to specify an argument list. Emit a useful error message. */
3706 : 748 : if (DECL_TYPE_TEMPLATE_P (decl))
3707 : : {
3708 : 33 : auto_diagnostic_group d;
3709 : 33 : error_at (location,
3710 : : "invalid use of template-name %qE without an argument list",
3711 : : decl);
3712 : 33 : if (DECL_CLASS_TEMPLATE_P (decl) && cxx_dialect < cxx17)
3713 : 25 : inform (location, "class template argument deduction is only available "
3714 : : "with %<-std=c++17%> or %<-std=gnu++17%>");
3715 : 33 : inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3716 : 33 : }
3717 : 715 : else if (TREE_CODE (id) == BIT_NOT_EXPR)
3718 : 3 : error_at (location, "invalid use of destructor %qD as a type", id);
3719 : 712 : else if (TREE_CODE (decl) == TYPE_DECL)
3720 : : /* Something like 'unsigned A a;' */
3721 : 0 : error_at (location, "invalid combination of multiple type-specifiers");
3722 : 712 : else if (!parser->scope)
3723 : : {
3724 : : /* Issue an error message. */
3725 : 394 : auto_diagnostic_group d;
3726 : 394 : name_hint hint;
3727 : 394 : if (TREE_CODE (id) == IDENTIFIER_NODE)
3728 : 391 : hint = lookup_name_fuzzy (id, FUZZY_LOOKUP_TYPENAME, location);
3729 : 394 : if (const char *suggestion = hint.suggestion ())
3730 : : {
3731 : 54 : gcc_rich_location richloc (location);
3732 : 54 : richloc.add_fixit_replace (suggestion);
3733 : 54 : error_at (&richloc,
3734 : : "%qE does not name a type; did you mean %qs?",
3735 : : id, suggestion);
3736 : 54 : }
3737 : : else
3738 : 340 : error_at (location, "%qE does not name a type", id);
3739 : : /* If we're in a template class, it's possible that the user was
3740 : : referring to a type from a base class. For example:
3741 : :
3742 : : template <typename T> struct A { typedef T X; };
3743 : : template <typename T> struct B : public A<T> { X x; };
3744 : :
3745 : : The user should have said "typename A<T>::X". */
3746 : 394 : if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_CONSTEXPR])
3747 : 3 : inform (location, "C++11 %<constexpr%> only available with "
3748 : : "%<-std=c++11%> or %<-std=gnu++11%>");
3749 : 391 : else if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_NOEXCEPT])
3750 : 1 : inform (location, "C++11 %<noexcept%> only available with "
3751 : : "%<-std=c++11%> or %<-std=gnu++11%>");
3752 : 390 : else if (TREE_CODE (id) == IDENTIFIER_NODE
3753 : 390 : && (id_equal (id, "module") || id_equal (id, "import")))
3754 : : {
3755 : 17 : if (modules_p ())
3756 : 15 : inform (location, "%qE is not recognized as a module control-line",
3757 : : id);
3758 : 2 : else if (cxx_dialect < cxx20)
3759 : 1 : inform (location, "C++20 %qE only available with %<-fmodules-ts%>",
3760 : : id);
3761 : : else
3762 : 1 : inform (location, "C++20 %qE only available with %<-fmodules-ts%>"
3763 : : ", which is not yet enabled with %<-std=c++20%>", id);
3764 : : }
3765 : 373 : else if (cxx_dialect < cxx11
3766 : 106 : && TREE_CODE (id) == IDENTIFIER_NODE
3767 : 479 : && id_equal (id, "thread_local"))
3768 : 0 : inform (location, "C++11 %<thread_local%> only available with "
3769 : : "%<-std=c++11%> or %<-std=gnu++11%>");
3770 : 373 : else if (cxx_dialect < cxx20 && id == ridpointers[(int)RID_CONSTINIT])
3771 : 4 : inform (location, "C++20 %<constinit%> only available with "
3772 : : "%<-std=c++20%> or %<-std=gnu++20%>");
3773 : 369 : else if (!flag_concepts && id == ridpointers[(int)RID_CONCEPT])
3774 : 3 : inform (location, "%<concept%> only available with %<-std=c++20%> or "
3775 : : "%<-fconcepts%>");
3776 : 366 : else if (!flag_concepts && id == ridpointers[(int)RID_REQUIRES])
3777 : 3 : inform (location, "%<requires%> only available with %<-std=c++20%> or "
3778 : : "%<-fconcepts%>");
3779 : 53 : else if (processing_template_decl && current_class_type
3780 : 402 : && TYPE_BINFO (current_class_type))
3781 : : {
3782 : 39 : for (tree b = TREE_CHAIN (TYPE_BINFO (current_class_type));
3783 : 45 : b; b = TREE_CHAIN (b))
3784 : : {
3785 : 21 : tree base_type = BINFO_TYPE (b);
3786 : 21 : if (CLASS_TYPE_P (base_type)
3787 : 42 : && dependent_type_p (base_type))
3788 : : {
3789 : : /* Go from a particular instantiation of the
3790 : : template (which will have an empty TYPE_FIELDs),
3791 : : to the main version. */
3792 : 21 : base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
3793 : 21 : for (tree field = TYPE_FIELDS (base_type);
3794 : 63 : field; field = DECL_CHAIN (field))
3795 : 57 : if (TREE_CODE (field) == TYPE_DECL
3796 : 57 : && DECL_NAME (field) == id)
3797 : : {
3798 : 30 : inform (location,
3799 : : "(perhaps %<typename %T::%E%> was intended)",
3800 : 15 : BINFO_TYPE (b), id);
3801 : 15 : goto found;
3802 : : }
3803 : : }
3804 : : }
3805 : 394 : found:;
3806 : : }
3807 : 394 : }
3808 : : /* Here we diagnose qualified-ids where the scope is actually correct,
3809 : : but the identifier does not resolve to a valid type name. */
3810 : 318 : else if (parser->scope != error_mark_node)
3811 : : {
3812 : 287 : if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
3813 : : {
3814 : 110 : auto_diagnostic_group d;
3815 : 110 : name_hint hint;
3816 : 110 : if (decl == error_mark_node)
3817 : 184 : hint = suggest_alternative_in_explicit_scope (location, id,
3818 : 92 : parser->scope);
3819 : 110 : const char *suggestion = hint.suggestion ();
3820 : 110 : gcc_rich_location richloc (location_of (id));
3821 : 110 : if (suggestion)
3822 : 4 : richloc.add_fixit_replace (suggestion);
3823 : 110 : if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3824 : : {
3825 : 54 : if (suggestion)
3826 : 0 : error_at (&richloc,
3827 : : "%qE in namespace %qE does not name a template"
3828 : : " type; did you mean %qs?",
3829 : : id, parser->scope, suggestion);
3830 : : else
3831 : 54 : error_at (&richloc,
3832 : : "%qE in namespace %qE does not name a template type",
3833 : : id, parser->scope);
3834 : : }
3835 : 56 : else if (TREE_CODE (id) == TEMPLATE_ID_EXPR)
3836 : : {
3837 : 0 : if (suggestion)
3838 : 0 : error_at (&richloc,
3839 : : "%qE in namespace %qE does not name a template"
3840 : : " type; did you mean %qs?",
3841 : 0 : TREE_OPERAND (id, 0), parser->scope, suggestion);
3842 : : else
3843 : 0 : error_at (&richloc,
3844 : : "%qE in namespace %qE does not name a template"
3845 : : " type",
3846 : 0 : TREE_OPERAND (id, 0), parser->scope);
3847 : : }
3848 : : else
3849 : : {
3850 : 56 : if (suggestion)
3851 : 4 : error_at (&richloc,
3852 : : "%qE in namespace %qE does not name a type"
3853 : : "; did you mean %qs?",
3854 : : id, parser->scope, suggestion);
3855 : : else
3856 : 52 : error_at (&richloc,
3857 : : "%qE in namespace %qE does not name a type",
3858 : : id, parser->scope);
3859 : : }
3860 : 110 : if (DECL_P (decl))
3861 : 15 : inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3862 : 110 : }
3863 : 134 : else if (CLASS_TYPE_P (parser->scope)
3864 : 311 : && constructor_name_p (id, parser->scope))
3865 : : {
3866 : : /* A<T>::A<T>() */
3867 : 15 : auto_diagnostic_group d;
3868 : 15 : error_at (location, "%<%T::%E%> names the constructor, not"
3869 : : " the type", parser->scope, id);
3870 : 15 : if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3871 : 12 : error_at (location, "and %qT has no template constructors",
3872 : : parser->scope);
3873 : 15 : }
3874 : 162 : else if (TYPE_P (parser->scope)
3875 : 162 : && dependent_scope_p (parser->scope))
3876 : : {
3877 : 69 : gcc_rich_location richloc (location);
3878 : 69 : richloc.add_fixit_insert_before ("typename ");
3879 : 69 : if (TREE_CODE (parser->scope) == TYPENAME_TYPE)
3880 : 6 : error_at (&richloc,
3881 : : "need %<typename%> before %<%T::%D::%E%> because "
3882 : : "%<%T::%D%> is a dependent scope",
3883 : 6 : TYPE_CONTEXT (parser->scope),
3884 : 6 : TYPENAME_TYPE_FULLNAME (parser->scope),
3885 : : id,
3886 : 6 : TYPE_CONTEXT (parser->scope),
3887 : 6 : TYPENAME_TYPE_FULLNAME (parser->scope));
3888 : : else
3889 : 63 : error_at (&richloc, "need %<typename%> before %<%T::%E%> because "
3890 : : "%qT is a dependent scope",
3891 : : parser->scope, id, parser->scope);
3892 : 69 : }
3893 : 93 : else if (TYPE_P (parser->scope))
3894 : : {
3895 : 93 : auto_diagnostic_group d;
3896 : 93 : if (!COMPLETE_TYPE_P (parser->scope)
3897 : 93 : && !currently_open_class (parser->scope))
3898 : 17 : cxx_incomplete_type_error (location_of (id), NULL_TREE,
3899 : 17 : parser->scope);
3900 : 76 : else if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3901 : 9 : error_at (location_of (id),
3902 : : "%qE in %q#T does not name a template type",
3903 : : id, parser->scope);
3904 : 67 : else if (TREE_CODE (id) == TEMPLATE_ID_EXPR)
3905 : 0 : error_at (location_of (id),
3906 : : "%qE in %q#T does not name a template type",
3907 : 0 : TREE_OPERAND (id, 0), parser->scope);
3908 : : else
3909 : 67 : error_at (location_of (id),
3910 : : "%qE in %q#T does not name a type",
3911 : : id, parser->scope);
3912 : 93 : if (DECL_P (decl))
3913 : 3 : inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3914 : 93 : }
3915 : : else
3916 : 0 : gcc_unreachable ();
3917 : : }
3918 : : }
3919 : :
3920 : : /* Check for a common situation where a type-name should be present,
3921 : : but is not, and issue a sensible error message. Returns true if an
3922 : : invalid type-name was detected.
3923 : :
3924 : : The situation handled by this function are variable declarations of the
3925 : : form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3926 : : Usually, `ID' should name a type, but if we got here it means that it
3927 : : does not. We try to emit the best possible error message depending on
3928 : : how exactly the id-expression looks like. */
3929 : :
3930 : : static bool
3931 : 24969161 : cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
3932 : : {
3933 : 24969161 : tree id;
3934 : 24969161 : cp_token *token = cp_lexer_peek_token (parser->lexer);
3935 : :
3936 : : /* Avoid duplicate error about ambiguous lookup. */
3937 : 24969161 : if (token->type == CPP_NESTED_NAME_SPECIFIER)
3938 : : {
3939 : 940841 : cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
3940 : 940841 : if (next->type == CPP_NAME && next->error_reported)
3941 : 0 : goto out;
3942 : : }
3943 : :
3944 : 24969161 : cp_parser_parse_tentatively (parser);
3945 : 24969161 : id = cp_parser_id_expression (parser,
3946 : : /*template_keyword_p=*/false,
3947 : : /*check_dependency_p=*/true,
3948 : : /*template_p=*/NULL,
3949 : : /*declarator_p=*/true,
3950 : : /*optional_p=*/false);
3951 : : /* If the next token is a (, this is a function with no explicit return
3952 : : type, i.e. constructor, destructor or conversion op. */
3953 : 24969161 : if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
3954 : 24969161 : || TREE_CODE (id) == TYPE_DECL)
3955 : : {
3956 : 24967792 : cp_parser_abort_tentative_parse (parser);
3957 : 24967792 : return false;
3958 : : }
3959 : 1369 : if (!cp_parser_parse_definitely (parser))
3960 : : return false;
3961 : :
3962 : : /* Emit a diagnostic for the invalid type. */
3963 : 654 : cp_parser_diagnose_invalid_type_name (parser, id, token->location);
3964 : 654 : out:
3965 : : /* If we aren't in the middle of a declarator (i.e. in a
3966 : : parameter-declaration-clause), skip to the end of the declaration;
3967 : : there's no point in trying to process it. */
3968 : 654 : if (!parser->in_declarator_p)
3969 : 536 : cp_parser_skip_to_end_of_block_or_statement (parser);
3970 : : return true;
3971 : : }
3972 : :
3973 : : /* Consume tokens up to, and including, the next non-nested closing `)'.
3974 : : Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3975 : : are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
3976 : : found an unnested token of that type. */
3977 : :
3978 : : static int
3979 : 113626019 : cp_parser_skip_to_closing_parenthesis_1 (cp_parser *parser,
3980 : : bool recovering,
3981 : : cpp_ttype or_ttype,
3982 : : bool consume_paren)
3983 : : {
3984 : 113626019 : unsigned paren_depth = 0;
3985 : 113626019 : unsigned brace_depth = 0;
3986 : 113626019 : unsigned square_depth = 0;
3987 : 113626019 : unsigned condop_depth = 0;
3988 : :
3989 : 227252038 : if (recovering && or_ttype == CPP_EOF
3990 : 227252038 : && cp_parser_uncommitted_to_tentative_parse_p (parser))
3991 : : return 0;
3992 : :
3993 : 1032710051 : while (true)
3994 : : {
3995 : 1032710051 : cp_token * token = cp_lexer_peek_token (parser->lexer);
3996 : :
3997 : : /* Have we found what we're looking for before the closing paren? */
3998 : 1032710051 : if (token->type == or_ttype && or_ttype != CPP_EOF
3999 : 5424384 : && !brace_depth && !paren_depth && !square_depth && !condop_depth)
4000 : : return -1;
4001 : :
4002 : 1027331092 : switch (token->type)
4003 : : {
4004 : 219 : case CPP_PRAGMA_EOL:
4005 : 219 : if (!parser->lexer->in_pragma)
4006 : : break;
4007 : : /* FALLTHRU */
4008 : : case CPP_EOF:
4009 : : /* If we've run out of tokens, then there is no closing `)'. */
4010 : : return 0;
4011 : :
4012 : : /* This is good for lambda expression capture-lists. */
4013 : 5220312 : case CPP_OPEN_SQUARE:
4014 : 5220312 : ++square_depth;
4015 : 5220312 : break;
4016 : 5220374 : case CPP_CLOSE_SQUARE:
4017 : 5220374 : if (!square_depth--)
4018 : : return 0;
4019 : : break;
4020 : :
4021 : 6464075 : case CPP_SEMICOLON:
4022 : : /* This matches the processing in skip_to_end_of_statement. */
4023 : 6464075 : if (!brace_depth)
4024 : : return 0;
4025 : : break;
4026 : :
4027 : 522414 : case CPP_OPEN_BRACE:
4028 : 522414 : ++brace_depth;
4029 : 522414 : break;
4030 : 522447 : case CPP_CLOSE_BRACE:
4031 : 522447 : if (!brace_depth--)
4032 : : return 0;
4033 : : break;
4034 : :
4035 : 126244164 : case CPP_OPEN_PAREN:
4036 : 126244164 : if (!brace_depth)
4037 : 125221937 : ++paren_depth;
4038 : : break;
4039 : :
4040 : 229152150 : case CPP_CLOSE_PAREN:
4041 : 229152150 : if (!brace_depth && !paren_depth--)
4042 : : {
4043 : 102907986 : if (consume_paren)
4044 : 63101876 : cp_lexer_consume_token (parser->lexer);
4045 : 102907986 : return 1;
4046 : : }
4047 : : break;
4048 : :
4049 : 3859126 : case CPP_QUERY:
4050 : 3859126 : if (!brace_depth && !paren_depth && !square_depth)
4051 : 2769347 : ++condop_depth;
4052 : : break;
4053 : :
4054 : 4066632 : case CPP_COLON:
4055 : 4066632 : if (!brace_depth && !paren_depth && !square_depth && condop_depth > 0)
4056 : 2769335 : condop_depth--;
4057 : : break;
4058 : :
4059 : 45968705 : case CPP_KEYWORD:
4060 : 45968705 : if (!cp_token_is_module_directive (token))
4061 : : break;
4062 : : /* FALLTHROUGH */
4063 : :
4064 : 12 : case CPP_PRAGMA:
4065 : : /* We fell into a pragma. Skip it, and continue. */
4066 : 24 : cp_parser_skip_to_pragma_eol (parser, recovering ? token : nullptr);
4067 : 12 : continue;
4068 : :
4069 : : default:
4070 : : break;
4071 : : }
4072 : :
4073 : : /* Consume the token. */
4074 : 919084060 : cp_lexer_consume_token (parser->lexer);
4075 : : }
4076 : : }
4077 : :
4078 : : /* Consume tokens up to, and including, the next non-nested closing `)'.
4079 : : Returns 1 iff we found a closing `)'. RECOVERING is true, if we
4080 : : are doing error recovery. Returns -1 if OR_COMMA is true and we
4081 : : found an unnested token of that type. */
4082 : :
4083 : : static int
4084 : 63102596 : cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
4085 : : bool recovering,
4086 : : bool or_comma,
4087 : : bool consume_paren)
4088 : : {
4089 : 0 : cpp_ttype ttype = or_comma ? CPP_COMMA : CPP_EOF;
4090 : 0 : return cp_parser_skip_to_closing_parenthesis_1 (parser, recovering,
4091 : 442 : ttype, consume_paren);
4092 : : }
4093 : :
4094 : : /* Consume tokens until we reach the end of the current statement.
4095 : : Normally, that will be just before consuming a `;'. However, if a
4096 : : non-nested `}' comes first, then we stop before consuming that. */
4097 : :
4098 : : static void
4099 : 3555 : cp_parser_skip_to_end_of_statement (cp_parser* parser)
4100 : : {
4101 : 3555 : unsigned nesting_depth = 0;
4102 : :
4103 : : /* Unwind generic function template scope if necessary. */
4104 : 3555 : if (parser->fully_implicit_function_template_p)
4105 : 6 : abort_fully_implicit_template (parser);
4106 : :
4107 : 9244 : while (true)
4108 : : {
4109 : 9244 : cp_token *token = cp_lexer_peek_token (parser->lexer);
4110 : :
4111 : 9244 : switch (token->type)
4112 : : {
4113 : 0 : case CPP_PRAGMA_EOL:
4114 : 0 : if (!parser->lexer->in_pragma)
4115 : : break;
4116 : : /* FALLTHRU */
4117 : : case CPP_EOF:
4118 : : /* If we've run out of tokens, stop. */
4119 : : return;
4120 : :
4121 : 2970 : case CPP_SEMICOLON:
4122 : : /* If the next token is a `;', we have reached the end of the
4123 : : statement. */
4124 : 2970 : if (!nesting_depth)
4125 : : return;
4126 : : break;
4127 : :
4128 : 409 : case CPP_CLOSE_BRACE:
4129 : : /* If this is a non-nested '}', stop before consuming it.
4130 : : That way, when confronted with something like:
4131 : :
4132 : : { 3 + }
4133 : :
4134 : : we stop before consuming the closing '}', even though we
4135 : : have not yet reached a `;'. */
4136 : 409 : if (nesting_depth == 0)
4137 : : return;
4138 : :
4139 : : /* If it is the closing '}' for a block that we have
4140 : : scanned, stop -- but only after consuming the token.
4141 : : That way given:
4142 : :
4143 : : void f g () { ... }
4144 : : typedef int I;
4145 : :
4146 : : we will stop after the body of the erroneously declared
4147 : : function, but before consuming the following `typedef'
4148 : : declaration. */
4149 : 364 : if (--nesting_depth == 0)
4150 : : {
4151 : 352 : cp_lexer_consume_token (parser->lexer);
4152 : 352 : return;
4153 : : }
4154 : : break;
4155 : :
4156 : 367 : case CPP_OPEN_BRACE:
4157 : 367 : ++nesting_depth;
4158 : 367 : break;
4159 : :
4160 : 972 : case CPP_KEYWORD:
4161 : 972 : if (!cp_token_is_module_directive (token))
4162 : : break;
4163 : : /* FALLTHROUGH */
4164 : :
4165 : 24 : case CPP_PRAGMA:
4166 : : /* We fell into a pragma. Skip it, and continue or return. */
4167 : 24 : cp_parser_skip_to_pragma_eol (parser, token);
4168 : 24 : if (!nesting_depth)
4169 : : return;
4170 : 9 : continue;
4171 : :
4172 : : default:
4173 : : break;
4174 : : }
4175 : :
4176 : : /* Consume the token. */
4177 : 5680 : cp_lexer_consume_token (parser->lexer);
4178 : : }
4179 : : }
4180 : :
4181 : : /* This function is called at the end of a statement or declaration.
4182 : : If the next token is a semicolon, it is consumed; otherwise, error
4183 : : recovery is attempted. */
4184 : :
4185 : : static void
4186 : 98703035 : cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
4187 : : {
4188 : : /* Look for the trailing `;'. */
4189 : 98703035 : if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
4190 : : {
4191 : : /* If there is additional (erroneous) input, skip to the end of
4192 : : the statement. */
4193 : 142 : cp_parser_skip_to_end_of_statement (parser);
4194 : : /* If the next token is now a `;', consume it. */
4195 : 142 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
4196 : 85 : cp_lexer_consume_token (parser->lexer);
4197 : : }
4198 : 98703035 : }
4199 : :
4200 : : /* Skip tokens until we have consumed an entire block, or until we
4201 : : have consumed a non-nested `;'. */
4202 : :
4203 : : static void
4204 : 14202 : cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
4205 : : {
4206 : 14202 : int nesting_depth = 0;
4207 : :
4208 : : /* Unwind generic function template scope if necessary. */
4209 : 14202 : if (parser->fully_implicit_function_template_p)
4210 : 15 : abort_fully_implicit_template (parser);
4211 : :
4212 : 35664 : while (nesting_depth >= 0)
4213 : : {
4214 : 21688 : cp_token *token = cp_lexer_peek_token (parser->lexer);
4215 : :
4216 : 21688 : switch (token->type)
4217 : : {
4218 : 0 : case CPP_PRAGMA_EOL:
4219 : 0 : if (!parser->lexer->in_pragma)
4220 : : break;
4221 : : /* FALLTHRU */
4222 : : case CPP_EOF:
4223 : : /* If we've run out of tokens, stop. */
4224 : : return;
4225 : :
4226 : 13347 : case CPP_SEMICOLON:
4227 : : /* Stop if this is an unnested ';'. */
4228 : 13347 : if (!nesting_depth)
4229 : 13976 : nesting_depth = -1;
4230 : : break;
4231 : :
4232 : 1266 : case CPP_CLOSE_BRACE:
4233 : : /* Stop if this is an unnested '}', or closes the outermost
4234 : : nesting level. */
4235 : 1266 : nesting_depth--;
4236 : 1266 : if (nesting_depth < 0)
4237 : : return;
4238 : 1125 : if (!nesting_depth)
4239 : 13976 : nesting_depth = -1;
4240 : : break;
4241 : :
4242 : 1131 : case CPP_OPEN_BRACE:
4243 : : /* Nest. */
4244 : 1131 : nesting_depth++;
4245 : 1131 : break;
4246 : :
4247 : 944 : case CPP_KEYWORD:
4248 : 944 : if (!cp_token_is_module_directive (token))
4249 : : break;
4250 : : /* FALLTHROUGH */
4251 : :
4252 : 12 : case CPP_PRAGMA:
4253 : : /* Skip it, and continue or return. */
4254 : 12 : cp_parser_skip_to_pragma_eol (parser, token);
4255 : 12 : if (!nesting_depth)
4256 : : return;
4257 : 0 : continue;
4258 : :
4259 : : default:
4260 : : break;
4261 : : }
4262 : :
4263 : : /* Consume the token. */
4264 : 21462 : cp_lexer_consume_token (parser->lexer);
4265 : : }
4266 : : }
4267 : :
4268 : : /* Skip tokens until a non-nested closing curly brace is the next
4269 : : token, or there are no more tokens. Return true in the first case,
4270 : : false otherwise. */
4271 : :
4272 : : static bool
4273 : 181 : cp_parser_skip_to_closing_brace (cp_parser *parser)
4274 : : {
4275 : 181 : unsigned nesting_depth = 0;
4276 : :
4277 : 821 : while (true)
4278 : : {
4279 : 501 : cp_token *token = cp_lexer_peek_token (parser->lexer);
4280 : :
4281 : 501 : switch (token->type)
4282 : : {
4283 : 6 : case CPP_PRAGMA_EOL:
4284 : 6 : if (!parser->lexer->in_pragma)
4285 : : break;
4286 : : /* FALLTHRU */
4287 : : case CPP_EOF:
4288 : : /* If we've run out of tokens, stop. */
4289 : : return false;
4290 : :
4291 : 170 : case CPP_CLOSE_BRACE:
4292 : : /* If the next token is a non-nested `}', then we have reached
4293 : : the end of the current block. */
4294 : 170 : if (nesting_depth-- == 0)
4295 : : return true;
4296 : : break;
4297 : :
4298 : 4 : case CPP_OPEN_BRACE:
4299 : : /* If it the next token is a `{', then we are entering a new
4300 : : block. Consume the entire block. */
4301 : 4 : ++nesting_depth;
4302 : 4 : break;
4303 : :
4304 : : default:
4305 : : break;
4306 : : }
4307 : :
4308 : : /* Consume the token. */
4309 : 320 : cp_lexer_consume_token (parser->lexer);
4310 : 320 : }
4311 : : }
4312 : :
4313 : : /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
4314 : : parameter is the PRAGMA token, allowing us to purge the entire pragma
4315 : : sequence. PRAGMA_TOK can be NULL, if we're speculatively scanning
4316 : : forwards (not error recovery). */
4317 : :
4318 : : static void
4319 : 2126707 : cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
4320 : : {
4321 : 2130151 : cp_token *token;
4322 : :
4323 : 2130151 : do
4324 : : {
4325 : : /* The preprocessor makes sure that a PRAGMA_EOL token appears
4326 : : before an EOF token, even when the EOF is on the pragma line.
4327 : : We should never get here without being inside a deferred
4328 : : pragma. */
4329 : 2130151 : gcc_checking_assert (cp_lexer_next_token_is_not (parser->lexer, CPP_EOF));
4330 : 2130151 : token = cp_lexer_consume_token (parser->lexer);
4331 : : }
4332 : 2130151 : while (token->type != CPP_PRAGMA_EOL);
4333 : :
4334 : 2126707 : if (pragma_tok)
4335 : : {
4336 : 2126695 : parser->lexer->in_pragma = false;
4337 : 2126695 : if (parser->lexer->in_omp_attribute_pragma
4338 : 2126695 : && cp_lexer_next_token_is (parser->lexer, CPP_EOF))
4339 : : {
4340 : 1355 : parser->lexer = parser->lexer->next;
4341 : : /* Put the current source position back where it was before this
4342 : : lexer was pushed. */
4343 : 1355 : cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4344 : : }
4345 : : }
4346 : 2126707 : }
4347 : :
4348 : : /* Require pragma end of line, resyncing with it as necessary. The
4349 : : arguments are as for cp_parser_skip_to_pragma_eol. */
4350 : :
4351 : : static void
4352 : 14916 : cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
4353 : : {
4354 : 14916 : parser->lexer->in_pragma = false;
4355 : 14916 : if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
4356 : 142 : cp_parser_skip_to_pragma_eol (parser, pragma_tok);
4357 : 14774 : else if (parser->lexer->in_omp_attribute_pragma
4358 : 14774 : && cp_lexer_next_token_is (parser->lexer, CPP_EOF))
4359 : : {
4360 : 651 : parser->lexer = parser->lexer->next;
4361 : : /* Put the current source position back where it was before this
4362 : : lexer was pushed. */
4363 : 651 : cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4364 : : }
4365 : 14916 : }
4366 : :
4367 : : /* This is a simple wrapper around make_typename_type. When the id is
4368 : : an unresolved identifier node, we can provide a superior diagnostic
4369 : : using cp_parser_diagnose_invalid_type_name. */
4370 : :
4371 : : static tree
4372 : 26928741 : cp_parser_make_typename_type (cp_parser *parser, tree id,
4373 : : location_t id_location)
4374 : : {
4375 : 26928741 : tree result;
4376 : 26928741 : if (identifier_p (id))
4377 : : {
4378 : 26928717 : result = make_typename_type (parser->scope, id, typename_type,
4379 : : /*complain=*/tf_none);
4380 : 26928717 : if (result == error_mark_node)
4381 : 43 : cp_parser_diagnose_invalid_type_name (parser, id, id_location);
4382 : 26928717 : return result;
4383 : : }
4384 : 24 : return make_typename_type (parser->scope, id, typename_type, tf_error);
4385 : : }
4386 : :
4387 : : /* This is a wrapper around the
4388 : : make_{pointer,ptrmem,reference}_declarator functions that decides
4389 : : which one to call based on the CODE and CLASS_TYPE arguments. The
4390 : : CODE argument should be one of the values returned by
4391 : : cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
4392 : : appertain to the pointer or reference. */
4393 : :
4394 : : static cp_declarator *
4395 : 171805967 : cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
4396 : : cp_cv_quals cv_qualifiers,
4397 : : cp_declarator *target,
4398 : : tree attributes)
4399 : : {
4400 : 171805967 : if (code == ERROR_MARK || target == cp_error_declarator)
4401 : 52 : return cp_error_declarator;
4402 : :
4403 : 171805915 : if (code == INDIRECT_REF)
4404 : 60562688 : if (class_type == NULL_TREE)
4405 : 59404448 : return make_pointer_declarator (cv_qualifiers, target, attributes);
4406 : : else
4407 : 1158240 : return make_ptrmem_declarator (cv_qualifiers, class_type,
4408 : 1158240 : target, attributes);
4409 : 111243227 : else if (code == ADDR_EXPR && class_type == NULL_TREE)
4410 : 94971234 : return make_reference_declarator (cv_qualifiers, target,
4411 : 94971234 : false, attributes);
4412 : 16271993 : else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
4413 : 16271993 : return make_reference_declarator (cv_qualifiers, target,
4414 : 16271993 : true, attributes);
4415 : 0 : gcc_unreachable ();
4416 : : }
4417 : :
4418 : : /* Create a new C++ parser. */
4419 : :
4420 : : static cp_parser *
4421 : 92049 : cp_parser_new (cp_lexer *lexer)
4422 : : {
4423 : : /* Initialize the binops_by_token so that we can get the tree
4424 : : directly from the token. */
4425 : 2025078 : for (unsigned i = 0; i < ARRAY_SIZE (binops); i++)
4426 : 1933029 : binops_by_token[binops[i].token_type] = binops[i];
4427 : :
4428 : 92049 : cp_parser *parser = ggc_cleared_alloc<cp_parser> ();
4429 : 92049 : parser->lexer = lexer;
4430 : 92049 : parser->context = cp_parser_context_new (NULL);
4431 : :
4432 : : /* For now, we always accept GNU extensions. */
4433 : 92049 : parser->allow_gnu_extensions_p = 1;
4434 : :
4435 : : /* The `>' token is a greater-than operator, not the end of a
4436 : : template-id. */
4437 : 92049 : parser->greater_than_is_operator_p = true;
4438 : :
4439 : 92049 : parser->default_arg_ok_p = true;
4440 : :
4441 : : /* We are not parsing a constant-expression. */
4442 : 92049 : parser->integral_constant_expression_p = false;
4443 : 92049 : parser->allow_non_integral_constant_expression_p = false;
4444 : 92049 : parser->non_integral_constant_expression_p = false;
4445 : :
4446 : : /* Local variable names are not forbidden. */
4447 : 92049 : parser->local_variables_forbidden_p = 0;
4448 : :
4449 : : /* We are not processing an `extern "C"' declaration. */
4450 : 92049 : parser->in_unbraced_linkage_specification_p = false;
4451 : :
4452 : : /* We aren't parsing an export-declaration. */
4453 : 92049 : parser->in_unbraced_export_declaration_p = false;
4454 : :
4455 : : /* We are not processing a declarator. */
4456 : 92049 : parser->in_declarator_p = false;
4457 : :
4458 : : /* We are not processing a template-argument-list. */
4459 : 92049 : parser->in_template_argument_list_p = false;
4460 : :
4461 : : /* We are not in an iteration statement. */
4462 : 92049 : parser->in_statement = 0;
4463 : :
4464 : : /* We are not in a switch statement. */
4465 : 92049 : parser->in_switch_statement_p = false;
4466 : :
4467 : : /* We are not parsing a type-id inside an expression. */
4468 : 92049 : parser->in_type_id_in_expr_p = false;
4469 : :
4470 : : /* String literals should be translated to the execution character set. */
4471 : 92049 : parser->translate_strings_p = true;
4472 : :
4473 : : /* We are not parsing a function body. */
4474 : 92049 : parser->in_function_body = false;
4475 : :
4476 : : /* We can correct until told otherwise. */
4477 : 92049 : parser->colon_corrects_to_scope_p = true;
4478 : :
4479 : : /* The unparsed function queue is empty. */
4480 : 92049 : push_unparsed_function_queues (parser);
4481 : :
4482 : : /* There are no classes being defined. */
4483 : 92049 : parser->num_classes_being_defined = 0;
4484 : :
4485 : : /* No template parameters apply. */
4486 : 92049 : parser->num_template_parameter_lists = 0;
4487 : :
4488 : : /* Special parsing data structures. */
4489 : 92049 : parser->omp_declare_simd = NULL;
4490 : 92049 : parser->oacc_routine = NULL;
4491 : :
4492 : : /* Disallow OpenMP array sections in expressions. */
4493 : 92049 : parser->omp_array_section_p = false;
4494 : :
4495 : : /* Not declaring an implicit function template. */
4496 : 92049 : parser->auto_is_implicit_function_template_parm_p = false;
4497 : 92049 : parser->fully_implicit_function_template_p = false;
4498 : 92049 : parser->implicit_template_parms = 0;
4499 : 92049 : parser->implicit_template_scope = 0;
4500 : :
4501 : : /* Allow constrained-type-specifiers. */
4502 : 92049 : parser->prevent_constrained_type_specifiers = 0;
4503 : :
4504 : : /* We haven't yet seen an 'extern "C"'. */
4505 : 92049 : parser->innermost_linkage_specification_location = UNKNOWN_LOCATION;
4506 : :
4507 : 92049 : return parser;
4508 : : }
4509 : :
4510 : : /* Create a cp_lexer structure which will emit the tokens in CACHE
4511 : : and push it onto the parser's lexer stack. This is used for delayed
4512 : : parsing of in-class method bodies and default arguments, and should
4513 : : not be confused with tentative parsing. */
4514 : : static void
4515 : 72605996 : cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
4516 : : {
4517 : 72605996 : cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
4518 : 72605996 : lexer->next = parser->lexer;
4519 : 72605996 : parser->lexer = lexer;
4520 : :
4521 : : /* Move the current source position to that of the first token in the
4522 : : new lexer. */
4523 : 72605996 : cp_lexer_set_source_position_from_token (lexer->next_token);
4524 : 72605996 : }
4525 : :
4526 : : /* Pop the top lexer off the parser stack. This is never used for the
4527 : : "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4528 : : static void
4529 : 72605996 : cp_parser_pop_lexer (cp_parser *parser)
4530 : : {
4531 : 72605996 : cp_lexer *lexer = parser->lexer;
4532 : 72605996 : parser->lexer = lexer->next;
4533 : 72605996 : cp_lexer_destroy (lexer);
4534 : :
4535 : : /* Put the current source position back where it was before this
4536 : : lexer was pushed. */
4537 : 72605996 : cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4538 : 72605996 : }
4539 : :
4540 : : /* Lexical conventions [gram.lex] */
4541 : :
4542 : : /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4543 : : identifier. */
4544 : :
4545 : : static cp_expr
4546 : 6006650754 : cp_parser_identifier (cp_parser* parser)
4547 : : {
4548 : 6006650754 : cp_token *token;
4549 : :
4550 : : /* Look for the identifier. */
4551 : 6006650754 : token = cp_parser_require (parser, CPP_NAME, RT_NAME);
4552 : : /* Return the value. */
4553 : 6006650754 : if (token)
4554 : 4792614816 : return cp_expr (token->u.value, token->location);
4555 : : else
4556 : 1214035938 : return error_mark_node;
4557 : : }
4558 : :
4559 : : /* Worker for cp_parser_string_literal, cp_parser_userdef_string_literal
4560 : : and cp_parser_unevaluated_string_literal.
4561 : : Do not call this directly; use either of the above.
4562 : :
4563 : : Parse a sequence of adjacent string constants. Return a
4564 : : TREE_STRING representing the combined, nul-terminated string
4565 : : constant. If TRANSLATE is true, translate the string to the
4566 : : execution character set. If WIDE_OK is true, a wide string is
4567 : : valid here. If UDL_OK is true, a string literal with user-defined
4568 : : suffix can be used in this context. If UNEVAL is true, diagnose
4569 : : numeric and conditional escape sequences in it if pedantic.
4570 : :
4571 : : C++98 [lex.string] says that if a narrow string literal token is
4572 : : adjacent to a wide string literal token, the behavior is undefined.
4573 : : However, C99 6.4.5p4 says that this results in a wide string literal.
4574 : : We follow C99 here, for consistency with the C front end.
4575 : :
4576 : : This code is largely lifted from lex_string() in c-lex.cc.
4577 : :
4578 : : FUTURE: ObjC++ will need to handle @-strings here. */
4579 : :
4580 : : static cp_expr
4581 : 16505762 : cp_parser_string_literal_common (cp_parser *parser, bool translate,
4582 : : bool wide_ok, bool udl_ok,
4583 : : bool lookup_udlit, bool uneval)
4584 : : {
4585 : 16505762 : tree value;
4586 : 16505762 : size_t count;
4587 : 16505762 : struct obstack str_ob;
4588 : 16505762 : struct obstack loc_ob;
4589 : 16505762 : cpp_string str, istr, *strs;
4590 : 16505762 : cp_token *tok;
4591 : 16505762 : enum cpp_ttype type, curr_type;
4592 : 16505762 : int have_suffix_p = 0;
4593 : 16505762 : tree string_tree;
4594 : 16505762 : tree suffix_id = NULL_TREE;
4595 : 16505762 : bool curr_tok_is_userdef_p = false;
4596 : :
4597 : 16505762 : tok = cp_lexer_peek_token (parser->lexer);
4598 : 16505762 : if (!cp_parser_is_string_literal (tok))
4599 : : {
4600 : 13 : cp_parser_error (parser, "expected string-literal");
4601 : 13 : return error_mark_node;
4602 : : }
4603 : :
4604 : 16505749 : location_t loc = tok->location;
4605 : :
4606 : 16505749 : if (cpp_userdef_string_p (tok->type))
4607 : : {
4608 : 544892 : if (!udl_ok)
4609 : : {
4610 : 4 : error_at (loc, "string literal with user-defined suffix "
4611 : : "is invalid in this context");
4612 : 4 : return error_mark_node;
4613 : : }
4614 : 544888 : string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
4615 : 544888 : curr_type = cpp_userdef_string_remove_type (tok->type);
4616 : 544888 : curr_tok_is_userdef_p = true;
4617 : : }
4618 : : else
4619 : : {
4620 : 15960857 : string_tree = tok->u.value;
4621 : 15960857 : curr_type = tok->type;
4622 : : }
4623 : 16505745 : type = curr_type;
4624 : :
4625 : : /* Try to avoid the overhead of creating and destroying an obstack
4626 : : for the common case of just one string. */
4627 : 33011490 : if (!cp_parser_is_string_literal
4628 : 16505745 : (cp_lexer_peek_nth_token (parser->lexer, 2)))
4629 : : {
4630 : 14537654 : cp_lexer_consume_token (parser->lexer);
4631 : :
4632 : 14537654 : str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
4633 : 14537654 : str.len = TREE_STRING_LENGTH (string_tree);
4634 : 14537654 : count = 1;
4635 : :
4636 : 14537654 : if (curr_tok_is_userdef_p)
4637 : : {
4638 : 544867 : suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
4639 : 544867 : have_suffix_p = 1;
4640 : 544867 : curr_type = cpp_userdef_string_remove_type (tok->type);
4641 : : }
4642 : : else
4643 : 16505743 : curr_type = tok->type;
4644 : :
4645 : : strs = &str;
4646 : : }
4647 : : else
4648 : : {
4649 : 1968091 : location_t last_tok_loc = tok->location;
4650 : 1968091 : gcc_obstack_init (&str_ob);
4651 : 1968091 : gcc_obstack_init (&loc_ob);
4652 : 1968091 : count = 0;
4653 : :
4654 : 5163441 : do
4655 : : {
4656 : 5163441 : cp_lexer_consume_token (parser->lexer);
4657 : 5163441 : count++;
4658 : 5163441 : str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
4659 : 5163441 : str.len = TREE_STRING_LENGTH (string_tree);
4660 : :
4661 : 5163441 : if (curr_tok_is_userdef_p)
4662 : : {
4663 : 57 : tree curr_suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
4664 : 57 : if (have_suffix_p == 0)
4665 : : {
4666 : : suffix_id = curr_suffix_id;
4667 : : have_suffix_p = 1;
4668 : : }
4669 : 15 : else if (have_suffix_p == 1
4670 : 15 : && curr_suffix_id != suffix_id)
4671 : : {
4672 : 9 : error ("inconsistent user-defined literal suffixes"
4673 : : " %qD and %qD in string literal",
4674 : : suffix_id, curr_suffix_id);
4675 : 9 : have_suffix_p = -1;
4676 : : }
4677 : 57 : curr_type = cpp_userdef_string_remove_type (tok->type);
4678 : : }
4679 : : else
4680 : 5163384 : curr_type = tok->type;
4681 : :
4682 : 5163441 : if (type != curr_type)
4683 : : {
4684 : 12525 : if (type == CPP_STRING)
4685 : : type = curr_type;
4686 : 12390 : else if (curr_type != CPP_STRING)
4687 : : {
4688 : 78 : rich_location rich_loc (line_table, tok->location);
4689 : 78 : rich_loc.add_range (last_tok_loc);
4690 : 78 : error_at (&rich_loc,
4691 : : "concatenation of string literals with "
4692 : : "conflicting encoding prefixes");
4693 : 78 : }
4694 : : }
4695 : :
4696 : 5163441 : obstack_grow (&str_ob, &str, sizeof (cpp_string));
4697 : 5163441 : obstack_grow (&loc_ob, &tok->location, sizeof (location_t));
4698 : :
4699 : 5163441 : last_tok_loc = tok->location;
4700 : :
4701 : 5163441 : tok = cp_lexer_peek_token (parser->lexer);
4702 : 5163441 : if (cpp_userdef_string_p (tok->type))
4703 : : {
4704 : 38 : if (!udl_ok)
4705 : : {
4706 : 2 : error_at (loc, "string literal with user-defined suffix "
4707 : : "is invalid in this context");
4708 : 2 : return error_mark_node;
4709 : : }
4710 : 36 : string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
4711 : 36 : curr_type = cpp_userdef_string_remove_type (tok->type);
4712 : 36 : curr_tok_is_userdef_p = true;
4713 : : }
4714 : : else
4715 : : {
4716 : 5163403 : string_tree = tok->u.value;
4717 : 5163403 : curr_type = tok->type;
4718 : 5163403 : curr_tok_is_userdef_p = false;
4719 : : }
4720 : : }
4721 : 5163439 : while (cp_parser_is_string_literal (tok));
4722 : :
4723 : : /* A string literal built by concatenation has its caret=start at
4724 : : the start of the initial string, and its finish at the finish of
4725 : : the final string literal. */
4726 : 1968089 : loc = make_location (loc, loc, get_finish (last_tok_loc));
4727 : :
4728 : 1968089 : strs = (cpp_string *) obstack_finish (&str_ob);
4729 : : }
4730 : :
4731 : 16505743 : if (type != CPP_STRING && !wide_ok)
4732 : : {
4733 : 74 : cp_parser_error (parser, "a wide string is invalid in this context");
4734 : 74 : type = CPP_STRING;
4735 : : }
4736 : 16505743 : if (uneval)
4737 : 515382 : type = CPP_UNEVAL_STRING;
4738 : :
4739 : 33011486 : if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
4740 : 16505743 : (parse_in, strs, count, &istr, type))
4741 : : {
4742 : 16505739 : value = build_string (istr.len, (const char *)istr.text);
4743 : 16505739 : free (CONST_CAST (unsigned char *, istr.text));
4744 : 16505739 : if (count > 1)
4745 : : {
4746 : 1968089 : location_t *locs = (location_t *)obstack_finish (&loc_ob);
4747 : 1968089 : gcc_assert (g_string_concat_db);
4748 : 1968089 : g_string_concat_db->record_string_concatenation (count, locs);
4749 : : }
4750 : :
4751 : 16505739 : switch (type)
4752 : : {
4753 : 16384753 : default:
4754 : 16384753 : case CPP_STRING:
4755 : 16384753 : TREE_TYPE (value) = char_array_type_node;
4756 : 16384753 : break;
4757 : 646 : case CPP_UTF8STRING:
4758 : 646 : if (flag_char8_t)
4759 : 257 : TREE_TYPE (value) = char8_array_type_node;
4760 : : else
4761 : 389 : TREE_TYPE (value) = char_array_type_node;
4762 : : break;
4763 : 628 : case CPP_STRING16:
4764 : 628 : TREE_TYPE (value) = char16_array_type_node;
4765 : 628 : break;
4766 : 685 : case CPP_STRING32:
4767 : 685 : TREE_TYPE (value) = char32_array_type_node;
4768 : 685 : break;
4769 : 119027 : case CPP_WSTRING:
4770 : 119027 : TREE_TYPE (value) = wchar_array_type_node;
4771 : 119027 : break;
4772 : : }
4773 : :
4774 : 16505739 : value = fix_string_type (value);
4775 : :
4776 : 16505739 : if (have_suffix_p)
4777 : : {
4778 : 544909 : tree literal = build_userdef_literal (suffix_id, value,
4779 : : OT_NONE, NULL_TREE);
4780 : 544909 : if (lookup_udlit)
4781 : 881 : value = finish_userdef_string_literal (literal);
4782 : : else
4783 : : value = literal;
4784 : : }
4785 : : }
4786 : : else
4787 : : /* cpp_interpret_string has issued an error. */
4788 : 4 : value = error_mark_node;
4789 : :
4790 : 16505743 : if (count > 1)
4791 : : {
4792 : 1968089 : obstack_free (&str_ob, 0);
4793 : 1968089 : obstack_free (&loc_ob, 0);
4794 : : }
4795 : :
4796 : 16505743 : return cp_expr (value, loc);
4797 : : }
4798 : :
4799 : : /* Parse a sequence of adjacent string constants. Return a TREE_STRING
4800 : : representing the combined, nul-terminated string constant. If
4801 : : TRANSLATE is true, translate the string to the execution character set.
4802 : : If WIDE_OK is true, a wide string is valid here.
4803 : :
4804 : : This function issues an error if a user defined string literal is
4805 : : encountered; use cp_parser_userdef_string_literal if UDLs are allowed. */
4806 : :
4807 : : static inline cp_expr
4808 : 9757317 : cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
4809 : : {
4810 : 9757317 : return cp_parser_string_literal_common (parser, translate, wide_ok,
4811 : : /*udl_ok=*/false,
4812 : : /*lookup_udlit=*/false,
4813 : : /*uneval=*/false);
4814 : : }
4815 : :
4816 : : /* Parse a string literal or user defined string literal.
4817 : :
4818 : : user-defined-string-literal :
4819 : : string-literal ud-suffix
4820 : :
4821 : : If LOOKUP_UDLIT, perform a lookup for a suitable template function. */
4822 : :
4823 : : static inline cp_expr
4824 : 6233050 : cp_parser_userdef_string_literal (cp_parser *parser, bool lookup_udlit)
4825 : : {
4826 : 6233050 : return cp_parser_string_literal_common (parser, /*translate=*/true,
4827 : : /*wide_ok=*/true, /*udl_ok=*/true,
4828 : 6233050 : lookup_udlit, /*uneval=*/false);
4829 : : }
4830 : :
4831 : : /* Parse an unevaluated string literal.
4832 : :
4833 : : unevaluated-string:
4834 : : string-literal */
4835 : :
4836 : : static inline cp_expr
4837 : 515395 : cp_parser_unevaluated_string_literal (cp_parser *parser)
4838 : : {
4839 : 515395 : return cp_parser_string_literal_common (parser, /*translate=*/false,
4840 : : /*wide_ok=*/false, /*udl_ok=*/false,
4841 : : /*lookup_udlit=*/false,
4842 : 515395 : /*uneval=*/true);
4843 : : }
4844 : :
4845 : : /* Look up a literal operator with the name and the exact arguments. */
4846 : :
4847 : : static tree
4848 : 252556 : lookup_literal_operator (tree name, vec<tree, va_gc> *args)
4849 : : {
4850 : 252556 : tree decl = lookup_name (name);
4851 : 252556 : if (!decl || !is_overloaded_fn (decl))
4852 : 94978 : return error_mark_node;
4853 : :
4854 : 598059 : for (lkp_iterator iter (decl); iter; ++iter)
4855 : : {
4856 : 496923 : tree fn = *iter;
4857 : :
4858 : 496923 : if (tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (fn)))
4859 : : {
4860 : : unsigned int ix;
4861 : : bool found = true;
4862 : :
4863 : : for (ix = 0;
4864 : 1406072 : found && ix < vec_safe_length (args) && parmtypes != NULL_TREE;
4865 : 387803 : ++ix, parmtypes = TREE_CHAIN (parmtypes))
4866 : : {
4867 : 387803 : tree tparm = TREE_VALUE (parmtypes);
4868 : 387803 : tree targ = TREE_TYPE ((*args)[ix]);
4869 : 387803 : bool ptr = TYPE_PTR_P (tparm);
4870 : 387803 : bool arr = TREE_CODE (targ) == ARRAY_TYPE;
4871 : 106978 : if ((ptr || arr || !same_type_p (tparm, targ))
4872 : 488855 : && (!ptr || !arr
4873 : 91138 : || !same_type_p (TREE_TYPE (tparm),
4874 : : TREE_TYPE (targ))))
4875 : : found = false;
4876 : : }
4877 : :
4878 : 496923 : if (found
4879 : 133543 : && ix == vec_safe_length (args)
4880 : : /* May be this should be sufficient_parms_p instead,
4881 : : depending on how exactly should user-defined literals
4882 : : work in presence of default arguments on the literal
4883 : : operator parameters. */
4884 : 630466 : && parmtypes == void_list_node)
4885 : 56442 : return decl;
4886 : : }
4887 : : }
4888 : :
4889 : 101136 : return error_mark_node;
4890 : : }
4891 : :
4892 : : /* Parse a user-defined char constant. Returns a call to a user-defined
4893 : : literal operator taking the character as an argument. */
4894 : :
4895 : : static cp_expr
4896 : 102 : cp_parser_userdef_char_literal (cp_parser *parser)
4897 : : {
4898 : 102 : cp_token *token = cp_lexer_consume_token (parser->lexer);
4899 : 102 : tree literal = token->u.value;
4900 : 102 : tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
4901 : 102 : tree value = USERDEF_LITERAL_VALUE (literal);
4902 : 102 : tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
4903 : 102 : tree decl, result;
4904 : :
4905 : : /* Build up a call to the user-defined operator */
4906 : : /* Lookup the name we got back from the id-expression. */
4907 : 102 : releasing_vec args;
4908 : 102 : vec_safe_push (args, value);
4909 : 102 : decl = lookup_literal_operator (name, args);
4910 : 102 : if (!decl || decl == error_mark_node)
4911 : : {
4912 : 62 : error ("unable to find character literal operator %qD with %qT argument",
4913 : 62 : name, TREE_TYPE (value));
4914 : 62 : return error_mark_node;
4915 : : }
4916 : 40 : result = finish_call_expr (decl, &args, false, true, tf_warning_or_error);
4917 : 40 : return result;
4918 : 102 : }
4919 : :
4920 : : /* A subroutine of cp_parser_userdef_numeric_literal to
4921 : : create a char... template parameter pack from a string node. */
4922 : :
4923 : : static tree
4924 : 50404 : make_char_string_pack (tree value)
4925 : : {
4926 : 50404 : tree charvec;
4927 : 50404 : tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
4928 : 50404 : const unsigned char *str
4929 : 50404 : = (const unsigned char *) TREE_STRING_POINTER (value);
4930 : 50404 : int i, len = TREE_STRING_LENGTH (value) - 1;
4931 : 50404 : tree argvec = make_tree_vec (1);
4932 : :
4933 : : /* Fill in CHARVEC with all of the parameters. */
4934 : 50404 : charvec = make_tree_vec (len);
4935 : 208794 : for (i = 0; i < len; ++i)
4936 : : {
4937 : 158390 : unsigned char s[3] = { '\'', str[i], '\'' };
4938 : 158390 : cpp_string in = { 3, s };
4939 : 158390 : cpp_string out = { 0, 0 };
4940 : 158390 : if (!cpp_interpret_string (parse_in, &in, 1, &out, CPP_STRING))
4941 : 0 : return NULL_TREE;
4942 : 158390 : gcc_assert (out.len == 2);
4943 : 158390 : TREE_VEC_ELT (charvec, i) = build_int_cst (char_type_node,
4944 : 158390 : out.text[0]);
4945 : : }
4946 : :
4947 : : /* Build the argument packs. */
4948 : 50404 : ARGUMENT_PACK_ARGS (argpack) = charvec;
4949 : :
4950 : 50404 : TREE_VEC_ELT (argvec, 0) = argpack;
4951 : :
4952 : 50404 : return argvec;
4953 : : }
4954 : :
4955 : : /* A subroutine of cp_parser_userdef_numeric_literal to
4956 : : create a char... template parameter pack from a string node. */
4957 : :
4958 : : static tree
4959 : 64 : make_string_pack (tree value)
4960 : : {
4961 : 64 : tree charvec;
4962 : 64 : tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
4963 : 64 : const unsigned char *str
4964 : 64 : = (const unsigned char *) TREE_STRING_POINTER (value);
4965 : 64 : int sz = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value))));
4966 : 64 : int len = TREE_STRING_LENGTH (value) / sz - 1;
4967 : 64 : tree argvec = make_tree_vec (2);
4968 : :
4969 : 64 : tree str_char_type_node = TREE_TYPE (TREE_TYPE (value));
4970 : 64 : str_char_type_node = TYPE_MAIN_VARIANT (str_char_type_node);
4971 : :
4972 : : /* First template parm is character type. */
4973 : 64 : TREE_VEC_ELT (argvec, 0) = str_char_type_node;
4974 : :
4975 : : /* Fill in CHARVEC with all of the parameters. */
4976 : 64 : charvec = make_tree_vec (len);
4977 : 256 : for (int i = 0; i < len; ++i)
4978 : 192 : TREE_VEC_ELT (charvec, i)
4979 : 384 : = double_int_to_tree (str_char_type_node,
4980 : 192 : double_int::from_buffer (str + i * sz, sz));
4981 : :
4982 : : /* Build the argument packs. */
4983 : 64 : ARGUMENT_PACK_ARGS (argpack) = charvec;
4984 : :
4985 : 64 : TREE_VEC_ELT (argvec, 1) = argpack;
4986 : :
4987 : 64 : return argvec;
4988 : : }
4989 : :
4990 : : /* Parse a user-defined numeric constant. returns a call to a user-defined
4991 : : literal operator. */
4992 : :
4993 : : static cp_expr
4994 : 87258 : cp_parser_userdef_numeric_literal (cp_parser *parser)
4995 : : {
4996 : 87258 : cp_token *token = cp_lexer_consume_token (parser->lexer);
4997 : 87258 : tree literal = token->u.value;
4998 : 87258 : tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
4999 : 87258 : tree value = USERDEF_LITERAL_VALUE (literal);
5000 : 87258 : int overflow = USERDEF_LITERAL_OVERFLOW (literal);
5001 : 87258 : tree num_string = USERDEF_LITERAL_NUM_STRING (literal);
5002 : 87258 : tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
5003 : 87258 : tree decl, result;
5004 : :
5005 : : /* Look for a literal operator taking the exact type of numeric argument
5006 : : as the literal value. */
5007 : 87258 : releasing_vec args;
5008 : 87258 : vec_safe_push (args, value);
5009 : 87258 : decl = lookup_literal_operator (name, args);
5010 : 87258 : if (decl && decl != error_mark_node)
5011 : : {
5012 : 5157 : result = finish_call_expr (decl, &args, false, true,
5013 : : tf_warning_or_error);
5014 : :
5015 : 5157 : if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE && overflow > 0)
5016 : : {
5017 : 3 : warning_at (token->location, OPT_Woverflow,
5018 : : "integer literal exceeds range of %qT type",
5019 : : long_long_unsigned_type_node);
5020 : : }
5021 : : else
5022 : : {
5023 : 5154 : if (overflow > 0)
5024 : 3 : warning_at (token->location, OPT_Woverflow,
5025 : : "floating literal exceeds range of %qT type",
5026 : : long_double_type_node);
5027 : 5151 : else if (overflow < 0)
5028 : 3 : warning_at (token->location, OPT_Woverflow,
5029 : : "floating literal truncated to zero");
5030 : : }
5031 : :
5032 : 5157 : return result;
5033 : : }
5034 : :
5035 : : /* If the numeric argument didn't work, look for a raw literal
5036 : : operator taking a const char* argument consisting of the number
5037 : : in string format. */
5038 : 82101 : args->truncate (0);
5039 : 82101 : vec_safe_push (args, num_string);
5040 : 82101 : decl = lookup_literal_operator (name, args);
5041 : 82101 : if (decl && decl != error_mark_node)
5042 : : {
5043 : 39 : result = finish_call_expr (decl, &args, false, true,
5044 : : tf_warning_or_error);
5045 : 39 : return result;
5046 : : }
5047 : :
5048 : : /* If the raw literal didn't work, look for a non-type template
5049 : : function with parameter pack char.... Call the function with
5050 : : template parameter characters representing the number. */
5051 : 82062 : args->truncate (0);
5052 : 82062 : decl = lookup_literal_operator (name, args);
5053 : 82062 : if (decl && decl != error_mark_node)
5054 : : {
5055 : 50404 : tree tmpl_args = make_char_string_pack (num_string);
5056 : 50404 : if (tmpl_args == NULL_TREE)
5057 : : {
5058 : 0 : error ("failed to translate literal to execution character set %qT",
5059 : : num_string);
5060 : 0 : return error_mark_node;
5061 : : }
5062 : 50404 : decl = lookup_template_function (decl, tmpl_args);
5063 : 50404 : result = finish_call_expr (decl, &args, false, true,
5064 : : tf_warning_or_error);
5065 : 50404 : return result;
5066 : : }
5067 : :
5068 : : /* In C++14 the standard library defines complex number suffixes that
5069 : : conflict with GNU extensions. Prefer them if <complex> is #included. */
5070 : 31658 : bool ext = cpp_get_options (parse_in)->ext_numeric_literals;
5071 : 31658 : bool i14 = (cxx_dialect > cxx11
5072 : 31658 : && (id_equal (suffix_id, "i")
5073 : 21054 : || id_equal (suffix_id, "if")
5074 : 10546 : || id_equal (suffix_id, "il")));
5075 : 31658 : diagnostic_t kind = DK_ERROR;
5076 : 31658 : int opt = 0;
5077 : :
5078 : 31658 : if (i14 && ext)
5079 : : {
5080 : 31611 : tree cxlit = lookup_qualified_name (std_node, "complex_literals",
5081 : : LOOK_want::NORMAL, false);
5082 : 31611 : if (cxlit == error_mark_node)
5083 : : {
5084 : : /* No <complex>, so pedwarn and use GNU semantics. */
5085 : 31658 : kind = DK_PEDWARN;
5086 : 31658 : opt = OPT_Wpedantic;
5087 : : }
5088 : : }
5089 : :
5090 : 31658 : {
5091 : 31658 : auto_diagnostic_group d;
5092 : 31658 : bool complained
5093 : 31658 : = emit_diagnostic (kind, input_location, opt,
5094 : : "unable to find numeric literal operator %qD", name);
5095 : :
5096 : 31658 : if (!complained)
5097 : : /* Don't inform either. */;
5098 : 62 : else if (i14)
5099 : : {
5100 : 19 : inform (token->location, "add %<using namespace std::complex_literals%> "
5101 : : "(from %<<complex>%>) to enable the C++14 user-defined literal "
5102 : : "suffixes");
5103 : 19 : if (ext)
5104 : 15 : inform (token->location, "or use %<j%> instead of %<i%> for the "
5105 : : "GNU built-in suffix");
5106 : : }
5107 : 43 : else if (!ext)
5108 : 36 : inform (token->location, "use %<-fext-numeric-literals%> "
5109 : : "to enable more built-in suffixes");
5110 : 31658 : }
5111 : :
5112 : 31658 : if (kind == DK_ERROR)
5113 : 50 : value = error_mark_node;
5114 : : else
5115 : : {
5116 : : /* Use the built-in semantics. */
5117 : 31608 : tree type;
5118 : 31608 : if (id_equal (suffix_id, "i"))
5119 : : {
5120 : 10582 : if (TREE_CODE (value) == INTEGER_CST)
5121 : 46 : type = integer_type_node;
5122 : : else
5123 : 10536 : type = double_type_node;
5124 : : }
5125 : 21026 : else if (id_equal (suffix_id, "if"))
5126 : 10508 : type = float_type_node;
5127 : : else /* if (id_equal (suffix_id, "il")) */
5128 : 10518 : type = long_double_type_node;
5129 : :
5130 : 31608 : value = fold_build2 (COMPLEX_EXPR, build_complex_type (type),
5131 : : build_zero_cst (type), fold_convert (type, value));
5132 : : }
5133 : :
5134 : 63349 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
5135 : : /* Avoid repeated diagnostics. */
5136 : 33 : token->u.value = value;
5137 : 31658 : return value;
5138 : 87258 : }
5139 : :
5140 : : /* Parse a user-defined string constant. Returns a call to a user-defined
5141 : : literal operator taking a character pointer and the length of the string
5142 : : as arguments. */
5143 : :
5144 : : static tree
5145 : 881 : finish_userdef_string_literal (tree literal)
5146 : : {
5147 : 881 : tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
5148 : 881 : tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
5149 : 881 : tree value = USERDEF_LITERAL_VALUE (literal);
5150 : 881 : int len = TREE_STRING_LENGTH (value)
5151 : 881 : / TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value)))) - 1;
5152 : 881 : tree decl;
5153 : :
5154 : : /* Build up a call to the user-defined operator. */
5155 : : /* Lookup the name we got back from the id-expression. */
5156 : 881 : releasing_vec args;
5157 : 881 : vec_safe_push (args, value);
5158 : 881 : vec_safe_push (args, build_int_cst (size_type_node, len));
5159 : 881 : decl = lookup_literal_operator (name, args);
5160 : :
5161 : 881 : if (decl && decl != error_mark_node)
5162 : 729 : return finish_call_expr (decl, &args, false, true,
5163 : 729 : tf_warning_or_error);
5164 : :
5165 : : /* Look for a suitable template function, either (C++20) with a single
5166 : : parameter of class type, or (N3599) with typename parameter CharT and
5167 : : parameter pack CharT... */
5168 : 152 : args->truncate (0);
5169 : 152 : decl = lookup_literal_operator (name, args);
5170 : 152 : if (decl && decl != error_mark_node)
5171 : : {
5172 : : /* Use resolve_nondeduced_context to try to choose one form of template
5173 : : or the other. */
5174 : 73 : tree tmpl_args = make_tree_vec (1);
5175 : 73 : TREE_VEC_ELT (tmpl_args, 0) = value;
5176 : 73 : decl = lookup_template_function (decl, tmpl_args);
5177 : 73 : tree res = resolve_nondeduced_context (decl, tf_none);
5178 : 73 : if (DECL_P (res))
5179 : : decl = res;
5180 : : else
5181 : : {
5182 : 64 : TREE_OPERAND (decl, 1) = make_string_pack (value);
5183 : 64 : res = resolve_nondeduced_context (decl, tf_none);
5184 : 64 : if (DECL_P (res))
5185 : 58 : decl = res;
5186 : : }
5187 : 73 : if (!DECL_P (decl) && cxx_dialect > cxx17)
5188 : 4 : TREE_OPERAND (decl, 1) = tmpl_args;
5189 : 73 : return finish_call_expr (decl, &args, false, true,
5190 : 73 : tf_warning_or_error);
5191 : : }
5192 : :
5193 : 79 : error ("unable to find string literal operator %qD with %qT, %qT arguments",
5194 : 79 : name, TREE_TYPE (value), size_type_node);
5195 : 79 : return error_mark_node;
5196 : 881 : }
5197 : :
5198 : :
5199 : : /* Basic concepts [gram.basic] */
5200 : :
5201 : : /* Parse a translation-unit.
5202 : :
5203 : : translation-unit:
5204 : : declaration-seq [opt] */
5205 : :
5206 : : static void
5207 : 90892 : cp_parser_translation_unit (cp_parser* parser)
5208 : : {
5209 : 90892 : gcc_checking_assert (!cp_error_declarator);
5210 : :
5211 : : /* Create the declarator obstack. */
5212 : 90892 : gcc_obstack_init (&declarator_obstack);
5213 : : /* Create the error declarator. */
5214 : 90892 : cp_error_declarator = make_declarator (cdk_error);
5215 : : /* Create the empty parameter list. */
5216 : 90892 : no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE,
5217 : : UNKNOWN_LOCATION);
5218 : : /* Remember where the base of the declarator obstack lies. */
5219 : 90892 : void *declarator_obstack_base = obstack_next_free (&declarator_obstack);
5220 : :
5221 : 90898 : push_deferring_access_checks (flag_access_control
5222 : : ? dk_no_deferred : dk_no_check);
5223 : :
5224 : 90892 : module_parse mp_state = MP_NOT_MODULE;
5225 : 90892 : if (modules_p () && !header_module_p ())
5226 : : mp_state = MP_FIRST;
5227 : :
5228 : : bool implicit_extern_c = false;
5229 : :
5230 : : /* Parse until EOF. */
5231 : 7604401 : for (;;)
5232 : : {
5233 : 7604401 : cp_token *token = cp_lexer_peek_token (parser->lexer);
5234 : :
5235 : : /* If we're entering or exiting a region that's implicitly
5236 : : extern "C", modify the lang context appropriately. This is
5237 : : so horrible. Please die. */
5238 : 7604401 : if (implicit_extern_c
5239 : 7604401 : != cp_lexer_peek_token (parser->lexer)->implicit_extern_c)
5240 : : {
5241 : 0 : implicit_extern_c = !implicit_extern_c;
5242 : 0 : if (implicit_extern_c)
5243 : 0 : push_lang_context (lang_name_c);
5244 : : else
5245 : 0 : pop_lang_context ();
5246 : : }
5247 : :
5248 : 7604401 : if (token->type == CPP_EOF)
5249 : : break;
5250 : :
5251 : 7513594 : if (modules_p ())
5252 : : {
5253 : : /* Top-level module declarations are ok, and change the
5254 : : portion of file we're in. Top-level import declarations
5255 : : are significant for the import portions. */
5256 : :
5257 : 42007 : cp_token *next = token;
5258 : 42007 : bool exporting = token->keyword == RID__EXPORT;
5259 : 42007 : if (exporting)
5260 : : {
5261 : 1513 : cp_lexer_consume_token (parser->lexer);
5262 : 1513 : next = cp_lexer_peek_token (parser->lexer);
5263 : : }
5264 : 42007 : if (next->keyword == RID__MODULE)
5265 : : {
5266 : 1889 : mp_state
5267 : 1889 : = cp_parser_module_declaration (parser, mp_state, exporting);
5268 : 1889 : continue;
5269 : : }
5270 : 40118 : else if (next->keyword == RID__IMPORT)
5271 : : {
5272 : 1905 : if (mp_state == MP_FIRST)
5273 : 908 : mp_state = MP_NOT_MODULE;
5274 : 1905 : cp_parser_import_declaration (parser, mp_state, exporting);
5275 : 1877 : continue;
5276 : : }
5277 : : else
5278 : 38213 : gcc_checking_assert (!exporting);
5279 : :
5280 : 38213 : if (mp_state == MP_GLOBAL && token->main_source_p)
5281 : : {
5282 : 152 : static bool warned = false;
5283 : 152 : if (!warned)
5284 : : {
5285 : 87 : warned = true;
5286 : 87 : pedwarn (token->location, OPT_Wglobal_module,
5287 : : "global module fragment contents must be"
5288 : : " from preprocessor inclusion");
5289 : : }
5290 : : }
5291 : : }
5292 : :
5293 : : /* This relies on the ordering of module_parse values. */
5294 : 7509800 : if (mp_state == MP_PURVIEW_IMPORTS || mp_state == MP_PRIVATE_IMPORTS)
5295 : : /* We're no longer in the import portion of a named module. */
5296 : 1387 : mp_state = module_parse (mp_state + 1);
5297 : 7508413 : else if (mp_state == MP_FIRST)
5298 : 288 : mp_state = MP_NOT_MODULE;
5299 : :
5300 : 7509800 : if (token->type == CPP_CLOSE_BRACE)
5301 : : {
5302 : 75 : cp_parser_error (parser, "expected declaration");
5303 : 75 : cp_lexer_consume_token (parser->lexer);
5304 : : /* If the next token is now a `;', consume it. */
5305 : 75 : if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
5306 : 12 : cp_lexer_consume_token (parser->lexer);
5307 : : }
5308 : : else
5309 : 7509725 : cp_parser_toplevel_declaration (parser);
5310 : : }
5311 : :
5312 : : /* Get rid of the token array; we don't need it any more. */
5313 : 90807 : cp_lexer_destroy (parser->lexer);
5314 : 90807 : parser->lexer = NULL;
5315 : :
5316 : : /* The EOF should have reset this. */
5317 : 90807 : gcc_checking_assert (!implicit_extern_c);
5318 : :
5319 : : /* Make sure the declarator obstack was fully cleaned up. */
5320 : 90807 : gcc_assert (obstack_next_free (&declarator_obstack)
5321 : : == declarator_obstack_base);
5322 : 90807 : }
5323 : :
5324 : : /* Return the appropriate tsubst flags for parsing, possibly in N3276
5325 : : decltype context. */
5326 : :
5327 : : static inline tsubst_flags_t
5328 : 407735543 : complain_flags (bool decltype_p)
5329 : : {
5330 : 407735543 : tsubst_flags_t complain = tf_warning_or_error;
5331 : 407735543 : if (decltype_p)
5332 : 4672494 : complain |= tf_decltype;
5333 : 407735543 : return complain;
5334 : : }
5335 : :
5336 : : /* We're about to parse a collection of statements. If we're currently
5337 : : parsing tentatively, set up a firewall so that any nested
5338 : : cp_parser_commit_to_tentative_parse won't affect the current context. */
5339 : :
5340 : : static cp_token_position
5341 : 618017 : cp_parser_start_tentative_firewall (cp_parser *parser)
5342 : : {
5343 : 1249655 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
5344 : : return 0;
5345 : :
5346 : 13621 : cp_parser_parse_tentatively (parser);
5347 : 13621 : cp_parser_commit_to_topmost_tentative_parse (parser);
5348 : 13621 : return cp_lexer_token_position (parser->lexer, false);
5349 : : }
5350 : :
5351 : : /* We've finished parsing the collection of statements. Wrap up the
5352 : : firewall and replace the relevant tokens with the parsed form. */
5353 : :
5354 : : static void
5355 : 618017 : cp_parser_end_tentative_firewall (cp_parser *parser, cp_token_position start,
5356 : : tree expr)
5357 : : {
5358 : 618017 : if (!start)
5359 : : return;
5360 : :
5361 : : /* Finish the firewall level. */
5362 : 13621 : cp_parser_parse_definitely (parser);
5363 : : /* And remember the result of the parse for when we try again. */
5364 : 13621 : cp_token *token = cp_lexer_token_at (parser->lexer, start);
5365 : 13621 : token->type = CPP_PREPARSED_EXPR;
5366 : 13621 : token->u.value = expr;
5367 : 13621 : token->keyword = RID_MAX;
5368 : 13621 : cp_lexer_purge_tokens_after (parser->lexer, start);
5369 : : }
5370 : :
5371 : : /* Like the above functions, but let the user modify the tokens. Used by
5372 : : CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
5373 : : later parses, so it makes sense to localize the effects of
5374 : : cp_parser_commit_to_tentative_parse. */
5375 : :
5376 : : struct tentative_firewall
5377 : : {
5378 : : cp_parser *parser;
5379 : : bool set;
5380 : :
5381 : 204338221 : tentative_firewall (cp_parser *p): parser(p)
5382 : : {
5383 : : /* If we're currently parsing tentatively, start a committed level as a
5384 : : firewall and then an inner tentative parse. */
5385 : 204338221 : if ((set = cp_parser_uncommitted_to_tentative_parse_p (parser)))
5386 : : {
5387 : 198351154 : cp_parser_parse_tentatively (parser);
5388 : 198351154 : cp_parser_commit_to_topmost_tentative_parse (parser);
5389 : 198351154 : cp_parser_parse_tentatively (parser);
5390 : : }
5391 : 204338221 : }
5392 : :
5393 : 204338218 : ~tentative_firewall()
5394 : : {
5395 : 204338218 : if (set)
5396 : : {
5397 : : /* Finish the inner tentative parse and the firewall, propagating any
5398 : : uncommitted error state to the outer tentative parse. */
5399 : 396702302 : bool err = cp_parser_error_occurred (parser);
5400 : 198351151 : cp_parser_parse_definitely (parser);
5401 : 198351151 : cp_parser_parse_definitely (parser);
5402 : 198351151 : if (err)
5403 : 216212163 : cp_parser_simulate_error (parser);
5404 : : }
5405 : 204338218 : }
5406 : : };
5407 : :
5408 : : /* Some tokens naturally come in pairs e.g.'(' and ')'.
5409 : : This class is for tracking such a matching pair of symbols.
5410 : : In particular, it tracks the location of the first token,
5411 : : so that if the second token is missing, we can highlight the
5412 : : location of the first token when notifying the user about the
5413 : : problem. */
5414 : :
5415 : : template <typename traits_t>
5416 : : class token_pair
5417 : : {
5418 : : public:
5419 : : /* token_pair's ctor. */
5420 : 866025315 : token_pair () : m_open_loc (UNKNOWN_LOCATION) {}
5421 : :
5422 : : /* If the next token is the opening symbol for this pair, consume it and
5423 : : return true.
5424 : : Otherwise, issue an error and return false.
5425 : : In either case, record the location of the opening token. */
5426 : :
5427 : 559386217 : bool require_open (cp_parser *parser)
5428 : : {
5429 : 559386217 : m_open_loc = cp_lexer_peek_token (parser->lexer)->location;
5430 : 559386217 : return cp_parser_require (parser, traits_t::open_token_type,
5431 : 559386217 : traits_t::required_token_open);
5432 : : }
5433 : :
5434 : : /* Consume the next token from PARSER, recording its location as
5435 : : that of the opening token within the pair. */
5436 : :
5437 : 306626589 : cp_token * consume_open (cp_parser *parser)
5438 : : {
5439 : 306626589 : cp_token *tok = cp_lexer_consume_token (parser->lexer);
5440 : 306626589 : gcc_assert (tok->type == traits_t::open_token_type);
5441 : 306626589 : m_open_loc = tok->location;
5442 : 306626589 : return tok;
5443 : : }
5444 : :
5445 : : /* If the next token is the closing symbol for this pair, consume it
5446 : : and return it.
5447 : : Otherwise, issue an error, highlighting the location of the
5448 : : corresponding opening token, and return NULL. */
5449 : :
5450 : 797642723 : cp_token *require_close (cp_parser *parser) const
5451 : : {
5452 : 797642723 : return cp_parser_require (parser, traits_t::close_token_type,
5453 : : traits_t::required_token_close,
5454 : 364632237 : m_open_loc);
5455 : : }
5456 : :
5457 : : location_t open_location () const { return m_open_loc; }
5458 : :
5459 : : private:
5460 : : location_t m_open_loc;
5461 : : };
5462 : :
5463 : : /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
5464 : :
5465 : : struct matching_paren_traits
5466 : : {
5467 : : static const enum cpp_ttype open_token_type = CPP_OPEN_PAREN;
5468 : : static const enum required_token required_token_open = RT_OPEN_PAREN;
5469 : : static const enum cpp_ttype close_token_type = CPP_CLOSE_PAREN;
5470 : : static const enum required_token required_token_close = RT_CLOSE_PAREN;
5471 : : };
5472 : :
5473 : : /* "matching_parens" is a token_pair<T> class for tracking matching
5474 : : pairs of parentheses. */
5475 : :
5476 : : typedef token_pair<matching_paren_traits> matching_parens;
5477 : :
5478 : : /* Traits for token_pair<T> for tracking matching pairs of braces. */
5479 : :
5480 : : struct matching_brace_traits
5481 : : {
5482 : : static const enum cpp_ttype open_token_type = CPP_OPEN_BRACE;
5483 : : static const enum required_token required_token_open = RT_OPEN_BRACE;
5484 : : static const enum cpp_ttype close_token_type = CPP_CLOSE_BRACE;
5485 : : static const enum required_token required_token_close = RT_CLOSE_BRACE;
5486 : : };
5487 : :
5488 : : /* "matching_braces" is a token_pair<T> class for tracking matching
5489 : : pairs of braces. */
5490 : :
5491 : : typedef token_pair<matching_brace_traits> matching_braces;
5492 : :
5493 : :
5494 : : /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
5495 : : enclosing parentheses. */
5496 : :
5497 : : static cp_expr
5498 : 28930 : cp_parser_statement_expr (cp_parser *parser)
5499 : : {
5500 : 28930 : cp_token_position start = cp_parser_start_tentative_firewall (parser);
5501 : 28930 : auto oas = make_temp_override (parser->omp_array_section_p, false);
5502 : :
5503 : : /* Consume the '('. */
5504 : 28930 : location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
5505 : 28930 : matching_parens parens;
5506 : 28930 : parens.consume_open (parser);
5507 : : /* Start the statement-expression. */
5508 : 28930 : tree expr = begin_stmt_expr ();
5509 : : /* Parse the compound-statement. */
5510 : 28930 : cp_parser_compound_statement (parser, expr, BCS_STMT_EXPR, false);
5511 : : /* Finish up. */
5512 : 28930 : expr = finish_stmt_expr (expr, false);
5513 : : /* Consume the ')'. */
5514 : 28930 : location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
5515 : 28930 : if (!parens.require_close (parser))
5516 : 0 : cp_parser_skip_to_end_of_statement (parser);
5517 : :
5518 : 28930 : cp_parser_end_tentative_firewall (parser, start, expr);
5519 : 28930 : location_t combined_loc = make_location (start_loc, start_loc, finish_loc);
5520 : 28930 : return cp_expr (expr, combined_loc);
5521 : 28930 : }
5522 : :
5523 : : /* Expressions [gram.expr] */
5524 : :
5525 : : /* Parse a fold-operator.
5526 : :
5527 : : fold-operator:
5528 : : - * / % ^ & | = < > << >>
5529 : : = -= *= /= %= ^= &= |= <<= >>=
5530 : : == != <= >= && || , .* ->*
5531 : :
5532 : : This returns the tree code corresponding to the matched operator
5533 : : as an int. When the current token matches a compound assignment
5534 : : operator, the resulting tree code is the negative value of the
5535 : : non-assignment operator. */
5536 : :
5537 : : static int
5538 : 27299059 : cp_parser_fold_operator (cp_token *token)
5539 : : {
5540 : 26760258 : switch (token->type)
5541 : : {
5542 : : case CPP_PLUS: return PLUS_EXPR;
5543 : : case CPP_MINUS: return MINUS_EXPR;
5544 : : case CPP_MULT: return MULT_EXPR;
5545 : : case CPP_DIV: return TRUNC_DIV_EXPR;
5546 : : case CPP_MOD: return TRUNC_MOD_EXPR;
5547 : : case CPP_XOR: return BIT_XOR_EXPR;
5548 : : case CPP_AND: return BIT_AND_EXPR;
5549 : : case CPP_OR: return BIT_IOR_EXPR;
5550 : : case CPP_LSHIFT: return LSHIFT_EXPR;
5551 : : case CPP_RSHIFT: return RSHIFT_EXPR;
5552 : :
5553 : : case CPP_EQ: return -NOP_EXPR;
5554 : : case CPP_PLUS_EQ: return -PLUS_EXPR;
5555 : : case CPP_MINUS_EQ: return -MINUS_EXPR;
5556 : : case CPP_MULT_EQ: return -MULT_EXPR;
5557 : : case CPP_DIV_EQ: return -TRUNC_DIV_EXPR;
5558 : : case CPP_MOD_EQ: return -TRUNC_MOD_EXPR;
5559 : : case CPP_XOR_EQ: return -BIT_XOR_EXPR;
5560 : : case CPP_AND_EQ: return -BIT_AND_EXPR;
5561 : : case CPP_OR_EQ: return -BIT_IOR_EXPR;
5562 : : case CPP_LSHIFT_EQ: return -LSHIFT_EXPR;
5563 : : case CPP_RSHIFT_EQ: return -RSHIFT_EXPR;
5564 : :
5565 : : case CPP_EQ_EQ: return EQ_EXPR;
5566 : : case CPP_NOT_EQ: return NE_EXPR;
5567 : : case CPP_LESS: return LT_EXPR;
5568 : : case CPP_GREATER: return GT_EXPR;
5569 : : case CPP_LESS_EQ: return LE_EXPR;
5570 : : case CPP_GREATER_EQ: return GE_EXPR;
5571 : :
5572 : : case CPP_AND_AND: return TRUTH_ANDIF_EXPR;
5573 : : case CPP_OR_OR: return TRUTH_ORIF_EXPR;
5574 : :
5575 : : case CPP_COMMA: return COMPOUND_EXPR;
5576 : :
5577 : : case CPP_DOT_STAR: return DOTSTAR_EXPR;
5578 : : case CPP_DEREF_STAR: return MEMBER_REF;
5579 : :
5580 : : default: return ERROR_MARK;
5581 : : }
5582 : : }
5583 : :
5584 : : /* Returns true if CODE indicates a binary expression, which is not allowed in
5585 : : the LHS of a fold-expression. More codes will need to be added to use this
5586 : : function in other contexts. */
5587 : :
5588 : : static bool
5589 : 486166 : is_binary_op (tree_code code)
5590 : : {
5591 : 486166 : switch (code)
5592 : : {
5593 : : case PLUS_EXPR:
5594 : : case POINTER_PLUS_EXPR:
5595 : : case MINUS_EXPR:
5596 : : case MULT_EXPR:
5597 : : case TRUNC_DIV_EXPR:
5598 : : case TRUNC_MOD_EXPR:
5599 : : case BIT_XOR_EXPR:
5600 : : case BIT_AND_EXPR:
5601 : : case BIT_IOR_EXPR:
5602 : : case LSHIFT_EXPR:
5603 : : case RSHIFT_EXPR:
5604 : :
5605 : : case MODOP_EXPR:
5606 : :
5607 : : case EQ_EXPR:
5608 : : case NE_EXPR:
5609 : : case LE_EXPR:
5610 : : case GE_EXPR:
5611 : : case LT_EXPR:
5612 : : case GT_EXPR:
5613 : :
5614 : : case TRUTH_ANDIF_EXPR:
5615 : : case TRUTH_ORIF_EXPR:
5616 : :
5617 : : case COMPOUND_EXPR:
5618 : :
5619 : : case DOTSTAR_EXPR:
5620 : : case MEMBER_REF:
5621 : : return true;
5622 : :
5623 : 486076 : default:
5624 : 486076 : return false;
5625 : : }
5626 : : }
5627 : :
5628 : : /* If the next token is a suitable fold operator, consume it and return as
5629 : : the function above. */
5630 : :
5631 : : static int
5632 : 538801 : cp_parser_fold_operator (cp_parser *parser)
5633 : : {
5634 : 538801 : cp_token* token = cp_lexer_peek_token (parser->lexer);
5635 : 538801 : int code = cp_parser_fold_operator (token);
5636 : 538801 : if (code != ERROR_MARK)
5637 : 538801 : cp_lexer_consume_token (parser->lexer);
5638 : 538801 : return code;
5639 : : }
5640 : :
5641 : : /* Parse a fold-expression.
5642 : :
5643 : : fold-expression:
5644 : : ( ... folding-operator cast-expression)
5645 : : ( cast-expression folding-operator ... )
5646 : : ( cast-expression folding operator ... folding-operator cast-expression)
5647 : :
5648 : : Note that the '(' and ')' are matched in primary expression. */
5649 : :
5650 : : static cp_expr
5651 : 538810 : cp_parser_fold_expression (cp_parser *parser, tree expr1)
5652 : : {
5653 : 538810 : cp_id_kind pidk;
5654 : 538810 : location_t loc = cp_lexer_peek_token (parser->lexer)->location;
5655 : 538810 : const cp_token *token = nullptr;
5656 : :
5657 : : // Left fold.
5658 : 538810 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5659 : : {
5660 : 1817 : if (expr1)
5661 : 9 : return error_mark_node;
5662 : 1808 : cp_lexer_consume_token (parser->lexer);
5663 : 1808 : token = cp_lexer_peek_token (parser->lexer);
5664 : 1808 : int op = cp_parser_fold_operator (parser);
5665 : 1808 : if (op == ERROR_MARK)
5666 : : {
5667 : 0 : cp_parser_error (parser, "expected binary operator");
5668 : 0 : return error_mark_node;
5669 : : }
5670 : :
5671 : 1808 : tree expr = cp_parser_cast_expression (parser, false, false,
5672 : : false, &pidk);
5673 : 1808 : if (expr == error_mark_node)
5674 : 0 : return error_mark_node;
5675 : 1808 : loc = make_location (token->location, loc, parser->lexer);
5676 : 1808 : return finish_left_unary_fold_expr (loc, expr, op);
5677 : : }
5678 : :
5679 : 536993 : token = cp_lexer_peek_token (parser->lexer);
5680 : 536993 : int op = cp_parser_fold_operator (parser);
5681 : 536993 : if (op == ERROR_MARK)
5682 : : {
5683 : 0 : cp_parser_error (parser, "expected binary operator");
5684 : 0 : return error_mark_node;
5685 : : }
5686 : :
5687 : 536993 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS))
5688 : : {
5689 : 0 : cp_parser_error (parser, "expected ...");
5690 : 0 : return error_mark_node;
5691 : : }
5692 : 536993 : cp_lexer_consume_token (parser->lexer);
5693 : :
5694 : : /* The operands of a fold-expression are cast-expressions, so binary or
5695 : : conditional expressions are not allowed. We check this here to avoid
5696 : : tentative parsing. */
5697 : 536993 : if (EXPR_P (expr1) && warning_suppressed_p (expr1, OPT_Wparentheses))
5698 : : /* OK, the expression was parenthesized. */;
5699 : 486166 : else if (is_binary_op (TREE_CODE (expr1)))
5700 : 90 : error_at (location_of (expr1),
5701 : : "binary expression in operand of fold-expression");
5702 : 486076 : else if (TREE_CODE (expr1) == COND_EXPR
5703 : 486076 : || (REFERENCE_REF_P (expr1)
5704 : 0 : && TREE_CODE (TREE_OPERAND (expr1, 0)) == COND_EXPR))
5705 : 3 : error_at (location_of (expr1),
5706 : : "conditional expression in operand of fold-expression");
5707 : :
5708 : : // Right fold.
5709 : 536993 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
5710 : : {
5711 : 525267 : loc = make_location (token->location, loc, parser->lexer);
5712 : 525267 : return finish_right_unary_fold_expr (loc, expr1, op);
5713 : : }
5714 : :
5715 : 11726 : if (cp_lexer_next_token_is_not (parser->lexer, token->type))
5716 : : {
5717 : 0 : cp_parser_error (parser, "mismatched operator in fold-expression");
5718 : 0 : return error_mark_node;
5719 : : }
5720 : 11726 : cp_lexer_consume_token (parser->lexer);
5721 : :
5722 : : // Binary left or right fold.
5723 : 11726 : tree expr2 = cp_parser_cast_expression (parser, false, false, false, &pidk);
5724 : 11726 : if (expr2 == error_mark_node)
5725 : 0 : return error_mark_node;
5726 : 11726 : loc = make_location (token->location, loc, parser->lexer);
5727 : 11726 : return finish_binary_fold_expr (loc, expr1, expr2, op);
5728 : : }
5729 : :
5730 : : /* Parse a primary-expression.
5731 : :
5732 : : primary-expression:
5733 : : literal
5734 : : this
5735 : : ( expression )
5736 : : id-expression
5737 : : lambda-expression (C++11)
5738 : :
5739 : : GNU Extensions:
5740 : :
5741 : : primary-expression:
5742 : : ( compound-statement )
5743 : : __builtin_va_arg ( assignment-expression , type-id )
5744 : : __builtin_offsetof ( type-id , offsetof-expression )
5745 : :
5746 : : C++ Extensions:
5747 : : __has_nothrow_assign ( type-id )
5748 : : __has_nothrow_constructor ( type-id )
5749 : : __has_nothrow_copy ( type-id )
5750 : : __has_trivial_assign ( type-id )
5751 : : __has_trivial_constructor ( type-id )
5752 : : __has_trivial_copy ( type-id )
5753 : : __has_trivial_destructor ( type-id )
5754 : : __has_virtual_destructor ( type-id )
5755 : : __is_abstract ( type-id )
5756 : : __is_base_of ( type-id , type-id )
5757 : : __is_class ( type-id )
5758 : : __is_empty ( type-id )
5759 : : __is_enum ( type-id )
5760 : : __is_final ( type-id )
5761 : : __is_literal_type ( type-id )
5762 : : __is_pod ( type-id )
5763 : : __is_polymorphic ( type-id )
5764 : : __is_std_layout ( type-id )
5765 : : __is_trivial ( type-id )
5766 : : __is_union ( type-id )
5767 : :
5768 : : Objective-C++ Extension:
5769 : :
5770 : : primary-expression:
5771 : : objc-expression
5772 : :
5773 : : literal:
5774 : : __null
5775 : :
5776 : : ADDRESS_P is true iff this expression was immediately preceded by
5777 : : "&" and therefore might denote a pointer-to-member. CAST_P is true
5778 : : iff this expression is the target of a cast. TEMPLATE_ARG_P is
5779 : : true iff this expression is a template argument.
5780 : :
5781 : : Returns a representation of the expression. Upon return, *IDK
5782 : : indicates what kind of id-expression (if any) was present. */
5783 : :
5784 : : static cp_expr
5785 : 822540139 : cp_parser_primary_expression (cp_parser *parser,
5786 : : bool address_p,
5787 : : bool cast_p,
5788 : : bool template_arg_p,
5789 : : bool decltype_p,
5790 : : cp_id_kind *idk)
5791 : : {
5792 : 822540139 : cp_token *token = NULL;
5793 : :
5794 : : /* Assume the primary expression is not an id-expression. */
5795 : 822540139 : *idk = CP_ID_KIND_NONE;
5796 : :
5797 : : /* Peek at the next token. */
5798 : 822540139 : token = cp_lexer_peek_token (parser->lexer);
5799 : 822540139 : switch ((int) token->type)
5800 : : {
5801 : : /* literal:
5802 : : integer-literal
5803 : : character-literal
5804 : : floating-literal
5805 : : string-literal
5806 : : boolean-literal
5807 : : pointer-literal
5808 : : user-defined-literal */
5809 : 94455898 : case CPP_CHAR:
5810 : 94455898 : case CPP_CHAR16:
5811 : 94455898 : case CPP_CHAR32:
5812 : 94455898 : case CPP_WCHAR:
5813 : 94455898 : case CPP_UTF8CHAR:
5814 : 94455898 : case CPP_NUMBER:
5815 : 94455898 : case CPP_PREPARSED_EXPR:
5816 : 94455898 : if (TREE_CODE (token->u.value) == USERDEF_LITERAL)
5817 : 87258 : return cp_parser_userdef_numeric_literal (parser);
5818 : 94368640 : token = cp_lexer_consume_token (parser->lexer);
5819 : 94368640 : if (TREE_CODE (token->u.value) == FIXED_CST)
5820 : : {
5821 : 48 : error_at (token->location,
5822 : : "fixed-point types not supported in C++");
5823 : 48 : return error_mark_node;
5824 : : }
5825 : : /* Floating-point literals are only allowed in an integral
5826 : : constant expression if they are cast to an integral or
5827 : : enumeration type. */
5828 : 94368592 : if ((TREE_CODE (token->u.value) == REAL_CST
5829 : 91039372 : || (TREE_CODE (token->u.value) == EXCESS_PRECISION_EXPR
5830 : 211110 : && TREE_CODE (TREE_OPERAND (token->u.value, 0)) == REAL_CST))
5831 : 3540324 : && parser->integral_constant_expression_p
5832 : 96204774 : && pedantic)
5833 : : {
5834 : : /* CAST_P will be set even in invalid code like "int(2.7 +
5835 : : ...)". Therefore, we have to check that the next token
5836 : : is sure to end the cast. */
5837 : 21224 : if (cast_p)
5838 : : {
5839 : 7195 : cp_token *next_token;
5840 : :
5841 : 7195 : next_token = cp_lexer_peek_token (parser->lexer);
5842 : 7195 : if (/* The comma at the end of an
5843 : : enumerator-definition. */
5844 : 7195 : next_token->type != CPP_COMMA
5845 : : /* The curly brace at the end of an enum-specifier. */
5846 : : && next_token->type != CPP_CLOSE_BRACE
5847 : : /* The end of a statement. */
5848 : : && next_token->type != CPP_SEMICOLON
5849 : : /* The end of the cast-expression. */
5850 : : && next_token->type != CPP_CLOSE_PAREN
5851 : : /* The end of an array bound. */
5852 : : && next_token->type != CPP_CLOSE_SQUARE
5853 : : /* The closing ">" in a template-argument-list. */
5854 : : && (next_token->type != CPP_GREATER
5855 : 1 : || parser->greater_than_is_operator_p)
5856 : : /* C++0x only: A ">>" treated like two ">" tokens,
5857 : : in a template-argument-list. */
5858 : 24 : && (next_token->type != CPP_RSHIFT
5859 : 0 : || (cxx_dialect == cxx98)
5860 : 0 : || parser->greater_than_is_operator_p))
5861 : : cast_p = false;
5862 : : }
5863 : :
5864 : : /* If we are within a cast, then the constraint that the
5865 : : cast is to an integral or enumeration type will be
5866 : : checked at that point. If we are not within a cast, then
5867 : : this code is invalid. */
5868 : : if (!cast_p)
5869 : 14053 : cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
5870 : : }
5871 : 94368592 : return (cp_expr (token->u.value, token->location, token->flags & DECIMAL_INT)
5872 : 94368592 : .maybe_add_location_wrapper ());
5873 : :
5874 : 102 : case CPP_CHAR_USERDEF:
5875 : 102 : case CPP_CHAR16_USERDEF:
5876 : 102 : case CPP_CHAR32_USERDEF:
5877 : 102 : case CPP_WCHAR_USERDEF:
5878 : 102 : case CPP_UTF8CHAR_USERDEF:
5879 : 102 : return cp_parser_userdef_char_literal (parser);
5880 : :
5881 : 9291677 : case CPP_STRING:
5882 : 9291677 : case CPP_STRING16:
5883 : 9291677 : case CPP_STRING32:
5884 : 9291677 : case CPP_WSTRING:
5885 : 9291677 : case CPP_UTF8STRING:
5886 : 9291677 : case CPP_STRING_USERDEF:
5887 : 9291677 : case CPP_STRING16_USERDEF:
5888 : 9291677 : case CPP_STRING32_USERDEF:
5889 : 9291677 : case CPP_WSTRING_USERDEF:
5890 : 9291677 : case CPP_UTF8STRING_USERDEF:
5891 : : /* ??? Should wide strings be allowed when parser->translate_strings_p
5892 : : is false (i.e. in attributes)? If not, we can kill the third
5893 : : argument to cp_parser_string_literal. */
5894 : 9291677 : if (parser->translate_strings_p)
5895 : 5687227 : return (cp_parser_userdef_string_literal (parser,
5896 : : /*lookup_udlit=*/true)
5897 : 5687227 : .maybe_add_location_wrapper ());
5898 : : else
5899 : 3604450 : return (cp_parser_string_literal (parser,
5900 : : /*translate=*/false,
5901 : : /*wide_ok=*/true)
5902 : 3604450 : .maybe_add_location_wrapper ());
5903 : :
5904 : 26791012 : case CPP_OPEN_PAREN:
5905 : : /* If we see `( { ' then we are looking at the beginning of
5906 : : a GNU statement-expression. */
5907 : 26791012 : if (cp_parser_allow_gnu_extensions_p (parser)
5908 : 26791012 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_BRACE))
5909 : : {
5910 : : /* Statement-expressions are not allowed by the standard. */
5911 : 28937 : pedwarn (token->location, OPT_Wpedantic,
5912 : : "ISO C++ forbids braced-groups within expressions");
5913 : :
5914 : : /* And they're not allowed outside of a function-body; you
5915 : : cannot, for example, write:
5916 : :
5917 : : int i = ({ int j = 3; j + 1; });
5918 : :
5919 : : at class or namespace scope. */
5920 : 28937 : if (!parser->in_function_body
5921 : 28933 : || parser->in_template_argument_list_p)
5922 : : {
5923 : 7 : error_at (token->location,
5924 : : "statement-expressions are not allowed outside "
5925 : : "functions nor in template-argument lists");
5926 : 7 : cp_parser_skip_to_end_of_block_or_statement (parser);
5927 : 7 : if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
5928 : 7 : cp_lexer_consume_token (parser->lexer);
5929 : 7 : return error_mark_node;
5930 : : }
5931 : : else
5932 : 28930 : return cp_parser_statement_expr (parser);
5933 : : }
5934 : : /* Otherwise it's a normal parenthesized expression. */
5935 : 26762075 : {
5936 : 26762075 : cp_expr expr;
5937 : 26762075 : bool saved_greater_than_is_operator_p;
5938 : :
5939 : 26762075 : location_t open_paren_loc = token->location;
5940 : :
5941 : : /* Consume the `('. */
5942 : 26762075 : matching_parens parens;
5943 : 26762075 : parens.consume_open (parser);
5944 : : /* Within a parenthesized expression, a `>' token is always
5945 : : the greater-than operator. */
5946 : 26762075 : saved_greater_than_is_operator_p
5947 : 26762075 : = parser->greater_than_is_operator_p;
5948 : 26762075 : parser->greater_than_is_operator_p = true;
5949 : :
5950 : 26762075 : if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5951 : : /* Left fold expression. */
5952 : 1808 : expr = NULL_TREE;
5953 : : else
5954 : : /* Parse the parenthesized expression. */
5955 : 26760267 : expr = cp_parser_expression (parser, idk, cast_p, decltype_p);
5956 : :
5957 : 26762075 : token = cp_lexer_peek_token (parser->lexer);
5958 : 53522140 : if (token->type == CPP_ELLIPSIS || cp_parser_fold_operator (token))
5959 : : {
5960 : 538810 : expr = cp_parser_fold_expression (parser, expr);
5961 : 538810 : if (expr != error_mark_node
5962 : 538810 : && cxx_dialect < cxx17)
5963 : 1 : pedwarn (input_location, OPT_Wc__17_extensions,
5964 : : "fold-expressions only available with %<-std=c++17%> "
5965 : : "or %<-std=gnu++17%>");
5966 : : }
5967 : : else
5968 : : /* Let the front end know that this expression was
5969 : : enclosed in parentheses. This matters in case, for
5970 : : example, the expression is of the form `A::B', since
5971 : : `&A::B' might be a pointer-to-member, but `&(A::B)' is
5972 : : not. */
5973 : 26223265 : expr = finish_parenthesized_expr (expr);
5974 : :
5975 : : /* DR 705: Wrapping an unqualified name in parentheses
5976 : : suppresses arg-dependent lookup. We want to pass back
5977 : : CP_ID_KIND_QUALIFIED for suppressing vtable lookup
5978 : : (c++/37862), but none of the others. */
5979 : 26762075 : if (*idk != CP_ID_KIND_QUALIFIED)
5980 : 26435999 : *idk = CP_ID_KIND_NONE;
5981 : :
5982 : : /* The `>' token might be the end of a template-id or
5983 : : template-parameter-list now. */
5984 : 26762075 : parser->greater_than_is_operator_p
5985 : 26762075 : = saved_greater_than_is_operator_p;
5986 : :
5987 : : /* Consume the `)'. */
5988 : 26762075 : token = cp_lexer_peek_token (parser->lexer);
5989 : 26762075 : location_t close_paren_loc = token->location;
5990 : 26762075 : bool no_wparens = warning_suppressed_p (expr, OPT_Wparentheses);
5991 : 26762075 : expr.set_range (open_paren_loc, close_paren_loc);
5992 : 26762075 : if (no_wparens)
5993 : 24604217 : suppress_warning (expr, OPT_Wparentheses);
5994 : 26762075 : if (!parens.require_close (parser)
5995 : 26762075 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
5996 : 104 : cp_parser_skip_to_end_of_statement (parser);
5997 : :
5998 : 26762075 : return expr;
5999 : : }
6000 : :
6001 : 589090 : case CPP_OPEN_SQUARE:
6002 : 589090 : {
6003 : 589090 : if (c_dialect_objc ())
6004 : : {
6005 : : /* We might have an Objective-C++ message. */
6006 : 0 : cp_parser_parse_tentatively (parser);
6007 : 0 : tree msg = cp_parser_objc_message_expression (parser);
6008 : : /* If that works out, we're done ... */
6009 : 0 : if (cp_parser_parse_definitely (parser))
6010 : 0 : return msg;
6011 : : /* ... else, fall though to see if it's a lambda. */
6012 : : }
6013 : 589090 : cp_expr lam = cp_parser_lambda_expression (parser);
6014 : : /* Don't warn about a failed tentative parse. */
6015 : 1178180 : if (cp_parser_error_occurred (parser))
6016 : 3 : return error_mark_node;
6017 : 589087 : maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
6018 : 589087 : return lam;
6019 : : }
6020 : :
6021 : 0 : case CPP_OBJC_STRING:
6022 : 0 : if (c_dialect_objc ())
6023 : : /* We have an Objective-C++ string literal. */
6024 : 0 : return cp_parser_objc_expression (parser);
6025 : 0 : cp_parser_error (parser, "expected primary-expression");
6026 : 0 : return error_mark_node;
6027 : :
6028 : 82592770 : case CPP_KEYWORD:
6029 : 82592770 : switch (token->keyword)
6030 : : {
6031 : : /* These two are the boolean literals. */
6032 : 33787935 : case RID_TRUE:
6033 : 33787935 : cp_lexer_consume_token (parser->lexer);
6034 : 33787935 : return cp_expr (boolean_true_node, token->location);
6035 : 14773643 : case RID_FALSE:
6036 : 14773643 : cp_lexer_consume_token (parser->lexer);
6037 : 14773643 : return cp_expr (boolean_false_node, token->location);
6038 : :
6039 : : /* The `__null' literal. */
6040 : 132374 : case RID_NULL:
6041 : 132374 : cp_lexer_consume_token (parser->lexer);
6042 : 132374 : return cp_expr (null_node, token->location);
6043 : :
6044 : : /* The `nullptr' literal. */
6045 : 3062694 : case RID_NULLPTR:
6046 : 3062694 : cp_lexer_consume_token (parser->lexer);
6047 : 3062694 : return cp_expr (nullptr_node, token->location);
6048 : :
6049 : : /* Recognize the `this' keyword. */
6050 : 29872193 : case RID_THIS:
6051 : 29872193 : cp_lexer_consume_token (parser->lexer);
6052 : 29872193 : if (parser->local_variables_forbidden_p & THIS_FORBIDDEN)
6053 : : {
6054 : 35 : error_at (token->location,
6055 : : "%<this%> may not be used in this context");
6056 : 35 : return error_mark_node;
6057 : : }
6058 : : /* Pointers cannot appear in constant-expressions. */
6059 : 29872158 : if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
6060 : 0 : return error_mark_node;
6061 : 29872158 : return cp_expr (finish_this_expr (), token->location);
6062 : :
6063 : : /* The `operator' keyword can be the beginning of an
6064 : : id-expression. */
6065 : 216857 : case RID_OPERATOR:
6066 : 216857 : goto id_expression;
6067 : :
6068 : 126072 : case RID_FUNCTION_NAME:
6069 : 126072 : case RID_PRETTY_FUNCTION_NAME:
6070 : 126072 : case RID_C99_FUNCTION_NAME:
6071 : 126072 : {
6072 : 126072 : non_integral_constant name;
6073 : :
6074 : : /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
6075 : : __func__ are the names of variables -- but they are
6076 : : treated specially. Therefore, they are handled here,
6077 : : rather than relying on the generic id-expression logic
6078 : : below. Grammatically, these names are id-expressions.
6079 : :
6080 : : Consume the token. */
6081 : 126072 : token = cp_lexer_consume_token (parser->lexer);
6082 : :
6083 : 126072 : switch (token->keyword)
6084 : : {
6085 : : case RID_FUNCTION_NAME:
6086 : : name = NIC_FUNC_NAME;
6087 : : break;
6088 : : case RID_PRETTY_FUNCTION_NAME:
6089 : : name = NIC_PRETTY_FUNC;
6090 : : break;
6091 : : case RID_C99_FUNCTION_NAME:
6092 : : name = NIC_C99_FUNC;
6093 : : break;
6094 : 0 : default:
6095 : 0 : gcc_unreachable ();
6096 : : }
6097 : :
6098 : 126072 : if (cp_parser_non_integral_constant_expression (parser, name))
6099 : 3 : return error_mark_node;
6100 : :
6101 : : /* Look up the name. */
6102 : 126069 : return finish_fname (token->u.value);
6103 : : }
6104 : :
6105 : 30933 : case RID_VA_ARG:
6106 : 30933 : {
6107 : 30933 : tree expression;
6108 : 30933 : tree type;
6109 : 30933 : location_t type_location;
6110 : 30933 : location_t start_loc
6111 : 30933 : = cp_lexer_peek_token (parser->lexer)->location;
6112 : : /* The `__builtin_va_arg' construct is used to handle
6113 : : `va_arg'. Consume the `__builtin_va_arg' token. */
6114 : 30933 : cp_lexer_consume_token (parser->lexer);
6115 : : /* Look for the opening `('. */
6116 : 30933 : matching_parens parens;
6117 : 30933 : parens.require_open (parser);
6118 : : /* Now, parse the assignment-expression. */
6119 : 30933 : expression = cp_parser_assignment_expression (parser);
6120 : : /* Look for the `,'. */
6121 : 30933 : cp_parser_require (parser, CPP_COMMA, RT_COMMA);
6122 : 30933 : type_location = cp_lexer_peek_token (parser->lexer)->location;
6123 : : /* Parse the type-id. */
6124 : 30933 : {
6125 : 30933 : type_id_in_expr_sentinel s (parser);
6126 : 30933 : type = cp_parser_type_id (parser);
6127 : 30933 : }
6128 : : /* Look for the closing `)'. */
6129 : 30933 : location_t finish_loc
6130 : 30933 : = cp_lexer_peek_token (parser->lexer)->location;
6131 : 30933 : parens.require_close (parser);
6132 : : /* Using `va_arg' in a constant-expression is not
6133 : : allowed. */
6134 : 30933 : if (cp_parser_non_integral_constant_expression (parser,
6135 : : NIC_VA_ARG))
6136 : 0 : return error_mark_node;
6137 : : /* Construct a location of the form:
6138 : : __builtin_va_arg (v, int)
6139 : : ~~~~~~~~~~~~~~~~~~~~~^~~~
6140 : : with the caret at the type, ranging from the start of the
6141 : : "__builtin_va_arg" token to the close paren. */
6142 : 30933 : location_t combined_loc
6143 : 30933 : = make_location (type_location, start_loc, finish_loc);
6144 : 30933 : return build_x_va_arg (combined_loc, expression, type);
6145 : : }
6146 : :
6147 : 2304 : case RID_OFFSETOF:
6148 : 2304 : return cp_parser_builtin_offsetof (parser);
6149 : :
6150 : : // C++ concepts
6151 : 586851 : case RID_REQUIRES:
6152 : 586851 : return cp_parser_requires_expression (parser);
6153 : :
6154 : : /* Objective-C++ expressions. */
6155 : 0 : case RID_AT_ENCODE:
6156 : 0 : case RID_AT_PROTOCOL:
6157 : 0 : case RID_AT_SELECTOR:
6158 : 0 : return cp_parser_objc_expression (parser);
6159 : :
6160 : 9 : case RID_OMP_ALL_MEMORY:
6161 : 9 : gcc_assert (flag_openmp);
6162 : 9 : cp_lexer_consume_token (parser->lexer);
6163 : 9 : error_at (token->location,
6164 : : "%<omp_all_memory%> may only be used in OpenMP "
6165 : : "%<depend%> clause");
6166 : 9 : return error_mark_node;
6167 : :
6168 : 13 : case RID_TEMPLATE:
6169 : 13 : if (parser->in_function_body
6170 : 13 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6171 : : == CPP_LESS))
6172 : : {
6173 : 8 : error_at (token->location,
6174 : : "a template declaration cannot appear at block scope");
6175 : 8 : cp_parser_skip_to_end_of_block_or_statement (parser);
6176 : 8 : return error_mark_node;
6177 : : }
6178 : : /* FALLTHRU */
6179 : 897 : default:
6180 : 897 : cp_parser_error (parser, "expected primary-expression");
6181 : 897 : return error_mark_node;
6182 : : }
6183 : :
6184 : : /* An id-expression can start with either an identifier, a
6185 : : `::' as the beginning of a qualified-id, or the "operator"
6186 : : keyword. */
6187 : 510915899 : case CPP_NAME:
6188 : 510915899 : if (const cp_trait* trait = cp_lexer_peek_trait_expr (parser->lexer))
6189 : 2185661 : return cp_parser_trait (parser, trait);
6190 : : /* FALLTHRU */
6191 : 606730889 : case CPP_SCOPE:
6192 : 606730889 : case CPP_TEMPLATE_ID:
6193 : 606730889 : case CPP_NESTED_NAME_SPECIFIER:
6194 : 606730889 : {
6195 : 508730238 : id_expression:
6196 : 606730889 : cp_expr id_expression;
6197 : 606730889 : cp_expr decl;
6198 : 606730889 : const char *error_msg;
6199 : 606730889 : bool template_p;
6200 : 606730889 : bool done;
6201 : 606730889 : cp_token *id_expr_token;
6202 : :
6203 : : /* Parse the id-expression. */
6204 : 606730889 : id_expression
6205 : 606730889 : = cp_parser_id_expression (parser,
6206 : : /*template_keyword_p=*/false,
6207 : : /*check_dependency_p=*/true,
6208 : : &template_p,
6209 : : /*declarator_p=*/false,
6210 : : /*optional_p=*/false);
6211 : 606730889 : if (id_expression == error_mark_node)
6212 : 12193 : return error_mark_node;
6213 : 606718696 : id_expr_token = token;
6214 : 606718696 : token = cp_lexer_peek_token (parser->lexer);
6215 : 606718696 : done = (token->type != CPP_OPEN_SQUARE
6216 : : && token->type != CPP_OPEN_PAREN
6217 : : && token->type != CPP_DOT
6218 : : && token->type != CPP_DEREF
6219 : : && token->type != CPP_PLUS_PLUS
6220 : : && token->type != CPP_MINUS_MINUS);
6221 : : /* If we have a template-id, then no further lookup is
6222 : : required. If the template-id was for a template-class, we
6223 : : will sometimes have a TYPE_DECL at this point. */
6224 : 606718696 : if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
6225 : 606718696 : || TREE_CODE (id_expression) == TYPE_DECL)
6226 : 585046051 : decl = id_expression;
6227 : : /* Look up the name. */
6228 : : else
6229 : : {
6230 : 578975986 : tree ambiguous_decls;
6231 : :
6232 : : /* If we already know that this lookup is ambiguous, then
6233 : : we've already issued an error message; there's no reason
6234 : : to check again. */
6235 : 578975986 : if (id_expr_token->type == CPP_NAME
6236 : 506435706 : && id_expr_token->error_reported)
6237 : : {
6238 : 0 : cp_parser_simulate_error (parser);
6239 : 0 : return error_mark_node;
6240 : : }
6241 : :
6242 : 578975986 : decl = cp_parser_lookup_name (parser, id_expression,
6243 : : none_type,
6244 : : template_p,
6245 : : /*is_namespace=*/false,
6246 : : /*check_dependency=*/true,
6247 : : &ambiguous_decls,
6248 : : id_expression.get_location ());
6249 : : /* If the lookup was ambiguous, an error will already have
6250 : : been issued. */
6251 : 578975986 : if (ambiguous_decls)
6252 : 141 : return error_mark_node;
6253 : :
6254 : : /* In Objective-C++, we may have an Objective-C 2.0
6255 : : dot-syntax for classes here. */
6256 : 578975845 : if (c_dialect_objc ()
6257 : 0 : && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
6258 : 0 : && TREE_CODE (decl) == TYPE_DECL
6259 : 578975845 : && objc_is_class_name (decl))
6260 : : {
6261 : 0 : tree component;
6262 : 0 : cp_lexer_consume_token (parser->lexer);
6263 : 0 : component = cp_parser_identifier (parser);
6264 : 0 : if (component == error_mark_node)
6265 : 0 : return error_mark_node;
6266 : :
6267 : 0 : tree result = objc_build_class_component_ref (id_expression,
6268 : 0 : component);
6269 : : /* Build a location of the form:
6270 : : expr.component
6271 : : ~~~~~^~~~~~~~~
6272 : : with caret at the start of the component name (at
6273 : : input_location), ranging from the start of the id_expression
6274 : : to the end of the component name. */
6275 : 0 : location_t combined_loc
6276 : 0 : = make_location (input_location, id_expression.get_start (),
6277 : : get_finish (input_location));
6278 : 0 : protected_set_expr_location (result, combined_loc);
6279 : 0 : return result;
6280 : : }
6281 : :
6282 : : /* In Objective-C++, an instance variable (ivar) may be preferred
6283 : : to whatever cp_parser_lookup_name() found.
6284 : : Call objc_lookup_ivar. To avoid exposing cp_expr to the
6285 : : rest of c-family, we have to do a little extra work to preserve
6286 : : any location information in cp_expr "decl". Given that
6287 : : objc_lookup_ivar is implemented in "c-family" and "objc", we
6288 : : have a trip through the pure "tree" type, rather than cp_expr.
6289 : : Naively copying it back to "decl" would implicitly give the
6290 : : new cp_expr value an UNKNOWN_LOCATION for nodes that don't
6291 : : store an EXPR_LOCATION. Hence we only update "decl" (and
6292 : : hence its location_t) if we get back a different tree node. */
6293 : 578975845 : tree decl_tree = objc_lookup_ivar (decl.get_value (),
6294 : : id_expression);
6295 : 578975845 : if (decl_tree != decl.get_value ())
6296 : 0 : decl = cp_expr (decl_tree);
6297 : :
6298 : : /* If name lookup gives us a SCOPE_REF, then the
6299 : : qualifying scope was dependent. */
6300 : 578975845 : if (TREE_CODE (decl) == SCOPE_REF)
6301 : : {
6302 : : /* At this point, we do not know if DECL is a valid
6303 : : integral constant expression. We assume that it is
6304 : : in fact such an expression, so that code like:
6305 : :
6306 : : template <int N> struct A {
6307 : : int a[B<N>::i];
6308 : : };
6309 : :
6310 : : is accepted. At template-instantiation time, we
6311 : : will check that B<N>::i is actually a constant. */
6312 : 21672489 : return decl;
6313 : : }
6314 : : /* Check to see if DECL is a local variable in a context
6315 : : where that is forbidden. */
6316 : 557303356 : if ((parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN)
6317 : 2838920 : && local_variable_p (decl)
6318 : : /* DR 2082 permits local variables in unevaluated contexts
6319 : : within a default argument. */
6320 : 557303392 : && !cp_unevaluated_operand)
6321 : : {
6322 : 15 : const char *msg
6323 : 15 : = (TREE_CODE (decl) == PARM_DECL
6324 : 15 : ? G_("parameter %qD may not appear in this context")
6325 : 15 : : G_("local variable %qD may not appear in this context"));
6326 : 15 : error_at (id_expression.get_location (), msg,
6327 : : decl.get_value ());
6328 : 15 : return error_mark_node;
6329 : : }
6330 : : }
6331 : :
6332 : 585046051 : decl = (finish_id_expression
6333 : 1170092099 : (id_expression, decl, parser->scope,
6334 : : idk,
6335 : 585046051 : parser->integral_constant_expression_p,
6336 : 585046051 : parser->allow_non_integral_constant_expression_p,
6337 : : &parser->non_integral_constant_expression_p,
6338 : : template_p, done, address_p,
6339 : : template_arg_p,
6340 : : &error_msg,
6341 : : id_expression.get_location ()));
6342 : 585046048 : if (error_msg)
6343 : 952 : cp_parser_error (parser, error_msg);
6344 : : /* Build a location for an id-expression of the form:
6345 : : ::ns::id
6346 : : ~~~~~~^~
6347 : : or:
6348 : : id
6349 : : ^~
6350 : : i.e. from the start of the first token to the end of the final
6351 : : token, with the caret at the start of the unqualified-id. */
6352 : 585046048 : location_t caret_loc = get_pure_location (id_expression.get_location ());
6353 : 585046048 : location_t start_loc = get_start (id_expr_token->location);
6354 : 585046048 : location_t finish_loc = get_finish (id_expression.get_location ());
6355 : 585046048 : location_t combined_loc
6356 : 585046048 : = make_location (caret_loc, start_loc, finish_loc);
6357 : :
6358 : 585046048 : decl.set_location (combined_loc);
6359 : 585046048 : return decl;
6360 : : }
6361 : :
6362 : : /* Anything else is an error. */
6363 : 119897 : default:
6364 : 119897 : cp_parser_error (parser, "expected primary-expression");
6365 : 119897 : return error_mark_node;
6366 : : }
6367 : : }
6368 : :
6369 : : static inline cp_expr
6370 : 3516715 : cp_parser_primary_expression (cp_parser *parser,
6371 : : bool address_p,
6372 : : bool cast_p,
6373 : : bool template_arg_p,
6374 : : cp_id_kind *idk)
6375 : : {
6376 : 3516715 : return cp_parser_primary_expression (parser, address_p, cast_p, template_arg_p,
6377 : : /*decltype*/false, idk);
6378 : : }
6379 : :
6380 : : /* Complain about missing template keyword when naming a dependent
6381 : : member template. */
6382 : :
6383 : : static void
6384 : 15 : missing_template_diag (location_t loc, diagnostic_t diag_kind = DK_WARNING)
6385 : : {
6386 : 15 : if (warning_suppressed_at (loc, OPT_Wmissing_template_keyword))
6387 : 0 : return;
6388 : :
6389 : 15 : gcc_rich_location richloc (loc);
6390 : 15 : richloc.add_fixit_insert_before ("template");
6391 : 15 : emit_diagnostic (diag_kind, &richloc, OPT_Wmissing_template_keyword,
6392 : : "expected %qs keyword before dependent "
6393 : : "template name", "template");
6394 : 15 : suppress_warning_at (loc, OPT_Wmissing_template_keyword);
6395 : 15 : }
6396 : :
6397 : : /* Parse an id-expression.
6398 : :
6399 : : id-expression:
6400 : : unqualified-id
6401 : : qualified-id
6402 : :
6403 : : qualified-id:
6404 : : :: [opt] nested-name-specifier template [opt] unqualified-id
6405 : : :: identifier
6406 : : :: operator-function-id
6407 : : :: template-id
6408 : :
6409 : : Return a representation of the unqualified portion of the
6410 : : identifier. Sets PARSER->SCOPE to the qualifying scope if there is
6411 : : a `::' or nested-name-specifier.
6412 : :
6413 : : Often, if the id-expression was a qualified-id, the caller will
6414 : : want to make a SCOPE_REF to represent the qualified-id. This
6415 : : function does not do this in order to avoid wastefully creating
6416 : : SCOPE_REFs when they are not required.
6417 : :
6418 : : If TEMPLATE_KEYWORD_P is true, then we have just seen the
6419 : : `template' keyword.
6420 : :
6421 : : If CHECK_DEPENDENCY_P is false, then names are looked up inside
6422 : : uninstantiated templates.
6423 : :
6424 : : If *TEMPLATE_P is non-NULL, it is set to true iff the
6425 : : `template' keyword is used to explicitly indicate that the entity
6426 : : named is a template.
6427 : :
6428 : : If DECLARATOR_P is true, the id-expression is appearing as part of
6429 : : a declarator, rather than as part of an expression. */
6430 : :
6431 : : static cp_expr
6432 : 1295028792 : cp_parser_id_expression (cp_parser *parser,
6433 : : bool template_keyword_p,
6434 : : bool check_dependency_p,
6435 : : bool *template_p,
6436 : : bool declarator_p,
6437 : : bool optional_p)
6438 : : {
6439 : 1295028792 : bool global_scope_p;
6440 : 1295028792 : bool nested_name_specifier_p;
6441 : :
6442 : : /* Assume the `template' keyword was not used. */
6443 : 1295028792 : if (template_p)
6444 : 755479772 : *template_p = template_keyword_p;
6445 : :
6446 : : /* Look for the optional `::' operator. */
6447 : 1295028792 : global_scope_p
6448 : 2590057584 : = (!template_keyword_p
6449 : 1295028792 : && (cp_parser_global_scope_opt (parser,
6450 : : /*current_scope_valid_p=*/false)
6451 : : != NULL_TREE));
6452 : :
6453 : : /* Look for the optional nested-name-specifier. */
6454 : 1295028792 : nested_name_specifier_p
6455 : 1295028792 : = (cp_parser_nested_name_specifier_opt (parser,
6456 : : /*typename_keyword_p=*/false,
6457 : : check_dependency_p,
6458 : : /*type_p=*/false,
6459 : : declarator_p,
6460 : : template_keyword_p)
6461 : : != NULL_TREE);
6462 : :
6463 : 1295028792 : cp_expr id = NULL_TREE;
6464 : 1295028792 : tree scope = parser->scope;
6465 : :
6466 : : /* Peek at the next token. */
6467 : 1295028792 : cp_token *token = cp_lexer_peek_token (parser->lexer);
6468 : :
6469 : : /* If there is a nested-name-specifier, then we are looking at
6470 : : the first qualified-id production. */
6471 : 1295028792 : if (nested_name_specifier_p)
6472 : : {
6473 : 102499693 : tree saved_object_scope;
6474 : 102499693 : tree saved_qualifying_scope;
6475 : :
6476 : : /* See if the next token is the `template' keyword. */
6477 : 102499693 : if (!template_p)
6478 : 11263896 : template_p = &template_keyword_p;
6479 : 102499693 : *template_p = cp_parser_optional_template_keyword (parser);
6480 : : /* Name lookup we do during the processing of the
6481 : : unqualified-id might obliterate SCOPE. */
6482 : 102499693 : saved_object_scope = parser->object_scope;
6483 : 102499693 : saved_qualifying_scope = parser->qualifying_scope;
6484 : : /* Process the final unqualified-id. */
6485 : 102499693 : id = cp_parser_unqualified_id (parser, *template_p,
6486 : : check_dependency_p,
6487 : : declarator_p,
6488 : : /*optional_p=*/false);
6489 : : /* Restore the SAVED_SCOPE for our caller. */
6490 : 102499693 : parser->scope = scope;
6491 : 102499693 : parser->object_scope = saved_object_scope;
6492 : 102499693 : parser->qualifying_scope = saved_qualifying_scope;
6493 : : }
6494 : : /* Otherwise, if we are in global scope, then we are looking at one
6495 : : of the other qualified-id productions. */
6496 : 1192529099 : else if (global_scope_p)
6497 : : {
6498 : : /* If it's an identifier, and the next token is not a "<", then
6499 : : we can avoid the template-id case. This is an optimization
6500 : : for this common case. */
6501 : 180327 : if (token->type == CPP_NAME
6502 : 203609 : && !cp_parser_nth_token_starts_template_argument_list_p
6503 : 23282 : (parser, 2))
6504 : 23282 : return cp_parser_identifier (parser);
6505 : :
6506 : 157045 : cp_parser_parse_tentatively (parser);
6507 : : /* Try a template-id. */
6508 : 157045 : id = cp_parser_template_id_expr (parser,
6509 : : /*template_keyword_p=*/false,
6510 : : /*check_dependency_p=*/true,
6511 : : declarator_p);
6512 : : /* If that worked, we're done. */
6513 : 157045 : if (cp_parser_parse_definitely (parser))
6514 : 18 : return id;
6515 : :
6516 : : /* Peek at the next token. (Changes in the token buffer may
6517 : : have invalidated the pointer obtained above.) */
6518 : 157027 : token = cp_lexer_peek_token (parser->lexer);
6519 : :
6520 : 157027 : switch (token->type)
6521 : : {
6522 : 0 : case CPP_NAME:
6523 : 0 : id = cp_parser_identifier (parser);
6524 : 0 : break;
6525 : :
6526 : 156988 : case CPP_KEYWORD:
6527 : 156988 : if (token->keyword == RID_OPERATOR)
6528 : : {
6529 : 132727 : id = cp_parser_operator_function_id (parser);
6530 : 132727 : break;
6531 : : }
6532 : : /* Fall through. */
6533 : :
6534 : 24300 : default:
6535 : 24300 : cp_parser_error (parser, "expected id-expression");
6536 : 24300 : return error_mark_node;
6537 : : }
6538 : : }
6539 : : else
6540 : : {
6541 : 1192348772 : if (!scope)
6542 : 1192348772 : scope = parser->context->object_type;
6543 : 1192348772 : id = cp_parser_unqualified_id (parser, template_keyword_p,
6544 : : /*check_dependency_p=*/true,
6545 : : declarator_p,
6546 : : optional_p);
6547 : : }
6548 : :
6549 : 1274623988 : if (id && TREE_CODE (id) == IDENTIFIER_NODE
6550 : 1226804888 : && warn_missing_template_keyword
6551 : 1226804879 : && !template_keyword_p
6552 : : /* Don't warn if we're looking inside templates. */
6553 : 1226804798 : && check_dependency_p
6554 : : /* In a template argument list a > could be closing
6555 : : the enclosing targs. */
6556 : 740097484 : && !parser->in_template_argument_list_p
6557 : 695416936 : && scope && dependentish_scope_p (scope)
6558 : : /* Don't confuse an ill-formed constructor declarator for a missing
6559 : : template keyword in a return type. */
6560 : 100300305 : && !(declarator_p && constructor_name_p (id, scope))
6561 : 99662089 : && cp_parser_nth_token_starts_template_argument_list_p (parser, 1)
6562 : 1295135596 : && warning_enabled_at (token->location,
6563 : : OPT_Wmissing_template_keyword))
6564 : : {
6565 : 4363 : saved_token_sentinel toks (parser->lexer, STS_ROLLBACK);
6566 : 4363 : if (cp_parser_skip_entire_template_parameter_list (parser)
6567 : : /* An operator after the > suggests that the > ends a
6568 : : template-id; a name or literal suggests that the > is an
6569 : : operator. */
6570 : 4363 : && (cp_lexer_peek_token (parser->lexer)->type
6571 : : <= CPP_LAST_PUNCTUATOR))
6572 : 15 : missing_template_diag (token->location);
6573 : 4363 : }
6574 : :
6575 : 1294981192 : return id;
6576 : : }
6577 : :
6578 : : /* Parse an unqualified-id.
6579 : :
6580 : : unqualified-id:
6581 : : identifier
6582 : : operator-function-id
6583 : : conversion-function-id
6584 : : ~ class-name
6585 : : template-id
6586 : :
6587 : : If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
6588 : : keyword, in a construct like `A::template ...'.
6589 : :
6590 : : Returns a representation of unqualified-id. For the `identifier'
6591 : : production, an IDENTIFIER_NODE is returned. For the `~ class-name'
6592 : : production a BIT_NOT_EXPR is returned; the operand of the
6593 : : BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
6594 : : other productions, see the documentation accompanying the
6595 : : corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
6596 : : names are looked up in uninstantiated templates. If DECLARATOR_P
6597 : : is true, the unqualified-id is appearing as part of a declarator,
6598 : : rather than as part of an expression. */
6599 : :
6600 : : static cp_expr
6601 : 1303543107 : cp_parser_unqualified_id (cp_parser* parser,
6602 : : bool template_keyword_p,
6603 : : bool check_dependency_p,
6604 : : bool declarator_p,
6605 : : bool optional_p)
6606 : : {
6607 : 1303543107 : cp_token *token;
6608 : :
6609 : : /* Peek at the next token. */
6610 : 1303543107 : token = cp_lexer_peek_token (parser->lexer);
6611 : :
6612 : 1303543107 : switch ((int) token->type)
6613 : : {
6614 : 1204226529 : case CPP_NAME:
6615 : 1204226529 : {
6616 : 1204226529 : tree id;
6617 : :
6618 : : /* We don't know yet whether or not this will be a
6619 : : template-id. */
6620 : 1204226529 : cp_parser_parse_tentatively (parser);
6621 : : /* Try a template-id. */
6622 : 1204226529 : id = cp_parser_template_id_expr (parser, template_keyword_p,
6623 : : check_dependency_p,
6624 : : declarator_p);
6625 : : /* If it worked, we're done. */
6626 : 1204226529 : if (cp_parser_parse_definitely (parser))
6627 : 0 : return id;
6628 : : /* Otherwise, it's an ordinary identifier. */
6629 : 1204226529 : return cp_parser_identifier (parser);
6630 : : }
6631 : :
6632 : 31749309 : case CPP_TEMPLATE_ID:
6633 : 31749309 : return cp_parser_template_id_expr (parser, template_keyword_p,
6634 : : check_dependency_p,
6635 : 31749309 : declarator_p);
6636 : :
6637 : 6343807 : case CPP_COMPL:
6638 : 6343807 : {
6639 : 6343807 : tree type_decl;
6640 : 6343807 : tree qualifying_scope;
6641 : 6343807 : tree object_scope;
6642 : 6343807 : tree scope;
6643 : 6343807 : bool done;
6644 : 6343807 : location_t tilde_loc = token->location;
6645 : :
6646 : : /* Consume the `~' token. */
6647 : 6343807 : cp_lexer_consume_token (parser->lexer);
6648 : : /* Parse the class-name. The standard, as written, seems to
6649 : : say that:
6650 : :
6651 : : template <typename T> struct S { ~S (); };
6652 : : template <typename T> S<T>::~S() {}
6653 : :
6654 : : is invalid, since `~' must be followed by a class-name, but
6655 : : `S<T>' is dependent, and so not known to be a class.
6656 : : That's not right; we need to look in uninstantiated
6657 : : templates. A further complication arises from:
6658 : :
6659 : : template <typename T> void f(T t) {
6660 : : t.T::~T();
6661 : : }
6662 : :
6663 : : Here, it is not possible to look up `T' in the scope of `T'
6664 : : itself. We must look in both the current scope, and the
6665 : : scope of the containing complete expression.
6666 : :
6667 : : Yet another issue is:
6668 : :
6669 : : struct S {
6670 : : int S;
6671 : : ~S();
6672 : : };
6673 : :
6674 : : S::~S() {}
6675 : :
6676 : : The standard does not seem to say that the `S' in `~S'
6677 : : should refer to the type `S' and not the data member
6678 : : `S::S'. */
6679 : :
6680 : : /* DR 244 says that we look up the name after the "~" in the
6681 : : same scope as we looked up the qualifying name. That idea
6682 : : isn't fully worked out; it's more complicated than that. */
6683 : 6343807 : scope = parser->scope;
6684 : 6343807 : object_scope = parser->object_scope;
6685 : 6343807 : qualifying_scope = parser->qualifying_scope;
6686 : :
6687 : : /* Check for invalid scopes. */
6688 : 6343807 : if (scope == error_mark_node)
6689 : : {
6690 : 3 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6691 : 3 : cp_lexer_consume_token (parser->lexer);
6692 : 3 : return error_mark_node;
6693 : : }
6694 : 6343804 : if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
6695 : : {
6696 : 33 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6697 : 9 : error_at (token->location,
6698 : : "scope %qT before %<~%> is not a class-name",
6699 : : scope);
6700 : 24 : cp_parser_simulate_error (parser);
6701 : 12 : if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6702 : 12 : cp_lexer_consume_token (parser->lexer);
6703 : 12 : return error_mark_node;
6704 : : }
6705 : 6343792 : if (template_keyword_p)
6706 : : {
6707 : 9 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6708 : 3 : error_at (tilde_loc, "%<template%> keyword not permitted in "
6709 : : "destructor name");
6710 : 6 : cp_parser_simulate_error (parser);
6711 : 3 : return error_mark_node;
6712 : : }
6713 : :
6714 : 6343789 : gcc_assert (!scope || TYPE_P (scope));
6715 : :
6716 : 6343789 : token = cp_lexer_peek_token (parser->lexer);
6717 : :
6718 : : /* Create a location with caret == start at the tilde,
6719 : : finishing at the end of the peeked token, e.g:
6720 : : ~token
6721 : : ^~~~~~. */
6722 : 6343789 : location_t loc
6723 : 6343789 : = make_location (tilde_loc, tilde_loc, token->location);
6724 : :
6725 : : /* If the name is of the form "X::~X" it's OK even if X is a
6726 : : typedef. */
6727 : :
6728 : 6343789 : if (scope
6729 : 507290 : && token->type == CPP_NAME
6730 : 507254 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6731 : : != CPP_LESS)
6732 : 6851022 : && (token->u.value == TYPE_IDENTIFIER (scope)
6733 : 78 : || (CLASS_TYPE_P (scope)
6734 : 69 : && constructor_name_p (token->u.value, scope))))
6735 : : {
6736 : 507155 : cp_lexer_consume_token (parser->lexer);
6737 : 507155 : return build_min_nt_loc (loc, BIT_NOT_EXPR, scope);
6738 : : }
6739 : :
6740 : : /* ~auto means the destructor of whatever the object is. */
6741 : 5836634 : if (cp_parser_is_keyword (token, RID_AUTO))
6742 : : {
6743 : 3 : if (cxx_dialect < cxx14)
6744 : 0 : pedwarn (loc, OPT_Wc__14_extensions,
6745 : : "%<~auto%> only available with "
6746 : : "%<-std=c++14%> or %<-std=gnu++14%>");
6747 : 3 : cp_lexer_consume_token (parser->lexer);
6748 : 3 : return build_min_nt_loc (loc, BIT_NOT_EXPR, make_auto ());
6749 : : }
6750 : :
6751 : : /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
6752 : : declarator-id of a constructor or destructor. */
6753 : 5836631 : if (token->type == CPP_TEMPLATE_ID && declarator_p)
6754 : : {
6755 : 64 : auto_diagnostic_group d;
6756 : 64 : bool w = false;
6757 : 70 : if (cxx_dialect >= cxx20 && !cp_parser_simulate_error (parser))
6758 : 15 : w = pedwarn (tilde_loc, OPT_Wtemplate_id_cdtor,
6759 : : "template-id not allowed for destructor in C++20");
6760 : 49 : else if (cxx_dialect < cxx20
6761 : 49 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
6762 : 31 : w = warning_at (tilde_loc, OPT_Wtemplate_id_cdtor,
6763 : : "template-id not allowed for destructor in C++20");
6764 : 46 : if (w)
6765 : 20 : inform (tilde_loc, "remove the %qs", "< >");
6766 : 64 : }
6767 : :
6768 : : /* If there was an explicit qualification (S::~T), first look
6769 : : in the scope given by the qualification (i.e., S).
6770 : :
6771 : : Note: in the calls to cp_parser_class_name below we pass
6772 : : typename_type so that lookup finds the injected-class-name
6773 : : rather than the constructor. */
6774 : 5836631 : done = false;
6775 : 5836631 : type_decl = NULL_TREE;
6776 : 5836631 : if (scope)
6777 : : {
6778 : 135 : cp_parser_parse_tentatively (parser);
6779 : 135 : type_decl = cp_parser_class_name (parser,
6780 : : /*typename_keyword_p=*/false,
6781 : : /*template_keyword_p=*/false,
6782 : : typename_type,
6783 : : /*check_dependency=*/false,
6784 : : /*class_head_p=*/false,
6785 : : declarator_p);
6786 : 135 : if (cp_parser_parse_definitely (parser))
6787 : : done = true;
6788 : : }
6789 : : /* In "N::S::~S", look in "N" as well. */
6790 : 5836631 : if (!done && scope && qualifying_scope)
6791 : : {
6792 : 0 : cp_parser_parse_tentatively (parser);
6793 : 0 : parser->scope = qualifying_scope;
6794 : 0 : parser->object_scope = NULL_TREE;
6795 : 0 : parser->qualifying_scope = NULL_TREE;
6796 : 0 : type_decl
6797 : 0 : = cp_parser_class_name (parser,
6798 : : /*typename_keyword_p=*/false,
6799 : : /*template_keyword_p=*/false,
6800 : : typename_type,
6801 : : /*check_dependency=*/false,
6802 : : /*class_head_p=*/false,
6803 : : declarator_p);
6804 : 0 : if (cp_parser_parse_definitely (parser))
6805 : : done = true;
6806 : : }
6807 : : /* In "p->S::~T", look in the scope given by "*p" as well. */
6808 : 5836631 : else if (!done && object_scope)
6809 : : {
6810 : 21 : cp_parser_parse_tentatively (parser);
6811 : 21 : parser->scope = object_scope;
6812 : 21 : parser->object_scope = NULL_TREE;
6813 : 21 : parser->qualifying_scope = NULL_TREE;
6814 : 21 : type_decl
6815 : 21 : = cp_parser_class_name (parser,
6816 : : /*typename_keyword_p=*/false,
6817 : : /*template_keyword_p=*/false,
6818 : : typename_type,
6819 : : /*check_dependency=*/false,
6820 : : /*class_head_p=*/false,
6821 : : declarator_p);
6822 : 21 : if (cp_parser_parse_definitely (parser))
6823 : 0 : done = true;
6824 : : }
6825 : : /* Look in the surrounding context. */
6826 : 5836631 : if (!done)
6827 : : {
6828 : 5836559 : parser->scope = NULL_TREE;
6829 : 5836559 : parser->object_scope = NULL_TREE;
6830 : 5836559 : parser->qualifying_scope = NULL_TREE;
6831 : 5836559 : if (processing_template_decl)
6832 : 3462569 : cp_parser_parse_tentatively (parser);
6833 : 5836559 : type_decl
6834 : 5836559 : = cp_parser_class_name (parser,
6835 : : /*typename_keyword_p=*/false,
6836 : : /*template_keyword_p=*/false,
6837 : : typename_type,
6838 : : /*check_dependency=*/false,
6839 : : /*class_head_p=*/false,
6840 : : declarator_p);
6841 : 5836559 : if (processing_template_decl
6842 : 5836559 : && ! cp_parser_parse_definitely (parser))
6843 : : {
6844 : : /* We couldn't find a type with this name. If we're parsing
6845 : : tentatively, fail and try something else. */
6846 : 25226 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
6847 : : {
6848 : 12589 : cp_parser_simulate_error (parser);
6849 : 12589 : return error_mark_node;
6850 : : }
6851 : : /* Otherwise, accept it and check for a match at instantiation
6852 : : time. */
6853 : 24 : type_decl = cp_parser_identifier (parser);
6854 : 24 : if (type_decl != error_mark_node)
6855 : 19 : type_decl = build_min_nt_loc (loc, BIT_NOT_EXPR, type_decl);
6856 : 24 : return type_decl;
6857 : : }
6858 : : }
6859 : : /* If an error occurred, assume that the name of the
6860 : : destructor is the same as the name of the qualifying
6861 : : class. That allows us to keep parsing after running
6862 : : into ill-formed destructor names. */
6863 : 5824018 : if (type_decl == error_mark_node && scope)
6864 : 9 : return build_min_nt_loc (loc, BIT_NOT_EXPR, scope);
6865 : 5824009 : else if (type_decl == error_mark_node)
6866 : 19 : return error_mark_node;
6867 : :
6868 : : /* Check that destructor name and scope match. */
6869 : 5823990 : if (declarator_p && scope && !check_dtor_name (scope, type_decl))
6870 : : {
6871 : 69 : if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6872 : 9 : error_at (loc,
6873 : : "declaration of %<~%T%> as member of %qT",
6874 : : type_decl, scope);
6875 : 60 : cp_parser_simulate_error (parser);
6876 : 30 : return error_mark_node;
6877 : : }
6878 : :
6879 : : /* [class.dtor]
6880 : :
6881 : : A typedef-name that names a class shall not be used as the
6882 : : identifier in the declarator for a destructor declaration. */
6883 : 5823960 : if (declarator_p
6884 : 5500105 : && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
6885 : 5499962 : && !DECL_SELF_REFERENCE_P (type_decl)
6886 : 5823960 : && !cp_parser_uncommitted_to_tentative_parse_p (parser))
6887 : 6 : error_at (loc,
6888 : : "typedef-name %qD used as destructor declarator",
6889 : : type_decl);
6890 : :
6891 : 5823960 : return build_min_nt_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type_decl));
6892 : : }
6893 : :
6894 : 36311714 : case CPP_KEYWORD:
6895 : 36311714 : if (token->keyword == RID_OPERATOR)
6896 : : {
6897 : 30976902 : cp_expr id;
6898 : :
6899 : : /* This could be a template-id, so we try that first. */
6900 : 30976902 : cp_parser_parse_tentatively (parser);
6901 : : /* Try a template-id. */
6902 : 30976902 : id = cp_parser_template_id_expr (parser, template_keyword_p,
6903 : : /*check_dependency_p=*/true,
6904 : : declarator_p);
6905 : : /* If that worked, we're done. */
6906 : 30976902 : if (cp_parser_parse_definitely (parser))
6907 : 5907 : return id;
6908 : : /* We still don't know whether we're looking at an
6909 : : operator-function-id or a conversion-function-id. */
6910 : 30970995 : cp_parser_parse_tentatively (parser);
6911 : : /* Try an operator-function-id. */
6912 : 30970995 : id = cp_parser_operator_function_id (parser);
6913 : : /* If that didn't work, try a conversion-function-id. */
6914 : 30970995 : if (!cp_parser_parse_definitely (parser))
6915 : 1209750 : id = cp_parser_conversion_function_id (parser);
6916 : :
6917 : 30970995 : return id;
6918 : : }
6919 : : /* Fall through. */
6920 : :
6921 : 30246560 : default:
6922 : 30246560 : if (optional_p)
6923 : 20357204 : return NULL_TREE;
6924 : 9889356 : cp_parser_error (parser, "expected unqualified-id");
6925 : 9889356 : return error_mark_node;
6926 : : }
6927 : : }
6928 : :
6929 : : /* Check [temp.names]/5: A name prefixed by the keyword template shall
6930 : : be a template-id or the name shall refer to a class template or an
6931 : : alias template. */
6932 : :
6933 : : static void
6934 : 2788721 : check_template_keyword_in_nested_name_spec (tree name)
6935 : : {
6936 : 2593555 : if (CLASS_TYPE_P (name)
6937 : 5382276 : && ((CLASSTYPE_USE_TEMPLATE (name)
6938 : 2526181 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (name)))
6939 : 67374 : || CLASSTYPE_IS_TEMPLATE (name)))
6940 : : return;
6941 : :
6942 : 195169 : if (TREE_CODE (name) == TYPENAME_TYPE
6943 : 195169 : && TREE_CODE (TYPENAME_TYPE_FULLNAME (name)) == TEMPLATE_ID_EXPR)
6944 : : return;
6945 : : /* Alias templates are also OK. */
6946 : 18 : else if (alias_template_specialization_p (name, nt_opaque))
6947 : : return;
6948 : :
6949 : 3 : permerror (input_location, TYPE_P (name)
6950 : : ? G_("%qT is not a template")
6951 : : : G_("%qD is not a template"),
6952 : : name);
6953 : : }
6954 : :
6955 : : /* Parse an (optional) nested-name-specifier.
6956 : :
6957 : : nested-name-specifier: [C++98]
6958 : : class-or-namespace-name :: nested-name-specifier [opt]
6959 : : class-or-namespace-name :: template nested-name-specifier [opt]
6960 : :
6961 : : nested-name-specifier: [C++0x]
6962 : : type-name ::
6963 : : namespace-name ::
6964 : : nested-name-specifier identifier ::
6965 : : nested-name-specifier template [opt] simple-template-id ::
6966 : :
6967 : : PARSER->SCOPE should be set appropriately before this function is
6968 : : called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
6969 : : effect. TYPE_P is TRUE if we non-type bindings should be ignored
6970 : : in name lookups.
6971 : :
6972 : : Sets PARSER->SCOPE to the class (TYPE) or namespace
6973 : : (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
6974 : : it unchanged if there is no nested-name-specifier. Returns the new
6975 : : scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
6976 : :
6977 : : If CHECK_DEPENDENCY_P is FALSE, names are looked up in dependent scopes.
6978 : :
6979 : : If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
6980 : : part of a declaration and/or decl-specifier. */
6981 : :
6982 : : static tree
6983 : 4496574531 : cp_parser_nested_name_specifier_opt (cp_parser *parser,
6984 : : bool typename_keyword_p,
6985 : : bool check_dependency_p,
6986 : : bool type_p,
6987 : : bool is_declaration,
6988 : : bool template_keyword_p /* = false */)
6989 : : {
6990 : 4496574531 : bool success = false;
6991 : 4496574531 : cp_token_position start = 0;
6992 : 4496574531 : cp_token *token;
6993 : :
6994 : : /* Remember where the nested-name-specifier starts. */
6995 : 4496574531 : if (cp_parser_uncommitted_to_tentative_parse_p (parser)
6996 : 3390096526 : && cp_lexer_next_token_is_not (parser->lexer, CPP_NESTED_NAME_SPECIFIER))
6997 : : {
6998 : 3340320886 : start = cp_lexer_token_position (parser->lexer, false);
6999 : 3340320886 : push_deferring_access_checks (dk_deferred);
7000 : : }
7001 : :
7002 : 4805852933 : while (true)
7003 : : {
7004 : 4805852933 : tree new_scope;
7005 : 4805852933 : tree old_scope;
7006 : 4805852933 : tree saved_qualifying_scope;
7007 : :
7008 : : /* Spot cases that cannot be the beginning of a
7009 : : nested-name-specifier. */
7010 : 4805852933 : token = cp_lexer_peek_token (parser->lexer);
7011 : :
7012 : : /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
7013 : : the already parsed nested-name-specifier. */
7014 : 4805852933 : if (token->type == CPP_NESTED_NAME_SPECIFIER)
7015 : : {
7016 : : /* Grab the nested-name-specifier and continue the loop. */
7017 : 139079805 : cp_parser_pre_parsed_nested_name_specifier (parser);
7018 : : /* If we originally encountered this nested-name-specifier
7019 : : with CHECK_DEPENDENCY_P set to true, we will not have
7020 : : resolved TYPENAME_TYPEs, so we must do so here. */
7021 : 139079805 : if (is_declaration
7022 : 139079805 : && !check_dependency_p
7023 : 9524138 : && TREE_CODE (parser->scope) == TYPENAME_TYPE)
7024 : : {
7025 : 57580 : new_scope = resolve_typename_type (parser->scope,
7026 : : /*only_current_p=*/false);
7027 : 57580 : if (TREE_CODE (new_scope) != TYPENAME_TYPE)
7028 : 57553 : parser->scope = new_scope;
7029 : : }
7030 : 139079805 : success = true;
7031 : 139079805 : continue;
7032 : : }
7033 : :
7034 : : /* Spot cases that cannot be the beginning of a
7035 : : nested-name-specifier. On the second and subsequent times
7036 : : through the loop, we look for the `template' keyword. */
7037 : 4666773128 : if (success && token->keyword == RID_TEMPLATE)
7038 : : ;
7039 : : /* A template-id can start a nested-name-specifier. */
7040 : 4665724018 : else if (token->type == CPP_TEMPLATE_ID)
7041 : : ;
7042 : : /* DR 743: decltype can be used in a nested-name-specifier. */
7043 : 4609703601 : else if (token_is_decltype (token))
7044 : : ;
7045 : : else
7046 : : {
7047 : : /* If the next token is not an identifier, then it is
7048 : : definitely not a type-name or namespace-name. */
7049 : 4609663252 : if (token->type != CPP_NAME)
7050 : : break;
7051 : : /* If the following token is neither a `<' (to begin a
7052 : : template-id), nor a `::', then we are not looking at a
7053 : : nested-name-specifier. */
7054 : 3502908846 : token = cp_lexer_peek_nth_token (parser->lexer, 2);
7055 : :
7056 : 3502908846 : if (token->type == CPP_COLON
7057 : 8744699 : && parser->colon_corrects_to_scope_p
7058 : 74 : && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_NAME
7059 : : /* name:name is a valid sequence in an Objective C message. */
7060 : 3502908890 : && !parser->objective_c_message_context_p)
7061 : : {
7062 : 44 : gcc_rich_location richloc (token->location);
7063 : 44 : richloc.add_fixit_replace ("::");
7064 : 44 : error_at (&richloc,
7065 : : "found %<:%> in nested-name-specifier, "
7066 : : "expected %<::%>");
7067 : 44 : token->type = CPP_SCOPE;
7068 : 44 : }
7069 : :
7070 : 3502908846 : if (token->type != CPP_SCOPE
7071 : 6870820894 : && !cp_parser_nth_token_starts_template_argument_list_p
7072 : 3367912048 : (parser, 2))
7073 : : break;
7074 : : }
7075 : :
7076 : : /* The nested-name-specifier is optional, so we parse
7077 : : tentatively. */
7078 : 395751531 : cp_parser_parse_tentatively (parser);
7079 : :
7080 : : /* Look for the optional `template' keyword, if this isn't the
7081 : : first time through the loop. */
7082 : 395751531 : if (success)
7083 : : {
7084 : 63377026 : template_keyword_p = cp_parser_optional_template_keyword (parser);
7085 : : /* DR1710: "In a qualified-id used as the name in
7086 : : a typename-specifier, elaborated-type-specifier, using-declaration,
7087 : : or class-or-decltype, an optional keyword template appearing at
7088 : : the top level is ignored." */
7089 : 63377026 : if (!template_keyword_p
7090 : 63377026 : && typename_keyword_p
7091 : 63377026 : && cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
7092 : : template_keyword_p = true;
7093 : : }
7094 : :
7095 : : /* Save the old scope since the name lookup we are about to do
7096 : : might destroy it. */
7097 : 395751531 : old_scope = parser->scope;
7098 : 395751531 : saved_qualifying_scope = parser->qualifying_scope;
7099 : : /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
7100 : : look up names in "X<T>::I" in order to determine that "Y" is
7101 : : a template. So, if we have a typename at this point, we make
7102 : : an effort to look through it. */
7103 : 395751531 : if (is_declaration
7104 : 395751531 : && !check_dependency_p
7105 : 1744350 : && !typename_keyword_p
7106 : 1744350 : && parser->scope
7107 : 19176 : && TREE_CODE (parser->scope) == TYPENAME_TYPE)
7108 : 0 : parser->scope = resolve_typename_type (parser->scope,
7109 : : /*only_current_p=*/false);
7110 : : /* Parse the qualifying entity. */
7111 : 395751531 : new_scope
7112 : 395751531 : = cp_parser_qualifying_entity (parser,
7113 : : typename_keyword_p,
7114 : : template_keyword_p,
7115 : : check_dependency_p,
7116 : : type_p,
7117 : : is_declaration);
7118 : : /* Look for the `::' token. */
7119 : 395751528 : cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
7120 : :
7121 : : /* If we found what we wanted, we keep going; otherwise, we're
7122 : : done. */
7123 : 395751528 : if (!cp_parser_parse_definitely (parser))
7124 : : {
7125 : 225552928 : bool error_p = false;
7126 : :
7127 : : /* Restore the OLD_SCOPE since it was valid before the
7128 : : failed attempt at finding the last
7129 : : class-or-namespace-name. */
7130 : 225552928 : parser->scope = old_scope;
7131 : 225552928 : parser->qualifying_scope = saved_qualifying_scope;
7132 : :
7133 : : /* If the next token is a decltype, and the one after that is a
7134 : : `::', then the decltype has failed to resolve to a class or
7135 : : enumeration type. Give this error even when parsing
7136 : : tentatively since it can't possibly be valid--and we're going
7137 : : to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
7138 : : won't get another chance.*/
7139 : 225552928 : if (cp_lexer_next_token_is (parser->lexer, CPP_DECLTYPE)
7140 : 225552928 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
7141 : : == CPP_SCOPE))
7142 : : {
7143 : 9 : token = cp_lexer_consume_token (parser->lexer);
7144 : 9 : tree dtype = token->u.tree_check_value->value;
7145 : 9 : if (dtype != error_mark_node)
7146 : 9 : error_at (token->location, "%<decltype%> evaluates to %qT, "
7147 : : "which is not a class or enumeration type",
7148 : : dtype);
7149 : 9 : parser->scope = error_mark_node;
7150 : 9 : error_p = true;
7151 : : /* As below. */
7152 : 9 : success = true;
7153 : 9 : cp_lexer_consume_token (parser->lexer);
7154 : : }
7155 : :
7156 : 225552928 : if (cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID)
7157 : 225552928 : && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SCOPE))
7158 : : {
7159 : : /* If we have a non-type template-id followed by ::, it can't
7160 : : possibly be valid. */
7161 : 51 : token = cp_lexer_peek_token (parser->lexer);
7162 : 51 : tree tid = token->u.tree_check_value->value;
7163 : 51 : if (TREE_CODE (tid) == TEMPLATE_ID_EXPR
7164 : 51 : && TREE_CODE (TREE_OPERAND (tid, 0)) != IDENTIFIER_NODE)
7165 : : {
7166 : 15 : auto_diagnostic_group d;
7167 : 15 : tree tmpl = NULL_TREE;
7168 : 15 : if (is_overloaded_fn (tid))
7169 : : {
7170 : 6 : tree fns = get_fns (tid);
7171 : 6 : if (OVL_SINGLE_P (fns))
7172 : 6 : tmpl = OVL_FIRST (fns);
7173 : 6 : error_at (token->location, "function template-id "
7174 : : "%qD in nested-name-specifier", tid);
7175 : : }
7176 : : else
7177 : : {
7178 : 9 : tmpl = TREE_OPERAND (tid, 0);
7179 : 18 : if (concept_definition_p (tmpl))
7180 : 6 : error_at (token->location, "concept-id %qD "
7181 : : "in nested-name-specifier", tid);
7182 : : else
7183 : : {
7184 : : /* Variable template. */
7185 : 3 : gcc_assert (variable_template_p (tmpl));
7186 : 3 : error_at (token->location, "variable template-id "
7187 : : "%qD in nested-name-specifier", tid);
7188 : : }
7189 : : }
7190 : 15 : if (tmpl)
7191 : 15 : inform (DECL_SOURCE_LOCATION (tmpl),
7192 : : "%qD declared here", tmpl);
7193 : :
7194 : 15 : parser->scope = error_mark_node;
7195 : 15 : error_p = true;
7196 : : /* As below. */
7197 : 15 : success = true;
7198 : 15 : cp_lexer_consume_token (parser->lexer);
7199 : 15 : cp_lexer_consume_token (parser->lexer);
7200 : 15 : }
7201 : : }
7202 : :
7203 : 4775354882 : if (cp_parser_uncommitted_to_tentative_parse_p (parser))
7204 : : break;
7205 : : /* If the next token is an identifier, and the one after
7206 : : that is a `::', then any valid interpretation would have
7207 : : found a class-or-namespace-name. */
7208 : 53227429 : while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
7209 : 6997545 : && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
7210 : : == CPP_SCOPE)
7211 : 53227554 : && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
7212 : : != CPP_COMPL))
7213 : : {
7214 : 122 : token = cp_lexer_consume_token (parser->lexer);
7215 : 122 : if (!error_p)
7216 : : {
7217 : 117 : if (!token->error_reported)
7218 : : {
7219 : 117 : tree decl;
7220 : 117 : tree ambiguous_decls;
7221 : :
7222 : 117 : decl = cp_parser_lookup_name (parser, token->u.value,
7223 : : none_type,
7224 : : /*is_template=*/false,
7225 : : /*is_namespace=*/false,
7226 : : /*check_dependency=*/true,
7227 : : &ambiguous_decls,
7228 : : token->location);
7229 : 117 : if (TREE_CODE (decl) == TEMPLATE_DECL)
7230 : 9 : error_at (token->location,
7231 : : "%qD used without template arguments",
7232 : : decl);
7233 : 108 : else if (ambiguous_decls)
7234 : : {
7235 : : // cp_parser_lookup_name has the same diagnostic,
7236 : : // thus make sure to emit it at most once.
7237 : 9 : if (cp_parser_uncommitted_to_tentative_parse_p
7238 : 9 : (parser))
7239 : : {
7240 : 0 : error_at (token->location,
7241 : : "reference to %qD is ambiguous",
7242 : : token->u.value);
7243 : 0 : print_candidates (ambiguous_decls);
7244 : : }
7245 : 9 : decl = error_mark_node;
7246 : : }
7247 : : else
7248 : : {
7249 : 99 : if (cxx_dialect != cxx98)
7250 : 77 : cp_parser_name_lookup_error
7251 : 77 : (parser, token->u.value, decl, NLE_NOT_CXX98,
7252 : : token->location);
7253 : : else
7254 : 22 : cp_parser_name_lookup_error
7255 : 22 : (parser, token->u.value, decl, NLE_CXX98,
7256 : : token->location);
7257 : : }
7258 : : }
7259 : 117 : parser->scope = error_mark_node;
7260 : 117 : error_p = true;
7261 : : /* Treat this as a successful nested-name-specifier
7262 : : due to:
7263 : :
7264 : : [basic.lookup.qual]
7265 : :
7266 : : If the name found is not a class-name (clause
7267 : : _class_) or namespace-name (_namespace.def_), the
7268 : : program is ill-formed. */
7269 : 117 : success = true;
7270 : : }
7271 : 122 : cp_lexer_consume_token (parser->lexer);
7272 : : }
7273 : : break;
7274 : : }
7275 : : /* We've found one valid nested-name-specifier. */
7276 : 170198600 : success = true;
7277 : : /* Name lookup always gives us a DECL. */
7278 : 170198600 : if (TREE_CODE (new_scope) == TYPE_DECL)
7279 : 76698629 : new_scope = TREE_TYPE (new_scope);
7280 : : /* Uses of "template" must be followed by actual templates. */
7281 : 170198600 : if (template_keyword_p)
7282 : 2788721 : check_template_keyword_in_nested_name_spec (new_scope);
7283 : : /* If it is a class scope, try to complete it; we are about to
7284 : : be looking up names inside the class. */
7285 : 170198600 : if (TYPE_P (new_scope)
7286 : : /* Since checking types for dependency can be expensive,
7287 : : avoid doing it if the type is already complete. */
7288 : 76707045 : && !COMPLETE_TYPE_P (new_scope)
7289 : : /* Do not try to complete dependent types. */
7290 : 217699518 : && !dependent_type_p (new_scope))
7291 : : {
7292 : 656741 : new_scope = complete_type (new_scope);
7293 : : /* If it is a typedef to current class, use the current
7294 : : class instead, as the typedef won't have any names inside
7295 : : it yet. */
7296 : 656738 : if (!COMPLETE_TYPE_P (new_scope)
7297 : 656738 : && currently_open_class (new_scope))
7298 : 44441 : new_scope = TYPE_MAIN_VARIANT (new_scope);
7299 : : }
7300 : : /* Make sure we look in the right scope the next time through
7301 : : the loop. */
7302 : 170198597 : parser->scope = new_scope;
7303 : : }
7304 : :
7305 : : /* If parsing tentatively, replace the sequence of tokens that makes
7306 : : up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
7307 : : token. That way, should we re-parse the token stream, we will
7308 : : not have to repeat the effort required to do the parse, nor will
7309 : : we issue duplicate error messages. */
7310 : 4496574525 : if (success && start)
7311 : : {
7312 : 132156454 : cp_token *token;
7313 : :
7314 : 132156454 : token = cp_lexer_token_at (parser->lexer, start);
7315 : : /* Reset the contents of the START token. */
7316 : 132156454 : token->type = CPP_NESTED_NAME_SPECIFIER;
7317 : : /* Retrieve any deferred checks. Do not pop this access checks yet
7318 : : so the memory will not be reclaimed during token replacing below. */
7319 : 132156454 : token->u.tree_check_value = ggc_cleared_alloc<struct tree_check> ();
7320 : 132156454 : token->tree_check_p = true;
7321 : 132156454 : token->u.tree_check_value->value = parser->scope;
7322 : 132156454 : token->u.tree_check_value->checks = get_deferred_access_checks ();
7323 : 132156454 : token->u.tree_check_value->qualifying_scope =
7324 : 132156454 : parser->qualifying_scope;
7325 : 132156454 : token->keyword = RID_MAX;
7326 : :
7327 : : /* Purge all subsequent tokens. */
7328 : 132156454 : cp_lexer_purge_tokens_after (parser->lexer, start);
7329 : : }
7330 : :
7331 : 4496574525 : if (start)
7332 : 3340320880 : pop_to_parent_deferring_access_checks ();
7333 : :
7334 : 4496574525 : return success ? parser->scope : NULL_TREE;
7335 : : }
7336 : :
7337 : : /* Parse a nested-name-specifier. See
7338 : : cp_parser_nested_name_specifier_opt for details. This function
7339 : : behaves identically, except that it will an issue an error if no
7340 : : nested-name-specifier is present. */
7341 : :
7342 : : static tree
7343 : 975787661 : cp_parser_nested_name_specifier (cp_parser *parser,
7344 : : bool typename_keyword_p,
7345 : : bool check_dependency_p,
7346 : : bool type_p,
7347 : : bool is_declaration)
7348 : : {
7349 : 975787661 : tree scope;
7350 : :
7351 : : /* Look for the nested-name-specifier. */
7352 : 975787661 : scope = cp_parser_nested_name_specifier_opt (parser,
7353 : : typename_keyword_p,
7354 : : check_dependency_p,
7355 : : type_p,
7356 : : is_declaration);
7357 : : /* If it was not present, issue an error message. */
7358 : 975787661 : if (!scope)
7359 : : {
7360 : 934834909 : cp_parser_error (parser, "expected nested-name-specifier");
7361 : 934834909 : parser->scope = NULL_TREE;
7362 : : }
7363 : :
7364 : 975787661 : return scope;
7365 : : }
7366 : :
7367 : : /* Parse the qualifying entity in a nested-name-specifier. For C++98,
7368 : : this is either a class-name or a namespace-name (which corresponds
7369 : : to the class-or-namespace-name production in the grammar). For
7370 : : C++0x, it can also be a type-name that refers to an enumeration
7371 : : type or a simple-template-id.
7372 : :
7373 : : TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
7374 : : TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
7375 : : CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
7376 : : TYPE_P is TRUE iff the next name should be taken as a class-name,
7377 : : even the same name is declared to be another entity in the same
7378 : : scope.
7379 : :
7380 : : Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
7381 : : specified by the class-or-namespace-name. If neither is found the
7382 : : ERROR_MARK_NODE is returned. */
7383 : :
7384 : : static tree
7385 : 395751531 : cp_parser_qualifying_entity (cp_parser *parser,
7386 : : bool typename_keyword_p,
7387 : : bool template_keyword_p,
7388 : : bool check_dependency_p,
7389 : : bool type_p,
7390 : : bool is_declaration)
7391 : : {
7392 : 395751531 : tree saved_scope;
7393 : 395751531 : tree saved_qualifying_scope;
7394 : 395751531 : tree saved_object_scope;
7395 : 395751531 : tree scope;
7396 : 395751531 : bool only_class_p;
7397 : 395751531 : bool successful_parse_p;
7398 : :
7399 : : /* DR 743: decltype can appear in a nested-name-specifier. */
7400 : 395751531 : if (cp_lexer_next_token_is_decltype (parser->lexer))
7401 : : {
7402 : 40349 : scope = cp_parser_decltype (parser);
7403 : 40349 : if (TREE_CODE (scope) != ENUMERAL_TYPE
7404 : 223 : && !MAYBE_CLASS_TYPE_P (scope))
7405 : : {
7406 : 750 : cp_parser_simulate_error (parser);
7407 : 375 : return error_mark_node;
7408 : : }
7409 : 39974 : if (TYPE_NAME (scope))
7410 : 611 : scope = TYPE_NAME (scope);
7411 : 39974 : return scope;
7412 : : }
7413 : :
7414 : : /* Before we try to parse the class-name, we must save away the
7415 : : current PARSER->SCOPE since cp_parser_class_name will destroy
7416 : : it. */
7417 : 395711182 : saved_scope = parser->scope;
7418 : 395711182 : saved_qualifying_scope = parser->qualifying_scope;
7419 : 395711182 : saved_object_scope = parser->object_scope;
7420 : : /* Try for a class-name first. If the SAVED_SCOPE is a type, then
7421 : : there is no need to look for a namespace-name. */
7422 : 1183062085 : only_class_p = template_keyword_p
7423 : 395711182 : || (saved_scope && TYPE_P (saved_scope) && cxx_dialect == cxx98);
7424 : 391639721 : if (!only_class_p)
7425 : 391639721 : cp_parser_parse_tentatively (parser);
7426 : 395711182 : scope = cp_parser_class_name (parser,
7427 : : typename_keyword_p,
7428 : : template_keyword_p,
7429 : : type_p ? class_type : none_type,
7430 : : check_dependency_p,
7431 : : /*class_head_p=*/false,
7432 : : is_declaration,
7433 : 395711182 : /*enum_ok=*/cxx_dialect > cxx98);
7434 : 395711179 : successful_parse_p = only_class_p || cp_parser_parse_definitely (parser);
7435 : : /* If that didn't work, try for a namespace-name. */
7436 : 395711179 : if (!only_class_p && !successful_parse_p)
7437 : : {
7438 : : /* Restore the saved scope. */
7439 : 175735681 : parser->scope = saved_scope;
7440 : 175735681 : parser->qualifying_scope = saved_qualifying_scope;
7441 : 175735681 : parser->object_scope = saved_object_scope;
7442 : : /* If we are not looking at an identifier followed by the scope
7443 : : resolution operator, then this is not part of a
7444 : : nested-name-specifier. (Note that this function is only used
7445 : : to parse the components of a nested-name-specifier.) */
7446 : 175735681 : if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
7447 : 175735681 : || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
7448 : 82243832 : return error_mark_node;
7449 : 93491849 : scope = cp_parser_namespace_name (parser);
7450 : : }
7451 : :
7452 : : return scope;
7453 : : }
7454 : :
7455 : : /* Return true if we are looking at a compound-literal, false otherwise. */
7456 : :
7457 : : static bool
7458 : 29417790 : cp_parser_compound_literal_p (cp_parser *parser)
7459 : : {
7460 : 29417790 : cp_lexer_save_tokens (parser->lexer);
7461 : :
7462 : : /* Skip tokens until the next token is a closing parenthesis.
7463 : : If we find the closing `)', and the next token is a `{', then
7464 : : we are looking at a compound-literal. */
7465 : 29417790 : bool compound_literal_p
7466 : 29417790 : = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
7467 : : /*consume_paren=*/true)
7468 : 29417790 : && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
7469 : :
7470 : : /* Roll back the tokens we skipped. */
7471 : 29417790 : cp_lexer_rollback_tokens (parser->lexer);
7472 : :
7473 : 29417790 : return compound_literal_p;
7474 : : }
7475 : :
7476 : : /* Return true if EXPR is the integer constant zero or a complex constant
7477 : : of zero, without any folding, but ignoring location wrappers. */
7478 : :
7479 : : bool
7480 : 196610 : literal_integer_zerop (const_tree expr)
7481 : : {
7482 : 196610 : return (location_wrapper_p (expr)
7483 : 196610 : && integer_zerop (TREE_OPERAND (expr, 0)));
7484 : : }
7485 : :
7486 : : /* Parse a postfix-expression.
7487 : :
7488 : : postfix-expression:
7489 : : primary-expression
7490 : : postfix-expression [ expression ]
7491 : : postfix-expression ( expression-list [opt] )
7492 : : simple-type-specifier ( expression-list [opt] )
7493 : : typename :: [opt] nested-name-specifier identifier
7494 : : ( expression-list [opt] )
7495 : : typename :: [opt] nested-name-specifier template [opt] template-id
7496 : : ( expression-list [opt] )
7497 : : postfix-expression . template [opt] id-expression
7498 : : postfix-expression -> template [opt] id-expression
7499 : : postfix-expression . pseudo-destructor-name
7500 : : postfix-expression -> pseudo-destructor-name
7501 : : postfix-expression ++
7502 : : postfix-expression --
7503 : : dynamic_cast < type-id > ( expression )
7504 : : static_cast < type-id > ( expression )
7505 : : reinterpret_cast < type-id > ( expression )
7506 : : const_cast < type-id > ( expression )
7507 : : typeid ( expression )
7508 : : typeid ( type-id )
7509 : :
7510 : : GNU Extension:
7511 : :
7512 : : postfix-expression:
7513 : : ( type-id ) { initializer-list , [opt] }
7514 : :
7515 : : This extension is a GNU version of the C99 compound-literal
7516 : : construct. (The C99 grammar uses `type-name' instead of `type-id',
7517 : : but they are essentially the same concept.)
7518 : :
|
