osprey-gcc-4.2.0/gcc/cp/parser.c

Go to the documentation of this file.

/* C++ Parser.
   Copyright (C) 2000, 2001, 2002, 2003, 2004,
   2005  Free Software Foundation, Inc.
   Written by Mark Mitchell <mark@codesourcery.com>.

   This file is part of GCC.

   GCC is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GCC is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GCC; see the file COPYING.  If not, write to the Free
   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "dyn-string.h"
#include "varray.h"
#include "cpplib.h"
#include "tree.h"
#include "cp-tree.h"
#include "c-pragma.h"
#include "decl.h"
#include "flags.h"
#include "diagnostic.h"
#include "toplev.h"
#include "output.h"
#include "target.h"
#include "cgraph.h"
#include "c-common.h"


/* The lexer.  */

/* The cp_lexer_* routines mediate between the lexer proper (in libcpp
   and c-lex.c) and the C++ parser.  */

/* A token's value and its associated deferred access checks and
   qualifying scope.  */

struct tree_check GTY(())
{
  /* The value associated with the token.  */
  tree value;
  /* The checks that have been associated with value.  */
  VEC (deferred_access_check, gc)* checks;
  /* The token's qualifying scope (used when it is a
     CPP_NESTED_NAME_SPECIFIER).  */
  tree qualifying_scope;
};

/* A C++ token.  */

typedef struct cp_token GTY (())
{
  /* The kind of token.  */
  ENUM_BITFIELD (cpp_ttype) type : 8;
  /* If this token is a keyword, this value indicates which keyword.
     Otherwise, this value is RID_MAX.  */
  ENUM_BITFIELD (rid) keyword : 8;
  /* Token flags.  */
  unsigned char flags;
  /* Identifier for the pragma.  */
  ENUM_BITFIELD (pragma_kind) pragma_kind : 6;
  /* True if this token is from a system header.  */
  BOOL_BITFIELD in_system_header : 1;
  /* True if this token is from a context where it is implicitly extern "C" */
  BOOL_BITFIELD implicit_extern_c : 1;
  /* True for a CPP_NAME token that is not a keyword (i.e., for which
     KEYWORD is RID_MAX) iff this name was looked up and found to be
     ambiguous.  An error has already been reported.  */
  BOOL_BITFIELD ambiguous_p : 1;
  /* The input file stack index at which this token was found.  */
  unsigned input_file_stack_index : INPUT_FILE_STACK_BITS;
  /* The value associated with this token, if any.  */
  union cp_token_value {
    /* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID.  */
    struct tree_check* GTY((tag ("1"))) tree_check_value;
    /* Use for all other tokens.  */
    tree GTY((tag ("0"))) value;
  } GTY((desc ("(%1.type == CPP_TEMPLATE_ID) || (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u;
  /* The location at which this token was found.  */
  location_t location;
} cp_token;

/* We use a stack of token pointer for saving token sets.  */
typedef struct cp_token *cp_token_position;
DEF_VEC_P (cp_token_position);
DEF_VEC_ALLOC_P (cp_token_position,heap);

static const cp_token eof_token =
{
  CPP_EOF, RID_MAX, 0, PRAGMA_NONE, 0, 0, false, 0, { NULL },
#if USE_MAPPED_LOCATION
  0
#else
  {0, 0}
#endif
};

/* The cp_lexer structure represents the C++ lexer.  It is responsible
   for managing the token stream from the preprocessor and supplying
   it to the parser.  Tokens are never added to the cp_lexer after
   it is created.  */

typedef struct cp_lexer GTY (())
{
  /* The memory allocated for the buffer.  NULL if this lexer does not
     own the token buffer.  */
  cp_token * GTY ((length ("%h.buffer_length"))) buffer;
  /* If the lexer owns the buffer, this is the number of tokens in the
     buffer.  */
  size_t buffer_length;

  /* A pointer just past the last available token.  The tokens
     in this lexer are [buffer, last_token).  */
  cp_token_position GTY ((skip)) last_token;

  /* The next available token.  If NEXT_TOKEN is &eof_token, then there are
     no more available tokens.  */
  cp_token_position GTY ((skip)) next_token;

  /* A stack indicating positions at which cp_lexer_save_tokens was
     called.  The top entry is the most recent position at which we
     began saving tokens.  If the stack is non-empty, we are saving
     tokens.  */
  VEC(cp_token_position,heap) *GTY ((skip)) saved_tokens;

  /* The next lexer in a linked list of lexers.  */
  struct cp_lexer *next;

  /* True if we should output debugging information.  */
  bool debugging_p;

  /* True if we're in the context of parsing a pragma, and should not
     increment past the end-of-line marker.  */
  bool in_pragma;
} cp_lexer;

/* cp_token_cache is a range of tokens.  There is no need to represent
   allocate heap memory for it, since tokens are never removed from the
   lexer's array.  There is also no need for the GC to walk through
   a cp_token_cache, since everything in here is referenced through
   a lexer.  */

typedef struct cp_token_cache GTY(())
{
  /* The beginning of the token range.  */
  cp_token * GTY((skip)) first;

  /* Points immediately after the last token in the range.  */
  cp_token * GTY ((skip)) last;
} cp_token_cache;

/* Prototypes.  */

static cp_lexer *cp_lexer_new_main
  (void);
static cp_lexer *cp_lexer_new_from_tokens
  (cp_token_cache *tokens);
static void cp_lexer_destroy
  (cp_lexer *);
static int cp_lexer_saving_tokens
  (const cp_lexer *);
static cp_token_position cp_lexer_token_position
  (cp_lexer *, bool);
static cp_token *cp_lexer_token_at
  (cp_lexer *, cp_token_position);
static void cp_lexer_get_preprocessor_token
  (cp_lexer *, cp_token *);
static inline cp_token *cp_lexer_peek_token
  (cp_lexer *);
static cp_token *cp_lexer_peek_nth_token
  (cp_lexer *, size_t);
static inline bool cp_lexer_next_token_is
  (cp_lexer *, enum cpp_ttype);
static bool cp_lexer_next_token_is_not
  (cp_lexer *, enum cpp_ttype);
static bool cp_lexer_next_token_is_keyword
  (cp_lexer *, enum rid);
static cp_token *cp_lexer_consume_token
  (cp_lexer *);
static void cp_lexer_purge_token
  (cp_lexer *);
static void cp_lexer_purge_tokens_after
  (cp_lexer *, cp_token_position);
static void cp_lexer_save_tokens
  (cp_lexer *);
static void cp_lexer_commit_tokens
  (cp_lexer *);
static void cp_lexer_rollback_tokens
  (cp_lexer *);
#ifdef ENABLE_CHECKING
static void cp_lexer_print_token
  (FILE *, cp_token *);
static inline bool cp_lexer_debugging_p
  (cp_lexer *);
static void cp_lexer_start_debugging
  (cp_lexer *) ATTRIBUTE_UNUSED;
static void cp_lexer_stop_debugging
  (cp_lexer *) ATTRIBUTE_UNUSED;
#else
/* If we define cp_lexer_debug_stream to NULL it will provoke warnings
   about passing NULL to functions that require non-NULL arguments
   (fputs, fprintf).  It will never be used, so all we need is a value
   of the right type that's guaranteed not to be NULL.  */
#define cp_lexer_debug_stream stdout
#define cp_lexer_print_token(str, tok) (void) 0
#define cp_lexer_debugging_p(lexer) 0
#endif /* ENABLE_CHECKING */

static cp_token_cache *cp_token_cache_new
  (cp_token *, cp_token *);

static void cp_parser_initial_pragma
  (cp_token *);

/* Manifest constants.  */
#define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
#define CP_SAVED_TOKEN_STACK 5

/* A token type for keywords, as opposed to ordinary identifiers.  */
#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))

/* A token type for template-ids.  If a template-id is processed while
   parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
   the value of the CPP_TEMPLATE_ID is whatever was returned by
   cp_parser_template_id.  */
#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))

/* A token type for nested-name-specifiers.  If a
   nested-name-specifier is processed while parsing tentatively, it is
   replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
   CPP_NESTED_NAME_SPECIFIER is whatever was returned by
   cp_parser_nested_name_specifier_opt.  */
#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))

/* A token type for tokens that are not tokens at all; these are used
   to represent slots in the array where there used to be a token
   that has now been deleted.  */
#define CPP_PURGED ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))

/* The number of token types, including C++-specific ones.  */
#define N_CP_TTYPES ((int) (CPP_PURGED + 1))

/* Variables.  */

#ifdef ENABLE_CHECKING
/* The stream to which debugging output should be written.  */
static FILE *cp_lexer_debug_stream;
#endif /* ENABLE_CHECKING */

/* Create a new main C++ lexer, the lexer that gets tokens from the
   preprocessor.  */

static cp_lexer *
cp_lexer_new_main (void)
{
  cp_token first_token;
  cp_lexer *lexer;
  cp_token *pos;
  size_t alloc;
  size_t space;
  cp_token *buffer;

  /* It's possible that parsing the first pragma will load a PCH file,
     which is a GC collection point.  So we have to do that before
     allocating any memory.  */
  cp_parser_initial_pragma (&first_token);

  /* Tell c_lex_with_flags not to merge string constants.  */
  c_lex_return_raw_strings = true;

  c_common_no_more_pch ();

  /* Allocate the memory.  */
  lexer = GGC_CNEW (cp_lexer);

#ifdef ENABLE_CHECKING
  /* Initially we are not debugging.  */
  lexer->debugging_p = false;
#endif /* ENABLE_CHECKING */
  lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
           CP_SAVED_TOKEN_STACK);

  /* Create the buffer.  */
  alloc = CP_LEXER_BUFFER_SIZE;
  buffer = GGC_NEWVEC (cp_token, alloc);

  /* Put the first token in the buffer.  */
  space = alloc;
  pos = buffer;
  *pos = first_token;

  /* Get the remaining tokens from the preprocessor.  */
  while (pos->type != CPP_EOF)
    {
      pos++;
      if (!--space)
  {
    space = alloc;
    alloc *= 2;
    buffer = GGC_RESIZEVEC (cp_token, buffer, alloc);
    pos = buffer + space;
  }
      cp_lexer_get_preprocessor_token (lexer, pos);
    }
  lexer->buffer = buffer;
  lexer->buffer_length = alloc - space;
  lexer->last_token = pos;
  lexer->next_token = lexer->buffer_length ? buffer : (cp_token *)&eof_token;

  /* Subsequent preprocessor diagnostics should use compiler
     diagnostic functions to get the compiler source location.  */
  cpp_get_options (parse_in)->client_diagnostic = true;
  cpp_get_callbacks (parse_in)->error = cp_cpp_error;

  gcc_assert (lexer->next_token->type != CPP_PURGED);
  return lexer;
}

/* Create a new lexer whose token stream is primed with the tokens in
   CACHE.  When these tokens are exhausted, no new tokens will be read.  */

static cp_lexer *
cp_lexer_new_from_tokens (cp_token_cache *cache)
{
  cp_token *first = cache->first;
  cp_token *last = cache->last;
  cp_lexer *lexer = GGC_CNEW (cp_lexer);

  /* We do not own the buffer.  */
  lexer->buffer = NULL;
  lexer->buffer_length = 0;
  lexer->next_token = first == last ? (cp_token *)&eof_token : first;
  lexer->last_token = last;

  lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
           CP_SAVED_TOKEN_STACK);

#ifdef ENABLE_CHECKING
  /* Initially we are not debugging.  */
  lexer->debugging_p = false;
#endif

  gcc_assert (lexer->next_token->type != CPP_PURGED);
  return lexer;
}

/* Frees all resources associated with LEXER.  */

static void
cp_lexer_destroy (cp_lexer *lexer)
{
  if (lexer->buffer)
    ggc_free (lexer->buffer);
  VEC_free (cp_token_position, heap, lexer->saved_tokens);
  ggc_free (lexer);
}

/* Returns nonzero if debugging information should be output.  */

#ifdef ENABLE_CHECKING

static inline bool
cp_lexer_debugging_p (cp_lexer *lexer)
{
  return lexer->debugging_p;
}

#endif /* ENABLE_CHECKING */

static inline cp_token_position
cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
{
  gcc_assert (!previous_p || lexer->next_token != &eof_token);

  return lexer->next_token - previous_p;
}

static inline cp_token *
cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos)
{
  return pos;
}

/* nonzero if we are presently saving tokens.  */

static inline int
cp_lexer_saving_tokens (const cp_lexer* lexer)
{
  return VEC_length (cp_token_position, lexer->saved_tokens) != 0;
}

/* Store the next token from the preprocessor in *TOKEN.  Return true
   if we reach EOF.  */

static void
cp_lexer_get_preprocessor_token (cp_lexer *lexer ATTRIBUTE_UNUSED ,
         cp_token *token)
{
  static int is_extern_c = 0;

   /* Get a new token from the preprocessor.  */
  token->type
    = c_lex_with_flags (&token->u.value, &token->location, &token->flags);
  token->input_file_stack_index = input_file_stack_tick;
  token->keyword = RID_MAX;
  token->pragma_kind = PRAGMA_NONE;
  token->in_system_header = in_system_header;

  /* On some systems, some header files are surrounded by an
     implicit extern "C" block.  Set a flag in the token if it
     comes from such a header.  */
  is_extern_c += pending_lang_change;
  pending_lang_change = 0;
  token->implicit_extern_c = is_extern_c > 0;

  /* Check to see if this token is a keyword.  */
  if (token->type == CPP_NAME)
    {
      if (C_IS_RESERVED_WORD (token->u.value))
  {
    /* Mark this token as a keyword.  */
    token->type = CPP_KEYWORD;
    /* Record which keyword.  */
    token->keyword = C_RID_CODE (token->u.value);
    /* Update the value.  Some keywords are mapped to particular
       entities, rather than simply having the value of the
       corresponding IDENTIFIER_NODE.  For example, `__const' is
       mapped to `const'.  */
    token->u.value = ridpointers[token->keyword];
  }
      else
  {
    token->ambiguous_p = false;
    token->keyword = RID_MAX;
  }
    }
  /* Handle Objective-C++ keywords.  */
  else if (token->type == CPP_AT_NAME)
    {
      token->type = CPP_KEYWORD;
      switch (C_RID_CODE (token->u.value))
  {
  /* Map 'class' to '@class', 'private' to '@private', etc.  */
  case RID_CLASS: token->keyword = RID_AT_CLASS; break;
  case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
  case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
  case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
  case RID_THROW: token->keyword = RID_AT_THROW; break;
  case RID_TRY: token->keyword = RID_AT_TRY; break;
  case RID_CATCH: token->keyword = RID_AT_CATCH; break;
  default: token->keyword = C_RID_CODE (token->u.value);
  }
    }
  else if (token->type == CPP_PRAGMA)
    {
      /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
      token->pragma_kind = TREE_INT_CST_LOW (token->u.value);
      token->u.value = NULL_TREE;
    }
}

/* Update the globals input_location and in_system_header and the
   input file stack from TOKEN.  */
static inline void
cp_lexer_set_source_position_from_token (cp_token *token)
{
  if (token->type != CPP_EOF)
    {
      input_location = token->location;
      in_system_header = token->in_system_header;
      restore_input_file_stack (token->input_file_stack_index);
    }
}

/* Return a pointer to the next token in the token stream, but do not
   consume it.  */

static inline cp_token *
cp_lexer_peek_token (cp_lexer *lexer)
{
  if (cp_lexer_debugging_p (lexer))
    {
      fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
      cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
      putc ('\n', cp_lexer_debug_stream);
    }
  return lexer->next_token;
}

/* Return true if the next token has the indicated TYPE.  */

static inline bool
cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
{
  return cp_lexer_peek_token (lexer)->type == type;
}

/* Return true if the next token does not have the indicated TYPE.  */

static inline bool
cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
{
  return !cp_lexer_next_token_is (lexer, type);
}

/* Return true if the next token is the indicated KEYWORD.  */

static inline bool
cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
{
  return cp_lexer_peek_token (lexer)->keyword == keyword;
}

/* Return true if the next token is a keyword for a decl-specifier.  */

static bool
cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
{
  cp_token *token;

  token = cp_lexer_peek_token (lexer);
  switch (token->keyword) 
    {
      /* Storage classes.  */
    case RID_AUTO:
    case RID_REGISTER:
    case RID_STATIC:
    case RID_EXTERN:
    case RID_MUTABLE:
    case RID_THREAD:
      /* Elaborated type specifiers.  */
    case RID_ENUM:
    case RID_CLASS:
    case RID_STRUCT:
    case RID_UNION:
    case RID_TYPENAME:
      /* Simple type specifiers.  */
    case RID_CHAR:
    case RID_WCHAR:
    case RID_BOOL:
    case RID_SHORT:
    case RID_INT:
    case RID_LONG:
    case RID_SIGNED:
    case RID_UNSIGNED:
    case RID_FLOAT:
    case RID_DOUBLE:
    case RID_VOID:
      /* GNU extensions.  */ 
    case RID_ATTRIBUTE:
    case RID_TYPEOF:
      return true;

    default:
      return false;
    }
}

/* Return a pointer to the Nth token in the token stream.  If N is 1,
   then this is precisely equivalent to cp_lexer_peek_token (except
   that it is not inline).  One would like to disallow that case, but
   there is one case (cp_parser_nth_token_starts_template_id) where
   the caller passes a variable for N and it might be 1.  */

static cp_token *
cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
{
  cp_token *token;

  /* N is 1-based, not zero-based.  */
  gcc_assert (n > 0);

  if (cp_lexer_debugging_p (lexer))
    fprintf (cp_lexer_debug_stream,
       "cp_lexer: peeking ahead %ld at token: ", (long)n);

  --n;
  token = lexer->next_token;
  gcc_assert (!n || token != &eof_token);
  while (n != 0)
    {
      ++token;
      if (token == lexer->last_token)
  {
    token = (cp_token *)&eof_token;
    break;
  }

      if (token->type != CPP_PURGED)
  --n;
    }

  if (cp_lexer_debugging_p (lexer))
    {
      cp_lexer_print_token (cp_lexer_debug_stream, token);
      putc ('\n', cp_lexer_debug_stream);
    }

  return token;
}

/* Return the next token, and advance the lexer's next_token pointer
   to point to the next non-purged token.  */

static cp_token *
cp_lexer_consume_token (cp_lexer* lexer)
{
  cp_token *token = lexer->next_token;

  gcc_assert (token != &eof_token);
  gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);

  do
    {
      lexer->next_token++;
      if (lexer->next_token == lexer->last_token)
  {
    lexer->next_token = (cp_token *)&eof_token;
    break;
  }

    }
  while (lexer->next_token->type == CPP_PURGED);

  cp_lexer_set_source_position_from_token (token);

  /* Provide debugging output.  */
  if (cp_lexer_debugging_p (lexer))
    {
      fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
      cp_lexer_print_token (cp_lexer_debug_stream, token);
      putc ('\n', cp_lexer_debug_stream);
    }

  return token;
}

/* Permanently remove the next token from the token stream, and
   advance the next_token pointer to refer to the next non-purged
   token.  */

static void
cp_lexer_purge_token (cp_lexer *lexer)
{
  cp_token *tok = lexer->next_token;

  gcc_assert (tok != &eof_token);
  tok->type = CPP_PURGED;
  tok->location = UNKNOWN_LOCATION;
  tok->u.value = NULL_TREE;
  tok->keyword = RID_MAX;

  do
    {
      tok++;
      if (tok == lexer->last_token)
  {
    tok = (cp_token *)&eof_token;
    break;
  }
    }
  while (tok->type == CPP_PURGED);
  lexer->next_token = tok;
}

/* Permanently remove all tokens after TOK, up to, but not
   including, the token that will be returned next by
   cp_lexer_peek_token.  */

static void
cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
{
  cp_token *peek = lexer->next_token;

  if (peek == &eof_token)
    peek = lexer->last_token;

  gcc_assert (tok < peek);

  for ( tok += 1; tok != peek; tok += 1)
    {
      tok->type = CPP_PURGED;
      tok->location = UNKNOWN_LOCATION;
      tok->u.value = NULL_TREE;
      tok->keyword = RID_MAX;
    }
}

/* Begin saving tokens.  All tokens consumed after this point will be
   preserved.  */

static void
cp_lexer_save_tokens (cp_lexer* lexer)
{
  /* Provide debugging output.  */
  if (cp_lexer_debugging_p (lexer))
    fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");

  VEC_safe_push (cp_token_position, heap,
     lexer->saved_tokens, lexer->next_token);
}

/* Commit to the portion of the token stream most recently saved.  */

static void
cp_lexer_commit_tokens (cp_lexer* lexer)
{
  /* Provide debugging output.  */
  if (cp_lexer_debugging_p (lexer))
    fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");

  VEC_pop (cp_token_position, lexer->saved_tokens);
}

/* Return all tokens saved since the last call to cp_lexer_save_tokens
   to the token stream.  Stop saving tokens.  */

static void
cp_lexer_rollback_tokens (cp_lexer* lexer)
{
  /* Provide debugging output.  */
  if (cp_lexer_debugging_p (lexer))
    fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");

  lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
}

/* Print a representation of the TOKEN on the STREAM.  */

#ifdef ENABLE_CHECKING

static void
cp_lexer_print_token (FILE * stream, cp_token *token)
{
  /* We don't use cpp_type2name here because the parser defines
     a few tokens of its own.  */
  static const char *const token_names[] = {
    /* cpplib-defined token types */
#define OP(e, s) #e,
#define TK(e, s) #e,
    TTYPE_TABLE
#undef OP
#undef TK
    /* C++ parser token types - see "Manifest constants", above.  */
    "KEYWORD",
    "TEMPLATE_ID",
    "NESTED_NAME_SPECIFIER",
    "PURGED"
  };

  /* If we have a name for the token, print it out.  Otherwise, we
     simply give the numeric code.  */
  gcc_assert (token->type < ARRAY_SIZE(token_names));
  fputs (token_names[token->type], stream);

  /* For some tokens, print the associated data.  */
  switch (token->type)
    {
    case CPP_KEYWORD:
      /* Some keywords have a value that is not an IDENTIFIER_NODE.
   For example, `struct' is mapped to an INTEGER_CST.  */
      if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
  break;
      /* else fall through */
    case CPP_NAME:
      fputs (IDENTIFIER_POINTER (token->u.value), stream);
      break;

    case CPP_STRING:
    case CPP_WSTRING:
      fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
      break;

    default:
      break;
    }
}

/* Start emitting debugging information.  */

static void
cp_lexer_start_debugging (cp_lexer* lexer)
{
  lexer->debugging_p = true;
}

/* Stop emitting debugging information.  */

static void
cp_lexer_stop_debugging (cp_lexer* lexer)
{
  lexer->debugging_p = false;
}

#endif /* ENABLE_CHECKING */

/* Create a new cp_token_cache, representing a range of tokens.  */

static cp_token_cache *
cp_token_cache_new (cp_token *first, cp_token *last)
{
  cp_token_cache *cache = GGC_NEW (cp_token_cache);
  cache->first = first;
  cache->last = last;
  return cache;
}


/* Decl-specifiers.  */

/* Set *DECL_SPECS to represent an empty decl-specifier-seq.  */

static void
clear_decl_specs (cp_decl_specifier_seq *decl_specs)
{
  memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
}

/* Declarators.  */

/* Nothing other than the parser should be creating declarators;
   declarators are a semi-syntactic representation of C++ entities.
   Other parts of the front end that need to create entities (like
   VAR_DECLs or FUNCTION_DECLs) should do that directly.  */

static cp_declarator *make_call_declarator
  (cp_declarator *, cp_parameter_declarator *, cp_cv_quals, tree);
static cp_declarator *make_array_declarator
  (cp_declarator *, tree);
static cp_declarator *make_pointer_declarator
  (cp_cv_quals, cp_declarator *);
static cp_declarator *make_reference_declarator
  (cp_cv_quals, cp_declarator *);
static cp_parameter_declarator *make_parameter_declarator
  (cp_decl_specifier_seq *, cp_declarator *, tree);
static cp_declarator *make_ptrmem_declarator
  (cp_cv_quals, tree, cp_declarator *);

/* An erroneous declarator.  */
static cp_declarator *cp_error_declarator;

/* The obstack on which declarators and related data structures are
   allocated.  */
static struct obstack declarator_obstack;

/* Alloc BYTES from the declarator memory pool.  */

static inline void *
alloc_declarator (size_t bytes)
{
  return obstack_alloc (&declarator_obstack, bytes);
}

/* Allocate a declarator of the indicated KIND.  Clear fields that are
   common to all declarators.  */

static cp_declarator *
make_declarator (cp_declarator_kind kind)
{
  cp_declarator *declarator;

  declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
  declarator->kind = kind;
  declarator->attributes = NULL_TREE;
  declarator->declarator = NULL;

  return declarator;
}

/* Make a declarator for a generalized identifier.  If
   QUALIFYING_SCOPE is non-NULL, the identifier is
   QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
   UNQUALIFIED_NAME.  SFK indicates the kind of special function this
   is, if any.   */

static cp_declarator *
make_id_declarator (tree qualifying_scope, tree unqualified_name,
        special_function_kind sfk)
{
  cp_declarator *declarator;

  /* It is valid to write:

       class C { void f(); };
       typedef C D;
       void D::f();

     The standard is not clear about whether `typedef const C D' is
     legal; as of 2002-09-15 the committee is considering that
     question.  EDG 3.0 allows that syntax.  Therefore, we do as
     well.  */
  if (qualifying_scope && TYPE_P (qualifying_scope))
    qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);

  gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
        || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
        || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);

  declarator = make_declarator (cdk_id);
  declarator->u.id.qualifying_scope = qualifying_scope;
  declarator->u.id.unqualified_name = unqualified_name;
  declarator->u.id.sfk = sfk;

  return declarator;
}

/* Make a declarator for a pointer to TARGET.  CV_QUALIFIERS is a list
   of modifiers such as const or volatile to apply to the pointer
   type, represented as identifiers.  */

cp_declarator *
make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
{
  cp_declarator *declarator;

  declarator = make_declarator (cdk_pointer);
  declarator->declarator = target;
  declarator->u.pointer.qualifiers = cv_qualifiers;
  declarator->u.pointer.class_type = NULL_TREE;

  return declarator;
}

/* Like make_pointer_declarator -- but for references.  */

cp_declarator *
make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
{
  cp_declarator *declarator;

  declarator = make_declarator (cdk_reference);
  declarator->declarator = target;
  declarator->u.pointer.qualifiers = cv_qualifiers;
  declarator->u.pointer.class_type = NULL_TREE;

  return declarator;
}

/* Like make_pointer_declarator -- but for a pointer to a non-static
   member of CLASS_TYPE.  */

cp_declarator *
make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
      cp_declarator *pointee)
{
  cp_declarator *declarator;

  declarator = make_declarator (cdk_ptrmem);
  declarator->declarator = pointee;
  declarator->u.pointer.qualifiers = cv_qualifiers;
  declarator->u.pointer.class_type = class_type;

  return declarator;
}

/* Make a declarator for the function given by TARGET, with the
   indicated PARMS.  The CV_QUALIFIERS aply to the function, as in
   "const"-qualified member function.  The EXCEPTION_SPECIFICATION
   indicates what exceptions can be thrown.  */

cp_declarator *
make_call_declarator (cp_declarator *target,
          cp_parameter_declarator *parms,
          cp_cv_quals cv_qualifiers,
          tree exception_specification)
{
  cp_declarator *declarator;

  declarator = make_declarator (cdk_function);
  declarator->declarator = target;
  declarator->u.function.parameters = parms;
  declarator->u.function.qualifiers = cv_qualifiers;
  declarator->u.function.exception_specification = exception_specification;

  return declarator;
}

/* Make a declarator for an array of BOUNDS elements, each of which is
   defined by ELEMENT.  */

cp_declarator *
make_array_declarator (cp_declarator *element, tree bounds)
{
  cp_declarator *declarator;

  declarator = make_declarator (cdk_array);
  declarator->declarator = element;
  declarator->u.array.bounds = bounds;

  return declarator;
}

cp_parameter_declarator *no_parameters;

/* Create a parameter declarator with the indicated DECL_SPECIFIERS,
   DECLARATOR and DEFAULT_ARGUMENT.  */

cp_parameter_declarator *
make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
         cp_declarator *declarator,
         tree default_argument)
{
  cp_parameter_declarator *parameter;

  parameter = ((cp_parameter_declarator *)
         alloc_declarator (sizeof (cp_parameter_declarator)));
  parameter->next = NULL;
  if (decl_specifiers)
    parameter->decl_specifiers = *decl_specifiers;
  else
    clear_decl_specs (&parameter->decl_specifiers);
  parameter->declarator = declarator;
  parameter->default_argument = default_argument;
  parameter->ellipsis_p = false;

  return parameter;
}

/* Returns true iff DECLARATOR  is a declaration for a function.  */

static bool
function_declarator_p (const cp_declarator *declarator)
{
  while (declarator)
    {
      if (declarator->kind == cdk_function
    && declarator->declarator->kind == cdk_id)
  return true;
      if (declarator->kind == cdk_id
    || declarator->kind == cdk_error)
  return false;
      declarator = declarator->declarator;
    }
  return false;
}
 
/* The parser.  */

/* Overview
   --------

   A cp_parser parses the token stream as specified by the C++
   grammar.  Its job is purely parsing, not semantic analysis.  For
   example, the parser breaks the token stream into declarators,
   expressions, statements, and other similar syntactic constructs.
   It does not check that the types of the expressions on either side
   of an assignment-statement are compatible, or that a function is
   not declared with a parameter of type `void'.

   The parser invokes routines elsewhere in the compiler to perform
   semantic analysis and to build up the abstract syntax tree for the
   code processed.

   The parser (and the template instantiation code, which is, in a
   way, a close relative of parsing) are the only parts of the
   compiler that should be calling push_scope and pop_scope, or
   related functions.  The parser (and template instantiation code)
   keeps track of what scope is presently active; everything else
   should simply honor that.  (The code that generates static
   initializers may also need to set the scope, in order to check
   access control correctly when emitting the initializers.)

   Methodology
   -----------

   The parser is of the standard recursive-descent variety.  Upcoming
   tokens in the token stream are examined in order to determine which
   production to use when parsing a non-terminal.  Some C++ constructs
   require arbitrary look ahead to disambiguate.  For example, it is
   impossible, in the general case, to tell whether a statement is an
   expression or declaration without scanning the entire statement.
   Therefore, the parser is capable of "parsing tentatively."  When the
   parser is not sure what construct comes next, it enters this mode.
   Then, while we attempt to parse the construct, the parser queues up
   error messages, rather than issuing them immediately, and saves the
   tokens it consumes.  If the construct is parsed successfully, the
   parser "commits", i.e., it issues any queued error messages and
   the tokens that were being preserved are permanently discarded.
   If, however, the construct is not parsed successfully, the parser
   rolls back its state completely so that it can resume parsing using
   a different alternative.

   Future Improvements
   -------------------

   The performance of the parser could probably be improved substantially.
   We could often eliminate the need to parse tentatively by looking ahead
   a little bit.  In some places, this approach might not entirely eliminate
   the need to parse tentatively, but it might still speed up the average
   case.  */

