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