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