/* Flags that are passed to some parsing functions.  These values can
   be bitwise-ored together.  */

typedef enum cp_parser_flags
{
  /* No flags.  */
  CP_PARSER_FLAGS_NONE = 0x0,
  /* The construct is optional.  If it is not present, then no error
     should be issued.  */
  CP_PARSER_FLAGS_OPTIONAL = 0x1,
  /* When parsing a type-specifier, do not allow user-defined types.  */
  CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2
} cp_parser_flags;

/* The different kinds of declarators we want to parse.  */

typedef enum cp_parser_declarator_kind
{
  /* We want an abstract declarator.  */
  CP_PARSER_DECLARATOR_ABSTRACT,
  /* We want a named declarator.  */
  CP_PARSER_DECLARATOR_NAMED,
  /* We don't mind, but the name must be an unqualified-id.  */
  CP_PARSER_DECLARATOR_EITHER
} cp_parser_declarator_kind;

/* The precedence values used to parse binary expressions.  The minimum value
   of PREC must be 1, because zero is reserved to quickly discriminate
   binary operators from other tokens.  */

enum cp_parser_prec
{
  PREC_NOT_OPERATOR,
  PREC_LOGICAL_OR_EXPRESSION,
  PREC_LOGICAL_AND_EXPRESSION,
  PREC_INCLUSIVE_OR_EXPRESSION,
  PREC_EXCLUSIVE_OR_EXPRESSION,
  PREC_AND_EXPRESSION,
  PREC_EQUALITY_EXPRESSION,
  PREC_RELATIONAL_EXPRESSION,
  PREC_SHIFT_EXPRESSION,
  PREC_ADDITIVE_EXPRESSION,
  PREC_MULTIPLICATIVE_EXPRESSION,
  PREC_PM_EXPRESSION,
  NUM_PREC_VALUES = PREC_PM_EXPRESSION
};

/* A mapping from a token type to a corresponding tree node type, with a
   precedence value.  */

typedef struct cp_parser_binary_operations_map_node
{
  /* The token type.  */
  enum cpp_ttype token_type;
  /* The corresponding tree code.  */
  enum tree_code tree_type;
  /* The precedence of this operator.  */
  enum cp_parser_prec prec;
} cp_parser_binary_operations_map_node;

/* The status of a tentative parse.  */

typedef enum cp_parser_status_kind
{
  /* No errors have occurred.  */
  CP_PARSER_STATUS_KIND_NO_ERROR,
  /* An error has occurred.  */
  CP_PARSER_STATUS_KIND_ERROR,
  /* We are committed to this tentative parse, whether or not an error
     has occurred.  */
  CP_PARSER_STATUS_KIND_COMMITTED
} cp_parser_status_kind;

typedef struct cp_parser_expression_stack_entry
{
  tree lhs;
  enum tree_code tree_type;
  int prec;
} cp_parser_expression_stack_entry;

/* The stack for storing partial expressions.  We only need NUM_PREC_VALUES
   entries because precedence levels on the stack are monotonically
   increasing.  */
typedef struct cp_parser_expression_stack_entry
  cp_parser_expression_stack[NUM_PREC_VALUES];

/* Context that is saved and restored when parsing tentatively.  */
typedef struct cp_parser_context GTY (())
{
  /* If this is a tentative parsing context, the status of the
     tentative parse.  */
  enum cp_parser_status_kind status;
  /* If non-NULL, we have just seen a `x->' or `x.' expression.  Names
     that are looked up in this context must be looked up both in the
     scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
     the context of the containing expression.  */
  tree object_type;

  /* The next parsing context in the stack.  */
  struct cp_parser_context *next;
} cp_parser_context;

/* Prototypes.  */

/* Constructors and destructors.  */

static cp_parser_context *cp_parser_context_new
  (cp_parser_context *);

/* Class variables.  */

static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;

/* The operator-precedence table used by cp_parser_binary_expression.
   Transformed into an associative array (binops_by_token) by
   cp_parser_new.  */

