]>
Commit | Line | Data |
---|---|---|
f617201f | 1 | /* Data structures and function exported by the C++ Parser. |
99dee823 | 2 | Copyright (C) 2010-2021 Free Software Foundation, Inc. |
f617201f DN |
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" | |
7b3b6ae4 | 24 | #include "cp/cp-tree.h" |
f617201f DN |
25 | #include "c-family/c-pragma.h" |
26 | ||
f617201f DN |
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. */ | |
9771b263 | 34 | vec<deferred_access_check, va_gc> *checks; |
f617201f DN |
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 | ||
a79683d5 | 42 | struct GTY (()) cp_token { |
f617201f | 43 | /* The kind of token. */ |
14c835a0 | 44 | enum cpp_ttype type : 8; |
f617201f DN |
45 | /* If this token is a keyword, this value indicates which keyword. |
46 | Otherwise, this value is RID_MAX. */ | |
14c835a0 | 47 | enum rid keyword : 8; |
f617201f DN |
48 | /* Token flags. */ |
49 | unsigned char flags; | |
f617201f | 50 | /* True if this token is from a context where it is implicitly extern "C" */ |
14c835a0 | 51 | bool implicit_extern_c : 1; |
63620197 JM |
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. */ | |
14c835a0 | 55 | bool error_reported : 1; |
f617201f DN |
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. */ | |
14c835a0 NS |
59 | bool purged_p : 1; |
60 | bool tree_check_p : 1; | |
0b372331 NS |
61 | bool main_source_p : 1; |
62 | /* 3 unused bits. */ | |
14c835a0 | 63 | |
f617201f DN |
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 { | |
ca8e4b87 | 68 | /* Used for compound tokens such as CPP_NESTED_NAME_SPECIFIER. */ |
14c835a0 | 69 | struct tree_check* GTY((tag ("true"))) tree_check_value; |
f617201f | 70 | /* Use for all other tokens. */ |
14c835a0 NS |
71 | tree GTY((tag ("false"))) value; |
72 | } GTY((desc ("%1.tree_check_p"))) u; | |
a79683d5 | 73 | }; |
f617201f | 74 | |
f617201f DN |
75 | |
76 | /* We use a stack of token pointer for saving token sets. */ | |
77 | typedef struct cp_token *cp_token_position; | |
f617201f DN |
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 | ||
a79683d5 | 84 | struct GTY (()) cp_lexer { |
f617201f DN |
85 | /* The memory allocated for the buffer. NULL if this lexer does not |
86 | own the token buffer. */ | |
9771b263 | 87 | vec<cp_token, va_gc> *buffer; |
f617201f DN |
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. */ | |
9771b263 | 101 | vec<cp_token_position> GTY ((skip)) saved_tokens; |
f617201f | 102 | |
14c835a0 NS |
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 | ||
f617201f DN |
107 | /* The next lexer in a linked list of lexers. */ |
108 | struct cp_lexer *next; | |
109 | ||
110 | /* True if we should output debugging information. */ | |
111 | bool debugging_p; | |
112 | ||
113 | /* True if we're in the context of parsing a pragma, and should not | |
114 | increment past the end-of-line marker. */ | |
115 | bool in_pragma; | |
a79683d5 | 116 | }; |
f617201f | 117 | |
f617201f DN |
118 | |
119 | /* cp_token_cache is a range of tokens. There is no need to represent | |
120 | allocate heap memory for it, since tokens are never removed from the | |
121 | lexer's array. There is also no need for the GC to walk through | |
122 | a cp_token_cache, since everything in here is referenced through | |
123 | a lexer. */ | |
124 | ||
a79683d5 | 125 | struct GTY(()) cp_token_cache { |
f617201f DN |
126 | /* The beginning of the token range. */ |
127 | cp_token * GTY((skip)) first; | |
128 | ||
129 | /* Points immediately after the last token in the range. */ | |
130 | cp_token * GTY ((skip)) last; | |
a79683d5 | 131 | }; |
f617201f DN |
132 | |
133 | typedef cp_token_cache *cp_token_cache_ptr; | |
f617201f | 134 | |
a79683d5 | 135 | struct cp_token_ident |
f617201f DN |
136 | { |
137 | unsigned int ident_len; | |
138 | const char *ident_str; | |
139 | unsigned int before_len; | |
140 | const char *before_str; | |
141 | unsigned int after_len; | |
142 | const char *after_str; | |
143 | }; | |
144 | ||
f617201f DN |
145 | /* An entry in a queue of function arguments that require post-processing. */ |
146 | ||
a79683d5 | 147 | struct GTY(()) cp_default_arg_entry { |
f617201f DN |
148 | /* The current_class_type when we parsed this arg. */ |
149 | tree class_type; | |
150 | ||
151 | /* The function decl itself. */ | |
152 | tree decl; | |
a79683d5 | 153 | }; |
f617201f | 154 | |
f617201f | 155 | |
b15ea309 | 156 | /* An entry in a stack for member functions defined within their classes. */ |
f617201f | 157 | |
a79683d5 | 158 | struct GTY(()) cp_unparsed_functions_entry { |
f617201f DN |
159 | /* Functions with default arguments that require post-processing. |
160 | Functions appear in this list in declaration order. */ | |
9771b263 | 161 | vec<cp_default_arg_entry, va_gc> *funs_with_default_args; |
f617201f DN |
162 | |
163 | /* Functions with defintions that require post-processing. Functions | |
164 | appear in this list in declaration order. */ | |
9771b263 | 165 | vec<tree, va_gc> *funs_with_definitions; |
eb026338 JM |
166 | |
167 | /* Non-static data members with initializers that require post-processing. | |
168 | FIELD_DECLs appear in this list in declaration order. */ | |
9771b263 | 169 | vec<tree, va_gc> *nsdmis; |
b15ea309 | 170 | |
78f7607d MP |
171 | /* Functions with noexcept-specifiers that require post-processing. */ |
172 | vec<tree, va_gc> *noexcepts; | |
a79683d5 | 173 | }; |
f617201f | 174 | |
f617201f DN |
175 | |
176 | /* The status of a tentative parse. */ | |
177 | ||
a79683d5 | 178 | enum cp_parser_status_kind |
f617201f DN |
179 | { |
180 | /* No errors have occurred. */ | |
181 | CP_PARSER_STATUS_KIND_NO_ERROR, | |
182 | /* An error has occurred. */ | |
183 | CP_PARSER_STATUS_KIND_ERROR, | |
184 | /* We are committed to this tentative parse, whether or not an error | |
185 | has occurred. */ | |
186 | CP_PARSER_STATUS_KIND_COMMITTED | |
a79683d5 | 187 | }; |
f617201f DN |
188 | |
189 | ||
190 | /* Context that is saved and restored when parsing tentatively. */ | |
a79683d5 | 191 | struct GTY (()) cp_parser_context { |
f617201f DN |
192 | /* If this is a tentative parsing context, the status of the |
193 | tentative parse. */ | |
194 | enum cp_parser_status_kind status; | |
195 | /* If non-NULL, we have just seen a `x->' or `x.' expression. Names | |
196 | that are looked up in this context must be looked up both in the | |
197 | scope given by OBJECT_TYPE (the type of `x' or `*x') and also in | |
198 | the context of the containing expression. */ | |
199 | tree object_type; | |
200 | ||
201 | /* The next parsing context in the stack. */ | |
202 | struct cp_parser_context *next; | |
a79683d5 | 203 | }; |
f617201f DN |
204 | |
205 | ||
94e7f906 | 206 | /* Helper data structure for parsing #pragma omp declare {simd,variant}. */ |
acf0174b JJ |
207 | struct cp_omp_declare_simd_data { |
208 | bool error_seen; /* Set if error has been reported. */ | |
209 | bool fndecl_seen; /* Set if one fn decl/definition has been seen already. */ | |
94e7f906 | 210 | bool variant_p; /* Set for #pragma omp declare variant. */ |
acf0174b | 211 | vec<cp_token_cache_ptr> tokens; |
8504d5dd | 212 | tree clauses; |
acf0174b JJ |
213 | }; |
214 | ||
0b212d8c TS |
215 | /* Helper data structure for parsing #pragma acc routine. */ |
216 | struct cp_oacc_routine_data : cp_omp_declare_simd_data { | |
217 | location_t loc; | |
218 | }; | |
acf0174b | 219 | |
f617201f DN |
220 | /* The cp_parser structure represents the C++ parser. */ |
221 | ||
a79683d5 | 222 | struct GTY(()) cp_parser { |
f617201f DN |
223 | /* The lexer from which we are obtaining tokens. */ |
224 | cp_lexer *lexer; | |
225 | ||
226 | /* The scope in which names should be looked up. If NULL_TREE, then | |
227 | we look up names in the scope that is currently open in the | |
228 | source program. If non-NULL, this is either a TYPE or | |
229 | NAMESPACE_DECL for the scope in which we should look. It can | |
230 | also be ERROR_MARK, when we've parsed a bogus scope. | |
231 | ||
232 | This value is not cleared automatically after a name is looked | |
233 | up, so we must be careful to clear it before starting a new look | |
234 | up sequence. (If it is not cleared, then `X::Y' followed by `Z' | |
235 | will look up `Z' in the scope of `X', rather than the current | |
236 | scope.) Unfortunately, it is difficult to tell when name lookup | |
237 | is complete, because we sometimes peek at a token, look it up, | |
238 | and then decide not to consume it. */ | |
239 | tree scope; | |
240 | ||
241 | /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the | |
242 | last lookup took place. OBJECT_SCOPE is used if an expression | |
243 | like "x->y" or "x.y" was used; it gives the type of "*x" or "x", | |
244 | respectively. QUALIFYING_SCOPE is used for an expression of the | |
245 | form "X::Y"; it refers to X. */ | |
246 | tree object_scope; | |
247 | tree qualifying_scope; | |
248 | ||
249 | /* A stack of parsing contexts. All but the bottom entry on the | |
250 | stack will be tentative contexts. | |
251 | ||
252 | We parse tentatively in order to determine which construct is in | |
253 | use in some situations. For example, in order to determine | |
254 | whether a statement is an expression-statement or a | |
255 | declaration-statement we parse it tentatively as a | |
256 | declaration-statement. If that fails, we then reparse the same | |
257 | token stream as an expression-statement. */ | |
258 | cp_parser_context *context; | |
259 | ||
260 | /* True if we are parsing GNU C++. If this flag is not set, then | |
261 | GNU extensions are not recognized. */ | |
262 | bool allow_gnu_extensions_p; | |
263 | ||
264 | /* TRUE if the `>' token should be interpreted as the greater-than | |
265 | operator. FALSE if it is the end of a template-id or | |
266 | template-parameter-list. In C++0x mode, this flag also applies to | |
267 | `>>' tokens, which are viewed as two consecutive `>' tokens when | |
268 | this flag is FALSE. */ | |
269 | bool greater_than_is_operator_p; | |
270 | ||
271 | /* TRUE if default arguments are allowed within a parameter list | |
272 | that starts at this point. FALSE if only a gnu extension makes | |
273 | them permissible. */ | |
274 | bool default_arg_ok_p; | |
275 | ||
276 | /* TRUE if we are parsing an integral constant-expression. See | |
277 | [expr.const] for a precise definition. */ | |
278 | bool integral_constant_expression_p; | |
279 | ||
280 | /* TRUE if we are parsing an integral constant-expression -- but a | |
281 | non-constant expression should be permitted as well. This flag | |
282 | is used when parsing an array bound so that GNU variable-length | |
283 | arrays are tolerated. */ | |
284 | bool allow_non_integral_constant_expression_p; | |
285 | ||
286 | /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has | |
287 | been seen that makes the expression non-constant. */ | |
288 | bool non_integral_constant_expression_p; | |
289 | ||
e01ffb47 MP |
290 | /* Used to track if local variable names and/or `this' are forbidden |
291 | in the current context. */ | |
292 | #define LOCAL_VARS_FORBIDDEN (1 << 0) | |
293 | #define THIS_FORBIDDEN (1 << 1) | |
294 | #define LOCAL_VARS_AND_THIS_FORBIDDEN (LOCAL_VARS_FORBIDDEN | THIS_FORBIDDEN) | |
295 | unsigned char local_variables_forbidden_p; | |
f617201f DN |
296 | |
297 | /* TRUE if the declaration we are parsing is part of a | |
298 | linkage-specification of the form `extern string-literal | |
299 | declaration'. */ | |
300 | bool in_unbraced_linkage_specification_p; | |
301 | ||
302 | /* TRUE if we are presently parsing a declarator, after the | |
303 | direct-declarator. */ | |
304 | bool in_declarator_p; | |
305 | ||
306 | /* TRUE if we are presently parsing a template-argument-list. */ | |
307 | bool in_template_argument_list_p; | |
308 | ||
309 | /* Set to IN_ITERATION_STMT if parsing an iteration-statement, | |
310 | to IN_OMP_BLOCK if parsing OpenMP structured block and | |
311 | IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement, | |
312 | this is bitwise ORed with IN_SWITCH_STMT, unless parsing an | |
313 | iteration-statement, OpenMP block or loop within that switch. */ | |
314 | #define IN_SWITCH_STMT 1 | |
315 | #define IN_ITERATION_STMT 2 | |
316 | #define IN_OMP_BLOCK 4 | |
317 | #define IN_OMP_FOR 8 | |
318 | #define IN_IF_STMT 16 | |
319 | unsigned char in_statement; | |
320 | ||
321 | /* TRUE if we are presently parsing the body of a switch statement. | |
322 | Note that this doesn't quite overlap with in_statement above. | |
323 | The difference relates to giving the right sets of error messages: | |
324 | "case not in switch" vs "break statement used with OpenMP...". */ | |
325 | bool in_switch_statement_p; | |
326 | ||
327 | /* TRUE if we are parsing a type-id in an expression context. In | |
328 | such a situation, both "type (expr)" and "type (type)" are valid | |
329 | alternatives. */ | |
330 | bool in_type_id_in_expr_p; | |
331 | ||
f617201f DN |
332 | /* TRUE if strings in expressions should be translated to the execution |
333 | character set. */ | |
334 | bool translate_strings_p; | |
335 | ||
336 | /* TRUE if we are presently parsing the body of a function, but not | |
337 | a local class. */ | |
338 | bool in_function_body; | |
0a35513e AH |
339 | |
340 | /* Nonzero if we're processing a __transaction_atomic or | |
341 | __transaction_relaxed statement. */ | |
342 | unsigned char in_transaction; | |
f617201f DN |
343 | |
344 | /* TRUE if we can auto-correct a colon to a scope operator. */ | |
345 | bool colon_corrects_to_scope_p; | |
346 | ||
acf0174b JJ |
347 | /* TRUE if : doesn't start a class definition. Should be only used |
348 | together with type_definition_forbidden_message non-NULL, in | |
349 | contexts where new types may not be defined, and the type list | |
350 | is terminated by colon. */ | |
351 | bool colon_doesnt_start_class_def_p; | |
352 | ||
f617201f DN |
353 | /* If non-NULL, then we are parsing a construct where new type |
354 | definitions are not permitted. The string stored here will be | |
355 | issued as an error message if a type is defined. */ | |
356 | const char *type_definition_forbidden_message; | |
357 | ||
657184d0 JJ |
358 | /* Argument for type_definition_forbidden_message if needed. */ |
359 | const char *type_definition_forbidden_message_arg; | |
360 | ||
f617201f DN |
361 | /* A stack used for member functions of local classes. The lists |
362 | contained in an individual entry can only be processed once the | |
363 | outermost class being defined is complete. */ | |
9771b263 | 364 | vec<cp_unparsed_functions_entry, va_gc> *unparsed_queues; |
f617201f DN |
365 | |
366 | /* The number of classes whose definitions are currently in | |
367 | progress. */ | |
368 | unsigned num_classes_being_defined; | |
369 | ||
370 | /* The number of template parameter lists that apply directly to the | |
371 | current declaration. */ | |
372 | unsigned num_template_parameter_lists; | |
1a11a94f | 373 | |
acf0174b | 374 | /* When parsing #pragma omp declare simd, this is a pointer to a |
0b212d8c | 375 | helper data structure. */ |
acf0174b JJ |
376 | cp_omp_declare_simd_data * GTY((skip)) omp_declare_simd; |
377 | ||
0b212d8c TS |
378 | /* When parsing #pragma acc routine, this is a pointer to a helper data |
379 | structure. */ | |
380 | cp_oacc_routine_data * GTY((skip)) oacc_routine; | |
3a40d81d | 381 | |
0dca5025 AB |
382 | /* Nonzero if parsing a parameter list where 'auto' should trigger an implicit |
383 | template parameter. */ | |
384 | bool auto_is_implicit_function_template_parm_p; | |
385 | ||
1a11a94f AB |
386 | /* TRUE if the function being declared was made a template due to its |
387 | parameter list containing generic type specifiers (`auto' or concept | |
388 | identifiers) rather than an explicit template parameter list. */ | |
389 | bool fully_implicit_function_template_p; | |
390 | ||
0dca5025 AB |
391 | /* Tracks the function's template parameter list when declaring a function |
392 | using generic type parameters. This is either a new chain in the case of a | |
393 | fully implicit function template or an extension of the function's existing | |
394 | template parameter list. This is tracked to optimize calls subsequent | |
395 | calls to synthesize_implicit_template_parm during | |
396 | cp_parser_parameter_declaration. */ | |
397 | tree implicit_template_parms; | |
398 | ||
399 | /* The scope into which an implicit template parameter list has been | |
400 | introduced or an existing template parameter list is being extended with | |
2ec7e902 | 401 | implicit template parameters. In most cases this is the sk_function_parms |
0dca5025 AB |
402 | scope containing the use of a generic type. In the case of an out-of-line |
403 | member definition using a generic type, it is the sk_class scope. */ | |
404 | cp_binding_level* implicit_template_scope; | |
405 | ||
971e17ff AS |
406 | /* True if parsing a result type in a compound requirement. This permits |
407 | constrained-type-specifiers inside what would normally be a trailing | |
408 | return type. */ | |
409 | bool in_result_type_constraint_p; | |
410 | ||
411 | /* True if a constrained-type-specifier is not allowed in this | |
412 | context e.g., because they could never be deduced. */ | |
413 | int prevent_constrained_type_specifiers; | |
414 | ||
15f7a469 DM |
415 | /* Location of the string-literal token within the current linkage |
416 | specification, if any, or UNKNOWN_LOCATION otherwise. */ | |
417 | location_t innermost_linkage_specification_location; | |
418 | ||
a79683d5 | 419 | }; |
f617201f DN |
420 | |
421 | /* In parser.c */ | |
7b3b6ae4 LC |
422 | extern void debug (cp_token &ref); |
423 | extern void debug (cp_token *ptr); | |
9771b263 | 424 | extern void cp_lexer_debug_tokens (vec<cp_token, va_gc> *); |
7b3b6ae4 LC |
425 | extern void debug (vec<cp_token, va_gc> &ref); |
426 | extern void debug (vec<cp_token, va_gc> *ptr); | |
aa6e7237 | 427 | extern void cp_debug_parser (FILE *, cp_parser *); |
7b3b6ae4 LC |
428 | extern void debug (cp_parser &ref); |
429 | extern void debug (cp_parser *ptr); | |
52ed68f7 | 430 | extern bool cp_keyword_starts_decl_specifier_p (enum rid keyword); |
f617201f DN |
431 | |
432 | #endif /* GCC_CP_PARSER_H */ |