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 | |
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/>. */ |
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 | |
30 | struct 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 | |
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. */ |
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. */ |
77 | typedef 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 | |
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; |
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 | |
137 | struct 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 | |
145 | typedef cp_token_cache *cp_token_cache_ptr; |
146 | |
147 | struct 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 | |
159 | struct 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 | |
170 | struct 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 | |
193 | enum 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. */ |
206 | struct 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}. */ |
222 | struct 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. */ |
232 | struct cp_oacc_routine_data : cp_omp_declare_simd_data { |
233 | tree clauses; |
234 | }; |
235 | |
236 | /* The cp_parser structure represents the C++ parser. */ |
237 | |
238 | struct 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 */ |
449 | extern void debug (cp_token &ref); |
450 | extern void debug (cp_token *ptr); |
451 | extern void cp_lexer_debug_tokens (vec<cp_token, va_gc> *); |
452 | extern void debug (vec<cp_token, va_gc> &ref); |
453 | extern void debug (vec<cp_token, va_gc> *ptr); |
454 | extern void cp_debug_parser (FILE *, cp_parser *); |
455 | extern void debug (cp_parser &ref); |
456 | extern void debug (cp_parser *ptr); |
457 | extern bool cp_keyword_starts_decl_specifier_p (enum rid keyword); |
458 | |
459 | #endif /* GCC_CP_PARSER_H */ |
460 | |