static const cp_parser_binary_operations_map_node binops[] = {
  { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
  { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },

  { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
  { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
  { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },

  { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
  { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },

  { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
  { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },

  { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
  { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
  { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
  { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },

  { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
  { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },

  { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },

  { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },

  { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },

  { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },

  { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
};

/* The same as binops, but initialized by cp_parser_new so that
   binops_by_token[N].token_type == N.  Used in cp_parser_binary_expression
   for speed.  */
static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];

/* Constructors and destructors.  */

/* Construct a new context.  The context below this one on the stack
   is given by NEXT.  */

static cp_parser_context *
cp_parser_context_new (cp_parser_context* next)
{
  cp_parser_context *context;

  /* Allocate the storage.  */
  if (cp_parser_context_free_list != NULL)
    {
      /* Pull the first entry from the free list.  */
      context = cp_parser_context_free_list;
      cp_parser_context_free_list = context->next;
      memset (context, 0, sizeof (*context));
    }
  else
    context = GGC_CNEW (cp_parser_context);

  /* No errors have occurred yet in this context.  */
  context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
  /* If this is not the bottomost context, copy information that we
     need from the previous context.  */
  if (next)
    {
      /* If, in the NEXT context, we are parsing an `x->' or `x.'
   expression, then we are parsing one in this context, too.  */
      context->object_type = next->object_type;
      /* Thread the stack.  */
      context->next = next;
    }

  return context;
}

/* The cp_parser structure represents the C++ parser.  */

typedef struct cp_parser GTY(())
{
  /* The lexer from which we are obtaining tokens.  */
  cp_lexer *lexer;

  /* The scope in which names should be looked up.  If NULL_TREE, then
     we look up names in the scope that is currently open in the
     source program.  If non-NULL, this is either a TYPE or
     NAMESPACE_DECL for the scope in which we should look.  It can
     also be ERROR_MARK, when we've parsed a bogus scope.

     This value is not cleared automatically after a name is looked
     up, so we must be careful to clear it before starting a new look
     up sequence.  (If it is not cleared, then `X::Y' followed by `Z'
     will look up `Z' in the scope of `X', rather than the current
     scope.)  Unfortunately, it is difficult to tell when name lookup
     is complete, because we sometimes peek at a token, look it up,
     and then decide not to consume it.   */
  tree scope;

  /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
     last lookup took place.  OBJECT_SCOPE is used if an expression
     like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
     respectively.  QUALIFYING_SCOPE is used for an expression of the
     form "X::Y"; it refers to X.  */
  tree object_scope;
  tree qualifying_scope;

  /* A stack of parsing contexts.  All but the bottom entry on the
     stack will be tentative contexts.

     We parse tentatively in order to determine which construct is in
     use in some situations.  For example, in order to determine
     whether a statement is an expression-statement or a
     declaration-statement we parse it tentatively as a
     declaration-statement.  If that fails, we then reparse the same
     token stream as an expression-statement.  */
  cp_parser_context *context;

  /* True if we are parsing GNU C++.  If this flag is not set, then
     GNU extensions are not recognized.  */
  bool allow_gnu_extensions_p;

  /* TRUE if the `>' token should be interpreted as the greater-than
     operator.  FALSE if it is the end of a template-id or
     template-parameter-list.  */
  bool greater_than_is_operator_p;

  /* TRUE if default arguments are allowed within a parameter list
     that starts at this point. FALSE if only a gnu extension makes
     them permissible.  */
  bool default_arg_ok_p;

  /* TRUE if we are parsing an integral constant-expression.  See
     [expr.const] for a precise definition.  */
  bool integral_constant_expression_p;

  /* TRUE if we are parsing an integral constant-expression -- but a
     non-constant expression should be permitted as well.  This flag
     is used when parsing an array bound so that GNU variable-length
     arrays are tolerated.  */
  bool allow_non_integral_constant_expression_p;

  /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
     been seen that makes the expression non-constant.  */
  bool non_integral_constant_expression_p;

  /* TRUE if local variable names and `this' are forbidden in the
     current context.  */
  bool local_variables_forbidden_p;

  /* TRUE if the declaration we are parsing is part of a
     linkage-specification of the form `extern string-literal
     declaration'.  */
  bool in_unbraced_linkage_specification_p;

  /* TRUE if we are presently parsing a declarator, after the
     direct-declarator.  */
  bool in_declarator_p;

  /* TRUE if we are presently parsing a template-argument-list.  */
  bool in_template_argument_list_p;

  /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
     to IN_OMP_BLOCK if parsing OpenMP structured block and
     IN_OMP_FOR if parsing OpenMP loop.  If parsing a switch statement,
     this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
     iteration-statement, OpenMP block or loop within that switch.  */
#define IN_SWITCH_STMT    1
#define IN_ITERATION_STMT 2
#define IN_OMP_BLOCK    4
#define IN_OMP_FOR    8
  unsigned char in_statement;

  /* TRUE if we are presently parsing the body of a switch statement.
     Note that this doesn't quite overlap with in_statement above.
     The difference relates to giving the right sets of error messages:
     "case not in switch" vs "break statement used with OpenMP...".  */
  bool in_switch_statement_p;

  /* TRUE if we are parsing a type-id in an expression context.  In
     such a situation, both "type (expr)" and "type (type)" are valid
     alternatives.  */
  bool in_type_id_in_expr_p;

  /* TRUE if we are currently in a header file where declarations are
     implicitly extern "C".  */
  bool implicit_extern_c;

  /* TRUE if strings in expressions should be translated to the execution
     character set.  */
  bool translate_strings_p;

  /* TRUE if we are presently parsing the body of a function, but not
     a local class.  */
  bool in_function_body;

  /* If non-NULL, then we are parsing a construct where new type
     definitions are not permitted.  The string stored here will be
     issued as an error message if a type is defined.  */
  const char *type_definition_forbidden_message;

  /* A list of lists. The outer list is a stack, used for member
     functions of local classes. At each level there are two sub-list,
     one on TREE_VALUE and one on TREE_PURPOSE. Each of those
     sub-lists has a FUNCTION_DECL or TEMPLATE_DECL on their
     TREE_VALUE's. The functions are chained in reverse declaration
     order.

     The TREE_PURPOSE sublist contains those functions with default
     arguments that need post processing, and the TREE_VALUE sublist
     contains those functions with definitions that need post
     processing.

     These lists can only be processed once the outermost class being
     defined is complete.  */
  tree unparsed_functions_queues;

  /* The number of classes whose definitions are currently in
     progress.  */
  unsigned num_classes_being_defined;

  /* The number of template parameter lists that apply directly to the
     current declaration.  */
  unsigned num_template_parameter_lists;
} cp_parser;

/* Prototypes.  */

/* Constructors and destructors.  */

static cp_parser *cp_parser_new
  (void);

/* Routines to parse various constructs.

   Those that return `tree' will return the error_mark_node (rather
   than NULL_TREE) if a parse error occurs, unless otherwise noted.
   Sometimes, they will return an ordinary node if error-recovery was
   attempted, even though a parse error occurred.  So, to check
   whether or not a parse error occurred, you should always use
   cp_parser_error_occurred.  If the construct is optional (indicated
   either by an `_opt' in the name of the function that does the
   parsing or via a FLAGS parameter), then NULL_TREE is returned if
   the construct is not present.  */

/* Lexical conventions [gram.lex]  */

static tree cp_parser_identifier
  (cp_parser *);
static tree cp_parser_string_literal
  (cp_parser *, bool, bool);

/* Basic concepts [gram.basic]  */

static bool cp_parser_translation_unit
  (cp_parser *);

/* Expressions [gram.expr]  */

static tree cp_parser_primary_expression
  (cp_parser *, bool, bool, bool, cp_id_kind *);
static tree cp_parser_id_expression
  (cp_parser *, bool, bool, bool *, bool, bool);
static tree cp_parser_unqualified_id
  (cp_parser *, bool, bool, bool, bool);
static tree cp_parser_nested_name_specifier_opt
  (cp_parser *, bool, bool, bool, bool);
static tree cp_parser_nested_name_specifier
  (cp_parser *, bool, bool, bool, bool);
static tree cp_parser_class_or_namespace_name
  (cp_parser *, bool, bool, bool, bool, bool);
static tree cp_parser_postfix_expression
  (cp_parser *, bool, bool);
static tree cp_parser_postfix_open_square_expression
  (cp_parser *, tree, bool);
static tree cp_parser_postfix_dot_deref_expression
  (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *);
static tree cp_parser_parenthesized_expression_list
  (cp_parser *, bool, bool, bool *);
static void cp_parser_pseudo_destructor_name
  (cp_parser *, tree *, tree *);
static tree cp_parser_unary_expression
  (cp_parser *, bool, bool);
static enum tree_code cp_parser_unary_operator
  (cp_token *);
static tree cp_parser_new_expression
  (cp_parser *);
static tree cp_parser_new_placement
  (cp_parser *);
static tree cp_parser_new_type_id
  (cp_parser *, tree *);
static cp_declarator *cp_parser_new_declarator_opt
  (cp_parser *);
static cp_declarator *cp_parser_direct_new_declarator
  (cp_parser *);
static tree cp_parser_new_initializer
  (cp_parser *);
static tree cp_parser_delete_expression
  (cp_parser *);
static tree cp_parser_cast_expression
  (cp_parser *, bool, bool);
static tree cp_parser_binary_expression
  (cp_parser *, bool);
static tree cp_parser_question_colon_clause
  (cp_parser *, tree);
static tree cp_parser_assignment_expression
  (cp_parser *, bool);
static enum tree_code cp_parser_assignment_operator_opt
  (cp_parser *);
static tree cp_parser_expression
  (cp_parser *, bool);
static tree cp_parser_constant_expression
  (cp_parser *, bool, bool *);
static tree cp_parser_builtin_offsetof
  (cp_parser *);

/* Statements [gram.stmt.stmt]  */

static void cp_parser_statement
  (cp_parser *, tree, bool);
static void cp_parser_label_for_labeled_statement
  (cp_parser *);
static tree cp_parser_expression_statement
  (cp_parser *, tree);
static tree cp_parser_compound_statement
  (cp_parser *, tree, bool);
static void cp_parser_statement_seq_opt
  (cp_parser *, tree);
static tree cp_parser_selection_statement
  (cp_parser *);
static tree cp_parser_condition
  (cp_parser *);
static tree cp_parser_iteration_statement
  (cp_parser *);
static void cp_parser_for_init_statement
  (cp_parser *);
static tree cp_parser_jump_statement
  (cp_parser *);
static void cp_parser_declaration_statement
  (cp_parser *);

static tree cp_parser_implicitly_scoped_statement
  (cp_parser *);
static void cp_parser_already_scoped_statement
  (cp_parser *);

/* Declarations [gram.dcl.dcl] */

static void cp_parser_declaration_seq_opt
  (cp_parser *);
static void cp_parser_declaration
  (cp_parser *);
static void cp_parser_block_declaration
  (cp_parser *, bool);
static void cp_parser_simple_declaration
  (cp_parser *, bool);
static void cp_parser_decl_specifier_seq
  (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
static tree cp_parser_storage_class_specifier_opt
  (cp_parser *);
static tree cp_parser_function_specifier_opt
  (cp_parser *, cp_decl_specifier_seq *);
static tree cp_parser_type_specifier
  (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
   int *, bool *);
static tree cp_parser_simple_type_specifier
  (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
static tree cp_parser_type_name
  (cp_parser *);
static tree cp_parser_elaborated_type_specifier
  (cp_parser *, bool, bool);
static tree cp_parser_enum_specifier
  (cp_parser *);
static void cp_parser_enumerator_list
  (cp_parser *, tree);
static void cp_parser_enumerator_definition
  (cp_parser *, tree);
static tree cp_parser_namespace_name
  (cp_parser *);
static void cp_parser_namespace_definition
  (cp_parser *);
static void cp_parser_namespace_body
  (cp_parser *);
static tree cp_parser_qualified_namespace_specifier
  (cp_parser *);
static void cp_parser_namespace_alias_definition
  (cp_parser *);
static bool cp_parser_using_declaration
  (cp_parser *, bool);
static void cp_parser_using_directive
  (cp_parser *);
static void cp_parser_asm_definition
  (cp_parser *);
static void cp_parser_linkage_specification
  (cp_parser *);

/* Declarators [gram.dcl.decl] */

static tree cp_parser_init_declarator
  (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *);
static cp_declarator *cp_parser_declarator
  (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
static cp_declarator *cp_parser_direct_declarator
  (cp_parser *, cp_parser_declarator_kind, int *, bool);
static enum tree_code cp_parser_ptr_operator
  (cp_parser *, tree *, cp_cv_quals *);
static cp_cv_quals cp_parser_cv_qualifier_seq_opt
  (cp_parser *);
static tree cp_parser_declarator_id
  (cp_parser *, bool);
static tree cp_parser_type_id
  (cp_parser *);
static void cp_parser_type_specifier_seq
  (cp_parser *, bool, cp_decl_specifier_seq *);
static cp_parameter_declarator *cp_parser_parameter_declaration_clause
  (cp_parser *);
static cp_parameter_declarator *cp_parser_parameter_declaration_list
  (cp_parser *, bool *);
static cp_parameter_declarator *cp_parser_parameter_declaration
  (cp_parser *, bool, bool *);
static void cp_parser_function_body
  (cp_parser *);
static tree cp_parser_initializer
  (cp_parser *, bool *, bool *);
static tree cp_parser_initializer_clause
  (cp_parser *, bool *);
static VEC(constructor_elt,gc) *cp_parser_initializer_list
  (cp_parser *, bool *);

static bool cp_parser_ctor_initializer_opt_and_function_body
  (cp_parser *);

/* Classes [gram.class] */

static tree cp_parser_class_name
  (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
static tree cp_parser_class_specifier
  (cp_parser *);
static tree cp_parser_class_head
  (cp_parser *, bool *, tree *, tree *);
static enum tag_types cp_parser_class_key
  (cp_parser *);
static void cp_parser_member_specification_opt
  (cp_parser *);
static void cp_parser_member_declaration
  (cp_parser *);
static tree cp_parser_pure_specifier
  (cp_parser *);
static tree cp_parser_constant_initializer
  (cp_parser *);

/* Derived classes [gram.class.derived] */

static tree cp_parser_base_clause
  (cp_parser *);
static tree cp_parser_base_specifier
  (cp_parser *);

/* Special member functions [gram.special] */

static tree cp_parser_conversion_function_id
  (cp_parser *);
static tree cp_parser_conversion_type_id
  (cp_parser *);
static cp_declarator *cp_parser_conversion_declarator_opt
  (cp_parser *);
static bool cp_parser_ctor_initializer_opt
  (cp_parser *);
static void cp_parser_mem_initializer_list
  (cp_parser *);
static tree cp_parser_mem_initializer
  (cp_parser *);
static tree cp_parser_mem_initializer_id
  (cp_parser *);

/* Overloading [gram.over] */

static tree cp_parser_operator_function_id
  (cp_parser *);
static tree cp_parser_operator
  (cp_parser *);

/* Templates [gram.temp] */

static void cp_parser_template_declaration
  (cp_parser *, bool);
static tree cp_parser_template_parameter_list
  (cp_parser *);
static tree cp_parser_template_parameter
  (cp_parser *, bool *);
static tree cp_parser_type_parameter
  (cp_parser *);
static tree cp_parser_template_id
  (cp_parser *, bool, bool, bool);
static tree cp_parser_template_name
  (cp_parser *, bool, bool, bool, bool *);
static tree cp_parser_template_argument_list
  (cp_parser *);
static tree cp_parser_template_argument
  (cp_parser *);
static void cp_parser_explicit_instantiation
  (cp_parser *);
static void cp_parser_explicit_specialization
  (cp_parser *);

/* Exception handling [gram.exception] */

static tree cp_parser_try_block
  (cp_parser *);
static bool cp_parser_function_try_block
  (cp_parser *);
static void cp_parser_handler_seq
  (cp_parser *);
static void cp_parser_handler
  (cp_parser *);
static tree cp_parser_exception_declaration
  (cp_parser *);
static tree cp_parser_throw_expression
  (cp_parser *);
static tree cp_parser_exception_specification_opt
  (cp_parser *);
static tree cp_parser_type_id_list
  (cp_parser *);

/* GNU Extensions */

static tree cp_parser_asm_specification_opt
  (cp_parser *);
static tree cp_parser_asm_operand_list
  (cp_parser *);
static tree cp_parser_asm_clobber_list
  (cp_parser *);
static tree cp_parser_attributes_opt
  (cp_parser *);
static tree cp_parser_attribute_list
  (cp_parser *);
static bool cp_parser_extension_opt
  (cp_parser *, int *);
static void cp_parser_label_declaration
  (cp_parser *);

enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
static bool cp_parser_pragma
  (cp_parser *, enum pragma_context);

/* Objective-C++ Productions */

static tree cp_parser_objc_message_receiver
  (cp_parser *);
static tree cp_parser_objc_message_args
  (cp_parser *);
static tree cp_parser_objc_message_expression
  (cp_parser *);
static tree cp_parser_objc_encode_expression
  (cp_parser *);
static tree cp_parser_objc_defs_expression
  (cp_parser *);
static tree cp_parser_objc_protocol_expression
  (cp_parser *);
static tree cp_parser_objc_selector_expression
  (cp_parser *);
static tree cp_parser_objc_expression
  (cp_parser *);
static bool cp_parser_objc_selector_p
  (enum cpp_ttype);
static tree cp_parser_objc_selector
  (cp_parser *);
static tree cp_parser_objc_protocol_refs_opt
  (cp_parser *);
static void cp_parser_objc_declaration
  (cp_parser *);
static tree cp_parser_objc_statement
  (cp_parser *);

/* Utility Routines */

static tree cp_parser_lookup_name
  (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *);
static tree cp_parser_lookup_name_simple
  (cp_parser *, tree);
static tree cp_parser_maybe_treat_template_as_class
  (tree, bool);
static bool cp_parser_check_declarator_template_parameters
  (cp_parser *, cp_declarator *);
static bool cp_parser_check_template_parameters
  (cp_parser *, unsigned);
static tree cp_parser_simple_cast_expression
  (cp_parser *);
static tree cp_parser_global_scope_opt
  (cp_parser *, bool);
static bool cp_parser_constructor_declarator_p
  (cp_parser *, bool);
static tree cp_parser_function_definition_from_specifiers_and_declarator
  (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
static tree cp_parser_function_definition_after_declarator
  (cp_parser *, bool);
static void cp_parser_template_declaration_after_export
  (cp_parser *, bool);
static void cp_parser_perform_template_parameter_access_checks
  (VEC (deferred_access_check,gc)*);
static tree cp_parser_single_declaration
  (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool *);
static tree cp_parser_functional_cast
  (cp_parser *, tree);
static tree cp_parser_save_member_function_body
  (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
static tree cp_parser_enclosed_template_argument_list
  (cp_parser *);
static void cp_parser_save_default_args
  (cp_parser *, tree);
static void cp_parser_late_parsing_for_member
  (cp_parser *, tree);
static void cp_parser_late_parsing_default_args
  (cp_parser *, tree);
static tree cp_parser_sizeof_operand
  (cp_parser *, enum rid);
static bool cp_parser_declares_only_class_p
  (cp_parser *);
static void cp_parser_set_storage_class
  (cp_parser *, cp_decl_specifier_seq *, enum rid);
static void cp_parser_set_decl_spec_type
  (cp_decl_specifier_seq *, tree, bool);
static bool cp_parser_friend_p
  (const cp_decl_specifier_seq *);
static cp_token *cp_parser_require
  (cp_parser *, enum cpp_ttype, const char *);
static cp_token *cp_parser_require_keyword
  (cp_parser *, enum rid, const char *);
static bool cp_parser_token_starts_function_definition_p
  (cp_token *);
static bool cp_parser_next_token_starts_class_definition_p
  (cp_parser *);
static bool cp_parser_next_token_ends_template_argument_p
  (cp_parser *);
static bool cp_parser_nth_token_starts_template_argument_list_p
  (cp_parser *, size_t);
static enum tag_types cp_parser_token_is_class_key
  (cp_token *);
static void cp_parser_check_class_key
  (enum tag_types, tree type);
static void cp_parser_check_access_in_redeclaration
  (tree type);
static bool cp_parser_optional_template_keyword
  (cp_parser *);
static void cp_parser_pre_parsed_nested_name_specifier
  (cp_parser *);
static void cp_parser_cache_group
  (cp_parser *, enum cpp_ttype, unsigned);
static void cp_parser_parse_tentatively
  (cp_parser *);
static void cp_parser_commit_to_tentative_parse
  (cp_parser *);
static void cp_parser_abort_tentative_parse
  (cp_parser *);
static bool cp_parser_parse_definitely
  (cp_parser *);
static inline bool cp_parser_parsing_tentatively
  (cp_parser *);
static bool cp_parser_uncommitted_to_tentative_parse_p
  (cp_parser *);
static void cp_parser_error
  (cp_parser *, const char *);
static void cp_parser_name_lookup_error
  (cp_parser *, tree, tree, const char *);
static bool cp_parser_simulate_error
  (cp_parser *);
static bool cp_parser_check_type_definition
  (cp_parser *);
static void cp_parser_check_for_definition_in_return_type
  (cp_declarator *, tree);
static void cp_parser_check_for_invalid_template_id
  (cp_parser *, tree);
static bool cp_parser_non_integral_constant_expression
  (cp_parser *, const char *);
static void cp_parser_diagnose_invalid_type_name
  (cp_parser *, tree, tree);
static bool cp_parser_parse_and_diagnose_invalid_type_name
  (cp_parser *);
static int cp_parser_skip_to_closing_parenthesis
  (cp_parser *, bool, bool, bool);
static void cp_parser_skip_to_end_of_statement
  (cp_parser *);
static void cp_parser_consume_semicolon_at_end_of_statement
  (cp_parser *);
static void cp_parser_skip_to_end_of_block_or_statement
  (cp_parser *);
static void cp_parser_skip_to_closing_brace
  (cp_parser *);
static void cp_parser_skip_to_end_of_template_parameter_list
  (cp_parser *);
static void cp_parser_skip_to_pragma_eol
  (cp_parser*, cp_token *);
static bool cp_parser_error_occurred
  (cp_parser *);
static bool cp_parser_allow_gnu_extensions_p
  (cp_parser *);
static bool cp_parser_is_string_literal
  (cp_token *);
static bool cp_parser_is_keyword
  (cp_token *, enum rid);
static tree cp_parser_make_typename_type
  (cp_parser *, tree, tree);

/* Returns nonzero if we are parsing tentatively.  */

static inline bool
cp_parser_parsing_tentatively (cp_parser* parser)
{
  return parser->context->next != NULL;
}

/* Returns nonzero if TOKEN is a string literal.  */

static bool
cp_parser_is_string_literal (cp_token* token)
{
  return (token->type == CPP_STRING || token->type == CPP_WSTRING);
}

/* Returns nonzero if TOKEN is the indicated KEYWORD.  */

static bool
cp_parser_is_keyword (cp_token* token, enum rid keyword)
{
  return token->keyword == keyword;
}

/* If not parsing tentatively, issue a diagnostic of the form
      FILE:LINE: MESSAGE before TOKEN
   where TOKEN is the next token in the input stream.  MESSAGE
   (specified by the caller) is usually of the form "expected
   OTHER-TOKEN".  */

static void
cp_parser_error (cp_parser* parser, const char* message)
{
  if (!cp_parser_simulate_error (parser))
    {
      cp_token *token = cp_lexer_peek_token (parser->lexer);
      /* This diagnostic makes more sense if it is tagged to the line
   of the token we just peeked at.  */
      cp_lexer_set_source_position_from_token (token);

      if (token->type == CPP_PRAGMA)
  {
    error ("%<#pragma%> is not allowed here");
    cp_parser_skip_to_pragma_eol (parser, token);
    return;
  }

      c_parse_error (message,
         /* Because c_parser_error does not understand
      CPP_KEYWORD, keywords are treated like
      identifiers.  */
         (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
         token->u.value);
    }
}

/* Issue an error about name-lookup failing.  NAME is the
   IDENTIFIER_NODE DECL is the result of
   the lookup (as returned from cp_parser_lookup_name).  DESIRED is
   the thing that we hoped to find.  */

static void
cp_parser_name_lookup_error (cp_parser* parser,
           tree name,
           tree decl,
           const char* desired)
{
  /* If name lookup completely failed, tell the user that NAME was not
     declared.  */
  if (decl == error_mark_node)
    {
      if (parser->scope && parser->scope != global_namespace)
  error ("%<%D::%D%> has not been declared",
         parser->scope, name);
      else if (parser->scope == global_namespace)
  error ("%<::%D%> has not been declared", name);
      else if (parser->object_scope
         && !CLASS_TYPE_P (parser->object_scope))
  error ("request for member %qD in non-class type %qT",
         name, parser->object_scope);
      else if (parser->object_scope)
  error ("%<%T::%D%> has not been declared",
         parser->object_scope, name);
      else
  error ("%qD has not been declared", name);
    }
  else if (parser->scope && parser->scope != global_namespace)
    error ("%<%D::%D%> %s", parser->scope, name, desired);
  else if (parser->scope == global_namespace)
    error ("%<::%D%> %s", name, desired);
  else
    error ("%qD %s", name, desired);
}

/* If we are parsing tentatively, remember that an error has occurred
   during this tentative parse.  Returns true if the error was
   simulated; false if a message should be issued by the caller.  */

static bool
cp_parser_simulate_error (cp_parser* parser)
{
  if (cp_parser_uncommitted_to_tentative_parse_p (parser))
    {
      parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
      return true;
    }
  return false;
}

/* Check for repeated decl-specifiers.  */

static void
cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs)
{
  cp_decl_spec ds;

  for (ds = ds_first; ds != ds_last; ++ds)
    {
      unsigned count = decl_specs->specs[(int)ds];
      if (count < 2)
  continue;
      /* The "long" specifier is a special case because of "long long".  */
      if (ds == ds_long)
  {
    if (count > 2)
      error ("%<long long long%> is too long for GCC");
    else if (pedantic && !in_system_header && warn_long_long)
      pedwarn ("ISO C++ does not support %<long long%>");
  }
      else if (count > 1)
  {
    static const char *const decl_spec_names[] = {
      "signed",
      "unsigned",
      "short",
      "long",
      "const",
      "volatile",
      "restrict",
      "inline",
      "virtual",
      "explicit",
      "friend",
      "typedef",
      "__complex",
      "__thread"
    };
    error ("duplicate %qs", decl_spec_names[(int)ds]);
  }
    }
}

/* This function is called when a type is defined.  If type
   definitions are forbidden at this point, an error message is
   issued.  */

static bool
cp_parser_check_type_definition (cp_parser* parser)
{
  /* If types are forbidden here, issue a message.  */
  if (parser->type_definition_forbidden_message)
    {
      /* Use `%s' to print the string in case there are any escape
   characters in the message.  */
      error ("%s", parser->type_definition_forbidden_message);
      return false;
    }
  return true;
}

/* This function is called when the DECLARATOR is processed.  The TYPE
   was a type defined in the decl-specifiers.  If it is invalid to
   define a type in the decl-specifiers for DECLARATOR, an error is
   issued.  */

static void
cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
                 tree type)
{
  /* [dcl.fct] forbids type definitions in return types.
     Unfortunately, it's not easy to know whether or not we are
     processing a return type until after the fact.  */
  while (declarator
   && (declarator->kind == cdk_pointer
       || declarator->kind == cdk_reference
       || declarator->kind == cdk_ptrmem))
    declarator = declarator->declarator;
  if (declarator
      && declarator->kind == cdk_function)
    {
      error ("new types may not be defined in a return type");
      inform ("(perhaps a semicolon is missing after the definition of %qT)",
        type);
    }
}

/* A type-specifier (TYPE) has been parsed which cannot be followed by
   "<" in any valid C++ program.  If the next token is indeed "<",
   issue a message warning the user about what appears to be an
   invalid attempt to form a template-id.  */

static void
cp_parser_check_for_invalid_template_id (cp_parser* parser,
           tree type)
{
  cp_token_position start = 0;

  if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
    {
      if (TYPE_P (type))
  error ("%qT is not a template", type);
      else if (TREE_CODE (type) == IDENTIFIER_NODE)
  error ("%qE is not a template", type);
      else
  error ("invalid template-id");
      /* Remember the location of the invalid "<".  */
      if (cp_parser_uncommitted_to_tentative_parse_p (parser))
  start = cp_lexer_token_position (parser->lexer, true);
      /* Consume the "<".  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the template arguments.  */
      cp_parser_enclosed_template_argument_list (parser);
      /* Permanently remove the invalid template arguments so that
   this error message is not issued again.  */
      if (start)
  cp_lexer_purge_tokens_after (parser->lexer, start);
    }
}

/* If parsing an integral constant-expression, issue an error message
   about the fact that THING appeared and return true.  Otherwise,
   return false.  In either case, set
   PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P.  */

static bool
cp_parser_non_integral_constant_expression (cp_parser  *parser,
              const char *thing)
{
  parser->non_integral_constant_expression_p = true;
  if (parser->integral_constant_expression_p)
    {
      if (!parser->allow_non_integral_constant_expression_p)
  {
    error ("%s cannot appear in a constant-expression", thing);
    return true;
  }
    }
  return false;
}

/* Emit a diagnostic for an invalid type name.  SCOPE is the
   qualifying scope (or NULL, if none) for ID.  This function commits
   to the current active tentative parse, if any.  (Otherwise, the
   problematic construct might be encountered again later, resulting
   in duplicate error messages.)  */

static void
cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree scope, tree id)
{
  tree decl, old_scope;
  /* Try to lookup the identifier.  */
  old_scope = parser->scope;
  parser->scope = scope;
  decl = cp_parser_lookup_name_simple (parser, id);
  parser->scope = old_scope;
  /* If the lookup found a template-name, it means that the user forgot
  to specify an argument list. Emit a useful error message.  */
  if (TREE_CODE (decl) == TEMPLATE_DECL)
    error ("invalid use of template-name %qE without an argument list", decl);
  else if (TREE_CODE (id) == BIT_NOT_EXPR)
    error ("invalid use of destructor %qD as a type", id);
  else if (TREE_CODE (decl) == TYPE_DECL)
    /* Something like 'unsigned A a;'  */
    error ("invalid combination of multiple type-specifiers");
  else if (!parser->scope)
    {
      /* Issue an error message.  */
      error ("%qE does not name a type", id);
      /* If we're in a template class, it's possible that the user was
   referring to a type from a base class.  For example:

     template <typename T> struct A { typedef T X; };
     template <typename T> struct B : public A<T> { X x; };

   The user should have said "typename A<T>::X".  */
      if (processing_template_decl && current_class_type
    && TYPE_BINFO (current_class_type))
  {
    tree b;

    for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
         b;
         b = TREE_CHAIN (b))
      {
        tree base_type = BINFO_TYPE (b);
        if (CLASS_TYPE_P (base_type)
      && dependent_type_p (base_type))
    {
      tree field;
      /* Go from a particular instantiation of the
         template (which will have an empty TYPE_FIELDs),
         to the main version.  */
      base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
      for (field = TYPE_FIELDS (base_type);
           field;
           field = TREE_CHAIN (field))
        if (TREE_CODE (field) == TYPE_DECL
      && DECL_NAME (field) == id)
          {
      inform ("(perhaps %<typename %T::%E%> was intended)",
        BINFO_TYPE (b), id);
      break;
          }
      if (field)
        break;
    }
      }
  }
    }
  /* Here we diagnose qualified-ids where the scope is actually correct,
     but the identifier does not resolve to a valid type name.  */
  else if (parser->scope != error_mark_node)
    {
      if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
  error ("%qE in namespace %qE does not name a type",
         id, parser->scope);
      else if (TYPE_P (parser->scope))
  error ("%qE in class %qT does not name a type", id, parser->scope);
      else
  gcc_unreachable ();
    }
  cp_parser_commit_to_tentative_parse (parser);
}

/* Check for a common situation where a type-name should be present,
   but is not, and issue a sensible error message.  Returns true if an
   invalid type-name was detected.

   The situation handled by this function are variable declarations of the
   form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
   Usually, `ID' should name a type, but if we got here it means that it
   does not. We try to emit the best possible error message depending on
   how exactly the id-expression looks like.  */

static bool
cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
{
  tree id;

  cp_parser_parse_tentatively (parser);
  id = cp_parser_id_expression (parser,
        /*template_keyword_p=*/false,
        /*check_dependency_p=*/true,
        /*template_p=*/NULL,
        /*declarator_p=*/true,
        /*optional_p=*/false);
  /* After the id-expression, there should be a plain identifier,
     otherwise this is not a simple variable declaration. Also, if
     the scope is dependent, we cannot do much.  */
  if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)
      || (parser->scope && TYPE_P (parser->scope)
    && dependent_type_p (parser->scope))
      || TREE_CODE (id) == TYPE_DECL)
    {
      cp_parser_abort_tentative_parse (parser);
      return false;
    }
  if (!cp_parser_parse_definitely (parser))
    return false;

  /* Emit a diagnostic for the invalid type.  */
  cp_parser_diagnose_invalid_type_name (parser, parser->scope, id);
  /* Skip to the end of the declaration; there's no point in
     trying to process it.  */
  cp_parser_skip_to_end_of_block_or_statement (parser);
  return true;
}

/* Consume tokens up to, and including, the next non-nested closing `)'.
   Returns 1 iff we found a closing `)'.  RECOVERING is true, if we
   are doing error recovery. Returns -1 if OR_COMMA is true and we
   found an unnested comma.  */

static int
cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
               bool recovering,
               bool or_comma,
               bool consume_paren)
{
  unsigned paren_depth = 0;
  unsigned brace_depth = 0;

  if (recovering && !or_comma
      && cp_parser_uncommitted_to_tentative_parse_p (parser))
    return 0;

  while (true)
    {
      cp_token * token = cp_lexer_peek_token (parser->lexer);

      switch (token->type)
  {
  case CPP_EOF:
  case CPP_PRAGMA_EOL:
    /* If we've run out of tokens, then there is no closing `)'.  */
    return 0;

  case CPP_SEMICOLON:
    /* This matches the processing in skip_to_end_of_statement.  */
    if (!brace_depth)
      return 0;
    break;

  case CPP_OPEN_BRACE:
    ++brace_depth;
    break;
  case CPP_CLOSE_BRACE:
    if (!brace_depth--)
      return 0;
    break;

  case CPP_COMMA:
    if (recovering && or_comma && !brace_depth && !paren_depth)
      return -1;
    break;

  case CPP_OPEN_PAREN:
    if (!brace_depth)
      ++paren_depth;
    break;

  case CPP_CLOSE_PAREN:
    if (!brace_depth && !paren_depth--)
      {
        if (consume_paren)
    cp_lexer_consume_token (parser->lexer);
        return 1;
      }
    break;

  default:
    break;
  }

      /* Consume the token.  */
      cp_lexer_consume_token (parser->lexer);
    }
}

/* Consume tokens until we reach the end of the current statement.
   Normally, that will be just before consuming a `;'.  However, if a
   non-nested `}' comes first, then we stop before consuming that.  */

static void
cp_parser_skip_to_end_of_statement (cp_parser* parser)
{
  unsigned nesting_depth = 0;

  while (true)
    {
      cp_token *token = cp_lexer_peek_token (parser->lexer);

      switch (token->type)
  {
  case CPP_EOF:
  case CPP_PRAGMA_EOL:
    /* If we've run out of tokens, stop.  */
    return;

  case CPP_SEMICOLON:
    /* If the next token is a `;', we have reached the end of the
       statement.  */
    if (!nesting_depth)
      return;
    break;

  case CPP_CLOSE_BRACE:
    /* If this is a non-nested '}', stop before consuming it.
       That way, when confronted with something like:

         { 3 + }

       we stop before consuming the closing '}', even though we
       have not yet reached a `;'.  */
    if (nesting_depth == 0)
      return;

    /* If it is the closing '}' for a block that we have
       scanned, stop -- but only after consuming the token.
       That way given:

    void f g () { ... }
    typedef int I;

       we will stop after the body of the erroneously declared
       function, but before consuming the following `typedef'
       declaration.  */
    if (--nesting_depth == 0)
      {
        cp_lexer_consume_token (parser->lexer);
        return;
      }

  case CPP_OPEN_BRACE:
    ++nesting_depth;
    break;

  default:
    break;
  }

      /* Consume the token.  */
      cp_lexer_consume_token (parser->lexer);
    }
}

/* This function is called at the end of a statement or declaration.
   If the next token is a semicolon, it is consumed; otherwise, error
   recovery is attempted.  */

static void
cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
{
  /* Look for the trailing `;'.  */
  if (!cp_parser_require (parser, CPP_SEMICOLON, "`;'"))
    {
      /* If there is additional (erroneous) input, skip to the end of
   the statement.  */
      cp_parser_skip_to_end_of_statement (parser);
      /* If the next token is now a `;', consume it.  */
      if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
  cp_lexer_consume_token (parser->lexer);
    }
}

/* Skip tokens until we have consumed an entire block, or until we
   have consumed a non-nested `;'.  */

static void
cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
{
  int nesting_depth = 0;

  while (nesting_depth >= 0)
    {
      cp_token *token = cp_lexer_peek_token (parser->lexer);

      switch (token->type)
  {
  case CPP_EOF:
  case CPP_PRAGMA_EOL:
    /* If we've run out of tokens, stop.  */
    return;

  case CPP_SEMICOLON:
    /* Stop if this is an unnested ';'. */
    if (!nesting_depth)
      nesting_depth = -1;
    break;

  case CPP_CLOSE_BRACE:
    /* Stop if this is an unnested '}', or closes the outermost
       nesting level.  */
    nesting_depth--;
    if (!nesting_depth)
      nesting_depth = -1;
    break;

  case CPP_OPEN_BRACE:
    /* Nest. */
    nesting_depth++;
    break;

  default:
    break;
  }

      /* Consume the token.  */
      cp_lexer_consume_token (parser->lexer);
    }
}

/* Skip tokens until a non-nested closing curly brace is the next
   token.  */

static void
cp_parser_skip_to_closing_brace (cp_parser *parser)
{
  unsigned nesting_depth = 0;

  while (true)
    {
      cp_token *token = cp_lexer_peek_token (parser->lexer);

      switch (token->type)
  {
  case CPP_EOF:
  case CPP_PRAGMA_EOL:
    /* If we've run out of tokens, stop.  */
    return;

  case CPP_CLOSE_BRACE:
    /* If the next token is a non-nested `}', then we have reached
       the end of the current block.  */
    if (nesting_depth-- == 0)
      return;
    break;

  case CPP_OPEN_BRACE:
    /* If it the next token is a `{', then we are entering a new
       block.  Consume the entire block.  */
    ++nesting_depth;
    break;

  default:
    break;
  }

      /* Consume the token.  */
      cp_lexer_consume_token (parser->lexer);
    }
}

/* Consume tokens until we reach the end of the pragma.  The PRAGMA_TOK
   parameter is the PRAGMA token, allowing us to purge the entire pragma
   sequence.  */

static void
cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
{
  cp_token *token;

  parser->lexer->in_pragma = false;

  do
    token = cp_lexer_consume_token (parser->lexer);
  while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);

  /* Ensure that the pragma is not parsed again.  */
  cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
}

/* Require pragma end of line, resyncing with it as necessary.  The
   arguments are as for cp_parser_skip_to_pragma_eol.  */

static void
cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
{
  parser->lexer->in_pragma = false;
  if (!cp_parser_require (parser, CPP_PRAGMA_EOL, "end of line"))
    cp_parser_skip_to_pragma_eol (parser, pragma_tok);
}

/* This is a simple wrapper around make_typename_type. When the id is
   an unresolved identifier node, we can provide a superior diagnostic
   using cp_parser_diagnose_invalid_type_name.  */

static tree
cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id)
{
  tree result;
  if (TREE_CODE (id) == IDENTIFIER_NODE)
    {
      result = make_typename_type (scope, id, typename_type,
           /*complain=*/tf_none);
      if (result == error_mark_node)
  cp_parser_diagnose_invalid_type_name (parser, scope, id);
      return result;
    }
  return make_typename_type (scope, id, typename_type, tf_error);
}


/* Create a new C++ parser.  */

static cp_parser *
cp_parser_new (void)
{
  cp_parser *parser;
  cp_lexer *lexer;
  unsigned i;

  /* cp_lexer_new_main is called before calling ggc_alloc because
     cp_lexer_new_main might load a PCH file.  */
  lexer = cp_lexer_new_main ();

  /* Initialize the binops_by_token so that we can get the tree
     directly from the token.  */
  for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
    binops_by_token[binops[i].token_type] = binops[i];

  parser = GGC_CNEW (cp_parser);
  parser->lexer = lexer;
  parser->context = cp_parser_context_new (NULL);

  /* For now, we always accept GNU extensions.  */
  parser->allow_gnu_extensions_p = 1;

  /* The `>' token is a greater-than operator, not the end of a
     template-id.  */
  parser->greater_than_is_operator_p = true;

  parser->default_arg_ok_p = true;

  /* We are not parsing a constant-expression.  */
  parser->integral_constant_expression_p = false;
  parser->allow_non_integral_constant_expression_p = false;
  parser->non_integral_constant_expression_p = false;

  /* Local variable names are not forbidden.  */
  parser->local_variables_forbidden_p = false;

  /* We are not processing an `extern "C"' declaration.  */
  parser->in_unbraced_linkage_specification_p = false;

  /* We are not processing a declarator.  */
  parser->in_declarator_p = false;

  /* We are not processing a template-argument-list.  */
  parser->in_template_argument_list_p = false;

  /* We are not in an iteration statement.  */
  parser->in_statement = 0;

  /* We are not in a switch statement.  */
  parser->in_switch_statement_p = false;

  /* We are not parsing a type-id inside an expression.  */
  parser->in_type_id_in_expr_p = false;

  /* Declarations aren't implicitly extern "C".  */
  parser->implicit_extern_c = false;

  /* String literals should be translated to the execution character set.  */
  parser->translate_strings_p = true;

  /* We are not parsing a function body.  */
  parser->in_function_body = false;

  /* The unparsed function queue is empty.  */
  parser->unparsed_functions_queues = build_tree_list (NULL_TREE, NULL_TREE);

  /* There are no classes being defined.  */
  parser->num_classes_being_defined = 0;

  /* No template parameters apply.  */
  parser->num_template_parameter_lists = 0;

  return parser;
}

/* Create a cp_lexer structure which will emit the tokens in CACHE
   and push it onto the parser's lexer stack.  This is used for delayed
   parsing of in-class method bodies and default arguments, and should
   not be confused with tentative parsing.  */
static void
cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
{
  cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
  lexer->next = parser->lexer;
  parser->lexer = lexer;

  /* Move the current source position to that of the first token in the
     new lexer.  */
  cp_lexer_set_source_position_from_token (lexer->next_token);
}

/* Pop the top lexer off the parser stack.  This is never used for the
   "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens.  */
static void
cp_parser_pop_lexer (cp_parser *parser)
{
  cp_lexer *lexer = parser->lexer;
  parser->lexer = lexer->next;
  cp_lexer_destroy (lexer);

  /* Put the current source position back where it was before this
     lexer was pushed.  */
  cp_lexer_set_source_position_from_token (parser->lexer->next_token);
}

/* Lexical conventions [gram.lex]  */

/* Parse an identifier.  Returns an IDENTIFIER_NODE representing the
   identifier.  */

static tree
cp_parser_identifier (cp_parser* parser)
{
  cp_token *token;

  /* Look for the identifier.  */
  token = cp_parser_require (parser, CPP_NAME, "identifier");
  /* Return the value.  */
  return token ? token->u.value : error_mark_node;
}

/* Parse a sequence of adjacent string constants.  Returns a
   TREE_STRING representing the combined, nul-terminated string
   constant.  If TRANSLATE is true, translate the string to the
   execution character set.  If WIDE_OK is true, a wide string is
   invalid here.

   C++98 [lex.string] says that if a narrow string literal token is
   adjacent to a wide string literal token, the behavior is undefined.
   However, C99 6.4.5p4 says that this results in a wide string literal.
   We follow C99 here, for consistency with the C front end.

   This code is largely lifted from lex_string() in c-lex.c.

   FUTURE: ObjC++ will need to handle @-strings here.  */
static tree
cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
{
  tree value;
  bool wide = false;
  size_t count;
  struct obstack str_ob;
  cpp_string str, istr, *strs;
  cp_token *tok;

  tok = cp_lexer_peek_token (parser->lexer);
  if (!cp_parser_is_string_literal (tok))
    {
      cp_parser_error (parser, "expected string-literal");
      return error_mark_node;
    }

  /* Try to avoid the overhead of creating and destroying an obstack
     for the common case of just one string.  */
  if (!cp_parser_is_string_literal
      (cp_lexer_peek_nth_token (parser->lexer, 2)))
    {
      cp_lexer_consume_token (parser->lexer);

      str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
      str.len = TREE_STRING_LENGTH (tok->u.value);
      count = 1;
      if (tok->type == CPP_WSTRING)
  wide = true;

      strs = &str;
    }
  else
    {
      gcc_obstack_init (&str_ob);
      count = 0;

      do
  {
    cp_lexer_consume_token (parser->lexer);
    count++;
    str.text = (unsigned char *)TREE_STRING_POINTER (tok->u.value);
    str.len = TREE_STRING_LENGTH (tok->u.value);
    if (tok->type == CPP_WSTRING)
      wide = true;

    obstack_grow (&str_ob, &str, sizeof (cpp_string));

    tok = cp_lexer_peek_token (parser->lexer);
  }
      while (cp_parser_is_string_literal (tok));

      strs = (cpp_string *) obstack_finish (&str_ob);
    }

  if (wide && !wide_ok)
    {
      cp_parser_error (parser, "a wide string is invalid in this context");
      wide = false;
    }

  if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
      (parse_in, strs, count, &istr, wide))
    {
      value = build_string (istr.len, (char *)istr.text);
      free ((void *)istr.text);

      TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
      value = fix_string_type (value);
    }
  else
    /* cpp_interpret_string has issued an error.  */
    value = error_mark_node;

  if (count > 1)
    obstack_free (&str_ob, 0);

  return value;
}


/* Basic concepts [gram.basic]  */

/* Parse a translation-unit.

   translation-unit:
     declaration-seq [opt]

   Returns TRUE if all went well.  */

static bool
cp_parser_translation_unit (cp_parser* parser)
{
  /* The address of the first non-permanent object on the declarator
     obstack.  */
  static void *declarator_obstack_base;

  bool success;

  /* Create the declarator obstack, if necessary.  */
  if (!cp_error_declarator)
    {
      gcc_obstack_init (&declarator_obstack);
      /* Create the error declarator.  */
      cp_error_declarator = make_declarator (cdk_error);
      /* Create the empty parameter list.  */
      no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
      /* Remember where the base of the declarator obstack lies.  */
      declarator_obstack_base = obstack_next_free (&declarator_obstack);
    }

  cp_parser_declaration_seq_opt (parser);

  /* If there are no tokens left then all went well.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
    {
      /* Get rid of the token array; we don't need it any more.  */
      cp_lexer_destroy (parser->lexer);
      parser->lexer = NULL;

      /* This file might have been a context that's implicitly extern
   "C".  If so, pop the lang context.  (Only relevant for PCH.) */
      if (parser->implicit_extern_c)
  {
    pop_lang_context ();
    parser->implicit_extern_c = false;
  }

      /* Finish up.  */
      finish_translation_unit ();

      success = true;
    }
  else
    {
      cp_parser_error (parser, "expected declaration");
      success = false;
    }

  /* Make sure the declarator obstack was fully cleaned up.  */
  gcc_assert (obstack_next_free (&declarator_obstack)
        == declarator_obstack_base);

  /* All went well.  */
  return success;
}

/* Expressions [gram.expr] */

/* Parse a primary-expression.

   primary-expression:
     literal
     this
     ( expression )
     id-expression

   GNU Extensions:

   primary-expression:
     ( compound-statement )
     __builtin_va_arg ( assignment-expression , type-id )
     __builtin_offsetof ( type-id , offsetof-expression )

   Objective-C++ Extension:

   primary-expression:
     objc-expression

   literal:
     __null

   ADDRESS_P is true iff this expression was immediately preceded by
   "&" and therefore might denote a pointer-to-member.  CAST_P is true
   iff this expression is the target of a cast.  TEMPLATE_ARG_P is
   true iff this expression is a template argument.

   Returns a representation of the expression.  Upon return, *IDK
   indicates what kind of id-expression (if any) was present.  */

static tree
cp_parser_primary_expression (cp_parser *parser,
            bool address_p,
            bool cast_p,
            bool template_arg_p,
            cp_id_kind *idk)
{
  cp_token *token;

  /* Assume the primary expression is not an id-expression.  */
  *idk = CP_ID_KIND_NONE;

  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);
  switch (token->type)
    {
      /* literal:
     integer-literal
     character-literal
     floating-literal
     string-literal
     boolean-literal  */
    case CPP_CHAR:
    case CPP_WCHAR:
    case CPP_NUMBER:
      token = cp_lexer_consume_token (parser->lexer);
      /* Floating-point literals are only allowed in an integral
   constant expression if they are cast to an integral or
   enumeration type.  */
      if (TREE_CODE (token->u.value) == REAL_CST
    && parser->integral_constant_expression_p
    && pedantic)
  {
    /* CAST_P will be set even in invalid code like "int(2.7 +
       ...)".   Therefore, we have to check that the next token
       is sure to end the cast.  */
    if (cast_p)
      {
        cp_token *next_token;

        next_token = cp_lexer_peek_token (parser->lexer);
        if (/* The comma at the end of an
         enumerator-definition.  */
      next_token->type != CPP_COMMA
      /* The curly brace at the end of an enum-specifier.  */
      && next_token->type != CPP_CLOSE_BRACE
      /* The end of a statement.  */
      && next_token->type != CPP_SEMICOLON
      /* The end of the cast-expression.  */
      && next_token->type != CPP_CLOSE_PAREN
      /* The end of an array bound.  */
      && next_token->type != CPP_CLOSE_SQUARE
      /* The closing ">" in a template-argument-list.  */
      && (next_token->type != CPP_GREATER
          || parser->greater_than_is_operator_p))
    cast_p = false;
      }

    /* If we are within a cast, then the constraint that the
       cast is to an integral or enumeration type will be
       checked at that point.  If we are not within a cast, then
       this code is invalid.  */
    if (!cast_p)
      cp_parser_non_integral_constant_expression
        (parser, "floating-point literal");
  }
      return token->u.value;

    case CPP_STRING:
    case CPP_WSTRING:
      /* ??? Should wide strings be allowed when parser->translate_strings_p
   is false (i.e. in attributes)?  If not, we can kill the third
   argument to cp_parser_string_literal.  */
      return cp_parser_string_literal (parser,
               parser->translate_strings_p,
               true);

    case CPP_OPEN_PAREN:
      {
  tree expr;
  bool saved_greater_than_is_operator_p;

  /* Consume the `('.  */
  cp_lexer_consume_token (parser->lexer);
  /* Within a parenthesized expression, a `>' token is always
     the greater-than operator.  */
  saved_greater_than_is_operator_p
    = parser->greater_than_is_operator_p;
  parser->greater_than_is_operator_p = true;
  /* If we see `( { ' then we are looking at the beginning of
     a GNU statement-expression.  */
  if (cp_parser_allow_gnu_extensions_p (parser)
      && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
    {
      /* Statement-expressions are not allowed by the standard.  */
      if (pedantic)
        pedwarn ("ISO C++ forbids braced-groups within expressions");

      /* And they're not allowed outside of a function-body; you
         cannot, for example, write:

     int i = ({ int j = 3; j + 1; });

         at class or namespace scope.  */
      if (!parser->in_function_body)
        error ("statement-expressions are allowed only inside functions");
      /* Start the statement-expression.  */
      expr = begin_stmt_expr ();
      /* Parse the compound-statement.  */
      cp_parser_compound_statement (parser, expr, false);
      /* Finish up.  */
      expr = finish_stmt_expr (expr, false);
    }
  else
    {
      /* Parse the parenthesized expression.  */
      expr = cp_parser_expression (parser, cast_p);
      /* Let the front end know that this expression was
         enclosed in parentheses. This matters in case, for
         example, the expression is of the form `A::B', since
         `&A::B' might be a pointer-to-member, but `&(A::B)' is
         not.  */
      finish_parenthesized_expr (expr);
    }
  /* The `>' token might be the end of a template-id or
     template-parameter-list now.  */
  parser->greater_than_is_operator_p
    = saved_greater_than_is_operator_p;
  /* Consume the `)'.  */
  if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
    cp_parser_skip_to_end_of_statement (parser);

  return expr;
      }

    case CPP_KEYWORD:
      switch (token->keyword)
  {
    /* These two are the boolean literals.  */
  case RID_TRUE:
    cp_lexer_consume_token (parser->lexer);
    return boolean_true_node;
  case RID_FALSE:
    cp_lexer_consume_token (parser->lexer);
    return boolean_false_node;

    /* The `__null' literal.  */
  case RID_NULL:
    cp_lexer_consume_token (parser->lexer);
    return null_node;

    /* Recognize the `this' keyword.  */
  case RID_THIS:
    cp_lexer_consume_token (parser->lexer);
    if (parser->local_variables_forbidden_p)
      {
        error ("%<this%> may not be used in this context");
        return error_mark_node;
      }
    /* Pointers cannot appear in constant-expressions.  */
    if (cp_parser_non_integral_constant_expression (parser,
                "`this'"))
      return error_mark_node;
    return finish_this_expr ();

    /* The `operator' keyword can be the beginning of an
       id-expression.  */
  case RID_OPERATOR:
    goto id_expression;

  case RID_FUNCTION_NAME:
  case RID_PRETTY_FUNCTION_NAME:
  case RID_C99_FUNCTION_NAME:
    /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
       __func__ are the names of variables -- but they are
       treated specially.  Therefore, they are handled here,
       rather than relying on the generic id-expression logic
       below.  Grammatically, these names are id-expressions.

       Consume the token.  */
    token = cp_lexer_consume_token (parser->lexer);
    /* Look up the name.  */
    return finish_fname (token->u.value);

  case RID_VA_ARG:
    {
      tree expression;
      tree type;

      /* The `__builtin_va_arg' construct is used to handle
         `va_arg'.  Consume the `__builtin_va_arg' token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Look for the opening `('.  */
      cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
      /* Now, parse the assignment-expression.  */
      expression = cp_parser_assignment_expression (parser,
                /*cast_p=*/false);
      /* Look for the `,'.  */
      cp_parser_require (parser, CPP_COMMA, "`,'");
      /* Parse the type-id.  */
      type = cp_parser_type_id (parser);
      /* Look for the closing `)'.  */
      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
      /* Using `va_arg' in a constant-expression is not
         allowed.  */
      if (cp_parser_non_integral_constant_expression (parser,
                  "`va_arg'"))
        return error_mark_node;
      return build_x_va_arg (expression, type);
    }

  case RID_OFFSETOF:
    return cp_parser_builtin_offsetof (parser);

    /* Objective-C++ expressions.  */
  case RID_AT_ENCODE:
  case RID_AT_PROTOCOL:
  case RID_AT_SELECTOR:
    return cp_parser_objc_expression (parser);

  default:
    cp_parser_error (parser, "expected primary-expression");
    return error_mark_node;
  }

      /* An id-expression can start with either an identifier, a
   `::' as the beginning of a qualified-id, or the "operator"
   keyword.  */
    case CPP_NAME:
    case CPP_SCOPE:
    case CPP_TEMPLATE_ID:
    case CPP_NESTED_NAME_SPECIFIER:
      {
  tree id_expression;
  tree decl;
  const char *error_msg;
  bool template_p;
  bool done;

      id_expression:
  /* Parse the id-expression.  */
  id_expression
    = cp_parser_id_expression (parser,
             /*template_keyword_p=*/false,
             /*check_dependency_p=*/true,
             &template_p,
             /*declarator_p=*/false,
             /*optional_p=*/false);
  if (id_expression == error_mark_node)
    return error_mark_node;
  token = cp_lexer_peek_token (parser->lexer);
  done = (token->type != CPP_OPEN_SQUARE
    && token->type != CPP_OPEN_PAREN
    && token->type != CPP_DOT
    && token->type != CPP_DEREF
    && token->type != CPP_PLUS_PLUS
    && token->type != CPP_MINUS_MINUS);
  /* If we have a template-id, then no further lookup is
     required.  If the template-id was for a template-class, we
     will sometimes have a TYPE_DECL at this point.  */
  if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
     || TREE_CODE (id_expression) == TYPE_DECL)
    decl = id_expression;
  /* Look up the name.  */
  else
    {
      tree ambiguous_decls;

      decl = cp_parser_lookup_name (parser, id_expression,
            none_type,
            template_p,
            /*is_namespace=*/false,
            /*check_dependency=*/true,
            &ambiguous_decls);
      /* If the lookup was ambiguous, an error will already have
         been issued.  */
      if (ambiguous_decls)
        return error_mark_node;

      /* In Objective-C++, an instance variable (ivar) may be preferred
         to whatever cp_parser_lookup_name() found.  */
      decl = objc_lookup_ivar (decl, id_expression);

      /* If name lookup gives us a SCOPE_REF, then the
         qualifying scope was dependent.  */
      if (TREE_CODE (decl) == SCOPE_REF)
        return decl;
      /* Check to see if DECL is a local variable in a context
         where that is forbidden.  */
      if (parser->local_variables_forbidden_p
    && local_variable_p (decl))
        {
    /* It might be that we only found DECL because we are
       trying to be generous with pre-ISO scoping rules.
       For example, consider:

         int i;
         void g() {
           for (int i = 0; i < 10; ++i) {}
           extern void f(int j = i);
         }

       Here, name look up will originally find the out
       of scope `i'.  We need to issue a warning message,
       but then use the global `i'.  */
    decl = check_for_out_of_scope_variable (decl);
    if (local_variable_p (decl))
      {
        error ("local variable %qD may not appear in this context",
         decl);
        return error_mark_node;
      }
        }
    }

  decl = (finish_id_expression
    (id_expression, decl, parser->scope,
     idk,
     parser->integral_constant_expression_p,
     parser->allow_non_integral_constant_expression_p,
     &parser->non_integral_constant_expression_p,
     template_p, done, address_p,
     template_arg_p,
     &error_msg));
  if (error_msg)
    cp_parser_error (parser, error_msg);
  return decl;
      }

      /* Anything else is an error.  */
    default:
      /* ...unless we have an Objective-C++ message or string literal, that is.  */
      if (c_dialect_objc ()
    && (token->type == CPP_OPEN_SQUARE || token->type == CPP_OBJC_STRING))
  return cp_parser_objc_expression (parser);

      cp_parser_error (parser, "expected primary-expression");
      return error_mark_node;
    }
}

/* Parse an id-expression.

   id-expression:
     unqualified-id
     qualified-id

   qualified-id:
     :: [opt] nested-name-specifier template [opt] unqualified-id
     :: identifier
     :: operator-function-id
     :: template-id

   Return a representation of the unqualified portion of the
   identifier.  Sets PARSER->SCOPE to the qualifying scope if there is
   a `::' or nested-name-specifier.

   Often, if the id-expression was a qualified-id, the caller will
   want to make a SCOPE_REF to represent the qualified-id.  This
   function does not do this in order to avoid wastefully creating
   SCOPE_REFs when they are not required.

   If TEMPLATE_KEYWORD_P is true, then we have just seen the
   `template' keyword.

   If CHECK_DEPENDENCY_P is false, then names are looked up inside
   uninstantiated templates.

   If *TEMPLATE_P is non-NULL, it is set to true iff the
   `template' keyword is used to explicitly indicate that the entity
   named is a template.

   If DECLARATOR_P is true, the id-expression is appearing as part of
   a declarator, rather than as part of an expression.  */

static tree
cp_parser_id_expression (cp_parser *parser,
       bool template_keyword_p,
       bool check_dependency_p,
       bool *template_p,
       bool declarator_p,
       bool optional_p)
{
  bool global_scope_p;
  bool nested_name_specifier_p;

  /* Assume the `template' keyword was not used.  */
  if (template_p)
    *template_p = template_keyword_p;

  /* Look for the optional `::' operator.  */
  global_scope_p
    = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)
       != NULL_TREE);
  /* Look for the optional nested-name-specifier.  */
  nested_name_specifier_p
    = (cp_parser_nested_name_specifier_opt (parser,
              /*typename_keyword_p=*/false,
              check_dependency_p,
              /*type_p=*/false,
              declarator_p)
       != NULL_TREE);
  /* If there is a nested-name-specifier, then we are looking at
     the first qualified-id production.  */
  if (nested_name_specifier_p)
    {
      tree saved_scope;
      tree saved_object_scope;
      tree saved_qualifying_scope;
      tree unqualified_id;
      bool is_template;

      /* See if the next token is the `template' keyword.  */
      if (!template_p)
  template_p = &is_template;
      *template_p = cp_parser_optional_template_keyword (parser);
      /* Name lookup we do during the processing of the
   unqualified-id might obliterate SCOPE.  */
      saved_scope = parser->scope;
      saved_object_scope = parser->object_scope;
      saved_qualifying_scope = parser->qualifying_scope;
      /* Process the final unqualified-id.  */
      unqualified_id = cp_parser_unqualified_id (parser, *template_p,
             check_dependency_p,
             declarator_p,
             /*optional_p=*/false);
      /* Restore the SAVED_SCOPE for our caller.  */
      parser->scope = saved_scope;
      parser->object_scope = saved_object_scope;
      parser->qualifying_scope = saved_qualifying_scope;

      return unqualified_id;
    }
  /* Otherwise, if we are in global scope, then we are looking at one
     of the other qualified-id productions.  */
  else if (global_scope_p)
    {
      cp_token *token;
      tree id;

      /* Peek at the next token.  */
      token = cp_lexer_peek_token (parser->lexer);

      /* If it's an identifier, and the next token is not a "<", then
   we can avoid the template-id case.  This is an optimization
   for this common case.  */
      if (token->type == CPP_NAME
    && !cp_parser_nth_token_starts_template_argument_list_p
         (parser, 2))
  return cp_parser_identifier (parser);

      cp_parser_parse_tentatively (parser);
      /* Try a template-id.  */
      id = cp_parser_template_id (parser,
          /*template_keyword_p=*/false,
          /*check_dependency_p=*/true,
          declarator_p);
      /* If that worked, we're done.  */
      if (cp_parser_parse_definitely (parser))
  return id;

      /* Peek at the next token.  (Changes in the token buffer may
   have invalidated the pointer obtained above.)  */
      token = cp_lexer_peek_token (parser->lexer);

      switch (token->type)
  {
  case CPP_NAME:
    return cp_parser_identifier (parser);

  case CPP_KEYWORD:
    if (token->keyword == RID_OPERATOR)
      return cp_parser_operator_function_id (parser);
    /* Fall through.  */

  default:
    cp_parser_error (parser, "expected id-expression");
    return error_mark_node;
  }
    }
  else
    return cp_parser_unqualified_id (parser, template_keyword_p,
             /*check_dependency_p=*/true,
             declarator_p,
             optional_p);
}

/* Parse an unqualified-id.

   unqualified-id:
     identifier
     operator-function-id
     conversion-function-id
     ~ class-name
     template-id

   If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
   keyword, in a construct like `A::template ...'.

   Returns a representation of unqualified-id.  For the `identifier'
   production, an IDENTIFIER_NODE is returned.  For the `~ class-name'
   production a BIT_NOT_EXPR is returned; the operand of the
   BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name.  For the
   other productions, see the documentation accompanying the
   corresponding parsing functions.  If CHECK_DEPENDENCY_P is false,
   names are looked up in uninstantiated templates.  If DECLARATOR_P
   is true, the unqualified-id is appearing as part of a declarator,
   rather than as part of an expression.  */

static tree
cp_parser_unqualified_id (cp_parser* parser,
        bool template_keyword_p,
        bool check_dependency_p,
        bool declarator_p,
        bool optional_p)
{
  cp_token *token;

  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);

  switch (token->type)
    {
    case CPP_NAME:
      {
  tree id;

  /* We don't know yet whether or not this will be a
     template-id.  */
  cp_parser_parse_tentatively (parser);
  /* Try a template-id.  */
  id = cp_parser_template_id (parser, template_keyword_p,
            check_dependency_p,
            declarator_p);
  /* If it worked, we're done.  */
  if (cp_parser_parse_definitely (parser))
    return id;
  /* Otherwise, it's an ordinary identifier.  */
  return cp_parser_identifier (parser);
      }

    case CPP_TEMPLATE_ID:
      return cp_parser_template_id (parser, template_keyword_p,
            check_dependency_p,
            declarator_p);

    case CPP_COMPL:
      {
  tree type_decl;
  tree qualifying_scope;
  tree object_scope;
  tree scope;
  bool done;

  /* Consume the `~' token.  */
  cp_lexer_consume_token (parser->lexer);
  /* Parse the class-name.  The standard, as written, seems to
     say that:

       template <typename T> struct S { ~S (); };
       template <typename T> S<T>::~S() {}

     is invalid, since `~' must be followed by a class-name, but
     `S<T>' is dependent, and so not known to be a class.
     That's not right; we need to look in uninstantiated
     templates.  A further complication arises from:

       template <typename T> void f(T t) {
         t.T::~T();
       }

     Here, it is not possible to look up `T' in the scope of `T'
     itself.  We must look in both the current scope, and the
     scope of the containing complete expression.

     Yet another issue is:

       struct S {
         int S;
         ~S();
       };

       S::~S() {}

     The standard does not seem to say that the `S' in `~S'
     should refer to the type `S' and not the data member
     `S::S'.  */

  /* DR 244 says that we look up the name after the "~" in the
     same scope as we looked up the qualifying name.  That idea
     isn't fully worked out; it's more complicated than that.  */
  scope = parser->scope;
  object_scope = parser->object_scope;
  qualifying_scope = parser->qualifying_scope;

  /* Check for invalid scopes.  */
  if (scope == error_mark_node)
    {
      if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
        cp_lexer_consume_token (parser->lexer);
      return error_mark_node;
    }
  if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
    {
      if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
        error ("scope %qT before %<~%> is not a class-name", scope);
      cp_parser_simulate_error (parser);
      if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
        cp_lexer_consume_token (parser->lexer);
      return error_mark_node;
    }
  gcc_assert (!scope || TYPE_P (scope));

  /* If the name is of the form "X::~X" it's OK.  */
  token = cp_lexer_peek_token (parser->lexer);
  if (scope
      && token->type == CPP_NAME
      && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
    == CPP_OPEN_PAREN)
      && constructor_name_p (token->u.value, scope))
    {
      cp_lexer_consume_token (parser->lexer);
      return build_nt (BIT_NOT_EXPR, scope);
    }

  /* If there was an explicit qualification (S::~T), first look
     in the scope given by the qualification (i.e., S).  */
  done = false;
  type_decl = NULL_TREE;
  if (scope)
    {
      cp_parser_parse_tentatively (parser);
      type_decl = cp_parser_class_name (parser,
                /*typename_keyword_p=*/false,
                /*template_keyword_p=*/false,
                none_type,
                /*check_dependency=*/false,
                /*class_head_p=*/false,
                declarator_p);
      if (cp_parser_parse_definitely (parser))
        done = true;
    }
  /* In "N::S::~S", look in "N" as well.  */
  if (!done && scope && qualifying_scope)
    {
      cp_parser_parse_tentatively (parser);
      parser->scope = qualifying_scope;
      parser->object_scope = NULL_TREE;
      parser->qualifying_scope = NULL_TREE;
      type_decl
        = cp_parser_class_name (parser,
              /*typename_keyword_p=*/false,
              /*template_keyword_p=*/false,
              none_type,
              /*check_dependency=*/false,
              /*class_head_p=*/false,
              declarator_p);
      if (cp_parser_parse_definitely (parser))
        done = true;
    }
  /* In "p->S::~T", look in the scope given by "*p" as well.  */
  else if (!done && object_scope)
    {
      cp_parser_parse_tentatively (parser);
      parser->scope = object_scope;
      parser->object_scope = NULL_TREE;
      parser->qualifying_scope = NULL_TREE;
      type_decl
        = cp_parser_class_name (parser,
              /*typename_keyword_p=*/false,
              /*template_keyword_p=*/false,
              none_type,
              /*check_dependency=*/false,
              /*class_head_p=*/false,
              declarator_p);
      if (cp_parser_parse_definitely (parser))
        done = true;
    }
  /* Look in the surrounding context.  */
  if (!done)
    {
      parser->scope = NULL_TREE;
      parser->object_scope = NULL_TREE;
      parser->qualifying_scope = NULL_TREE;
      type_decl
        = cp_parser_class_name (parser,
              /*typename_keyword_p=*/false,
              /*template_keyword_p=*/false,
              none_type,
              /*check_dependency=*/false,
              /*class_head_p=*/false,
              declarator_p);
    }
  /* If an error occurred, assume that the name of the
     destructor is the same as the name of the qualifying
     class.  That allows us to keep parsing after running
     into ill-formed destructor names.  */
  if (type_decl == error_mark_node && scope)
    return build_nt (BIT_NOT_EXPR, scope);
  else if (type_decl == error_mark_node)
    return error_mark_node;

  /* Check that destructor name and scope match.  */
  if (declarator_p && scope && !check_dtor_name (scope, type_decl))
    {
      if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
        error ("declaration of %<~%T%> as member of %qT",
         type_decl, scope);
      cp_parser_simulate_error (parser);
      return error_mark_node;
    }

  /* [class.dtor]

     A typedef-name that names a class shall not be used as the
     identifier in the declarator for a destructor declaration.  */
  if (declarator_p
      && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
      && !DECL_SELF_REFERENCE_P (type_decl)
      && !cp_parser_uncommitted_to_tentative_parse_p (parser))
    error ("typedef-name %qD used as destructor declarator",
     type_decl);

  return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
      }

    case CPP_KEYWORD:
      if (token->keyword == RID_OPERATOR)
  {
    tree id;

    /* This could be a template-id, so we try that first.  */
    cp_parser_parse_tentatively (parser);
    /* Try a template-id.  */
    id = cp_parser_template_id (parser, template_keyword_p,
              /*check_dependency_p=*/true,
              declarator_p);
    /* If that worked, we're done.  */
    if (cp_parser_parse_definitely (parser))
      return id;
    /* We still don't know whether we're looking at an
       operator-function-id or a conversion-function-id.  */
    cp_parser_parse_tentatively (parser);
    /* Try an operator-function-id.  */
    id = cp_parser_operator_function_id (parser);
    /* If that didn't work, try a conversion-function-id.  */
    if (!cp_parser_parse_definitely (parser))
      id = cp_parser_conversion_function_id (parser);

    return id;
  }
      /* Fall through.  */

    default:
      if (optional_p)
  return NULL_TREE;
      cp_parser_error (parser, "expected unqualified-id");
      return error_mark_node;
    }
}

