1/* Data structures and function exported by the C++ Parser.
2 Copyright (C) 2010-2023 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 GCC is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#ifndef GCC_CP_PARSER_H
21#define GCC_CP_PARSER_H
22
23#include "tree.h"
24#include "cp/cp-tree.h"
25#include "c-family/c-pragma.h"
26
27/* A token's value and its associated deferred access checks and
28 qualifying scope. */
29
30struct GTY(()) tree_check {
31 /* The value associated with the token. */
32 tree value;
33 /* The checks that have been associated with value. */
34 vec<deferred_access_check, va_gc> *checks;
35 /* The token's qualifying scope (used when it is a
36 CPP_NESTED_NAME_SPECIFIER). */
37 tree qualifying_scope;
38};
39
40/* A C++ token. */
41
42struct GTY (()) cp_token {
43 /* The kind of token. */
44 enum cpp_ttype type : 8;
45 /* If this token is a keyword, this value indicates which keyword.
46 Otherwise, this value is RID_MAX. */
47 enum rid keyword : 8;
48 /* Token flags. */
49 unsigned char flags;
50 /* True if this token is from a context where it is implicitly extern "C" */
51 bool implicit_extern_c : 1;
52 /* True if an error has already been reported for this token, such as a
53 CPP_NAME token that is not a keyword (i.e., for which KEYWORD is
54 RID_MAX) iff this name was looked up and found to be ambiguous. */
55 bool error_reported : 1;
56 /* True for a token that has been purged. If a token is purged,
57 it is no longer a valid token and it should be considered
58 deleted. */
59 bool purged_p : 1;
60 bool tree_check_p : 1;
61 bool main_source_p : 1;
62 /* 3 unused bits. */
63
64 /* The location at which this token was found. */
65 location_t location;
66 /* The value associated with this token, if any. */
67 union cp_token_value {
68 /* Used for compound tokens such as CPP_NESTED_NAME_SPECIFIER. */
69 struct tree_check* GTY((tag ("true"))) tree_check_value;
70 /* Use for all other tokens. */
71 tree GTY((tag ("false"))) value;
72 } GTY((desc ("%1.tree_check_p"))) u;
73};
74
75
76/* We use a stack of token pointer for saving token sets. */
77typedef struct cp_token *cp_token_position;
78
79/* The cp_lexer structure represents the C++ lexer. It is responsible
80 for managing the token stream from the preprocessor and supplying
81 it to the parser. Tokens are never added to the cp_lexer after
82 it is created. */
83
84struct GTY (()) cp_lexer {
85 /* The memory allocated for the buffer. NULL if this lexer does not
86 own the token buffer. */
87 vec<cp_token, va_gc> *buffer;
88
89 /* A pointer just past the last available token. The tokens
90 in this lexer are [buffer, last_token). */
91 cp_token_position GTY ((skip)) last_token;
92
93 /* The next available token. If NEXT_TOKEN is &eof_token, then there are
94 no more available tokens. */
95 cp_token_position GTY ((skip)) next_token;
96
97 /* A stack indicating positions at which cp_lexer_save_tokens was
98 called. The top entry is the most recent position at which we
99 began saving tokens. If the stack is non-empty, we are saving
100 tokens. */
101 vec<cp_token_position> GTY ((skip)) saved_tokens;
102
103 /* Saved pieces of end token we replaced with the eof token. */
104 enum cpp_ttype saved_type : 8;
105 enum rid saved_keyword : 8;
106
107 /* The next lexer in a linked list of lexers. */
108 struct cp_lexer *next;
109
110 /* Set for omp::decl attribute parsing to the decl to which it
111 appertains. */
112 tree in_omp_decl_attribute;
113
114 /* True if we should output debugging information. */
115 bool debugging_p;
116
117 /* True if we're in the context of parsing a pragma, and should not
118 increment past the end-of-line marker. */
119 bool in_pragma;
120
121 /* True if we're in the context of OpenMP directives written as C++11
122 attributes turned into pragma. */
123 bool in_omp_attribute_pragma;
124
125 /* True for in_omp_attribute_pragma lexer that should be destroyed
126 when it is no longer in use. */
127 bool orphan_p;
128};
129
130
131/* cp_token_cache is a range of tokens. There is no need to represent
132 allocate heap memory for it, since tokens are never removed from the
133 lexer's array. There is also no need for the GC to walk through
134 a cp_token_cache, since everything in here is referenced through
135 a lexer. */
136
137struct GTY(()) cp_token_cache {
138 /* The beginning of the token range. */
139 cp_token * GTY((skip)) first;
140
141 /* Points immediately after the last token in the range. */
142 cp_token * GTY ((skip)) last;
143};
144
145typedef cp_token_cache *cp_token_cache_ptr;
146
147struct cp_token_ident
148{
149 unsigned int ident_len;
150 const char *ident_str;
151 unsigned int before_len;
152 const char *before_str;
153 unsigned int after_len;
154 const char *after_str;
155};
156
157/* An entry in a queue of function arguments that require post-processing. */
158
159struct GTY(()) cp_default_arg_entry {
160 /* The current_class_type when we parsed this arg. */
161 tree class_type;
162
163 /* The function decl itself. */
164 tree decl;
165};
166
167
168/* An entry in a stack for member functions defined within their classes. */
169
170struct GTY(()) cp_unparsed_functions_entry {
171 /* Functions with default arguments that require post-processing.
172 Functions appear in this list in declaration order. */
173 vec<cp_default_arg_entry, va_gc> *funs_with_default_args;
174
175 /* Functions with defintions that require post-processing. Functions
176 appear in this list in declaration order. */
177 vec<tree, va_gc> *funs_with_definitions;
178
179 /* Non-static data members with initializers that require post-processing.
180 FIELD_DECLs appear in this list in declaration order. */
181 vec<tree, va_gc> *nsdmis;
182
183 /* Functions with noexcept-specifiers that require post-processing. */
184 vec<tree, va_gc> *noexcepts;
185
186 /* Functions with contract attributes that require post-processing. */
187 vec<tree, va_gc> *contracts;
188};
189
190
191/* The status of a tentative parse. */
192
193enum cp_parser_status_kind
194{
195 /* No errors have occurred. */
196 CP_PARSER_STATUS_KIND_NO_ERROR,
197 /* An error has occurred. */
198 CP_PARSER_STATUS_KIND_ERROR,
199 /* We are committed to this tentative parse, whether or not an error
200 has occurred. */
201 CP_PARSER_STATUS_KIND_COMMITTED
202};
203
204
205/* Context that is saved and restored when parsing tentatively. */
206struct GTY (()) cp_parser_context {
207 /* If this is a tentative parsing context, the status of the
208 tentative parse. */
209 enum cp_parser_status_kind status;
210 /* If non-NULL, we have just seen a `x->' or `x.' expression. Names
211 that are looked up in this context must be looked up both in the
212 scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
213 the context of the containing expression. */
214 tree object_type;
215
216 /* The next parsing context in the stack. */
217 struct cp_parser_context *next;
218};
219
220
221/* Helper data structure for parsing #pragma omp declare {simd,variant}. */
222struct cp_omp_declare_simd_data {
223 bool error_seen; /* Set if error has been reported. */
224 bool fndecl_seen; /* Set if one fn decl/definition has been seen already. */
225 bool variant_p; /* Set for #pragma omp declare variant. */
226 location_t loc;
227 vec<cp_token_cache_ptr> tokens;
228 tree *attribs[2];
229};
230
231/* Helper data structure for parsing #pragma acc routine. */
232struct cp_oacc_routine_data : cp_omp_declare_simd_data {
233 tree clauses;
234};
235
236/* The cp_parser structure represents the C++ parser. */
237
238struct GTY(()) cp_parser {
239 /* The lexer from which we are obtaining tokens. */
240 cp_lexer *lexer;
241
242 /* The scope in which names should be looked up. If NULL_TREE, then
243 we look up names in the scope that is currently open in the
244 source program. If non-NULL, this is either a TYPE or
245 NAMESPACE_DECL for the scope in which we should look. It can
246 also be ERROR_MARK, when we've parsed a bogus scope.
247
248 This value is not cleared automatically after a name is looked
249 up, so we must be careful to clear it before starting a new look
250 up sequence. (If it is not cleared, then `X::Y' followed by `Z'
251 will look up `Z' in the scope of `X', rather than the current
252 scope.) Unfortunately, it is difficult to tell when name lookup
253 is complete, because we sometimes peek at a token, look it up,
254 and then decide not to consume it. */
255 tree scope;
256
257 /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
258 last lookup took place. OBJECT_SCOPE is used if an expression
259 like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
260 respectively. QUALIFYING_SCOPE is used for an expression of the
261 form "X::Y"; it refers to X. */
262 tree object_scope;
263 tree qualifying_scope;
264
265 /* A stack of parsing contexts. All but the bottom entry on the
266 stack will be tentative contexts.
267
268 We parse tentatively in order to determine which construct is in
269 use in some situations. For example, in order to determine
270 whether a statement is an expression-statement or a
271 declaration-statement we parse it tentatively as a
272 declaration-statement. If that fails, we then reparse the same
273 token stream as an expression-statement. */
274 cp_parser_context *context;
275
276 /* True if we are parsing GNU C++. If this flag is not set, then
277 GNU extensions are not recognized. */
278 bool allow_gnu_extensions_p;
279
280 /* TRUE if the `>' token should be interpreted as the greater-than
281 operator. FALSE if it is the end of a template-id or
282 template-parameter-list. In C++0x mode, this flag also applies to
283 `>>' tokens, which are viewed as two consecutive `>' tokens when
284 this flag is FALSE. */
285 bool greater_than_is_operator_p;
286
287 /* TRUE if default arguments are allowed within a parameter list
288 that starts at this point. FALSE if only a gnu extension makes
289 them permissible. */
290 bool default_arg_ok_p;
291
292 /* TRUE if we are parsing an integral constant-expression. See
293 [expr.const] for a precise definition. */
294 bool integral_constant_expression_p;
295
296 /* TRUE if we are parsing an integral constant-expression -- but a
297 non-constant expression should be permitted as well. This flag
298 is used when parsing an array bound so that GNU variable-length
299 arrays are tolerated. */
300 bool allow_non_integral_constant_expression_p;
301
302 /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
303 been seen that makes the expression non-constant. */
304 bool non_integral_constant_expression_p;
305
306 /* Used to track if local variable names and/or `this' are forbidden
307 in the current context. */
308#define LOCAL_VARS_FORBIDDEN (1 << 0)
309#define THIS_FORBIDDEN (1 << 1)
310#define LOCAL_VARS_AND_THIS_FORBIDDEN (LOCAL_VARS_FORBIDDEN | THIS_FORBIDDEN)
311 unsigned char local_variables_forbidden_p;
312
313 /* TRUE if the declaration we are parsing is part of a
314 linkage-specification of the form `extern string-literal
315 declaration'. */
316 bool in_unbraced_linkage_specification_p;
317
318 /* TRUE if we are presently parsing a declarator, after the
319 direct-declarator. */
320 bool in_declarator_p;
321
322 /* TRUE if we are presently parsing a template-argument-list. */
323 bool in_template_argument_list_p;
324
325 /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
326 to IN_OMP_BLOCK if parsing OpenMP structured block and
327 IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
328 this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
329 iteration-statement, OpenMP block or loop within that switch. */
330#define IN_SWITCH_STMT 1
331#define IN_ITERATION_STMT 2
332#define IN_OMP_BLOCK 4
333#define IN_OMP_FOR 8
334#define IN_IF_STMT 16
335 unsigned char in_statement;
336
337 /* TRUE if we are presently parsing the body of a switch statement.
338 Note that this doesn't quite overlap with in_statement above.
339 The difference relates to giving the right sets of error messages:
340 "case not in switch" vs "break statement used with OpenMP...". */
341 bool in_switch_statement_p;
342
343 /* TRUE if we are parsing a type-id in an expression context. In
344 such a situation, both "type (expr)" and "type (type)" are valid
345 alternatives. */
346 bool in_type_id_in_expr_p;
347
348 /* TRUE if strings in expressions should be translated to the execution
349 character set. */
350 bool translate_strings_p;
351
352 /* TRUE if we are presently parsing the body of a function, but not
353 a local class. */
354 bool in_function_body;
355
356 /* Nonzero if we're processing a __transaction_atomic or
357 __transaction_relaxed statement. */
358 unsigned char in_transaction;
359
360 /* TRUE if we can auto-correct a colon to a scope operator. */
361 bool colon_corrects_to_scope_p;
362
363 /* TRUE if : doesn't start a class definition. Should be only used
364 together with type_definition_forbidden_message non-NULL, in
365 contexts where new types may not be defined, and the type list
366 is terminated by colon. */
367 bool colon_doesnt_start_class_def_p;
368
369 /* TRUE if we are parsing an objective c message, and ':' is permitted
370 to terminate an assignment-expression. */
371 bool objective_c_message_context_p;
372
373 /* If non-NULL, then we are parsing a construct where new type
374 definitions are not permitted. The string stored here will be
375 issued as an error message if a type is defined. */
376 const char *type_definition_forbidden_message;
377
378 /* Argument for type_definition_forbidden_message if needed. */
379 const char *type_definition_forbidden_message_arg;
380
381 /* A stack used for member functions of local classes. The lists
382 contained in an individual entry can only be processed once the
383 outermost class being defined is complete. */
384 vec<cp_unparsed_functions_entry, va_gc> *unparsed_queues;
385
386 /* The number of classes whose definitions are currently in
387 progress. */
388 unsigned num_classes_being_defined;
389
390 /* The number of template parameter lists that apply directly to the
391 current declaration. */
392 unsigned num_template_parameter_lists;
393
394 /* When parsing #pragma omp declare simd, this is a pointer to a
395 helper data structure. */
396 cp_omp_declare_simd_data * GTY((skip)) omp_declare_simd;
397
398 /* When parsing #pragma acc routine, this is a pointer to a helper data
399 structure. */
400 cp_oacc_routine_data * GTY((skip)) oacc_routine;
401
402 /* Nonzero if parsing a parameter list where 'auto' should trigger an implicit
403 template parameter. */
404 bool auto_is_implicit_function_template_parm_p;
405
406 /* TRUE if the function being declared was made a template due to its
407 parameter list containing generic type specifiers (`auto' or concept
408 identifiers) rather than an explicit template parameter list. */
409 bool fully_implicit_function_template_p;
410
411 /* TRUE if omp::directive, omp::decl or omp::sequence attributes may not
412 appear. */
413 bool omp_attrs_forbidden_p;
414
415 /* Tracks the function's template parameter list when declaring a function
416 using generic type parameters. This is either a new chain in the case of a
417 fully implicit function template or an extension of the function's existing
418 template parameter list. This is tracked to optimize calls subsequent
419 calls to synthesize_implicit_template_parm during
420 cp_parser_parameter_declaration. */
421 tree implicit_template_parms;
422
423 /* The scope into which an implicit template parameter list has been
424 introduced or an existing template parameter list is being extended with
425 implicit template parameters. In most cases this is the sk_function_parms
426 scope containing the use of a generic type. In the case of an out-of-line
427 member definition using a generic type, it is the sk_class scope. */
428 cp_binding_level* implicit_template_scope;
429
430 /* True if parsing a result type in a compound requirement. This permits
431 constrained-type-specifiers inside what would normally be a trailing
432 return type. */
433 bool in_result_type_constraint_p;
434
435 /* True if a constrained-type-specifier is not allowed in this
436 context e.g., because they could never be deduced. */
437 int prevent_constrained_type_specifiers;
438
439 /* Location of the string-literal token within the current linkage
440 specification, if any, or UNKNOWN_LOCATION otherwise. */
441 location_t innermost_linkage_specification_location;
442
443 /* Pointer to state for parsing omp_loops. Managed by
444 cp_parser_omp_for_loop in parser.cc and not used outside that file. */
445 struct omp_for_parse_data * GTY((skip)) omp_for_parse_state;
446};
447
448/* In parser.cc */
449extern void debug (cp_token &ref);
450extern void debug (cp_token *ptr);
451extern void cp_lexer_debug_tokens (vec<cp_token, va_gc> *);
452extern void debug (vec<cp_token, va_gc> &ref);
453extern void debug (vec<cp_token, va_gc> *ptr);
454extern void cp_debug_parser (FILE *, cp_parser *);
455extern void debug (cp_parser &ref);
456extern void debug (cp_parser *ptr);
457extern bool cp_keyword_starts_decl_specifier_p (enum rid keyword);
458
459#endif /* GCC_CP_PARSER_H */
460

source code of gcc/cp/parser.h