gcc/cp/parser.h

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