/* Parse an (optional) nested-name-specifier.

   nested-name-specifier:
     class-or-namespace-name :: nested-name-specifier [opt]
     class-or-namespace-name :: template nested-name-specifier [opt]

   PARSER->SCOPE should be set appropriately before this function is
   called.  TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
   effect.  TYPE_P is TRUE if we non-type bindings should be ignored
   in name lookups.

   Sets PARSER->SCOPE to the class (TYPE) or namespace
   (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
   it unchanged if there is no nested-name-specifier.  Returns the new
   scope iff there is a nested-name-specifier, or NULL_TREE otherwise.

   If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
   part of a declaration and/or decl-specifier.  */

static tree
cp_parser_nested_name_specifier_opt (cp_parser *parser,
             bool typename_keyword_p,
             bool check_dependency_p,
             bool type_p,
             bool is_declaration)
{
  bool success = false;
  cp_token_position start = 0;
  cp_token *token;

  /* Remember where the nested-name-specifier starts.  */
  if (cp_parser_uncommitted_to_tentative_parse_p (parser))
    {
      start = cp_lexer_token_position (parser->lexer, false);
      push_deferring_access_checks (dk_deferred);
    }

  while (true)
    {
      tree new_scope;
      tree old_scope;
      tree saved_qualifying_scope;
      bool template_keyword_p;

      /* Spot cases that cannot be the beginning of a
   nested-name-specifier.  */
      token = cp_lexer_peek_token (parser->lexer);

      /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
   the already parsed nested-name-specifier.  */
      if (token->type == CPP_NESTED_NAME_SPECIFIER)
  {
    /* Grab the nested-name-specifier and continue the loop.  */
    cp_parser_pre_parsed_nested_name_specifier (parser);
    /* If we originally encountered this nested-name-specifier
       with IS_DECLARATION set to false, we will not have
       resolved TYPENAME_TYPEs, so we must do so here.  */
    if (is_declaration
        && TREE_CODE (parser->scope) == TYPENAME_TYPE)
      {
        new_scope = resolve_typename_type (parser->scope,
             /*only_current_p=*/false);
        if (new_scope != error_mark_node)
    parser->scope = new_scope;
      }
    success = true;
    continue;
  }

      /* Spot cases that cannot be the beginning of a
   nested-name-specifier.  On the second and subsequent times
   through the loop, we look for the `template' keyword.  */
      if (success && token->keyword == RID_TEMPLATE)
  ;
      /* A template-id can start a nested-name-specifier.  */
      else if (token->type == CPP_TEMPLATE_ID)
  ;
      else
  {
    /* If the next token is not an identifier, then it is
       definitely not a class-or-namespace-name.  */
    if (token->type != CPP_NAME)
      break;
    /* If the following token is neither a `<' (to begin a
       template-id), nor a `::', then we are not looking at a
       nested-name-specifier.  */
    token = cp_lexer_peek_nth_token (parser->lexer, 2);
    if (token->type != CPP_SCOPE
        && !cp_parser_nth_token_starts_template_argument_list_p
      (parser, 2))
      break;
  }

      /* The nested-name-specifier is optional, so we parse
   tentatively.  */
      cp_parser_parse_tentatively (parser);

      /* Look for the optional `template' keyword, if this isn't the
   first time through the loop.  */
      if (success)
  template_keyword_p = cp_parser_optional_template_keyword (parser);
      else
  template_keyword_p = false;

      /* Save the old scope since the name lookup we are about to do
   might destroy it.  */
      old_scope = parser->scope;
      saved_qualifying_scope = parser->qualifying_scope;
      /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
   look up names in "X<T>::I" in order to determine that "Y" is
   a template.  So, if we have a typename at this point, we make
   an effort to look through it.  */
      if (is_declaration
    && !typename_keyword_p
    && parser->scope
    && TREE_CODE (parser->scope) == TYPENAME_TYPE)
  parser->scope = resolve_typename_type (parser->scope,
                 /*only_current_p=*/false);
      /* Parse the qualifying entity.  */
      new_scope
  = cp_parser_class_or_namespace_name (parser,
               typename_keyword_p,
               template_keyword_p,
               check_dependency_p,
               type_p,
               is_declaration);
      /* Look for the `::' token.  */
      cp_parser_require (parser, CPP_SCOPE, "`::'");

      /* If we found what we wanted, we keep going; otherwise, we're
   done.  */
      if (!cp_parser_parse_definitely (parser))
  {
    bool error_p = false;

    /* Restore the OLD_SCOPE since it was valid before the
       failed attempt at finding the last
       class-or-namespace-name.  */
    parser->scope = old_scope;
    parser->qualifying_scope = saved_qualifying_scope;
    if (cp_parser_uncommitted_to_tentative_parse_p (parser))
      break;
    /* If the next token is an identifier, and the one after
       that is a `::', then any valid interpretation would have
       found a class-or-namespace-name.  */
    while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
     && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
         == CPP_SCOPE)
     && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
         != CPP_COMPL))
      {
        token = cp_lexer_consume_token (parser->lexer);
        if (!error_p)
    {
      if (!token->ambiguous_p)
        {
          tree decl;
          tree ambiguous_decls;

          decl = cp_parser_lookup_name (parser, token->u.value,
                none_type,
                /*is_template=*/false,
                /*is_namespace=*/false,
                /*check_dependency=*/true,
                &ambiguous_decls);
          if (TREE_CODE (decl) == TEMPLATE_DECL)
      error ("%qD used without template parameters", decl);
          else if (ambiguous_decls)
      {
        error ("reference to %qD is ambiguous",
         token->u.value);
        print_candidates (ambiguous_decls);
        decl = error_mark_node;
      }
          else
      cp_parser_name_lookup_error
        (parser, token->u.value, decl,
         "is not a class or namespace");
        }
      parser->scope = error_mark_node;
      error_p = true;
      /* Treat this as a successful nested-name-specifier
         due to:

         [basic.lookup.qual]

         If the name found is not a class-name (clause
         _class_) or namespace-name (_namespace.def_), the
         program is ill-formed.  */
      success = true;
    }
        cp_lexer_consume_token (parser->lexer);
      }
    break;
  }
      /* We've found one valid nested-name-specifier.  */
      success = true;
      /* Name lookup always gives us a DECL.  */
      if (TREE_CODE (new_scope) == TYPE_DECL)
  new_scope = TREE_TYPE (new_scope);
      /* Uses of "template" must be followed by actual templates.  */
      if (template_keyword_p
    && !(CLASS_TYPE_P (new_scope)
         && ((CLASSTYPE_USE_TEMPLATE (new_scope)
        && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
       || CLASSTYPE_IS_TEMPLATE (new_scope)))
    && !(TREE_CODE (new_scope) == TYPENAME_TYPE
         && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
       == TEMPLATE_ID_EXPR)))
  pedwarn (TYPE_P (new_scope)
     ? "%qT is not a template"
     : "%qD is not a template",
     new_scope);
      /* If it is a class scope, try to complete it; we are about to
   be looking up names inside the class.  */
      if (TYPE_P (new_scope)
    /* Since checking types for dependency can be expensive,
       avoid doing it if the type is already complete.  */
    && !COMPLETE_TYPE_P (new_scope)
    /* Do not try to complete dependent types.  */
    && !dependent_type_p (new_scope))
  new_scope = complete_type (new_scope);
      /* Make sure we look in the right scope the next time through
   the loop.  */
      parser->scope = new_scope;
    }

  /* If parsing tentatively, replace the sequence of tokens that makes
     up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
     token.  That way, should we re-parse the token stream, we will
     not have to repeat the effort required to do the parse, nor will
     we issue duplicate error messages.  */
  if (success && start)
    {
      cp_token *token;

      token = cp_lexer_token_at (parser->lexer, start);
      /* Reset the contents of the START token.  */
      token->type = CPP_NESTED_NAME_SPECIFIER;
      /* Retrieve any deferred checks.  Do not pop this access checks yet
   so the memory will not be reclaimed during token replacing below.  */
      token->u.tree_check_value = GGC_CNEW (struct tree_check);
      token->u.tree_check_value->value = parser->scope;
      token->u.tree_check_value->checks = get_deferred_access_checks ();
      token->u.tree_check_value->qualifying_scope =
  parser->qualifying_scope;
      token->keyword = RID_MAX;

      /* Purge all subsequent tokens.  */
      cp_lexer_purge_tokens_after (parser->lexer, start);
    }

  if (start)
    pop_to_parent_deferring_access_checks ();

  return success ? parser->scope : NULL_TREE;
}

/* Parse a nested-name-specifier.  See
   cp_parser_nested_name_specifier_opt for details.  This function
   behaves identically, except that it will an issue an error if no
   nested-name-specifier is present.  */

static tree
cp_parser_nested_name_specifier (cp_parser *parser,
         bool typename_keyword_p,
         bool check_dependency_p,
         bool type_p,
         bool is_declaration)
{
  tree scope;

  /* Look for the nested-name-specifier.  */
  scope = cp_parser_nested_name_specifier_opt (parser,
                 typename_keyword_p,
                 check_dependency_p,
                 type_p,
                 is_declaration);
  /* If it was not present, issue an error message.  */
  if (!scope)
    {
      cp_parser_error (parser, "expected nested-name-specifier");
      parser->scope = NULL_TREE;
    }

  return scope;
}

/* Parse a class-or-namespace-name.

   class-or-namespace-name:
     class-name
     namespace-name

   TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
   TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
   CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
   TYPE_P is TRUE iff the next name should be taken as a class-name,
   even the same name is declared to be another entity in the same
   scope.

   Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
   specified by the class-or-namespace-name.  If neither is found the
   ERROR_MARK_NODE is returned.  */

static tree
cp_parser_class_or_namespace_name (cp_parser *parser,
           bool typename_keyword_p,
           bool template_keyword_p,
           bool check_dependency_p,
           bool type_p,
           bool is_declaration)
{
  tree saved_scope;
  tree saved_qualifying_scope;
  tree saved_object_scope;
  tree scope;
  bool only_class_p;

  /* Before we try to parse the class-name, we must save away the
     current PARSER->SCOPE since cp_parser_class_name will destroy
     it.  */
  saved_scope = parser->scope;
  saved_qualifying_scope = parser->qualifying_scope;
  saved_object_scope = parser->object_scope;
  /* Try for a class-name first.  If the SAVED_SCOPE is a type, then
     there is no need to look for a namespace-name.  */
  only_class_p = template_keyword_p || (saved_scope && TYPE_P (saved_scope));
  if (!only_class_p)
    cp_parser_parse_tentatively (parser);
  scope = cp_parser_class_name (parser,
        typename_keyword_p,
        template_keyword_p,
        type_p ? class_type : none_type,
        check_dependency_p,
        /*class_head_p=*/false,
        is_declaration);
  /* If that didn't work, try for a namespace-name.  */
  if (!only_class_p && !cp_parser_parse_definitely (parser))
    {
      /* Restore the saved scope.  */
      parser->scope = saved_scope;
      parser->qualifying_scope = saved_qualifying_scope;
      parser->object_scope = saved_object_scope;
      /* If we are not looking at an identifier followed by the scope
   resolution operator, then this is not part of a
   nested-name-specifier.  (Note that this function is only used
   to parse the components of a nested-name-specifier.)  */
      if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
    || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
  return error_mark_node;
      scope = cp_parser_namespace_name (parser);
    }

  return scope;
}

/* Parse a postfix-expression.

   postfix-expression:
     primary-expression
     postfix-expression [ expression ]
     postfix-expression ( expression-list [opt] )
     simple-type-specifier ( expression-list [opt] )
     typename :: [opt] nested-name-specifier identifier
       ( expression-list [opt] )
     typename :: [opt] nested-name-specifier template [opt] template-id
       ( expression-list [opt] )
     postfix-expression . template [opt] id-expression
     postfix-expression -> template [opt] id-expression
     postfix-expression . pseudo-destructor-name
     postfix-expression -> pseudo-destructor-name
     postfix-expression ++
     postfix-expression --
     dynamic_cast < type-id > ( expression )
     static_cast < type-id > ( expression )
     reinterpret_cast < type-id > ( expression )
     const_cast < type-id > ( expression )
     typeid ( expression )
     typeid ( type-id )

   GNU Extension:

   postfix-expression:
     ( type-id ) { initializer-list , [opt] }

   This extension is a GNU version of the C99 compound-literal
   construct.  (The C99 grammar uses `type-name' instead of `type-id',
   but they are essentially the same concept.)

   If ADDRESS_P is true, the postfix expression is the operand of the
   `&' operator.  CAST_P is true if this expression is the target of a
   cast.

   Returns a representation of the expression.  */

