gcc/cp/parser.h

   1 /* Data structures and function exported by the C++ Parser.
   2    Copyright (C) 2010-2018 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.  */
 203 struct 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.  */
 211 struct 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
 217 struct 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  */
 415 extern void debug (cp_token &ref);
 416 extern void debug (cp_token *ptr);
 417 extern void cp_lexer_debug_tokens (vec<cp_token, va_gc> *);
 418 extern void debug (vec<cp_token, va_gc> &ref);
 419 extern void debug (vec<cp_token, va_gc> *ptr);
 420 extern void cp_debug_parser (FILE *, cp_parser *);
 421 extern void debug (cp_parser &ref);
 422 extern void debug (cp_parser *ptr);
 423 extern bool cp_keyword_starts_decl_specifier_p (enum rid keyword);
 424
 425 #endif  /* GCC_CP_PARSER_H  */