1 /* Data structures and function exported by the C++ Parser. 2 Copyright (C) 2010-2021 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 /* 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; 116 }; 117 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 125 struct GTY(()) cp_token_cache { 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; 131 }; 132 133 typedef cp_token_cache *cp_token_cache_ptr; 134 135 struct cp_token_ident 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 145 /* An entry in a queue of function arguments that require post-processing. */ 146 147 struct GTY(()) cp_default_arg_entry { 148 /* The current_class_type when we parsed this arg. */ 149 tree class_type; 150 151 /* The function decl itself. */ 152 tree decl; 153 }; 154 155 156 /* An entry in a stack for member functions defined within their classes. */ 157 158 struct GTY(()) cp_unparsed_functions_entry { 159 /* Functions with default arguments that require post-processing. 160 Functions appear in this list in declaration order. */ 161 vec<cp_default_arg_entry, va_gc> *funs_with_default_args; 162 163 /* Functions with defintions that require post-processing. Functions 164 appear in this list in declaration order. */ 165 vec<tree, va_gc> *funs_with_definitions; 166 167 /* Non-static data members with initializers that require post-processing. 168 FIELD_DECLs appear in this list in declaration order. */ 169 vec<tree, va_gc> *nsdmis; 170 171 /* Functions with noexcept-specifiers that require post-processing. */ 172 vec<tree, va_gc> *noexcepts; 173 }; 174 175 176 /* The status of a tentative parse. */ 177 178 enum cp_parser_status_kind 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 187 }; 188 189 190 /* Context that is saved and restored when parsing tentatively. */ 191 struct GTY (()) cp_parser_context { 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; 203 }; 204 205 206 /* Helper data structure for parsing #pragma omp declare {simd,variant}. */ 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. */ 210 bool variant_p; /* Set for #pragma omp declare variant. */ 211 vec<cp_token_cache_ptr> tokens; 212 tree clauses; 213 }; 214 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 }; 219 220 /* The cp_parser structure represents the C++ parser. */ 221 222 struct GTY(()) cp_parser { 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 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; 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 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; 339 340 /* Nonzero if we're processing a __transaction_atomic or 341 __transaction_relaxed statement. */ 342 unsigned char in_transaction; 343 344 /* TRUE if we can auto-correct a colon to a scope operator. */ 345 bool colon_corrects_to_scope_p; 346 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 353 /* TRUE if we are parsing an objective c message, and ':' is permitted 354 to terminate an assignment-expression. */ 355 bool objective_c_message_context_p; 356 357 /* If non-NULL, then we are parsing a construct where new type 358 definitions are not permitted. The string stored here will be 359 issued as an error message if a type is defined. */ 360 const char *type_definition_forbidden_message; 361 362 /* Argument for type_definition_forbidden_message if needed. */ 363 const char *type_definition_forbidden_message_arg; 364 365 /* A stack used for member functions of local classes. The lists 366 contained in an individual entry can only be processed once the 367 outermost class being defined is complete. */ 368 vec<cp_unparsed_functions_entry, va_gc> *unparsed_queues; 369 370 /* The number of classes whose definitions are currently in 371 progress. */ 372 unsigned num_classes_being_defined; 373 374 /* The number of template parameter lists that apply directly to the 375 current declaration. */ 376 unsigned num_template_parameter_lists; 377 378 /* When parsing #pragma omp declare simd, this is a pointer to a 379 helper data structure. */ 380 cp_omp_declare_simd_data * GTY((skip)) omp_declare_simd; 381 382 /* When parsing #pragma acc routine, this is a pointer to a helper data 383 structure. */ 384 cp_oacc_routine_data * GTY((skip)) oacc_routine; 385 386 /* Nonzero if parsing a parameter list where 'auto' should trigger an implicit 387 template parameter. */ 388 bool auto_is_implicit_function_template_parm_p; 389 390 /* TRUE if the function being declared was made a template due to its 391 parameter list containing generic type specifiers (`auto' or concept 392 identifiers) rather than an explicit template parameter list. */ 393 bool fully_implicit_function_template_p; 394 395 /* Tracks the function's template parameter list when declaring a function 396 using generic type parameters. This is either a new chain in the case of a 397 fully implicit function template or an extension of the function's existing 398 template parameter list. This is tracked to optimize calls subsequent 399 calls to synthesize_implicit_template_parm during 400 cp_parser_parameter_declaration. */ 401 tree implicit_template_parms; 402 403 /* The scope into which an implicit template parameter list has been 404 introduced or an existing template parameter list is being extended with 405 implicit template parameters. In most cases this is the sk_function_parms 406 scope containing the use of a generic type. In the case of an out-of-line 407 member definition using a generic type, it is the sk_class scope. */ 408 cp_binding_level* implicit_template_scope; 409 410 /* True if parsing a result type in a compound requirement. This permits 411 constrained-type-specifiers inside what would normally be a trailing 412 return type. */ 413 bool in_result_type_constraint_p; 414 415 /* True if a constrained-type-specifier is not allowed in this 416 context e.g., because they could never be deduced. */ 417 int prevent_constrained_type_specifiers; 418 419 /* Location of the string-literal token within the current linkage 420 specification, if any, or UNKNOWN_LOCATION otherwise. */ 421 location_t innermost_linkage_specification_location; 422 423 }; 424 425 /* In parser.c */ 426 extern void debug (cp_token &ref); 427 extern void debug (cp_token *ptr); 428 extern void cp_lexer_debug_tokens (vec<cp_token, va_gc> *); 429 extern void debug (vec<cp_token, va_gc> &ref); 430 extern void debug (vec<cp_token, va_gc> *ptr); 431 extern void cp_debug_parser (FILE *, cp_parser *); 432 extern void debug (cp_parser &ref); 433 extern void debug (cp_parser *ptr); 434 extern bool cp_keyword_starts_decl_specifier_p (enum rid keyword); 435 436 #endif /* GCC_CP_PARSER_H */ 437