static tree
cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p)
{
  cp_token *token;
  enum rid keyword;
  cp_id_kind idk = CP_ID_KIND_NONE;
  tree postfix_expression = NULL_TREE;

  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);
  /* Some of the productions are determined by keywords.  */
  keyword = token->keyword;
  switch (keyword)
    {
    case RID_DYNCAST:
    case RID_STATCAST:
    case RID_REINTCAST:
    case RID_CONSTCAST:
      {
  tree type;
  tree expression;
  const char *saved_message;

  /* All of these can be handled in the same way from the point
     of view of parsing.  Begin by consuming the token
     identifying the cast.  */
  cp_lexer_consume_token (parser->lexer);

  /* New types cannot be defined in the cast.  */
  saved_message = parser->type_definition_forbidden_message;
  parser->type_definition_forbidden_message
    = "types may not be defined in casts";

  /* Look for the opening `<'.  */
  cp_parser_require (parser, CPP_LESS, "`<'");
  /* Parse the type to which we are casting.  */
  type = cp_parser_type_id (parser);
  /* Look for the closing `>'.  */
  cp_parser_require (parser, CPP_GREATER, "`>'");
  /* Restore the old message.  */
  parser->type_definition_forbidden_message = saved_message;

  /* And the expression which is being cast.  */
  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
  expression = cp_parser_expression (parser, /*cast_p=*/true);
  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

  /* Only type conversions to integral or enumeration types
     can be used in constant-expressions.  */
  if (!cast_valid_in_integral_constant_expression_p (type)
      && (cp_parser_non_integral_constant_expression
    (parser,
     "a cast to a type other than an integral or "
     "enumeration type")))
    return error_mark_node;

  switch (keyword)
    {
    case RID_DYNCAST:
      postfix_expression
        = build_dynamic_cast (type, expression);
      break;
    case RID_STATCAST:
      postfix_expression
        = build_static_cast (type, expression);
      break;
    case RID_REINTCAST:
      postfix_expression
        = build_reinterpret_cast (type, expression);
      break;
    case RID_CONSTCAST:
      postfix_expression
        = build_const_cast (type, expression);
      break;
    default:
      gcc_unreachable ();
    }
      }
      break;

    case RID_TYPEID:
      {
  tree type;
  const char *saved_message;
  bool saved_in_type_id_in_expr_p;

  /* Consume the `typeid' token.  */
  cp_lexer_consume_token (parser->lexer);
  /* Look for the `(' token.  */
  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
  /* Types cannot be defined in a `typeid' expression.  */
  saved_message = parser->type_definition_forbidden_message;
  parser->type_definition_forbidden_message
    = "types may not be defined in a `typeid\' expression";
  /* We can't be sure yet whether we're looking at a type-id or an
     expression.  */
  cp_parser_parse_tentatively (parser);
  /* Try a type-id first.  */
  saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
  parser->in_type_id_in_expr_p = true;
  type = cp_parser_type_id (parser);
  parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
  /* Look for the `)' token.  Otherwise, we can't be sure that
     we're not looking at an expression: consider `typeid (int
     (3))', for example.  */
  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
  /* If all went well, simply lookup the type-id.  */
  if (cp_parser_parse_definitely (parser))
    postfix_expression = get_typeid (type);
  /* Otherwise, fall back to the expression variant.  */
  else
    {
      tree expression;

      /* Look for an expression.  */
      expression = cp_parser_expression (parser, /*cast_p=*/false);
      /* Compute its typeid.  */
      postfix_expression = build_typeid (expression);
      /* Look for the `)' token.  */
      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
    }
  /* Restore the saved message.  */
  parser->type_definition_forbidden_message = saved_message;
  /* `typeid' may not appear in an integral constant expression.  */
  if (cp_parser_non_integral_constant_expression(parser,
                   "`typeid' operator"))
    return error_mark_node;
      }
      break;

    case RID_TYPENAME:
      {
  tree type;
  /* The syntax permitted here is the same permitted for an
     elaborated-type-specifier.  */
  type = cp_parser_elaborated_type_specifier (parser,
                /*is_friend=*/false,
                /*is_declaration=*/false);
  postfix_expression = cp_parser_functional_cast (parser, type);
      }
      break;

    default:
      {
  tree type;

  /* If the next thing is a simple-type-specifier, we may be
     looking at a functional cast.  We could also be looking at
     an id-expression.  So, we try the functional cast, and if
     that doesn't work we fall back to the primary-expression.  */
  cp_parser_parse_tentatively (parser);
  /* Look for the simple-type-specifier.  */
  type = cp_parser_simple_type_specifier (parser,
            /*decl_specs=*/NULL,
            CP_PARSER_FLAGS_NONE);
  /* Parse the cast itself.  */
  if (!cp_parser_error_occurred (parser))
    postfix_expression
      = cp_parser_functional_cast (parser, type);
  /* If that worked, we're done.  */
  if (cp_parser_parse_definitely (parser))
    break;

  /* If the functional-cast didn't work out, try a
     compound-literal.  */
  if (cp_parser_allow_gnu_extensions_p (parser)
      && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
    {
      VEC(constructor_elt,gc) *initializer_list = NULL;
      bool saved_in_type_id_in_expr_p;

      cp_parser_parse_tentatively (parser);
      /* Consume the `('.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the type.  */
      saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
      parser->in_type_id_in_expr_p = true;
      type = cp_parser_type_id (parser);
      parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
      /* Look for the `)'.  */
      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
      /* Look for the `{'.  */
      cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
      /* If things aren't going well, there's no need to
         keep going.  */
      if (!cp_parser_error_occurred (parser))
        {
    bool non_constant_p;
    /* Parse the initializer-list.  */
    initializer_list
      = cp_parser_initializer_list (parser, &non_constant_p);
    /* Allow a trailing `,'.  */
    if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
      cp_lexer_consume_token (parser->lexer);
    /* Look for the final `}'.  */
    cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
        }
      /* If that worked, we're definitely looking at a
         compound-literal expression.  */
      if (cp_parser_parse_definitely (parser))
        {
    /* Warn the user that a compound literal is not
       allowed in standard C++.  */
    if (pedantic)
      pedwarn ("ISO C++ forbids compound-literals");
    /* For simplicitly, we disallow compound literals in
       constant-expressions for simpliicitly.  We could
       allow compound literals of integer type, whose
       initializer was a constant, in constant
       expressions.  Permitting that usage, as a further
       extension, would not change the meaning of any
       currently accepted programs.  (Of course, as
       compound literals are not part of ISO C++, the
       standard has nothing to say.)  */
    if (cp_parser_non_integral_constant_expression 
        (parser, "non-constant compound literals"))
      {
        postfix_expression = error_mark_node;
        break;
      }
    /* Form the representation of the compound-literal.  */
    postfix_expression
      = finish_compound_literal (type, initializer_list);
    break;
        }
    }

  /* It must be a primary-expression.  */
  postfix_expression
    = cp_parser_primary_expression (parser, address_p, cast_p,
            /*template_arg_p=*/false,
            &idk);
      }
      break;
    }

  /* Keep looping until the postfix-expression is complete.  */
  while (true)
    {
      if (idk == CP_ID_KIND_UNQUALIFIED
    && TREE_CODE (postfix_expression) == IDENTIFIER_NODE
    && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
  /* It is not a Koenig lookup function call.  */
  postfix_expression
    = unqualified_name_lookup_error (postfix_expression);

      /* Peek at the next token.  */
      token = cp_lexer_peek_token (parser->lexer);

      switch (token->type)
  {
  case CPP_OPEN_SQUARE:
    postfix_expression
      = cp_parser_postfix_open_square_expression (parser,
              postfix_expression,
              false);
    idk = CP_ID_KIND_NONE;
    break;

  case CPP_OPEN_PAREN:
    /* postfix-expression ( expression-list [opt] ) */
    {
      bool koenig_p;
      bool is_builtin_constant_p;
      bool saved_integral_constant_expression_p = false;
      bool saved_non_integral_constant_expression_p = false;
      tree args;

      is_builtin_constant_p
        = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression);
      if (is_builtin_constant_p)
        {
    /* The whole point of __builtin_constant_p is to allow
       non-constant expressions to appear as arguments.  */
    saved_integral_constant_expression_p
      = parser->integral_constant_expression_p;
    saved_non_integral_constant_expression_p
      = parser->non_integral_constant_expression_p;
    parser->integral_constant_expression_p = false;
        }
      args = (cp_parser_parenthesized_expression_list
        (parser, /*is_attribute_list=*/false,
         /*cast_p=*/false,
         /*non_constant_p=*/NULL));
      if (is_builtin_constant_p)
        {
    parser->integral_constant_expression_p
      = saved_integral_constant_expression_p;
    parser->non_integral_constant_expression_p
      = saved_non_integral_constant_expression_p;
        }

      if (args == error_mark_node)
        {
    postfix_expression = error_mark_node;
    break;
        }

      /* Function calls are not permitted in
         constant-expressions.  */
      if (! builtin_valid_in_constant_expr_p (postfix_expression)
    && cp_parser_non_integral_constant_expression (parser,
                     "a function call"))
        {
    postfix_expression = error_mark_node;
    break;
        }

      koenig_p = false;
      if (idk == CP_ID_KIND_UNQUALIFIED)
        {
    if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
      {
        if (args)
          {
      koenig_p = true;
      postfix_expression
        = perform_koenig_lookup (postfix_expression, args);
          }
        else
          postfix_expression
      = unqualified_fn_lookup_error (postfix_expression);
      }
    /* We do not perform argument-dependent lookup if
       normal lookup finds a non-function, in accordance
       with the expected resolution of DR 218.  */
    else if (args && is_overloaded_fn (postfix_expression))
      {
        tree fn = get_first_fn (postfix_expression);

        if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
          fn = OVL_CURRENT (TREE_OPERAND (fn, 0));

        /* Only do argument dependent lookup if regular
           lookup does not find a set of member functions.
           [basic.lookup.koenig]/2a  */
        if (!DECL_FUNCTION_MEMBER_P (fn))
          {
      koenig_p = true;
      postfix_expression
        = perform_koenig_lookup (postfix_expression, args);
          }
      }
        }

      if (TREE_CODE (postfix_expression) == COMPONENT_REF)
        {
    tree instance = TREE_OPERAND (postfix_expression, 0);
    tree fn = TREE_OPERAND (postfix_expression, 1);

    if (processing_template_decl
        && (type_dependent_expression_p (instance)
      || (!BASELINK_P (fn)
          && TREE_CODE (fn) != FIELD_DECL)
      || type_dependent_expression_p (fn)
      || any_type_dependent_arguments_p (args)))
      {
        postfix_expression
          = build_min_nt (CALL_EXPR, postfix_expression,
              args, NULL_TREE);
        break;
      }

    if (BASELINK_P (fn))
      postfix_expression
        = (build_new_method_call
           (instance, fn, args, NULL_TREE,
      (idk == CP_ID_KIND_QUALIFIED
       ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL),
      /*fn_p=*/NULL));
    else
      postfix_expression
        = finish_call_expr (postfix_expression, args,
          /*disallow_virtual=*/false,
          /*koenig_p=*/false);
        }
      else if (TREE_CODE (postfix_expression) == OFFSET_REF
         || TREE_CODE (postfix_expression) == MEMBER_REF
         || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
        postfix_expression = (build_offset_ref_call_from_tree
            (postfix_expression, args));
      else if (idk == CP_ID_KIND_QUALIFIED)
        /* A call to a static class member, or a namespace-scope
     function.  */
        postfix_expression
    = finish_call_expr (postfix_expression, args,
            /*disallow_virtual=*/true,
            koenig_p);
      else
        /* All other function calls.  */
        postfix_expression
    = finish_call_expr (postfix_expression, args,
            /*disallow_virtual=*/false,
            koenig_p);

      /* The POSTFIX_EXPRESSION is certainly no longer an id.  */
      idk = CP_ID_KIND_NONE;
    }
    break;

  case CPP_DOT:
  case CPP_DEREF:
    /* postfix-expression . template [opt] id-expression
       postfix-expression . pseudo-destructor-name
       postfix-expression -> template [opt] id-expression
       postfix-expression -> pseudo-destructor-name */

    /* Consume the `.' or `->' operator.  */
    cp_lexer_consume_token (parser->lexer);

    postfix_expression
      = cp_parser_postfix_dot_deref_expression (parser, token->type,
                  postfix_expression,
                  false, &idk);
    break;

  case CPP_PLUS_PLUS:
    /* postfix-expression ++  */
    /* Consume the `++' token.  */
    cp_lexer_consume_token (parser->lexer);
    /* Generate a representation for the complete expression.  */
    postfix_expression
      = finish_increment_expr (postfix_expression,
             POSTINCREMENT_EXPR);
    /* Increments may not appear in constant-expressions.  */
    if (cp_parser_non_integral_constant_expression (parser,
                "an increment"))
      postfix_expression = error_mark_node;
    idk = CP_ID_KIND_NONE;
    break;

  case CPP_MINUS_MINUS:
    /* postfix-expression -- */
    /* Consume the `--' token.  */
    cp_lexer_consume_token (parser->lexer);
    /* Generate a representation for the complete expression.  */
    postfix_expression
      = finish_increment_expr (postfix_expression,
             POSTDECREMENT_EXPR);
    /* Decrements may not appear in constant-expressions.  */
    if (cp_parser_non_integral_constant_expression (parser,
                "a decrement"))
      postfix_expression = error_mark_node;
    idk = CP_ID_KIND_NONE;
    break;

  default:
    return postfix_expression;
  }
    }

  /* We should never get here.  */
  gcc_unreachable ();
  return error_mark_node;
}

/* A subroutine of cp_parser_postfix_expression that also gets hijacked
   by cp_parser_builtin_offsetof.  We're looking for

     postfix-expression [ expression ]

   FOR_OFFSETOF is set if we're being called in that context, which
   changes how we deal with integer constant expressions.  */

static tree
cp_parser_postfix_open_square_expression (cp_parser *parser,
            tree postfix_expression,
            bool for_offsetof)
{
  tree index;

  /* Consume the `[' token.  */
  cp_lexer_consume_token (parser->lexer);

  /* Parse the index expression.  */
  /* ??? For offsetof, there is a question of what to allow here.  If
     offsetof is not being used in an integral constant expression context,
     then we *could* get the right answer by computing the value at runtime.
     If we are in an integral constant expression context, then we might
     could accept any constant expression; hard to say without analysis.
     Rather than open the barn door too wide right away, allow only integer
     constant expressions here.  */
  if (for_offsetof)
    index = cp_parser_constant_expression (parser, false, NULL);
  else
    index = cp_parser_expression (parser, /*cast_p=*/false);

  /* Look for the closing `]'.  */
  cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");

  /* Build the ARRAY_REF.  */
  postfix_expression = grok_array_decl (postfix_expression, index);

  /* When not doing offsetof, array references are not permitted in
     constant-expressions.  */
  if (!for_offsetof
      && (cp_parser_non_integral_constant_expression
    (parser, "an array reference")))
    postfix_expression = error_mark_node;

  return postfix_expression;
}

/* A subroutine of cp_parser_postfix_expression that also gets hijacked
   by cp_parser_builtin_offsetof.  We're looking for

     postfix-expression . template [opt] id-expression
     postfix-expression . pseudo-destructor-name
     postfix-expression -> template [opt] id-expression
     postfix-expression -> pseudo-destructor-name

   FOR_OFFSETOF is set if we're being called in that context.  That sorta
   limits what of the above we'll actually accept, but nevermind.
   TOKEN_TYPE is the "." or "->" token, which will already have been
   removed from the stream.  */

static tree
cp_parser_postfix_dot_deref_expression (cp_parser *parser,
          enum cpp_ttype token_type,
          tree postfix_expression,
          bool for_offsetof, cp_id_kind *idk)
{
  tree name;
  bool dependent_p;
  bool pseudo_destructor_p;
  tree scope = NULL_TREE;

  /* If this is a `->' operator, dereference the pointer.  */
  if (token_type == CPP_DEREF)
    postfix_expression = build_x_arrow (postfix_expression);
  /* Check to see whether or not the expression is type-dependent.  */
  dependent_p = type_dependent_expression_p (postfix_expression);
  /* The identifier following the `->' or `.' is not qualified.  */
  parser->scope = NULL_TREE;
  parser->qualifying_scope = NULL_TREE;
  parser->object_scope = NULL_TREE;
  *idk = CP_ID_KIND_NONE;
  /* Enter the scope corresponding to the type of the object
     given by the POSTFIX_EXPRESSION.  */
  if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE)
    {
      scope = TREE_TYPE (postfix_expression);
      /* According to the standard, no expression should ever have
   reference type.  Unfortunately, we do not currently match
   the standard in this respect in that our internal representation
   of an expression may have reference type even when the standard
   says it does not.  Therefore, we have to manually obtain the
   underlying type here.  */
      scope = non_reference (scope);
      /* The type of the POSTFIX_EXPRESSION must be complete.  */
      if (scope == unknown_type_node)
  {
    error ("%qE does not have class type", postfix_expression);
    scope = NULL_TREE;
  }
      else
  scope = complete_type_or_else (scope, NULL_TREE);
      /* Let the name lookup machinery know that we are processing a
   class member access expression.  */
      parser->context->object_type = scope;
      /* If something went wrong, we want to be able to discern that case,
   as opposed to the case where there was no SCOPE due to the type
   of expression being dependent.  */
      if (!scope)
  scope = error_mark_node;
      /* If the SCOPE was erroneous, make the various semantic analysis
   functions exit quickly -- and without issuing additional error
   messages.  */
      if (scope == error_mark_node)
  postfix_expression = error_mark_node;
    }

  /* Assume this expression is not a pseudo-destructor access.  */
  pseudo_destructor_p = false;

  /* If the SCOPE is a scalar type, then, if this is a valid program,
     we must be looking at a pseudo-destructor-name.  */
  if (scope && SCALAR_TYPE_P (scope))
    {
      tree s;
      tree type;

      cp_parser_parse_tentatively (parser);
      /* Parse the pseudo-destructor-name.  */
      s = NULL_TREE;
      cp_parser_pseudo_destructor_name (parser, &s, &type);
      if (cp_parser_parse_definitely (parser))
  {
    pseudo_destructor_p = true;
    postfix_expression
      = finish_pseudo_destructor_expr (postfix_expression,
               s, TREE_TYPE (type));
  }
    }

  if (!pseudo_destructor_p)
    {
      /* If the SCOPE is not a scalar type, we are looking at an
   ordinary class member access expression, rather than a
   pseudo-destructor-name.  */
      bool template_p;
      /* Parse the id-expression.  */
      name = (cp_parser_id_expression
        (parser,
         cp_parser_optional_template_keyword (parser),
         /*check_dependency_p=*/true,
         &template_p,
         /*declarator_p=*/false,
         /*optional_p=*/false));
      /* In general, build a SCOPE_REF if the member name is qualified.
   However, if the name was not dependent and has already been
   resolved; there is no need to build the SCOPE_REF.  For example;

       struct X { void f(); };
       template <typename T> void f(T* t) { t->X::f(); }

   Even though "t" is dependent, "X::f" is not and has been resolved
   to a BASELINK; there is no need to include scope information.  */

      /* But we do need to remember that there was an explicit scope for
   virtual function calls.  */
      if (parser->scope)
  *idk = CP_ID_KIND_QUALIFIED;

      /* If the name is a template-id that names a type, we will get a
   TYPE_DECL here.  That is invalid code.  */
      if (TREE_CODE (name) == TYPE_DECL)
  {
    error ("invalid use of %qD", name);
    postfix_expression = error_mark_node;
  }
      else
  {
    if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
      {
        name = build_qualified_name (/*type=*/NULL_TREE,
             parser->scope,
             name,
             template_p);
        parser->scope = NULL_TREE;
        parser->qualifying_scope = NULL_TREE;
        parser->object_scope = NULL_TREE;
      }
    if (scope && name && BASELINK_P (name))
      adjust_result_of_qualified_name_lookup
        (name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope);
    postfix_expression
      = finish_class_member_access_expr (postfix_expression, name,
                 template_p);
  }
    }

  /* We no longer need to look up names in the scope of the object on
     the left-hand side of the `.' or `->' operator.  */
  parser->context->object_type = NULL_TREE;

  /* Outside of offsetof, these operators may not appear in
     constant-expressions.  */
  if (!for_offsetof
      && (cp_parser_non_integral_constant_expression
    (parser, token_type == CPP_DEREF ? "'->'" : "`.'")))
    postfix_expression = error_mark_node;

  return postfix_expression;
}

/* Parse a parenthesized expression-list.

   expression-list:
     assignment-expression
     expression-list, assignment-expression

   attribute-list:
     expression-list
     identifier
     identifier, expression-list

   CAST_P is true if this expression is the target of a cast.

   Returns a TREE_LIST.  The TREE_VALUE of each node is a
   representation of an assignment-expression.  Note that a TREE_LIST
   is returned even if there is only a single expression in the list.
   error_mark_node is returned if the ( and or ) are
   missing. NULL_TREE is returned on no expressions. The parentheses
   are eaten. IS_ATTRIBUTE_LIST is true if this is really an attribute
   list being parsed.  If NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P
   indicates whether or not all of the expressions in the list were
   constant.  */

static tree
cp_parser_parenthesized_expression_list (cp_parser* parser,
           bool is_attribute_list,
           bool cast_p,
           bool *non_constant_p)
{
  tree expression_list = NULL_TREE;
  bool fold_expr_p = is_attribute_list;
  tree identifier = NULL_TREE;

  /* Assume all the expressions will be constant.  */
  if (non_constant_p)
    *non_constant_p = false;

  if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
    return error_mark_node;

  /* Consume expressions until there are no more.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
    while (true)
      {
  tree expr;

  /* At the beginning of attribute lists, check to see if the
     next token is an identifier.  */
  if (is_attribute_list
      && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
    {
      cp_token *token;

      /* Consume the identifier.  */
      token = cp_lexer_consume_token (parser->lexer);
      /* Save the identifier.  */
      identifier = token->u.value;
    }
  else
    {
      /* Parse the next assignment-expression.  */
      if (non_constant_p)
        {
    bool expr_non_constant_p;
    expr = (cp_parser_constant_expression
      (parser, /*allow_non_constant_p=*/true,
       &expr_non_constant_p));
    if (expr_non_constant_p)
      *non_constant_p = true;
        }
      else
        expr = cp_parser_assignment_expression (parser, cast_p);

      if (fold_expr_p)
        expr = fold_non_dependent_expr (expr);

       /* Add it to the list.  We add error_mark_node
    expressions to the list, so that we can still tell if
    the correct form for a parenthesized expression-list
    is found. That gives better errors.  */
      expression_list = tree_cons (NULL_TREE, expr, expression_list);

      if (expr == error_mark_node)
        goto skip_comma;
    }

  /* After the first item, attribute lists look the same as
     expression lists.  */
  is_attribute_list = false;

      get_comma:;
  /* If the next token isn't a `,', then we are done.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
    break;

  /* Otherwise, consume the `,' and keep going.  */
  cp_lexer_consume_token (parser->lexer);
      }

  if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
    {
      int ending;

    skip_comma:;
      /* We try and resync to an unnested comma, as that will give the
   user better diagnostics.  */
      ending = cp_parser_skip_to_closing_parenthesis (parser,
                  /*recovering=*/true,
                  /*or_comma=*/true,
                  /*consume_paren=*/true);
      if (ending < 0)
  goto get_comma;
      if (!ending)
  return error_mark_node;
    }

  /* We built up the list in reverse order so we must reverse it now.  */
  expression_list = nreverse (expression_list);
  if (identifier)
    expression_list = tree_cons (NULL_TREE, identifier, expression_list);

  return expression_list;
}

/* Parse a pseudo-destructor-name.

   pseudo-destructor-name:
     :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
     :: [opt] nested-name-specifier template template-id :: ~ type-name
     :: [opt] nested-name-specifier [opt] ~ type-name

   If either of the first two productions is used, sets *SCOPE to the
   TYPE specified before the final `::'.  Otherwise, *SCOPE is set to
   NULL_TREE.  *TYPE is set to the TYPE_DECL for the final type-name,
   or ERROR_MARK_NODE if the parse fails.  */

static void
cp_parser_pseudo_destructor_name (cp_parser* parser,
          tree* scope,
          tree* type)
{
  bool nested_name_specifier_p;

  /* Assume that things will not work out.  */
  *type = error_mark_node;

  /* Look for the optional `::' operator.  */
  cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
  /* Look for the optional nested-name-specifier.  */
  nested_name_specifier_p
    = (cp_parser_nested_name_specifier_opt (parser,
              /*typename_keyword_p=*/false,
              /*check_dependency_p=*/true,
              /*type_p=*/false,
              /*is_declaration=*/true)
       != NULL_TREE);
  /* Now, if we saw a nested-name-specifier, we might be doing the
     second production.  */
  if (nested_name_specifier_p
      && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
    {
      /* Consume the `template' keyword.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the template-id.  */
      cp_parser_template_id (parser,
           /*template_keyword_p=*/true,
           /*check_dependency_p=*/false,
           /*is_declaration=*/true);
      /* Look for the `::' token.  */
      cp_parser_require (parser, CPP_SCOPE, "`::'");
    }
  /* If the next token is not a `~', then there might be some
     additional qualification.  */
  else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
    {
      /* Look for the type-name.  */
      *scope = TREE_TYPE (cp_parser_type_name (parser));

      if (*scope == error_mark_node)
  return;

      /* If we don't have ::~, then something has gone wrong.  Since
   the only caller of this function is looking for something
   after `.' or `->' after a scalar type, most likely the
   program is trying to get a member of a non-aggregate
   type.  */
      if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE)
    || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_COMPL)
  {
    cp_parser_error (parser, "request for member of non-aggregate type");
    return;
  }

      /* Look for the `::' token.  */
      cp_parser_require (parser, CPP_SCOPE, "`::'");
    }
  else
    *scope = NULL_TREE;

  /* Look for the `~'.  */
  cp_parser_require (parser, CPP_COMPL, "`~'");
  /* Look for the type-name again.  We are not responsible for
     checking that it matches the first type-name.  */
  *type = cp_parser_type_name (parser);
}

/* Parse a unary-expression.

   unary-expression:
     postfix-expression
     ++ cast-expression
     -- cast-expression
     unary-operator cast-expression
     sizeof unary-expression
     sizeof ( type-id )
     new-expression
     delete-expression

   GNU Extensions:

   unary-expression:
     __extension__ cast-expression
     __alignof__ unary-expression
     __alignof__ ( type-id )
     __real__ cast-expression
     __imag__ cast-expression
     && identifier

   ADDRESS_P is true iff the unary-expression is appearing as the
   operand of the `&' operator.   CAST_P is true if this expression is
   the target of a cast.

   Returns a representation of the expression.  */

static tree
cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p)
{
  cp_token *token;
  enum tree_code unary_operator;

  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);
  /* Some keywords give away the kind of expression.  */
  if (token->type == CPP_KEYWORD)
    {
      enum rid keyword = token->keyword;

      switch (keyword)
  {
  case RID_ALIGNOF:
  case RID_SIZEOF:
    {
      tree operand;
      enum tree_code op;

      op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
      /* Consume the token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the operand.  */
      operand = cp_parser_sizeof_operand (parser, keyword);

      if (TYPE_P (operand))
        return cxx_sizeof_or_alignof_type (operand, op, true);
      else
        return cxx_sizeof_or_alignof_expr (operand, op);
    }

  case RID_NEW:
    return cp_parser_new_expression (parser);

  case RID_DELETE:
    return cp_parser_delete_expression (parser);

  case RID_EXTENSION:
    {
      /* The saved value of the PEDANTIC flag.  */
      int saved_pedantic;
      tree expr;

      /* Save away the PEDANTIC flag.  */
      cp_parser_extension_opt (parser, &saved_pedantic);
      /* Parse the cast-expression.  */
      expr = cp_parser_simple_cast_expression (parser);
      /* Restore the PEDANTIC flag.  */
      pedantic = saved_pedantic;

      return expr;
    }

  case RID_REALPART:
  case RID_IMAGPART:
    {
      tree expression;

      /* Consume the `__real__' or `__imag__' token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the cast-expression.  */
      expression = cp_parser_simple_cast_expression (parser);
      /* Create the complete representation.  */
      return build_x_unary_op ((keyword == RID_REALPART
              ? REALPART_EXPR : IMAGPART_EXPR),
             expression);
    }
    break;

  default:
    break;
  }
    }

  /* Look for the `:: new' and `:: delete', which also signal the
     beginning of a new-expression, or delete-expression,
     respectively.  If the next token is `::', then it might be one of
     these.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
    {
      enum rid keyword;

      /* See if the token after the `::' is one of the keywords in
   which we're interested.  */
      keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
      /* If it's `new', we have a new-expression.  */
      if (keyword == RID_NEW)
  return cp_parser_new_expression (parser);
      /* Similarly, for `delete'.  */
      else if (keyword == RID_DELETE)
  return cp_parser_delete_expression (parser);
    }

  /* Look for a unary operator.  */
  unary_operator = cp_parser_unary_operator (token);
  /* The `++' and `--' operators can be handled similarly, even though
     they are not technically unary-operators in the grammar.  */
  if (unary_operator == ERROR_MARK)
    {
      if (token->type == CPP_PLUS_PLUS)
  unary_operator = PREINCREMENT_EXPR;
      else if (token->type == CPP_MINUS_MINUS)
  unary_operator = PREDECREMENT_EXPR;
      /* Handle the GNU address-of-label extension.  */
      else if (cp_parser_allow_gnu_extensions_p (parser)
         && token->type == CPP_AND_AND)
  {
    tree identifier;

    /* Consume the '&&' token.  */
    cp_lexer_consume_token (parser->lexer);
    /* Look for the identifier.  */
    identifier = cp_parser_identifier (parser);
    /* Create an expression representing the address.  */
    return finish_label_address_expr (identifier);
  }
    }
  if (unary_operator != ERROR_MARK)
    {
      tree cast_expression;
      tree expression = error_mark_node;
      const char *non_constant_p = NULL;

      /* Consume the operator token.  */
      token = cp_lexer_consume_token (parser->lexer);
      /* Parse the cast-expression.  */
      cast_expression
  = cp_parser_cast_expression (parser,
             unary_operator == ADDR_EXPR,
             /*cast_p=*/false);
      /* Now, build an appropriate representation.  */
      switch (unary_operator)
  {
  case INDIRECT_REF:
    non_constant_p = "`*'";
    expression = build_x_indirect_ref (cast_expression, "unary *");
    break;

  case ADDR_EXPR:
    non_constant_p = "`&'";
    /* Fall through.  */
  case BIT_NOT_EXPR:
    expression = build_x_unary_op (unary_operator, cast_expression);
    break;

  case PREINCREMENT_EXPR:
  case PREDECREMENT_EXPR:
    non_constant_p = (unary_operator == PREINCREMENT_EXPR
          ? "`++'" : "`--'");
    /* Fall through.  */
  case UNARY_PLUS_EXPR:
  case NEGATE_EXPR:
  case TRUTH_NOT_EXPR:
    expression = finish_unary_op_expr (unary_operator, cast_expression);
    break;

  default:
    gcc_unreachable ();
  }

      if (non_constant_p
    && cp_parser_non_integral_constant_expression (parser,
               non_constant_p))
  expression = error_mark_node;

      return expression;
    }

  return cp_parser_postfix_expression (parser, address_p, cast_p);
}

/* Returns ERROR_MARK if TOKEN is not a unary-operator.  If TOKEN is a
   unary-operator, the corresponding tree code is returned.  */

static enum tree_code
cp_parser_unary_operator (cp_token* token)
{
  switch (token->type)
    {
    case CPP_MULT:
      return INDIRECT_REF;

    case CPP_AND:
      return ADDR_EXPR;

    case CPP_PLUS:
      return UNARY_PLUS_EXPR;

    case CPP_MINUS:
      return NEGATE_EXPR;

    case CPP_NOT:
      return TRUTH_NOT_EXPR;

    case CPP_COMPL:
      return BIT_NOT_EXPR;

    default:
      return ERROR_MARK;
    }
}

/* Parse a new-expression.

   new-expression:
     :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
     :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]

   Returns a representation of the expression.  */

static tree
cp_parser_new_expression (cp_parser* parser)
{
  bool global_scope_p;
  tree placement;
  tree type;
  tree initializer;
  tree nelts;

  /* Look for the optional `::' operator.  */
  global_scope_p
    = (cp_parser_global_scope_opt (parser,
           /*current_scope_valid_p=*/false)
       != NULL_TREE);
  /* Look for the `new' operator.  */
  cp_parser_require_keyword (parser, RID_NEW, "`new'");
  /* There's no easy way to tell a new-placement from the
     `( type-id )' construct.  */
  cp_parser_parse_tentatively (parser);
  /* Look for a new-placement.  */
  placement = cp_parser_new_placement (parser);
  /* If that didn't work out, there's no new-placement.  */
  if (!cp_parser_parse_definitely (parser))
    placement = NULL_TREE;

  /* If the next token is a `(', then we have a parenthesized
     type-id.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
    {
      /* Consume the `('.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the type-id.  */
      type = cp_parser_type_id (parser);
      /* Look for the closing `)'.  */
      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
      /* There should not be a direct-new-declarator in this production,
   but GCC used to allowed this, so we check and emit a sensible error
   message for this case.  */
      if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
  {
    error ("array bound forbidden after parenthesized type-id");
    inform ("try removing the parentheses around the type-id");
    cp_parser_direct_new_declarator (parser);
  }
      nelts = NULL_TREE;
    }
  /* Otherwise, there must be a new-type-id.  */
  else
    type = cp_parser_new_type_id (parser, &nelts);

  /* If the next token is a `(', then we have a new-initializer.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
    initializer = cp_parser_new_initializer (parser);
  else
    initializer = NULL_TREE;

  /* A new-expression may not appear in an integral constant
     expression.  */
  if (cp_parser_non_integral_constant_expression (parser, "`new'"))
    return error_mark_node;

  /* Create a representation of the new-expression.  */
  return build_new (placement, type, nelts, initializer, global_scope_p);
}

/* Parse a new-placement.

   new-placement:
     ( expression-list )

   Returns the same representation as for an expression-list.  */

static tree
cp_parser_new_placement (cp_parser* parser)
{
  tree expression_list;

  /* Parse the expression-list.  */
  expression_list = (cp_parser_parenthesized_expression_list
         (parser, false, /*cast_p=*/false,
          /*non_constant_p=*/NULL));

  return expression_list;
}

/* Parse a new-type-id.

   new-type-id:
     type-specifier-seq new-declarator [opt]

   Returns the TYPE allocated.  If the new-type-id indicates an array
   type, *NELTS is set to the number of elements in the last array
   bound; the TYPE will not include the last array bound.  */

static tree
cp_parser_new_type_id (cp_parser* parser, tree *nelts)
{
  cp_decl_specifier_seq type_specifier_seq;
  cp_declarator *new_declarator;
  cp_declarator *declarator;
  cp_declarator *outer_declarator;
  const char *saved_message;
  tree type;

  /* The type-specifier sequence must not contain type definitions.
     (It cannot contain declarations of new types either, but if they
     are not definitions we will catch that because they are not
     complete.)  */
  saved_message = parser->type_definition_forbidden_message;
  parser->type_definition_forbidden_message
    = "types may not be defined in a new-type-id";
  /* Parse the type-specifier-seq.  */
  cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
        &type_specifier_seq);
  /* Restore the old message.  */
  parser->type_definition_forbidden_message = saved_message;
  /* Parse the new-declarator.  */
  new_declarator = cp_parser_new_declarator_opt (parser);

  /* Determine the number of elements in the last array dimension, if
     any.  */
  *nelts = NULL_TREE;
  /* Skip down to the last array dimension.  */
  declarator = new_declarator;
  outer_declarator = NULL;
  while (declarator && (declarator->kind == cdk_pointer
      || declarator->kind == cdk_ptrmem))
    {
      outer_declarator = declarator;
      declarator = declarator->declarator;
    }
  while (declarator
   && declarator->kind == cdk_array
   && declarator->declarator
   && declarator->declarator->kind == cdk_array)
    {
      outer_declarator = declarator;
      declarator = declarator->declarator;
    }

  if (declarator && declarator->kind == cdk_array)
    {
      *nelts = declarator->u.array.bounds;
      if (*nelts == error_mark_node)
  *nelts = integer_one_node;

      if (outer_declarator)
  outer_declarator->declarator = declarator->declarator;
      else
  new_declarator = NULL;
    }

  type = groktypename (&type_specifier_seq, new_declarator);
  if (TREE_CODE (type) == ARRAY_TYPE && *nelts == NULL_TREE)
    {
      *nelts = array_type_nelts_top (type);
      type = TREE_TYPE (type);
    }
  return type;
}

/* Parse an (optional) new-declarator.

   new-declarator:
     ptr-operator new-declarator [opt]
     direct-new-declarator

   Returns the declarator.  */

