gcc/cp/parser.h

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