1 /* Data structures and function exported by the C++ Parser.
2 Copyright (C) 2010-2023 Free Software Foundation, Inc.
4 This file is part of GCC.
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)
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.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 #ifndef GCC_CP_PARSER_H
21 #define GCC_CP_PARSER_H
24 #include "cp/cp-tree.h"
25 #include "c-family/c-pragma.h"
27 /* A token's value and its associated deferred access checks and
30 struct GTY(()) tree_check
{
31 /* The value associated with the token. */
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
;
42 struct 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. */
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
60 bool tree_check_p
: 1;
61 bool main_source_p
: 1;
64 /* The location at which this token was found. */
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
;
76 /* We use a stack of token pointer for saving token sets. */
77 typedef struct cp_token
*cp_token_position
;
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
84 struct 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
;
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
;
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
;
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
101 vec
<cp_token_position
> GTY ((skip
)) saved_tokens
;
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;
107 /* The next lexer in a linked list of lexers. */
108 struct cp_lexer
*next
;
110 /* True if we should output debugging information. */
113 /* True if we're in the context of parsing a pragma, and should not
114 increment past the end-of-line marker. */
117 /* True if we're in the context of OpenMP directives written as C++11
118 attributes turned into pragma. */
119 bool in_omp_attribute_pragma
;
121 /* True for in_omp_attribute_pragma lexer that should be destroyed
122 when it is no longer in use. */
127 /* cp_token_cache is a range of tokens. There is no need to represent
128 allocate heap memory for it, since tokens are never removed from the
129 lexer's array. There is also no need for the GC to walk through
130 a cp_token_cache, since everything in here is referenced through
133 struct GTY(()) cp_token_cache
{
134 /* The beginning of the token range. */
135 cp_token
* GTY((skip
)) first
;
137 /* Points immediately after the last token in the range. */
138 cp_token
* GTY ((skip
)) last
;
141 typedef cp_token_cache
*cp_token_cache_ptr
;
143 struct cp_token_ident
145 unsigned int ident_len
;
146 const char *ident_str
;
147 unsigned int before_len
;
148 const char *before_str
;
149 unsigned int after_len
;
150 const char *after_str
;
153 /* An entry in a queue of function arguments that require post-processing. */
155 struct GTY(()) cp_default_arg_entry
{
156 /* The current_class_type when we parsed this arg. */
159 /* The function decl itself. */
164 /* An entry in a stack for member functions defined within their classes. */
166 struct GTY(()) cp_unparsed_functions_entry
{
167 /* Functions with default arguments that require post-processing.
168 Functions appear in this list in declaration order. */
169 vec
<cp_default_arg_entry
, va_gc
> *funs_with_default_args
;
171 /* Functions with defintions that require post-processing. Functions
172 appear in this list in declaration order. */
173 vec
<tree
, va_gc
> *funs_with_definitions
;
175 /* Non-static data members with initializers that require post-processing.
176 FIELD_DECLs appear in this list in declaration order. */
177 vec
<tree
, va_gc
> *nsdmis
;
179 /* Functions with noexcept-specifiers that require post-processing. */
180 vec
<tree
, va_gc
> *noexcepts
;
182 /* Functions with contract attributes that require post-processing. */
183 vec
<tree
, va_gc
> *contracts
;
187 /* The status of a tentative parse. */
189 enum cp_parser_status_kind
191 /* No errors have occurred. */
192 CP_PARSER_STATUS_KIND_NO_ERROR
,
193 /* An error has occurred. */
194 CP_PARSER_STATUS_KIND_ERROR
,
195 /* We are committed to this tentative parse, whether or not an error
197 CP_PARSER_STATUS_KIND_COMMITTED
201 /* Context that is saved and restored when parsing tentatively. */
202 struct GTY (()) cp_parser_context
{
203 /* If this is a tentative parsing context, the status of the
205 enum cp_parser_status_kind status
;
206 /* If non-NULL, we have just seen a `x->' or `x.' expression. Names
207 that are looked up in this context must be looked up both in the
208 scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
209 the context of the containing expression. */
212 /* The next parsing context in the stack. */
213 struct cp_parser_context
*next
;
217 /* Helper data structure for parsing #pragma omp declare {simd,variant}. */
218 struct cp_omp_declare_simd_data
{
219 bool error_seen
; /* Set if error has been reported. */
220 bool fndecl_seen
; /* Set if one fn decl/definition has been seen already. */
221 bool variant_p
; /* Set for #pragma omp declare variant. */
223 vec
<cp_token_cache_ptr
> tokens
;
227 /* Helper data structure for parsing #pragma acc routine. */
228 struct cp_oacc_routine_data
: cp_omp_declare_simd_data
{
232 /* The cp_parser structure represents the C++ parser. */
234 struct GTY(()) cp_parser
{
235 /* The lexer from which we are obtaining tokens. */
238 /* The scope in which names should be looked up. If NULL_TREE, then
239 we look up names in the scope that is currently open in the
240 source program. If non-NULL, this is either a TYPE or
241 NAMESPACE_DECL for the scope in which we should look. It can
242 also be ERROR_MARK, when we've parsed a bogus scope.
244 This value is not cleared automatically after a name is looked
245 up, so we must be careful to clear it before starting a new look
246 up sequence. (If it is not cleared, then `X::Y' followed by `Z'
247 will look up `Z' in the scope of `X', rather than the current
248 scope.) Unfortunately, it is difficult to tell when name lookup
249 is complete, because we sometimes peek at a token, look it up,
250 and then decide not to consume it. */
253 /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
254 last lookup took place. OBJECT_SCOPE is used if an expression
255 like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
256 respectively. QUALIFYING_SCOPE is used for an expression of the
257 form "X::Y"; it refers to X. */
259 tree qualifying_scope
;
261 /* A stack of parsing contexts. All but the bottom entry on the
262 stack will be tentative contexts.
264 We parse tentatively in order to determine which construct is in
265 use in some situations. For example, in order to determine
266 whether a statement is an expression-statement or a
267 declaration-statement we parse it tentatively as a
268 declaration-statement. If that fails, we then reparse the same
269 token stream as an expression-statement. */
270 cp_parser_context
*context
;
272 /* True if we are parsing GNU C++. If this flag is not set, then
273 GNU extensions are not recognized. */
274 bool allow_gnu_extensions_p
;
276 /* TRUE if the `>' token should be interpreted as the greater-than
277 operator. FALSE if it is the end of a template-id or
278 template-parameter-list. In C++0x mode, this flag also applies to
279 `>>' tokens, which are viewed as two consecutive `>' tokens when
280 this flag is FALSE. */
281 bool greater_than_is_operator_p
;
283 /* TRUE if default arguments are allowed within a parameter list
284 that starts at this point. FALSE if only a gnu extension makes
286 bool default_arg_ok_p
;
288 /* TRUE if we are parsing an integral constant-expression. See
289 [expr.const] for a precise definition. */
290 bool integral_constant_expression_p
;
292 /* TRUE if we are parsing an integral constant-expression -- but a
293 non-constant expression should be permitted as well. This flag
294 is used when parsing an array bound so that GNU variable-length
295 arrays are tolerated. */
296 bool allow_non_integral_constant_expression_p
;
298 /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
299 been seen that makes the expression non-constant. */
300 bool non_integral_constant_expression_p
;
302 /* Used to track if local variable names and/or `this' are forbidden
303 in the current context. */
304 #define LOCAL_VARS_FORBIDDEN (1 << 0)
305 #define THIS_FORBIDDEN (1 << 1)
306 #define LOCAL_VARS_AND_THIS_FORBIDDEN (LOCAL_VARS_FORBIDDEN | THIS_FORBIDDEN)
307 unsigned char local_variables_forbidden_p
;
309 /* TRUE if the declaration we are parsing is part of a
310 linkage-specification of the form `extern string-literal
312 bool in_unbraced_linkage_specification_p
;
314 /* TRUE if we are presently parsing a declarator, after the
315 direct-declarator. */
316 bool in_declarator_p
;
318 /* TRUE if we are presently parsing a template-argument-list. */
319 bool in_template_argument_list_p
;
321 /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
322 to IN_OMP_BLOCK if parsing OpenMP structured block and
323 IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
324 this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
325 iteration-statement, OpenMP block or loop within that switch. */
326 #define IN_SWITCH_STMT 1
327 #define IN_ITERATION_STMT 2
328 #define IN_OMP_BLOCK 4
330 #define IN_IF_STMT 16
331 unsigned char in_statement
;
333 /* TRUE if we are presently parsing the body of a switch statement.
334 Note that this doesn't quite overlap with in_statement above.
335 The difference relates to giving the right sets of error messages:
336 "case not in switch" vs "break statement used with OpenMP...". */
337 bool in_switch_statement_p
;
339 /* TRUE if we are parsing a type-id in an expression context. In
340 such a situation, both "type (expr)" and "type (type)" are valid
342 bool in_type_id_in_expr_p
;
344 /* TRUE if strings in expressions should be translated to the execution
346 bool translate_strings_p
;
348 /* TRUE if we are presently parsing the body of a function, but not
350 bool in_function_body
;
352 /* Nonzero if we're processing a __transaction_atomic or
353 __transaction_relaxed statement. */
354 unsigned char in_transaction
;
356 /* TRUE if we can auto-correct a colon to a scope operator. */
357 bool colon_corrects_to_scope_p
;
359 /* TRUE if : doesn't start a class definition. Should be only used
360 together with type_definition_forbidden_message non-NULL, in
361 contexts where new types may not be defined, and the type list
362 is terminated by colon. */
363 bool colon_doesnt_start_class_def_p
;
365 /* TRUE if we are parsing an objective c message, and ':' is permitted
366 to terminate an assignment-expression. */
367 bool objective_c_message_context_p
;
369 /* If non-NULL, then we are parsing a construct where new type
370 definitions are not permitted. The string stored here will be
371 issued as an error message if a type is defined. */
372 const char *type_definition_forbidden_message
;
374 /* Argument for type_definition_forbidden_message if needed. */
375 const char *type_definition_forbidden_message_arg
;
377 /* A stack used for member functions of local classes. The lists
378 contained in an individual entry can only be processed once the
379 outermost class being defined is complete. */
380 vec
<cp_unparsed_functions_entry
, va_gc
> *unparsed_queues
;
382 /* The number of classes whose definitions are currently in
384 unsigned num_classes_being_defined
;
386 /* The number of template parameter lists that apply directly to the
387 current declaration. */
388 unsigned num_template_parameter_lists
;
390 /* When parsing #pragma omp declare simd, this is a pointer to a
391 helper data structure. */
392 cp_omp_declare_simd_data
* GTY((skip
)) omp_declare_simd
;
394 /* When parsing #pragma acc routine, this is a pointer to a helper data
396 cp_oacc_routine_data
* GTY((skip
)) oacc_routine
;
398 /* Nonzero if parsing a parameter list where 'auto' should trigger an implicit
399 template parameter. */
400 bool auto_is_implicit_function_template_parm_p
;
402 /* TRUE if the function being declared was made a template due to its
403 parameter list containing generic type specifiers (`auto' or concept
404 identifiers) rather than an explicit template parameter list. */
405 bool fully_implicit_function_template_p
;
407 /* TRUE if omp::directive or omp::sequence attributes may not appear. */
408 bool omp_attrs_forbidden_p
;
410 /* Tracks the function's template parameter list when declaring a function
411 using generic type parameters. This is either a new chain in the case of a
412 fully implicit function template or an extension of the function's existing
413 template parameter list. This is tracked to optimize calls subsequent
414 calls to synthesize_implicit_template_parm during
415 cp_parser_parameter_declaration. */
416 tree implicit_template_parms
;
418 /* The scope into which an implicit template parameter list has been
419 introduced or an existing template parameter list is being extended with
420 implicit template parameters. In most cases this is the sk_function_parms
421 scope containing the use of a generic type. In the case of an out-of-line
422 member definition using a generic type, it is the sk_class scope. */
423 cp_binding_level
* implicit_template_scope
;
425 /* True if parsing a result type in a compound requirement. This permits
426 constrained-type-specifiers inside what would normally be a trailing
428 bool in_result_type_constraint_p
;
430 /* True if a constrained-type-specifier is not allowed in this
431 context e.g., because they could never be deduced. */
432 int prevent_constrained_type_specifiers
;
434 /* Location of the string-literal token within the current linkage
435 specification, if any, or UNKNOWN_LOCATION otherwise. */
436 location_t innermost_linkage_specification_location
;
441 extern void debug (cp_token
&ref
);
442 extern void debug (cp_token
*ptr
);
443 extern void cp_lexer_debug_tokens (vec
<cp_token
, va_gc
> *);
444 extern void debug (vec
<cp_token
, va_gc
> &ref
);
445 extern void debug (vec
<cp_token
, va_gc
> *ptr
);
446 extern void cp_debug_parser (FILE *, cp_parser
*);
447 extern void debug (cp_parser
&ref
);
448 extern void debug (cp_parser
*ptr
);
449 extern bool cp_keyword_starts_decl_specifier_p (enum rid keyword
);
451 #endif /* GCC_CP_PARSER_H */