static cp_declarator *
cp_parser_new_declarator_opt (cp_parser* parser)
{
  enum tree_code code;
  tree type;
  cp_cv_quals cv_quals;

  /* We don't know if there's a ptr-operator next, or not.  */
  cp_parser_parse_tentatively (parser);
  /* Look for a ptr-operator.  */
  code = cp_parser_ptr_operator (parser, &type, &cv_quals);
  /* If that worked, look for more new-declarators.  */
  if (cp_parser_parse_definitely (parser))
    {
      cp_declarator *declarator;

      /* Parse another optional declarator.  */
      declarator = cp_parser_new_declarator_opt (parser);

      /* Create the representation of the declarator.  */
      if (type)
  declarator = make_ptrmem_declarator (cv_quals, type, declarator);
      else if (code == INDIRECT_REF)
  declarator = make_pointer_declarator (cv_quals, declarator);
      else
  declarator = make_reference_declarator (cv_quals, declarator);

      return declarator;
    }

  /* If the next token is a `[', there is a direct-new-declarator.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
    return cp_parser_direct_new_declarator (parser);

  return NULL;
}

/* Parse a direct-new-declarator.

   direct-new-declarator:
     [ expression ]
     direct-new-declarator [constant-expression]

   */

static cp_declarator *
cp_parser_direct_new_declarator (cp_parser* parser)
{
  cp_declarator *declarator = NULL;

  while (true)
    {
      tree expression;

      /* Look for the opening `['.  */
      cp_parser_require (parser, CPP_OPEN_SQUARE, "`['");
      /* The first expression is not required to be constant.  */
      if (!declarator)
  {
    expression = cp_parser_expression (parser, /*cast_p=*/false);
    /* The standard requires that the expression have integral
       type.  DR 74 adds enumeration types.  We believe that the
       real intent is that these expressions be handled like the
       expression in a `switch' condition, which also allows
       classes with a single conversion to integral or
       enumeration type.  */
    if (!processing_template_decl)
      {
        expression
    = build_expr_type_conversion (WANT_INT | WANT_ENUM,
                expression,
                /*complain=*/true);
        if (!expression)
    {
      error ("expression in new-declarator must have integral "
       "or enumeration type");
      expression = error_mark_node;
    }
      }
  }
      /* But all the other expressions must be.  */
      else
  expression
    = cp_parser_constant_expression (parser,
             /*allow_non_constant=*/false,
             NULL);
      /* Look for the closing `]'.  */
      cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");

      /* Add this bound to the declarator.  */
      declarator = make_array_declarator (declarator, expression);

      /* If the next token is not a `[', then there are no more
   bounds.  */
      if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
  break;
    }

  return declarator;
}

/* Parse a new-initializer.

   new-initializer:
     ( expression-list [opt] )

   Returns a representation of the expression-list.  If there is no
   expression-list, VOID_ZERO_NODE is returned.  */

static tree
cp_parser_new_initializer (cp_parser* parser)
{
  tree expression_list;

  expression_list = (cp_parser_parenthesized_expression_list
         (parser, false, /*cast_p=*/false,
          /*non_constant_p=*/NULL));
  if (!expression_list)
    expression_list = void_zero_node;

  return expression_list;
}

/* Parse a delete-expression.

   delete-expression:
     :: [opt] delete cast-expression
     :: [opt] delete [ ] cast-expression

   Returns a representation of the expression.  */

static tree
cp_parser_delete_expression (cp_parser* parser)
{
  bool global_scope_p;
  bool array_p;
  tree expression;

  /* Look for the optional `::' operator.  */
  global_scope_p
    = (cp_parser_global_scope_opt (parser,
           /*current_scope_valid_p=*/false)
       != NULL_TREE);
  /* Look for the `delete' keyword.  */
  cp_parser_require_keyword (parser, RID_DELETE, "`delete'");
  /* See if the array syntax is in use.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
    {
      /* Consume the `[' token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Look for the `]' token.  */
      cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
      /* Remember that this is the `[]' construct.  */
      array_p = true;
    }
  else
    array_p = false;

  /* Parse the cast-expression.  */
  expression = cp_parser_simple_cast_expression (parser);

  /* A delete-expression may not appear in an integral constant
     expression.  */
  if (cp_parser_non_integral_constant_expression (parser, "`delete'"))
    return error_mark_node;

  return delete_sanity (expression, NULL_TREE, array_p, global_scope_p);
}

/* Parse a cast-expression.

   cast-expression:
     unary-expression
     ( type-id ) cast-expression

   ADDRESS_P is true iff the unary-expression is appearing as the
   operand of the `&' operator.   CAST_P is true if this expression is
   the target of a cast.

   Returns a representation of the expression.  */

static tree
cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p)
{
  /* If it's a `(', then we might be looking at a cast.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
    {
      tree type = NULL_TREE;
      tree expr = NULL_TREE;
      bool compound_literal_p;
      const char *saved_message;

      /* There's no way to know yet whether or not this is a cast.
   For example, `(int (3))' is a unary-expression, while `(int)
   3' is a cast.  So, we resort to parsing tentatively.  */
      cp_parser_parse_tentatively (parser);
      /* Types may not be defined in a cast.  */
      saved_message = parser->type_definition_forbidden_message;
      parser->type_definition_forbidden_message
  = "types may not be defined in casts";
      /* Consume the `('.  */
      cp_lexer_consume_token (parser->lexer);
      /* A very tricky bit is that `(struct S) { 3 }' is a
   compound-literal (which we permit in C++ as an extension).
   But, that construct is not a cast-expression -- it is a
   postfix-expression.  (The reason is that `(struct S) { 3 }.i'
   is legal; if the compound-literal were a cast-expression,
   you'd need an extra set of parentheses.)  But, if we parse
   the type-id, and it happens to be a class-specifier, then we
   will commit to the parse at that point, because we cannot
   undo the action that is done when creating a new class.  So,
   then we cannot back up and do a postfix-expression.

   Therefore, we scan ahead to the closing `)', and check to see
   if the token after the `)' is a `{'.  If so, we are not
   looking at a cast-expression.

   Save tokens so that we can put them back.  */
      cp_lexer_save_tokens (parser->lexer);
      /* Skip tokens until the next token is a closing parenthesis.
   If we find the closing `)', and the next token is a `{', then
   we are looking at a compound-literal.  */
      compound_literal_p
  = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
              /*consume_paren=*/true)
     && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
      /* Roll back the tokens we skipped.  */
      cp_lexer_rollback_tokens (parser->lexer);
      /* If we were looking at a compound-literal, simulate an error
   so that the call to cp_parser_parse_definitely below will
   fail.  */
      if (compound_literal_p)
  cp_parser_simulate_error (parser);
      else
  {
    bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
    parser->in_type_id_in_expr_p = true;
    /* Look for the type-id.  */
    type = cp_parser_type_id (parser);
    /* Look for the closing `)'.  */
    cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
    parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
  }

      /* Restore the saved message.  */
      parser->type_definition_forbidden_message = saved_message;

      /* If ok so far, parse the dependent expression. We cannot be
   sure it is a cast. Consider `(T ())'.  It is a parenthesized
   ctor of T, but looks like a cast to function returning T
   without a dependent expression.  */
      if (!cp_parser_error_occurred (parser))
  expr = cp_parser_cast_expression (parser,
            /*address_p=*/false,
            /*cast_p=*/true);

      if (cp_parser_parse_definitely (parser))
  {
    /* Warn about old-style casts, if so requested.  */
    if (warn_old_style_cast
        && !in_system_header
        && !VOID_TYPE_P (type)
        && current_lang_name != lang_name_c)
      warning (OPT_Wold_style_cast, "use of old-style cast");

    /* Only type conversions to integral or enumeration types
       can be used in constant-expressions.  */
    if (!cast_valid_in_integral_constant_expression_p (type)
        && (cp_parser_non_integral_constant_expression
      (parser,
       "a cast to a type other than an integral or "
       "enumeration type")))
      return error_mark_node;

    /* Perform the cast.  */
    expr = build_c_cast (type, expr);
    return expr;
  }
    }

  /* If we get here, then it's not a cast, so it must be a
     unary-expression.  */
  return cp_parser_unary_expression (parser, address_p, cast_p);
}

/* Parse a binary expression of the general form:

   pm-expression:
     cast-expression
     pm-expression .* cast-expression
     pm-expression ->* cast-expression

   multiplicative-expression:
     pm-expression
     multiplicative-expression * pm-expression
     multiplicative-expression / pm-expression
     multiplicative-expression % pm-expression

   additive-expression:
     multiplicative-expression
     additive-expression + multiplicative-expression
     additive-expression - multiplicative-expression

   shift-expression:
     additive-expression
     shift-expression << additive-expression
     shift-expression >> additive-expression

   relational-expression:
     shift-expression
     relational-expression < shift-expression
     relational-expression > shift-expression
     relational-expression <= shift-expression
     relational-expression >= shift-expression

  GNU Extension:

   relational-expression:
     relational-expression <? shift-expression
     relational-expression >? shift-expression

   equality-expression:
     relational-expression
     equality-expression == relational-expression
     equality-expression != relational-expression

   and-expression:
     equality-expression
     and-expression & equality-expression

   exclusive-or-expression:
     and-expression
     exclusive-or-expression ^ and-expression

   inclusive-or-expression:
     exclusive-or-expression
     inclusive-or-expression | exclusive-or-expression

   logical-and-expression:
     inclusive-or-expression
     logical-and-expression && inclusive-or-expression

   logical-or-expression:
     logical-and-expression
     logical-or-expression || logical-and-expression

   All these are implemented with a single function like:

   binary-expression:
     simple-cast-expression
     binary-expression <token> binary-expression

   CAST_P is true if this expression is the target of a cast.

   The binops_by_token map is used to get the tree codes for each <token> type.
   binary-expressions are associated according to a precedence table.  */

#define TOKEN_PRECEDENCE(token) \
  ((token->type == CPP_GREATER && !parser->greater_than_is_operator_p) \
   ? PREC_NOT_OPERATOR \
   : binops_by_token[token->type].prec)

static tree
cp_parser_binary_expression (cp_parser* parser, bool cast_p)
{
  cp_parser_expression_stack stack;
  cp_parser_expression_stack_entry *sp = &stack[0];
  tree lhs, rhs;
  cp_token *token;
  enum tree_code tree_type;
  enum cp_parser_prec prec = PREC_NOT_OPERATOR, new_prec, lookahead_prec;
  bool overloaded_p;

  /* Parse the first expression.  */
  lhs = cp_parser_cast_expression (parser, /*address_p=*/false, cast_p);

  for (;;)
    {
      /* Get an operator token.  */
      token = cp_lexer_peek_token (parser->lexer);

      new_prec = TOKEN_PRECEDENCE (token);

      /* Popping an entry off the stack means we completed a subexpression:
   - either we found a token which is not an operator (`>' where it is not
     an operator, or prec == PREC_NOT_OPERATOR), in which case popping
     will happen repeatedly;
   - or, we found an operator which has lower priority.  This is the case
     where the recursive descent *ascends*, as in `3 * 4 + 5' after
     parsing `3 * 4'.  */
      if (new_prec <= prec)
  {
    if (sp == stack)
      break;
    else
      goto pop;
  }

     get_rhs:
      tree_type = binops_by_token[token->type].tree_type;

      /* We used the operator token.  */
      cp_lexer_consume_token (parser->lexer);

      /* Extract another operand.  It may be the RHS of this expression
   or the LHS of a new, higher priority expression.  */
      rhs = cp_parser_simple_cast_expression (parser);

      /* Get another operator token.  Look up its precedence to avoid
   building a useless (immediately popped) stack entry for common
   cases such as 3 + 4 + 5 or 3 * 4 + 5.  */
      token = cp_lexer_peek_token (parser->lexer);
      lookahead_prec = TOKEN_PRECEDENCE (token);
      if (lookahead_prec > new_prec)
  {
    /* ... and prepare to parse the RHS of the new, higher priority
       expression.  Since precedence levels on the stack are
       monotonically increasing, we do not have to care about
       stack overflows.  */
    sp->prec = prec;
    sp->tree_type = tree_type;
    sp->lhs = lhs;
    sp++;
    lhs = rhs;
    prec = new_prec;
    new_prec = lookahead_prec;
    goto get_rhs;

   pop:
    /* If the stack is not empty, we have parsed into LHS the right side
       (`4' in the example above) of an expression we had suspended.
       We can use the information on the stack to recover the LHS (`3')
       from the stack together with the tree code (`MULT_EXPR'), and
       the precedence of the higher level subexpression
       (`PREC_ADDITIVE_EXPRESSION').  TOKEN is the CPP_PLUS token,
       which will be used to actually build the additive expression.  */
    --sp;
    prec = sp->prec;
    tree_type = sp->tree_type;
    rhs = lhs;
    lhs = sp->lhs;
  }

      overloaded_p = false;
      lhs = build_x_binary_op (tree_type, lhs, rhs, &overloaded_p);

      /* If the binary operator required the use of an overloaded operator,
   then this expression cannot be an integral constant-expression.
   An overloaded operator can be used even if both operands are
   otherwise permissible in an integral constant-expression if at
   least one of the operands is of enumeration type.  */

      if (overloaded_p
    && (cp_parser_non_integral_constant_expression
        (parser, "calls to overloaded operators")))
  return error_mark_node;
    }

  return lhs;
}


/* Parse the `? expression : assignment-expression' part of a
   conditional-expression.  The LOGICAL_OR_EXPR is the
   logical-or-expression that started the conditional-expression.
   Returns a representation of the entire conditional-expression.

   This routine is used by cp_parser_assignment_expression.

     ? expression : assignment-expression

   GNU Extensions:

     ? : assignment-expression */

static tree
cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
{
  tree expr;
  tree assignment_expr;

  /* Consume the `?' token.  */
  cp_lexer_consume_token (parser->lexer);
  if (cp_parser_allow_gnu_extensions_p (parser)
      && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
    /* Implicit true clause.  */
    expr = NULL_TREE;
  else
    /* Parse the expression.  */
    expr = cp_parser_expression (parser, /*cast_p=*/false);

  /* The next token should be a `:'.  */
  cp_parser_require (parser, CPP_COLON, "`:'");
  /* Parse the assignment-expression.  */
  assignment_expr = cp_parser_assignment_expression (parser, /*cast_p=*/false);

  /* Build the conditional-expression.  */
  return build_x_conditional_expr (logical_or_expr,
           expr,
           assignment_expr);
}

/* Parse an assignment-expression.

   assignment-expression:
     conditional-expression
     logical-or-expression assignment-operator assignment_expression
     throw-expression

   CAST_P is true if this expression is the target of a cast.

   Returns a representation for the expression.  */

static tree
cp_parser_assignment_expression (cp_parser* parser, bool cast_p)
{
  tree expr;

  /* If the next token is the `throw' keyword, then we're looking at
     a throw-expression.  */
  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
    expr = cp_parser_throw_expression (parser);
  /* Otherwise, it must be that we are looking at a
     logical-or-expression.  */
  else
    {
      /* Parse the binary expressions (logical-or-expression).  */
      expr = cp_parser_binary_expression (parser, cast_p);
      /* If the next token is a `?' then we're actually looking at a
   conditional-expression.  */
      if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
  return cp_parser_question_colon_clause (parser, expr);
      else
  {
    enum tree_code assignment_operator;

    /* If it's an assignment-operator, we're using the second
       production.  */
    assignment_operator
      = cp_parser_assignment_operator_opt (parser);
    if (assignment_operator != ERROR_MARK)
      {
        tree rhs;

        /* Parse the right-hand side of the assignment.  */
        rhs = cp_parser_assignment_expression (parser, cast_p);
        /* An assignment may not appear in a
     constant-expression.  */
        if (cp_parser_non_integral_constant_expression (parser,
                    "an assignment"))
    return error_mark_node;
        /* Build the assignment expression.  */
        expr = build_x_modify_expr (expr,
            assignment_operator,
            rhs);
      }
  }
    }

  return expr;
}

/* Parse an (optional) assignment-operator.

   assignment-operator: one of
     = *= /= %= += -= >>= <<= &= ^= |=

   GNU Extension:

   assignment-operator: one of
     <?= >?=

   If the next token is an assignment operator, the corresponding tree
   code is returned, and the token is consumed.  For example, for
   `+=', PLUS_EXPR is returned.  For `=' itself, the code returned is
   NOP_EXPR.  For `/', TRUNC_DIV_EXPR is returned; for `%',
   TRUNC_MOD_EXPR is returned.  If TOKEN is not an assignment
   operator, ERROR_MARK is returned.  */

static enum tree_code
cp_parser_assignment_operator_opt (cp_parser* parser)
{
  enum tree_code op;
  cp_token *token;

  /* Peek at the next toen.  */
  token = cp_lexer_peek_token (parser->lexer);

  switch (token->type)
    {
    case CPP_EQ:
      op = NOP_EXPR;
      break;

    case CPP_MULT_EQ:
      op = MULT_EXPR;
      break;

    case CPP_DIV_EQ:
      op = TRUNC_DIV_EXPR;
      break;

    case CPP_MOD_EQ:
      op = TRUNC_MOD_EXPR;
      break;

    case CPP_PLUS_EQ:
      op = PLUS_EXPR;
      break;

    case CPP_MINUS_EQ:
      op = MINUS_EXPR;
      break;

    case CPP_RSHIFT_EQ:
      op = RSHIFT_EXPR;
      break;

    case CPP_LSHIFT_EQ:
      op = LSHIFT_EXPR;
      break;

    case CPP_AND_EQ:
      op = BIT_AND_EXPR;
      break;

    case CPP_XOR_EQ:
      op = BIT_XOR_EXPR;
      break;

    case CPP_OR_EQ:
      op = BIT_IOR_EXPR;
      break;

    default:
      /* Nothing else is an assignment operator.  */
      op = ERROR_MARK;
    }

  /* If it was an assignment operator, consume it.  */
  if (op != ERROR_MARK)
    cp_lexer_consume_token (parser->lexer);

  return op;
}

/* Parse an expression.

   expression:
     assignment-expression
     expression , assignment-expression

   CAST_P is true if this expression is the target of a cast.

   Returns a representation of the expression.  */

static tree
cp_parser_expression (cp_parser* parser, bool cast_p)
{
  tree expression = NULL_TREE;

  while (true)
    {
      tree assignment_expression;

      /* Parse the next assignment-expression.  */
      assignment_expression
  = cp_parser_assignment_expression (parser, cast_p);
      /* If this is the first assignment-expression, we can just
   save it away.  */
      if (!expression)
  expression = assignment_expression;
      else
  expression = build_x_compound_expr (expression,
              assignment_expression);
      /* If the next token is not a comma, then we are done with the
   expression.  */
      if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
  break;
      /* Consume the `,'.  */
      cp_lexer_consume_token (parser->lexer);
      /* A comma operator cannot appear in a constant-expression.  */
      if (cp_parser_non_integral_constant_expression (parser,
                  "a comma operator"))
  expression = error_mark_node;
    }

  return expression;
}

/* Parse a constant-expression.

   constant-expression:
     conditional-expression

  If ALLOW_NON_CONSTANT_P a non-constant expression is silently
  accepted.  If ALLOW_NON_CONSTANT_P is true and the expression is not
  constant, *NON_CONSTANT_P is set to TRUE.  If ALLOW_NON_CONSTANT_P
  is false, NON_CONSTANT_P should be NULL.  */

static tree
cp_parser_constant_expression (cp_parser* parser,
             bool allow_non_constant_p,
             bool *non_constant_p)
{
  bool saved_integral_constant_expression_p;
  bool saved_allow_non_integral_constant_expression_p;
  bool saved_non_integral_constant_expression_p;
  tree expression;

  /* It might seem that we could simply parse the
     conditional-expression, and then check to see if it were
     TREE_CONSTANT.  However, an expression that is TREE_CONSTANT is
     one that the compiler can figure out is constant, possibly after
     doing some simplifications or optimizations.  The standard has a
     precise definition of constant-expression, and we must honor
     that, even though it is somewhat more restrictive.

     For example:

       int i[(2, 3)];

     is not a legal declaration, because `(2, 3)' is not a
     constant-expression.  The `,' operator is forbidden in a
     constant-expression.  However, GCC's constant-folding machinery
     will fold this operation to an INTEGER_CST for `3'.  */

  /* Save the old settings.  */
  saved_integral_constant_expression_p = parser->integral_constant_expression_p;
  saved_allow_non_integral_constant_expression_p
    = parser->allow_non_integral_constant_expression_p;
  saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
  /* We are now parsing a constant-expression.  */
  parser->integral_constant_expression_p = true;
  parser->allow_non_integral_constant_expression_p = allow_non_constant_p;
  parser->non_integral_constant_expression_p = false;
  /* Although the grammar says "conditional-expression", we parse an
     "assignment-expression", which also permits "throw-expression"
     and the use of assignment operators.  In the case that
     ALLOW_NON_CONSTANT_P is false, we get better errors than we would
     otherwise.  In the case that ALLOW_NON_CONSTANT_P is true, it is
     actually essential that we look for an assignment-expression.
     For example, cp_parser_initializer_clauses uses this function to
     determine whether a particular assignment-expression is in fact
     constant.  */
  expression = cp_parser_assignment_expression (parser, /*cast_p=*/false);
  /* Restore the old settings.  */
  parser->integral_constant_expression_p
    = saved_integral_constant_expression_p;
  parser->allow_non_integral_constant_expression_p
    = saved_allow_non_integral_constant_expression_p;
  if (allow_non_constant_p)
    *non_constant_p = parser->non_integral_constant_expression_p;
  else if (parser->non_integral_constant_expression_p)
    expression = error_mark_node;
  parser->non_integral_constant_expression_p
    = saved_non_integral_constant_expression_p;

  return expression;
}

/* Parse __builtin_offsetof.

   offsetof-expression:
     "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"

   offsetof-member-designator:
     id-expression
     | offsetof-member-designator "." id-expression
     | offsetof-member-designator "[" expression "]"  */

static tree
cp_parser_builtin_offsetof (cp_parser *parser)
{
  int save_ice_p, save_non_ice_p;
  tree type, expr;
  cp_id_kind dummy;

  /* We're about to accept non-integral-constant things, but will
     definitely yield an integral constant expression.  Save and
     restore these values around our local parsing.  */
  save_ice_p = parser->integral_constant_expression_p;
  save_non_ice_p = parser->non_integral_constant_expression_p;

  /* Consume the "__builtin_offsetof" token.  */
  cp_lexer_consume_token (parser->lexer);
  /* Consume the opening `('.  */
  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
  /* Parse the type-id.  */
  type = cp_parser_type_id (parser);
  /* Look for the `,'.  */
  cp_parser_require (parser, CPP_COMMA, "`,'");

  /* Build the (type *)null that begins the traditional offsetof macro.  */
  expr = build_static_cast (build_pointer_type (type), null_pointer_node);

  /* Parse the offsetof-member-designator.  We begin as if we saw "expr->".  */
  expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr,
             true, &dummy);
  while (true)
    {
      cp_token *token = cp_lexer_peek_token (parser->lexer);
      switch (token->type)
  {
  case CPP_OPEN_SQUARE:
    /* offsetof-member-designator "[" expression "]" */
    expr = cp_parser_postfix_open_square_expression (parser, expr, true);
    break;

  case CPP_DOT:
    /* offsetof-member-designator "." identifier */
    cp_lexer_consume_token (parser->lexer);
    expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT, expr,
               true, &dummy);
    break;

  case CPP_CLOSE_PAREN:
    /* Consume the ")" token.  */
    cp_lexer_consume_token (parser->lexer);
    goto success;

  default:
    /* Error.  We know the following require will fail, but
       that gives the proper error message.  */
    cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
    cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
    expr = error_mark_node;
    goto failure;
  }
    }

 success:
  /* If we're processing a template, we can't finish the semantics yet.
     Otherwise we can fold the entire expression now.  */
  if (processing_template_decl)
    expr = build1 (OFFSETOF_EXPR, size_type_node, expr);
  else
    expr = finish_offsetof (expr);

 failure:
  parser->integral_constant_expression_p = save_ice_p;
  parser->non_integral_constant_expression_p = save_non_ice_p;

  return expr;
}

/* Statements [gram.stmt.stmt]  */

/* Parse a statement.

   statement:
     labeled-statement
     expression-statement
     compound-statement
     selection-statement
     iteration-statement
     jump-statement
     declaration-statement
     try-block

  IN_COMPOUND is true when the statement is nested inside a
  cp_parser_compound_statement; this matters for certain pragmas.  */

static void
cp_parser_statement (cp_parser* parser, tree in_statement_expr,
         bool in_compound)
{
  tree statement;
  cp_token *token;
  location_t statement_location;

 restart:
  /* There is no statement yet.  */
  statement = NULL_TREE;
  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);
  /* Remember the location of the first token in the statement.  */
  statement_location = token->location;
  /* If this is a keyword, then that will often determine what kind of
     statement we have.  */
  if (token->type == CPP_KEYWORD)
    {
      enum rid keyword = token->keyword;

      switch (keyword)
  {
  case RID_CASE:
  case RID_DEFAULT:
    /* Looks like a labeled-statement with a case label.
       Parse the label, and then use tail recursion to parse
       the statement.  */
    cp_parser_label_for_labeled_statement (parser);
    goto restart;

  case RID_IF:
  case RID_SWITCH:
    statement = cp_parser_selection_statement (parser);
    break;

  case RID_WHILE:
  case RID_DO:
  case RID_FOR:
    statement = cp_parser_iteration_statement (parser);
    break;

  case RID_BREAK:
  case RID_CONTINUE:
  case RID_RETURN:
  case RID_GOTO:
    statement = cp_parser_jump_statement (parser);
    break;

    /* Objective-C++ exception-handling constructs.  */
  case RID_AT_TRY:
  case RID_AT_CATCH:
  case RID_AT_FINALLY:
  case RID_AT_SYNCHRONIZED:
  case RID_AT_THROW:
    statement = cp_parser_objc_statement (parser);
    break;

  case RID_TRY:
    statement = cp_parser_try_block (parser);
    break;

  default:
    /* It might be a keyword like `int' that can start a
       declaration-statement.  */
    break;
  }
    }
  else if (token->type == CPP_NAME)
    {
      /* If the next token is a `:', then we are looking at a
   labeled-statement.  */
      token = cp_lexer_peek_nth_token (parser->lexer, 2);
      if (token->type == CPP_COLON)
  {
    /* Looks like a labeled-statement with an ordinary label.
       Parse the label, and then use tail recursion to parse
       the statement.  */
    cp_parser_label_for_labeled_statement (parser);
    goto restart;
  }
    }
  /* Anything that starts with a `{' must be a compound-statement.  */
  else if (token->type == CPP_OPEN_BRACE)
    statement = cp_parser_compound_statement (parser, NULL, false);
  /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
     a statement all its own.  */
  else if (token->type == CPP_PRAGMA)
    {
      /* Only certain OpenMP pragmas are attached to statements, and thus
   are considered statements themselves.  All others are not.  In
   the context of a compound, accept the pragma as a "statement" and
   return so that we can check for a close brace.  Otherwise we
   require a real statement and must go back and read one.  */
      if (in_compound)
  cp_parser_pragma (parser, pragma_compound);
      else if (!cp_parser_pragma (parser, pragma_stmt))
  goto restart;
      return;
    }
  else if (token->type == CPP_EOF)
    {
      cp_parser_error (parser, "expected statement");
      return;
    }

  /* Everything else must be a declaration-statement or an
     expression-statement.  Try for the declaration-statement
     first, unless we are looking at a `;', in which case we know that
     we have an expression-statement.  */
  if (!statement)
    {
      if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
  {
    cp_parser_parse_tentatively (parser);
    /* Try to parse the declaration-statement.  */
    cp_parser_declaration_statement (parser);
    /* If that worked, we're done.  */
    if (cp_parser_parse_definitely (parser))
      return;
  }
      /* Look for an expression-statement instead.  */
      statement = cp_parser_expression_statement (parser, in_statement_expr);
    }

  /* Set the line number for the statement.  */
  if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
    SET_EXPR_LOCATION (statement, statement_location);
}

/* Parse the label for a labeled-statement, i.e.

   identifier :
   case constant-expression :
   default :

   GNU Extension:
   case constant-expression ... constant-expression : statement

   When a label is parsed without errors, the label is added to the
   parse tree by the finish_* functions, so this function doesn't
   have to return the label.  */

static void
cp_parser_label_for_labeled_statement (cp_parser* parser)
{
  cp_token *token;

  /* The next token should be an identifier.  */
  token = cp_lexer_peek_token (parser->lexer);
  if (token->type != CPP_NAME
      && token->type != CPP_KEYWORD)
    {
      cp_parser_error (parser, "expected labeled-statement");
      return;
    }

  switch (token->keyword)
    {
    case RID_CASE:
      {
  tree expr, expr_hi;
  cp_token *ellipsis;

  /* Consume the `case' token.  */
  cp_lexer_consume_token (parser->lexer);
  /* Parse the constant-expression.  */
  expr = cp_parser_constant_expression (parser,
                /*allow_non_constant_p=*/false,
                NULL);

  ellipsis = cp_lexer_peek_token (parser->lexer);
  if (ellipsis->type == CPP_ELLIPSIS)
    {
      /* Consume the `...' token.  */
      cp_lexer_consume_token (parser->lexer);
      expr_hi =
        cp_parser_constant_expression (parser,
               /*allow_non_constant_p=*/false,
               NULL);
      /* We don't need to emit warnings here, as the common code
         will do this for us.  */
    }
  else
    expr_hi = NULL_TREE;

  if (parser->in_switch_statement_p)
    finish_case_label (expr, expr_hi);
  else
    error ("case label %qE not within a switch statement", expr);
      }
      break;

    case RID_DEFAULT:
      /* Consume the `default' token.  */
      cp_lexer_consume_token (parser->lexer);

      if (parser->in_switch_statement_p)
  finish_case_label (NULL_TREE, NULL_TREE);
      else
  error ("case label not within a switch statement");
      break;

    default:
      /* Anything else must be an ordinary label.  */
      finish_label_stmt (cp_parser_identifier (parser));
      break;
    }

  /* Require the `:' token.  */
  cp_parser_require (parser, CPP_COLON, "`:'");
}

/* Parse an expression-statement.

   expression-statement:
     expression [opt] ;

   Returns the new EXPR_STMT -- or NULL_TREE if the expression
   statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
   indicates whether this expression-statement is part of an
   expression statement.  */

static tree
cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
{
  tree statement = NULL_TREE;

  /* If the next token is a ';', then there is no expression
     statement.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
    statement = cp_parser_expression (parser, /*cast_p=*/false);

  /* Consume the final `;'.  */
  cp_parser_consume_semicolon_at_end_of_statement (parser);

  if (in_statement_expr
      && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
    /* This is the final expression statement of a statement
       expression.  */
    statement = finish_stmt_expr_expr (statement, in_statement_expr);
  else if (statement)
    statement = finish_expr_stmt (statement);
  else
    finish_stmt ();

  return statement;
}

/* Parse a compound-statement.

   compound-statement:
     { statement-seq [opt] }

   Returns a tree representing the statement.  */

