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 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_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. */ 76 typedef 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 83 struct 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 120 struct 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 128 typedef cp_token_cache *cp_token_cache_ptr; 129 130 struct 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 142 struct 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 153 struct 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 174 enum 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. */ 187 struct 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, and Cilk Plus 203 SIMD-enabled functions' vector attribute. */ 204 struct cp_omp_declare_simd_data { 205 bool error_seen; /* Set if error has been reported. */ 206 bool fndecl_seen; /* Set if one fn decl/definition has been seen already. */ 207 vec<cp_token_cache_ptr> tokens; 208 tree clauses; 209 }; 210 211 /* Helper data structure for parsing #pragma acc routine. */ 212 struct cp_oacc_routine_data : cp_omp_declare_simd_data { 213 location_t loc; 214 }; 215 216 /* The cp_parser structure represents the C++ parser. */ 217 218 struct GTY(()) cp_parser { 219 /* The lexer from which we are obtaining tokens. */ 220 cp_lexer *lexer; 221 222 /* The scope in which names should be looked up. If NULL_TREE, then 223 we look up names in the scope that is currently open in the 224 source program. If non-NULL, this is either a TYPE or 225 NAMESPACE_DECL for the scope in which we should look. It can 226 also be ERROR_MARK, when we've parsed a bogus scope. 227 228 This value is not cleared automatically after a name is looked 229 up, so we must be careful to clear it before starting a new look 230 up sequence. (If it is not cleared, then `X::Y' followed by `Z' 231 will look up `Z' in the scope of `X', rather than the current 232 scope.) Unfortunately, it is difficult to tell when name lookup 233 is complete, because we sometimes peek at a token, look it up, 234 and then decide not to consume it. */ 235 tree scope; 236 237 /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the 238 last lookup took place. OBJECT_SCOPE is used if an expression 239 like "x->y" or "x.y" was used; it gives the type of "*x" or "x", 240 respectively. QUALIFYING_SCOPE is used for an expression of the 241 form "X::Y"; it refers to X. */ 242 tree object_scope; 243 tree qualifying_scope; 244 245 /* A stack of parsing contexts. All but the bottom entry on the 246 stack will be tentative contexts. 247 248 We parse tentatively in order to determine which construct is in 249 use in some situations. For example, in order to determine 250 whether a statement is an expression-statement or a 251 declaration-statement we parse it tentatively as a 252 declaration-statement. If that fails, we then reparse the same 253 token stream as an expression-statement. */ 254 cp_parser_context *context; 255 256 /* True if we are parsing GNU C++. If this flag is not set, then 257 GNU extensions are not recognized. */ 258 bool allow_gnu_extensions_p; 259 260 /* TRUE if the `>' token should be interpreted as the greater-than 261 operator. FALSE if it is the end of a template-id or 262 template-parameter-list. In C++0x mode, this flag also applies to 263 `>>' tokens, which are viewed as two consecutive `>' tokens when 264 this flag is FALSE. */ 265 bool greater_than_is_operator_p; 266 267 /* TRUE if default arguments are allowed within a parameter list 268 that starts at this point. FALSE if only a gnu extension makes 269 them permissible. */ 270 bool default_arg_ok_p; 271 272 /* TRUE if we are parsing an integral constant-expression. See 273 [expr.const] for a precise definition. */ 274 bool integral_constant_expression_p; 275 276 /* TRUE if we are parsing an integral constant-expression -- but a 277 non-constant expression should be permitted as well. This flag 278 is used when parsing an array bound so that GNU variable-length 279 arrays are tolerated. */ 280 bool allow_non_integral_constant_expression_p; 281 282 /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has 283 been seen that makes the expression non-constant. */ 284 bool non_integral_constant_expression_p; 285 286 /* TRUE if local variable names and `this' are forbidden in the 287 current context. */ 288 bool local_variables_forbidden_p; 289 290 /* TRUE if the declaration we are parsing is part of a 291 linkage-specification of the form `extern string-literal 292 declaration'. */ 293 bool in_unbraced_linkage_specification_p; 294 295 /* TRUE if we are presently parsing a declarator, after the 296 direct-declarator. */ 297 bool in_declarator_p; 298 299 /* TRUE if we are presently parsing a template-argument-list. */ 300 bool in_template_argument_list_p; 301 302 /* Set to IN_ITERATION_STMT if parsing an iteration-statement, 303 to IN_OMP_BLOCK if parsing OpenMP structured block and 304 IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement, 305 this is bitwise ORed with IN_SWITCH_STMT, unless parsing an 306 iteration-statement, OpenMP block or loop within that switch. */ 307 #define IN_SWITCH_STMT 1 308 #define IN_ITERATION_STMT 2 309 #define IN_OMP_BLOCK 4 310 #define IN_OMP_FOR 8 311 #define IN_IF_STMT 16 312 #define IN_CILK_SIMD_FOR 32 313 #define IN_CILK_SPAWN 64 314 unsigned char in_statement; 315 316 /* TRUE if we are presently parsing the body of a switch statement. 317 Note that this doesn't quite overlap with in_statement above. 318 The difference relates to giving the right sets of error messages: 319 "case not in switch" vs "break statement used with OpenMP...". */ 320 bool in_switch_statement_p; 321 322 /* TRUE if we are parsing a type-id in an expression context. In 323 such a situation, both "type (expr)" and "type (type)" are valid 324 alternatives. */ 325 bool in_type_id_in_expr_p; 326 327 /* TRUE if we are currently in a header file where declarations are 328 implicitly extern "C". */ 329 bool implicit_extern_c; 330 331 /* TRUE if strings in expressions should be translated to the execution 332 character set. */ 333 bool translate_strings_p; 334 335 /* TRUE if we are presently parsing the body of a function, but not 336 a local class. */ 337 bool in_function_body; 338 339 /* Nonzero if we're processing a __transaction_atomic or 340 __transaction_relaxed statement. */ 341 unsigned char in_transaction; 342 343 /* TRUE if we can auto-correct a colon to a scope operator. */ 344 bool colon_corrects_to_scope_p; 345 346 /* TRUE if : doesn't start a class definition. Should be only used 347 together with type_definition_forbidden_message non-NULL, in 348 contexts where new types may not be defined, and the type list 349 is terminated by colon. */ 350 bool colon_doesnt_start_class_def_p; 351 352 /* If non-NULL, then we are parsing a construct where new type 353 definitions are not permitted. The string stored here will be 354 issued as an error message if a type is defined. */ 355 const char *type_definition_forbidden_message; 356 357 /* A stack used for member functions of local classes. The lists 358 contained in an individual entry can only be processed once the 359 outermost class being defined is complete. */ 360 vec<cp_unparsed_functions_entry, va_gc> *unparsed_queues; 361 362 /* The number of classes whose definitions are currently in 363 progress. */ 364 unsigned num_classes_being_defined; 365 366 /* The number of template parameter lists that apply directly to the 367 current declaration. */ 368 unsigned num_template_parameter_lists; 369 370 /* When parsing #pragma omp declare simd, this is a pointer to a 371 helper data structure. */ 372 cp_omp_declare_simd_data * GTY((skip)) omp_declare_simd; 373 374 /* When parsing Cilk Plus SIMD-enabled functions' vector attributes, 375 this is a pointer to a helper data structure. */ 376 cp_omp_declare_simd_data * GTY((skip)) cilk_simd_fn_info; 377 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; 381 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 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 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 401 implicit template parameters. In most cases this is the sk_function_parms 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 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 415 }; 416 417 /* In parser.c */ 418 extern void debug (cp_token &ref); 419 extern void debug (cp_token *ptr); 420 extern void cp_lexer_debug_tokens (vec<cp_token, va_gc> *); 421 extern void debug (vec<cp_token, va_gc> &ref); 422 extern void debug (vec<cp_token, va_gc> *ptr); 423 extern void cp_debug_parser (FILE *, cp_parser *); 424 extern void debug (cp_parser &ref); 425 extern void debug (cp_parser *ptr); 426 extern bool cp_keyword_starts_decl_specifier_p (enum rid keyword); 427 428 #endif /* GCC_CP_PARSER_H */ 429