static tree
cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
            bool in_try)
{
  tree compound_stmt;

  /* Consume the `{'.  */
  if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
    return error_mark_node;
  /* Begin the compound-statement.  */
  compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
  /* Parse an (optional) statement-seq.  */
  cp_parser_statement_seq_opt (parser, in_statement_expr);
  /* Finish the compound-statement.  */
  finish_compound_stmt (compound_stmt);
  /* Consume the `}'.  */
  cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");

  return compound_stmt;
}

/* Parse an (optional) statement-seq.

   statement-seq:
     statement
     statement-seq [opt] statement  */

static void
cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
{
  /* Scan statements until there aren't any more.  */
  while (true)
    {
      cp_token *token = cp_lexer_peek_token (parser->lexer);

      /* If we're looking at a `}', then we've run out of statements.  */
      if (token->type == CPP_CLOSE_BRACE
    || token->type == CPP_EOF
    || token->type == CPP_PRAGMA_EOL)
  break;

      /* Parse the statement.  */
      cp_parser_statement (parser, in_statement_expr, true);
    }
}

/* Parse a selection-statement.

   selection-statement:
     if ( condition ) statement
     if ( condition ) statement else statement
     switch ( condition ) statement

   Returns the new IF_STMT or SWITCH_STMT.  */

static tree
cp_parser_selection_statement (cp_parser* parser)
{
  cp_token *token;
  enum rid keyword;

  /* Peek at the next token.  */
  token = cp_parser_require (parser, CPP_KEYWORD, "selection-statement");

  /* See what kind of keyword it is.  */
  keyword = token->keyword;
  switch (keyword)
    {
    case RID_IF:
    case RID_SWITCH:
      {
  tree statement;
  tree condition;

  /* Look for the `('.  */
  if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
    {
      cp_parser_skip_to_end_of_statement (parser);
      return error_mark_node;
    }

  /* Begin the selection-statement.  */
  if (keyword == RID_IF)
    statement = begin_if_stmt ();
  else
    statement = begin_switch_stmt ();

  /* Parse the condition.  */
  condition = cp_parser_condition (parser);
  /* Look for the `)'.  */
  if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
    cp_parser_skip_to_closing_parenthesis (parser, true, false,
             /*consume_paren=*/true);

  if (keyword == RID_IF)
    {
      /* Add the condition.  */
      finish_if_stmt_cond (condition, statement);

      /* Parse the then-clause.  */
      cp_parser_implicitly_scoped_statement (parser);
      finish_then_clause (statement);

      /* If the next token is `else', parse the else-clause.  */
      if (cp_lexer_next_token_is_keyword (parser->lexer,
            RID_ELSE))
        {
    /* Consume the `else' keyword.  */
    cp_lexer_consume_token (parser->lexer);
    begin_else_clause (statement);
    /* Parse the else-clause.  */
    cp_parser_implicitly_scoped_statement (parser);
    finish_else_clause (statement);
        }

      /* Now we're all done with the if-statement.  */
      finish_if_stmt (statement);
    }
  else
    {
      bool in_switch_statement_p;
      unsigned char in_statement;

      /* Add the condition.  */
      finish_switch_cond (condition, statement);

      /* Parse the body of the switch-statement.  */
      in_switch_statement_p = parser->in_switch_statement_p;
      in_statement = parser->in_statement;
      parser->in_switch_statement_p = true;
      parser->in_statement |= IN_SWITCH_STMT;
      cp_parser_implicitly_scoped_statement (parser);
      parser->in_switch_statement_p = in_switch_statement_p;
      parser->in_statement = in_statement;

      /* Now we're all done with the switch-statement.  */
      finish_switch_stmt (statement);
    }

  return statement;
      }
      break;

    default:
      cp_parser_error (parser, "expected selection-statement");
      return error_mark_node;
    }
}

/* Parse a condition.

   condition:
     expression
     type-specifier-seq declarator = assignment-expression

   GNU Extension:

   condition:
     type-specifier-seq declarator asm-specification [opt]
       attributes [opt] = assignment-expression

   Returns the expression that should be tested.  */

static tree
cp_parser_condition (cp_parser* parser)
{
  cp_decl_specifier_seq type_specifiers;
  const char *saved_message;

  /* Try the declaration first.  */
  cp_parser_parse_tentatively (parser);
  /* New types are not allowed in the type-specifier-seq for a
     condition.  */
  saved_message = parser->type_definition_forbidden_message;
  parser->type_definition_forbidden_message
    = "types may not be defined in conditions";
  /* Parse the type-specifier-seq.  */
  cp_parser_type_specifier_seq (parser, /*is_condition==*/true,
        &type_specifiers);
  /* Restore the saved message.  */
  parser->type_definition_forbidden_message = saved_message;
  /* If all is well, we might be looking at a declaration.  */
  if (!cp_parser_error_occurred (parser))
    {
      tree decl;
      tree asm_specification;
      tree attributes;
      cp_declarator *declarator;
      tree initializer = NULL_TREE;

      /* Parse the declarator.  */
      declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
           /*ctor_dtor_or_conv_p=*/NULL,
           /*parenthesized_p=*/NULL,
           /*member_p=*/false);
      /* Parse the attributes.  */
      attributes = cp_parser_attributes_opt (parser);
      /* Parse the asm-specification.  */
      asm_specification = cp_parser_asm_specification_opt (parser);
      /* If the next token is not an `=', then we might still be
   looking at an expression.  For example:

     if (A(a).x)

   looks like a decl-specifier-seq and a declarator -- but then
   there is no `=', so this is an expression.  */
      cp_parser_require (parser, CPP_EQ, "`='");
      /* If we did see an `=', then we are looking at a declaration
   for sure.  */
      if (cp_parser_parse_definitely (parser))
  {
    tree pushed_scope;
    bool non_constant_p;

    /* Create the declaration.  */
    decl = start_decl (declarator, &type_specifiers,
           /*initialized_p=*/true,
           attributes, /*prefix_attributes=*/NULL_TREE,
           &pushed_scope);
    /* Parse the assignment-expression.  */
    initializer
      = cp_parser_constant_expression (parser,
               /*allow_non_constant_p=*/true,
               &non_constant_p);
    if (!non_constant_p)
      initializer = fold_non_dependent_expr (initializer);

    /* Process the initializer.  */
    cp_finish_decl (decl,
        initializer, !non_constant_p,
        asm_specification,
        LOOKUP_ONLYCONVERTING);

    if (pushed_scope)
      pop_scope (pushed_scope);

    return convert_from_reference (decl);
  }
    }
  /* If we didn't even get past the declarator successfully, we are
     definitely not looking at a declaration.  */
  else
    cp_parser_abort_tentative_parse (parser);

  /* Otherwise, we are looking at an expression.  */
  return cp_parser_expression (parser, /*cast_p=*/false);
}

/* Parse an iteration-statement.

   iteration-statement:
     while ( condition ) statement
     do statement while ( expression ) ;
     for ( for-init-statement condition [opt] ; expression [opt] )
       statement

   Returns the new WHILE_STMT, DO_STMT, or FOR_STMT.  */

static tree
cp_parser_iteration_statement (cp_parser* parser)
{
  cp_token *token;
  enum rid keyword;
  tree statement;
  unsigned char in_statement;

  /* Peek at the next token.  */
  token = cp_parser_require (parser, CPP_KEYWORD, "iteration-statement");
  if (!token)
    return error_mark_node;

  /* Remember whether or not we are already within an iteration
     statement.  */
  in_statement = parser->in_statement;

  /* See what kind of keyword it is.  */
  keyword = token->keyword;
  switch (keyword)
    {
    case RID_WHILE:
      {
  tree condition;

  /* Begin the while-statement.  */
  statement = begin_while_stmt ();
  /* Look for the `('.  */
  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
  /* Parse the condition.  */
  condition = cp_parser_condition (parser);
  finish_while_stmt_cond (condition, statement);
  /* Look for the `)'.  */
  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
  /* Parse the dependent statement.  */
  parser->in_statement = IN_ITERATION_STMT;
  cp_parser_already_scoped_statement (parser);
  parser->in_statement = in_statement;
  /* We're done with the while-statement.  */
  finish_while_stmt (statement);
      }
      break;

    case RID_DO:
      {
  tree expression;

  /* Begin the do-statement.  */
  statement = begin_do_stmt ();
  /* Parse the body of the do-statement.  */
  parser->in_statement = IN_ITERATION_STMT;
  cp_parser_implicitly_scoped_statement (parser);
  parser->in_statement = in_statement;
  finish_do_body (statement);
  /* Look for the `while' keyword.  */
  cp_parser_require_keyword (parser, RID_WHILE, "`while'");
  /* Look for the `('.  */
  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
  /* Parse the expression.  */
  expression = cp_parser_expression (parser, /*cast_p=*/false);
  /* We're done with the do-statement.  */
  finish_do_stmt (expression, statement);
  /* Look for the `)'.  */
  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
  /* Look for the `;'.  */
  cp_parser_require (parser, CPP_SEMICOLON, "`;'");
      }
      break;

    case RID_FOR:
      {
  tree condition = NULL_TREE;
  tree expression = NULL_TREE;

  /* Begin the for-statement.  */
  statement = begin_for_stmt ();
  /* Look for the `('.  */
  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
  /* Parse the initialization.  */
  cp_parser_for_init_statement (parser);
  finish_for_init_stmt (statement);

  /* If there's a condition, process it.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
    condition = cp_parser_condition (parser);
  finish_for_cond (condition, statement);
  /* Look for the `;'.  */
  cp_parser_require (parser, CPP_SEMICOLON, "`;'");

  /* If there's an expression, process it.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
    expression = cp_parser_expression (parser, /*cast_p=*/false);
  finish_for_expr (expression, statement);
  /* Look for the `)'.  */
  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");

  /* Parse the body of the for-statement.  */
  parser->in_statement = IN_ITERATION_STMT;
  cp_parser_already_scoped_statement (parser);
  parser->in_statement = in_statement;

  /* We're done with the for-statement.  */
  finish_for_stmt (statement);
      }
      break;

    default:
      cp_parser_error (parser, "expected iteration-statement");
      statement = error_mark_node;
      break;
    }

  return statement;
}

/* Parse a for-init-statement.

   for-init-statement:
     expression-statement
     simple-declaration  */

static void
cp_parser_for_init_statement (cp_parser* parser)
{
  /* If the next token is a `;', then we have an empty
     expression-statement.  Grammatically, this is also a
     simple-declaration, but an invalid one, because it does not
     declare anything.  Therefore, if we did not handle this case
     specially, we would issue an error message about an invalid
     declaration.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
    {
      /* We're going to speculatively look for a declaration, falling back
   to an expression, if necessary.  */
      cp_parser_parse_tentatively (parser);
      /* Parse the declaration.  */
      cp_parser_simple_declaration (parser,
            /*function_definition_allowed_p=*/false);
      /* If the tentative parse failed, then we shall need to look for an
   expression-statement.  */
      if (cp_parser_parse_definitely (parser))
  return;
    }

  cp_parser_expression_statement (parser, false);
}

/* Parse a jump-statement.

   jump-statement:
     break ;
     continue ;
     return expression [opt] ;
     goto identifier ;

   GNU extension:

   jump-statement:
     goto * expression ;

   Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR.  */

static tree
cp_parser_jump_statement (cp_parser* parser)
{
  tree statement = error_mark_node;
  cp_token *token;
  enum rid keyword;

  /* Peek at the next token.  */
  token = cp_parser_require (parser, CPP_KEYWORD, "jump-statement");
  if (!token)
    return error_mark_node;

  /* See what kind of keyword it is.  */
  keyword = token->keyword;
  switch (keyword)
    {
    case RID_BREAK:
      switch (parser->in_statement)
  {
  case 0:
    error ("break statement not within loop or switch");
    break;
  default:
    gcc_assert ((parser->in_statement & IN_SWITCH_STMT)
          || parser->in_statement == IN_ITERATION_STMT);
    statement = finish_break_stmt ();
    break;
  case IN_OMP_BLOCK:
    error ("invalid exit from OpenMP structured block");
    break;
  case IN_OMP_FOR:
    error ("break statement used with OpenMP for loop");
    break;
  }
      cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
      break;

    case RID_CONTINUE:
      switch (parser->in_statement & ~IN_SWITCH_STMT)
  {
  case 0:
    error ("continue statement not within a loop");
    break;
  case IN_ITERATION_STMT:
  case IN_OMP_FOR:
    statement = finish_continue_stmt ();
    break;
  case IN_OMP_BLOCK:
    error ("invalid exit from OpenMP structured block");
    break;
  default:
    gcc_unreachable ();
  }
      cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
      break;

    case RID_RETURN:
      {
  tree expr;

  /* If the next token is a `;', then there is no
     expression.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
    expr = cp_parser_expression (parser, /*cast_p=*/false);
  else
    expr = NULL_TREE;
  /* Build the return-statement.  */
  statement = finish_return_stmt (expr);
  /* Look for the final `;'.  */
  cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
      }
      break;

    case RID_GOTO:
      /* Create the goto-statement.  */
      if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
  {
    /* Issue a warning about this use of a GNU extension.  */
    if (pedantic)
      pedwarn ("ISO C++ forbids computed gotos");
    /* Consume the '*' token.  */
    cp_lexer_consume_token (parser->lexer);
    /* Parse the dependent expression.  */
    finish_goto_stmt (cp_parser_expression (parser, /*cast_p=*/false));
  }
      else
  finish_goto_stmt (cp_parser_identifier (parser));
      /* Look for the final `;'.  */
      cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
      break;

    default:
      cp_parser_error (parser, "expected jump-statement");
      break;
    }

  return statement;
}

/* Parse a declaration-statement.

   declaration-statement:
     block-declaration  */

static void
cp_parser_declaration_statement (cp_parser* parser)
{
  void *p;

  /* Get the high-water mark for the DECLARATOR_OBSTACK.  */
  p = obstack_alloc (&declarator_obstack, 0);

 /* Parse the block-declaration.  */
  cp_parser_block_declaration (parser, /*statement_p=*/true);

  /* Free any declarators allocated.  */
  obstack_free (&declarator_obstack, p);

  /* Finish off the statement.  */
  finish_stmt ();
}

/* Some dependent statements (like `if (cond) statement'), are
   implicitly in their own scope.  In other words, if the statement is
   a single statement (as opposed to a compound-statement), it is
   none-the-less treated as if it were enclosed in braces.  Any
   declarations appearing in the dependent statement are out of scope
   after control passes that point.  This function parses a statement,
   but ensures that is in its own scope, even if it is not a
   compound-statement.

   Returns the new statement.  */

static tree
cp_parser_implicitly_scoped_statement (cp_parser* parser)
{
  tree statement;

  /* Mark if () ; with a special NOP_EXPR.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
    {
      cp_lexer_consume_token (parser->lexer);
      statement = add_stmt (build_empty_stmt ());
    }
  /* if a compound is opened, we simply parse the statement directly.  */
  else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
    statement = cp_parser_compound_statement (parser, NULL, false);
  /* If the token is not a `{', then we must take special action.  */
  else
    {
      /* Create a compound-statement.  */
      statement = begin_compound_stmt (0);
      /* Parse the dependent-statement.  */
      cp_parser_statement (parser, NULL_TREE, false);
      /* Finish the dummy compound-statement.  */
      finish_compound_stmt (statement);
    }

  /* Return the statement.  */
  return statement;
}

/* For some dependent statements (like `while (cond) statement'), we
   have already created a scope.  Therefore, even if the dependent
   statement is a compound-statement, we do not want to create another
   scope.  */

static void
cp_parser_already_scoped_statement (cp_parser* parser)
{
  /* If the token is a `{', then we must take special action.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
    cp_parser_statement (parser, NULL_TREE, false);
  else
    {
      /* Avoid calling cp_parser_compound_statement, so that we
   don't create a new scope.  Do everything else by hand.  */
      cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
      cp_parser_statement_seq_opt (parser, NULL_TREE);
      cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
    }
}

/* Declarations [gram.dcl.dcl] */

/* Parse an optional declaration-sequence.

   declaration-seq:
     declaration
     declaration-seq declaration  */

static void
cp_parser_declaration_seq_opt (cp_parser* parser)
{
  while (true)
    {
      cp_token *token;

      token = cp_lexer_peek_token (parser->lexer);

      if (token->type == CPP_CLOSE_BRACE
    || token->type == CPP_EOF
    || token->type == CPP_PRAGMA_EOL)
  break;

      if (token->type == CPP_SEMICOLON)
  {
    /* A declaration consisting of a single semicolon is
       invalid.  Allow it unless we're being pedantic.  */
    cp_lexer_consume_token (parser->lexer);
    if (pedantic && !in_system_header)
      pedwarn ("extra %<;%>");
    continue;
  }

      /* If we're entering or exiting a region that's implicitly
   extern "C", modify the lang context appropriately.  */
      if (!parser->implicit_extern_c && token->implicit_extern_c)
  {
    push_lang_context (lang_name_c);
    parser->implicit_extern_c = true;
  }
      else if (parser->implicit_extern_c && !token->implicit_extern_c)
  {
    pop_lang_context ();
    parser->implicit_extern_c = false;
  }

      if (token->type == CPP_PRAGMA)
  {
    /* A top-level declaration can consist solely of a #pragma.
       A nested declaration cannot, so this is done here and not
       in cp_parser_declaration.  (A #pragma at block scope is
       handled in cp_parser_statement.)  */
    cp_parser_pragma (parser, pragma_external);
    continue;
  }

      /* Parse the declaration itself.  */
      cp_parser_declaration (parser);
    }
}

/* Parse a declaration.

   declaration:
     block-declaration
     function-definition
     template-declaration
     explicit-instantiation
     explicit-specialization
     linkage-specification
     namespace-definition

   GNU extension:

   declaration:
      __extension__ declaration */

static void
cp_parser_declaration (cp_parser* parser)
{
  cp_token token1;
  cp_token token2;
  int saved_pedantic;
  void *p;

  /* Check for the `__extension__' keyword.  */
  if (cp_parser_extension_opt (parser, &saved_pedantic))
    {
      /* Parse the qualified declaration.  */
      cp_parser_declaration (parser);
      /* Restore the PEDANTIC flag.  */
      pedantic = saved_pedantic;

      return;
    }

  /* Try to figure out what kind of declaration is present.  */
  token1 = *cp_lexer_peek_token (parser->lexer);

  if (token1.type != CPP_EOF)
    token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
  else
    {
      token2.type = CPP_EOF;
      token2.keyword = RID_MAX;
    }

  /* Get the high-water mark for the DECLARATOR_OBSTACK.  */
  p = obstack_alloc (&declarator_obstack, 0);

  /* If the next token is `extern' and the following token is a string
     literal, then we have a linkage specification.  */
  if (token1.keyword == RID_EXTERN
      && cp_parser_is_string_literal (&token2))
    cp_parser_linkage_specification (parser);
  /* If the next token is `template', then we have either a template
     declaration, an explicit instantiation, or an explicit
     specialization.  */
  else if (token1.keyword == RID_TEMPLATE)
    {
      /* `template <>' indicates a template specialization.  */
      if (token2.type == CPP_LESS
    && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
  cp_parser_explicit_specialization (parser);
      /* `template <' indicates a template declaration.  */
      else if (token2.type == CPP_LESS)
  cp_parser_template_declaration (parser, /*member_p=*/false);
      /* Anything else must be an explicit instantiation.  */
      else
  cp_parser_explicit_instantiation (parser);
    }
  /* If the next token is `export', then we have a template
     declaration.  */
  else if (token1.keyword == RID_EXPORT)
    cp_parser_template_declaration (parser, /*member_p=*/false);
  /* If the next token is `extern', 'static' or 'inline' and the one
     after that is `template', we have a GNU extended explicit
     instantiation directive.  */
  else if (cp_parser_allow_gnu_extensions_p (parser)
     && (token1.keyword == RID_EXTERN
         || token1.keyword == RID_STATIC
         || token1.keyword == RID_INLINE)
     && token2.keyword == RID_TEMPLATE)
    cp_parser_explicit_instantiation (parser);
  /* If the next token is `namespace', check for a named or unnamed
     namespace definition.  */
  else if (token1.keyword == RID_NAMESPACE
     && (/* A named namespace definition.  */
         (token2.type == CPP_NAME
    && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
        != CPP_EQ))
         /* An unnamed namespace definition.  */
         || token2.type == CPP_OPEN_BRACE
         || token2.keyword == RID_ATTRIBUTE))
    cp_parser_namespace_definition (parser);
  /* Objective-C++ declaration/definition.  */
  else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1.keyword))
    cp_parser_objc_declaration (parser);
  /* We must have either a block declaration or a function
     definition.  */
  else
    /* Try to parse a block-declaration, or a function-definition.  */
    cp_parser_block_declaration (parser, /*statement_p=*/false);

  /* Free any declarators allocated.  */
  obstack_free (&declarator_obstack, p);
}

/* Parse a block-declaration.

   block-declaration:
     simple-declaration
     asm-definition
     namespace-alias-definition
     using-declaration
     using-directive

   GNU Extension:

   block-declaration:
     __extension__ block-declaration
     label-declaration

   If STATEMENT_P is TRUE, then this block-declaration is occurring as
   part of a declaration-statement.  */

static void
cp_parser_block_declaration (cp_parser *parser,
           bool      statement_p)
{
  cp_token *token1;
  int saved_pedantic;

  /* Check for the `__extension__' keyword.  */
  if (cp_parser_extension_opt (parser, &saved_pedantic))
    {
      /* Parse the qualified declaration.  */
      cp_parser_block_declaration (parser, statement_p);
      /* Restore the PEDANTIC flag.  */
      pedantic = saved_pedantic;

      return;
    }

  /* Peek at the next token to figure out which kind of declaration is
     present.  */
  token1 = cp_lexer_peek_token (parser->lexer);

  /* If the next keyword is `asm', we have an asm-definition.  */
  if (token1->keyword == RID_ASM)
    {
      if (statement_p)
  cp_parser_commit_to_tentative_parse (parser);
      cp_parser_asm_definition (parser);
    }
  /* If the next keyword is `namespace', we have a
     namespace-alias-definition.  */
  else if (token1->keyword == RID_NAMESPACE)
    cp_parser_namespace_alias_definition (parser);
  /* If the next keyword is `using', we have either a
     using-declaration or a using-directive.  */
  else if (token1->keyword == RID_USING)
    {
      cp_token *token2;

      if (statement_p)
  cp_parser_commit_to_tentative_parse (parser);
      /* If the token after `using' is `namespace', then we have a
   using-directive.  */
      token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
      if (token2->keyword == RID_NAMESPACE)
  cp_parser_using_directive (parser);
      /* Otherwise, it's a using-declaration.  */
      else
  cp_parser_using_declaration (parser,
             /*access_declaration_p=*/false);
    }
  /* If the next keyword is `__label__' we have a label declaration.  */
  else if (token1->keyword == RID_LABEL)
    {
      if (statement_p)
  cp_parser_commit_to_tentative_parse (parser);
      cp_parser_label_declaration (parser);
    }
  /* Anything else must be a simple-declaration.  */
  else
    cp_parser_simple_declaration (parser, !statement_p);
}

/* Parse a simple-declaration.

   simple-declaration:
     decl-specifier-seq [opt] init-declarator-list [opt] ;

   init-declarator-list:
     init-declarator
     init-declarator-list , init-declarator

   If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
   function-definition as a simple-declaration.  */

static void
cp_parser_simple_declaration (cp_parser* parser,
            bool function_definition_allowed_p)
{
  cp_decl_specifier_seq decl_specifiers;
  int declares_class_or_enum;
  bool saw_declarator;

  /* Defer access checks until we know what is being declared; the
     checks for names appearing in the decl-specifier-seq should be
     done as if we were in the scope of the thing being declared.  */
  push_deferring_access_checks (dk_deferred);

  /* Parse the decl-specifier-seq.  We have to keep track of whether
     or not the decl-specifier-seq declares a named class or
     enumeration type, since that is the only case in which the
     init-declarator-list is allowed to be empty.

     [dcl.dcl]

     In a simple-declaration, the optional init-declarator-list can be
     omitted only when declaring a class or enumeration, that is when
     the decl-specifier-seq contains either a class-specifier, an
     elaborated-type-specifier, or an enum-specifier.  */
  cp_parser_decl_specifier_seq (parser,
        CP_PARSER_FLAGS_OPTIONAL,
        &decl_specifiers,
        &declares_class_or_enum);
  /* We no longer need to defer access checks.  */
  stop_deferring_access_checks ();

  /* In a block scope, a valid declaration must always have a
     decl-specifier-seq.  By not trying to parse declarators, we can
     resolve the declaration/expression ambiguity more quickly.  */
  if (!function_definition_allowed_p
      && !decl_specifiers.any_specifiers_p)
    {
      cp_parser_error (parser, "expected declaration");
      goto done;
    }

  /* If the next two tokens are both identifiers, the code is
     erroneous. The usual cause of this situation is code like:

       T t;

     where "T" should name a type -- but does not.  */
  if (!decl_specifiers.type
      && cp_parser_parse_and_diagnose_invalid_type_name (parser))
    {
      /* If parsing tentatively, we should commit; we really are
   looking at a declaration.  */
      cp_parser_commit_to_tentative_parse (parser);
      /* Give up.  */
      goto done;
    }

  /* If we have seen at least one decl-specifier, and the next token
     is not a parenthesis, then we must be looking at a declaration.
     (After "int (" we might be looking at a functional cast.)  */
  if (decl_specifiers.any_specifiers_p
      && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
    cp_parser_commit_to_tentative_parse (parser);

  /* Keep going until we hit the `;' at the end of the simple
     declaration.  */
  saw_declarator = false;
  while (cp_lexer_next_token_is_not (parser->lexer,
             CPP_SEMICOLON))
    {
      cp_token *token;
      bool function_definition_p;
      tree decl;

      if (saw_declarator)
  {
    /* If we are processing next declarator, coma is expected */
    token = cp_lexer_peek_token (parser->lexer);
    gcc_assert (token->type == CPP_COMMA);
    cp_lexer_consume_token (parser->lexer);
  }
      else
  saw_declarator = true;

      /* Parse the init-declarator.  */
      decl = cp_parser_init_declarator (parser, &decl_specifiers,
          /*checks=*/NULL,
          function_definition_allowed_p,
          /*member_p=*/false,
          declares_class_or_enum,
          &function_definition_p);
      /* If an error occurred while parsing tentatively, exit quickly.
   (That usually happens when in the body of a function; each
   statement is treated as a declaration-statement until proven
   otherwise.)  */
      if (cp_parser_error_occurred (parser))
  goto done;
      /* Handle function definitions specially.  */
      if (function_definition_p)
  {
    /* If the next token is a `,', then we are probably
       processing something like:

         void f() {}, *p;

       which is erroneous.  */
    if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
      error ("mixing declarations and function-definitions is forbidden");
    /* Otherwise, we're done with the list of declarators.  */
    else
      {
        pop_deferring_access_checks ();
        return;
      }
  }
      /* The next token should be either a `,' or a `;'.  */
      token = cp_lexer_peek_token (parser->lexer);
      /* If it's a `,', there are more declarators to come.  */
      if (token->type == CPP_COMMA)
  /* will be consumed next time around */;
      /* If it's a `;', we are done.  */
      else if (token->type == CPP_SEMICOLON)
  break;
      /* Anything else is an error.  */
      else
  {
    /* If we have already issued an error message we don't need
       to issue another one.  */
    if (decl != error_mark_node
        || cp_parser_uncommitted_to_tentative_parse_p (parser))
      cp_parser_error (parser, "expected %<,%> or %<;%>");
    /* Skip tokens until we reach the end of the statement.  */
    cp_parser_skip_to_end_of_statement (parser);
    /* If the next token is now a `;', consume it.  */
    if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
      cp_lexer_consume_token (parser->lexer);
    goto done;
  }
      /* After the first time around, a function-definition is not
   allowed -- even if it was OK at first.  For example:

     int i, f() {}

   is not valid.  */
      function_definition_allowed_p = false;
    }

  /* Issue an error message if no declarators are present, and the
     decl-specifier-seq does not itself declare a class or
     enumeration.  */
  if (!saw_declarator)
    {
      if (cp_parser_declares_only_class_p (parser))
  shadow_tag (&decl_specifiers);
      /* Perform any deferred access checks.  */
      perform_deferred_access_checks ();
    }

  /* Consume the `;'.  */
  cp_parser_require (parser, CPP_SEMICOLON, "`;'");

 done:
  pop_deferring_access_checks ();
}

/* Parse a decl-specifier-seq.

   decl-specifier-seq:
     decl-specifier-seq [opt] decl-specifier

   decl-specifier:
     storage-class-specifier
     type-specifier
     function-specifier
     friend
     typedef

   GNU Extension:

   decl-specifier:
     attributes

   Set *DECL_SPECS to a representation of the decl-specifier-seq.

   The parser flags FLAGS is used to control type-specifier parsing.

   *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
   flags:

     1: one of the decl-specifiers is an elaborated-type-specifier
  (i.e., a type declaration)
     2: one of the decl-specifiers is an enum-specifier or a
  class-specifier (i.e., a type definition)

   */

static void
cp_parser_decl_specifier_seq (cp_parser* parser,
            cp_parser_flags flags,
            cp_decl_specifier_seq *decl_specs,
            int* declares_class_or_enum)
{
  bool constructor_possible_p = !parser->in_declarator_p;

  /* Clear DECL_SPECS.  */
  clear_decl_specs (decl_specs);

  /* Assume no class or enumeration type is declared.  */
  *declares_class_or_enum = 0;

  /* Keep reading specifiers until there are no more to read.  */
  while (true)
    {
      bool constructor_p;
      bool found_decl_spec;
      cp_token *token;

      /* Peek at the next token.  */
      token = cp_lexer_peek_token (parser->lexer);
      /* Handle attributes.  */
      if (token->keyword == RID_ATTRIBUTE)
  {
    /* Parse the attributes.  */
    decl_specs->attributes
      = chainon (decl_specs->attributes,
           cp_parser_attributes_opt (parser));
    continue;
  }
      /* Assume we will find a decl-specifier keyword.  */
      found_decl_spec = true;
      /* If the next token is an appropriate keyword, we can simply
   add it to the list.  */
      switch (token->keyword)
  {
    /* decl-specifier:
         friend  */
  case RID_FRIEND:
    if (!at_class_scope_p ())
      {
        error ("%<friend%> used outside of class");
        cp_lexer_purge_token (parser->lexer);
      }
    else
      {
        ++decl_specs->specs[(int) ds_friend];
        /* Consume the token.  */
        cp_lexer_consume_token (parser->lexer);
      }
    break;

    /* function-specifier:
         inline
         virtual
         explicit  */
  case RID_INLINE:
  case RID_VIRTUAL:
  case RID_EXPLICIT:
    cp_parser_function_specifier_opt (parser, decl_specs);
    break;

    /* decl-specifier:
         typedef  */
  case RID_TYPEDEF:
    ++decl_specs->specs[(int) ds_typedef];
    /* Consume the token.  */
    cp_lexer_consume_token (parser->lexer);
    /* A constructor declarator cannot appear in a typedef.  */
    constructor_possible_p = false;
    /* The "typedef" keyword can only occur in a declaration; we
       may as well commit at this point.  */
    cp_parser_commit_to_tentative_parse (parser);

          if (decl_specs->storage_class != sc_none)
            decl_specs->conflicting_specifiers_p = true;
    break;

    /* storage-class-specifier:
         auto
         register
         static
         extern
         mutable

       GNU Extension:
         thread  */
  case RID_AUTO:
  case RID_REGISTER:
  case RID_STATIC:
  case RID_EXTERN:
  case RID_MUTABLE:
    /* Consume the token.  */
    cp_lexer_consume_token (parser->lexer);
    cp_parser_set_storage_class (parser, decl_specs, token->keyword);
    break;
  case RID_THREAD:
    /* Consume the token.  */
    cp_lexer_consume_token (parser->lexer);
    ++decl_specs->specs[(int) ds_thread];
    break;

  default:
    /* We did not yet find a decl-specifier yet.  */
    found_decl_spec = false;
    break;
  }

      /* Constructors are a special case.  The `S' in `S()' is not a
   decl-specifier; it is the beginning of the declarator.  */
      constructor_p
  = (!found_decl_spec
     && constructor_possible_p
     && (cp_parser_constructor_declarator_p
         (parser, decl_specs->specs[(int) ds_friend] != 0)));

      /* If we don't have a DECL_SPEC yet, then we must be looking at
   a type-specifier.  */
      if (!found_decl_spec && !constructor_p)
  {
    int decl_spec_declares_class_or_enum;
    bool is_cv_qualifier;
    tree type_spec;

    type_spec
      = cp_parser_type_specifier (parser, flags,
          decl_specs,
          /*is_declaration=*/true,
          &decl_spec_declares_class_or_enum,
          &is_cv_qualifier);

    *declares_class_or_enum |= decl_spec_declares_class_or_enum;

    /* If this type-specifier referenced a user-defined type
       (a typedef, class-name, etc.), then we can't allow any
       more such type-specifiers henceforth.

       [dcl.spec]

       The longest sequence of decl-specifiers that could
       possibly be a type name is taken as the
       decl-specifier-seq of a declaration.  The sequence shall
       be self-consistent as described below.

       [dcl.type]

       As a general rule, at most one type-specifier is allowed
       in the complete decl-specifier-seq of a declaration.  The
       only exceptions are the following:

       -- const or volatile can be combined with any other
    type-specifier.

       -- signed or unsigned can be combined with char, long,
    short, or int.

       -- ..

       Example:

         typedef char* Pc;
         void g (const int Pc);

       Here, Pc is *not* part of the decl-specifier seq; it's
       the declarator.  Therefore, once we see a type-specifier
       (other than a cv-qualifier), we forbid any additional
       user-defined types.  We *do* still allow things like `int
       int' to be considered a decl-specifier-seq, and issue the
       error message later.  */
    if (type_spec && !is_cv_qualifier)
      flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
    /* A constructor declarator cannot follow a type-specifier.  */
    if (type_spec)
      {
        constructor_possible_p = false;
        found_decl_spec = true;
      }
  }

      /* If we still do not have a DECL_SPEC, then there are no more
   decl-specifiers.  */
      if (!found_decl_spec)
  break;

      decl_specs->any_specifiers_p = true;
      /* After we see one decl-specifier, further decl-specifiers are
   always optional.  */
      flags |= CP_PARSER_FLAGS_OPTIONAL;
    }

  cp_parser_check_decl_spec (decl_specs);

  /* Don't allow a friend specifier with a class definition.  */
  if (decl_specs->specs[(int) ds_friend] != 0
      && (*declares_class_or_enum & 2))
    error ("class definition may not be declared a friend");
}

/* Parse an (optional) storage-class-specifier.

   storage-class-specifier:
     auto
     register
     static
     extern
     mutable

   GNU Extension:

   storage-class-specifier:
     thread

   Returns an IDENTIFIER_NODE corresponding to the keyword used.  */

static tree
cp_parser_storage_class_specifier_opt (cp_parser* parser)
{
  switch (cp_lexer_peek_token (parser->lexer)->keyword)
    {
    case RID_AUTO:
    case RID_REGISTER:
    case RID_STATIC:
    case RID_EXTERN:
    case RID_MUTABLE:
    case RID_THREAD:
      /* Consume the token.  */
      return cp_lexer_consume_token (parser->lexer)->u.value;

    default:
      return NULL_TREE;
    }
}

/* Parse an (optional) function-specifier.

   function-specifier:
     inline
     virtual
     explicit

   Returns an IDENTIFIER_NODE corresponding to the keyword used.
   Updates DECL_SPECS, if it is non-NULL.  */

static tree
cp_parser_function_specifier_opt (cp_parser* parser,
          cp_decl_specifier_seq *decl_specs)
{
  switch (cp_lexer_peek_token (parser->lexer)->keyword)
    {
    case RID_INLINE:
      if (decl_specs)
  ++decl_specs->specs[(int) ds_inline];
      break;

    case RID_VIRTUAL:
      /* 14.5.2.3 [temp.mem]

   A member function template shall not be virtual.  */
      if (PROCESSING_REAL_TEMPLATE_DECL_P ())
  error ("templates may not be %<virtual%>");
      else if (decl_specs)
  ++decl_specs->specs[(int) ds_virtual];
      break;

    case RID_EXPLICIT:
      if (decl_specs)
  ++decl_specs->specs[(int) ds_explicit];
      break;

    default:
      return NULL_TREE;
    }

  /* Consume the token.  */
  return cp_lexer_consume_token (parser->lexer)->u.value;
}

/* Parse a linkage-specification.

   linkage-specification:
     extern string-literal { declaration-seq [opt] }
     extern string-literal declaration  */

static void
cp_parser_linkage_specification (cp_parser* parser)
{
  tree linkage;

  /* Look for the `extern' keyword.  */
  cp_parser_require_keyword (parser, RID_EXTERN, "`extern'");

  /* Look for the string-literal.  */
  linkage = cp_parser_string_literal (parser, false, false);

  /* Transform the literal into an identifier.  If the literal is a
     wide-character string, or contains embedded NULs, then we can't
     handle it as the user wants.  */
  if (strlen (TREE_STRING_POINTER (linkage))
      != (size_t) (TREE_STRING_LENGTH (linkage) - 1))
    {
      cp_parser_error (parser, "invalid linkage-specification");
      /* Assume C++ linkage.  */
      linkage = lang_name_cplusplus;
    }
  else
    linkage = get_identifier (TREE_STRING_POINTER (linkage));

  /* We're now using the new linkage.  */
  push_lang_context (linkage);

  /* If the next token is a `{', then we're using the first
     production.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
    {
      /* Consume the `{' token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the declarations.  */
      cp_parser_declaration_seq_opt (parser);
      /* Look for the closing `}'.  */
      cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
    }
  /* Otherwise, there's just one declaration.  */
  else
    {
      bool saved_in_unbraced_linkage_specification_p;

      saved_in_unbraced_linkage_specification_p
  = parser->in_unbraced_linkage_specification_p;
      parser->in_unbraced_linkage_specification_p = true;
      cp_parser_declaration (parser);
      parser->in_unbraced_linkage_specification_p
  = saved_in_unbraced_linkage_specification_p;
    }

  /* We're done with the linkage-specification.  */
  pop_lang_context ();
}

/* Special member functions [gram.special] */

/* Parse a conversion-function-id.

   conversion-function-id:
     operator conversion-type-id

   Returns an IDENTIFIER_NODE representing the operator.  */

static tree
cp_parser_conversion_function_id (cp_parser* parser)
{
  tree type;
  tree saved_scope;
  tree saved_qualifying_scope;
  tree saved_object_scope;
  tree pushed_scope = NULL_TREE;

  /* Look for the `operator' token.  */
  if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'"))
    return error_mark_node;
  /* When we parse the conversion-type-id, the current scope will be
     reset.  However, we need that information in able to look up the
     conversion function later, so we save it here.  */
  saved_scope = parser->scope;
  saved_qualifying_scope = parser->qualifying_scope;
  saved_object_scope = parser->object_scope;
  /* We must enter the scope of the class so that the names of
     entities declared within the class are available in the
     conversion-type-id.  For example, consider:

       struct S {
   typedef int I;
   operator I();
       };

       S::operator I() { ... }

     In order to see that `I' is a type-name in the definition, we
     must be in the scope of `S'.  */
  if (saved_scope)
    pushed_scope = push_scope (saved_scope);
  /* Parse the conversion-type-id.  */
  type = cp_parser_conversion_type_id (parser);
  /* Leave the scope of the class, if any.  */
  if (pushed_scope)
    pop_scope (pushed_scope);
  /* Restore the saved scope.  */
  parser->scope = saved_scope;
  parser->qualifying_scope = saved_qualifying_scope;
  parser->object_scope = saved_object_scope;
  /* If the TYPE is invalid, indicate failure.  */
  if (type == error_mark_node)
    return error_mark_node;
  return mangle_conv_op_name_for_type (type);
}

/* Parse a conversion-type-id:

   conversion-type-id:
     type-specifier-seq conversion-declarator [opt]

   Returns the TYPE specified.  */

static tree
cp_parser_conversion_type_id (cp_parser* parser)
{
  tree attributes;
  cp_decl_specifier_seq type_specifiers;
  cp_declarator *declarator;
  tree type_specified;

  /* Parse the attributes.  */
  attributes = cp_parser_attributes_opt (parser);
  /* Parse the type-specifiers.  */
  cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
        &type_specifiers);
  /* If that didn't work, stop.  */
  if (type_specifiers.type == error_mark_node)
    return error_mark_node;
  /* Parse the conversion-declarator.  */
  declarator = cp_parser_conversion_declarator_opt (parser);

  type_specified =  grokdeclarator (declarator, &type_specifiers, TYPENAME,
            /*initialized=*/0, &attributes);
  if (attributes)
    cplus_decl_attributes (&type_specified, attributes, /*flags=*/0);
  return type_specified;
}

/* Parse an (optional) conversion-declarator.

   conversion-declarator:
     ptr-operator conversion-declarator [opt]

   */

static cp_declarator *
cp_parser_conversion_declarator_opt (cp_parser* parser)
{
  enum tree_code code;
  tree class_type;
  cp_cv_quals cv_quals;

  /* We don't know if there's a ptr-operator next, or not.  */
  cp_parser_parse_tentatively (parser);
  /* Try the ptr-operator.  */
  code = cp_parser_ptr_operator (parser, &class_type, &cv_quals);
  /* If it worked, look for more conversion-declarators.  */
  if (cp_parser_parse_definitely (parser))
    {
      cp_declarator *declarator;

      /* Parse another optional declarator.  */
      declarator = cp_parser_conversion_declarator_opt (parser);

      /* Create the representation of the declarator.  */
      if (class_type)
  declarator = make_ptrmem_declarator (cv_quals, class_type,
               declarator);
      else if (code == INDIRECT_REF)
  declarator = make_pointer_declarator (cv_quals, declarator);
      else
  declarator = make_reference_declarator (cv_quals, declarator);

      return declarator;
   }

  return NULL;
}

/* Parse an (optional) ctor-initializer.

   ctor-initializer:
     : mem-initializer-list

   Returns TRUE iff the ctor-initializer was actually present.  */

static bool
cp_parser_ctor_initializer_opt (cp_parser* parser)
{
  /* If the next token is not a `:', then there is no
     ctor-initializer.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
    {
      /* Do default initialization of any bases and members.  */
      if (DECL_CONSTRUCTOR_P (current_function_decl))
  finish_mem_initializers (NULL_TREE);

      return false;
    }

  /* Consume the `:' token.  */
  cp_lexer_consume_token (parser->lexer);
  /* And the mem-initializer-list.  */
  cp_parser_mem_initializer_list (parser);

  return true;
}

/* Parse a mem-initializer-list.

   mem-initializer-list:
     mem-initializer
     mem-initializer , mem-initializer-list  */

static void
cp_parser_mem_initializer_list (cp_parser* parser)
{
  tree mem_initializer_list = NULL_TREE;

  /* Let the semantic analysis code know that we are starting the
     mem-initializer-list.  */
  if (!DECL_CONSTRUCTOR_P (current_function_decl))
    error ("only constructors take base initializers");

  /* Loop through the list.  */
  while (true)
    {
      tree mem_initializer;

      /* Parse the mem-initializer.  */
      mem_initializer = cp_parser_mem_initializer (parser);
      /* Add it to the list, unless it was erroneous.  */
      if (mem_initializer != error_mark_node)
  {
    TREE_CHAIN (mem_initializer) = mem_initializer_list;
    mem_initializer_list = mem_initializer;
  }
      /* If the next token is not a `,', we're done.  */
      if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
  break;
      /* Consume the `,' token.  */
      cp_lexer_consume_token (parser->lexer);
    }

  /* Perform semantic analysis.  */
  if (DECL_CONSTRUCTOR_P (current_function_decl))
    finish_mem_initializers (mem_initializer_list);
}

/* Parse a mem-initializer.

   mem-initializer:
     mem-initializer-id ( expression-list [opt] )

   GNU extension:

   mem-initializer:
     ( expression-list [opt] )

   Returns a TREE_LIST.  The TREE_PURPOSE is the TYPE (for a base
   class) or FIELD_DECL (for a non-static data member) to initialize;
   the TREE_VALUE is the expression-list.  An empty initialization
   list is represented by void_list_node.  */

static tree
cp_parser_mem_initializer (cp_parser* parser)
{
  tree mem_initializer_id;
  tree expression_list;
  tree member;

  /* Find out what is being initialized.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
    {
      pedwarn ("anachronistic old-style base class initializer");
      mem_initializer_id = NULL_TREE;
    }
  else
    mem_initializer_id = cp_parser_mem_initializer_id (parser);
  member = expand_member_init (mem_initializer_id);
  if (member && !DECL_P (member))
    in_base_initializer = 1;

  expression_list
    = cp_parser_parenthesized_expression_list (parser, false,
                 /*cast_p=*/false,
                 /*non_constant_p=*/NULL);
  if (expression_list == error_mark_node)
    return error_mark_node;
  if (!expression_list)
    expression_list = void_type_node;

  in_base_initializer = 0;

  return member ? build_tree_list (member, expression_list) : error_mark_node;
}

/* Parse a mem-initializer-id.

   mem-initializer-id:
     :: [opt] nested-name-specifier [opt] class-name
     identifier

   Returns a TYPE indicating the class to be initializer for the first
   production.  Returns an IDENTIFIER_NODE indicating the data member
   to be initialized for the second production.  */

static tree
cp_parser_mem_initializer_id (cp_parser* parser)
{
  bool global_scope_p;
  bool nested_name_specifier_p;
  bool template_p = false;
  tree id;

  /* `typename' is not allowed in this context ([temp.res]).  */
  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
    {
      error ("keyword %<typename%> not allowed in this context (a qualified "
       "member initializer is implicitly a type)");
      cp_lexer_consume_token (parser->lexer);
    }
  /* Look for the optional `::' operator.  */
  global_scope_p
    = (cp_parser_global_scope_opt (parser,
           /*current_scope_valid_p=*/false)
       != NULL_TREE);
  /* Look for the optional nested-name-specifier.  The simplest way to
     implement:

       [temp.res]

       The keyword `typename' is not permitted in a base-specifier or
       mem-initializer; in these contexts a qualified name that
       depends on a template-parameter is implicitly assumed to be a
       type name.

     is to assume that we have seen the `typename' keyword at this
     point.  */
  nested_name_specifier_p
    = (cp_parser_nested_name_specifier_opt (parser,
              /*typename_keyword_p=*/true,
              /*check_dependency_p=*/true,
              /*type_p=*/true,
              /*is_declaration=*/true)
       != NULL_TREE);
  if (nested_name_specifier_p)
    template_p = cp_parser_optional_template_keyword (parser);
  /* If there is a `::' operator or a nested-name-specifier, then we
     are definitely looking for a class-name.  */
  if (global_scope_p || nested_name_specifier_p)
    return cp_parser_class_name (parser,
         /*typename_keyword_p=*/true,
         /*template_keyword_p=*/template_p,
         none_type,
         /*check_dependency_p=*/true,
         /*class_head_p=*/false,
         /*is_declaration=*/true);
  /* Otherwise, we could also be looking for an ordinary identifier.  */
  cp_parser_parse_tentatively (parser);
  /* Try a class-name.  */
  id = cp_parser_class_name (parser,
           /*typename_keyword_p=*/true,
           /*template_keyword_p=*/false,
           none_type,
           /*check_dependency_p=*/true,
           /*class_head_p=*/false,
           /*is_declaration=*/true);
  /* If we found one, we're done.  */
  if (cp_parser_parse_definitely (parser))
    return id;
  /* Otherwise, look for an ordinary identifier.  */
  return cp_parser_identifier (parser);
}

/* Overloading [gram.over] */

/* Parse an operator-function-id.

   operator-function-id:
     operator operator

   Returns an IDENTIFIER_NODE for the operator which is a
   human-readable spelling of the identifier, e.g., `operator +'.  */

static tree
cp_parser_operator_function_id (cp_parser* parser)
{
  /* Look for the `operator' keyword.  */
  if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'"))
    return error_mark_node;
  /* And then the name of the operator itself.  */
  return cp_parser_operator (parser);
}

/* Parse an operator.

   operator:
     new delete new[] delete[] + - * / % ^ & | ~ ! = < >
     += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
     || ++ -- , ->* -> () []

   GNU Extensions:

   operator:
     <? >? <?= >?=

   Returns an IDENTIFIER_NODE for the operator which is a
   human-readable spelling of the identifier, e.g., `operator +'.  */

static tree
cp_parser_operator (cp_parser* parser)
{
  tree id = NULL_TREE;
  cp_token *token;

  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);
  /* Figure out which operator we have.  */
  switch (token->type)
    {
    case CPP_KEYWORD:
      {
  enum tree_code op;

  /* The keyword should be either `new' or `delete'.  */
  if (token->keyword == RID_NEW)
    op = NEW_EXPR;
  else if (token->keyword == RID_DELETE)
    op = DELETE_EXPR;
  else
    break;

  /* Consume the `new' or `delete' token.  */
  cp_lexer_consume_token (parser->lexer);

  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);
  /* If it's a `[' token then this is the array variant of the
     operator.  */
  if (token->type == CPP_OPEN_SQUARE)
    {
      /* Consume the `[' token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Look for the `]' token.  */
      cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
      id = ansi_opname (op == NEW_EXPR
            ? VEC_NEW_EXPR : VEC_DELETE_EXPR);
    }
  /* Otherwise, we have the non-array variant.  */
  else
    id = ansi_opname (op);

  return id;
      }

    case CPP_PLUS:
      id = ansi_opname (PLUS_EXPR);
      break;

    case CPP_MINUS:
      id = ansi_opname (MINUS_EXPR);
      break;

    case CPP_MULT:
      id = ansi_opname (MULT_EXPR);
      break;

    case CPP_DIV:
      id = ansi_opname (TRUNC_DIV_EXPR);
      break;

    case CPP_MOD:
      id = ansi_opname (TRUNC_MOD_EXPR);
      break;

    case CPP_XOR:
      id = ansi_opname (BIT_XOR_EXPR);
      break;

    case CPP_AND:
      id = ansi_opname (BIT_AND_EXPR);
      break;

    case CPP_OR:
      id = ansi_opname (BIT_IOR_EXPR);
      break;

    case CPP_COMPL:
      id = ansi_opname (BIT_NOT_EXPR);
      break;

    case CPP_NOT:
      id = ansi_opname (TRUTH_NOT_EXPR);
      break;

    case CPP_EQ:
      id = ansi_assopname (NOP_EXPR);
      break;

    case CPP_LESS:
      id = ansi_opname (LT_EXPR);
      break;

    case CPP_GREATER:
      id = ansi_opname (GT_EXPR);
      break;

    case CPP_PLUS_EQ:
      id = ansi_assopname (PLUS_EXPR);
      break;

    case CPP_MINUS_EQ:
      id = ansi_assopname (MINUS_EXPR);
      break;

    case CPP_MULT_EQ:
      id = ansi_assopname (MULT_EXPR);
      break;

    case CPP_DIV_EQ:
      id = ansi_assopname (TRUNC_DIV_EXPR);
      break;

    case CPP_MOD_EQ:
      id = ansi_assopname (TRUNC_MOD_EXPR);
      break;

    case CPP_XOR_EQ:
      id = ansi_assopname (BIT_XOR_EXPR);
      break;

    case CPP_AND_EQ:
      id = ansi_assopname (BIT_AND_EXPR);
      break;

    case CPP_OR_EQ:
      id = ansi_assopname (BIT_IOR_EXPR);
      break;

    case CPP_LSHIFT:
      id = ansi_opname (LSHIFT_EXPR);
      break;

    case CPP_RSHIFT:
      id = ansi_opname (RSHIFT_EXPR);
      break;

    case CPP_LSHIFT_EQ:
      id = ansi_assopname (LSHIFT_EXPR);
      break;

    case CPP_RSHIFT_EQ:
      id = ansi_assopname (RSHIFT_EXPR);
      break;

    case CPP_EQ_EQ:
      id = ansi_opname (EQ_EXPR);
      break;

    case CPP_NOT_EQ:
      id = ansi_opname (NE_EXPR);
      break;

    case CPP_LESS_EQ:
      id = ansi_opname (LE_EXPR);
      break;

    case CPP_GREATER_EQ:
      id = ansi_opname (GE_EXPR);
      break;

    case CPP_AND_AND:
      id = ansi_opname (TRUTH_ANDIF_EXPR);
      break;

    case CPP_OR_OR:
      id = ansi_opname (TRUTH_ORIF_EXPR);
      break;

    case CPP_PLUS_PLUS:
      id = ansi_opname (POSTINCREMENT_EXPR);
      break;

    case CPP_MINUS_MINUS:
      id = ansi_opname (PREDECREMENT_EXPR);
      break;

    case CPP_COMMA:
      id = ansi_opname (COMPOUND_EXPR);
      break;

    case CPP_DEREF_STAR:
      id = ansi_opname (MEMBER_REF);
      break;

    case CPP_DEREF:
      id = ansi_opname (COMPONENT_REF);
      break;

    case CPP_OPEN_PAREN:
      /* Consume the `('.  */
      cp_lexer_consume_token (parser->lexer);
      /* Look for the matching `)'.  */
      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
      return ansi_opname (CALL_EXPR);

    case CPP_OPEN_SQUARE:
      /* Consume the `['.  */
      cp_lexer_consume_token (parser->lexer);
      /* Look for the matching `]'.  */
      cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
      return ansi_opname (ARRAY_REF);

    default:
      /* Anything else is an error.  */
      break;
    }

  /* If we have selected an identifier, we need to consume the
     operator token.  */
  if (id)
    cp_lexer_consume_token (parser->lexer);
  /* Otherwise, no valid operator name was present.  */
  else
    {
      cp_parser_error (parser, "expected operator");
      id = error_mark_node;
    }

  return id;
}

/* Parse a template-declaration.

   template-declaration:
     export [opt] template < template-parameter-list > declaration

   If MEMBER_P is TRUE, this template-declaration occurs within a
   class-specifier.

   The grammar rule given by the standard isn't correct.  What
   is really meant is:

   template-declaration:
     export [opt] template-parameter-list-seq
       decl-specifier-seq [opt] init-declarator [opt] ;
     export [opt] template-parameter-list-seq
       function-definition

   template-parameter-list-seq:
     template-parameter-list-seq [opt]
     template < template-parameter-list >  */

static void
cp_parser_template_declaration (cp_parser* parser, bool member_p)
{
  /* Check for `export'.  */
  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
    {
      /* Consume the `export' token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Warn that we do not support `export'.  */
      warning (0, "keyword %<export%> not implemented, and will be ignored");
    }

  cp_parser_template_declaration_after_export (parser, member_p);
}

/* Parse a template-parameter-list.

   template-parameter-list:
     template-parameter
     template-parameter-list , template-parameter

   Returns a TREE_LIST.  Each node represents a template parameter.
   The nodes are connected via their TREE_CHAINs.  */

static tree
cp_parser_template_parameter_list (cp_parser* parser)
{
  tree parameter_list = NULL_TREE;

  begin_template_parm_list ();
  while (true)
    {
      tree parameter;
      cp_token *token;
      bool is_non_type;

      /* Parse the template-parameter.  */
      parameter = cp_parser_template_parameter (parser, &is_non_type);
      /* Add it to the list.  */
      if (parameter != error_mark_node)
  parameter_list = process_template_parm (parameter_list,
            parameter,
            is_non_type);
      else
       {
         tree err_parm = build_tree_list (parameter, parameter);
         TREE_VALUE (err_parm) = error_mark_node;
         parameter_list = chainon (parameter_list, err_parm);
       }

      /* Peek at the next token.  */
      token = cp_lexer_peek_token (parser->lexer);
      /* If it's not a `,', we're done.  */
      if (token->type != CPP_COMMA)
  break;
      /* Otherwise, consume the `,' token.  */
      cp_lexer_consume_token (parser->lexer);
    }

  return end_template_parm_list (parameter_list);
}

/* Parse a template-parameter.

   template-parameter:
     type-parameter
     parameter-declaration

   If all goes well, returns a TREE_LIST.  The TREE_VALUE represents
   the parameter.  The TREE_PURPOSE is the default value, if any.
   Returns ERROR_MARK_NODE on failure.  *IS_NON_TYPE is set to true
   iff this parameter is a non-type parameter.  */

static tree
cp_parser_template_parameter (cp_parser* parser, bool *is_non_type)
{
  cp_token *token;
  cp_parameter_declarator *parameter_declarator;
  tree parm;

  /* Assume it is a type parameter or a template parameter.  */
  *is_non_type = false;
  /* Peek at the next token.  */
  token = cp_lexer_peek_token (parser->lexer);
  /* If it is `class' or `template', we have a type-parameter.  */
  if (token->keyword == RID_TEMPLATE)
    return cp_parser_type_parameter (parser);
  /* If it is `class' or `typename' we do not know yet whether it is a
     type parameter or a non-type parameter.  Consider:

       template <typename T, typename T::X X> ...

     or:

       template <class C, class D*> ...

     Here, the first parameter is a type parameter, and the second is
     a non-type parameter.  We can tell by looking at the token after
     the identifier -- if it is a `,', `=', or `>' then we have a type
     parameter.  */
  if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)
    {
      /* Peek at the token after `class' or `typename'.  */
      token = cp_lexer_peek_nth_token (parser->lexer, 2);
      /* If it's an identifier, skip it.  */
      if (token->type == CPP_NAME)
  token = cp_lexer_peek_nth_token (parser->lexer, 3);
      /* Now, see if the token looks like the end of a template
   parameter.  */
      if (token->type == CPP_COMMA
    || token->type == CPP_EQ
    || token->type == CPP_GREATER)
  return cp_parser_type_parameter (parser);
    }

  /* Otherwise, it is a non-type parameter.

     [temp.param]

     When parsing a default template-argument for a non-type
     template-parameter, the first non-nested `>' is taken as the end
     of the template parameter-list rather than a greater-than
     operator.  */
  *is_non_type = true;
  parameter_declarator
     = cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
          /*parenthesized_p=*/NULL);
  parm = grokdeclarator (parameter_declarator->declarator,
       &parameter_declarator->decl_specifiers,
       PARM, /*initialized=*/0,
       /*attrlist=*/NULL);
  if (parm == error_mark_node)
    return error_mark_node;
  return build_tree_list (parameter_declarator->default_argument, parm);
}

/* Parse a type-parameter.

   type-parameter:
     class identifier [opt]
     class identifier [opt] = type-id
     typename identifier [opt]
     typename identifier [opt] = type-id
     template < template-parameter-list > class identifier [opt]
     template < template-parameter-list > class identifier [opt]
       = id-expression

   Returns a TREE_LIST.  The TREE_VALUE is itself a TREE_LIST.  The
   TREE_PURPOSE is the default-argument, if any.  The TREE_VALUE is
   the declaration of the parameter.  */

static tree
cp_parser_type_parameter (cp_parser* parser)
{
  cp_token *token;
  tree parameter;

  /* Look for a keyword to tell us what kind of parameter this is.  */
  token = cp_parser_require (parser, CPP_KEYWORD,
           "`class', `typename', or `template'");
  if (!token)
    return error_mark_node;

  switch (token->keyword)
    {
    case RID_CLASS:
    case RID_TYPENAME:
      {
  tree identifier;
  tree default_argument;

  /* If the next token is an identifier, then it names the
     parameter.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
    identifier = cp_parser_identifier (parser);
  else
    identifier = NULL_TREE;

  /* Create the parameter.  */
  parameter = finish_template_type_parm (class_type_node, identifier);

  /* If the next token is an `=', we have a default argument.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
    {
      /* Consume the `=' token.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the default-argument.  */
      push_deferring_access_checks (dk_no_deferred);
      default_argument = cp_parser_type_id (parser);
      pop_deferring_access_checks ();
    }
  else
    default_argument = NULL_TREE;

  /* Create the combined representation of the parameter and the
     default argument.  */
  parameter = build_tree_list (default_argument, parameter);
      }
      break;

    case RID_TEMPLATE:
      {
  tree parameter_list;
  tree identifier;
  tree default_argument;

  /* Look for the `<'.  */
  cp_parser_require (parser, CPP_LESS, "`<'");
  /* Parse the template-parameter-list.  */
  parameter_list = cp_parser_template_parameter_list (parser);
  /* Look for the `>'.  */
  cp_parser_require (parser, CPP_GREATER, "`>'");
  /* Look for the `class' keyword.  */
  cp_parser_require_keyword (parser, RID_CLASS, "`class'");
  /* If the next token is an `=', then there is a
     default-argument.  If the next token is a `>', we are at
     the end of the parameter-list.  If the next token is a `,',
     then we are at the end of this parameter.  */
  if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
      && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
      && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
    {
      identifier = cp_parser_identifier (parser);
      /* Treat invalid names as if the parameter were nameless.  */
      if (identifier == error_mark_node)
        identifier = NULL_TREE;
    }
  else
    identifier = NULL_TREE;

  /* Create the template parameter.  */
  parameter = finish_template_template_parm (class_type_node,
               identifier);

  /* If the next token is an `=', then there is a
     default-argument.  */
  if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
    {
      bool is_template;

      /* Consume the `='.  */
      cp_lexer_consume_token (parser->lexer);
      /* Parse the id-expression.  */
      push_deferring_access_checks (dk_no_deferred);
      default_argument
        = cp_parser_id_expression (parser,
           /*template_keyword_p=*/false,
           /*check_dependency_p=*/true,
           /*template_p=*/&is_template,
           /*declarator_p=*/false,
           /*optional_p=*/false);
      if (TREE_CODE (default_argument) == TYPE_DECL)
        /* If the id-expression was a template-id that refers to
     a template-class, we already have the declaration here,
     so no further lookup is needed.  */
     ;
      else
        /* Look up the name.  */
        default_argument
    = cp_parser_lookup_name (parser, default_argument,
           none_type,
           /*is_template=*/is_template,
           /*is_namespace=*/false,
           /*check_dependency=*/true,