This commit was generated by cvs2svn to compensate for changes in r132718,

which included commits to RCS files with non-trunk default branches.

1 files changed, 15323 insertions, 0 deletions

diff --git a/contrib/gcc/cp/parser.c b/contrib/gcc/cp/parser.c
new file mode 100644
index 0000000..344a8f5
--- /dev/null
+++ b/contrib/gcc/cp/parser.c
@@ -0,0 +1,15323 @@
+/* C++ Parser.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004 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, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, 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"
+
+
+/* The lexer.  */
+
+/* Overview
+   --------
+
+   A cp_lexer represents a stream of cp_tokens.  It allows arbitrary
+   look-ahead.
+
+   Methodology
+   -----------
+
+   We use a circular buffer to store incoming tokens.
+
+   Some artifacts of the C++ language (such as the
+   expression/declaration ambiguity) require arbitrary look-ahead.
+   The strategy we adopt for dealing with these problems is to attempt
+   to parse one construct (e.g., the declaration) and fall back to the
+   other (e.g., the expression) if that attempt does not succeed.
+   Therefore, we must sometimes store an arbitrary number of tokens.
+
+   The parser routinely peeks at the next token, and then consumes it
+   later.  That also requires a buffer in which to store the tokens.
+     
+   In order to easily permit adding tokens to the end of the buffer,
+   while removing them from the beginning of the buffer, we use a
+   circular buffer.  */
+
+/* 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;
+  /* The value associated with this token, if any.  */
+  tree value;
+  /* The location at which this token was found.  */
+  location_t location;
+} cp_token;
+
+/* The number of tokens in a single token block.
+   Computed so that cp_token_block fits in a 512B allocation unit.  */
+
+#define CP_TOKEN_BLOCK_NUM_TOKENS ((512 - 3*sizeof (char*))/sizeof (cp_token))
+
+/* A group of tokens.  These groups are chained together to store
+   large numbers of tokens.  (For example, a token block is created
+   when the body of an inline member function is first encountered;
+   the tokens are processed later after the class definition is
+   complete.)  
+
+   This somewhat ungainly data structure (as opposed to, say, a
+   variable-length array), is used due to constraints imposed by the
+   current garbage-collection methodology.  If it is made more
+   flexible, we could perhaps simplify the data structures involved.  */
+
+typedef struct cp_token_block GTY (())
+{
+  /* The tokens.  */
+  cp_token tokens[CP_TOKEN_BLOCK_NUM_TOKENS];
+  /* The number of tokens in this block.  */
+  size_t num_tokens;
+  /* The next token block in the chain.  */
+  struct cp_token_block *next;
+  /* The previous block in the chain.  */
+  struct cp_token_block *prev;
+} cp_token_block;
+
+typedef struct cp_token_cache GTY (())
+{
+  /* The first block in the cache.  NULL if there are no tokens in the
+     cache.  */
+  cp_token_block *first;
+  /* The last block in the cache.  NULL If there are no tokens in the
+     cache.  */
+  cp_token_block *last;
+} cp_token_cache;
+
+/* Prototypes.  */
+
+static cp_token_cache *cp_token_cache_new 
+  (void);
+static void cp_token_cache_push_token
+  (cp_token_cache *, cp_token *);
+
+/* Create a new cp_token_cache.  */
+
+static cp_token_cache *
+cp_token_cache_new (void)
+{
+  return ggc_alloc_cleared (sizeof (cp_token_cache));
+}
+
+/* Add *TOKEN to *CACHE.  */
+
+static void
+cp_token_cache_push_token (cp_token_cache *cache,
+			   cp_token *token)
+{
+  cp_token_block *b = cache->last;
+
+  /* See if we need to allocate a new token block.  */
+  if (!b || b->num_tokens == CP_TOKEN_BLOCK_NUM_TOKENS)
+    {
+      b = ggc_alloc_cleared (sizeof (cp_token_block));
+      b->prev = cache->last;
+      if (cache->last)
+	{
+	  cache->last->next = b;
+	  cache->last = b;
+	}
+      else
+	cache->first = cache->last = b;
+    }
+  /* Add this token to the current token block.  */
+  b->tokens[b->num_tokens++] = *token;
+}
+
+/* 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.  */
+
+typedef struct cp_lexer GTY (())
+{
+  /* The memory allocated for the buffer.  Never NULL.  */
+  cp_token * GTY ((length ("(%h.buffer_end - %h.buffer)"))) buffer;
+  /* A pointer just past the end of the memory allocated for the buffer.  */
+  cp_token * GTY ((skip (""))) buffer_end;
+  /* The first valid token in the buffer, or NULL if none.  */
+  cp_token * GTY ((skip (""))) first_token;
+  /* The next available token.  If NEXT_TOKEN is NULL, then there are
+     no more available tokens.  */
+  cp_token * GTY ((skip (""))) next_token;
+  /* A pointer just past the last available token.  If FIRST_TOKEN is
+     NULL, however, there are no available tokens, and then this
+     location is simply the place in which the next token read will be
+     placed.  If LAST_TOKEN == FIRST_TOKEN, then the buffer is full.
+     When the LAST_TOKEN == BUFFER, then the last token is at the
+     highest memory address in the BUFFER.  */
+  cp_token * GTY ((skip (""))) last_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.  The entries are differences in token
+     position between FIRST_TOKEN and the first saved token.
+
+     If the stack is non-empty, we are saving tokens.  When a token is
+     consumed, the NEXT_TOKEN pointer will move, but the FIRST_TOKEN
+     pointer will not.  The token stream will be preserved so that it
+     can be reexamined later.
+
+     If the stack is empty, then we are not saving tokens.  Whenever a
+     token is consumed, the FIRST_TOKEN pointer will be moved, and the
+     consumed token will be gone forever.  */
+  varray_type saved_tokens;
+
+  /* The STRING_CST tokens encountered while processing the current
+     string literal.  */
+  varray_type string_tokens;
+
+  /* True if we should obtain more tokens from the preprocessor; false
+     if we are processing a saved token cache.  */
+  bool main_lexer_p;
+
+  /* True if we should output debugging information.  */
+  bool debugging_p;
+
+  /* The next lexer in a linked list of lexers.  */
+  struct cp_lexer *next;
+} cp_lexer;
+
+/* Prototypes.  */
+
+static cp_lexer *cp_lexer_new_main
+  (void);
+static cp_lexer *cp_lexer_new_from_tokens
+  (struct cp_token_cache *);
+static int cp_lexer_saving_tokens
+  (const cp_lexer *);
+static cp_token *cp_lexer_next_token
+  (cp_lexer *, cp_token *);
+static cp_token *cp_lexer_prev_token
+  (cp_lexer *, cp_token *);
+static ptrdiff_t cp_lexer_token_difference 
+  (cp_lexer *, cp_token *, cp_token *);
+static cp_token *cp_lexer_read_token
+  (cp_lexer *);
+static void cp_lexer_maybe_grow_buffer
+  (cp_lexer *);
+static void cp_lexer_get_preprocessor_token
+  (cp_lexer *, cp_token *);
+static 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 *);
+static void cp_lexer_save_tokens
+  (cp_lexer *);
+static void cp_lexer_commit_tokens
+  (cp_lexer *);
+static void cp_lexer_rollback_tokens
+  (cp_lexer *);
+static inline void cp_lexer_set_source_position_from_token 
+  (cp_lexer *, const cp_token *);
+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;
+
+/* Manifest constants.  */
+
+#define CP_TOKEN_BUFFER_SIZE 5
+#define CP_SAVED_TOKENS_SIZE 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 mark the end of a token block.  */
+#define CPP_NONE (CPP_NESTED_NAME_SPECIFIER + 1)
+
+/* Variables.  */
+
+/* The stream to which debugging output should be written.  */
+static FILE *cp_lexer_debug_stream;
+
+/* Create a new main C++ lexer, the lexer that gets tokens from the
+   preprocessor.  */
+
+static cp_lexer *
+cp_lexer_new_main (void)
+{
+  cp_lexer *lexer;
+  cp_token first_token;
+
+  /* It's possible that lexing the first token will load a PCH file,
+     which is a GC collection point.  So we have to grab the first
+     token before allocating any memory.  */
+  cp_lexer_get_preprocessor_token (NULL, &first_token);
+  c_common_no_more_pch ();
+
+  /* Allocate the memory.  */
+  lexer = ggc_alloc_cleared (sizeof (cp_lexer));
+
+  /* Create the circular buffer.  */
+  lexer->buffer = ggc_calloc (CP_TOKEN_BUFFER_SIZE, sizeof (cp_token));
+  lexer->buffer_end = lexer->buffer + CP_TOKEN_BUFFER_SIZE;
+
+  /* There is one token in the buffer.  */
+  lexer->last_token = lexer->buffer + 1;
+  lexer->first_token = lexer->buffer;
+  lexer->next_token = lexer->buffer;
+  memcpy (lexer->buffer, &first_token, sizeof (cp_token));
+
+  /* This lexer obtains more tokens by calling c_lex.  */
+  lexer->main_lexer_p = true;
+
+  /* Create the SAVED_TOKENS stack.  */
+  VARRAY_INT_INIT (lexer->saved_tokens, CP_SAVED_TOKENS_SIZE, "saved_tokens");
+  
+  /* Create the STRINGS array.  */
+  VARRAY_TREE_INIT (lexer->string_tokens, 32, "strings");
+
+  /* Assume we are not debugging.  */
+  lexer->debugging_p = false;
+
+  return lexer;
+}
+
+/* Create a new lexer whose token stream is primed with the TOKENS.
+   When these tokens are exhausted, no new tokens will be read.  */
+
+static cp_lexer *
+cp_lexer_new_from_tokens (cp_token_cache *tokens)
+{
+  cp_lexer *lexer;
+  cp_token *token;
+  cp_token_block *block;
+  ptrdiff_t num_tokens;
+
+  /* Allocate the memory.  */
+  lexer = ggc_alloc_cleared (sizeof (cp_lexer));
+
+  /* Create a new buffer, appropriately sized.  */
+  num_tokens = 0;
+  for (block = tokens->first; block != NULL; block = block->next)
+    num_tokens += block->num_tokens;
+  lexer->buffer = ggc_alloc (num_tokens * sizeof (cp_token));
+  lexer->buffer_end = lexer->buffer + num_tokens;
+  
+  /* Install the tokens.  */
+  token = lexer->buffer;
+  for (block = tokens->first; block != NULL; block = block->next)
+    {
+      memcpy (token, block->tokens, block->num_tokens * sizeof (cp_token));
+      token += block->num_tokens;
+    }
+
+  /* The FIRST_TOKEN is the beginning of the buffer.  */
+  lexer->first_token = lexer->buffer;
+  /* The next available token is also at the beginning of the buffer.  */
+  lexer->next_token = lexer->buffer;
+  /* The buffer is full.  */
+  lexer->last_token = lexer->first_token;
+
+  /* This lexer doesn't obtain more tokens.  */
+  lexer->main_lexer_p = false;
+
+  /* Create the SAVED_TOKENS stack.  */
+  VARRAY_INT_INIT (lexer->saved_tokens, CP_SAVED_TOKENS_SIZE, "saved_tokens");
+  
+  /* Create the STRINGS array.  */
+  VARRAY_TREE_INIT (lexer->string_tokens, 32, "strings");
+
+  /* Assume we are not debugging.  */
+  lexer->debugging_p = false;
+
+  return lexer;
+}
+
+/* Returns nonzero if debugging information should be output.  */
+
+static inline bool
+cp_lexer_debugging_p (cp_lexer *lexer)
+{
+  return lexer->debugging_p;
+}
+
+/* Set the current source position from the information stored in
+   TOKEN.  */
+
+static inline void
+cp_lexer_set_source_position_from_token (cp_lexer *lexer ATTRIBUTE_UNUSED ,
+                                         const cp_token *token)
+{
+  /* Ideally, the source position information would not be a global
+     variable, but it is.  */
+
+  /* Update the line number.  */
+  if (token->type != CPP_EOF)
+    input_location = token->location;
+}
+
+/* TOKEN points into the circular token buffer.  Return a pointer to
+   the next token in the buffer.  */
+
+static inline cp_token *
+cp_lexer_next_token (cp_lexer* lexer, cp_token* token)
+{
+  token++;
+  if (token == lexer->buffer_end)
+    token = lexer->buffer;
+  return token;
+}
+
+/* TOKEN points into the circular token buffer.  Return a pointer to
+   the previous token in the buffer.  */
+
+static inline cp_token *
+cp_lexer_prev_token (cp_lexer* lexer, cp_token* token)
+{
+  if (token == lexer->buffer)
+    token = lexer->buffer_end;
+  return token - 1;
+}
+
+/* nonzero if we are presently saving tokens.  */
+
+static int
+cp_lexer_saving_tokens (const cp_lexer* lexer)
+{
+  return VARRAY_ACTIVE_SIZE (lexer->saved_tokens) != 0;
+}
+
+/* Return a pointer to the token that is N tokens beyond TOKEN in the
+   buffer.  */
+
+static cp_token *
+cp_lexer_advance_token (cp_lexer *lexer, cp_token *token, ptrdiff_t n)
+{
+  token += n;
+  if (token >= lexer->buffer_end)
+    token = lexer->buffer + (token - lexer->buffer_end);
+  return token;
+}
+
+/* Returns the number of times that START would have to be incremented
+   to reach FINISH.  If START and FINISH are the same, returns zero.  */
+
+static ptrdiff_t
+cp_lexer_token_difference (cp_lexer* lexer, cp_token* start, cp_token* finish)
+{
+  if (finish >= start)
+    return finish - start;
+  else
+    return ((lexer->buffer_end - lexer->buffer)
+	    - (start - finish));
+}
+
+/* Obtain another token from the C preprocessor and add it to the
+   token buffer.  Returns the newly read token.  */
+
+static cp_token *
+cp_lexer_read_token (cp_lexer* lexer)
+{
+  cp_token *token;
+
+  /* Make sure there is room in the buffer.  */
+  cp_lexer_maybe_grow_buffer (lexer);
+
+  /* If there weren't any tokens, then this one will be the first.  */
+  if (!lexer->first_token)
+    lexer->first_token = lexer->last_token;
+  /* Similarly, if there were no available tokens, there is one now.  */
+  if (!lexer->next_token)
+    lexer->next_token = lexer->last_token;
+
+  /* Figure out where we're going to store the new token.  */
+  token = lexer->last_token;
+
+  /* Get a new token from the preprocessor.  */
+  cp_lexer_get_preprocessor_token (lexer, token);
+
+  /* Increment LAST_TOKEN.  */
+  lexer->last_token = cp_lexer_next_token (lexer, token);
+
+  /* Strings should have type `const char []'.  Right now, we will
+     have an ARRAY_TYPE that is constant rather than an array of
+     constant elements.
+     FIXME: Make fix_string_type get this right in the first place.  */
+  if ((token->type == CPP_STRING || token->type == CPP_WSTRING)
+      && flag_const_strings)
+    {
+      tree type;
+
+      /* Get the current type.  It will be an ARRAY_TYPE.  */
+      type = TREE_TYPE (token->value);
+      /* Use build_cplus_array_type to rebuild the array, thereby
+	 getting the right type.  */
+      type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
+      /* Reset the type of the token.  */
+      TREE_TYPE (token->value) = type;
+    }
+
+  return token;
+}
+
+/* If the circular buffer is full, make it bigger.  */
+
+static void
+cp_lexer_maybe_grow_buffer (cp_lexer* lexer)
+{
+  /* If the buffer is full, enlarge it.  */
+  if (lexer->last_token == lexer->first_token)
+    {
+      cp_token *new_buffer;
+      cp_token *old_buffer;
+      cp_token *new_first_token;
+      ptrdiff_t buffer_length;
+      size_t num_tokens_to_copy;
+
+      /* Remember the current buffer pointer.  It will become invalid,
+	 but we will need to do pointer arithmetic involving this
+	 value.  */
+      old_buffer = lexer->buffer;
+      /* Compute the current buffer size.  */
+      buffer_length = lexer->buffer_end - lexer->buffer;
+      /* Allocate a buffer twice as big.  */
+      new_buffer = ggc_realloc (lexer->buffer, 
+				2 * buffer_length * sizeof (cp_token));
+      
+      /* Because the buffer is circular, logically consecutive tokens
+	 are not necessarily placed consecutively in memory.
+	 Therefore, we must keep move the tokens that were before
+	 FIRST_TOKEN to the second half of the newly allocated
+	 buffer.  */
+      num_tokens_to_copy = (lexer->first_token - old_buffer);
+      memcpy (new_buffer + buffer_length,
+	      new_buffer,
+	      num_tokens_to_copy * sizeof (cp_token));
+      /* Clear the rest of the buffer.  We never look at this storage,
+	 but the garbage collector may.  */
+      memset (new_buffer + buffer_length + num_tokens_to_copy, 0, 
+	      (buffer_length - num_tokens_to_copy) * sizeof (cp_token));
+
+      /* Now recompute all of the buffer pointers.  */
+      new_first_token 
+	= new_buffer + (lexer->first_token - old_buffer);
+      if (lexer->next_token != NULL)
+	{
+	  ptrdiff_t next_token_delta;
+
+	  if (lexer->next_token > lexer->first_token)
+	    next_token_delta = lexer->next_token - lexer->first_token;
+	  else
+	    next_token_delta = 
+	      buffer_length - (lexer->first_token - lexer->next_token);
+	  lexer->next_token = new_first_token + next_token_delta;
+	}
+      lexer->last_token = new_first_token + buffer_length;
+      lexer->buffer = new_buffer;
+      lexer->buffer_end = new_buffer + buffer_length * 2;
+      lexer->first_token = new_first_token;
+    }
+}
+
+/* Store the next token from the preprocessor in *TOKEN.  */
+
+static void 
+cp_lexer_get_preprocessor_token (cp_lexer *lexer ATTRIBUTE_UNUSED ,
+                                 cp_token *token)
+{
+  bool done;
+
+  /* If this not the main lexer, return a terminating CPP_EOF token.  */
+  if (lexer != NULL && !lexer->main_lexer_p)
+    {
+      token->type = CPP_EOF;
+      token->location.line = 0;
+      token->location.file = NULL;
+      token->value = NULL_TREE;
+      token->keyword = RID_MAX;
+
+      return;
+    }
+
+  done = false;
+  /* Keep going until we get a token we like.  */
+  while (!done)
+    {
+      /* Get a new token from the preprocessor.  */
+      token->type = c_lex_with_flags (&token->value, &token->flags);
+      /* Issue messages about tokens we cannot process.  */
+      switch (token->type)
+	{
+	case CPP_ATSIGN:
+	case CPP_HASH:
+	case CPP_PASTE:
+	  error ("invalid token");
+	  break;
+
+	default:
+	  /* This is a good token, so we exit the loop.  */
+	  done = true;
+	  break;
+	}
+    }
+  /* Now we've got our token.  */
+  token->location = input_location;
+
+  /* Check to see if this token is a keyword.  */
+  if (token->type == CPP_NAME 
+      && C_IS_RESERVED_WORD (token->value))
+    {
+      /* Mark this token as a keyword.  */
+      token->type = CPP_KEYWORD;
+      /* Record which keyword.  */
+      token->keyword = C_RID_CODE (token->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->value = ridpointers[token->keyword];
+    }
+  else
+    token->keyword = RID_MAX;
+}
+
+/* Return a pointer to the next token in the token stream, but do not
+   consume it.  */
+
+static cp_token *
+cp_lexer_peek_token (cp_lexer* lexer)
+{
+  cp_token *token;
+
+  /* If there are no tokens, read one now.  */
+  if (!lexer->next_token)
+    cp_lexer_read_token (lexer);
+
+  /* Provide debugging output.  */
+  if (cp_lexer_debugging_p (lexer))
+    {
+      fprintf (cp_lexer_debug_stream, "cp_lexer: peeking at token: ");
+      cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
+      fprintf (cp_lexer_debug_stream, "\n");
+    }
+
+  token = lexer->next_token;
+  cp_lexer_set_source_position_from_token (lexer, token);
+  return token;
+}
+
+/* Return true if the next token has the indicated TYPE.  */
+
+static bool
+cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
+{
+  cp_token *token;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (lexer);
+  /* Check to see if it has the indicated TYPE.  */
+  return token->type == type;
+}
+
+/* Return true if the next token does not have the indicated TYPE.  */
+
+static 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 bool
+cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
+{
+  cp_token *token;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (lexer);
+  /* Check to see if it is the indicated keyword.  */
+  return token->keyword == keyword;
+}
+
+/* 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.  */
+
+static cp_token *
+cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
+{
+  cp_token *token;
+
+  /* N is 1-based, not zero-based.  */
+  my_friendly_assert (n > 0, 20000224);
+
+  /* Skip ahead from NEXT_TOKEN, reading more tokens as necessary.  */
+  token = lexer->next_token;
+  /* If there are no tokens in the buffer, get one now.  */
+  if (!token)
+    {
+      cp_lexer_read_token (lexer);
+      token = lexer->next_token;
+    }
+
+  /* Now, read tokens until we have enough.  */
+  while (--n > 0)
+    {
+      /* Advance to the next token.  */
+      token = cp_lexer_next_token (lexer, token);
+      /* If that's all the tokens we have, read a new one.  */
+      if (token == lexer->last_token)
+	token = cp_lexer_read_token (lexer);
+    }
+
+  return token;
+}
+
+/* Consume the next token.  The pointer returned is valid only until
+   another token is read.  Callers should preserve copy the token
+   explicitly if they will need its value for a longer period of
+   time.  */
+
+static cp_token *
+cp_lexer_consume_token (cp_lexer* lexer)
+{
+  cp_token *token;
+
+  /* If there are no tokens, read one now.  */
+  if (!lexer->next_token)
+    cp_lexer_read_token (lexer);
+
+  /* Remember the token we'll be returning.  */
+  token = lexer->next_token;
+
+  /* Increment NEXT_TOKEN.  */
+  lexer->next_token = cp_lexer_next_token (lexer, 
+					   lexer->next_token);
+  /* Check to see if we're all out of tokens.  */
+  if (lexer->next_token == lexer->last_token)
+    lexer->next_token = NULL;
+
+  /* If we're not saving tokens, then move FIRST_TOKEN too.  */
+  if (!cp_lexer_saving_tokens (lexer))
+    {
+      /* If there are no tokens available, set FIRST_TOKEN to NULL.  */
+      if (!lexer->next_token)
+	lexer->first_token = NULL;
+      else
+	lexer->first_token = lexer->next_token;
+    }
+
+  /* Provide debugging output.  */
+  if (cp_lexer_debugging_p (lexer))
+    {
+      fprintf (cp_lexer_debug_stream, "cp_lexer: consuming token: ");
+      cp_lexer_print_token (cp_lexer_debug_stream, token);
+      fprintf (cp_lexer_debug_stream, "\n");
+    }
+
+  return token;
+}
+
+/* Permanently remove the next token from the token stream.  There
+   must be a valid next token already; this token never reads
+   additional tokens from the preprocessor.  */
+
+static void
+cp_lexer_purge_token (cp_lexer *lexer)
+{
+  cp_token *token;
+  cp_token *next_token;
+
+  token = lexer->next_token;
+  while (true) 
+    {
+      next_token = cp_lexer_next_token (lexer, token);
+      if (next_token == lexer->last_token)
+	break;
+      *token = *next_token;
+      token = next_token;
+    }
+
+  lexer->last_token = token;
+  /* The token purged may have been the only token remaining; if so,
+     clear NEXT_TOKEN.  */
+  if (lexer->next_token == token)
+    lexer->next_token = NULL;
+}
+
+/* Permanently remove all tokens after TOKEN, 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 *token)
+{
+  cp_token *peek;
+  cp_token *t1;
+  cp_token *t2;
+
+  if (lexer->next_token)
+    {
+      /* Copy the tokens that have not yet been read to the location
+	 immediately following TOKEN.  */
+      t1 = cp_lexer_next_token (lexer, token);
+      t2 = peek = cp_lexer_peek_token (lexer);
+      /* Move tokens into the vacant area between TOKEN and PEEK.  */
+      while (t2 != lexer->last_token)
+	{
+	  *t1 = *t2;
+	  t1 = cp_lexer_next_token (lexer, t1);
+	  t2 = cp_lexer_next_token (lexer, t2);
+	}
+      /* Now, the next available token is right after TOKEN.  */
+      lexer->next_token = cp_lexer_next_token (lexer, token);
+      /* And the last token is wherever we ended up.  */
+      lexer->last_token = t1;
+    }
+  else
+    {
+      /* There are no tokens in the buffer, so there is nothing to
+	 copy.  The last token in the buffer is TOKEN itself.  */
+      lexer->last_token = cp_lexer_next_token (lexer, token);
+    }
+}
+
+/* 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");
+
+  /* Make sure that LEXER->NEXT_TOKEN is non-NULL so that we can
+     restore the tokens if required.  */
+  if (!lexer->next_token)
+    cp_lexer_read_token (lexer);
+
+  VARRAY_PUSH_INT (lexer->saved_tokens,
+		   cp_lexer_token_difference (lexer,
+					      lexer->first_token,
+					      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");
+
+  VARRAY_POP (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)
+{
+  size_t delta;
+
+  /* Provide debugging output.  */
+  if (cp_lexer_debugging_p (lexer))
+    fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
+
+  /* Find the token that was the NEXT_TOKEN when we started saving
+     tokens.  */
+  delta = VARRAY_TOP_INT(lexer->saved_tokens);
+  /* Make it the next token again now.  */
+  lexer->next_token = cp_lexer_advance_token (lexer,
+					      lexer->first_token, 
+					      delta);
+  /* It might be the case that there were no tokens when we started
+     saving tokens, but that there are some tokens now.  */
+  if (!lexer->next_token && lexer->first_token)
+    lexer->next_token = lexer->first_token;
+
+  /* Stop saving tokens.  */
+  VARRAY_POP (lexer->saved_tokens);
+}
+
+/* Print a representation of the TOKEN on the STREAM.  */
+
+static void
+cp_lexer_print_token (FILE * stream, cp_token* token)
+{
+  const char *token_type = NULL;
+
+  /* Figure out what kind of token this is.  */
+  switch (token->type)
+    {
+    case CPP_EQ:
+      token_type = "EQ";
+      break;
+
+    case CPP_COMMA:
+      token_type = "COMMA";
+      break;
+
+    case CPP_OPEN_PAREN:
+      token_type = "OPEN_PAREN";
+      break;
+
+    case CPP_CLOSE_PAREN:
+      token_type = "CLOSE_PAREN";
+      break;
+
+    case CPP_OPEN_BRACE:
+      token_type = "OPEN_BRACE";
+      break;
+
+    case CPP_CLOSE_BRACE:
+      token_type = "CLOSE_BRACE";
+      break;
+
+    case CPP_SEMICOLON:
+      token_type = "SEMICOLON";
+      break;
+
+    case CPP_NAME:
+      token_type = "NAME";
+      break;
+
+    case CPP_EOF:
+      token_type = "EOF";
+      break;
+
+    case CPP_KEYWORD:
+      token_type = "keyword";
+      break;
+
+      /* This is not a token that we know how to handle yet.  */
+    default:
+      break;
+    }
+
+  /* If we have a name for the token, print it out.  Otherwise, we
+     simply give the numeric code.  */
+  if (token_type)
+    fprintf (stream, "%s", token_type);
+  else
+    fprintf (stream, "%d", token->type);
+  /* And, for an identifier, print the identifier name.  */
+  if (token->type == CPP_NAME 
+      /* Some keywords have a value that is not an IDENTIFIER_NODE.
+	 For example, `struct' is mapped to an INTEGER_CST.  */
+      || (token->type == CPP_KEYWORD 
+	  && TREE_CODE (token->value) == IDENTIFIER_NODE))
+    fprintf (stream, " %s", IDENTIFIER_POINTER (token->value));
+}
+
+/* Start emitting debugging information.  */
+
+static void
+cp_lexer_start_debugging (cp_lexer* lexer)
+{
+  ++lexer->debugging_p;
+}
+  
+/* Stop emitting debugging information.  */
+
+static void
+cp_lexer_stop_debugging (cp_lexer* lexer)
+{
+  --lexer->debugging_p;
+}
+
+
+/* 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.  Some possible improvements include:
+
+     - The expression parser recurses through the various levels of
+       precedence as specified in the grammar, rather than using an
+       operator-precedence technique.  Therefore, parsing a simple
+       identifier requires multiple recursive calls.
+
+     - 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 declartor.  */
+  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;
+
+/* A mapping from a token type to a corresponding tree node type.  */
+
+typedef struct cp_parser_token_tree_map_node
+{
+  /* The token type.  */
+  ENUM_BITFIELD (cpp_ttype) token_type : 8;
+  /* The corresponding tree code.  */
+  ENUM_BITFIELD (tree_code) tree_type : 8;
+} cp_parser_token_tree_map_node;
+
+/* A complete map consists of several ordinary entries, followed by a
+   terminator.  The terminating entry has a token_type of CPP_EOF.  */
+
+typedef cp_parser_token_tree_map_node cp_parser_token_tree_map[];
+
+/* 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;
+
+/* 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;
+
+/* 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_alloc_cleared (sizeof (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.  
+
+     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 we are parsing the argument to "__offsetof__".  */
+  bool in_offsetof_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;
+
+  /* TRUE if we are presently parsing the body of an
+     iteration-statement.  */
+  bool in_iteration_statement_p;
+
+  /* TRUE if we are presently parsing the body of a switch
+     statement.  */
+  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;
+
+  /* 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;
+
+/* The type of a function that parses some kind of expression.  */
+typedef tree (*cp_parser_expression_fn) (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 *);
+
+/* Basic concepts [gram.basic]  */
+
+static bool cp_parser_translation_unit
+  (cp_parser *);
+
+/* Expressions [gram.expr]  */
+
+static tree cp_parser_primary_expression
+  (cp_parser *, cp_id_kind *, tree *);
+static tree cp_parser_id_expression
+  (cp_parser *, bool, bool, bool *, bool);
+static tree cp_parser_unqualified_id
+  (cp_parser *, 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);
+static tree cp_parser_parenthesized_expression_list
+  (cp_parser *, bool, bool *);
+static void cp_parser_pseudo_destructor_name
+  (cp_parser *, tree *, tree *);
+static tree cp_parser_unary_expression
+  (cp_parser *, 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 *);
+static tree cp_parser_new_declarator_opt
+  (cp_parser *);
+static tree 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);
+static tree cp_parser_pm_expression
+  (cp_parser *);
+static tree cp_parser_multiplicative_expression
+  (cp_parser *);
+static tree cp_parser_additive_expression
+  (cp_parser *);
+static tree cp_parser_shift_expression
+  (cp_parser *);
+static tree cp_parser_relational_expression
+  (cp_parser *);
+static tree cp_parser_equality_expression
+  (cp_parser *);
+static tree cp_parser_and_expression
+  (cp_parser *);
+static tree cp_parser_exclusive_or_expression
+  (cp_parser *);
+static tree cp_parser_inclusive_or_expression
+  (cp_parser *);
+static tree cp_parser_logical_and_expression
+  (cp_parser *);
+static tree cp_parser_logical_or_expression 
+  (cp_parser *);
+static tree cp_parser_question_colon_clause
+  (cp_parser *, tree);
+static tree cp_parser_assignment_expression
+  (cp_parser *);
+static enum tree_code cp_parser_assignment_operator_opt
+  (cp_parser *);
+static tree cp_parser_expression
+  (cp_parser *);
+static tree cp_parser_constant_expression
+  (cp_parser *, bool, bool *);
+
+/* Statements [gram.stmt.stmt]  */
+
+static void cp_parser_statement
+  (cp_parser *, bool);
+static tree cp_parser_labeled_statement
+  (cp_parser *, bool);
+static tree cp_parser_expression_statement
+  (cp_parser *, bool);
+static tree cp_parser_compound_statement
+  (cp_parser *, bool);
+static void cp_parser_statement_seq_opt
+  (cp_parser *, bool);
+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 tree cp_parser_decl_specifier_seq 
+  (cp_parser *, cp_parser_flags, tree *, int *);
+static tree cp_parser_storage_class_specifier_opt
+  (cp_parser *);
+static tree cp_parser_function_specifier_opt
+  (cp_parser *);
+static tree cp_parser_type_specifier
+  (cp_parser *, cp_parser_flags, bool, bool, int *, bool *);
+static tree cp_parser_simple_type_specifier
+  (cp_parser *, cp_parser_flags, bool);
+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 void cp_parser_using_declaration
+  (cp_parser *);
+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 *, tree, tree, bool, bool, int, bool *);
+static tree cp_parser_declarator
+  (cp_parser *, cp_parser_declarator_kind, int *, bool *);
+static tree cp_parser_direct_declarator
+  (cp_parser *, cp_parser_declarator_kind, int *);
+static enum tree_code cp_parser_ptr_operator
+  (cp_parser *, tree *, tree *);
+static tree cp_parser_cv_qualifier_seq_opt
+  (cp_parser *);
+static tree cp_parser_cv_qualifier_opt
+  (cp_parser *);
+static tree cp_parser_declarator_id
+  (cp_parser *);
+static tree cp_parser_type_id
+  (cp_parser *);
+static tree cp_parser_type_specifier_seq
+  (cp_parser *);
+static tree cp_parser_parameter_declaration_clause
+  (cp_parser *);
+static tree cp_parser_parameter_declaration_list
+  (cp_parser *);
+static tree 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 tree 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, bool, bool, bool, bool);
+static tree cp_parser_class_specifier
+  (cp_parser *);
+static tree cp_parser_class_head
+  (cp_parser *, bool *, 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 tree 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 *);
+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 *);
+
+/* Utility Routines */
+
+static tree cp_parser_lookup_name
+  (cp_parser *, tree, bool, bool, bool, bool);
+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 *, tree);
+static bool cp_parser_check_template_parameters
+  (cp_parser *, unsigned);
+static tree cp_parser_simple_cast_expression
+  (cp_parser *);
+static tree cp_parser_binary_expression
+  (cp_parser *, const cp_parser_token_tree_map, cp_parser_expression_fn);
+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 *, tree, tree, tree);
+static tree cp_parser_function_definition_after_declarator
+  (cp_parser *, bool);
+static void cp_parser_template_declaration_after_export
+  (cp_parser *, bool);
+static tree cp_parser_single_declaration
+  (cp_parser *, bool, bool *);
+static tree cp_parser_functional_cast
+  (cp_parser *, tree);
+static tree cp_parser_save_member_function_body
+  (cp_parser *, tree, tree, 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 bool cp_parser_friend_p
+  (tree);
+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 *, cp_token_cache *, 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_committed_to_tentative_parse
+  (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 void cp_parser_check_type_definition
+  (cp_parser *);
+static void cp_parser_check_for_definition_in_return_type
+  (tree, int);
+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 bool cp_parser_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_until_found
+  (cp_parser *, enum cpp_ttype, const char *);
+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);
+
+/* 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;
+}
+
+/* Issue the indicated error MESSAGE.  */
+
+static void
+cp_parser_error (cp_parser* parser, const char* message)
+{
+  /* Output the MESSAGE -- unless we're parsing tentatively.  */
+  if (!cp_parser_simulate_error (parser))
+    {
+      cp_token *token;
+      token = cp_lexer_peek_token (parser->lexer);
+      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->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
+	error ("`%D' 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 ("`%D' %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 messgae should be issued by the caller.  */
+
+static bool
+cp_parser_simulate_error (cp_parser* parser)
+{
+  if (cp_parser_parsing_tentatively (parser)
+      && !cp_parser_committed_to_tentative_parse (parser))
+    {
+      parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
+      return true;
+    }
+  return false;
+}
+
+/* This function is called when a type is defined.  If type
+   definitions are forbidden at this point, an error message is
+   issued.  */
+
+static void
+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);
+}
+
+/* This function is called when a declaration is parsed.  If
+   DECLARATOR is a function declarator and DECLARES_CLASS_OR_ENUM
+   indicates that a type was defined in the decl-specifiers for DECL,
+   then an error is issued.  */
+
+static void
+cp_parser_check_for_definition_in_return_type (tree declarator, 
+					       int declares_class_or_enum)
+{
+  /* [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
+	 && (TREE_CODE (declarator) == INDIRECT_REF
+	     || TREE_CODE (declarator) == ADDR_EXPR))
+    declarator = TREE_OPERAND (declarator, 0);
+  if (declarator
+      && TREE_CODE (declarator) == CALL_EXPR 
+      && declares_class_or_enum & 2)
+    error ("new types may not be defined in a return 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)
+{
+  ptrdiff_t start;
+  cp_token *token;
+
+  if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
+    {
+      if (TYPE_P (type))
+	error ("`%T' is not a template", type);
+      else if (TREE_CODE (type) == IDENTIFIER_NODE)
+	error ("`%s' is not a template", IDENTIFIER_POINTER (type));
+      else
+	error ("invalid template-id");
+      /* Remember the location of the invalid "<".  */
+      if (cp_parser_parsing_tentatively (parser)
+	  && !cp_parser_committed_to_tentative_parse (parser))
+	{
+	  token = cp_lexer_peek_token (parser->lexer);
+	  token = cp_lexer_prev_token (parser->lexer, token);
+	  start = cp_lexer_token_difference (parser->lexer,
+					     parser->lexer->first_token,
+					     token);
+	}
+      else
+	start = -1;
+      /* 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 >= 0)
+	{
+	  token = cp_lexer_advance_token (parser->lexer,
+					  parser->lexer->first_token,
+					  start);
+	  cp_lexer_purge_tokens_after (parser->lexer, token);
+	}
+    }
+}
+
+/* If parsing an integral constant-expression, issue an error message
+   about the fact that THING appeared and return true.  Otherwise,
+   return false, marking the current expression as non-constant.  */
+
+static bool
+cp_parser_non_integral_constant_expression (cp_parser  *parser,
+					    const char *thing)
+{
+  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;
+	}
+      parser->non_integral_constant_expression_p = true;
+    }
+  return false;
+}
+
+/* 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.  */
+
+static bool
+cp_parser_diagnose_invalid_type_name (cp_parser *parser)
+{
+  /* 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 (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
+      && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME)
+    {
+      tree name;
+
+      /* If parsing tentatively, we should commit; we really are
+	 looking at a declaration.  */
+      /* Consume the first identifier.  */
+      name = cp_lexer_consume_token (parser->lexer)->value;
+      /* Issue an error message.  */
+      error ("`%s' does not name a type", IDENTIFIER_POINTER (name));
+      /* 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)
+	{
+	  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) == name)
+		      {
+			error ("(perhaps `typename %T::%s' was intended)",
+			       BINFO_TYPE (b), IDENTIFIER_POINTER (name));
+			break;
+		      }
+		  if (field)
+		    break;
+		}
+	    }
+	}
+      /* Skip to the end of the declaration; there's no point in
+	 trying to process it.  */
+      cp_parser_skip_to_end_of_statement (parser);
+      
+      return true;
+    }
+
+  return false;
+}
+
+/* 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_parsing_tentatively (parser)
+      && !cp_parser_committed_to_tentative_parse (parser))
+    return 0;
+  
+  while (true)
+    {
+      cp_token *token;
+      
+      /* If we've run out of tokens, then there is no closing `)'.  */
+      if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
+	return 0;
+
+      token = cp_lexer_peek_token (parser->lexer);
+      
+      /* This matches the processing in skip_to_end_of_statement.  */
+      if (token->type == CPP_SEMICOLON && !brace_depth)
+	return 0;
+      if (token->type == CPP_OPEN_BRACE)
+	++brace_depth;
+      if (token->type == CPP_CLOSE_BRACE)
+	{
+	  if (!brace_depth--)
+	    return 0;
+	}
+      if (recovering && or_comma && token->type == CPP_COMMA
+	  && !brace_depth && !paren_depth)
+	return -1;
+      
+      if (!brace_depth)
+	{
+	  /* If it is an `(', we have entered another level of nesting.  */
+	  if (token->type == CPP_OPEN_PAREN)
+	    ++paren_depth;
+	  /* If it is a `)', then we might be done.  */
+	  else if (token->type == CPP_CLOSE_PAREN && !paren_depth--)
+	    {
+	      if (consume_paren)
+		cp_lexer_consume_token (parser->lexer);
+	      return 1;
+	    }
+	}
+      
+      /* 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;
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If we've run out of tokens, stop.  */
+      if (token->type == CPP_EOF)
+	break;
+      /* If the next token is a `;', we have reached the end of the
+	 statement.  */
+      if (token->type == CPP_SEMICOLON && !nesting_depth)
+	break;
+      /* If the next token is a non-nested `}', then we have reached
+	 the end of the current block.  */
+      if (token->type == 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)
+	    break;
+	  /* 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);
+	      break;
+	    }
+	}
+      /* If it the next token is a `{', then we are entering a new
+	 block.  Consume the entire block.  */
+      else if (token->type == CPP_OPEN_BRACE)
+	++nesting_depth;
+      /* 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)
+{
+  unsigned nesting_depth = 0;
+
+  while (true)
+    {
+      cp_token *token;
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If we've run out of tokens, stop.  */
+      if (token->type == CPP_EOF)
+	break;
+      /* If the next token is a `;', we have reached the end of the
+	 statement.  */
+      if (token->type == CPP_SEMICOLON && !nesting_depth)
+	{
+	  /* Consume the `;'.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  break;
+	}
+      /* Consume the token.  */
+      token = cp_lexer_consume_token (parser->lexer);
+      /* If the next token is a non-nested `}', then we have reached
+	 the end of the current block.  */
+      if (token->type == CPP_CLOSE_BRACE 
+	  && (nesting_depth == 0 || --nesting_depth == 0))
+	break;
+      /* If it the next token is a `{', then we are entering a new
+	 block.  Consume the entire block.  */
+      if (token->type == CPP_OPEN_BRACE)
+	++nesting_depth;
+    }
+}
+
+/* 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;
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If we've run out of tokens, stop.  */
+      if (token->type == CPP_EOF)
+	break;
+      /* If the next token is a non-nested `}', then we have reached
+	 the end of the current block.  */
+      if (token->type == CPP_CLOSE_BRACE && nesting_depth-- == 0)
+	break;
+      /* If it the next token is a `{', then we are entering a new
+	 block.  Consume the entire block.  */
+      else if (token->type == CPP_OPEN_BRACE)
+	++nesting_depth;
+      /* Consume the token.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+}
+
+/* Create a new C++ parser.  */
+
+static cp_parser *
+cp_parser_new (void)
+{
+  cp_parser *parser;
+  cp_lexer *lexer;
+
+  /* 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 ();
+
+  parser = ggc_alloc_cleared (sizeof (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;
+
+  /* We are not parsing offsetof.  */
+  parser->in_offsetof_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_iteration_statement_p = false;
+
+  /* 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;
+
+  /* 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;
+}
+
+/* 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->value : error_mark_node;
+}
+
+/* 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)
+{
+  while (true)
+    {
+      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))
+	break;
+      
+      /* Otherwise, issue an error message.  */
+      cp_parser_error (parser, "expected declaration");
+      return false;
+    }
+
+  /* Consume the EOF token.  */
+  cp_parser_require (parser, CPP_EOF, "end-of-file");
+  
+  /* Finish up.  */
+  finish_translation_unit ();
+
+  /* All went well.  */
+  return true;
+}
+
+/* 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 )
+
+   literal:
+     __null
+
+   Returns a representation of the expression.  
+
+   *IDK indicates what kind of id-expression (if any) was present.  
+
+   *QUALIFYING_CLASS is set to a non-NULL value if the id-expression can be
+   used as the operand of a pointer-to-member.  In that case,
+   *QUALIFYING_CLASS gives the class that is used as the qualifying
+   class in the pointer-to-member.  */
+
+static tree
+cp_parser_primary_expression (cp_parser *parser, 
+			      cp_id_kind *idk,
+			      tree *qualifying_class)
+{
+  cp_token *token;
+
+  /* Assume the primary expression is not an id-expression.  */
+  *idk = CP_ID_KIND_NONE;
+  /* And that it cannot be used as pointer-to-member.  */
+  *qualifying_class = NULL_TREE;
+
+  /* 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_STRING:
+    case CPP_WSTRING:
+    case CPP_NUMBER:
+      token = cp_lexer_consume_token (parser->lexer);
+      return token->value;
+
+    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 (!at_function_scope_p ())
+	      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, true);
+	    /* Finish up.  */
+	    expr = finish_stmt_expr (expr, false);
+	  }
+	else
+	  {
+	    /* Parse the parenthesized expression.  */
+	    expr = cp_parser_expression (parser);
+	    /* 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->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);
+	    /* 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:
+	  {
+	    tree expression;
+	    bool saved_in_offsetof_p;
+
+	    /* Consume the "__offsetof__" token.  */
+	    cp_lexer_consume_token (parser->lexer);
+	    /* Consume the opening `('.  */
+	    cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+	    /* Parse the parenthesized (almost) constant-expression.  */
+	    saved_in_offsetof_p = parser->in_offsetof_p;
+	    parser->in_offsetof_p = true;
+	    expression 
+	      = cp_parser_constant_expression (parser,
+					       /*allow_non_constant_p=*/false,
+					       /*non_constant_p=*/NULL);
+	    parser->in_offsetof_p = saved_in_offsetof_p;
+	    /* Consume the closing ')'.  */
+	    cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+
+	    return expression;
+	  }
+
+	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;
+
+      id_expression:
+	/* Parse the id-expression.  */
+	id_expression 
+	  = cp_parser_id_expression (parser, 
+				     /*template_keyword_p=*/false,
+				     /*check_dependency_p=*/true,
+				     /*template_p=*/NULL,
+				     /*declarator_p=*/false);
+	if (id_expression == error_mark_node)
+	  return error_mark_node;
+	/* 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.  */
+	else if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
+	    || TREE_CODE (id_expression) == TYPE_DECL)
+	  decl = id_expression;
+	/* Look up the name.  */
+	else 
+	  {
+	    decl = cp_parser_lookup_name_simple (parser, id_expression);
+	    /* If name lookup gives us a SCOPE_REF, then the
+	       qualifying scope was dependent.  Just propagate the
+	       name.  */
+	    if (TREE_CODE (decl) == SCOPE_REF)
+	      {
+		if (TYPE_P (TREE_OPERAND (decl, 0)))
+		  *qualifying_class = TREE_OPERAND (decl, 0);
+		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 `%D' may not appear in this context",
+			   decl);
+		    return error_mark_node;
+		  }
+	      }
+	  }
+	
+	decl = finish_id_expression (id_expression, decl, parser->scope, 
+				     idk, qualifying_class,
+				     parser->integral_constant_expression_p,
+				     parser->allow_non_integral_constant_expression_p,
+				     &parser->non_integral_constant_expression_p,
+				     &error_msg);
+	if (error_msg)
+	  cp_parser_error (parser, error_msg);
+	return decl;
+      }
+
+      /* Anything else is an error.  */
+    default:
+      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 global_scope_p;
+  bool nested_name_specifier_p;
+
+  /* Assume the `template' keyword was not used.  */
+  if (template_p)
+    *template_p = false;
+
+  /* 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,
+					    /*is_declarator=*/false)
+       != 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);
+      /* 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);
+}
+
+/* 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)
+{
+  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;
+
+	/* 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;
+
+	/* If the name is of the form "X::~X" it's OK.  */
+	if (scope && TYPE_P (scope)
+	    && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
+	    && (cp_lexer_peek_nth_token (parser->lexer, 2)->type 
+		== CPP_OPEN_PAREN)
+	    && (cp_lexer_peek_token (parser->lexer)->value 
+		== TYPE_IDENTIFIER (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).  */
+	if (scope)
+	  {
+	    cp_parser_parse_tentatively (parser);
+	    type_decl = cp_parser_class_name (parser, 
+					      /*typename_keyword_p=*/false,
+					      /*template_keyword_p=*/false,
+					      /*type_p=*/false,
+					      /*check_dependency=*/false,
+					      /*class_head_p=*/false,
+					      declarator_p);
+	    if (cp_parser_parse_definitely (parser))
+	      return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
+	  }
+	/* In "N::S::~S", look in "N" as well.  */
+	if (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,
+				      /*type_p=*/false,
+				      /*check_dependency=*/false,
+				      /*class_head_p=*/false,
+				      declarator_p);
+	    if (cp_parser_parse_definitely (parser))
+	      return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
+	  }
+	/* In "p->S::~T", look in the scope given by "*p" as well.  */
+	else if (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,
+				      /*type_p=*/false,
+				      /*check_dependency=*/false,
+				      /*class_head_p=*/false,
+				      declarator_p);
+	    if (cp_parser_parse_definitely (parser))
+	      return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
+	  }
+	/* Look in the surrounding context.  */
+	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,
+				  /*type_p=*/false,
+				  /*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 && TYPE_P (scope))
+	  return build_nt (BIT_NOT_EXPR, scope);
+	else if (type_decl == error_mark_node)
+	  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))
+	  error ("typedef-name `%D' 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:
+      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;
+  tree access_check = NULL_TREE;
+  ptrdiff_t start;
+  cp_token* token;
+
+  /* If the next token corresponds to a nested name specifier, there
+     is no need to reparse it.  However, if CHECK_DEPENDENCY_P is
+     false, it may have been true before, in which case something 
+     like `A<X>::B<Y>::C' may have resulted in a nested-name-specifier
+     of `A<X>::', where it should now be `A<X>::B<Y>::'.  So, when
+     CHECK_DEPENDENCY_P is false, we have to fall through into the
+     main loop.  */
+  if (check_dependency_p
+      && cp_lexer_next_token_is (parser->lexer, CPP_NESTED_NAME_SPECIFIER))
+    {
+      cp_parser_pre_parsed_nested_name_specifier (parser);
+      return parser->scope;
+    }
+
+  /* Remember where the nested-name-specifier starts.  */
+  if (cp_parser_parsing_tentatively (parser)
+      && !cp_parser_committed_to_tentative_parse (parser))
+    {
+      token = cp_lexer_peek_token (parser->lexer);
+      start = cp_lexer_token_difference (parser->lexer,
+					 parser->lexer->first_token,
+					 token);
+    }
+  else
+    start = -1;
+
+  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);
+	  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;
+      /* 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 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) 
+		{
+		  tree decl;
+
+		  decl = cp_parser_lookup_name_simple (parser, token->value);
+		  if (TREE_CODE (decl) == TEMPLATE_DECL)
+		    error ("`%D' used without template parameters",
+			   decl);
+		  else
+		    cp_parser_name_lookup_error 
+		      (parser, token->value, decl, 
+		       "is not a class or namespace");
+		  parser->scope = NULL_TREE;
+		  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;
+      /* Make sure we look in the right scope the next time through
+	 the loop.  */
+      parser->scope = (TREE_CODE (new_scope) == TYPE_DECL 
+		       ? TREE_TYPE (new_scope)
+		       : 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 (parser->scope)
+	  /* Since checking types for dependency can be expensive,
+	     avoid doing it if the type is already complete.  */
+	  && !COMPLETE_TYPE_P (parser->scope)
+	  /* Do not try to complete dependent types.  */
+	  && !dependent_type_p (parser->scope))
+	complete_type (parser->scope);
+    }
+
+  /* Retrieve any deferred checks.  Do not pop this access checks yet
+     so the memory will not be reclaimed during token replacing below.  */
+  access_check = get_deferred_access_checks ();
+
+  /* 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 >= 0)
+    {
+      /* Find the token that corresponds to the start of the
+	 template-id.  */
+      token = cp_lexer_advance_token (parser->lexer, 
+				      parser->lexer->first_token,
+				      start);
+
+      /* Reset the contents of the START token.  */
+      token->type = CPP_NESTED_NAME_SPECIFIER;
+      token->value = build_tree_list (access_check, parser->scope);
+      TREE_TYPE (token->value) = parser->qualifying_scope;
+      token->keyword = RID_MAX;
+      /* Purge all subsequent tokens.  */
+      cp_lexer_purge_tokens_after (parser->lexer, token);
+    }
+
+  pop_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, and it will return
+   ERROR_MARK_NODE, rather than NULL_TREE, 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 error_mark_node;
+    }
+
+  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,
+				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.
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_postfix_expression (cp_parser *parser, bool address_p)
+{
+  cp_token *token;
+  enum rid keyword;
+  cp_id_kind idk = CP_ID_KIND_NONE;
+  tree postfix_expression = NULL_TREE;
+  /* Non-NULL only if the current postfix-expression can be used to
+     form a pointer-to-member.  In that case, QUALIFYING_CLASS is the
+     class used to qualify the member.  */
+  tree qualifying_class = 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);
+	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+
+	/* Only type conversions to integral or enumeration types
+	   can be used in constant-expressions.  */
+	if (parser->integral_constant_expression_p
+	    && !dependent_type_p (type)
+	    && !INTEGRAL_OR_ENUMERATION_TYPE_P (type)
+	    /* A cast to pointer or reference type is allowed in the
+	       implementation of "offsetof".  */
+	    && !(parser->in_offsetof_p && POINTER_TYPE_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:
+	    abort ();
+	  }
+      }
+      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);
+	    /* Compute its typeid.  */
+	    postfix_expression = build_typeid (expression);
+	    /* Look for the `)' token.  */
+	    cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+	  }
+	/* `typeid' may not appear in an integral constant expression.  */
+	if (cp_parser_non_integral_constant_expression(parser, 
+						       "`typeid' operator"))
+	  return error_mark_node;
+	/* Restore the saved message.  */
+	parser->type_definition_forbidden_message = saved_message;
+      }
+      break;
+      
+    case RID_TYPENAME:
+      {
+	bool template_p = false;
+	tree id;
+	tree type;
+
+	/* Consume the `typename' token.  */
+	cp_lexer_consume_token (parser->lexer);
+	/* Look for the optional `::' operator.  */
+	cp_parser_global_scope_opt (parser, 
+				    /*current_scope_valid_p=*/false);
+	/* Look for the nested-name-specifier.  */
+	cp_parser_nested_name_specifier (parser,
+					 /*typename_keyword_p=*/true,
+					 /*check_dependency_p=*/true,
+					 /*type_p=*/true,
+					 /*is_declaration=*/true);
+	/* Look for the optional `template' keyword.  */
+	template_p = cp_parser_optional_template_keyword (parser);
+	/* We don't know whether we're looking at a template-id or an
+	   identifier.  */
+	cp_parser_parse_tentatively (parser);
+	/* Try a template-id.  */
+	id = cp_parser_template_id (parser, template_p,
+				    /*check_dependency_p=*/true,
+				    /*is_declaration=*/true);
+	/* If that didn't work, try an identifier.  */
+	if (!cp_parser_parse_definitely (parser))
+	  id = cp_parser_identifier (parser);
+	/* If we look up a template-id in a non-dependent qualifying
+	   scope, there's no need to create a dependent type.  */
+	if (TREE_CODE (id) == TYPE_DECL
+	    && !dependent_type_p (parser->scope))
+	  type = TREE_TYPE (id);
+	/* Create a TYPENAME_TYPE to represent the type to which the
+	   functional cast is being performed.  */
+	else
+	  type = make_typename_type (parser->scope, id, 
+				     /*complain=*/1);
+
+	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, 
+						CP_PARSER_FLAGS_NONE,
+						/*identifier_p=*/false);
+	/* 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))
+	  {
+	    tree initializer_list = NULL_TREE;
+	    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");
+		/* 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, 
+							   &idk,
+							   &qualifying_class);
+      }
+      break;
+    }
+
+  /* If we were avoiding committing to the processing of a
+     qualified-id until we knew whether or not we had a
+     pointer-to-member, we now know.  */
+  if (qualifying_class)
+    {
+      bool done;
+
+      /* Peek at the next token.  */
+      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);
+
+      postfix_expression = finish_qualified_id_expr (qualifying_class,
+						     postfix_expression,
+						     done,
+						     address_p);
+      if (done)
+	return postfix_expression;
+    }
+
+  /* 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 [ expression ] */
+	  {
+	    tree index;
+
+	    /* Consume the `[' token.  */
+	    cp_lexer_consume_token (parser->lexer);
+	    /* Parse the index expression.  */
+	    index = cp_parser_expression (parser);
+	    /* Look for the closing `]'.  */
+	    cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
+
+	    /* Build the ARRAY_REF.  */
+	    postfix_expression 
+	      = grok_array_decl (postfix_expression, index);
+	    idk = CP_ID_KIND_NONE;
+	    /* Array references are not permitted in
+	       constant-expressions (but they are allowed
+	       in offsetof).  */
+	    if (!parser->in_offsetof_p
+		&& cp_parser_non_integral_constant_expression
+		    (parser, "an array reference"))
+	      postfix_expression = error_mark_node;
+	  }
+	  break;
+
+	case CPP_OPEN_PAREN:
+	  /* postfix-expression ( expression-list [opt] ) */
+	  {
+	    bool koenig_p;
+	    tree args = (cp_parser_parenthesized_expression_list 
+			 (parser, false, /*non_constant_p=*/NULL));
+
+	    if (args == error_mark_node)
+	      {
+		postfix_expression = error_mark_node;
+		break;
+	      }
+	    
+	    /* Function calls are not permitted in
+	       constant-expressions.  */
+	    if (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)
+	      {
+		/* We do not perform argument-dependent lookup if
+		   normal lookup finds a non-function, in accordance
+		   with the expected resolution of DR 218.  */
+		if (args
+		    && (is_overloaded_fn (postfix_expression)
+			|| TREE_CODE (postfix_expression) == IDENTIFIER_NODE))
+		  {
+		    koenig_p = true;
+		    postfix_expression 
+		      = perform_koenig_lookup (postfix_expression, args);
+		  }
+		else if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
+		  postfix_expression
+		    = unqualified_fn_lookup_error (postfix_expression);
+	      }
+	  
+	    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);
+		    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)));
+		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 */
+	  {
+	    tree name;
+	    bool dependent_p;
+	    bool template_p;
+	    tree scope = NULL_TREE;
+	    enum cpp_ttype token_type = token->type;
+
+	    /* 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.  */
+		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;
+	      }
+
+	    /* Consume the `.' or `->' operator.  */
+	    cp_lexer_consume_token (parser->lexer);
+	    /* If the SCOPE is not a scalar type, we are looking at an
+	       ordinary class member access expression, rather than a
+	       pseudo-destructor-name.  */
+	    if (!scope || !SCALAR_TYPE_P (scope))
+	      {
+		template_p = cp_parser_optional_template_keyword (parser);
+		/* Parse the id-expression.  */
+		name = cp_parser_id_expression (parser,
+						template_p,
+						/*check_dependency_p=*/true,
+						/*template_p=*/NULL,
+						/*declarator_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 (name != error_mark_node 
+		    && !BASELINK_P (name)
+		    && parser->scope)
+		  {
+		    name = build_nt (SCOPE_REF, parser->scope, name);
+		    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_BINFO (name)), scope);
+		postfix_expression 
+		  = finish_class_member_access_expr (postfix_expression, name);
+	      }
+	    /* Otherwise, try the pseudo-destructor-name production.  */
+	    else
+	      {
+		tree s = NULL_TREE;
+		tree type;
+
+		/* Parse the pseudo-destructor-name.  */
+		cp_parser_pseudo_destructor_name (parser, &s, &type);
+		/* Form the call.  */
+		postfix_expression 
+		  = finish_pseudo_destructor_expr (postfix_expression,
+						   s, TREE_TYPE (type));
+	      }
+
+	    /* 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;
+	    /* These operators may not appear in constant-expressions.  */
+	    if (/* The "->" operator is allowed in the implementation
+		   of "offsetof".  The "." operator may appear in the
+		   name of the member.  */
+		!parser->in_offsetof_p
+		&& (cp_parser_non_integral_constant_expression 
+		    (parser,
+		     token_type == CPP_DEREF ? "'->'" : "`.'")))
+	      postfix_expression = error_mark_node;
+	  }
+	  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.  */
+  abort ();
+  return error_mark_node;
+}
+
+/* Parse a parenthesized expression-list.
+
+   expression-list:
+     assignment-expression
+     expression-list, assignment-expression
+
+   attribute-list:
+     expression-list
+     identifier
+     identifier, expression-list
+
+   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 *non_constant_p)
+{
+  tree expression_list = NULL_TREE;
+  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->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);
+
+	     /* 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;
+
+  /* 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 we didn't get an aggregate type, or 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 (*scope == error_mark_node
+	  || 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");
+	  *type = error_mark_node;
+	  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.
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_unary_expression (cp_parser *parser, bool address_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);
+      /* 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:
+	  /* The "&" operator is allowed in the implementation of
+	     "offsetof".  */
+	  if (!parser->in_offsetof_p)
+	    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 CONVERT_EXPR:
+	case NEGATE_EXPR:
+	case TRUTH_NOT_EXPR:
+	  expression = finish_unary_op_expr (unary_operator, cast_expression);
+	  break;
+
+	default:
+	  abort ();
+	}
+
+      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);
+}
+
+/* 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 CONVERT_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;
+
+  /* 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);
+	}
+    }
+  /* Otherwise, there must be a new-type-id.  */
+  else
+    type = cp_parser_new_type_id (parser);
+
+  /* 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, 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, /*non_constant_p=*/NULL));
+
+  return expression_list;
+}
+
+/* Parse a new-type-id.
+
+   new-type-id:
+     type-specifier-seq new-declarator [opt]
+
+   Returns a TREE_LIST whose TREE_PURPOSE is the type-specifier-seq,
+   and whose TREE_VALUE is the new-declarator.  */
+
+static tree
+cp_parser_new_type_id (cp_parser* parser)
+{
+  tree type_specifier_seq;
+  tree declarator;
+  const char *saved_message;
+
+  /* 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.  */
+  type_specifier_seq = cp_parser_type_specifier_seq (parser);
+  /* Restore the old message.  */
+  parser->type_definition_forbidden_message = saved_message;
+  /* Parse the new-declarator.  */
+  declarator = cp_parser_new_declarator_opt (parser);
+
+  return build_tree_list (type_specifier_seq, declarator);
+}
+
+/* Parse an (optional) new-declarator.
+
+   new-declarator:
+     ptr-operator new-declarator [opt]
+     direct-new-declarator
+
+   Returns a representation of the declarator.  See
+   cp_parser_declarator for the representations used.  */
+
+static tree
+cp_parser_new_declarator_opt (cp_parser* parser)
+{
+  enum tree_code code;
+  tree type;
+  tree cv_qualifier_seq;
+
+  /* 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_qualifier_seq);
+  /* If that worked, look for more new-declarators.  */
+  if (cp_parser_parse_definitely (parser))
+    {
+      tree declarator;
+
+      /* Parse another optional declarator.  */
+      declarator = cp_parser_new_declarator_opt (parser);
+
+      /* Create the representation of the declarator.  */
+      if (code == INDIRECT_REF)
+	declarator = make_pointer_declarator (cv_qualifier_seq,
+					      declarator);
+      else
+	declarator = make_reference_declarator (cv_qualifier_seq,
+						declarator);
+
+     /* Handle the pointer-to-member case.  */
+     if (type)
+       declarator = build_nt (SCOPE_REF, type, 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_TREE;
+}
+
+/* Parse a direct-new-declarator.
+
+   direct-new-declarator:
+     [ expression ]
+     direct-new-declarator [constant-expression]  
+
+   Returns an ARRAY_REF, following the same conventions as are
+   documented for cp_parser_direct_declarator.  */
+
+static tree
+cp_parser_direct_new_declarator (cp_parser* parser)
+{
+  tree declarator = NULL_TREE;
+
+  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);
+	  /* 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 = build_nt (ARRAY_REF, 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, /*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
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_cast_expression (cp_parser *parser, bool address_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_simple_cast_expression (parser);
+
+      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 ("use of old-style cast");
+
+	  /* Only type conversions to integral or enumeration types
+	     can be used in constant-expressions.  */
+	  if (parser->integral_constant_expression_p
+	      && !dependent_type_p (type)
+	      && !INTEGRAL_OR_ENUMERATION_TYPE_P (type)
+	      && (cp_parser_non_integral_constant_expression 
+		  (parser,
+		   "a casts 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);
+}
+
+/* Parse a pm-expression.
+
+   pm-expression:
+     cast-expression
+     pm-expression .* cast-expression
+     pm-expression ->* cast-expression
+
+     Returns a representation of the expression.  */
+
+static tree
+cp_parser_pm_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_DEREF_STAR, MEMBER_REF },
+    { CPP_DOT_STAR, DOTSTAR_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser, map, 
+				      cp_parser_simple_cast_expression);
+}
+
+/* Parse a multiplicative-expression.
+
+   mulitplicative-expression:
+     pm-expression
+     multiplicative-expression * pm-expression
+     multiplicative-expression / pm-expression
+     multiplicative-expression % pm-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_multiplicative_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_MULT, MULT_EXPR },
+    { CPP_DIV, TRUNC_DIV_EXPR },
+    { CPP_MOD, TRUNC_MOD_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_pm_expression);
+}
+
+/* Parse an additive-expression.
+
+   additive-expression:
+     multiplicative-expression
+     additive-expression + multiplicative-expression
+     additive-expression - multiplicative-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_additive_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_PLUS, PLUS_EXPR },
+    { CPP_MINUS, MINUS_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_multiplicative_expression);
+}
+
+/* Parse a shift-expression.
+
+   shift-expression:
+     additive-expression
+     shift-expression << additive-expression
+     shift-expression >> additive-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_shift_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_LSHIFT, LSHIFT_EXPR },
+    { CPP_RSHIFT, RSHIFT_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_additive_expression);
+}
+
+/* Parse a relational-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
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_relational_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_LESS, LT_EXPR },
+    { CPP_GREATER, GT_EXPR },
+    { CPP_LESS_EQ, LE_EXPR },
+    { CPP_GREATER_EQ, GE_EXPR },
+    { CPP_MIN, MIN_EXPR },
+    { CPP_MAX, MAX_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_shift_expression);
+}
+
+/* Parse an equality-expression.
+
+   equality-expression:
+     relational-expression
+     equality-expression == relational-expression
+     equality-expression != relational-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_equality_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_EQ_EQ, EQ_EXPR },
+    { CPP_NOT_EQ, NE_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_relational_expression);
+}
+
+/* Parse an and-expression.
+
+   and-expression:
+     equality-expression
+     and-expression & equality-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_and_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_AND, BIT_AND_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_equality_expression);
+}
+
+/* Parse an exclusive-or-expression.
+
+   exclusive-or-expression:
+     and-expression
+     exclusive-or-expression ^ and-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_exclusive_or_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_XOR, BIT_XOR_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_and_expression);
+}
+
+
+/* Parse an inclusive-or-expression.
+
+   inclusive-or-expression:
+     exclusive-or-expression
+     inclusive-or-expression | exclusive-or-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_inclusive_or_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_OR, BIT_IOR_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_exclusive_or_expression);
+}
+
+/* Parse a logical-and-expression.
+
+   logical-and-expression:
+     inclusive-or-expression
+     logical-and-expression && inclusive-or-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_logical_and_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_AND_AND, TRUTH_ANDIF_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_inclusive_or_expression);
+}
+
+/* Parse a logical-or-expression.
+
+   logical-or-expression:
+     logical-and-expression
+     logical-or-expression || logical-and-expression
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_logical_or_expression (cp_parser* parser)
+{
+  static const cp_parser_token_tree_map map = {
+    { CPP_OR_OR, TRUTH_ORIF_EXPR },
+    { CPP_EOF, ERROR_MARK }
+  };
+
+  return cp_parser_binary_expression (parser,
+				      map,
+				      cp_parser_logical_and_expression);
+}
+
+/* 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);
+  
+  /* The next token should be a `:'.  */
+  cp_parser_require (parser, CPP_COLON, "`:'");
+  /* Parse the assignment-expression.  */
+  assignment_expr = cp_parser_assignment_expression (parser);
+
+  /* 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
+
+   Returns a representation for the expression.  */
+
+static tree
+cp_parser_assignment_expression (cp_parser* parser)
+{
+  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 logical-or-expression.  */
+      expr = cp_parser_logical_or_expression (parser);
+      /* 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);
+	      /* 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;
+
+    case CPP_MIN_EQ:
+      op = MIN_EXPR;
+      break;
+
+    case CPP_MAX_EQ:
+      op = MAX_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
+
+   Returns a representation of the expression.  */
+
+static tree
+cp_parser_expression (cp_parser* parser)
+{
+  tree expression = NULL_TREE;
+
+  while (true)
+    {
+      tree assignment_expression;
+
+      /* Parse the next assignment-expression.  */
+      assignment_expression 
+	= cp_parser_assignment_expression (parser);
+      /* 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);
+  /* 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;
+  parser->non_integral_constant_expression_p = saved_non_integral_constant_expression_p;
+
+  return expression;
+}
+
+/* Statements [gram.stmt.stmt]  */
+
+/* Parse a statement.  
+
+   statement:
+     labeled-statement
+     expression-statement
+     compound-statement
+     selection-statement
+     iteration-statement
+     jump-statement
+     declaration-statement
+     try-block  */
+
+static void
+cp_parser_statement (cp_parser* parser, bool in_statement_expr_p)
+{
+  tree statement;
+  cp_token *token;
+  int statement_line_number;
+
+  /* There is no statement yet.  */
+  statement = NULL_TREE;
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* Remember the line number of the first token in the statement.  */
+  statement_line_number = token->location.line;
+  /* 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:
+	  statement = cp_parser_labeled_statement (parser,
+						   in_statement_expr_p);
+	  break;
+
+	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;
+
+	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)
+	statement = cp_parser_labeled_statement (parser, in_statement_expr_p);
+    }
+  /* Anything that starts with a `{' must be a compound-statement.  */
+  else if (token->type == CPP_OPEN_BRACE)
+    statement = cp_parser_compound_statement (parser, false);
+
+  /* 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_p);
+    }
+
+  /* Set the line number for the statement.  */
+  if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
+    STMT_LINENO (statement) = statement_line_number;
+}
+
+/* Parse a labeled-statement.
+
+   labeled-statement:
+     identifier : statement
+     case constant-expression : statement
+     default : statement
+
+   GNU Extension:
+   
+   labeled-statement:
+     case constant-expression ... constant-expression : statement
+
+   Returns the new CASE_LABEL, for a `case' or `default' label.  For
+   an ordinary label, returns a LABEL_STMT.  */
+
+static tree
+cp_parser_labeled_statement (cp_parser* parser, bool in_statement_expr_p)
+{
+  cp_token *token;
+  tree statement = error_mark_node;
+
+  /* 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 error_mark_node;
+    }
+
+  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)
+	  error ("case label `%E' not within a switch statement", expr);
+	else
+	  statement = finish_case_label (expr, expr_hi);
+      }
+      break;
+
+    case RID_DEFAULT:
+      /* Consume the `default' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      if (!parser->in_switch_statement_p)
+	error ("case label not within a switch statement");
+      else
+	statement = finish_case_label (NULL_TREE, NULL_TREE);
+      break;
+
+    default:
+      /* Anything else must be an ordinary label.  */
+      statement = finish_label_stmt (cp_parser_identifier (parser));
+      break;
+    }
+
+  /* Require the `:' token.  */
+  cp_parser_require (parser, CPP_COLON, "`:'");
+  /* Parse the labeled statement.  */
+  cp_parser_statement (parser, in_statement_expr_p);
+
+  /* Return the label, in the case of a `case' or `default' label.  */
+  return statement;
+}
+
+/* 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, bool in_statement_expr_p)
+{
+  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);
+  
+  /* Consume the final `;'.  */
+  cp_parser_consume_semicolon_at_end_of_statement (parser);
+
+  if (in_statement_expr_p
+      && 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);
+    }
+  else if (statement)
+    statement = finish_expr_stmt (statement);
+  else
+    finish_stmt ();
+  
+  return statement;
+}
+
+/* Parse a compound-statement.
+
+   compound-statement:
+     { statement-seq [opt] }
+     
+   Returns a COMPOUND_STMT representing the statement.  */
+
+static tree
+cp_parser_compound_statement (cp_parser *parser, bool in_statement_expr_p)
+{
+  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 (/*has_no_scope=*/false);
+  /* Parse an (optional) statement-seq.  */
+  cp_parser_statement_seq_opt (parser, in_statement_expr_p);
+  /* 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, bool in_statement_expr_p)
+{
+  /* Scan statements until there aren't any more.  */
+  while (true)
+    {
+      /* If we're looking at a `}', then we've run out of statements.  */
+      if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE)
+	  || cp_lexer_next_token_is (parser->lexer, CPP_EOF))
+	break;
+
+      /* Parse the statement.  */
+      cp_parser_statement (parser, in_statement_expr_p);
+    }
+}
+
+/* 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)
+	  {
+	    tree then_stmt;
+
+	    /* Add the condition.  */
+	    finish_if_stmt_cond (condition, statement);
+
+	    /* Parse the then-clause.  */
+	    then_stmt = 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))
+	      {
+		tree else_stmt;
+
+		/* Consume the `else' keyword.  */
+		cp_lexer_consume_token (parser->lexer);
+		/* Parse the else-clause.  */
+		else_stmt 
+		  = cp_parser_implicitly_scoped_statement (parser);
+		finish_else_clause (statement);
+	      }
+
+	    /* Now we're all done with the if-statement.  */
+	    finish_if_stmt ();
+	  }
+	else
+	  {
+	    tree body;
+	    bool in_switch_statement_p;
+
+	    /* Add the condition.  */
+	    finish_switch_cond (condition, statement);
+
+	    /* Parse the body of the switch-statement.  */
+	    in_switch_statement_p = parser->in_switch_statement_p;
+	    parser->in_switch_statement_p = true;
+	    body = cp_parser_implicitly_scoped_statement (parser);
+	    parser->in_switch_statement_p = in_switch_statement_p;
+
+	    /* 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)
+{
+  tree 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.  */
+  type_specifiers = cp_parser_type_specifier_seq (parser);
+  /* 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;
+      tree 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);
+      /* 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))
+	{
+	  /* Create the declaration.  */
+	  decl = start_decl (declarator, type_specifiers, 
+			     /*initialized_p=*/true,
+			     attributes, /*prefix_attributes=*/NULL_TREE);
+	  /* Parse the assignment-expression.  */
+	  initializer = cp_parser_assignment_expression (parser);
+	  
+	  /* Process the initializer.  */
+	  cp_finish_decl (decl, 
+			  initializer, 
+			  asm_specification, 
+			  LOOKUP_ONLYCONVERTING);
+	  
+	  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);
+}
+
+/* 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;
+  bool in_iteration_statement_p;
+
+
+  /* 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_iteration_statement_p = parser->in_iteration_statement_p;
+
+  /* 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_iteration_statement_p = true;
+	cp_parser_already_scoped_statement (parser);
+	parser->in_iteration_statement_p = in_iteration_statement_p;
+	/* 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_iteration_statement_p = true;
+	cp_parser_implicitly_scoped_statement (parser);
+	parser->in_iteration_statement_p = in_iteration_statement_p;
+	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);
+	/* 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);
+	finish_for_expr (expression, statement);
+	/* Look for the `)'.  */
+	cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+	
+	/* Parse the body of the for-statement.  */
+	parser->in_iteration_statement_p = true;
+	cp_parser_already_scoped_statement (parser);
+	parser->in_iteration_statement_p = in_iteration_statement_p;
+
+	/* 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_STMT, or
+   GOTO_STMT.  */
+
+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:
+      if (!parser->in_switch_statement_p
+	  && !parser->in_iteration_statement_p)
+	{
+	  error ("break statement not within loop or switch");
+	  statement = error_mark_node;
+	}
+      else
+	statement = finish_break_stmt ();
+      cp_parser_require (parser, CPP_SEMICOLON, "`;'");
+      break;
+
+    case RID_CONTINUE:
+      if (!parser->in_iteration_statement_p)
+	{
+	  error ("continue statement not within a loop");
+	  statement = error_mark_node;
+	}
+      else
+	statement = finish_continue_stmt ();
+      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);
+	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));
+	}
+      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)
+{
+  /* Parse the block-declaration.  */
+  cp_parser_block_declaration (parser, /*statement_p=*/true);
+
+  /* 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;
+
+  /* If the token is not a `{', then we must take special action.  */
+  if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
+    {
+      /* Create a compound-statement.  */
+      statement = begin_compound_stmt (/*has_no_scope=*/false);
+      /* Parse the dependent-statement.  */
+      cp_parser_statement (parser, false);
+      /* Finish the dummy compound-statement.  */
+      finish_compound_stmt (statement);
+    }
+  /* Otherwise, we simply parse the statement directly.  */
+  else
+    statement = cp_parser_compound_statement (parser, false);
+
+  /* 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 not a `{', then we must take special action.  */
+  if (cp_lexer_next_token_is_not(parser->lexer, CPP_OPEN_BRACE))
+    {
+      tree statement;
+
+      /* Create a compound-statement.  */
+      statement = begin_compound_stmt (/*has_no_scope=*/true);
+      /* Parse the dependent-statement.  */
+      cp_parser_statement (parser, false);
+      /* Finish the dummy compound-statement.  */
+      finish_compound_stmt (statement);
+    }
+  /* Otherwise, we simply parse the statement directly.  */
+  else
+    cp_parser_statement (parser, false);
+}
+
+/* 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)
+	break;
+
+      if (token->type == CPP_SEMICOLON) 
+	{
+	  /* A declaration consisting of a single semicolon is
+	     invalid.  Allow it unless we're being pedantic.  */
+	  if (pedantic && !in_system_header)
+	    pedwarn ("extra `;'");
+	  cp_lexer_consume_token (parser->lexer);
+	  continue;
+	}
+
+      /* The C lexer modifies PENDING_LANG_CHANGE when it wants the
+	 parser to enter or exit implicit `extern "C"' blocks.  */
+      while (pending_lang_change > 0)
+	{
+	  push_lang_context (lang_name_c);
+	  --pending_lang_change;
+	}
+      while (pending_lang_change < 0)
+	{
+	  pop_lang_context ();
+	  ++pending_lang_change;
+	}
+
+      /* 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;
+
+  /* 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);
+
+  /* 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_OPEN_BRACE))
+	       /* An unnamed namespace definition.  */
+	       || token2.type == CPP_OPEN_BRACE))
+    cp_parser_namespace_definition (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);
+}
+
+/* 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);
+    }
+  /* 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)
+{
+  tree decl_specifiers;
+  tree attributes;
+  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.  */
+  decl_specifiers
+    = cp_parser_decl_specifier_seq (parser, 
+				    CP_PARSER_FLAGS_OPTIONAL,
+				    &attributes,
+				    &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)
+    {
+      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 (cp_parser_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;
+    }
+
+  /* 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;
+
+      saw_declarator = true;
+      /* Parse the init-declarator.  */
+      decl = cp_parser_init_declarator (parser, decl_specifiers, attributes,
+					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)
+	cp_lexer_consume_token (parser->lexer);
+      /* If it's a `;', we are done.  */
+      else if (token->type == CPP_SEMICOLON)
+	break;
+      /* Anything else is an error.  */
+      else
+	{
+	  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
+
+   Returns a TREE_LIST, giving the decl-specifiers in the order they
+   appear in the source code.  The TREE_VALUE of each node is the
+   decl-specifier.  For a keyword (such as `auto' or `friend'), the
+   TREE_VALUE is simply the corresponding TREE_IDENTIFIER.  For the
+   representation of a type-specifier, see cp_parser_type_specifier.  
+
+   If there are attributes, they will be stored in *ATTRIBUTES,
+   represented as described above cp_parser_attributes.  
+
+   If FRIEND_IS_NOT_CLASS_P is non-NULL, and the `friend' specifier
+   appears, and the entity that will be a friend is not going to be a
+   class, then *FRIEND_IS_NOT_CLASS_P will be set to TRUE.  Note that
+   even if *FRIEND_IS_NOT_CLASS_P is FALSE, the entity to which
+   friendship is granted might not be a class.  
+
+   *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 tree
+cp_parser_decl_specifier_seq (cp_parser* parser, 
+                              cp_parser_flags flags, 
+                              tree* attributes,
+			      int* declares_class_or_enum)
+{
+  tree decl_specs = NULL_TREE;
+  bool friend_p = false;
+  bool constructor_possible_p = !parser->in_declarator_p;
+  
+  /* Assume no class or enumeration type is declared.  */
+  *declares_class_or_enum = 0;
+
+  /* Assume there are no attributes.  */
+  *attributes = NULL_TREE;
+
+  /* Keep reading specifiers until there are no more to read.  */
+  while (true)
+    {
+      tree decl_spec = NULL_TREE;
+      bool constructor_p;
+      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_spec = cp_parser_attributes_opt (parser);
+	  /* Add them to the list.  */
+	  *attributes = chainon (*attributes, decl_spec);
+	  continue;
+	}
+      /* If the next token is an appropriate keyword, we can simply
+	 add it to the list.  */
+      switch (token->keyword)
+	{
+	case RID_FRIEND:
+	  /* decl-specifier:
+	       friend  */
+	  if (friend_p)
+	    error ("duplicate `friend'");
+	  else
+	    friend_p = true;
+	  /* The representation of the specifier is simply the
+	     appropriate TREE_IDENTIFIER node.  */
+	  decl_spec = token->value;
+	  /* Consume the token.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  break;
+
+	  /* function-specifier:
+	       inline
+	       virtual
+	       explicit  */
+	case RID_INLINE:
+	case RID_VIRTUAL:
+	case RID_EXPLICIT:
+	  decl_spec = cp_parser_function_specifier_opt (parser);
+	  break;
+	  
+	  /* decl-specifier:
+	       typedef  */
+	case RID_TYPEDEF:
+	  /* The representation of the specifier is simply the
+	     appropriate TREE_IDENTIFIER node.  */
+	  decl_spec = token->value;
+	  /* 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);
+	  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:
+	case RID_THREAD:
+	  decl_spec = cp_parser_storage_class_specifier_opt (parser);
+	  break;
+	  
+	default:
+	  break;
+	}
+
+      /* Constructors are a special case.  The `S' in `S()' is not a
+	 decl-specifier; it is the beginning of the declarator.  */
+      constructor_p = (!decl_spec 
+		       && constructor_possible_p
+		       && cp_parser_constructor_declarator_p (parser,
+							      friend_p));
+
+      /* If we don't have a DECL_SPEC yet, then we must be looking at
+	 a type-specifier.  */
+      if (!decl_spec && !constructor_p)
+	{
+	  int decl_spec_declares_class_or_enum;
+	  bool is_cv_qualifier;
+
+	  decl_spec
+	    = cp_parser_type_specifier (parser, flags,
+					friend_p,
+					/*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 (decl_spec && !is_cv_qualifier)
+	    flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
+	  /* A constructor declarator cannot follow a type-specifier.  */
+	  if (decl_spec)
+	    constructor_possible_p = false;
+	}
+
+      /* If we still do not have a DECL_SPEC, then there are no more
+	 decl-specifiers.  */
+      if (!decl_spec)
+	{
+	  /* Issue an error message, unless the entire construct was
+             optional.  */
+	  if (!(flags & CP_PARSER_FLAGS_OPTIONAL))
+	    {
+	      cp_parser_error (parser, "expected decl specifier");
+	      return error_mark_node;
+	    }
+
+	  break;
+	}
+
+      /* Add the DECL_SPEC to the list of specifiers.  */
+      if (decl_specs == NULL || TREE_VALUE (decl_specs) != error_mark_node)
+	decl_specs = tree_cons (NULL_TREE, decl_spec, decl_specs);
+
+      /* After we see one decl-specifier, further decl-specifiers are
+	 always optional.  */
+      flags |= CP_PARSER_FLAGS_OPTIONAL;
+    }
+
+  /* Don't allow a friend specifier with a class definition.  */
+  if (friend_p && (*declares_class_or_enum & 2))
+    error ("class definition may not be declared a friend");
+
+  /* We have built up the DECL_SPECS in reverse order.  Return them in
+     the correct order.  */
+  return nreverse (decl_specs);
+}
+
+/* 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)->value;
+
+    default:
+      return NULL_TREE;
+    }
+}
+
+/* Parse an (optional) function-specifier. 
+
+   function-specifier:
+     inline
+     virtual
+     explicit
+
+   Returns an IDENTIFIER_NODE corresponding to the keyword used.  */
+   
+static tree
+cp_parser_function_specifier_opt (cp_parser* parser)
+{
+  switch (cp_lexer_peek_token (parser->lexer)->keyword)
+    {
+    case RID_INLINE:
+    case RID_VIRTUAL:
+    case RID_EXPLICIT:
+      /* Consume the token.  */
+      return cp_lexer_consume_token (parser->lexer)->value;
+
+    default:
+      return NULL_TREE;
+    }
+}
+
+/* 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)
+{
+  cp_token *token;
+  tree linkage;
+
+  /* Look for the `extern' keyword.  */
+  cp_parser_require_keyword (parser, RID_EXTERN, "`extern'");
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If it's not a string-literal, then there's a problem.  */
+  if (!cp_parser_is_string_literal (token))
+    {
+      cp_parser_error (parser, "expected language-name");
+      return;
+    }
+  /* Consume the token.  */
+  cp_lexer_consume_token (parser->lexer);
+
+  /* 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 (token->type == CPP_WSTRING
+      || (strlen (TREE_STRING_POINTER (token->value))
+	  != (size_t) (TREE_STRING_LENGTH (token->value) - 1)))
+    {
+      cp_parser_error (parser, "invalid linkage-specification");
+      /* Assume C++ linkage.  */
+      linkage = get_identifier ("c++");
+    }
+  /* If it's a simple string constant, things are easier.  */
+  else
+    linkage = get_identifier (TREE_STRING_POINTER (token->value));
+
+  /* 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;
+      have_extern_spec = true;
+      cp_parser_declaration (parser);
+      have_extern_spec = false;
+      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;
+  bool pop_p = false;
+
+  /* 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)
+    pop_p = 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 (pop_p)
+    pop_scope (saved_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;
+  tree type_specifiers;
+  tree declarator;
+
+  /* Parse the attributes.  */
+  attributes = cp_parser_attributes_opt (parser);
+  /* Parse the type-specifiers.  */
+  type_specifiers = cp_parser_type_specifier_seq (parser);
+  /* If that didn't work, stop.  */
+  if (type_specifiers == error_mark_node)
+    return error_mark_node;
+  /* Parse the conversion-declarator.  */
+  declarator = cp_parser_conversion_declarator_opt (parser);
+
+  return grokdeclarator (declarator, type_specifiers, TYPENAME,
+			 /*initialized=*/0, &attributes);
+}
+
+/* Parse an (optional) conversion-declarator.
+
+   conversion-declarator:
+     ptr-operator conversion-declarator [opt]  
+
+   Returns a representation of the declarator.  See
+   cp_parser_declarator for details.  */
+
+static tree
+cp_parser_conversion_declarator_opt (cp_parser* parser)
+{
+  enum tree_code code;
+  tree class_type;
+  tree cv_qualifier_seq;
+
+  /* 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_qualifier_seq);
+  /* If it worked, look for more conversion-declarators.  */
+  if (cp_parser_parse_definitely (parser))
+    {
+     tree declarator;
+
+     /* Parse another optional declarator.  */
+     declarator = cp_parser_conversion_declarator_opt (parser);
+
+     /* Create the representation of the declarator.  */
+     if (code == INDIRECT_REF)
+       declarator = make_pointer_declarator (cv_qualifier_seq,
+					     declarator);
+     else
+       declarator =  make_reference_declarator (cv_qualifier_seq,
+						declarator);
+
+     /* Handle the pointer-to-member case.  */
+     if (class_type)
+       declarator = build_nt (SCOPE_REF, class_type, declarator);
+
+     return declarator;
+   }
+
+  return NULL_TREE;
+}
+
+/* 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)
+	{
+	  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.  */
+
+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,
+					       /*non_constant_p=*/NULL);
+  if (!expression_list)
+    expression_list = void_type_node;
+
+  in_base_initializer = 0;
+  
+  return member ? build_tree_list (member, expression_list) : NULL_TREE;
+}
+
+/* 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,
+				 /*type_p=*/false,
+				 /*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,
+			     /*type_p=*/false,
+			     /*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);
+
+      /* Extensions.  */
+    case CPP_MIN:
+      id = ansi_opname (MIN_EXPR);
+      break;
+
+    case CPP_MAX:
+      id = ansi_opname (MAX_EXPR);
+      break;
+
+    case CPP_MIN_EQ:
+      id = ansi_assopname (MIN_EXPR);
+      break;
+
+    case CPP_MAX_EQ:
+      id = ansi_assopname (MAX_EXPR);
+      break;
+
+    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 ("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;
+
+  while (true)
+    {
+      tree parameter;
+      cp_token *token;
+
+      /* Parse the template-parameter.  */
+      parameter = cp_parser_template_parameter (parser);
+      /* Add it to the list.  */
+      parameter_list = process_template_parm (parameter_list,
+					      parameter);
+
+      /* 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 parameter_list;
+}
+
+/* Parse a template-parameter.
+
+   template-parameter:
+     type-parameter
+     parameter-declaration
+
+   Returns a TREE_LIST.  The TREE_VALUE represents the parameter.  The
+   TREE_PURPOSE is the default value, if any.  */
+
+static tree
+cp_parser_template_parameter (cp_parser* parser)
+{
+  cp_token *token;
+
+  /* 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.  */
+  return 
+    cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
+				     /*parenthesized_p=*/NULL);
+}
+
+/* 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.  */
+	    default_argument = cp_parser_type_id (parser);
+	  }
+	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.  */
+	begin_template_parm_list ();
+	parameter_list 
+	  = cp_parser_template_parameter_list (parser);
+	parameter_list = end_template_parm_list (parameter_list);
+	/* 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);
+	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.  */
+	    default_argument 
+	      = cp_parser_id_expression (parser,
+					 /*template_keyword_p=*/false,
+					 /*check_dependency_p=*/true,
+					 /*template_p=*/&is_template,
+					 /*declarator_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,
+					/*is_type=*/false,
+					/*is_template=*/is_template,
+					/*is_namespace=*/false,
+					/*check_dependency=*/true);
+	    /* See if the default argument is valid.  */
+	    default_argument
+	      = check_template_template_default_arg (default_argument);
+	  }
+	else
+	  default_argument = NULL_TREE;
+
+	/* Create the combined representation of the parameter and the
+	   default argument.  */
+	parameter =  build_tree_list (default_argument, parameter);
+      }
+      break;
+
+    default:
+      /* Anything else is an error.  */
+      cp_parser_error (parser,
+		       "expected `class', `typename', or `template'");
+      parameter = error_mark_node;
+    }
+  
+  return parameter;
+}
+
+/* Parse a template-id.
+
+   template-id:
+     template-name < template-argument-list [opt] >
+
+   If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
+   `template' keyword.  In this case, a TEMPLATE_ID_EXPR will be
+   returned.  Otherwise, if the template-name names a function, or set
+   of functions, returns a TEMPLATE_ID_EXPR.  If the template-name
+   names a class, returns a TYPE_DECL for the specialization.  
+
+   If CHECK_DEPENDENCY_P is FALSE, names are looked up in
+   uninstantiated templates.  */
+
+static tree
+cp_parser_template_id (cp_parser *parser, 
+		       bool template_keyword_p, 
+		       bool check_dependency_p,
+		       bool is_declaration)
+{
+  tree template;
+  tree arguments;
+  tree template_id;
+  ptrdiff_t start_of_id;
+  tree access_check = NULL_TREE;
+  cp_token *next_token, *next_token_2;
+  bool is_identifier;
+
+  /* If the next token corresponds to a template-id, there is no need
+     to reparse it.  */
+  next_token = cp_lexer_peek_token (parser->lexer);
+  if (next_token->type == CPP_TEMPLATE_ID)
+    {
+      tree value;
+      tree check;
+
+      /* Get the stored value.  */
+      value = cp_lexer_consume_token (parser->lexer)->value;
+      /* Perform any access checks that were deferred.  */
+      for (check = TREE_PURPOSE (value); check; check = TREE_CHAIN (check))
+	perform_or_defer_access_check (TREE_PURPOSE (check),
+				       TREE_VALUE (check));
+      /* Return the stored value.  */
+      return TREE_VALUE (value);
+    }
+
+  /* Avoid performing name lookup if there is no possibility of
+     finding a template-id.  */
+  if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR)
+      || (next_token->type == CPP_NAME
+	  && !cp_parser_nth_token_starts_template_argument_list_p 
+	       (parser, 2)))
+    {
+      cp_parser_error (parser, "expected template-id");
+      return error_mark_node;
+    }
+
+  /* Remember where the template-id starts.  */
+  if (cp_parser_parsing_tentatively (parser)
+      && !cp_parser_committed_to_tentative_parse (parser))
+    {
+      next_token = cp_lexer_peek_token (parser->lexer);
+      start_of_id = cp_lexer_token_difference (parser->lexer,
+					       parser->lexer->first_token,
+					       next_token);
+    }
+  else
+    start_of_id = -1;
+
+  push_deferring_access_checks (dk_deferred);
+
+  /* Parse the template-name.  */
+  is_identifier = false;
+  template = cp_parser_template_name (parser, template_keyword_p,
+				      check_dependency_p,
+				      is_declaration,
+				      &is_identifier);
+  if (template == error_mark_node || is_identifier)
+    {
+      pop_deferring_access_checks ();
+      return template;
+    }
+
+  /* If we find the sequence `[:' after a template-name, it's probably 
+     a digraph-typo for `< ::'. Substitute the tokens and check if we can
+     parse correctly the argument list.  */
+  next_token = cp_lexer_peek_nth_token (parser->lexer, 1);
+  next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
+  if (next_token->type == CPP_OPEN_SQUARE 
+      && next_token->flags & DIGRAPH
+      && next_token_2->type == CPP_COLON 
+      && !(next_token_2->flags & PREV_WHITE))
+    {
+      cp_parser_parse_tentatively (parser);
+      /* Change `:' into `::'.  */
+      next_token_2->type = CPP_SCOPE;
+      /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
+         CPP_LESS.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Parse the arguments.  */
+      arguments = cp_parser_enclosed_template_argument_list (parser);
+      if (!cp_parser_parse_definitely (parser))
+	{
+	  /* If we couldn't parse an argument list, then we revert our changes
+	     and return simply an error. Maybe this is not a template-id
+	     after all.  */
+	  next_token_2->type = CPP_COLON;
+	  cp_parser_error (parser, "expected `<'");
+	  pop_deferring_access_checks ();
+	  return error_mark_node;
+	}
+      /* Otherwise, emit an error about the invalid digraph, but continue
+         parsing because we got our argument list.  */
+      pedwarn ("`<::' cannot begin a template-argument list");
+      inform ("`<:' is an alternate spelling for `['. Insert whitespace "
+	      "between `<' and `::'");
+      if (!flag_permissive)
+	{
+	  static bool hint;
+	  if (!hint)
+	    {
+	      inform ("(if you use `-fpermissive' G++ will accept your code)");
+	      hint = true;
+	    }
+	}
+    }
+  else
+    {
+      /* Look for the `<' that starts the template-argument-list.  */
+      if (!cp_parser_require (parser, CPP_LESS, "`<'"))
+	{
+	  pop_deferring_access_checks ();
+	  return error_mark_node;
+	}
+      /* Parse the arguments.  */
+      arguments = cp_parser_enclosed_template_argument_list (parser);
+    }
+
+  /* Build a representation of the specialization.  */
+  if (TREE_CODE (template) == IDENTIFIER_NODE)
+    template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments);
+  else if (DECL_CLASS_TEMPLATE_P (template)
+	   || DECL_TEMPLATE_TEMPLATE_PARM_P (template))
+    template_id 
+      = finish_template_type (template, arguments, 
+			      cp_lexer_next_token_is (parser->lexer, 
+						      CPP_SCOPE));
+  else
+    {
+      /* If it's not a class-template or a template-template, it should be
+	 a function-template.  */
+      my_friendly_assert ((DECL_FUNCTION_TEMPLATE_P (template)
+			   || TREE_CODE (template) == OVERLOAD
+			   || BASELINK_P (template)),
+			  20010716);
+      
+      template_id = lookup_template_function (template, arguments);
+    }
+  
+  /* Retrieve any deferred checks.  Do not pop this access checks yet
+     so the memory will not be reclaimed during token replacing below.  */
+  access_check = get_deferred_access_checks ();
+
+  /* If parsing tentatively, replace the sequence of tokens that makes
+     up the template-id with a CPP_TEMPLATE_ID 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 about problems during instantiation of the
+     template.  */
+  if (start_of_id >= 0)
+    {
+      cp_token *token;
+
+      /* Find the token that corresponds to the start of the
+	 template-id.  */
+      token = cp_lexer_advance_token (parser->lexer, 
+				      parser->lexer->first_token,
+				      start_of_id);
+
+      /* Reset the contents of the START_OF_ID token.  */
+      token->type = CPP_TEMPLATE_ID;
+      token->value = build_tree_list (access_check, template_id);
+      token->keyword = RID_MAX;
+      /* Purge all subsequent tokens.  */
+      cp_lexer_purge_tokens_after (parser->lexer, token);
+    }
+
+  pop_deferring_access_checks ();
+  return template_id;
+}
+
+/* Parse a template-name.
+
+   template-name:
+     identifier
+ 
+   The standard should actually say:
+
+   template-name:
+     identifier
+     operator-function-id
+
+   A defect report has been filed about this issue.
+
+   A conversion-function-id cannot be a template name because they cannot
+   be part of a template-id. In fact, looking at this code:
+
+   a.operator K<int>()
+
+   the conversion-function-id is "operator K<int>", and K<int> is a type-id.
+   It is impossible to call a templated conversion-function-id with an 
+   explicit argument list, since the only allowed template parameter is
+   the type to which it is converting.
+
+   If TEMPLATE_KEYWORD_P is true, then we have just seen the
+   `template' keyword, in a construction like:
+
+     T::template f<3>()
+
+   In that case `f' is taken to be a template-name, even though there
+   is no way of knowing for sure.
+
+   Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
+   name refers to a set of overloaded functions, at least one of which
+   is a template, or an IDENTIFIER_NODE with the name of the template,
+   if TEMPLATE_KEYWORD_P is true.  If CHECK_DEPENDENCY_P is FALSE,
+   names are looked up inside uninstantiated templates.  */
+
+static tree
+cp_parser_template_name (cp_parser* parser, 
+                         bool template_keyword_p, 
+                         bool check_dependency_p,
+			 bool is_declaration,
+			 bool *is_identifier)
+{
+  tree identifier;
+  tree decl;
+  tree fns;
+
+  /* If the next token is `operator', then we have either an
+     operator-function-id or a conversion-function-id.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
+    {
+      /* We 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.  */
+      identifier = cp_parser_operator_function_id (parser);
+      /* If that didn't work, try a conversion-function-id.  */
+      if (!cp_parser_parse_definitely (parser))
+        {
+	  cp_parser_error (parser, "expected template-name");
+	  return error_mark_node;
+        }
+    }
+  /* Look for the identifier.  */
+  else
+    identifier = cp_parser_identifier (parser);
+  
+  /* If we didn't find an identifier, we don't have a template-id.  */
+  if (identifier == error_mark_node)
+    return error_mark_node;
+
+  /* If the name immediately followed the `template' keyword, then it
+     is a template-name.  However, if the next token is not `<', then
+     we do not treat it as a template-name, since it is not being used
+     as part of a template-id.  This enables us to handle constructs
+     like:
+
+       template <typename T> struct S { S(); };
+       template <typename T> S<T>::S();
+
+     correctly.  We would treat `S' as a template -- if it were `S<T>'
+     -- but we do not if there is no `<'.  */
+
+  if (processing_template_decl
+      && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
+    {
+      /* In a declaration, in a dependent context, we pretend that the
+	 "template" keyword was present in order to improve error
+	 recovery.  For example, given:
+	 
+	   template <typename T> void f(T::X<int>);
+	 
+	 we want to treat "X<int>" as a template-id.  */
+      if (is_declaration 
+	  && !template_keyword_p 
+	  && parser->scope && TYPE_P (parser->scope)
+	  && dependent_type_p (parser->scope)
+	  /* Do not do this for dtors (or ctors), since they never
+	     need the template keyword before their name.  */
+	  && !constructor_name_p (identifier, parser->scope))
+	{
+	  ptrdiff_t start;
+	  cp_token* token;
+	  /* Explain what went wrong.  */
+	  error ("non-template `%D' used as template", identifier);
+	  inform ("use `%T::template %D' to indicate that it is a template",
+		  parser->scope, identifier);
+	  /* If parsing tentatively, find the location of the "<"
+	     token.  */
+	  if (cp_parser_parsing_tentatively (parser)
+	      && !cp_parser_committed_to_tentative_parse (parser))
+	    {
+	      cp_parser_simulate_error (parser);
+	      token = cp_lexer_peek_token (parser->lexer);
+	      token = cp_lexer_prev_token (parser->lexer, token);
+	      start = cp_lexer_token_difference (parser->lexer,
+						 parser->lexer->first_token,
+						 token);
+	    }
+	  else
+	    start = -1;
+	  /* Parse the template arguments so that we can issue error
+	     messages about them.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  cp_parser_enclosed_template_argument_list (parser);
+	  /* Skip tokens until we find a good place from which to
+	     continue parsing.  */
+	  cp_parser_skip_to_closing_parenthesis (parser,
+						 /*recovering=*/true,
+						 /*or_comma=*/true,
+						 /*consume_paren=*/false);
+	  /* If parsing tentatively, permanently remove the
+	     template argument list.  That will prevent duplicate
+	     error messages from being issued about the missing
+	     "template" keyword.  */
+	  if (start >= 0)
+	    {
+	      token = cp_lexer_advance_token (parser->lexer,
+					      parser->lexer->first_token,
+					      start);
+	      cp_lexer_purge_tokens_after (parser->lexer, token);
+	    }
+	  if (is_identifier)
+	    *is_identifier = true;
+	  return identifier;
+	}
+
+      /* If the "template" keyword is present, then there is generally
+	 no point in doing name-lookup, so we just return IDENTIFIER.
+	 But, if the qualifying scope is non-dependent then we can
+	 (and must) do name-lookup normally.  */
+      if (template_keyword_p
+	  && (!parser->scope
+	      || (TYPE_P (parser->scope) 
+		  && dependent_type_p (parser->scope))))
+	return identifier;
+    }
+
+  /* Look up the name.  */
+  decl = cp_parser_lookup_name (parser, identifier,
+				/*is_type=*/false,
+				/*is_template=*/false,
+				/*is_namespace=*/false,
+				check_dependency_p);
+  decl = maybe_get_template_decl_from_type_decl (decl);
+
+  /* If DECL is a template, then the name was a template-name.  */
+  if (TREE_CODE (decl) == TEMPLATE_DECL)
+    ;
+  else 
+    {
+      /* The standard does not explicitly indicate whether a name that
+	 names a set of overloaded declarations, some of which are
+	 templates, is a template-name.  However, such a name should
+	 be a template-name; otherwise, there is no way to form a
+	 template-id for the overloaded templates.  */
+      fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl;
+      if (TREE_CODE (fns) == OVERLOAD)
+	{
+	  tree fn;
+	  
+	  for (fn = fns; fn; fn = OVL_NEXT (fn))
+	    if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL)
+	      break;
+	}
+      else
+	{
+	  /* Otherwise, the name does not name a template.  */
+	  cp_parser_error (parser, "expected template-name");
+	  return error_mark_node;
+	}
+    }
+
+  /* If DECL is dependent, and refers to a function, then just return
+     its name; we will look it up again during template instantiation.  */
+  if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl))
+    {
+      tree scope = CP_DECL_CONTEXT (get_first_fn (decl));
+      if (TYPE_P (scope) && dependent_type_p (scope))
+	return identifier;
+    }
+
+  return decl;
+}
+
+/* Parse a template-argument-list.
+
+   template-argument-list:
+     template-argument
+     template-argument-list , template-argument
+
+   Returns a TREE_VEC containing the arguments.  */
+
+static tree
+cp_parser_template_argument_list (cp_parser* parser)
+{
+  tree fixed_args[10];
+  unsigned n_args = 0;
+  unsigned alloced = 10;
+  tree *arg_ary = fixed_args;
+  tree vec;
+  bool saved_in_template_argument_list_p;
+
+  saved_in_template_argument_list_p = parser->in_template_argument_list_p;
+  parser->in_template_argument_list_p = true;
+  do
+    {
+      tree argument;
+
+      if (n_args)
+	/* Consume the comma.  */
+	cp_lexer_consume_token (parser->lexer);
+      
+      /* Parse the template-argument.  */
+      argument = cp_parser_template_argument (parser);
+      if (n_args == alloced)
+	{
+	  alloced *= 2;
+	  
+	  if (arg_ary == fixed_args)
+	    {
+	      arg_ary = xmalloc (sizeof (tree) * alloced);
+	      memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);
+	    }
+	  else
+	    arg_ary = xrealloc (arg_ary, sizeof (tree) * alloced);
+	}
+      arg_ary[n_args++] = argument;
+    }
+  while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
+
+  vec = make_tree_vec (n_args);
+
+  while (n_args--)
+    TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];
+  
+  if (arg_ary != fixed_args)
+    free (arg_ary);
+  parser->in_template_argument_list_p = saved_in_template_argument_list_p;
+  return vec;
+}
+
+/* Parse a template-argument.
+
+   template-argument:
+     assignment-expression
+     type-id
+     id-expression
+
+   The representation is that of an assignment-expression, type-id, or
+   id-expression -- except that the qualified id-expression is
+   evaluated, so that the value returned is either a DECL or an
+   OVERLOAD.  
+
+   Although the standard says "assignment-expression", it forbids
+   throw-expressions or assignments in the template argument.
+   Therefore, we use "conditional-expression" instead.  */
+
+static tree
+cp_parser_template_argument (cp_parser* parser)
+{
+  tree argument;
+  bool template_p;
+  bool address_p;
+  bool maybe_type_id = false;
+  cp_token *token;
+  cp_id_kind idk;
+  tree qualifying_class;
+
+  /* There's really no way to know what we're looking at, so we just
+     try each alternative in order.  
+
+       [temp.arg]
+
+       In a template-argument, an ambiguity between a type-id and an
+       expression is resolved to a type-id, regardless of the form of
+       the corresponding template-parameter.  
+
+     Therefore, we try a type-id first.  */
+  cp_parser_parse_tentatively (parser);
+  argument = cp_parser_type_id (parser);
+  /* If there was no error parsing the type-id but the next token is a '>>',
+     we probably found a typo for '> >'. But there are type-id which are 
+     also valid expressions. For instance:
+
+     struct X { int operator >> (int); };
+     template <int V> struct Foo {};
+     Foo<X () >> 5> r;
+
+     Here 'X()' is a valid type-id of a function type, but the user just
+     wanted to write the expression "X() >> 5". Thus, we remember that we
+     found a valid type-id, but we still try to parse the argument as an
+     expression to see what happens.  */
+  if (!cp_parser_error_occurred (parser)
+      && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
+    {
+      maybe_type_id = true;
+      cp_parser_abort_tentative_parse (parser);
+    }
+  else
+    {
+      /* If the next token isn't a `,' or a `>', then this argument wasn't
+      really finished. This means that the argument is not a valid
+      type-id.  */
+      if (!cp_parser_next_token_ends_template_argument_p (parser))
+	cp_parser_error (parser, "expected template-argument");
+      /* If that worked, we're done.  */
+      if (cp_parser_parse_definitely (parser))
+	return argument;
+    }
+  /* We're still not sure what the argument will be.  */
+  cp_parser_parse_tentatively (parser);
+  /* Try a template.  */
+  argument = cp_parser_id_expression (parser, 
+				      /*template_keyword_p=*/false,
+				      /*check_dependency_p=*/true,
+				      &template_p,
+				      /*declarator_p=*/false);
+  /* If the next token isn't a `,' or a `>', then this argument wasn't
+     really finished.  */
+  if (!cp_parser_next_token_ends_template_argument_p (parser))
+    cp_parser_error (parser, "expected template-argument");
+  if (!cp_parser_error_occurred (parser))
+    {
+      /* Figure out what is being referred to.  If the id-expression
+	 was for a class template specialization, then we will have a
+	 TYPE_DECL at this point.  There is no need to do name lookup
+	 at this point in that case.  */
+      if (TREE_CODE (argument) != TYPE_DECL)
+	argument = cp_parser_lookup_name (parser, argument,
+					  /*is_type=*/false,
+					  /*is_template=*/template_p,
+					  /*is_namespace=*/false,
+					  /*check_dependency=*/true);
+      if (TREE_CODE (argument) != TEMPLATE_DECL
+	  && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
+	cp_parser_error (parser, "expected template-name");
+    }
+  if (cp_parser_parse_definitely (parser))
+    return argument;
+  /* It must be a non-type argument.  There permitted cases are given
+     in [temp.arg.nontype]:
+
+     -- an integral constant-expression of integral or enumeration
+        type; or
+
+     -- the name of a non-type template-parameter; or
+
+     -- the name of an object or function with external linkage...
+
+     -- the address of an object or function with external linkage...
+
+     -- a pointer to member...  */
+  /* Look for a non-type template parameter.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+    {
+      cp_parser_parse_tentatively (parser);
+      argument = cp_parser_primary_expression (parser,
+					       &idk,
+					       &qualifying_class);
+      if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
+	  || !cp_parser_next_token_ends_template_argument_p (parser))
+	cp_parser_simulate_error (parser);
+      if (cp_parser_parse_definitely (parser))
+	return argument;
+    }
+  /* If the next token is "&", the argument must be the address of an
+     object or function with external linkage.  */
+  address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
+  if (address_p)
+    cp_lexer_consume_token (parser->lexer);
+  /* See if we might have an id-expression.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  if (token->type == CPP_NAME
+      || token->keyword == RID_OPERATOR
+      || token->type == CPP_SCOPE
+      || token->type == CPP_TEMPLATE_ID
+      || token->type == CPP_NESTED_NAME_SPECIFIER)
+    {
+      cp_parser_parse_tentatively (parser);
+      argument = cp_parser_primary_expression (parser,
+					       &idk,
+					       &qualifying_class);
+      if (cp_parser_error_occurred (parser)
+	  || !cp_parser_next_token_ends_template_argument_p (parser))
+	cp_parser_abort_tentative_parse (parser);
+      else
+	{
+	  if (qualifying_class)
+	    argument = finish_qualified_id_expr (qualifying_class,
+						 argument,
+						 /*done=*/true,
+						 address_p);
+	  if (TREE_CODE (argument) == VAR_DECL)
+	    {
+	      /* A variable without external linkage might still be a
+		 valid constant-expression, so no error is issued here
+		 if the external-linkage check fails.  */
+	      if (!DECL_EXTERNAL_LINKAGE_P (argument))
+		cp_parser_simulate_error (parser);
+	    }
+	  else if (is_overloaded_fn (argument))
+	    /* All overloaded functions are allowed; if the external
+	       linkage test does not pass, an error will be issued
+	       later.  */
+	    ;
+	  else if (address_p
+		   && (TREE_CODE (argument) == OFFSET_REF 
+		       || TREE_CODE (argument) == SCOPE_REF))
+	    /* A pointer-to-member.  */
+	    ;
+	  else
+	    cp_parser_simulate_error (parser);
+
+	  if (cp_parser_parse_definitely (parser))
+	    {
+	      if (address_p)
+		argument = build_x_unary_op (ADDR_EXPR, argument);
+	      return argument;
+	    }
+	}
+    }
+  /* If the argument started with "&", there are no other valid
+     alternatives at this point.  */
+  if (address_p)
+    {
+      cp_parser_error (parser, "invalid non-type template argument");
+      return error_mark_node;
+    }
+  /* If the argument wasn't successfully parsed as a type-id followed
+     by '>>', the argument can only be a constant expression now.  
+     Otherwise, we try parsing the constant-expression tentatively,
+     because the argument could really be a type-id.  */
+  if (maybe_type_id)
+    cp_parser_parse_tentatively (parser);
+  argument = cp_parser_constant_expression (parser, 
+					    /*allow_non_constant_p=*/false,
+					    /*non_constant_p=*/NULL);
+  argument = fold_non_dependent_expr (argument);
+  if (!maybe_type_id)
+    return argument;
+  if (!cp_parser_next_token_ends_template_argument_p (parser))
+    cp_parser_error (parser, "expected template-argument");
+  if (cp_parser_parse_definitely (parser))
+    return argument;
+  /* We did our best to parse the argument as a non type-id, but that
+     was the only alternative that matched (albeit with a '>' after
+     it). We can assume it's just a typo from the user, and a 
+     diagnostic will then be issued.  */
+  return cp_parser_type_id (parser);
+}
+
+/* Parse an explicit-instantiation.
+
+   explicit-instantiation:
+     template declaration  
+
+   Although the standard says `declaration', what it really means is:
+
+   explicit-instantiation:
+     template decl-specifier-seq [opt] declarator [opt] ; 
+
+   Things like `template int S<int>::i = 5, int S<double>::j;' are not
+   supposed to be allowed.  A defect report has been filed about this
+   issue.  
+
+   GNU Extension:
+  
+   explicit-instantiation:
+     storage-class-specifier template 
+       decl-specifier-seq [opt] declarator [opt] ;
+     function-specifier template 
+       decl-specifier-seq [opt] declarator [opt] ;  */
+
+static void
+cp_parser_explicit_instantiation (cp_parser* parser)
+{
+  int declares_class_or_enum;
+  tree decl_specifiers;
+  tree attributes;
+  tree extension_specifier = NULL_TREE;
+
+  /* Look for an (optional) storage-class-specifier or
+     function-specifier.  */
+  if (cp_parser_allow_gnu_extensions_p (parser))
+    {
+      extension_specifier 
+	= cp_parser_storage_class_specifier_opt (parser);
+      if (!extension_specifier)
+	extension_specifier = cp_parser_function_specifier_opt (parser);
+    }
+
+  /* Look for the `template' keyword.  */
+  cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'");
+  /* Let the front end know that we are processing an explicit
+     instantiation.  */
+  begin_explicit_instantiation ();
+  /* [temp.explicit] says that we are supposed to ignore access
+     control while processing explicit instantiation directives.  */
+  push_deferring_access_checks (dk_no_check);
+  /* Parse a decl-specifier-seq.  */
+  decl_specifiers 
+    = cp_parser_decl_specifier_seq (parser,
+				    CP_PARSER_FLAGS_OPTIONAL,
+				    &attributes,
+				    &declares_class_or_enum);
+  /* If there was exactly one decl-specifier, and it declared a class,
+     and there's no declarator, then we have an explicit type
+     instantiation.  */
+  if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
+    {
+      tree type;
+
+      type = check_tag_decl (decl_specifiers);
+      /* Turn access control back on for names used during
+	 template instantiation.  */
+      pop_deferring_access_checks ();
+      if (type)
+	do_type_instantiation (type, extension_specifier, /*complain=*/1);
+    }
+  else
+    {
+      tree declarator;
+      tree decl;
+
+      /* Parse the declarator.  */
+      declarator 
+	= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
+				/*ctor_dtor_or_conv_p=*/NULL,
+				/*parenthesized_p=*/NULL);
+      cp_parser_check_for_definition_in_return_type (declarator, 
+						     declares_class_or_enum);
+      if (declarator != error_mark_node)
+	{
+	  decl = grokdeclarator (declarator, decl_specifiers, 
+				 NORMAL, 0, NULL);
+	  /* Turn access control back on for names used during
+	     template instantiation.  */
+	  pop_deferring_access_checks ();
+	  /* Do the explicit instantiation.  */
+	  do_decl_instantiation (decl, extension_specifier);
+	}
+      else
+	{
+	  pop_deferring_access_checks ();
+	  /* Skip the body of the explicit instantiation.  */
+	  cp_parser_skip_to_end_of_statement (parser);
+	}
+    }
+  /* We're done with the instantiation.  */
+  end_explicit_instantiation ();
+
+  cp_parser_consume_semicolon_at_end_of_statement (parser);
+}
+
+/* Parse an explicit-specialization.
+
+   explicit-specialization:
+     template < > declaration  
+
+   Although the standard says `declaration', what it really means is:
+
+   explicit-specialization:
+     template <> decl-specifier [opt] init-declarator [opt] ;
+     template <> function-definition 
+     template <> explicit-specialization
+     template <> template-declaration  */
+
+static void
+cp_parser_explicit_specialization (cp_parser* parser)
+{
+  /* Look for the `template' keyword.  */
+  cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'");
+  /* Look for the `<'.  */
+  cp_parser_require (parser, CPP_LESS, "`<'");
+  /* Look for the `>'.  */
+  cp_parser_require (parser, CPP_GREATER, "`>'");
+  /* We have processed another parameter list.  */
+  ++parser->num_template_parameter_lists;
+  /* Let the front end know that we are beginning a specialization.  */
+  begin_specialization ();
+
+  /* If the next keyword is `template', we need to figure out whether
+     or not we're looking a template-declaration.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
+    {
+      if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
+	  && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
+	cp_parser_template_declaration_after_export (parser,
+						     /*member_p=*/false);
+      else
+	cp_parser_explicit_specialization (parser);
+    }
+  else
+    /* Parse the dependent declaration.  */
+    cp_parser_single_declaration (parser, 
+				  /*member_p=*/false,
+				  /*friend_p=*/NULL);
+
+  /* We're done with the specialization.  */
+  end_specialization ();
+  /* We're done with this parameter list.  */
+  --parser->num_template_parameter_lists;
+}
+
+/* Parse a type-specifier.
+
+   type-specifier:
+     simple-type-specifier
+     class-specifier
+     enum-specifier
+     elaborated-type-specifier
+     cv-qualifier
+
+   GNU Extension:
+
+   type-specifier:
+     __complex__
+
+   Returns a representation of the type-specifier.  If the
+   type-specifier is a keyword (like `int' or `const', or
+   `__complex__') then the corresponding IDENTIFIER_NODE is returned.
+   For a class-specifier, enum-specifier, or elaborated-type-specifier
+   a TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
+
+   If IS_FRIEND is TRUE then this type-specifier is being declared a
+   `friend'.  If IS_DECLARATION is TRUE, then this type-specifier is
+   appearing in a decl-specifier-seq.
+
+   If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
+   class-specifier, enum-specifier, or elaborated-type-specifier, then
+   *DECLARES_CLASS_OR_ENUM is set to a nonzero value.  The value is 1
+   if a type is declared; 2 if it is defined.  Otherwise, it is set to
+   zero.
+
+   If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
+   cv-qualifier, then IS_CV_QUALIFIER is set to TRUE.  Otherwise, it
+   is set to FALSE.  */
+
+static tree
+cp_parser_type_specifier (cp_parser* parser, 
+			  cp_parser_flags flags, 
+			  bool is_friend,
+			  bool is_declaration,
+			  int* declares_class_or_enum,
+			  bool* is_cv_qualifier)
+{
+  tree type_spec = NULL_TREE;
+  cp_token *token;
+  enum rid keyword;
+
+  /* Assume this type-specifier does not declare a new type.  */
+  if (declares_class_or_enum)
+    *declares_class_or_enum = 0;
+  /* And that it does not specify a cv-qualifier.  */
+  if (is_cv_qualifier)
+    *is_cv_qualifier = false;
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+
+  /* If we're looking at a keyword, we can use that to guide the
+     production we choose.  */
+  keyword = token->keyword;
+  switch (keyword)
+    {
+      /* Any of these indicate either a class-specifier, or an
+	 elaborated-type-specifier.  */
+    case RID_CLASS:
+    case RID_STRUCT:
+    case RID_UNION:
+    case RID_ENUM:
+      /* Parse tentatively so that we can back up if we don't find a
+	 class-specifier or enum-specifier.  */
+      cp_parser_parse_tentatively (parser);
+      /* Look for the class-specifier or enum-specifier.  */
+      if (keyword == RID_ENUM)
+	type_spec = cp_parser_enum_specifier (parser);
+      else
+	type_spec = cp_parser_class_specifier (parser);
+
+      /* If that worked, we're done.  */
+      if (cp_parser_parse_definitely (parser))
+	{
+	  if (declares_class_or_enum)
+	    *declares_class_or_enum = 2;
+	  return type_spec;
+	}
+
+      /* Fall through.  */
+
+    case RID_TYPENAME:
+      /* Look for an elaborated-type-specifier.  */
+      type_spec = cp_parser_elaborated_type_specifier (parser,
+						       is_friend,
+						       is_declaration);
+      /* We're declaring a class or enum -- unless we're using
+	 `typename'.  */
+      if (declares_class_or_enum && keyword != RID_TYPENAME)
+	*declares_class_or_enum = 1;
+      return type_spec;
+
+    case RID_CONST:
+    case RID_VOLATILE:
+    case RID_RESTRICT:
+      type_spec = cp_parser_cv_qualifier_opt (parser);
+      /* Even though we call a routine that looks for an optional
+	 qualifier, we know that there should be one.  */
+      my_friendly_assert (type_spec != NULL, 20000328);
+      /* This type-specifier was a cv-qualified.  */
+      if (is_cv_qualifier)
+	*is_cv_qualifier = true;
+
+      return type_spec;
+
+    case RID_COMPLEX:
+      /* The `__complex__' keyword is a GNU extension.  */
+      return cp_lexer_consume_token (parser->lexer)->value;
+
+    default:
+      break;
+    }
+
+  /* If we do not already have a type-specifier, assume we are looking
+     at a simple-type-specifier.  */
+  type_spec = cp_parser_simple_type_specifier (parser, flags, 
+					       /*identifier_p=*/true);
+
+  /* If we didn't find a type-specifier, and a type-specifier was not
+     optional in this context, issue an error message.  */
+  if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
+    {
+      cp_parser_error (parser, "expected type specifier");
+      return error_mark_node;
+    }
+
+  return type_spec;
+}
+
+/* Parse a simple-type-specifier.
+
+   simple-type-specifier:
+     :: [opt] nested-name-specifier [opt] type-name
+     :: [opt] nested-name-specifier template template-id
+     char
+     wchar_t
+     bool
+     short
+     int
+     long
+     signed
+     unsigned
+     float
+     double
+     void  
+
+   GNU Extension:
+
+   simple-type-specifier:
+     __typeof__ unary-expression
+     __typeof__ ( type-id )
+
+   For the various keywords, the value returned is simply the
+   TREE_IDENTIFIER representing the keyword if IDENTIFIER_P is true.
+   For the first two productions, and if IDENTIFIER_P is false, the
+   value returned is the indicated TYPE_DECL.  */
+
+static tree
+cp_parser_simple_type_specifier (cp_parser* parser, cp_parser_flags flags,
+				 bool identifier_p)
+{
+  tree type = NULL_TREE;
+  cp_token *token;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+
+  /* If we're looking at a keyword, things are easy.  */
+  switch (token->keyword)
+    {
+    case RID_CHAR:
+      type = char_type_node;
+      break;
+    case RID_WCHAR:
+      type = wchar_type_node;
+      break;
+    case RID_BOOL:
+      type = boolean_type_node;
+      break;
+    case RID_SHORT:
+      type = short_integer_type_node;
+      break;
+    case RID_INT:
+      type = integer_type_node;
+      break;
+    case RID_LONG:
+      type = long_integer_type_node;
+      break;
+    case RID_SIGNED:
+      type = integer_type_node;
+      break;
+    case RID_UNSIGNED:
+      type = unsigned_type_node;
+      break;
+    case RID_FLOAT:
+      type = float_type_node;
+      break;
+    case RID_DOUBLE:
+      type = double_type_node;
+      break;
+    case RID_VOID:
+      type = void_type_node;
+      break;
+
+    case RID_TYPEOF:
+      {
+	tree operand;
+
+	/* Consume the `typeof' token.  */
+	cp_lexer_consume_token (parser->lexer);
+	/* Parse the operand to `typeof'.  */
+	operand = cp_parser_sizeof_operand (parser, RID_TYPEOF);
+	/* If it is not already a TYPE, take its type.  */
+	if (!TYPE_P (operand))
+	  operand = finish_typeof (operand);
+
+	return operand;
+      }
+
+    default:
+      break;
+    }
+
+  /* If the type-specifier was for a built-in type, we're done.  */
+  if (type)
+    {
+      tree id;
+
+      /* Consume the token.  */
+      id = cp_lexer_consume_token (parser->lexer)->value;
+
+      /* There is no valid C++ program where a non-template type is
+	 followed by a "<".  That usually indicates that the user thought
+	 that the type was a template.  */
+      cp_parser_check_for_invalid_template_id (parser, type);
+
+      return identifier_p ? id : TYPE_NAME (type);
+    }
+
+  /* The type-specifier must be a user-defined type.  */
+  if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES)) 
+    {
+      bool qualified_p;
+      bool global_p;
+
+      /* Don't gobble tokens or issue error messages if this is an
+	 optional type-specifier.  */
+      if (flags & CP_PARSER_FLAGS_OPTIONAL)
+	cp_parser_parse_tentatively (parser);
+
+      /* Look for the optional `::' operator.  */
+      global_p
+	= (cp_parser_global_scope_opt (parser,
+				       /*current_scope_valid_p=*/false)
+	   != NULL_TREE);
+      /* Look for the nested-name specifier.  */
+      qualified_p
+	= (cp_parser_nested_name_specifier_opt (parser,
+						/*typename_keyword_p=*/false,
+						/*check_dependency_p=*/true,
+						/*type_p=*/false,
+						/*is_declaration=*/false)
+	   != NULL_TREE);
+      /* If we have seen a nested-name-specifier, and the next token
+	 is `template', then we are using the template-id production.  */
+      if (parser->scope 
+	  && cp_parser_optional_template_keyword (parser))
+	{
+	  /* Look for the template-id.  */
+	  type = cp_parser_template_id (parser, 
+					/*template_keyword_p=*/true,
+					/*check_dependency_p=*/true,
+					/*is_declaration=*/false);
+	  /* If the template-id did not name a type, we are out of
+	     luck.  */
+	  if (TREE_CODE (type) != TYPE_DECL)
+	    {
+	      cp_parser_error (parser, "expected template-id for type");
+	      type = NULL_TREE;
+	    }
+	}
+      /* Otherwise, look for a type-name.  */
+      else
+	type = cp_parser_type_name (parser);
+      /* Keep track of all name-lookups performed in class scopes.  */
+      if (type  
+	  && !global_p
+	  && !qualified_p
+	  && TREE_CODE (type) == TYPE_DECL 
+	  && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
+	maybe_note_name_used_in_class (DECL_NAME (type), type);
+      /* If it didn't work out, we don't have a TYPE.  */
+      if ((flags & CP_PARSER_FLAGS_OPTIONAL) 
+	  && !cp_parser_parse_definitely (parser))
+	type = NULL_TREE;
+    }
+
+  /* If we didn't get a type-name, issue an error message.  */
+  if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
+    {
+      cp_parser_error (parser, "expected type-name");
+      return error_mark_node;
+    }
+
+  /* There is no valid C++ program where a non-template type is
+     followed by a "<".  That usually indicates that the user thought
+     that the type was a template.  */
+  if (type && type != error_mark_node)
+    cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type));
+
+  return type;
+}
+
+/* Parse a type-name.
+
+   type-name:
+     class-name
+     enum-name
+     typedef-name  
+
+   enum-name:
+     identifier
+
+   typedef-name:
+     identifier 
+
+   Returns a TYPE_DECL for the the type.  */
+
+static tree
+cp_parser_type_name (cp_parser* parser)
+{
+  tree type_decl;
+  tree identifier;
+
+  /* We can't know yet whether it is a class-name or not.  */
+  cp_parser_parse_tentatively (parser);
+  /* Try a class-name.  */
+  type_decl = cp_parser_class_name (parser, 
+				    /*typename_keyword_p=*/false,
+				    /*template_keyword_p=*/false,
+				    /*type_p=*/false,
+				    /*check_dependency_p=*/true,
+				    /*class_head_p=*/false,
+				    /*is_declaration=*/false);
+  /* If it's not a class-name, keep looking.  */
+  if (!cp_parser_parse_definitely (parser))
+    {
+      /* It must be a typedef-name or an enum-name.  */
+      identifier = cp_parser_identifier (parser);
+      if (identifier == error_mark_node)
+	return error_mark_node;
+      
+      /* Look up the type-name.  */
+      type_decl = cp_parser_lookup_name_simple (parser, identifier);
+      /* Issue an error if we did not find a type-name.  */
+      if (TREE_CODE (type_decl) != TYPE_DECL)
+	{
+	  if (!cp_parser_simulate_error (parser))
+	    cp_parser_name_lookup_error (parser, identifier, type_decl, 
+					 "is not a type");
+	  type_decl = error_mark_node;
+	}
+      /* Remember that the name was used in the definition of the
+	 current class so that we can check later to see if the
+	 meaning would have been different after the class was
+	 entirely defined.  */
+      else if (type_decl != error_mark_node
+	       && !parser->scope)
+	maybe_note_name_used_in_class (identifier, type_decl);
+    }
+  
+  return type_decl;
+}
+
+
+/* Parse an elaborated-type-specifier.  Note that the grammar given
+   here incorporates the resolution to DR68.
+
+   elaborated-type-specifier:
+     class-key :: [opt] nested-name-specifier [opt] identifier
+     class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
+     enum :: [opt] nested-name-specifier [opt] identifier
+     typename :: [opt] nested-name-specifier identifier
+     typename :: [opt] nested-name-specifier template [opt] 
+       template-id 
+
+   GNU extension:
+
+   elaborated-type-specifier:
+     class-key attributes :: [opt] nested-name-specifier [opt] identifier
+     class-key attributes :: [opt] nested-name-specifier [opt] 
+               template [opt] template-id
+     enum attributes :: [opt] nested-name-specifier [opt] identifier
+
+   If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
+   declared `friend'.  If IS_DECLARATION is TRUE, then this
+   elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
+   something is being declared.
+
+   Returns the TYPE specified.  */
+
+static tree
+cp_parser_elaborated_type_specifier (cp_parser* parser, 
+                                     bool is_friend, 
+                                     bool is_declaration)
+{
+  enum tag_types tag_type;
+  tree identifier;
+  tree type = NULL_TREE;
+  tree attributes = NULL_TREE;
+
+  /* See if we're looking at the `enum' keyword.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
+    {
+      /* Consume the `enum' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Remember that it's an enumeration type.  */
+      tag_type = enum_type;
+      /* Parse the attributes.  */
+      attributes = cp_parser_attributes_opt (parser);
+    }
+  /* Or, it might be `typename'.  */
+  else if (cp_lexer_next_token_is_keyword (parser->lexer,
+					   RID_TYPENAME))
+    {
+      /* Consume the `typename' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Remember that it's a `typename' type.  */
+      tag_type = typename_type;
+      /* The `typename' keyword is only allowed in templates.  */
+      if (!processing_template_decl)
+	pedwarn ("using `typename' outside of template");
+    }
+  /* Otherwise it must be a class-key.  */
+  else
+    {
+      tag_type = cp_parser_class_key (parser);
+      if (tag_type == none_type)
+	return error_mark_node;
+      /* Parse the attributes.  */
+      attributes = cp_parser_attributes_opt (parser);
+    }
+
+  /* Look for the `::' operator.  */
+  cp_parser_global_scope_opt (parser, 
+			      /*current_scope_valid_p=*/false);
+  /* Look for the nested-name-specifier.  */
+  if (tag_type == typename_type)
+    {
+      if (cp_parser_nested_name_specifier (parser,
+					   /*typename_keyword_p=*/true,
+					   /*check_dependency_p=*/true,
+					   /*type_p=*/true,
+					   is_declaration) 
+	  == error_mark_node)
+	return error_mark_node;
+    }
+  else
+    /* Even though `typename' is not present, the proposed resolution
+       to Core Issue 180 says that in `class A<T>::B', `B' should be
+       considered a type-name, even if `A<T>' is dependent.  */
+    cp_parser_nested_name_specifier_opt (parser,
+					 /*typename_keyword_p=*/true,
+					 /*check_dependency_p=*/true,
+					 /*type_p=*/true,
+					 is_declaration);
+  /* For everything but enumeration types, consider a template-id.  */
+  if (tag_type != enum_type)
+    {
+      bool template_p = false;
+      tree decl;
+
+      /* Allow the `template' keyword.  */
+      template_p = cp_parser_optional_template_keyword (parser);
+      /* If we didn't see `template', we don't know if there's a
+         template-id or not.  */
+      if (!template_p)
+	cp_parser_parse_tentatively (parser);
+      /* Parse the template-id.  */
+      decl = cp_parser_template_id (parser, template_p,
+				    /*check_dependency_p=*/true,
+				    is_declaration);
+      /* If we didn't find a template-id, look for an ordinary
+         identifier.  */
+      if (!template_p && !cp_parser_parse_definitely (parser))
+	;
+      /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
+	 in effect, then we must assume that, upon instantiation, the
+	 template will correspond to a class.  */
+      else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
+	       && tag_type == typename_type)
+	type = make_typename_type (parser->scope, decl,
+				   /*complain=*/1);
+      else 
+	type = TREE_TYPE (decl);
+    }
+
+  /* For an enumeration type, consider only a plain identifier.  */
+  if (!type)
+    {
+      identifier = cp_parser_identifier (parser);
+
+      if (identifier == error_mark_node)
+	{
+	  parser->scope = NULL_TREE;
+	  return error_mark_node;
+	}
+
+      /* For a `typename', we needn't call xref_tag.  */
+      if (tag_type == typename_type)
+	return make_typename_type (parser->scope, identifier, 
+				   /*complain=*/1);
+      /* Look up a qualified name in the usual way.  */
+      if (parser->scope)
+	{
+	  tree decl;
+
+	  /* In an elaborated-type-specifier, names are assumed to name
+	     types, so we set IS_TYPE to TRUE when calling
+	     cp_parser_lookup_name.  */
+	  decl = cp_parser_lookup_name (parser, identifier, 
+					/*is_type=*/true,
+					/*is_template=*/false,
+					/*is_namespace=*/false,
+					/*check_dependency=*/true);
+
+	  /* If we are parsing friend declaration, DECL may be a
+	     TEMPLATE_DECL tree node here.  However, we need to check
+	     whether this TEMPLATE_DECL results in valid code.  Consider
+	     the following example:
+
+	       namespace N {
+		 template <class T> class C {};
+	       }
+	       class X {
+		 template <class T> friend class N::C; // #1, valid code
+	       };
+	       template <class T> class Y {
+		 friend class N::C;		       // #2, invalid code
+	       };
+
+	     For both case #1 and #2, we arrive at a TEMPLATE_DECL after
+	     name lookup of `N::C'.  We see that friend declaration must
+	     be template for the code to be valid.  Note that
+	     processing_template_decl does not work here since it is
+	     always 1 for the above two cases.  */
+
+	  decl = (cp_parser_maybe_treat_template_as_class 
+		  (decl, /*tag_name_p=*/is_friend
+			 && parser->num_template_parameter_lists));
+
+	  if (TREE_CODE (decl) != TYPE_DECL)
+	    {
+	      error ("expected type-name");
+	      return error_mark_node;
+	    }
+
+	  if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
+	    check_elaborated_type_specifier 
+	      (tag_type, decl,
+	       (parser->num_template_parameter_lists
+		|| DECL_SELF_REFERENCE_P (decl)));
+
+	  type = TREE_TYPE (decl);
+	}
+      else 
+	{
+	  /* An elaborated-type-specifier sometimes introduces a new type and
+	     sometimes names an existing type.  Normally, the rule is that it
+	     introduces a new type only if there is not an existing type of
+	     the same name already in scope.  For example, given:
+
+	       struct S {};
+	       void f() { struct S s; }
+
+	     the `struct S' in the body of `f' is the same `struct S' as in
+	     the global scope; the existing definition is used.  However, if
+	     there were no global declaration, this would introduce a new 
+	     local class named `S'.
+
+	     An exception to this rule applies to the following code:
+
+	       namespace N { struct S; }
+
+	     Here, the elaborated-type-specifier names a new type
+	     unconditionally; even if there is already an `S' in the
+	     containing scope this declaration names a new type.
+	     This exception only applies if the elaborated-type-specifier
+	     forms the complete declaration:
+
+	       [class.name] 
+
+	       A declaration consisting solely of `class-key identifier ;' is
+	       either a redeclaration of the name in the current scope or a
+	       forward declaration of the identifier as a class name.  It
+	       introduces the name into the current scope.
+
+	     We are in this situation precisely when the next token is a `;'.
+
+	     An exception to the exception is that a `friend' declaration does
+	     *not* name a new type; i.e., given:
+
+	       struct S { friend struct T; };
+
+	     `T' is not a new type in the scope of `S'.  
+
+	     Also, `new struct S' or `sizeof (struct S)' never results in the
+	     definition of a new type; a new type can only be declared in a
+	     declaration context.  */
+
+ 	  /* Warn about attributes. They are ignored.  */
+ 	  if (attributes)
+	    warning ("type attributes are honored only at type definition");
+
+	  type = xref_tag (tag_type, identifier, 
+			   (is_friend 
+			    || !is_declaration
+			    || cp_lexer_next_token_is_not (parser->lexer, 
+							   CPP_SEMICOLON)),
+			   parser->num_template_parameter_lists);
+	}
+    }
+  if (tag_type != enum_type)
+    cp_parser_check_class_key (tag_type, type);
+
+  /* A "<" cannot follow an elaborated type specifier.  If that
+     happens, the user was probably trying to form a template-id.  */
+  cp_parser_check_for_invalid_template_id (parser, type);
+
+  return type;
+}
+
+/* Parse an enum-specifier.
+
+   enum-specifier:
+     enum identifier [opt] { enumerator-list [opt] }
+
+   Returns an ENUM_TYPE representing the enumeration.  */
+
+static tree
+cp_parser_enum_specifier (cp_parser* parser)
+{
+  cp_token *token;
+  tree identifier = NULL_TREE;
+  tree type;
+
+  /* Look for the `enum' keyword.  */
+  if (!cp_parser_require_keyword (parser, RID_ENUM, "`enum'"))
+    return error_mark_node;
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+
+  /* See if it is an identifier.  */
+  if (token->type == CPP_NAME)
+    identifier = cp_parser_identifier (parser);
+
+  /* Look for the `{'.  */
+  if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
+    return error_mark_node;
+
+  /* At this point, we're going ahead with the enum-specifier, even
+     if some other problem occurs.  */
+  cp_parser_commit_to_tentative_parse (parser);
+
+  /* Issue an error message if type-definitions are forbidden here.  */
+  cp_parser_check_type_definition (parser);
+
+  /* Create the new type.  */
+  type = start_enum (identifier ? identifier : make_anon_name ());
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If it's not a `}', then there are some enumerators.  */
+  if (token->type != CPP_CLOSE_BRACE)
+    cp_parser_enumerator_list (parser, type);
+  /* Look for the `}'.  */
+  cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
+
+  /* Finish up the enumeration.  */
+  finish_enum (type);
+
+  return type;
+}
+
+/* Parse an enumerator-list.  The enumerators all have the indicated
+   TYPE.  
+
+   enumerator-list:
+     enumerator-definition
+     enumerator-list , enumerator-definition  */
+
+static void
+cp_parser_enumerator_list (cp_parser* parser, tree type)
+{
+  while (true)
+    {
+      cp_token *token;
+
+      /* Parse an enumerator-definition.  */
+      cp_parser_enumerator_definition (parser, type);
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If it's not a `,', then we've reached the end of the 
+	 list.  */
+      if (token->type != CPP_COMMA)
+	break;
+      /* Otherwise, consume the `,' and keep going.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* If the next token is a `}', there is a trailing comma.  */
+      if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
+	{
+	  if (pedantic && !in_system_header)
+	    pedwarn ("comma at end of enumerator list");
+	  break;
+	}
+    }
+}
+
+/* Parse an enumerator-definition.  The enumerator has the indicated
+   TYPE.
+
+   enumerator-definition:
+     enumerator
+     enumerator = constant-expression
+    
+   enumerator:
+     identifier  */
+
+static void
+cp_parser_enumerator_definition (cp_parser* parser, tree type)
+{
+  cp_token *token;
+  tree identifier;
+  tree value;
+
+  /* Look for the identifier.  */
+  identifier = cp_parser_identifier (parser);
+  if (identifier == error_mark_node)
+    return;
+  
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If it's an `=', then there's an explicit value.  */
+  if (token->type == CPP_EQ)
+    {
+      /* Consume the `=' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Parse the value.  */
+      value = cp_parser_constant_expression (parser, 
+					     /*allow_non_constant_p=*/false,
+					     NULL);
+    }
+  else
+    value = NULL_TREE;
+
+  /* Create the enumerator.  */
+  build_enumerator (identifier, value, type);
+}
+
+/* Parse a namespace-name.
+
+   namespace-name:
+     original-namespace-name
+     namespace-alias
+
+   Returns the NAMESPACE_DECL for the namespace.  */
+
+static tree
+cp_parser_namespace_name (cp_parser* parser)
+{
+  tree identifier;
+  tree namespace_decl;
+
+  /* Get the name of the namespace.  */
+  identifier = cp_parser_identifier (parser);
+  if (identifier == error_mark_node)
+    return error_mark_node;
+
+  /* Look up the identifier in the currently active scope.  Look only
+     for namespaces, due to:
+
+       [basic.lookup.udir]
+
+       When looking up a namespace-name in a using-directive or alias
+       definition, only namespace names are considered.  
+
+     And:
+
+       [basic.lookup.qual]
+
+       During the lookup of a name preceding the :: scope resolution
+       operator, object, function, and enumerator names are ignored.  
+
+     (Note that cp_parser_class_or_namespace_name only calls this
+     function if the token after the name is the scope resolution
+     operator.)  */
+  namespace_decl = cp_parser_lookup_name (parser, identifier,
+					  /*is_type=*/false,
+					  /*is_template=*/false,
+					  /*is_namespace=*/true,
+					  /*check_dependency=*/true);
+  /* If it's not a namespace, issue an error.  */
+  if (namespace_decl == error_mark_node
+      || TREE_CODE (namespace_decl) != NAMESPACE_DECL)
+    {
+      cp_parser_error (parser, "expected namespace-name");
+      namespace_decl = error_mark_node;
+    }
+  
+  return namespace_decl;
+}
+
+/* Parse a namespace-definition.
+
+   namespace-definition:
+     named-namespace-definition
+     unnamed-namespace-definition  
+
+   named-namespace-definition:
+     original-namespace-definition
+     extension-namespace-definition
+
+   original-namespace-definition:
+     namespace identifier { namespace-body }
+   
+   extension-namespace-definition:
+     namespace original-namespace-name { namespace-body }
+ 
+   unnamed-namespace-definition:
+     namespace { namespace-body } */
+
+static void
+cp_parser_namespace_definition (cp_parser* parser)
+{
+  tree identifier;
+
+  /* Look for the `namespace' keyword.  */
+  cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
+
+  /* Get the name of the namespace.  We do not attempt to distinguish
+     between an original-namespace-definition and an
+     extension-namespace-definition at this point.  The semantic
+     analysis routines are responsible for that.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+    identifier = cp_parser_identifier (parser);
+  else
+    identifier = NULL_TREE;
+
+  /* Look for the `{' to start the namespace.  */
+  cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
+  /* Start the namespace.  */
+  push_namespace (identifier);
+  /* Parse the body of the namespace.  */
+  cp_parser_namespace_body (parser);
+  /* Finish the namespace.  */
+  pop_namespace ();
+  /* Look for the final `}'.  */
+  cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
+}
+
+/* Parse a namespace-body.
+
+   namespace-body:
+     declaration-seq [opt]  */
+
+static void
+cp_parser_namespace_body (cp_parser* parser)
+{
+  cp_parser_declaration_seq_opt (parser);
+}
+
+/* Parse a namespace-alias-definition.
+
+   namespace-alias-definition:
+     namespace identifier = qualified-namespace-specifier ;  */
+
+static void
+cp_parser_namespace_alias_definition (cp_parser* parser)
+{
+  tree identifier;
+  tree namespace_specifier;
+
+  /* Look for the `namespace' keyword.  */
+  cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
+  /* Look for the identifier.  */
+  identifier = cp_parser_identifier (parser);
+  if (identifier == error_mark_node)
+    return;
+  /* Look for the `=' token.  */
+  cp_parser_require (parser, CPP_EQ, "`='");
+  /* Look for the qualified-namespace-specifier.  */
+  namespace_specifier 
+    = cp_parser_qualified_namespace_specifier (parser);
+  /* Look for the `;' token.  */
+  cp_parser_require (parser, CPP_SEMICOLON, "`;'");
+
+  /* Register the alias in the symbol table.  */
+  do_namespace_alias (identifier, namespace_specifier);
+}
+
+/* Parse a qualified-namespace-specifier.
+
+   qualified-namespace-specifier:
+     :: [opt] nested-name-specifier [opt] namespace-name
+
+   Returns a NAMESPACE_DECL corresponding to the specified
+   namespace.  */
+
+static tree
+cp_parser_qualified_namespace_specifier (cp_parser* parser)
+{
+  /* Look for the optional `::'.  */
+  cp_parser_global_scope_opt (parser, 
+			      /*current_scope_valid_p=*/false);
+
+  /* Look for the optional nested-name-specifier.  */
+  cp_parser_nested_name_specifier_opt (parser,
+				       /*typename_keyword_p=*/false,
+				       /*check_dependency_p=*/true,
+				       /*type_p=*/false,
+				       /*is_declaration=*/true);
+
+  return cp_parser_namespace_name (parser);
+}
+
+/* Parse a using-declaration.
+
+   using-declaration:
+     using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
+     using :: unqualified-id ;  */
+
+static void
+cp_parser_using_declaration (cp_parser* parser)
+{
+  cp_token *token;
+  bool typename_p = false;
+  bool global_scope_p;
+  tree decl;
+  tree identifier;
+  tree scope;
+  tree qscope;
+
+  /* Look for the `using' keyword.  */
+  cp_parser_require_keyword (parser, RID_USING, "`using'");
+  
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* See if it's `typename'.  */
+  if (token->keyword == RID_TYPENAME)
+    {
+      /* Remember that we've seen it.  */
+      typename_p = true;
+      /* Consume the `typename' token.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  /* Look for the optional global scope qualification.  */
+  global_scope_p 
+    = (cp_parser_global_scope_opt (parser,
+				   /*current_scope_valid_p=*/false) 
+       != NULL_TREE);
+
+  /* If we saw `typename', or didn't see `::', then there must be a
+     nested-name-specifier present.  */
+  if (typename_p || !global_scope_p)
+    qscope = cp_parser_nested_name_specifier (parser, typename_p, 
+					      /*check_dependency_p=*/true,
+					      /*type_p=*/false,
+					      /*is_declaration=*/true);
+  /* Otherwise, we could be in either of the two productions.  In that
+     case, treat the nested-name-specifier as optional.  */
+  else
+    qscope = cp_parser_nested_name_specifier_opt (parser,
+						  /*typename_keyword_p=*/false,
+						  /*check_dependency_p=*/true,
+						  /*type_p=*/false,
+						  /*is_declaration=*/true);
+  if (!qscope)
+    qscope = global_namespace;
+
+  /* Parse the unqualified-id.  */
+  identifier = cp_parser_unqualified_id (parser, 
+					 /*template_keyword_p=*/false,
+					 /*check_dependency_p=*/true,
+					 /*declarator_p=*/true);
+
+  /* The function we call to handle a using-declaration is different
+     depending on what scope we are in.  */
+  if (identifier == error_mark_node)
+    ;
+  else if (TREE_CODE (identifier) != IDENTIFIER_NODE
+	   && TREE_CODE (identifier) != BIT_NOT_EXPR)
+    /* [namespace.udecl]
+
+       A using declaration shall not name a template-id.  */
+    error ("a template-id may not appear in a using-declaration");
+  else
+    {
+      scope = current_scope ();
+      if (scope && TYPE_P (scope))
+	{
+	  /* Create the USING_DECL.  */
+	  decl = do_class_using_decl (build_nt (SCOPE_REF,
+						parser->scope,
+						identifier));
+	  /* Add it to the list of members in this class.  */
+	  finish_member_declaration (decl);
+	}
+      else
+	{
+	  decl = cp_parser_lookup_name_simple (parser, identifier);
+	  if (decl == error_mark_node)
+	    cp_parser_name_lookup_error (parser, identifier, decl, NULL);
+	  else if (scope)
+	    do_local_using_decl (decl, qscope, identifier);
+	  else
+	    do_toplevel_using_decl (decl, qscope, identifier);
+	}
+    }
+
+  /* Look for the final `;'.  */
+  cp_parser_require (parser, CPP_SEMICOLON, "`;'");
+}
+
+/* Parse a using-directive.  
+ 
+   using-directive:
+     using namespace :: [opt] nested-name-specifier [opt]
+       namespace-name ;  */
+
+static void
+cp_parser_using_directive (cp_parser* parser)
+{
+  tree namespace_decl;
+  tree attribs;
+
+  /* Look for the `using' keyword.  */
+  cp_parser_require_keyword (parser, RID_USING, "`using'");
+  /* And the `namespace' keyword.  */
+  cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
+  /* Look for the optional `::' operator.  */
+  cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
+  /* And the optional nested-name-specifier.  */
+  cp_parser_nested_name_specifier_opt (parser,
+				       /*typename_keyword_p=*/false,
+				       /*check_dependency_p=*/true,
+				       /*type_p=*/false,
+				       /*is_declaration=*/true);
+  /* Get the namespace being used.  */
+  namespace_decl = cp_parser_namespace_name (parser);
+  /* And any specified attributes.  */
+  attribs = cp_parser_attributes_opt (parser);
+  /* Update the symbol table.  */
+  parse_using_directive (namespace_decl, attribs);
+  /* Look for the final `;'.  */
+  cp_parser_require (parser, CPP_SEMICOLON, "`;'");
+}
+
+/* Parse an asm-definition.
+
+   asm-definition:
+     asm ( string-literal ) ;  
+
+   GNU Extension:
+
+   asm-definition:
+     asm volatile [opt] ( string-literal ) ;
+     asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
+     asm volatile [opt] ( string-literal : asm-operand-list [opt]
+                          : asm-operand-list [opt] ) ;
+     asm volatile [opt] ( string-literal : asm-operand-list [opt] 
+                          : asm-operand-list [opt] 
+                          : asm-operand-list [opt] ) ;  */
+
+static void
+cp_parser_asm_definition (cp_parser* parser)
+{
+  cp_token *token;
+  tree string;
+  tree outputs = NULL_TREE;
+  tree inputs = NULL_TREE;
+  tree clobbers = NULL_TREE;
+  tree asm_stmt;
+  bool volatile_p = false;
+  bool extended_p = false;
+
+  /* Look for the `asm' keyword.  */
+  cp_parser_require_keyword (parser, RID_ASM, "`asm'");
+  /* See if the next token is `volatile'.  */
+  if (cp_parser_allow_gnu_extensions_p (parser)
+      && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
+    {
+      /* Remember that we saw the `volatile' keyword.  */
+      volatile_p = true;
+      /* Consume the token.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+  /* Look for the opening `('.  */
+  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+  /* Look for the string.  */
+  token = cp_parser_require (parser, CPP_STRING, "asm body");
+  if (!token)
+    return;
+  string = token->value;
+  /* If we're allowing GNU extensions, check for the extended assembly
+     syntax.  Unfortunately, the `:' tokens need not be separated by 
+     a space in C, and so, for compatibility, we tolerate that here
+     too.  Doing that means that we have to treat the `::' operator as
+     two `:' tokens.  */
+  if (cp_parser_allow_gnu_extensions_p (parser)
+      && at_function_scope_p ()
+      && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
+	  || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
+    {
+      bool inputs_p = false;
+      bool clobbers_p = false;
+
+      /* The extended syntax was used.  */
+      extended_p = true;
+
+      /* Look for outputs.  */
+      if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
+	{
+	  /* Consume the `:'.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  /* Parse the output-operands.  */
+	  if (cp_lexer_next_token_is_not (parser->lexer, 
+					  CPP_COLON)
+	      && cp_lexer_next_token_is_not (parser->lexer,
+					     CPP_SCOPE)
+	      && cp_lexer_next_token_is_not (parser->lexer,
+					     CPP_CLOSE_PAREN))
+	    outputs = cp_parser_asm_operand_list (parser);
+	}
+      /* If the next token is `::', there are no outputs, and the
+	 next token is the beginning of the inputs.  */
+      else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
+	{
+	  /* Consume the `::' token.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  /* The inputs are coming next.  */
+	  inputs_p = true;
+	}
+
+      /* Look for inputs.  */
+      if (inputs_p
+	  || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
+	{
+	  if (!inputs_p)
+	    /* Consume the `:'.  */
+	    cp_lexer_consume_token (parser->lexer);
+	  /* Parse the output-operands.  */
+	  if (cp_lexer_next_token_is_not (parser->lexer, 
+					  CPP_COLON)
+	      && cp_lexer_next_token_is_not (parser->lexer,
+					     CPP_SCOPE)
+	      && cp_lexer_next_token_is_not (parser->lexer,
+					     CPP_CLOSE_PAREN))
+	    inputs = cp_parser_asm_operand_list (parser);
+	}
+      else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
+	/* The clobbers are coming next.  */
+	clobbers_p = true;
+
+      /* Look for clobbers.  */
+      if (clobbers_p 
+	  || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
+	{
+	  if (!clobbers_p)
+	    /* Consume the `:'.  */
+	    cp_lexer_consume_token (parser->lexer);
+	  /* Parse the clobbers.  */
+	  if (cp_lexer_next_token_is_not (parser->lexer,
+					  CPP_CLOSE_PAREN))
+	    clobbers = cp_parser_asm_clobber_list (parser);
+	}
+    }
+  /* Look for the closing `)'.  */
+  if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
+    cp_parser_skip_to_closing_parenthesis (parser, true, false,
+					   /*consume_paren=*/true);
+  cp_parser_require (parser, CPP_SEMICOLON, "`;'");
+
+  /* Create the ASM_STMT.  */
+  if (at_function_scope_p ())
+    {
+      asm_stmt = 
+	finish_asm_stmt (volatile_p 
+			 ? ridpointers[(int) RID_VOLATILE] : NULL_TREE,
+			 string, outputs, inputs, clobbers);
+      /* If the extended syntax was not used, mark the ASM_STMT.  */
+      if (!extended_p)
+	ASM_INPUT_P (asm_stmt) = 1;
+    }
+  else
+    assemble_asm (string);
+}
+
+/* Declarators [gram.dcl.decl] */
+
+/* Parse an init-declarator.
+
+   init-declarator:
+     declarator initializer [opt]
+
+   GNU Extension:
+
+   init-declarator:
+     declarator asm-specification [opt] attributes [opt] initializer [opt]
+
+   function-definition:
+     decl-specifier-seq [opt] declarator ctor-initializer [opt]
+       function-body 
+     decl-specifier-seq [opt] declarator function-try-block  
+
+   GNU Extension:
+
+   function-definition:
+     __extension__ function-definition 
+
+   The DECL_SPECIFIERS and PREFIX_ATTRIBUTES apply to this declarator.
+   Returns a representation of the entity declared.  If MEMBER_P is TRUE,
+   then this declarator appears in a class scope.  The new DECL created
+   by this declarator is returned.
+
+   If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
+   for a function-definition here as well.  If the declarator is a
+   declarator for a function-definition, *FUNCTION_DEFINITION_P will
+   be TRUE upon return.  By that point, the function-definition will
+   have been completely parsed.
+
+   FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
+   is FALSE.  */
+
+static tree
+cp_parser_init_declarator (cp_parser* parser, 
+			   tree decl_specifiers, 
+			   tree prefix_attributes,
+			   bool function_definition_allowed_p,
+			   bool member_p,
+			   int declares_class_or_enum,
+			   bool* function_definition_p)
+{
+  cp_token *token;
+  tree declarator;
+  tree attributes;
+  tree asm_specification;
+  tree initializer;
+  tree decl = NULL_TREE;
+  tree scope;
+  bool is_initialized;
+  bool is_parenthesized_init;
+  bool is_non_constant_init;
+  int ctor_dtor_or_conv_p;
+  bool friend_p;
+  bool pop_p = false;
+
+  /* Assume that this is not the declarator for a function
+     definition.  */
+  if (function_definition_p)
+    *function_definition_p = false;
+
+  /* Defer access checks while parsing the declarator; we cannot know
+     what names are accessible until we know what is being 
+     declared.  */
+  resume_deferring_access_checks ();
+
+  /* Parse the declarator.  */
+  declarator 
+    = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
+			    &ctor_dtor_or_conv_p,
+			    /*parenthesized_p=*/NULL);
+  /* Gather up the deferred checks.  */
+  stop_deferring_access_checks ();
+
+  /* If the DECLARATOR was erroneous, there's no need to go
+     further.  */
+  if (declarator == error_mark_node)
+    return error_mark_node;
+
+  cp_parser_check_for_definition_in_return_type (declarator,
+						 declares_class_or_enum);
+
+  /* Figure out what scope the entity declared by the DECLARATOR is
+     located in.  `grokdeclarator' sometimes changes the scope, so
+     we compute it now.  */
+  scope = get_scope_of_declarator (declarator);
+
+  /* If we're allowing GNU extensions, look for an asm-specification
+     and attributes.  */
+  if (cp_parser_allow_gnu_extensions_p (parser))
+    {
+      /* Look for an asm-specification.  */
+      asm_specification = cp_parser_asm_specification_opt (parser);
+      /* And attributes.  */
+      attributes = cp_parser_attributes_opt (parser);
+    }
+  else
+    {
+      asm_specification = NULL_TREE;
+      attributes = NULL_TREE;
+    }
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* Check to see if the token indicates the start of a
+     function-definition.  */
+  if (cp_parser_token_starts_function_definition_p (token))
+    {
+      if (!function_definition_allowed_p)
+	{
+	  /* If a function-definition should not appear here, issue an
+	     error message.  */
+	  cp_parser_error (parser,
+			   "a function-definition is not allowed here");
+	  return error_mark_node;
+	}
+      else
+	{
+	  /* Neither attributes nor an asm-specification are allowed
+	     on a function-definition.  */
+	  if (asm_specification)
+	    error ("an asm-specification is not allowed on a function-definition");
+	  if (attributes)
+	    error ("attributes are not allowed on a function-definition");
+	  /* This is a function-definition.  */
+	  *function_definition_p = true;
+
+	  /* Parse the function definition.  */
+	  if (member_p)
+	    decl = cp_parser_save_member_function_body (parser,
+							decl_specifiers,
+							declarator,
+							prefix_attributes);
+	  else
+	    decl 
+	      = (cp_parser_function_definition_from_specifiers_and_declarator
+		 (parser, decl_specifiers, prefix_attributes, declarator));
+
+	  return decl;
+	}
+    }
+
+  /* [dcl.dcl]
+
+     Only in function declarations for constructors, destructors, and
+     type conversions can the decl-specifier-seq be omitted.  
+
+     We explicitly postpone this check past the point where we handle
+     function-definitions because we tolerate function-definitions
+     that are missing their return types in some modes.  */
+  if (!decl_specifiers && ctor_dtor_or_conv_p <= 0)
+    {
+      cp_parser_error (parser, 
+		       "expected constructor, destructor, or type conversion");
+      return error_mark_node;
+    }
+
+  /* An `=' or an `(' indicates an initializer.  */
+  is_initialized = (token->type == CPP_EQ 
+		     || token->type == CPP_OPEN_PAREN);
+  /* If the init-declarator isn't initialized and isn't followed by a
+     `,' or `;', it's not a valid init-declarator.  */
+  if (!is_initialized 
+      && token->type != CPP_COMMA
+      && token->type != CPP_SEMICOLON)
+    {
+      cp_parser_error (parser, "expected init-declarator");
+      return error_mark_node;
+    }
+
+  /* Because start_decl has side-effects, we should only call it if we
+     know we're going ahead.  By this point, we know that we cannot
+     possibly be looking at any other construct.  */
+  cp_parser_commit_to_tentative_parse (parser);
+
+  /* If the decl specifiers were bad, issue an error now that we're
+     sure this was intended to be a declarator.  Then continue
+     declaring the variable(s), as int, to try to cut down on further
+     errors.  */
+  if (decl_specifiers != NULL
+      && TREE_VALUE (decl_specifiers) == error_mark_node)
+    {
+      cp_parser_error (parser, "invalid type in declaration");
+      TREE_VALUE (decl_specifiers) = integer_type_node;
+    }
+
+  /* Check to see whether or not this declaration is a friend.  */
+  friend_p = cp_parser_friend_p (decl_specifiers);
+
+  /* Check that the number of template-parameter-lists is OK.  */
+  if (!cp_parser_check_declarator_template_parameters (parser, declarator))
+    return error_mark_node;
+
+  /* Enter the newly declared entry in the symbol table.  If we're
+     processing a declaration in a class-specifier, we wait until
+     after processing the initializer.  */
+  if (!member_p)
+    {
+      if (parser->in_unbraced_linkage_specification_p)
+	{
+	  decl_specifiers = tree_cons (error_mark_node,
+				       get_identifier ("extern"),
+				       decl_specifiers);
+	  have_extern_spec = false;
+	}
+      decl = start_decl (declarator, decl_specifiers,
+			 is_initialized, attributes, prefix_attributes);
+    }
+
+  /* Enter the SCOPE.  That way unqualified names appearing in the
+     initializer will be looked up in SCOPE.  */
+  if (scope)
+    pop_p = push_scope (scope);
+
+  /* Perform deferred access control checks, now that we know in which
+     SCOPE the declared entity resides.  */
+  if (!member_p && decl) 
+    {
+      tree saved_current_function_decl = NULL_TREE;
+
+      /* If the entity being declared is a function, pretend that we
+	 are in its scope.  If it is a `friend', it may have access to
+	 things that would not otherwise be accessible.  */
+      if (TREE_CODE (decl) == FUNCTION_DECL)
+	{
+	  saved_current_function_decl = current_function_decl;
+	  current_function_decl = decl;
+	}
+	
+      /* Perform the access control checks for the declarator and the
+	 the decl-specifiers.  */
+      perform_deferred_access_checks ();
+
+      /* Restore the saved value.  */
+      if (TREE_CODE (decl) == FUNCTION_DECL)
+	current_function_decl = saved_current_function_decl;
+    }
+
+  /* Parse the initializer.  */
+  if (is_initialized)
+    initializer = cp_parser_initializer (parser, 
+					 &is_parenthesized_init,
+					 &is_non_constant_init);
+  else
+    {
+      initializer = NULL_TREE;
+      is_parenthesized_init = false;
+      is_non_constant_init = true;
+    }
+
+  /* The old parser allows attributes to appear after a parenthesized
+     initializer.  Mark Mitchell proposed removing this functionality
+     on the GCC mailing lists on 2002-08-13.  This parser accepts the
+     attributes -- but ignores them.  */
+  if (cp_parser_allow_gnu_extensions_p (parser) && is_parenthesized_init)
+    if (cp_parser_attributes_opt (parser))
+      warning ("attributes after parenthesized initializer ignored");
+
+  /* Leave the SCOPE, now that we have processed the initializer.  It
+     is important to do this before calling cp_finish_decl because it
+     makes decisions about whether to create DECL_STMTs or not based
+     on the current scope.  */
+  if (pop_p)
+    pop_scope (scope);
+
+  /* For an in-class declaration, use `grokfield' to create the
+     declaration.  */
+  if (member_p)
+    {
+      decl = grokfield (declarator, decl_specifiers,
+			initializer, /*asmspec=*/NULL_TREE,
+			/*attributes=*/NULL_TREE);
+      if (decl && TREE_CODE (decl) == FUNCTION_DECL)
+	cp_parser_save_default_args (parser, decl);
+    }
+  
+  /* Finish processing the declaration.  But, skip friend
+     declarations.  */
+  if (!friend_p && decl)
+    cp_finish_decl (decl, 
+		    initializer, 
+		    asm_specification,
+		    /* If the initializer is in parentheses, then this is
+		       a direct-initialization, which means that an
+		       `explicit' constructor is OK.  Otherwise, an
+		       `explicit' constructor cannot be used.  */
+		    ((is_parenthesized_init || !is_initialized)
+		     ? 0 : LOOKUP_ONLYCONVERTING));
+
+  /* Remember whether or not variables were initialized by
+     constant-expressions.  */
+  if (decl && TREE_CODE (decl) == VAR_DECL 
+      && is_initialized && !is_non_constant_init)
+    DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
+
+  return decl;
+}
+
+/* Parse a declarator.
+   
+   declarator:
+     direct-declarator
+     ptr-operator declarator  
+
+   abstract-declarator:
+     ptr-operator abstract-declarator [opt]
+     direct-abstract-declarator
+
+   GNU Extensions:
+
+   declarator:
+     attributes [opt] direct-declarator
+     attributes [opt] ptr-operator declarator  
+
+   abstract-declarator:
+     attributes [opt] ptr-operator abstract-declarator [opt]
+     attributes [opt] direct-abstract-declarator
+     
+   Returns a representation of the declarator.  If the declarator has
+   the form `* declarator', then an INDIRECT_REF is returned, whose
+   only operand is the sub-declarator.  Analogously, `& declarator' is
+   represented as an ADDR_EXPR.  For `X::* declarator', a SCOPE_REF is
+   used.  The first operand is the TYPE for `X'.  The second operand
+   is an INDIRECT_REF whose operand is the sub-declarator.
+
+   Otherwise, the representation is as for a direct-declarator.
+
+   (It would be better to define a structure type to represent
+   declarators, rather than abusing `tree' nodes to represent
+   declarators.  That would be much clearer and save some memory.
+   There is no reason for declarators to be garbage-collected, for
+   example; they are created during parser and no longer needed after
+   `grokdeclarator' has been called.)
+
+   For a ptr-operator that has the optional cv-qualifier-seq,
+   cv-qualifiers will be stored in the TREE_TYPE of the INDIRECT_REF
+   node.
+
+   If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
+   detect constructor, destructor or conversion operators. It is set
+   to -1 if the declarator is a name, and +1 if it is a
+   function. Otherwise it is set to zero. Usually you just want to
+   test for >0, but internally the negative value is used.
+   
+   (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
+   a decl-specifier-seq unless it declares a constructor, destructor,
+   or conversion.  It might seem that we could check this condition in
+   semantic analysis, rather than parsing, but that makes it difficult
+   to handle something like `f()'.  We want to notice that there are
+   no decl-specifiers, and therefore realize that this is an
+   expression, not a declaration.)  
+ 
+   If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
+   the declarator is a direct-declarator of the form "(...)".  */
+
+static tree
+cp_parser_declarator (cp_parser* parser, 
+                      cp_parser_declarator_kind dcl_kind, 
+                      int* ctor_dtor_or_conv_p,
+		      bool* parenthesized_p)
+{
+  cp_token *token;
+  tree declarator;
+  enum tree_code code;
+  tree cv_qualifier_seq;
+  tree class_type;
+  tree attributes = NULL_TREE;
+
+  /* Assume this is not a constructor, destructor, or type-conversion
+     operator.  */
+  if (ctor_dtor_or_conv_p)
+    *ctor_dtor_or_conv_p = 0;
+
+  if (cp_parser_allow_gnu_extensions_p (parser))
+    attributes = cp_parser_attributes_opt (parser);
+  
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  
+  /* Check for the ptr-operator production.  */
+  cp_parser_parse_tentatively (parser);
+  /* Parse the ptr-operator.  */
+  code = cp_parser_ptr_operator (parser, 
+				 &class_type, 
+				 &cv_qualifier_seq);
+  /* If that worked, then we have a ptr-operator.  */
+  if (cp_parser_parse_definitely (parser))
+    {
+      /* If a ptr-operator was found, then this declarator was not
+	 parenthesized.  */
+      if (parenthesized_p)
+	*parenthesized_p = true;
+      /* The dependent declarator is optional if we are parsing an
+	 abstract-declarator.  */
+      if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
+	cp_parser_parse_tentatively (parser);
+
+      /* Parse the dependent declarator.  */
+      declarator = cp_parser_declarator (parser, dcl_kind,
+					 /*ctor_dtor_or_conv_p=*/NULL,
+					 /*parenthesized_p=*/NULL);
+
+      /* If we are parsing an abstract-declarator, we must handle the
+	 case where the dependent declarator is absent.  */
+      if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
+	  && !cp_parser_parse_definitely (parser))
+	declarator = NULL_TREE;
+	
+      /* Build the representation of the ptr-operator.  */
+      if (code == INDIRECT_REF)
+	declarator = make_pointer_declarator (cv_qualifier_seq, 
+					      declarator);
+      else
+	declarator = make_reference_declarator (cv_qualifier_seq,
+						declarator);
+      /* Handle the pointer-to-member case.  */
+      if (class_type)
+	declarator = build_nt (SCOPE_REF, class_type, declarator);
+    }
+  /* Everything else is a direct-declarator.  */
+  else
+    {
+      if (parenthesized_p)
+	*parenthesized_p = cp_lexer_next_token_is (parser->lexer,
+						   CPP_OPEN_PAREN);
+      declarator = cp_parser_direct_declarator (parser, dcl_kind,
+						ctor_dtor_or_conv_p);
+    }
+
+  if (attributes && declarator != error_mark_node)
+    declarator = tree_cons (attributes, declarator, NULL_TREE);
+  
+  return declarator;
+}
+
+/* Parse a direct-declarator or direct-abstract-declarator.
+
+   direct-declarator:
+     declarator-id
+     direct-declarator ( parameter-declaration-clause )
+       cv-qualifier-seq [opt] 
+       exception-specification [opt]
+     direct-declarator [ constant-expression [opt] ]
+     ( declarator )  
+
+   direct-abstract-declarator:
+     direct-abstract-declarator [opt]
+       ( parameter-declaration-clause ) 
+       cv-qualifier-seq [opt]
+       exception-specification [opt]
+     direct-abstract-declarator [opt] [ constant-expression [opt] ]
+     ( abstract-declarator )
+
+   Returns a representation of the declarator.  DCL_KIND is
+   CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
+   direct-abstract-declarator.  It is CP_PARSER_DECLARATOR_NAMED, if
+   we are parsing a direct-declarator.  It is
+   CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
+   of ambiguity we prefer an abstract declarator, as per
+   [dcl.ambig.res].  CTOR_DTOR_OR_CONV_P is as for
+   cp_parser_declarator.
+
+   For the declarator-id production, the representation is as for an
+   id-expression, except that a qualified name is represented as a
+   SCOPE_REF.  A function-declarator is represented as a CALL_EXPR;
+   see the documentation of the FUNCTION_DECLARATOR_* macros for
+   information about how to find the various declarator components.
+   An array-declarator is represented as an ARRAY_REF.  The
+   direct-declarator is the first operand; the constant-expression
+   indicating the size of the array is the second operand.  */
+
+static tree
+cp_parser_direct_declarator (cp_parser* parser,
+                             cp_parser_declarator_kind dcl_kind,
+                             int* ctor_dtor_or_conv_p)
+{
+  cp_token *token;
+  tree declarator = NULL_TREE;
+  tree scope = NULL_TREE;
+  bool saved_default_arg_ok_p = parser->default_arg_ok_p;
+  bool saved_in_declarator_p = parser->in_declarator_p;
+  bool first = true;
+  bool pop_p = false;
+
+  while (true)
+    {
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      if (token->type == CPP_OPEN_PAREN)
+	{
+	  /* This is either a parameter-declaration-clause, or a
+  	     parenthesized declarator. When we know we are parsing a
+  	     named declarator, it must be a parenthesized declarator
+  	     if FIRST is true. For instance, `(int)' is a
+  	     parameter-declaration-clause, with an omitted
+  	     direct-abstract-declarator. But `((*))', is a
+  	     parenthesized abstract declarator. Finally, when T is a
+  	     template parameter `(T)' is a
+  	     parameter-declaration-clause, and not a parenthesized
+  	     named declarator.
+	     
+	     We first try and parse a parameter-declaration-clause,
+	     and then try a nested declarator (if FIRST is true).
+
+	     It is not an error for it not to be a
+	     parameter-declaration-clause, even when FIRST is
+	     false. Consider,
+
+	       int i (int);
+	       int i (3);
+
+	     The first is the declaration of a function while the
+	     second is a the definition of a variable, including its
+	     initializer.
+
+	     Having seen only the parenthesis, we cannot know which of
+	     these two alternatives should be selected.  Even more
+	     complex are examples like:
+
+               int i (int (a));
+	       int i (int (3));
+
+	     The former is a function-declaration; the latter is a
+	     variable initialization.  
+
+	     Thus again, we try a parameter-declaration-clause, and if
+	     that fails, we back out and return.  */
+
+	  if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
+	    {
+	      tree params;
+	      unsigned saved_num_template_parameter_lists;
+	      
+	      cp_parser_parse_tentatively (parser);
+
+	      /* Consume the `('.  */
+	      cp_lexer_consume_token (parser->lexer);
+	      if (first)
+		{
+		  /* If this is going to be an abstract declarator, we're
+		     in a declarator and we can't have default args.  */
+		  parser->default_arg_ok_p = false;
+		  parser->in_declarator_p = true;
+		}
+	  
+	      /* Inside the function parameter list, surrounding
+		 template-parameter-lists do not apply.  */
+	      saved_num_template_parameter_lists
+		= parser->num_template_parameter_lists;
+	      parser->num_template_parameter_lists = 0;
+
+	      /* Parse the parameter-declaration-clause.  */
+	      params = cp_parser_parameter_declaration_clause (parser);
+
+	      parser->num_template_parameter_lists
+		= saved_num_template_parameter_lists;
+
+	      /* If all went well, parse the cv-qualifier-seq and the
+	     	 exception-specification.  */
+	      if (cp_parser_parse_definitely (parser))
+		{
+		  tree cv_qualifiers;
+		  tree exception_specification;
+
+		  if (ctor_dtor_or_conv_p)
+		    *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
+		  first = false;
+		  /* Consume the `)'.  */
+		  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+
+		  /* Parse the cv-qualifier-seq.  */
+		  cv_qualifiers = cp_parser_cv_qualifier_seq_opt (parser);
+		  /* And the exception-specification.  */
+		  exception_specification 
+		    = cp_parser_exception_specification_opt (parser);
+
+		  /* Create the function-declarator.  */
+		  declarator = make_call_declarator (declarator,
+						     params,
+						     cv_qualifiers,
+						     exception_specification);
+		  /* Any subsequent parameter lists are to do with
+	 	     return type, so are not those of the declared
+	 	     function.  */
+		  parser->default_arg_ok_p = false;
+		  
+		  /* Repeat the main loop.  */
+		  continue;
+		}
+	    }
+	  
+	  /* If this is the first, we can try a parenthesized
+	     declarator.  */
+	  if (first)
+	    {
+	      bool saved_in_type_id_in_expr_p;
+
+	      parser->default_arg_ok_p = saved_default_arg_ok_p;
+	      parser->in_declarator_p = saved_in_declarator_p;
+	      
+	      /* Consume the `('.  */
+	      cp_lexer_consume_token (parser->lexer);
+	      /* Parse the nested declarator.  */
+	      saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
+	      parser->in_type_id_in_expr_p = true;
+	      declarator 
+		= cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
+					/*parenthesized_p=*/NULL);
+	      parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
+	      first = false;
+	      /* Expect a `)'.  */
+	      if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
+		declarator = error_mark_node;
+	      if (declarator == error_mark_node)
+		break;
+	      
+	      goto handle_declarator;
+	    }
+	  /* Otherwise, we must be done.  */
+	  else
+	    break;
+	}
+      else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
+	       && token->type == CPP_OPEN_SQUARE)
+	{
+	  /* Parse an array-declarator.  */
+	  tree bounds;
+
+	  if (ctor_dtor_or_conv_p)
+	    *ctor_dtor_or_conv_p = 0;
+	  
+	  first = false;
+	  parser->default_arg_ok_p = false;
+	  parser->in_declarator_p = true;
+	  /* Consume the `['.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  /* Peek at the next token.  */
+	  token = cp_lexer_peek_token (parser->lexer);
+	  /* If the next token is `]', then there is no
+	     constant-expression.  */
+	  if (token->type != CPP_CLOSE_SQUARE)
+	    {
+	      bool non_constant_p;
+
+	      bounds 
+		= cp_parser_constant_expression (parser,
+						 /*allow_non_constant=*/true,
+						 &non_constant_p);
+	      if (!non_constant_p)
+		bounds = fold_non_dependent_expr (bounds);
+	    }
+	  else
+	    bounds = NULL_TREE;
+	  /* Look for the closing `]'.  */
+	  if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"))
+	    {
+	      declarator = error_mark_node;
+	      break;
+	    }
+
+	  declarator = build_nt (ARRAY_REF, declarator, bounds);
+	}
+      else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
+	{
+	  /* Parse a declarator-id */
+	  if (dcl_kind == CP_PARSER_DECLARATOR_EITHER)
+	    cp_parser_parse_tentatively (parser);
+	  declarator = cp_parser_declarator_id (parser);
+	  if (dcl_kind == CP_PARSER_DECLARATOR_EITHER)
+	    {
+	      if (!cp_parser_parse_definitely (parser))
+		declarator = error_mark_node;
+	      else if (TREE_CODE (declarator) != IDENTIFIER_NODE)
+		{
+		  cp_parser_error (parser, "expected unqualified-id");
+		  declarator = error_mark_node;
+		}
+	    }
+	  
+	  if (declarator == error_mark_node)
+	    break;
+	  
+	  if (TREE_CODE (declarator) == SCOPE_REF
+	      && !current_scope ())
+	    {
+	      tree scope = TREE_OPERAND (declarator, 0);
+
+	      /* In the declaration of a member of a template class
+	     	 outside of the class itself, the SCOPE will sometimes
+	     	 be a TYPENAME_TYPE.  For example, given:
+	     	  
+               	 template <typename T>
+	       	 int S<T>::R::i = 3;
+		  
+             	 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'.  In
+             	 this context, we must resolve S<T>::R to an ordinary
+             	 type, rather than a typename type.
+		  
+	     	 The reason we normally avoid resolving TYPENAME_TYPEs
+	     	 is that a specialization of `S' might render
+	     	 `S<T>::R' not a type.  However, if `S' is
+	     	 specialized, then this `i' will not be used, so there
+	     	 is no harm in resolving the types here.  */
+	      if (TREE_CODE (scope) == TYPENAME_TYPE)
+		{
+		  tree type;
+
+		  /* Resolve the TYPENAME_TYPE.  */
+		  type = resolve_typename_type (scope,
+						/*only_current_p=*/false);
+		  /* If that failed, the declarator is invalid.  */
+		  if (type == error_mark_node)
+		    error ("`%T::%D' is not a type",
+			   TYPE_CONTEXT (scope),
+			   TYPE_IDENTIFIER (scope));
+		  /* Build a new DECLARATOR.  */
+		  declarator = build_nt (SCOPE_REF, 
+					 type,
+					 TREE_OPERAND (declarator, 1));
+		}
+	    }
+      
+	  /* Check to see whether the declarator-id names a constructor, 
+	     destructor, or conversion.  */
+	  if (declarator && ctor_dtor_or_conv_p 
+	      && ((TREE_CODE (declarator) == SCOPE_REF 
+		   && CLASS_TYPE_P (TREE_OPERAND (declarator, 0)))
+		  || (TREE_CODE (declarator) != SCOPE_REF
+		      && at_class_scope_p ())))
+	    {
+	      tree unqualified_name;
+	      tree class_type;
+
+	      /* Get the unqualified part of the name.  */
+	      if (TREE_CODE (declarator) == SCOPE_REF)
+		{
+		  class_type = TREE_OPERAND (declarator, 0);
+		  unqualified_name = TREE_OPERAND (declarator, 1);
+		}
+	      else
+		{
+		  class_type = current_class_type;
+		  unqualified_name = declarator;
+		}
+
+	      /* See if it names ctor, dtor or conv.  */
+	      if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR
+		  || IDENTIFIER_TYPENAME_P (unqualified_name)
+		  || constructor_name_p (unqualified_name, class_type)
+		  || (TREE_CODE (unqualified_name) == TYPE_DECL
+		      && same_type_p (TREE_TYPE (unqualified_name),
+				      class_type)))
+		*ctor_dtor_or_conv_p = -1;
+	    }
+
+	handle_declarator:;
+	  scope = get_scope_of_declarator (declarator);
+	  if (scope)
+	    /* Any names that appear after the declarator-id for a
+	       member are looked up in the containing scope.  */
+	    pop_p = push_scope (scope);
+	  parser->in_declarator_p = true;
+	  if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
+	      || (declarator
+		  && (TREE_CODE (declarator) == SCOPE_REF
+		      || TREE_CODE (declarator) == IDENTIFIER_NODE)))
+	    /* Default args are only allowed on function
+	       declarations.  */
+	    parser->default_arg_ok_p = saved_default_arg_ok_p;
+	  else
+	    parser->default_arg_ok_p = false;
+
+	  first = false;
+	}
+      /* We're done.  */
+      else
+	break;
+    }
+
+  /* For an abstract declarator, we might wind up with nothing at this
+     point.  That's an error; the declarator is not optional.  */
+  if (!declarator)
+    cp_parser_error (parser, "expected declarator");
+
+  /* If we entered a scope, we must exit it now.  */
+  if (pop_p)
+    pop_scope (scope);
+
+  parser->default_arg_ok_p = saved_default_arg_ok_p;
+  parser->in_declarator_p = saved_in_declarator_p;
+  
+  return declarator;
+}
+
+/* Parse a ptr-operator.  
+
+   ptr-operator:
+     * cv-qualifier-seq [opt]
+     &
+     :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
+
+   GNU Extension:
+
+   ptr-operator:
+     & cv-qualifier-seq [opt]
+
+   Returns INDIRECT_REF if a pointer, or pointer-to-member, was
+   used.  Returns ADDR_EXPR if a reference was used.  In the
+   case of a pointer-to-member, *TYPE is filled in with the 
+   TYPE containing the member.  *CV_QUALIFIER_SEQ is filled in
+   with the cv-qualifier-seq, or NULL_TREE, if there are no
+   cv-qualifiers.  Returns ERROR_MARK if an error occurred.  */
+   
+static enum tree_code
+cp_parser_ptr_operator (cp_parser* parser, 
+                        tree* type, 
+                        tree* cv_qualifier_seq)
+{
+  enum tree_code code = ERROR_MARK;
+  cp_token *token;
+
+  /* Assume that it's not a pointer-to-member.  */
+  *type = NULL_TREE;
+  /* And that there are no cv-qualifiers.  */
+  *cv_qualifier_seq = NULL_TREE;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If it's a `*' or `&' we have a pointer or reference.  */
+  if (token->type == CPP_MULT || token->type == CPP_AND)
+    {
+      /* Remember which ptr-operator we were processing.  */
+      code = (token->type == CPP_AND ? ADDR_EXPR : INDIRECT_REF);
+
+      /* Consume the `*' or `&'.  */
+      cp_lexer_consume_token (parser->lexer);
+
+      /* A `*' can be followed by a cv-qualifier-seq, and so can a
+	 `&', if we are allowing GNU extensions.  (The only qualifier
+	 that can legally appear after `&' is `restrict', but that is
+	 enforced during semantic analysis.  */
+      if (code == INDIRECT_REF 
+	  || cp_parser_allow_gnu_extensions_p (parser))
+	*cv_qualifier_seq = cp_parser_cv_qualifier_seq_opt (parser);
+    }
+  else
+    {
+      /* Try the pointer-to-member case.  */
+      cp_parser_parse_tentatively (parser);
+      /* Look for the optional `::' operator.  */
+      cp_parser_global_scope_opt (parser,
+				  /*current_scope_valid_p=*/false);
+      /* Look for the nested-name specifier.  */
+      cp_parser_nested_name_specifier (parser,
+				       /*typename_keyword_p=*/false,
+				       /*check_dependency_p=*/true,
+				       /*type_p=*/false,
+				       /*is_declaration=*/false);
+      /* If we found it, and the next token is a `*', then we are
+	 indeed looking at a pointer-to-member operator.  */
+      if (!cp_parser_error_occurred (parser)
+	  && cp_parser_require (parser, CPP_MULT, "`*'"))
+	{
+	  /* The type of which the member is a member is given by the
+	     current SCOPE.  */
+	  *type = parser->scope;
+	  /* The next name will not be qualified.  */
+	  parser->scope = NULL_TREE;
+	  parser->qualifying_scope = NULL_TREE;
+	  parser->object_scope = NULL_TREE;
+	  /* Indicate that the `*' operator was used.  */
+	  code = INDIRECT_REF;
+	  /* Look for the optional cv-qualifier-seq.  */
+	  *cv_qualifier_seq = cp_parser_cv_qualifier_seq_opt (parser);
+	}
+      /* If that didn't work we don't have a ptr-operator.  */
+      if (!cp_parser_parse_definitely (parser))
+	cp_parser_error (parser, "expected ptr-operator");
+    }
+
+  return code;
+}
+
+/* Parse an (optional) cv-qualifier-seq.
+
+   cv-qualifier-seq:
+     cv-qualifier cv-qualifier-seq [opt]  
+
+   Returns a TREE_LIST.  The TREE_VALUE of each node is the
+   representation of a cv-qualifier.  */
+
+static tree
+cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
+{
+  tree cv_qualifiers = NULL_TREE;
+  
+  while (true)
+    {
+      tree cv_qualifier;
+
+      /* Look for the next cv-qualifier.  */
+      cv_qualifier = cp_parser_cv_qualifier_opt (parser);
+      /* If we didn't find one, we're done.  */
+      if (!cv_qualifier)
+	break;
+
+      /* Add this cv-qualifier to the list.  */
+      cv_qualifiers 
+	= tree_cons (NULL_TREE, cv_qualifier, cv_qualifiers);
+    }
+
+  /* We built up the list in reverse order.  */
+  return nreverse (cv_qualifiers);
+}
+
+/* Parse an (optional) cv-qualifier.
+
+   cv-qualifier:
+     const
+     volatile  
+
+   GNU Extension:
+
+   cv-qualifier:
+     __restrict__ */
+
+static tree
+cp_parser_cv_qualifier_opt (cp_parser* parser)
+{
+  cp_token *token;
+  tree cv_qualifier = NULL_TREE;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* See if it's a cv-qualifier.  */
+  switch (token->keyword)
+    {
+    case RID_CONST:
+    case RID_VOLATILE:
+    case RID_RESTRICT:
+      /* Save the value of the token.  */
+      cv_qualifier = token->value;
+      /* Consume the token.  */
+      cp_lexer_consume_token (parser->lexer);
+      break;
+
+    default:
+      break;
+    }
+
+  return cv_qualifier;
+}
+
+/* Parse a declarator-id.
+
+   declarator-id:
+     id-expression
+     :: [opt] nested-name-specifier [opt] type-name  
+
+   In the `id-expression' case, the value returned is as for
+   cp_parser_id_expression if the id-expression was an unqualified-id.
+   If the id-expression was a qualified-id, then a SCOPE_REF is
+   returned.  The first operand is the scope (either a NAMESPACE_DECL
+   or TREE_TYPE), but the second is still just a representation of an
+   unqualified-id.  */
+
+static tree
+cp_parser_declarator_id (cp_parser* parser)
+{
+  tree id_expression;
+
+  /* The expression must be an id-expression.  Assume that qualified
+     names are the names of types so that:
+
+       template <class T>
+       int S<T>::R::i = 3;
+
+     will work; we must treat `S<T>::R' as the name of a type.
+     Similarly, assume that qualified names are templates, where
+     required, so that:
+
+       template <class T>
+       int S<T>::R<T>::i = 3;
+
+     will work, too.  */
+  id_expression = cp_parser_id_expression (parser,
+					   /*template_keyword_p=*/false,
+					   /*check_dependency_p=*/false,
+					   /*template_p=*/NULL,
+					   /*declarator_p=*/true);
+  /* If the name was qualified, create a SCOPE_REF to represent 
+     that.  */
+  if (parser->scope)
+    {
+      id_expression = build_nt (SCOPE_REF, parser->scope, id_expression);
+      parser->scope = NULL_TREE;
+    }
+
+  return id_expression;
+}
+
+/* Parse a type-id.
+
+   type-id:
+     type-specifier-seq abstract-declarator [opt]
+
+   Returns the TYPE specified.  */
+
+static tree
+cp_parser_type_id (cp_parser* parser)
+{
+  tree type_specifier_seq;
+  tree abstract_declarator;
+
+  /* Parse the type-specifier-seq.  */
+  type_specifier_seq 
+    = cp_parser_type_specifier_seq (parser);
+  if (type_specifier_seq == error_mark_node)
+    return error_mark_node;
+
+  /* There might or might not be an abstract declarator.  */
+  cp_parser_parse_tentatively (parser);
+  /* Look for the declarator.  */
+  abstract_declarator 
+    = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
+			    /*parenthesized_p=*/NULL);
+  /* Check to see if there really was a declarator.  */
+  if (!cp_parser_parse_definitely (parser))
+    abstract_declarator = NULL_TREE;
+
+  return groktypename (build_tree_list (type_specifier_seq,
+					abstract_declarator));
+}
+
+/* Parse a type-specifier-seq.
+
+   type-specifier-seq:
+     type-specifier type-specifier-seq [opt]
+
+   GNU extension:
+
+   type-specifier-seq:
+     attributes type-specifier-seq [opt]
+
+   Returns a TREE_LIST.  Either the TREE_VALUE of each node is a
+   type-specifier, or the TREE_PURPOSE is a list of attributes.  */
+
+static tree
+cp_parser_type_specifier_seq (cp_parser* parser)
+{
+  bool seen_type_specifier = false;
+  tree type_specifier_seq = NULL_TREE;
+
+  /* Parse the type-specifiers and attributes.  */
+  while (true)
+    {
+      tree type_specifier;
+
+      /* Check for attributes first.  */
+      if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
+	{
+	  type_specifier_seq = tree_cons (cp_parser_attributes_opt (parser),
+					  NULL_TREE,
+					  type_specifier_seq);
+	  continue;
+	}
+
+      /* After the first type-specifier, others are optional.  */
+      if (seen_type_specifier)
+	cp_parser_parse_tentatively (parser);
+      /* Look for the type-specifier.  */
+      type_specifier = cp_parser_type_specifier (parser, 
+						 CP_PARSER_FLAGS_NONE,
+						 /*is_friend=*/false,
+						 /*is_declaration=*/false,
+						 NULL,
+						 NULL);
+      /* If the first type-specifier could not be found, this is not a
+	 type-specifier-seq at all.  */
+      if (!seen_type_specifier && type_specifier == error_mark_node)
+	return error_mark_node;
+      /* If subsequent type-specifiers could not be found, the
+	 type-specifier-seq is complete.  */
+      else if (seen_type_specifier && !cp_parser_parse_definitely (parser))
+	break;
+
+      /* Add the new type-specifier to the list.  */
+      type_specifier_seq 
+	= tree_cons (NULL_TREE, type_specifier, type_specifier_seq);
+      seen_type_specifier = true;
+    }
+
+  /* We built up the list in reverse order.  */
+  return nreverse (type_specifier_seq);
+}
+
+/* Parse a parameter-declaration-clause.
+
+   parameter-declaration-clause:
+     parameter-declaration-list [opt] ... [opt]
+     parameter-declaration-list , ...
+
+   Returns a representation for the parameter declarations.  Each node
+   is a TREE_LIST.  (See cp_parser_parameter_declaration for the exact
+   representation.)  If the parameter-declaration-clause ends with an
+   ellipsis, PARMLIST_ELLIPSIS_P will hold of the first node in the
+   list.  A return value of NULL_TREE indicates a
+   parameter-declaration-clause consisting only of an ellipsis.  */
+
+static tree
+cp_parser_parameter_declaration_clause (cp_parser* parser)
+{
+  tree parameters;
+  cp_token *token;
+  bool ellipsis_p;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* Check for trivial parameter-declaration-clauses.  */
+  if (token->type == CPP_ELLIPSIS)
+    {
+      /* Consume the `...' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      return NULL_TREE;
+    }
+  else if (token->type == CPP_CLOSE_PAREN)
+    /* There are no parameters.  */
+    {
+#ifndef NO_IMPLICIT_EXTERN_C
+      if (in_system_header && current_class_type == NULL
+	  && current_lang_name == lang_name_c)
+	return NULL_TREE;
+      else
+#endif
+	return void_list_node;
+    }
+  /* Check for `(void)', too, which is a special case.  */
+  else if (token->keyword == RID_VOID
+	   && (cp_lexer_peek_nth_token (parser->lexer, 2)->type 
+	       == CPP_CLOSE_PAREN))
+    {
+      /* Consume the `void' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* There are no parameters.  */
+      return void_list_node;
+    }
+  
+  /* Parse the parameter-declaration-list.  */
+  parameters = cp_parser_parameter_declaration_list (parser);
+  /* If a parse error occurred while parsing the
+     parameter-declaration-list, then the entire
+     parameter-declaration-clause is erroneous.  */
+  if (parameters == error_mark_node)
+    return error_mark_node;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If it's a `,', the clause should terminate with an ellipsis.  */
+  if (token->type == CPP_COMMA)
+    {
+      /* Consume the `,'.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Expect an ellipsis.  */
+      ellipsis_p 
+	= (cp_parser_require (parser, CPP_ELLIPSIS, "`...'") != NULL);
+    }
+  /* It might also be `...' if the optional trailing `,' was 
+     omitted.  */
+  else if (token->type == CPP_ELLIPSIS)
+    {
+      /* Consume the `...' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* And remember that we saw it.  */
+      ellipsis_p = true;
+    }
+  else
+    ellipsis_p = false;
+
+  /* Finish the parameter list.  */
+  return finish_parmlist (parameters, ellipsis_p);
+}
+
+/* Parse a parameter-declaration-list.
+
+   parameter-declaration-list:
+     parameter-declaration
+     parameter-declaration-list , parameter-declaration
+
+   Returns a representation of the parameter-declaration-list, as for
+   cp_parser_parameter_declaration_clause.  However, the
+   `void_list_node' is never appended to the list.  */
+
+static tree
+cp_parser_parameter_declaration_list (cp_parser* parser)
+{
+  tree parameters = NULL_TREE;
+
+  /* Look for more parameters.  */
+  while (true)
+    {
+      tree parameter;
+      bool parenthesized_p;
+      /* Parse the parameter.  */
+      parameter 
+	= cp_parser_parameter_declaration (parser, 
+					   /*template_parm_p=*/false,
+					   &parenthesized_p);
+
+      /* If a parse error occurred parsing the parameter declaration,
+	 then the entire parameter-declaration-list is erroneous.  */
+      if (parameter == error_mark_node)
+	{
+	  parameters = error_mark_node;
+	  break;
+	}
+      /* Add the new parameter to the list.  */
+      TREE_CHAIN (parameter) = parameters;
+      parameters = parameter;
+
+      /* Peek at the next token.  */
+      if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
+	  || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
+	/* The parameter-declaration-list is complete.  */
+	break;
+      else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
+	{
+	  cp_token *token;
+
+	  /* Peek at the next token.  */
+	  token = cp_lexer_peek_nth_token (parser->lexer, 2);
+	  /* If it's an ellipsis, then the list is complete.  */
+	  if (token->type == CPP_ELLIPSIS)
+	    break;
+	  /* Otherwise, there must be more parameters.  Consume the
+	     `,'.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  /* When parsing something like:
+
+	        int i(float f, double d)
+		
+             we can tell after seeing the declaration for "f" that we
+	     are not looking at an initialization of a variable "i",
+	     but rather at the declaration of a function "i".  
+
+	     Due to the fact that the parsing of template arguments
+	     (as specified to a template-id) requires backtracking we
+	     cannot use this technique when inside a template argument
+	     list.  */
+	  if (!parser->in_template_argument_list_p
+	      && !parser->in_type_id_in_expr_p
+	      && cp_parser_parsing_tentatively (parser)
+	      && !cp_parser_committed_to_tentative_parse (parser)
+	      /* However, a parameter-declaration of the form
+		 "foat(f)" (which is a valid declaration of a
+		 parameter "f") can also be interpreted as an
+		 expression (the conversion of "f" to "float").  */
+	      && !parenthesized_p)
+	    cp_parser_commit_to_tentative_parse (parser);
+	}
+      else
+	{
+	  cp_parser_error (parser, "expected `,' or `...'");
+	  if (!cp_parser_parsing_tentatively (parser)
+	      || cp_parser_committed_to_tentative_parse (parser))
+	    cp_parser_skip_to_closing_parenthesis (parser, 
+						   /*recovering=*/true,
+						   /*or_comma=*/false,
+						   /*consume_paren=*/false);
+	  break;
+	}
+    }
+
+  /* We built up the list in reverse order; straighten it out now.  */
+  return nreverse (parameters);
+}
+
+/* Parse a parameter declaration.
+
+   parameter-declaration:
+     decl-specifier-seq declarator
+     decl-specifier-seq declarator = assignment-expression
+     decl-specifier-seq abstract-declarator [opt]
+     decl-specifier-seq abstract-declarator [opt] = assignment-expression
+
+   If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
+   declares a template parameter.  (In that case, a non-nested `>'
+   token encountered during the parsing of the assignment-expression
+   is not interpreted as a greater-than operator.)
+
+   Returns a TREE_LIST representing the parameter-declaration.  The
+   TREE_PURPOSE is the default argument expression, or NULL_TREE if
+   there is no default argument.  The TREE_VALUE is a representation
+   of the decl-specifier-seq and declarator.  In particular, the
+   TREE_VALUE will be a TREE_LIST whose TREE_PURPOSE represents the
+   decl-specifier-seq and whose TREE_VALUE represents the declarator.
+   If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
+   the declarator is of the form "(p)".  */
+
+static tree
+cp_parser_parameter_declaration (cp_parser *parser, 
+				 bool template_parm_p,
+				 bool *parenthesized_p)
+{
+  int declares_class_or_enum;
+  bool greater_than_is_operator_p;
+  tree decl_specifiers;
+  tree attributes;
+  tree declarator;
+  tree default_argument;
+  tree parameter;
+  cp_token *token;
+  const char *saved_message;
+
+  /* In a template parameter, `>' is not an operator.
+
+     [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.  */
+  greater_than_is_operator_p = !template_parm_p;
+
+  /* Type definitions may not appear in parameter types.  */
+  saved_message = parser->type_definition_forbidden_message;
+  parser->type_definition_forbidden_message 
+    = "types may not be defined in parameter types";
+
+  /* Parse the declaration-specifiers.  */
+  decl_specifiers 
+    = cp_parser_decl_specifier_seq (parser,
+				    CP_PARSER_FLAGS_NONE,
+				    &attributes,
+				    &declares_class_or_enum);
+  /* If an error occurred, there's no reason to attempt to parse the
+     rest of the declaration.  */
+  if (cp_parser_error_occurred (parser))
+    {
+      parser->type_definition_forbidden_message = saved_message;
+      return error_mark_node;
+    }
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If the next token is a `)', `,', `=', `>', or `...', then there
+     is no declarator.  */
+  if (token->type == CPP_CLOSE_PAREN 
+      || token->type == CPP_COMMA
+      || token->type == CPP_EQ
+      || token->type == CPP_ELLIPSIS
+      || token->type == CPP_GREATER)
+    {
+      declarator = NULL_TREE;
+      if (parenthesized_p)
+	*parenthesized_p = false;
+    }
+  /* Otherwise, there should be a declarator.  */
+  else
+    {
+      bool saved_default_arg_ok_p = parser->default_arg_ok_p;
+      parser->default_arg_ok_p = false;
+  
+      /* After seeing a decl-specifier-seq, if the next token is not a
+	 "(", there is no possibility that the code is a valid
+	 expression.  Therefore, if parsing tentatively, we commit at
+	 this point.  */
+      if (!parser->in_template_argument_list_p
+	  /* In an expression context, having seen:
+
+	       (int((char ...
+
+	     we cannot be sure whether we are looking at a
+	     function-type (taking a "char" as a parameter) or a cast
+	     of some object of type "char" to "int".  */
+	  && !parser->in_type_id_in_expr_p
+	  && cp_parser_parsing_tentatively (parser)
+	  && !cp_parser_committed_to_tentative_parse (parser)
+	  && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
+	cp_parser_commit_to_tentative_parse (parser);
+      /* Parse the declarator.  */
+      declarator = cp_parser_declarator (parser,
+					 CP_PARSER_DECLARATOR_EITHER,
+					 /*ctor_dtor_or_conv_p=*/NULL,
+					 parenthesized_p);
+      parser->default_arg_ok_p = saved_default_arg_ok_p;
+      /* After the declarator, allow more attributes.  */
+      attributes = chainon (attributes, cp_parser_attributes_opt (parser));
+    }
+
+  /* The restriction on defining new types applies only to the type
+     of the parameter, not to the default argument.  */
+  parser->type_definition_forbidden_message = saved_message;
+
+  /* If the next token is `=', then process a default argument.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
+    {
+      bool saved_greater_than_is_operator_p;
+      /* Consume the `='.  */
+      cp_lexer_consume_token (parser->lexer);
+
+      /* If we are defining a class, then the tokens that make up the
+	 default argument must be saved and processed later.  */
+      if (!template_parm_p && at_class_scope_p () 
+	  && TYPE_BEING_DEFINED (current_class_type))
+	{
+	  unsigned depth = 0;
+
+	  /* Create a DEFAULT_ARG to represented the unparsed default
+             argument.  */
+	  default_argument = make_node (DEFAULT_ARG);
+	  DEFARG_TOKENS (default_argument) = cp_token_cache_new ();
+
+	  /* Add tokens until we have processed the entire default
+	     argument.  */
+	  while (true)
+	    {
+	      bool done = false;
+	      cp_token *token;
+
+	      /* Peek at the next token.  */
+	      token = cp_lexer_peek_token (parser->lexer);
+	      /* What we do depends on what token we have.  */
+	      switch (token->type)
+		{
+		  /* In valid code, a default argument must be
+		     immediately followed by a `,' `)', or `...'.  */
+		case CPP_COMMA:
+		case CPP_CLOSE_PAREN:
+		case CPP_ELLIPSIS:
+		  /* If we run into a non-nested `;', `}', or `]',
+		     then the code is invalid -- but the default
+		     argument is certainly over.  */
+		case CPP_SEMICOLON:
+		case CPP_CLOSE_BRACE:
+		case CPP_CLOSE_SQUARE:
+		  if (depth == 0)
+		    done = true;
+		  /* Update DEPTH, if necessary.  */
+		  else if (token->type == CPP_CLOSE_PAREN
+			   || token->type == CPP_CLOSE_BRACE
+			   || token->type == CPP_CLOSE_SQUARE)
+		    --depth;
+		  break;
+
+		case CPP_OPEN_PAREN:
+		case CPP_OPEN_SQUARE:
+		case CPP_OPEN_BRACE:
+		  ++depth;
+		  break;
+
+		case CPP_GREATER:
+		  /* If we see a non-nested `>', and `>' is not an
+		     operator, then it marks the end of the default
+		     argument.  */
+		  if (!depth && !greater_than_is_operator_p)
+		    done = true;
+		  break;
+
+		  /* If we run out of tokens, issue an error message.  */
+		case CPP_EOF:
+		  error ("file ends in default argument");
+		  done = true;
+		  break;
+
+		case CPP_NAME:
+		case CPP_SCOPE:
+		  /* In these cases, we should look for template-ids.
+		     For example, if the default argument is 
+		     `X<int, double>()', we need to do name lookup to
+		     figure out whether or not `X' is a template; if
+		     so, the `,' does not end the default argument.
+
+		     That is not yet done.  */
+		  break;
+
+		default:
+		  break;
+		}
+
+	      /* If we've reached the end, stop.  */
+	      if (done)
+		break;
+	      
+	      /* Add the token to the token block.  */
+	      token = cp_lexer_consume_token (parser->lexer);
+	      cp_token_cache_push_token (DEFARG_TOKENS (default_argument),
+					 token);
+	    }
+	}
+      /* Outside of a class definition, we can just parse the
+         assignment-expression.  */
+      else
+	{
+	  bool saved_local_variables_forbidden_p;
+
+	  /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
+	     set correctly.  */
+	  saved_greater_than_is_operator_p 
+	    = parser->greater_than_is_operator_p;
+	  parser->greater_than_is_operator_p = greater_than_is_operator_p;
+	  /* Local variable names (and the `this' keyword) may not
+	     appear in a default argument.  */
+	  saved_local_variables_forbidden_p 
+	    = parser->local_variables_forbidden_p;
+	  parser->local_variables_forbidden_p = true;
+	  /* Parse the assignment-expression.  */
+	  default_argument = cp_parser_assignment_expression (parser);
+	  /* Restore saved state.  */
+	  parser->greater_than_is_operator_p 
+	    = saved_greater_than_is_operator_p;
+	  parser->local_variables_forbidden_p 
+	    = saved_local_variables_forbidden_p; 
+	}
+      if (!parser->default_arg_ok_p)
+	{
+	  if (!flag_pedantic_errors)
+	    warning ("deprecated use of default argument for parameter of non-function");
+	  else
+	    {
+	      error ("default arguments are only permitted for function parameters");
+	      default_argument = NULL_TREE;
+	    }
+	}
+    }
+  else
+    default_argument = NULL_TREE;
+  
+  /* Create the representation of the parameter.  */
+  if (attributes)
+    decl_specifiers = tree_cons (attributes, NULL_TREE, decl_specifiers);
+  parameter = build_tree_list (default_argument, 
+			       build_tree_list (decl_specifiers,
+						declarator));
+
+  return parameter;
+}
+
+/* Parse a function-body.
+
+   function-body:
+     compound_statement  */
+
+static void
+cp_parser_function_body (cp_parser *parser)
+{
+  cp_parser_compound_statement (parser, false);
+}
+
+/* Parse a ctor-initializer-opt followed by a function-body.  Return
+   true if a ctor-initializer was present.  */
+
+static bool
+cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser)
+{
+  tree body;
+  bool ctor_initializer_p;
+
+  /* Begin the function body.  */
+  body = begin_function_body ();
+  /* Parse the optional ctor-initializer.  */
+  ctor_initializer_p = cp_parser_ctor_initializer_opt (parser);
+  /* Parse the function-body.  */
+  cp_parser_function_body (parser);
+  /* Finish the function body.  */
+  finish_function_body (body);
+
+  return ctor_initializer_p;
+}
+
+/* Parse an initializer.
+
+   initializer:
+     = initializer-clause
+     ( expression-list )  
+
+   Returns a expression representing the initializer.  If no
+   initializer is present, NULL_TREE is returned.  
+
+   *IS_PARENTHESIZED_INIT is set to TRUE if the `( expression-list )'
+   production is used, and zero otherwise.  *IS_PARENTHESIZED_INIT is
+   set to FALSE if there is no initializer present.  If there is an
+   initializer, and it is not a constant-expression, *NON_CONSTANT_P
+   is set to true; otherwise it is set to false.  */
+
+static tree
+cp_parser_initializer (cp_parser* parser, bool* is_parenthesized_init,
+		       bool* non_constant_p)
+{
+  cp_token *token;
+  tree init;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+
+  /* Let our caller know whether or not this initializer was
+     parenthesized.  */
+  *is_parenthesized_init = (token->type == CPP_OPEN_PAREN);
+  /* Assume that the initializer is constant.  */
+  *non_constant_p = false;
+
+  if (token->type == CPP_EQ)
+    {
+      /* Consume the `='.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Parse the initializer-clause.  */
+      init = cp_parser_initializer_clause (parser, non_constant_p);
+    }
+  else if (token->type == CPP_OPEN_PAREN)
+    init = cp_parser_parenthesized_expression_list (parser, false,
+						    non_constant_p);
+  else
+    {
+      /* Anything else is an error.  */
+      cp_parser_error (parser, "expected initializer");
+      init = error_mark_node;
+    }
+
+  return init;
+}
+
+/* Parse an initializer-clause.  
+
+   initializer-clause:
+     assignment-expression
+     { initializer-list , [opt] }
+     { }
+
+   Returns an expression representing the initializer.  
+
+   If the `assignment-expression' production is used the value
+   returned is simply a representation for the expression.  
+
+   Otherwise, a CONSTRUCTOR is returned.  The CONSTRUCTOR_ELTS will be
+   the elements of the initializer-list (or NULL_TREE, if the last
+   production is used).  The TREE_TYPE for the CONSTRUCTOR will be
+   NULL_TREE.  There is no way to detect whether or not the optional
+   trailing `,' was provided.  NON_CONSTANT_P is as for
+   cp_parser_initializer.  */
+
+static tree
+cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
+{
+  tree initializer;
+
+  /* If it is not a `{', then we are looking at an
+     assignment-expression.  */
+  if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
+    {
+      initializer 
+	= cp_parser_constant_expression (parser,
+					/*allow_non_constant_p=*/true,
+					non_constant_p);
+      if (!*non_constant_p)
+	initializer = fold_non_dependent_expr (initializer);
+    }
+  else
+    {
+      /* Consume the `{' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Create a CONSTRUCTOR to represent the braced-initializer.  */
+      initializer = make_node (CONSTRUCTOR);
+      /* Mark it with TREE_HAS_CONSTRUCTOR.  This should not be
+	 necessary, but check_initializer depends upon it, for 
+	 now.  */
+      TREE_HAS_CONSTRUCTOR (initializer) = 1;
+      /* If it's not a `}', then there is a non-trivial initializer.  */
+      if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
+	{
+	  /* Parse the initializer list.  */
+	  CONSTRUCTOR_ELTS (initializer)
+	    = cp_parser_initializer_list (parser, non_constant_p);
+	  /* A trailing `,' token is allowed.  */
+	  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
+	    cp_lexer_consume_token (parser->lexer);
+	}
+      /* Now, there should be a trailing `}'.  */
+      cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
+    }
+
+  return initializer;
+}
+
+/* Parse an initializer-list.
+
+   initializer-list:
+     initializer-clause
+     initializer-list , initializer-clause
+
+   GNU Extension:
+   
+   initializer-list:
+     identifier : initializer-clause
+     initializer-list, identifier : initializer-clause
+
+   Returns a TREE_LIST.  The TREE_VALUE of each node is an expression
+   for the initializer.  If the TREE_PURPOSE is non-NULL, it is the
+   IDENTIFIER_NODE naming the field to initialize.  NON_CONSTANT_P is
+   as for cp_parser_initializer.  */
+
+static tree
+cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
+{
+  tree initializers = NULL_TREE;
+
+  /* Assume all of the expressions are constant.  */
+  *non_constant_p = false;
+
+  /* Parse the rest of the list.  */
+  while (true)
+    {
+      cp_token *token;
+      tree identifier;
+      tree initializer;
+      bool clause_non_constant_p;
+
+      /* If the next token is an identifier and the following one is a
+	 colon, we are looking at the GNU designated-initializer
+	 syntax.  */
+      if (cp_parser_allow_gnu_extensions_p (parser)
+	  && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
+	  && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
+	{
+	  /* Consume the identifier.  */
+	  identifier = cp_lexer_consume_token (parser->lexer)->value;
+	  /* Consume the `:'.  */
+	  cp_lexer_consume_token (parser->lexer);
+	}
+      else
+	identifier = NULL_TREE;
+
+      /* Parse the initializer.  */
+      initializer = cp_parser_initializer_clause (parser, 
+						  &clause_non_constant_p);
+      /* If any clause is non-constant, so is the entire initializer.  */
+      if (clause_non_constant_p)
+	*non_constant_p = true;
+      /* Add it to the list.  */
+      initializers = tree_cons (identifier, initializer, initializers);
+
+      /* If the next token is not a comma, we have reached the end of
+	 the list.  */
+      if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
+	break;
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_nth_token (parser->lexer, 2);
+      /* If the next token is a `}', then we're still done.  An
+	 initializer-clause can have a trailing `,' after the
+	 initializer-list and before the closing `}'.  */
+      if (token->type == CPP_CLOSE_BRACE)
+	break;
+
+      /* Consume the `,' token.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  /* The initializers were built up in reverse order, so we need to
+     reverse them now.  */
+  return nreverse (initializers);
+}
+
+/* Classes [gram.class] */
+
+/* Parse a class-name.
+
+   class-name:
+     identifier
+     template-id
+
+   TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
+   to indicate that names looked up in dependent types should be
+   assumed to be types.  TEMPLATE_KEYWORD_P is true iff the `template'
+   keyword has been used to indicate that the name that appears next
+   is a template.  TYPE_P is true iff the next name should be treated
+   as class-name, even if it is declared to be some other kind of name
+   as well.  If CHECK_DEPENDENCY_P is FALSE, names are looked up in
+   dependent scopes.  If CLASS_HEAD_P is TRUE, this class is the class
+   being defined in a class-head.
+
+   Returns the TYPE_DECL representing the class.  */
+
+static tree
+cp_parser_class_name (cp_parser *parser, 
+		      bool typename_keyword_p, 
+		      bool template_keyword_p, 
+		      bool type_p,
+		      bool check_dependency_p,
+		      bool class_head_p,
+		      bool is_declaration)
+{
+  tree decl;
+  tree scope;
+  bool typename_p;
+  cp_token *token;
+
+  /* All class-names start with an identifier.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
+    {
+      cp_parser_error (parser, "expected class-name");
+      return error_mark_node;
+    }
+    
+  /* PARSER->SCOPE can be cleared when parsing the template-arguments
+     to a template-id, so we save it here.  */
+  scope = parser->scope;
+  if (scope == error_mark_node)
+    return error_mark_node;
+  
+  /* Any name names a type if we're following the `typename' keyword
+     in a qualified name where the enclosing scope is type-dependent.  */
+  typename_p = (typename_keyword_p && scope && TYPE_P (scope)
+		&& dependent_type_p (scope));
+  /* Handle the common case (an identifier, but not a template-id)
+     efficiently.  */
+  if (token->type == CPP_NAME 
+      && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
+    {
+      tree identifier;
+
+      /* Look for the identifier.  */
+      identifier = cp_parser_identifier (parser);
+      /* If the next token isn't an identifier, we are certainly not
+	 looking at a class-name.  */
+      if (identifier == error_mark_node)
+	decl = error_mark_node;
+      /* If we know this is a type-name, there's no need to look it
+	 up.  */
+      else if (typename_p)
+	decl = identifier;
+      else
+	{
+	  /* If the next token is a `::', then the name must be a type
+	     name.
+
+	     [basic.lookup.qual]
+
+	     During the lookup for a name preceding the :: scope
+	     resolution operator, object, function, and enumerator
+	     names are ignored.  */
+	  if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
+	    type_p = true;
+	  /* Look up the name.  */
+	  decl = cp_parser_lookup_name (parser, identifier, 
+					type_p,
+					/*is_template=*/false,
+					/*is_namespace=*/false,
+					check_dependency_p);
+	}
+    }
+  else
+    {
+      /* Try a template-id.  */
+      decl = cp_parser_template_id (parser, template_keyword_p,
+				    check_dependency_p,
+				    is_declaration);
+      if (decl == error_mark_node)
+	return error_mark_node;
+    }
+
+  decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);
+
+  /* If this is a typename, create a TYPENAME_TYPE.  */
+  if (typename_p && decl != error_mark_node)
+    {
+      decl = make_typename_type (scope, decl, /*complain=*/1);
+      if (decl != error_mark_node)
+	decl = TYPE_NAME (decl);
+    }
+
+  /* Check to see that it is really the name of a class.  */
+  if (TREE_CODE (decl) == TEMPLATE_ID_EXPR 
+      && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
+      && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
+    /* Situations like this:
+
+	 template <typename T> struct A {
+	   typename T::template X<int>::I i; 
+	 };
+
+       are problematic.  Is `T::template X<int>' a class-name?  The
+       standard does not seem to be definitive, but there is no other
+       valid interpretation of the following `::'.  Therefore, those
+       names are considered class-names.  */
+    decl = TYPE_NAME (make_typename_type (scope, decl, tf_error));
+  else if (decl == error_mark_node
+	   || TREE_CODE (decl) != TYPE_DECL
+	   || !IS_AGGR_TYPE (TREE_TYPE (decl)))
+    {
+      cp_parser_error (parser, "expected class-name");
+      return error_mark_node;
+    }
+
+  return decl;
+}
+
+/* Parse a class-specifier.
+
+   class-specifier:
+     class-head { member-specification [opt] }
+
+   Returns the TREE_TYPE representing the class.  */
+
+static tree
+cp_parser_class_specifier (cp_parser* parser)
+{
+  cp_token *token;
+  tree type;
+  tree attributes;
+  int has_trailing_semicolon;
+  bool nested_name_specifier_p;
+  unsigned saved_num_template_parameter_lists;
+  bool pop_p = false;
+
+  push_deferring_access_checks (dk_no_deferred);
+
+  /* Parse the class-head.  */
+  type = cp_parser_class_head (parser,
+			       &nested_name_specifier_p,
+			       &attributes);
+  /* If the class-head was a semantic disaster, skip the entire body
+     of the class.  */
+  if (!type)
+    {
+      cp_parser_skip_to_end_of_block_or_statement (parser);
+      pop_deferring_access_checks ();
+      return error_mark_node;
+    }
+
+  /* Look for the `{'.  */
+  if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
+    {
+      pop_deferring_access_checks ();
+      return error_mark_node;
+    }
+
+  /* Issue an error message if type-definitions are forbidden here.  */
+  cp_parser_check_type_definition (parser);
+  /* Remember that we are defining one more class.  */
+  ++parser->num_classes_being_defined;
+  /* Inside the class, surrounding template-parameter-lists do not
+     apply.  */
+  saved_num_template_parameter_lists 
+    = parser->num_template_parameter_lists; 
+  parser->num_template_parameter_lists = 0;
+
+  /* Start the class.  */
+  if (nested_name_specifier_p)
+    pop_p = push_scope (CP_DECL_CONTEXT (TYPE_MAIN_DECL (type)));
+  type = begin_class_definition (type);
+  if (type == error_mark_node)
+    /* If the type is erroneous, skip the entire body of the class.  */
+    cp_parser_skip_to_closing_brace (parser);
+  else
+    /* Parse the member-specification.  */
+    cp_parser_member_specification_opt (parser);
+  /* Look for the trailing `}'.  */
+  cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
+  /* We get better error messages by noticing a common problem: a
+     missing trailing `;'.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  has_trailing_semicolon = (token->type == CPP_SEMICOLON);
+  /* Look for trailing attributes to apply to this class.  */
+  if (cp_parser_allow_gnu_extensions_p (parser))
+    {
+      tree sub_attr = cp_parser_attributes_opt (parser);
+      attributes = chainon (attributes, sub_attr);
+    }
+  if (type != error_mark_node)
+    type = finish_struct (type, attributes);
+  if (pop_p)
+    pop_scope (CP_DECL_CONTEXT (TYPE_MAIN_DECL (type)));
+  /* If this class is not itself within the scope of another class,
+     then we need to parse the bodies of all of the queued function
+     definitions.  Note that the queued functions defined in a class
+     are not always processed immediately following the
+     class-specifier for that class.  Consider:
+
+       struct A {
+         struct B { void f() { sizeof (A); } };
+       };
+
+     If `f' were processed before the processing of `A' were
+     completed, there would be no way to compute the size of `A'.
+     Note that the nesting we are interested in here is lexical --
+     not the semantic nesting given by TYPE_CONTEXT.  In particular,
+     for:
+
+       struct A { struct B; };
+       struct A::B { void f() { } };
+
+     there is no need to delay the parsing of `A::B::f'.  */
+  if (--parser->num_classes_being_defined == 0) 
+    {
+      tree queue_entry;
+      tree fn;
+
+      /* In a first pass, parse default arguments to the functions.
+	 Then, in a second pass, parse the bodies of the functions.
+	 This two-phased approach handles cases like:
+	 
+	    struct S { 
+              void f() { g(); } 
+              void g(int i = 3);
+            };
+
+         */
+      for (TREE_PURPOSE (parser->unparsed_functions_queues)
+	     = nreverse (TREE_PURPOSE (parser->unparsed_functions_queues));
+	   (queue_entry = TREE_PURPOSE (parser->unparsed_functions_queues));
+	   TREE_PURPOSE (parser->unparsed_functions_queues)
+	     = TREE_CHAIN (TREE_PURPOSE (parser->unparsed_functions_queues)))
+	{
+	  fn = TREE_VALUE (queue_entry);
+	  /* Make sure that any template parameters are in scope.  */
+	  maybe_begin_member_template_processing (fn);
+	  /* If there are default arguments that have not yet been processed,
+	     take care of them now.  */
+	  cp_parser_late_parsing_default_args (parser, fn);
+	  /* Remove any template parameters from the symbol table.  */
+	  maybe_end_member_template_processing ();
+	}
+      /* Now parse the body of the functions.  */
+      for (TREE_VALUE (parser->unparsed_functions_queues)
+	     = nreverse (TREE_VALUE (parser->unparsed_functions_queues));
+	   (queue_entry = TREE_VALUE (parser->unparsed_functions_queues));
+	   TREE_VALUE (parser->unparsed_functions_queues)
+	     = TREE_CHAIN (TREE_VALUE (parser->unparsed_functions_queues)))
+	{
+	  /* Figure out which function we need to process.  */
+	  fn = TREE_VALUE (queue_entry);
+
+	  /* A hack to prevent garbage collection.  */
+	  function_depth++;
+
+	  /* Parse the function.  */
+	  cp_parser_late_parsing_for_member (parser, fn);
+	  function_depth--;
+	}
+
+    }
+
+  /* Put back any saved access checks.  */
+  pop_deferring_access_checks ();
+
+  /* Restore the count of active template-parameter-lists.  */
+  parser->num_template_parameter_lists
+    = saved_num_template_parameter_lists;
+
+  return type;
+}
+
+/* Parse a class-head.
+
+   class-head:
+     class-key identifier [opt] base-clause [opt]
+     class-key nested-name-specifier identifier base-clause [opt]
+     class-key nested-name-specifier [opt] template-id 
+       base-clause [opt]  
+
+   GNU Extensions:
+     class-key attributes identifier [opt] base-clause [opt]
+     class-key attributes nested-name-specifier identifier base-clause [opt]
+     class-key attributes nested-name-specifier [opt] template-id 
+       base-clause [opt]  
+
+   Returns the TYPE of the indicated class.  Sets
+   *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
+   involving a nested-name-specifier was used, and FALSE otherwise.
+
+   Returns NULL_TREE if the class-head is syntactically valid, but
+   semantically invalid in a way that means we should skip the entire
+   body of the class.  */
+
+static tree
+cp_parser_class_head (cp_parser* parser, 
+		      bool* nested_name_specifier_p,
+		      tree *attributes_p)
+{
+  cp_token *token;
+  tree nested_name_specifier;
+  enum tag_types class_key;
+  tree id = NULL_TREE;
+  tree type = NULL_TREE;
+  tree attributes;
+  bool template_id_p = false;
+  bool qualified_p = false;
+  bool invalid_nested_name_p = false;
+  bool invalid_explicit_specialization_p = false;
+  bool pop_p = false;
+  unsigned num_templates;
+
+  /* Assume no nested-name-specifier will be present.  */
+  *nested_name_specifier_p = false;
+  /* Assume no template parameter lists will be used in defining the
+     type.  */
+  num_templates = 0;
+
+  /* Look for the class-key.  */
+  class_key = cp_parser_class_key (parser);
+  if (class_key == none_type)
+    return error_mark_node;
+
+  /* Parse the attributes.  */
+  attributes = cp_parser_attributes_opt (parser);
+
+  /* If the next token is `::', that is invalid -- but sometimes
+     people do try to write:
+
+       struct ::S {};  
+
+     Handle this gracefully by accepting the extra qualifier, and then
+     issuing an error about it later if this really is a
+     class-head.  If it turns out just to be an elaborated type
+     specifier, remain silent.  */
+  if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
+    qualified_p = true;
+
+  push_deferring_access_checks (dk_no_check);
+
+  /* Determine the name of the class.  Begin by looking for an
+     optional nested-name-specifier.  */
+  nested_name_specifier 
+    = cp_parser_nested_name_specifier_opt (parser,
+					   /*typename_keyword_p=*/false,
+					   /*check_dependency_p=*/false,
+					   /*type_p=*/false,
+					   /*is_declaration=*/false);
+  /* If there was a nested-name-specifier, then there *must* be an
+     identifier.  */
+  if (nested_name_specifier)
+    {
+      /* Although the grammar says `identifier', it really means
+	 `class-name' or `template-name'.  You are only allowed to
+	 define a class that has already been declared with this
+	 syntax.  
+
+	 The proposed resolution for Core Issue 180 says that whever
+	 you see `class T::X' you should treat `X' as a type-name.
+	 
+	 It is OK to define an inaccessible class; for example:
+	 
+           class A { class B; };
+           class A::B {};
+	 
+         We do not know if we will see a class-name, or a
+	 template-name.  We look for a class-name first, in case the
+	 class-name is a template-id; if we looked for the
+	 template-name first we would stop after the template-name.  */
+      cp_parser_parse_tentatively (parser);
+      type = cp_parser_class_name (parser,
+				   /*typename_keyword_p=*/false,
+				   /*template_keyword_p=*/false,
+				   /*type_p=*/true,
+				   /*check_dependency_p=*/false,
+				   /*class_head_p=*/true,
+				   /*is_declaration=*/false);
+      /* If that didn't work, ignore the nested-name-specifier.  */
+      if (!cp_parser_parse_definitely (parser))
+	{
+	  invalid_nested_name_p = true;
+	  id = cp_parser_identifier (parser);
+	  if (id == error_mark_node)
+	    id = NULL_TREE;
+	}
+      /* If we could not find a corresponding TYPE, treat this
+	 declaration like an unqualified declaration.  */
+      if (type == error_mark_node)
+	nested_name_specifier = NULL_TREE;
+      /* Otherwise, count the number of templates used in TYPE and its
+	 containing scopes.  */
+      else 
+	{
+	  tree scope;
+
+	  for (scope = TREE_TYPE (type); 
+	       scope && TREE_CODE (scope) != NAMESPACE_DECL;
+	       scope = (TYPE_P (scope) 
+			? TYPE_CONTEXT (scope)
+			: DECL_CONTEXT (scope))) 
+	    if (TYPE_P (scope) 
+		&& CLASS_TYPE_P (scope)
+		&& CLASSTYPE_TEMPLATE_INFO (scope)
+		&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))
+		&& !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope))
+	      ++num_templates;
+	}
+    }
+  /* Otherwise, the identifier is optional.  */
+  else
+    {
+      /* We don't know whether what comes next is a template-id,
+	 an identifier, or nothing at all.  */
+      cp_parser_parse_tentatively (parser);
+      /* Check for a template-id.  */
+      id = cp_parser_template_id (parser, 
+				  /*template_keyword_p=*/false,
+				  /*check_dependency_p=*/true,
+				  /*is_declaration=*/true);
+      /* If that didn't work, it could still be an identifier.  */
+      if (!cp_parser_parse_definitely (parser))
+	{
+	  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+	    id = cp_parser_identifier (parser);
+	  else
+	    id = NULL_TREE;
+	}
+      else
+	{
+	  template_id_p = true;
+	  ++num_templates;
+	}
+    }
+
+  pop_deferring_access_checks ();
+
+  if (id)
+    cp_parser_check_for_invalid_template_id (parser, id);
+
+  /* If it's not a `:' or a `{' then we can't really be looking at a
+     class-head, since a class-head only appears as part of a
+     class-specifier.  We have to detect this situation before calling
+     xref_tag, since that has irreversible side-effects.  */
+  if (!cp_parser_next_token_starts_class_definition_p (parser))
+    {
+      cp_parser_error (parser, "expected `{' or `:'");
+      return error_mark_node;
+    }
+
+  /* At this point, we're going ahead with the class-specifier, even
+     if some other problem occurs.  */
+  cp_parser_commit_to_tentative_parse (parser);
+  /* Issue the error about the overly-qualified name now.  */
+  if (qualified_p)
+    cp_parser_error (parser,
+		     "global qualification of class name is invalid");
+  else if (invalid_nested_name_p)
+    cp_parser_error (parser,
+		     "qualified name does not name a class");
+  else if (nested_name_specifier)
+    {
+      tree scope;
+      /* Figure out in what scope the declaration is being placed.  */
+      scope = current_scope ();
+      if (!scope)
+	scope = current_namespace;
+      /* If that scope does not contain the scope in which the
+	 class was originally declared, the program is invalid.  */
+      if (scope && !is_ancestor (scope, nested_name_specifier))
+	{
+	  error ("declaration of `%D' in `%D' which does not "
+		 "enclose `%D'", type, scope, nested_name_specifier);
+	  type = NULL_TREE;
+	  goto done;
+	}
+      /* [dcl.meaning]
+
+         A declarator-id shall not be qualified exception of the
+	 definition of a ... nested class outside of its class
+	 ... [or] a the definition or explicit instantiation of a
+	 class member of a namespace outside of its namespace.  */
+      if (scope == nested_name_specifier)
+	{
+	  pedwarn ("extra qualification ignored");
+	  nested_name_specifier = NULL_TREE;
+	  num_templates = 0;
+	}
+    }
+  /* An explicit-specialization must be preceded by "template <>".  If
+     it is not, try to recover gracefully.  */
+  if (at_namespace_scope_p () 
+      && parser->num_template_parameter_lists == 0
+      && template_id_p)
+    {
+      error ("an explicit specialization must be preceded by 'template <>'");
+      invalid_explicit_specialization_p = true;
+      /* Take the same action that would have been taken by
+	 cp_parser_explicit_specialization.  */
+      ++parser->num_template_parameter_lists;
+      begin_specialization ();
+    }
+  /* There must be no "return" statements between this point and the
+     end of this function; set "type "to the correct return value and
+     use "goto done;" to return.  */
+  /* Make sure that the right number of template parameters were
+     present.  */
+  if (!cp_parser_check_template_parameters (parser, num_templates))
+    {
+      /* If something went wrong, there is no point in even trying to
+	 process the class-definition.  */
+      type = NULL_TREE;
+      goto done;
+    }
+
+  /* Look up the type.  */
+  if (template_id_p)
+    {
+      type = TREE_TYPE (id);
+      maybe_process_partial_specialization (type);
+    }
+  else if (!nested_name_specifier)
+    {
+      /* If the class was unnamed, create a dummy name.  */
+      if (!id)
+	id = make_anon_name ();
+      type = xref_tag (class_key, id, /*globalize=*/false,
+		       parser->num_template_parameter_lists);
+    }
+  else
+    {
+      tree class_type;
+      bool pop_p = false;
+
+      /* Given:
+
+	    template <typename T> struct S { struct T };
+	    template <typename T> struct S<T>::T { };
+
+	 we will get a TYPENAME_TYPE when processing the definition of
+	 `S::T'.  We need to resolve it to the actual type before we
+	 try to define it.  */
+      if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
+	{
+	  class_type = resolve_typename_type (TREE_TYPE (type),
+					      /*only_current_p=*/false);
+	  if (class_type != error_mark_node)
+	    type = TYPE_NAME (class_type);
+	  else
+	    {
+	      cp_parser_error (parser, "could not resolve typename type");
+	      type = error_mark_node;
+	    }
+	}
+
+      maybe_process_partial_specialization (TREE_TYPE (type));
+      class_type = current_class_type;
+      /* Enter the scope indicated by the nested-name-specifier.  */
+      if (nested_name_specifier)
+	pop_p = push_scope (nested_name_specifier);
+      /* Get the canonical version of this type.  */
+      type = TYPE_MAIN_DECL (TREE_TYPE (type));
+      if (PROCESSING_REAL_TEMPLATE_DECL_P ()
+	  && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
+	type = push_template_decl (type);
+      type = TREE_TYPE (type);
+      if (nested_name_specifier)
+	{
+	  *nested_name_specifier_p = true;
+	  if (pop_p)
+	    pop_scope (nested_name_specifier);
+	}
+    }
+  /* Indicate whether this class was declared as a `class' or as a
+     `struct'.  */
+  if (TREE_CODE (type) == RECORD_TYPE)
+    CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type);
+  cp_parser_check_class_key (class_key, type);
+
+  /* Enter the scope containing the class; the names of base classes
+     should be looked up in that context.  For example, given:
+
+       struct A { struct B {}; struct C; };
+       struct A::C : B {};
+
+     is valid.  */
+  if (nested_name_specifier)
+    pop_p = push_scope (nested_name_specifier);
+  /* Now, look for the base-clause.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  if (token->type == CPP_COLON)
+    {
+      tree bases;
+
+      /* Get the list of base-classes.  */
+      bases = cp_parser_base_clause (parser);
+      /* Process them.  */
+      xref_basetypes (type, bases);
+    }
+  /* Leave the scope given by the nested-name-specifier.  We will
+     enter the class scope itself while processing the members.  */
+  if (pop_p)
+    pop_scope (nested_name_specifier);
+
+ done:
+  if (invalid_explicit_specialization_p)
+    {
+      end_specialization ();
+      --parser->num_template_parameter_lists;
+    }
+  *attributes_p = attributes;
+  return type;
+}
+
+/* Parse a class-key.
+
+   class-key:
+     class
+     struct
+     union
+
+   Returns the kind of class-key specified, or none_type to indicate
+   error.  */
+
+static enum tag_types
+cp_parser_class_key (cp_parser* parser)
+{
+  cp_token *token;
+  enum tag_types tag_type;
+
+  /* Look for the class-key.  */
+  token = cp_parser_require (parser, CPP_KEYWORD, "class-key");
+  if (!token)
+    return none_type;
+
+  /* Check to see if the TOKEN is a class-key.  */
+  tag_type = cp_parser_token_is_class_key (token);
+  if (!tag_type)
+    cp_parser_error (parser, "expected class-key");
+  return tag_type;
+}
+
+/* Parse an (optional) member-specification.
+
+   member-specification:
+     member-declaration member-specification [opt]
+     access-specifier : member-specification [opt]  */
+
+static void
+cp_parser_member_specification_opt (cp_parser* parser)
+{
+  while (true)
+    {
+      cp_token *token;
+      enum rid keyword;
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If it's a `}', or EOF then we've seen all the members.  */
+      if (token->type == CPP_CLOSE_BRACE || token->type == CPP_EOF)
+	break;
+
+      /* See if this token is a keyword.  */
+      keyword = token->keyword;
+      switch (keyword)
+	{
+	case RID_PUBLIC:
+	case RID_PROTECTED:
+	case RID_PRIVATE:
+	  /* Consume the access-specifier.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  /* Remember which access-specifier is active.  */
+	  current_access_specifier = token->value;
+	  /* Look for the `:'.  */
+	  cp_parser_require (parser, CPP_COLON, "`:'");
+	  break;
+
+	default:
+	  /* Otherwise, the next construction must be a
+	     member-declaration.  */
+	  cp_parser_member_declaration (parser);
+	}
+    }
+}
+
+/* Parse a member-declaration.  
+
+   member-declaration:
+     decl-specifier-seq [opt] member-declarator-list [opt] ;
+     function-definition ; [opt]
+     :: [opt] nested-name-specifier template [opt] unqualified-id ;
+     using-declaration
+     template-declaration 
+
+   member-declarator-list:
+     member-declarator
+     member-declarator-list , member-declarator
+
+   member-declarator:
+     declarator pure-specifier [opt] 
+     declarator constant-initializer [opt]
+     identifier [opt] : constant-expression 
+
+   GNU Extensions:
+
+   member-declaration:
+     __extension__ member-declaration
+
+   member-declarator:
+     declarator attributes [opt] pure-specifier [opt]
+     declarator attributes [opt] constant-initializer [opt]
+     identifier [opt] attributes [opt] : constant-expression  */
+
+static void
+cp_parser_member_declaration (cp_parser* parser)
+{
+  tree decl_specifiers;
+  tree prefix_attributes;
+  tree decl;
+  int declares_class_or_enum;
+  bool friend_p;
+  cp_token *token;
+  int saved_pedantic;
+
+  /* Check for the `__extension__' keyword.  */
+  if (cp_parser_extension_opt (parser, &saved_pedantic))
+    {
+      /* Recurse.  */
+      cp_parser_member_declaration (parser);
+      /* Restore the old value of the PEDANTIC flag.  */
+      pedantic = saved_pedantic;
+
+      return;
+    }
+
+  /* Check for a template-declaration.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
+    {
+      /* Parse the template-declaration.  */
+      cp_parser_template_declaration (parser, /*member_p=*/true);
+
+      return;
+    }
+
+  /* Check for a using-declaration.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
+    {
+      /* Parse the using-declaration.  */
+      cp_parser_using_declaration (parser);
+
+      return;
+    }
+  
+  /* Parse the decl-specifier-seq.  */
+  decl_specifiers 
+    = cp_parser_decl_specifier_seq (parser,
+				    CP_PARSER_FLAGS_OPTIONAL,
+				    &prefix_attributes,
+				    &declares_class_or_enum);
+  /* Check for an invalid type-name.  */
+  if (cp_parser_diagnose_invalid_type_name (parser))
+    return;
+  /* If there is no declarator, then the decl-specifier-seq should
+     specify a type.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
+    {
+      /* If there was no decl-specifier-seq, and the next token is a
+	 `;', then we have something like:
+
+	   struct S { ; };
+
+	 [class.mem]
+
+	 Each member-declaration shall declare at least one member
+	 name of the class.  */
+      if (!decl_specifiers)
+	{
+	  if (pedantic)
+	    pedwarn ("extra semicolon");
+	}
+      else 
+	{
+	  tree type;
+	  
+	  /* See if this declaration is a friend.  */
+	  friend_p = cp_parser_friend_p (decl_specifiers);
+	  /* If there were decl-specifiers, check to see if there was
+	     a class-declaration.  */
+	  type = check_tag_decl (decl_specifiers);
+	  /* Nested classes have already been added to the class, but
+	     a `friend' needs to be explicitly registered.  */
+	  if (friend_p)
+	    {
+	      /* If the `friend' keyword was present, the friend must
+		 be introduced with a class-key.  */
+	       if (!declares_class_or_enum)
+		 error ("a class-key must be used when declaring a friend");
+	       /* In this case:
+
+		    template <typename T> struct A { 
+                      friend struct A<T>::B; 
+                    };
+ 
+		  A<T>::B will be represented by a TYPENAME_TYPE, and
+		  therefore not recognized by check_tag_decl.  */
+	       if (!type)
+		 {
+		   tree specifier;
+
+		   for (specifier = decl_specifiers; 
+			specifier;
+			specifier = TREE_CHAIN (specifier))
+		     {
+		       tree s = TREE_VALUE (specifier);
+
+		       if (TREE_CODE (s) == IDENTIFIER_NODE)
+                         get_global_value_if_present (s, &type);
+		       if (TREE_CODE (s) == TYPE_DECL)
+			 s = TREE_TYPE (s);
+		       if (TYPE_P (s))
+			 {
+			   type = s;
+			   break;
+			 }
+		     }
+		 }
+	       if (!type || !TYPE_P (type))
+		 error ("friend declaration does not name a class or "
+			"function");
+	       else
+		 make_friend_class (current_class_type, type,
+				    /*complain=*/true);
+	    }
+	  /* If there is no TYPE, an error message will already have
+	     been issued.  */
+	  else if (!type)
+	    ;
+	  /* An anonymous aggregate has to be handled specially; such
+	     a declaration really declares a data member (with a
+	     particular type), as opposed to a nested class.  */
+	  else if (ANON_AGGR_TYPE_P (type))
+	    {
+	      /* Remove constructors and such from TYPE, now that we
+		 know it is an anonymous aggregate.  */
+	      fixup_anonymous_aggr (type);
+	      /* And make the corresponding data member.  */
+	      decl = build_decl (FIELD_DECL, NULL_TREE, type);
+	      /* Add it to the class.  */
+	      finish_member_declaration (decl);
+	    }
+	  else
+	    cp_parser_check_access_in_redeclaration (TYPE_NAME (type));
+	}
+    }
+  else
+    {
+      /* See if these declarations will be friends.  */
+      friend_p = cp_parser_friend_p (decl_specifiers);
+
+      /* Keep going until we hit the `;' at the end of the 
+	 declaration.  */
+      while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
+	{
+	  tree attributes = NULL_TREE;
+	  tree first_attribute;
+
+	  /* Peek at the next token.  */
+	  token = cp_lexer_peek_token (parser->lexer);
+
+	  /* Check for a bitfield declaration.  */
+	  if (token->type == CPP_COLON
+	      || (token->type == CPP_NAME
+		  && cp_lexer_peek_nth_token (parser->lexer, 2)->type 
+		  == CPP_COLON))
+	    {
+	      tree identifier;
+	      tree width;
+
+	      /* Get the name of the bitfield.  Note that we cannot just
+		 check TOKEN here because it may have been invalidated by
+		 the call to cp_lexer_peek_nth_token above.  */
+	      if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
+		identifier = cp_parser_identifier (parser);
+	      else
+		identifier = NULL_TREE;
+
+	      /* Consume the `:' token.  */
+	      cp_lexer_consume_token (parser->lexer);
+	      /* Get the width of the bitfield.  */
+	      width 
+		= cp_parser_constant_expression (parser,
+						 /*allow_non_constant=*/false,
+						 NULL);
+
+	      /* Look for attributes that apply to the bitfield.  */
+	      attributes = cp_parser_attributes_opt (parser);
+	      /* Remember which attributes are prefix attributes and
+		 which are not.  */
+	      first_attribute = attributes;
+	      /* Combine the attributes.  */
+	      attributes = chainon (prefix_attributes, attributes);
+
+	      /* Create the bitfield declaration.  */
+	      decl = grokbitfield (identifier, 
+				   decl_specifiers,
+				   width);
+	      /* Apply the attributes.  */
+	      cplus_decl_attributes (&decl, attributes, /*flags=*/0);
+	    }
+	  else
+	    {
+	      tree declarator;
+	      tree initializer;
+	      tree asm_specification;
+	      int ctor_dtor_or_conv_p;
+
+	      /* Parse the declarator.  */
+	      declarator 
+		= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
+					&ctor_dtor_or_conv_p,
+					/*parenthesized_p=*/NULL);
+
+	      /* If something went wrong parsing the declarator, make sure
+		 that we at least consume some tokens.  */
+	      if (declarator == error_mark_node)
+		{
+		  /* Skip to the end of the statement.  */
+		  cp_parser_skip_to_end_of_statement (parser);
+		  /* If the next token is not a semicolon, that is
+		     probably because we just skipped over the body of
+		     a function.  So, we consume a semicolon if
+		     present, but do not issue an error message if it
+		     is not present.  */
+		  if (cp_lexer_next_token_is (parser->lexer,
+					      CPP_SEMICOLON))
+		    cp_lexer_consume_token (parser->lexer);
+		  return;
+		}
+
+	      cp_parser_check_for_definition_in_return_type 
+		(declarator, declares_class_or_enum);
+
+	      /* Look for an asm-specification.  */
+	      asm_specification = cp_parser_asm_specification_opt (parser);
+	      /* Look for attributes that apply to the declaration.  */
+	      attributes = cp_parser_attributes_opt (parser);
+	      /* Remember which attributes are prefix attributes and
+		 which are not.  */
+	      first_attribute = attributes;
+	      /* Combine the attributes.  */
+	      attributes = chainon (prefix_attributes, attributes);
+
+	      /* If it's an `=', then we have a constant-initializer or a
+		 pure-specifier.  It is not correct to parse the
+		 initializer before registering the member declaration
+		 since the member declaration should be in scope while
+		 its initializer is processed.  However, the rest of the
+		 front end does not yet provide an interface that allows
+		 us to handle this correctly.  */
+	      if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
+		{
+		  /* In [class.mem]:
+
+		     A pure-specifier shall be used only in the declaration of
+		     a virtual function.  
+
+		     A member-declarator can contain a constant-initializer
+		     only if it declares a static member of integral or
+		     enumeration type.  
+
+		     Therefore, if the DECLARATOR is for a function, we look
+		     for a pure-specifier; otherwise, we look for a
+		     constant-initializer.  When we call `grokfield', it will
+		     perform more stringent semantics checks.  */
+		  if (TREE_CODE (declarator) == CALL_EXPR)
+		    initializer = cp_parser_pure_specifier (parser);
+		  else
+		    /* Parse the initializer.  */
+		    initializer = cp_parser_constant_initializer (parser);
+		}
+	      /* Otherwise, there is no initializer.  */
+	      else
+		initializer = NULL_TREE;
+
+	      /* See if we are probably looking at a function
+		 definition.  We are certainly not looking at at a
+		 member-declarator.  Calling `grokfield' has
+		 side-effects, so we must not do it unless we are sure
+		 that we are looking at a member-declarator.  */
+	      if (cp_parser_token_starts_function_definition_p 
+		  (cp_lexer_peek_token (parser->lexer)))
+		{
+		  /* The grammar does not allow a pure-specifier to be
+		     used when a member function is defined.  (It is
+		     possible that this fact is an oversight in the
+		     standard, since a pure function may be defined
+		     outside of the class-specifier.  */
+		  if (initializer)
+		    error ("pure-specifier on function-definition");
+		  decl = cp_parser_save_member_function_body (parser,
+							      decl_specifiers,
+							      declarator,
+							      attributes);
+		  /* If the member was not a friend, declare it here.  */
+		  if (!friend_p)
+		    finish_member_declaration (decl);
+		  /* Peek at the next token.  */
+		  token = cp_lexer_peek_token (parser->lexer);
+		  /* If the next token is a semicolon, consume it.  */
+		  if (token->type == CPP_SEMICOLON)
+		    cp_lexer_consume_token (parser->lexer);
+		  return;
+		}
+	      else
+		{
+		  /* Create the declaration.  */
+		  decl = grokfield (declarator, decl_specifiers, 
+				    initializer, asm_specification,
+				    attributes);
+		  /* Any initialization must have been from a
+		     constant-expression.  */
+		  if (decl && TREE_CODE (decl) == VAR_DECL && initializer)
+		    DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
+		}
+	    }
+
+	  /* Reset PREFIX_ATTRIBUTES.  */
+	  while (attributes && TREE_CHAIN (attributes) != first_attribute)
+	    attributes = TREE_CHAIN (attributes);
+	  if (attributes)
+	    TREE_CHAIN (attributes) = NULL_TREE;
+
+	  /* If there is any qualification still in effect, clear it
+	     now; we will be starting fresh with the next declarator.  */
+	  parser->scope = NULL_TREE;
+	  parser->qualifying_scope = NULL_TREE;
+	  parser->object_scope = NULL_TREE;
+	  /* If it's a `,', then there are more declarators.  */
+	  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
+	    cp_lexer_consume_token (parser->lexer);
+	  /* If the next token isn't a `;', then we have a parse error.  */
+	  else if (cp_lexer_next_token_is_not (parser->lexer,
+					       CPP_SEMICOLON))
+	    {
+	      cp_parser_error (parser, "expected `;'");
+	      /* Skip tokens until we find a `;'.  */
+	      cp_parser_skip_to_end_of_statement (parser);
+
+	      break;
+	    }
+
+	  if (decl)
+	    {
+	      /* Add DECL to the list of members.  */
+	      if (!friend_p)
+		finish_member_declaration (decl);
+
+	      if (TREE_CODE (decl) == FUNCTION_DECL)
+		cp_parser_save_default_args (parser, decl);
+	    }
+	}
+    }
+
+  cp_parser_require (parser, CPP_SEMICOLON, "`;'");
+}
+
+/* Parse a pure-specifier.
+
+   pure-specifier:
+     = 0
+
+   Returns INTEGER_ZERO_NODE if a pure specifier is found.
+   Otherwise, ERROR_MARK_NODE is returned.  */
+
+static tree
+cp_parser_pure_specifier (cp_parser* parser)
+{
+  cp_token *token;
+
+  /* Look for the `=' token.  */
+  if (!cp_parser_require (parser, CPP_EQ, "`='"))
+    return error_mark_node;
+  /* Look for the `0' token.  */
+  token = cp_parser_require (parser, CPP_NUMBER, "`0'");
+  /* Unfortunately, this will accept `0L' and `0x00' as well.  We need
+     to get information from the lexer about how the number was
+     spelled in order to fix this problem.  */
+  if (!token || !integer_zerop (token->value))
+    return error_mark_node;
+
+  return integer_zero_node;
+}
+
+/* Parse a constant-initializer.
+
+   constant-initializer:
+     = constant-expression
+
+   Returns a representation of the constant-expression.  */
+
+static tree
+cp_parser_constant_initializer (cp_parser* parser)
+{
+  /* Look for the `=' token.  */
+  if (!cp_parser_require (parser, CPP_EQ, "`='"))
+    return error_mark_node;
+
+  /* It is invalid to write:
+
+       struct S { static const int i = { 7 }; };
+
+     */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
+    {
+      cp_parser_error (parser,
+		       "a brace-enclosed initializer is not allowed here");
+      /* Consume the opening brace.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Skip the initializer.  */
+      cp_parser_skip_to_closing_brace (parser);
+      /* Look for the trailing `}'.  */
+      cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
+      
+      return error_mark_node;
+    }
+
+  return cp_parser_constant_expression (parser, 
+					/*allow_non_constant=*/false,
+					NULL);
+}
+
+/* Derived classes [gram.class.derived] */
+
+/* Parse a base-clause.
+
+   base-clause:
+     : base-specifier-list  
+
+   base-specifier-list:
+     base-specifier
+     base-specifier-list , base-specifier
+
+   Returns a TREE_LIST representing the base-classes, in the order in
+   which they were declared.  The representation of each node is as
+   described by cp_parser_base_specifier.  
+
+   In the case that no bases are specified, this function will return
+   NULL_TREE, not ERROR_MARK_NODE.  */
+
+static tree
+cp_parser_base_clause (cp_parser* parser)
+{
+  tree bases = NULL_TREE;
+
+  /* Look for the `:' that begins the list.  */
+  cp_parser_require (parser, CPP_COLON, "`:'");
+
+  /* Scan the base-specifier-list.  */
+  while (true)
+    {
+      cp_token *token;
+      tree base;
+
+      /* Look for the base-specifier.  */
+      base = cp_parser_base_specifier (parser);
+      /* Add BASE to the front of the list.  */
+      if (base != error_mark_node)
+	{
+	  TREE_CHAIN (base) = bases;
+	  bases = base;
+	}
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If it's not a comma, then the list is complete.  */
+      if (token->type != CPP_COMMA)
+	break;
+      /* Consume the `,'.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  /* PARSER->SCOPE may still be non-NULL at this point, if the last
+     base class had a qualified name.  However, the next name that
+     appears is certainly not qualified.  */
+  parser->scope = NULL_TREE;
+  parser->qualifying_scope = NULL_TREE;
+  parser->object_scope = NULL_TREE;
+
+  return nreverse (bases);
+}
+
+/* Parse a base-specifier.
+
+   base-specifier:
+     :: [opt] nested-name-specifier [opt] class-name
+     virtual access-specifier [opt] :: [opt] nested-name-specifier
+       [opt] class-name
+     access-specifier virtual [opt] :: [opt] nested-name-specifier
+       [opt] class-name
+
+   Returns a TREE_LIST.  The TREE_PURPOSE will be one of
+   ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
+   indicate the specifiers provided.  The TREE_VALUE will be a TYPE
+   (or the ERROR_MARK_NODE) indicating the type that was specified.  */
+       
+static tree
+cp_parser_base_specifier (cp_parser* parser)
+{
+  cp_token *token;
+  bool done = false;
+  bool virtual_p = false;
+  bool duplicate_virtual_error_issued_p = false;
+  bool duplicate_access_error_issued_p = false;
+  bool class_scope_p, template_p;
+  tree access = access_default_node;
+  tree type;
+
+  /* Process the optional `virtual' and `access-specifier'.  */
+  while (!done)
+    {
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* Process `virtual'.  */
+      switch (token->keyword)
+	{
+	case RID_VIRTUAL:
+	  /* If `virtual' appears more than once, issue an error.  */
+	  if (virtual_p && !duplicate_virtual_error_issued_p)
+	    {
+	      cp_parser_error (parser,
+			       "`virtual' specified more than once in base-specified");
+	      duplicate_virtual_error_issued_p = true;
+	    }
+
+	  virtual_p = true;
+
+	  /* Consume the `virtual' token.  */
+	  cp_lexer_consume_token (parser->lexer);
+
+	  break;
+
+	case RID_PUBLIC:
+	case RID_PROTECTED:
+	case RID_PRIVATE:
+	  /* If more than one access specifier appears, issue an
+	     error.  */
+	  if (access != access_default_node
+	      && !duplicate_access_error_issued_p)
+	    {
+	      cp_parser_error (parser,
+			       "more than one access specifier in base-specified");
+	      duplicate_access_error_issued_p = true;
+	    }
+
+	  access = ridpointers[(int) token->keyword];
+
+	  /* Consume the access-specifier.  */
+	  cp_lexer_consume_token (parser->lexer);
+
+	  break;
+
+	default:
+	  done = true;
+	  break;
+	}
+    }
+  /* It is not uncommon to see programs mechanically, errouneously, use
+     the 'typename' keyword to denote (dependent) qualified types
+     as base classes.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
+    {
+      if (!processing_template_decl)
+	error ("keyword `typename' not allowed outside of templates");
+      else
+	error ("keyword `typename' not allowed in this context "
+	       "(the base class is implicitly a type)");
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  /* Look for the optional `::' operator.  */
+  cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
+  /* Look for the 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 pretend that we have seen the `typename' keyword at this
+     point.  */ 
+  cp_parser_nested_name_specifier_opt (parser,
+				       /*typename_keyword_p=*/true,
+				       /*check_dependency_p=*/true,
+				       /*type_p=*/true,
+				       /*is_declaration=*/true);
+  /* If the base class is given by a qualified name, assume that names
+     we see are type names or templates, as appropriate.  */
+  class_scope_p = (parser->scope && TYPE_P (parser->scope));
+  template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
+  
+  /* Finally, look for the class-name.  */
+  type = cp_parser_class_name (parser, 
+			       class_scope_p,
+			       template_p,
+			       /*type_p=*/true,
+			       /*check_dependency_p=*/true,
+			       /*class_head_p=*/false,
+			       /*is_declaration=*/true);
+
+  if (type == error_mark_node)
+    return error_mark_node;
+
+  return finish_base_specifier (TREE_TYPE (type), access, virtual_p);
+}
+
+/* Exception handling [gram.exception] */
+
+/* Parse an (optional) exception-specification.
+
+   exception-specification:
+     throw ( type-id-list [opt] )
+
+   Returns a TREE_LIST representing the exception-specification.  The
+   TREE_VALUE of each node is a type.  */
+
+static tree
+cp_parser_exception_specification_opt (cp_parser* parser)
+{
+  cp_token *token;
+  tree type_id_list;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If it's not `throw', then there's no exception-specification.  */
+  if (!cp_parser_is_keyword (token, RID_THROW))
+    return NULL_TREE;
+
+  /* Consume the `throw'.  */
+  cp_lexer_consume_token (parser->lexer);
+
+  /* Look for the `('.  */
+  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If it's not a `)', then there is a type-id-list.  */
+  if (token->type != CPP_CLOSE_PAREN)
+    {
+      const char *saved_message;
+
+      /* Types may not be defined in an exception-specification.  */
+      saved_message = parser->type_definition_forbidden_message;
+      parser->type_definition_forbidden_message
+	= "types may not be defined in an exception-specification";
+      /* Parse the type-id-list.  */
+      type_id_list = cp_parser_type_id_list (parser);
+      /* Restore the saved message.  */
+      parser->type_definition_forbidden_message = saved_message;
+    }
+  else
+    type_id_list = empty_except_spec;
+
+  /* Look for the `)'.  */
+  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+
+  return type_id_list;
+}
+
+/* Parse an (optional) type-id-list.
+
+   type-id-list:
+     type-id
+     type-id-list , type-id
+
+   Returns a TREE_LIST.  The TREE_VALUE of each node is a TYPE,
+   in the order that the types were presented.  */
+
+static tree
+cp_parser_type_id_list (cp_parser* parser)
+{
+  tree types = NULL_TREE;
+
+  while (true)
+    {
+      cp_token *token;
+      tree type;
+
+      /* Get the next type-id.  */
+      type = cp_parser_type_id (parser);
+      /* Add it to the list.  */
+      types = add_exception_specifier (types, type, /*complain=*/1);
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If it is not a `,', we are done.  */
+      if (token->type != CPP_COMMA)
+	break;
+      /* Consume the `,'.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  return nreverse (types);
+}
+
+/* Parse a try-block.
+
+   try-block:
+     try compound-statement handler-seq  */
+
+static tree
+cp_parser_try_block (cp_parser* parser)
+{
+  tree try_block;
+
+  cp_parser_require_keyword (parser, RID_TRY, "`try'");
+  try_block = begin_try_block ();
+  cp_parser_compound_statement (parser, false);
+  finish_try_block (try_block);
+  cp_parser_handler_seq (parser);
+  finish_handler_sequence (try_block);
+
+  return try_block;
+}
+
+/* Parse a function-try-block.
+
+   function-try-block:
+     try ctor-initializer [opt] function-body handler-seq  */
+
+static bool
+cp_parser_function_try_block (cp_parser* parser)
+{
+  tree try_block;
+  bool ctor_initializer_p;
+
+  /* Look for the `try' keyword.  */
+  if (!cp_parser_require_keyword (parser, RID_TRY, "`try'"))
+    return false;
+  /* Let the rest of the front-end know where we are.  */
+  try_block = begin_function_try_block ();
+  /* Parse the function-body.  */
+  ctor_initializer_p 
+    = cp_parser_ctor_initializer_opt_and_function_body (parser);
+  /* We're done with the `try' part.  */
+  finish_function_try_block (try_block);
+  /* Parse the handlers.  */
+  cp_parser_handler_seq (parser);
+  /* We're done with the handlers.  */
+  finish_function_handler_sequence (try_block);
+
+  return ctor_initializer_p;
+}
+
+/* Parse a handler-seq.
+
+   handler-seq:
+     handler handler-seq [opt]  */
+
+static void
+cp_parser_handler_seq (cp_parser* parser)
+{
+  while (true)
+    {
+      cp_token *token;
+
+      /* Parse the handler.  */
+      cp_parser_handler (parser);
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If it's not `catch' then there are no more handlers.  */
+      if (!cp_parser_is_keyword (token, RID_CATCH))
+	break;
+    }
+}
+
+/* Parse a handler.
+
+   handler:
+     catch ( exception-declaration ) compound-statement  */
+
+static void
+cp_parser_handler (cp_parser* parser)
+{
+  tree handler;
+  tree declaration;
+
+  cp_parser_require_keyword (parser, RID_CATCH, "`catch'");
+  handler = begin_handler ();
+  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+  declaration = cp_parser_exception_declaration (parser);
+  finish_handler_parms (declaration, handler);
+  cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+  cp_parser_compound_statement (parser, false);
+  finish_handler (handler);
+}
+
+/* Parse an exception-declaration.
+
+   exception-declaration:
+     type-specifier-seq declarator
+     type-specifier-seq abstract-declarator
+     type-specifier-seq
+     ...  
+
+   Returns a VAR_DECL for the declaration, or NULL_TREE if the
+   ellipsis variant is used.  */
+
+static tree
+cp_parser_exception_declaration (cp_parser* parser)
+{
+  tree type_specifiers;
+  tree declarator;
+  const char *saved_message;
+
+  /* If it's an ellipsis, it's easy to handle.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
+    {
+      /* Consume the `...' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      return NULL_TREE;
+    }
+
+  /* Types may not be defined in exception-declarations.  */
+  saved_message = parser->type_definition_forbidden_message;
+  parser->type_definition_forbidden_message
+    = "types may not be defined in exception-declarations";
+
+  /* Parse the type-specifier-seq.  */
+  type_specifiers = cp_parser_type_specifier_seq (parser);
+  /* If it's a `)', then there is no declarator.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
+    declarator = NULL_TREE;
+  else
+    declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
+				       /*ctor_dtor_or_conv_p=*/NULL,
+				       /*parenthesized_p=*/NULL);
+
+  /* Restore the saved message.  */
+  parser->type_definition_forbidden_message = saved_message;
+
+  return start_handler_parms (type_specifiers, declarator);
+}
+
+/* Parse a throw-expression. 
+
+   throw-expression:
+     throw assignment-expression [opt]
+
+   Returns a THROW_EXPR representing the throw-expression.  */
+
+static tree
+cp_parser_throw_expression (cp_parser* parser)
+{
+  tree expression;
+  cp_token* token;
+
+  cp_parser_require_keyword (parser, RID_THROW, "`throw'");
+  token = cp_lexer_peek_token (parser->lexer);
+  /* Figure out whether or not there is an assignment-expression
+     following the "throw" keyword.  */
+  if (token->type == CPP_COMMA
+      || token->type == CPP_SEMICOLON
+      || token->type == CPP_CLOSE_PAREN
+      || token->type == CPP_CLOSE_SQUARE
+      || token->type == CPP_CLOSE_BRACE
+      || token->type == CPP_COLON)
+    expression = NULL_TREE;
+  else
+    expression = cp_parser_assignment_expression (parser);
+
+  return build_throw (expression);
+}
+
+/* GNU Extensions */
+
+/* Parse an (optional) asm-specification.
+
+   asm-specification:
+     asm ( string-literal )
+
+   If the asm-specification is present, returns a STRING_CST
+   corresponding to the string-literal.  Otherwise, returns
+   NULL_TREE.  */
+
+static tree
+cp_parser_asm_specification_opt (cp_parser* parser)
+{
+  cp_token *token;
+  tree asm_specification;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If the next token isn't the `asm' keyword, then there's no 
+     asm-specification.  */
+  if (!cp_parser_is_keyword (token, RID_ASM))
+    return NULL_TREE;
+
+  /* Consume the `asm' token.  */
+  cp_lexer_consume_token (parser->lexer);
+  /* Look for the `('.  */
+  cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+
+  /* Look for the string-literal.  */
+  token = cp_parser_require (parser, CPP_STRING, "string-literal");
+  if (token)
+    asm_specification = token->value;
+  else
+    asm_specification = NULL_TREE;
+
+  /* Look for the `)'.  */
+  cp_parser_require (parser, CPP_CLOSE_PAREN, "`('");
+
+  return asm_specification;
+}
+
+/* Parse an asm-operand-list.  
+
+   asm-operand-list:
+     asm-operand
+     asm-operand-list , asm-operand
+     
+   asm-operand:
+     string-literal ( expression )  
+     [ string-literal ] string-literal ( expression )
+
+   Returns a TREE_LIST representing the operands.  The TREE_VALUE of
+   each node is the expression.  The TREE_PURPOSE is itself a
+   TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
+   string-literal (or NULL_TREE if not present) and whose TREE_VALUE
+   is a STRING_CST for the string literal before the parenthesis.  */
+
+static tree
+cp_parser_asm_operand_list (cp_parser* parser)
+{
+  tree asm_operands = NULL_TREE;
+
+  while (true)
+    {
+      tree string_literal;
+      tree expression;
+      tree name;
+      cp_token *token;
+      
+      if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)) 
+	{
+	  /* Consume the `[' token.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  /* Read the operand name.  */
+	  name = cp_parser_identifier (parser);
+	  if (name != error_mark_node) 
+	    name = build_string (IDENTIFIER_LENGTH (name),
+				 IDENTIFIER_POINTER (name));
+	  /* Look for the closing `]'.  */
+	  cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
+	}
+      else
+	name = NULL_TREE;
+      /* Look for the string-literal.  */
+      token = cp_parser_require (parser, CPP_STRING, "string-literal");
+      string_literal = token ? token->value : error_mark_node;
+      /* Look for the `('.  */
+      cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+      /* Parse the expression.  */
+      expression = cp_parser_expression (parser);
+      /* Look for the `)'.  */
+      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+      /* Add this operand to the list.  */
+      asm_operands = tree_cons (build_tree_list (name, string_literal),
+				expression, 
+				asm_operands);
+      /* If the next token is not a `,', there are no more 
+	 operands.  */
+      if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
+	break;
+      /* Consume the `,'.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  return nreverse (asm_operands);
+}
+
+/* Parse an asm-clobber-list.  
+
+   asm-clobber-list:
+     string-literal
+     asm-clobber-list , string-literal  
+
+   Returns a TREE_LIST, indicating the clobbers in the order that they
+   appeared.  The TREE_VALUE of each node is a STRING_CST.  */
+
+static tree
+cp_parser_asm_clobber_list (cp_parser* parser)
+{
+  tree clobbers = NULL_TREE;
+
+  while (true)
+    {
+      cp_token *token;
+      tree string_literal;
+
+      /* Look for the string literal.  */
+      token = cp_parser_require (parser, CPP_STRING, "string-literal");
+      string_literal = token ? token->value : error_mark_node;
+      /* Add it to the list.  */
+      clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
+      /* If the next token is not a `,', then the list is 
+	 complete.  */
+      if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
+	break;
+      /* Consume the `,' token.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  return clobbers;
+}
+
+/* Parse an (optional) series of attributes.
+
+   attributes:
+     attributes attribute
+
+   attribute:
+     __attribute__ (( attribute-list [opt] ))  
+
+   The return value is as for cp_parser_attribute_list.  */
+     
+static tree
+cp_parser_attributes_opt (cp_parser* parser)
+{
+  tree attributes = NULL_TREE;
+
+  while (true)
+    {
+      cp_token *token;
+      tree attribute_list;
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If it's not `__attribute__', then we're done.  */
+      if (token->keyword != RID_ATTRIBUTE)
+	break;
+
+      /* Consume the `__attribute__' keyword.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Look for the two `(' tokens.  */
+      cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+      cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      if (token->type != CPP_CLOSE_PAREN)
+	/* Parse the attribute-list.  */
+	attribute_list = cp_parser_attribute_list (parser);
+      else
+	/* If the next token is a `)', then there is no attribute
+	   list.  */
+	attribute_list = NULL;
+
+      /* Look for the two `)' tokens.  */
+      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+
+      /* Add these new attributes to the list.  */
+      attributes = chainon (attributes, attribute_list);
+    }
+
+  return attributes;
+}
+
+/* Parse an attribute-list.  
+
+   attribute-list:  
+     attribute 
+     attribute-list , attribute
+
+   attribute:
+     identifier     
+     identifier ( identifier )
+     identifier ( identifier , expression-list )
+     identifier ( expression-list ) 
+
+   Returns a TREE_LIST.  Each node corresponds to an attribute.  THe
+   TREE_PURPOSE of each node is the identifier indicating which
+   attribute is in use.  The TREE_VALUE represents the arguments, if
+   any.  */
+
+static tree
+cp_parser_attribute_list (cp_parser* parser)
+{
+  tree attribute_list = NULL_TREE;
+
+  while (true)
+    {
+      cp_token *token;
+      tree identifier;
+      tree attribute;
+
+      /* Look for the identifier.  We also allow keywords here; for
+	 example `__attribute__ ((const))' is legal.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      if (token->type != CPP_NAME 
+	  && token->type != CPP_KEYWORD)
+	return error_mark_node;
+      /* Consume the token.  */
+      token = cp_lexer_consume_token (parser->lexer);
+      
+      /* Save away the identifier that indicates which attribute this is.  */
+      identifier = token->value;
+      attribute = build_tree_list (identifier, NULL_TREE);
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If it's an `(', then parse the attribute arguments.  */
+      if (token->type == CPP_OPEN_PAREN)
+	{
+	  tree arguments;
+
+	  arguments = (cp_parser_parenthesized_expression_list 
+		       (parser, true, /*non_constant_p=*/NULL));
+	  /* Save the identifier and arguments away.  */
+	  TREE_VALUE (attribute) = arguments;
+	}
+
+      /* Add this attribute to the list.  */
+      TREE_CHAIN (attribute) = attribute_list;
+      attribute_list = attribute;
+
+      /* Now, look for more attributes.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If the next token isn't a `,', we're done.  */
+      if (token->type != CPP_COMMA)
+	break;
+
+      /* Consume the comma and keep going.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+
+  /* We built up the list in reverse order.  */
+  return nreverse (attribute_list);
+}
+
+/* Parse an optional `__extension__' keyword.  Returns TRUE if it is
+   present, and FALSE otherwise.  *SAVED_PEDANTIC is set to the
+   current value of the PEDANTIC flag, regardless of whether or not
+   the `__extension__' keyword is present.  The caller is responsible
+   for restoring the value of the PEDANTIC flag.  */
+
+static bool
+cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
+{
+  /* Save the old value of the PEDANTIC flag.  */
+  *saved_pedantic = pedantic;
+
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
+    {
+      /* Consume the `__extension__' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* We're not being pedantic while the `__extension__' keyword is
+	 in effect.  */
+      pedantic = 0;
+
+      return true;
+    }
+
+  return false;
+}
+
+/* Parse a label declaration.
+
+   label-declaration:
+     __label__ label-declarator-seq ;
+
+   label-declarator-seq:
+     identifier , label-declarator-seq
+     identifier  */
+
+static void
+cp_parser_label_declaration (cp_parser* parser)
+{
+  /* Look for the `__label__' keyword.  */
+  cp_parser_require_keyword (parser, RID_LABEL, "`__label__'");
+
+  while (true)
+    {
+      tree identifier;
+
+      /* Look for an identifier.  */
+      identifier = cp_parser_identifier (parser);
+      /* Declare it as a lobel.  */
+      finish_label_decl (identifier);
+      /* If the next token is a `;', stop.  */
+      if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
+	break;
+      /* Look for the `,' separating the label declarations.  */
+      cp_parser_require (parser, CPP_COMMA, "`,'");
+    }
+
+  /* Look for the final `;'.  */
+  cp_parser_require (parser, CPP_SEMICOLON, "`;'");
+}
+
+/* Support Functions */
+
+/* Looks up NAME in the current scope, as given by PARSER->SCOPE.
+   NAME should have one of the representations used for an
+   id-expression.  If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
+   is returned.  If PARSER->SCOPE is a dependent type, then a
+   SCOPE_REF is returned.
+
+   If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
+   returned; the name was already resolved when the TEMPLATE_ID_EXPR
+   was formed.  Abstractly, such entities should not be passed to this
+   function, because they do not need to be looked up, but it is
+   simpler to check for this special case here, rather than at the
+   call-sites.
+
+   In cases not explicitly covered above, this function returns a
+   DECL, OVERLOAD, or baselink representing the result of the lookup.
+   If there was no entity with the indicated NAME, the ERROR_MARK_NODE
+   is returned.
+
+   If IS_TYPE is TRUE, bindings that do not refer to types are
+   ignored.
+
+   If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
+   ignored.
+
+   If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
+   are ignored.
+
+   If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
+   types.  */
+
+static tree
+cp_parser_lookup_name (cp_parser *parser, tree name, 
+		       bool is_type, bool is_template, bool is_namespace,
+		       bool check_dependency)
+{
+  tree decl;
+  tree object_type = parser->context->object_type;
+
+  /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
+     no longer valid.  Note that if we are parsing tentatively, and
+     the parse fails, OBJECT_TYPE will be automatically restored.  */
+  parser->context->object_type = NULL_TREE;
+
+  if (name == error_mark_node)
+    return error_mark_node;
+
+  /* A template-id has already been resolved; there is no lookup to
+     do.  */
+  if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
+    return name;
+  if (BASELINK_P (name))
+    {
+      my_friendly_assert ((TREE_CODE (BASELINK_FUNCTIONS (name))
+			   == TEMPLATE_ID_EXPR),
+			  20020909);
+      return name;
+    }
+
+  /* A BIT_NOT_EXPR is used to represent a destructor.  By this point,
+     it should already have been checked to make sure that the name
+     used matches the type being destroyed.  */
+  if (TREE_CODE (name) == BIT_NOT_EXPR)
+    {
+      tree type;
+
+      /* Figure out to which type this destructor applies.  */
+      if (parser->scope)
+	type = parser->scope;
+      else if (object_type)
+	type = object_type;
+      else
+	type = current_class_type;
+      /* If that's not a class type, there is no destructor.  */
+      if (!type || !CLASS_TYPE_P (type))
+	return error_mark_node;
+      if (!CLASSTYPE_DESTRUCTORS (type))
+	  return error_mark_node;
+      /* If it was a class type, return the destructor.  */
+      return CLASSTYPE_DESTRUCTORS (type);
+    }
+
+  /* By this point, the NAME should be an ordinary identifier.  If
+     the id-expression was a qualified name, the qualifying scope is
+     stored in PARSER->SCOPE at this point.  */
+  my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE,
+		      20000619);
+  
+  /* Perform the lookup.  */
+  if (parser->scope)
+    { 
+      bool dependent_p;
+
+      if (parser->scope == error_mark_node)
+	return error_mark_node;
+
+      /* If the SCOPE is dependent, the lookup must be deferred until
+	 the template is instantiated -- unless we are explicitly
+	 looking up names in uninstantiated templates.  Even then, we
+	 cannot look up the name if the scope is not a class type; it
+	 might, for example, be a template type parameter.  */
+      dependent_p = (TYPE_P (parser->scope)
+		     && !(parser->in_declarator_p
+			  && currently_open_class (parser->scope))
+		     && dependent_type_p (parser->scope));
+      if ((check_dependency || !CLASS_TYPE_P (parser->scope))
+	   && dependent_p)
+	{
+	  if (is_type)
+	    /* The resolution to Core Issue 180 says that `struct A::B'
+	       should be considered a type-name, even if `A' is
+	       dependent.  */
+	    decl = TYPE_NAME (make_typename_type (parser->scope,
+						  name,
+						  /*complain=*/1));
+	  else if (is_template)
+	    decl = make_unbound_class_template (parser->scope,
+						name,
+						/*complain=*/1);
+	  else
+	    decl = build_nt (SCOPE_REF, parser->scope, name);
+	}
+      else
+	{
+	  bool pop_p = false;
+
+	  /* If PARSER->SCOPE is a dependent type, then it must be a
+	     class type, and we must not be checking dependencies;
+	     otherwise, we would have processed this lookup above.  So
+	     that PARSER->SCOPE is not considered a dependent base by
+	     lookup_member, we must enter the scope here.  */
+	  if (dependent_p)
+	    pop_p = push_scope (parser->scope);
+	  /* If the PARSER->SCOPE is a a template specialization, it
+	     may be instantiated during name lookup.  In that case,
+	     errors may be issued.  Even if we rollback the current
+	     tentative parse, those errors are valid.  */
+	  decl = lookup_qualified_name (parser->scope, name, is_type,
+					/*complain=*/true);
+	  if (pop_p)
+	    pop_scope (parser->scope);
+	}
+      parser->qualifying_scope = parser->scope;
+      parser->object_scope = NULL_TREE;
+    }
+  else if (object_type)
+    {
+      tree object_decl = NULL_TREE;
+      /* Look up the name in the scope of the OBJECT_TYPE, unless the
+	 OBJECT_TYPE is not a class.  */
+      if (CLASS_TYPE_P (object_type))
+	/* If the OBJECT_TYPE is a template specialization, it may
+	   be instantiated during name lookup.  In that case, errors
+	   may be issued.  Even if we rollback the current tentative
+	   parse, those errors are valid.  */
+	object_decl = lookup_member (object_type,
+				     name,
+				     /*protect=*/0, is_type);
+      /* Look it up in the enclosing context, too.  */
+      decl = lookup_name_real (name, is_type, /*nonclass=*/0, 
+			       is_namespace,
+			       /*flags=*/0);
+      parser->object_scope = object_type;
+      parser->qualifying_scope = NULL_TREE;
+      if (object_decl)
+	decl = object_decl;
+    }
+  else
+    {
+      decl = lookup_name_real (name, is_type, /*nonclass=*/0, 
+			       is_namespace,
+			       /*flags=*/0);
+      parser->qualifying_scope = NULL_TREE;
+      parser->object_scope = NULL_TREE;
+    }
+
+  /* If the lookup failed, let our caller know.  */
+  if (!decl 
+      || decl == error_mark_node
+      || (TREE_CODE (decl) == FUNCTION_DECL 
+	  && DECL_ANTICIPATED (decl)))
+    return error_mark_node;
+
+  /* If it's a TREE_LIST, the result of the lookup was ambiguous.  */
+  if (TREE_CODE (decl) == TREE_LIST)
+    {
+      /* The error message we have to print is too complicated for
+	 cp_parser_error, so we incorporate its actions directly.  */
+      if (!cp_parser_simulate_error (parser))
+	{
+	  error ("reference to `%D' is ambiguous", name);
+	  print_candidates (decl);
+	}
+      return error_mark_node;
+    }
+
+  my_friendly_assert (DECL_P (decl) 
+		      || TREE_CODE (decl) == OVERLOAD
+		      || TREE_CODE (decl) == SCOPE_REF
+		      || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
+		      || BASELINK_P (decl),
+		      20000619);
+
+  /* If we have resolved the name of a member declaration, check to
+     see if the declaration is accessible.  When the name resolves to
+     set of overloaded functions, accessibility is checked when
+     overload resolution is done.  
+
+     During an explicit instantiation, access is not checked at all,
+     as per [temp.explicit].  */
+  if (DECL_P (decl))
+    check_accessibility_of_qualified_id (decl, object_type, parser->scope);
+
+  return decl;
+}
+
+/* Like cp_parser_lookup_name, but for use in the typical case where
+   CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
+   IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE.  */
+
+static tree
+cp_parser_lookup_name_simple (cp_parser* parser, tree name)
+{
+  return cp_parser_lookup_name (parser, name, 
+				/*is_type=*/false,
+				/*is_template=*/false,
+				/*is_namespace=*/false,
+				/*check_dependency=*/true);
+}
+
+/* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
+   the current context, return the TYPE_DECL.  If TAG_NAME_P is
+   true, the DECL indicates the class being defined in a class-head,
+   or declared in an elaborated-type-specifier.
+
+   Otherwise, return DECL.  */
+
+static tree
+cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
+{
+  /* If the TEMPLATE_DECL is being declared as part of a class-head,
+     the translation from TEMPLATE_DECL to TYPE_DECL occurs:
+
+       struct A { 
+         template <typename T> struct B;
+       };
+
+       template <typename T> struct A::B {}; 
+   
+     Similarly, in a elaborated-type-specifier:
+
+       namespace N { struct X{}; }
+
+       struct A {
+         template <typename T> friend struct N::X;
+       };
+
+     However, if the DECL refers to a class type, and we are in
+     the scope of the class, then the name lookup automatically
+     finds the TYPE_DECL created by build_self_reference rather
+     than a TEMPLATE_DECL.  For example, in:
+
+       template <class T> struct S {
+         S s;
+       };
+
+     there is no need to handle such case.  */
+
+  if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
+    return DECL_TEMPLATE_RESULT (decl);
+
+  return decl;
+}
+
+/* If too many, or too few, template-parameter lists apply to the
+   declarator, issue an error message.  Returns TRUE if all went well,
+   and FALSE otherwise.  */
+
+static bool
+cp_parser_check_declarator_template_parameters (cp_parser* parser, 
+                                                tree declarator)
+{
+  unsigned num_templates;
+
+  /* We haven't seen any classes that involve template parameters yet.  */
+  num_templates = 0;
+
+  switch (TREE_CODE (declarator))
+    {
+    case CALL_EXPR:
+    case ARRAY_REF:
+    case INDIRECT_REF:
+    case ADDR_EXPR:
+      {
+	tree main_declarator = TREE_OPERAND (declarator, 0);
+	return
+	  cp_parser_check_declarator_template_parameters (parser, 
+							  main_declarator);
+      }
+
+    case SCOPE_REF:
+      {
+	tree scope;
+	tree member;
+
+	scope = TREE_OPERAND (declarator, 0);
+	member = TREE_OPERAND (declarator, 1);
+
+	/* If this is a pointer-to-member, then we are not interested
+	   in the SCOPE, because it does not qualify the thing that is
+	   being declared.  */
+	if (TREE_CODE (member) == INDIRECT_REF)
+	  return (cp_parser_check_declarator_template_parameters
+		  (parser, member));
+
+	while (scope && CLASS_TYPE_P (scope))
+	  {
+	    /* You're supposed to have one `template <...>'
+	       for every template class, but you don't need one
+	       for a full specialization.  For example:
+	       
+	       template <class T> struct S{};
+	       template <> struct S<int> { void f(); };
+	       void S<int>::f () {}
+	       
+	       is correct; there shouldn't be a `template <>' for
+	       the definition of `S<int>::f'.  */
+	    if (CLASSTYPE_TEMPLATE_INFO (scope)
+		&& (CLASSTYPE_TEMPLATE_INSTANTIATION (scope)
+		    || uses_template_parms (CLASSTYPE_TI_ARGS (scope)))
+		&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)))
+	      ++num_templates;
+
+	    scope = TYPE_CONTEXT (scope);
+	  }
+      }
+
+      /* Fall through.  */
+
+    default:
+      /* If the DECLARATOR has the form `X<y>' then it uses one
+	 additional level of template parameters.  */
+      if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
+	++num_templates;
+
+      return cp_parser_check_template_parameters (parser, 
+						  num_templates);
+    }
+}
+
+/* NUM_TEMPLATES were used in the current declaration.  If that is
+   invalid, return FALSE and issue an error messages.  Otherwise,
+   return TRUE.  */
+
+static bool
+cp_parser_check_template_parameters (cp_parser* parser,
+                                     unsigned num_templates)
+{
+  /* If there are more template classes than parameter lists, we have
+     something like:
+     
+       template <class T> void S<T>::R<T>::f ();  */
+  if (parser->num_template_parameter_lists < num_templates)
+    {
+      error ("too few template-parameter-lists");
+      return false;
+    }
+  /* If there are the same number of template classes and parameter
+     lists, that's OK.  */
+  if (parser->num_template_parameter_lists == num_templates)
+    return true;
+  /* If there are more, but only one more, then we are referring to a
+     member template.  That's OK too.  */
+  if (parser->num_template_parameter_lists == num_templates + 1)
+      return true;
+  /* Otherwise, there are too many template parameter lists.  We have
+     something like:
+
+     template <class T> template <class U> void S::f();  */
+  error ("too many template-parameter-lists");
+  return false;
+}
+
+/* Parse a binary-expression of the general form:
+
+   binary-expression:
+     <expr>
+     binary-expression <token> <expr>
+
+   The TOKEN_TREE_MAP maps <token> types to <expr> codes.  FN is used
+   to parser the <expr>s.  If the first production is used, then the
+   value returned by FN is returned directly.  Otherwise, a node with
+   the indicated EXPR_TYPE is returned, with operands corresponding to
+   the two sub-expressions.  */
+
+static tree
+cp_parser_binary_expression (cp_parser* parser, 
+                             const cp_parser_token_tree_map token_tree_map, 
+                             cp_parser_expression_fn fn)
+{
+  tree lhs;
+
+  /* Parse the first expression.  */
+  lhs = (*fn) (parser);
+  /* Now, look for more expressions.  */
+  while (true)
+    {
+      cp_token *token;
+      const cp_parser_token_tree_map_node *map_node;
+      tree rhs;
+
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If the token is `>', and that's not an operator at the
+	 moment, then we're done.  */
+      if (token->type == CPP_GREATER
+	  && !parser->greater_than_is_operator_p)
+	break;
+      /* If we find one of the tokens we want, build the corresponding
+	 tree representation.  */
+      for (map_node = token_tree_map; 
+	   map_node->token_type != CPP_EOF;
+	   ++map_node)
+	if (map_node->token_type == token->type)
+	  {
+	    /* Assume that an overloaded operator will not be used.  */
+	    bool overloaded_p = false;
+
+	    /* Consume the operator token.  */
+	    cp_lexer_consume_token (parser->lexer);
+	    /* Parse the right-hand side of the expression.  */
+	    rhs = (*fn) (parser);
+	    /* Build the binary tree node.  */
+	    lhs = build_x_binary_op (map_node->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")))
+	      lhs = error_mark_node;
+	    break;
+	  }
+
+      /* If the token wasn't one of the ones we want, we're done.  */
+      if (map_node->token_type == CPP_EOF)
+	break;
+    }
+
+  return lhs;
+}
+
+/* Parse an optional `::' token indicating that the following name is
+   from the global namespace.  If so, PARSER->SCOPE is set to the
+   GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
+   unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
+   Returns the new value of PARSER->SCOPE, if the `::' token is
+   present, and NULL_TREE otherwise.  */
+
+static tree
+cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
+{
+  cp_token *token;
+
+  /* Peek at the next token.  */
+  token = cp_lexer_peek_token (parser->lexer);
+  /* If we're looking at a `::' token then we're starting from the
+     global namespace, not our current location.  */
+  if (token->type == CPP_SCOPE)
+    {
+      /* Consume the `::' token.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Set the SCOPE so that we know where to start the lookup.  */
+      parser->scope = global_namespace;
+      parser->qualifying_scope = global_namespace;
+      parser->object_scope = NULL_TREE;
+
+      return parser->scope;
+    }
+  else if (!current_scope_valid_p)
+    {
+      parser->scope = NULL_TREE;
+      parser->qualifying_scope = NULL_TREE;
+      parser->object_scope = NULL_TREE;
+    }
+
+  return NULL_TREE;
+}
+
+/* Returns TRUE if the upcoming token sequence is the start of a
+   constructor declarator.  If FRIEND_P is true, the declarator is
+   preceded by the `friend' specifier.  */
+
+static bool
+cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p)
+{
+  bool constructor_p;
+  tree type_decl = NULL_TREE;
+  bool nested_name_p;
+  cp_token *next_token;
+
+  /* The common case is that this is not a constructor declarator, so
+     try to avoid doing lots of work if at all possible.  It's not
+     valid declare a constructor at function scope.  */
+  if (at_function_scope_p ())
+    return false;
+  /* And only certain tokens can begin a constructor declarator.  */
+  next_token = cp_lexer_peek_token (parser->lexer);
+  if (next_token->type != CPP_NAME
+      && next_token->type != CPP_SCOPE
+      && next_token->type != CPP_NESTED_NAME_SPECIFIER
+      && next_token->type != CPP_TEMPLATE_ID)
+    return false;
+
+  /* Parse tentatively; we are going to roll back all of the tokens
+     consumed here.  */
+  cp_parser_parse_tentatively (parser);
+  /* Assume that we are looking at a constructor declarator.  */
+  constructor_p = true;
+
+  /* Look for the optional `::' operator.  */
+  cp_parser_global_scope_opt (parser,
+			      /*current_scope_valid_p=*/false);
+  /* Look for the nested-name-specifier.  */
+  nested_name_p 
+    = (cp_parser_nested_name_specifier_opt (parser,
+					    /*typename_keyword_p=*/false,
+					    /*check_dependency_p=*/false,
+					    /*type_p=*/false,
+					    /*is_declaration=*/false)
+       != NULL_TREE);
+  /* Outside of a class-specifier, there must be a
+     nested-name-specifier.  */
+  if (!nested_name_p && 
+      (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type)
+       || friend_p))
+    constructor_p = false;
+  /* If we still think that this might be a constructor-declarator,
+     look for a class-name.  */
+  if (constructor_p)
+    {
+      /* If we have:
+
+	   template <typename T> struct S { S(); };
+	   template <typename T> S<T>::S ();
+
+	 we must recognize that the nested `S' names a class.
+	 Similarly, for:
+
+	   template <typename T> S<T>::S<T> ();
+
+	 we must recognize that the nested `S' names a template.  */
+      type_decl = cp_parser_class_name (parser,
+					/*typename_keyword_p=*/false,
+					/*template_keyword_p=*/false,
+					/*type_p=*/false,
+					/*check_dependency_p=*/false,
+					/*class_head_p=*/false,
+					/*is_declaration=*/false);
+      /* If there was no class-name, then this is not a constructor.  */
+      constructor_p = !cp_parser_error_occurred (parser);
+    }
+
+  /* If we're still considering a constructor, we have to see a `(',
+     to begin the parameter-declaration-clause, followed by either a
+     `)', an `...', or a decl-specifier.  We need to check for a
+     type-specifier to avoid being fooled into thinking that:
+
+       S::S (f) (int);
+
+     is a constructor.  (It is actually a function named `f' that
+     takes one parameter (of type `int') and returns a value of type
+     `S::S'.  */
+  if (constructor_p 
+      && cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
+    {
+      if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
+	  && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
+	  /* A parameter declaration begins with a decl-specifier,
+	     which is either the "attribute" keyword, a storage class
+	     specifier, or (usually) a type-specifier.  */
+	  && !cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE)
+	  && !cp_parser_storage_class_specifier_opt (parser))
+	{
+	  tree type;
+	  bool pop_p = false;
+	  unsigned saved_num_template_parameter_lists;
+
+	  /* Names appearing in the type-specifier should be looked up
+	     in the scope of the class.  */
+	  if (current_class_type)
+	    type = NULL_TREE;
+	  else
+	    {
+	      type = TREE_TYPE (type_decl);
+	      if (TREE_CODE (type) == TYPENAME_TYPE)
+		{
+		  type = resolve_typename_type (type, 
+						/*only_current_p=*/false);
+		  if (type == error_mark_node)
+		    {
+		      cp_parser_abort_tentative_parse (parser);
+		      return false;
+		    }
+		}
+	      pop_p = push_scope (type);
+	    }
+
+	  /* Inside the constructor parameter list, surrounding
+	     template-parameter-lists do not apply.  */
+	  saved_num_template_parameter_lists
+	    = parser->num_template_parameter_lists;
+	  parser->num_template_parameter_lists = 0;
+
+	  /* Look for the type-specifier.  */
+	  cp_parser_type_specifier (parser,
+				    CP_PARSER_FLAGS_NONE,
+				    /*is_friend=*/false,
+				    /*is_declarator=*/true,
+				    /*declares_class_or_enum=*/NULL,
+				    /*is_cv_qualifier=*/NULL);
+
+	  parser->num_template_parameter_lists
+	    = saved_num_template_parameter_lists;
+
+	  /* Leave the scope of the class.  */
+	  if (pop_p)
+	    pop_scope (type);
+
+	  constructor_p = !cp_parser_error_occurred (parser);
+	}
+    }
+  else
+    constructor_p = false;
+  /* We did not really want to consume any tokens.  */
+  cp_parser_abort_tentative_parse (parser);
+
+  return constructor_p;
+}
+
+/* Parse the definition of the function given by the DECL_SPECIFIERS,
+   ATTRIBUTES, and DECLARATOR.  The access checks have been deferred;
+   they must be performed once we are in the scope of the function.
+
+   Returns the function defined.  */
+
+static tree
+cp_parser_function_definition_from_specifiers_and_declarator
+  (cp_parser* parser,
+   tree decl_specifiers,
+   tree attributes,
+   tree declarator)
+{
+  tree fn;
+  bool success_p;
+
+  /* Begin the function-definition.  */
+  success_p = begin_function_definition (decl_specifiers, 
+					 attributes, 
+					 declarator);
+
+  /* If there were names looked up in the decl-specifier-seq that we
+     did not check, check them now.  We must wait until we are in the
+     scope of the function to perform the checks, since the function
+     might be a friend.  */
+  perform_deferred_access_checks ();
+
+  if (!success_p)
+    {
+      /* If begin_function_definition didn't like the definition, skip
+	 the entire function.  */
+      error ("invalid function declaration");
+      cp_parser_skip_to_end_of_block_or_statement (parser);
+      fn = error_mark_node;
+    }
+  else
+    fn = cp_parser_function_definition_after_declarator (parser,
+							 /*inline_p=*/false);
+
+  return fn;
+}
+
+/* Parse the part of a function-definition that follows the
+   declarator.  INLINE_P is TRUE iff this function is an inline
+   function defined with a class-specifier.
+
+   Returns the function defined.  */
+
+static tree 
+cp_parser_function_definition_after_declarator (cp_parser* parser, 
+						bool inline_p)
+{
+  tree fn;
+  bool ctor_initializer_p = false;
+  bool saved_in_unbraced_linkage_specification_p;
+  unsigned saved_num_template_parameter_lists;
+
+  /* If the next token is `return', then the code may be trying to
+     make use of the "named return value" extension that G++ used to
+     support.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
+    {
+      /* Consume the `return' keyword.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Look for the identifier that indicates what value is to be
+	 returned.  */
+      cp_parser_identifier (parser);
+      /* Issue an error message.  */
+      error ("named return values are no longer supported");
+      /* Skip tokens until we reach the start of the function body.  */
+      while (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
+	     && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
+	cp_lexer_consume_token (parser->lexer);
+    }
+  /* The `extern' in `extern "C" void f () { ... }' does not apply to
+     anything declared inside `f'.  */
+  saved_in_unbraced_linkage_specification_p 
+    = parser->in_unbraced_linkage_specification_p;
+  parser->in_unbraced_linkage_specification_p = false;
+  /* Inside the function, surrounding template-parameter-lists do not
+     apply.  */
+  saved_num_template_parameter_lists 
+    = parser->num_template_parameter_lists; 
+  parser->num_template_parameter_lists = 0;
+  /* If the next token is `try', then we are looking at a
+     function-try-block.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
+    ctor_initializer_p = cp_parser_function_try_block (parser);
+  /* A function-try-block includes the function-body, so we only do
+     this next part if we're not processing a function-try-block.  */
+  else
+    ctor_initializer_p 
+      = cp_parser_ctor_initializer_opt_and_function_body (parser);
+
+  /* Finish the function.  */
+  fn = finish_function ((ctor_initializer_p ? 1 : 0) | 
+			(inline_p ? 2 : 0));
+  /* Generate code for it, if necessary.  */
+  expand_or_defer_fn (fn);
+  /* Restore the saved values.  */
+  parser->in_unbraced_linkage_specification_p 
+    = saved_in_unbraced_linkage_specification_p;
+  parser->num_template_parameter_lists 
+    = saved_num_template_parameter_lists;
+
+  return fn;
+}
+
+/* Parse a template-declaration, assuming that the `export' (and
+   `extern') keywords, if present, has already been scanned.  MEMBER_P
+   is as for cp_parser_template_declaration.  */
+
+static void
+cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
+{
+  tree decl = NULL_TREE;
+  tree parameter_list;
+  bool friend_p = false;
+
+  /* Look for the `template' keyword.  */
+  if (!cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'"))
+    return;
+      
+  /* And the `<'.  */
+  if (!cp_parser_require (parser, CPP_LESS, "`<'"))
+    return;
+      
+  /* If the next token is `>', then we have an invalid
+     specialization.  Rather than complain about an invalid template
+     parameter, issue an error message here.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
+    {
+      cp_parser_error (parser, "invalid explicit specialization");
+      begin_specialization ();
+      parameter_list = NULL_TREE;
+    }
+  else
+    {
+      /* Parse the template parameters.  */
+      begin_template_parm_list ();
+      parameter_list = cp_parser_template_parameter_list (parser);
+      parameter_list = end_template_parm_list (parameter_list);
+    }
+
+  /* Look for the `>'.  */
+  cp_parser_skip_until_found (parser, CPP_GREATER, "`>'");
+  /* We just processed one more parameter list.  */
+  ++parser->num_template_parameter_lists;
+  /* If the next token is `template', there are more template
+     parameters.  */
+  if (cp_lexer_next_token_is_keyword (parser->lexer, 
+				      RID_TEMPLATE))
+    cp_parser_template_declaration_after_export (parser, member_p);
+  else
+    {
+      decl = cp_parser_single_declaration (parser,
+					   member_p,
+					   &friend_p);
+
+      /* If this is a member template declaration, let the front
+	 end know.  */
+      if (member_p && !friend_p && decl)
+	{
+	  if (TREE_CODE (decl) == TYPE_DECL)
+	    cp_parser_check_access_in_redeclaration (decl);
+
+	  decl = finish_member_template_decl (decl);
+	}
+      else if (friend_p && decl && TREE_CODE (decl) == TYPE_DECL)
+	make_friend_class (current_class_type, TREE_TYPE (decl),
+			   /*complain=*/true);
+    }
+  /* We are done with the current parameter list.  */
+  --parser->num_template_parameter_lists;
+
+  /* Finish up.  */
+  finish_template_decl (parameter_list);
+
+  /* Register member declarations.  */
+  if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
+    finish_member_declaration (decl);
+
+  /* If DECL is a function template, we must return to parse it later.
+     (Even though there is no definition, there might be default
+     arguments that need handling.)  */
+  if (member_p && decl 
+      && (TREE_CODE (decl) == FUNCTION_DECL
+	  || DECL_FUNCTION_TEMPLATE_P (decl)))
+    TREE_VALUE (parser->unparsed_functions_queues)
+      = tree_cons (NULL_TREE, decl, 
+		   TREE_VALUE (parser->unparsed_functions_queues));
+}
+
+/* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
+   `function-definition' sequence.  MEMBER_P is true, this declaration
+   appears in a class scope.
+
+   Returns the DECL for the declared entity.  If FRIEND_P is non-NULL,
+   *FRIEND_P is set to TRUE iff the declaration is a friend.  */
+
+static tree
+cp_parser_single_declaration (cp_parser* parser, 
+			      bool member_p,
+			      bool* friend_p)
+{
+  int declares_class_or_enum;
+  tree decl = NULL_TREE;
+  tree decl_specifiers;
+  tree attributes;
+  bool function_definition_p = false;
+
+  /* Defer access checks until we know what is being declared.  */
+  push_deferring_access_checks (dk_deferred);
+
+  /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
+     alternative.  */
+  decl_specifiers 
+    = cp_parser_decl_specifier_seq (parser,
+				    CP_PARSER_FLAGS_OPTIONAL,
+				    &attributes,
+				    &declares_class_or_enum);
+  if (friend_p)
+    *friend_p = cp_parser_friend_p (decl_specifiers);
+  /* Gather up the access checks that occurred the
+     decl-specifier-seq.  */
+  stop_deferring_access_checks ();
+
+  /* Check for the declaration of a template class.  */
+  if (declares_class_or_enum)
+    {
+      if (cp_parser_declares_only_class_p (parser))
+	{
+	  decl = shadow_tag (decl_specifiers);
+	  if (decl)
+	    decl = TYPE_NAME (decl);
+	  else
+	    decl = error_mark_node;
+	}
+    }
+  else
+    decl = NULL_TREE;
+  /* If it's not a template class, try for a template function.  If
+     the next token is a `;', then this declaration does not declare
+     anything.  But, if there were errors in the decl-specifiers, then
+     the error might well have come from an attempted class-specifier.
+     In that case, there's no need to warn about a missing declarator.  */
+  if (!decl
+      && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
+	  || !value_member (error_mark_node, decl_specifiers)))
+    decl = cp_parser_init_declarator (parser, 
+				      decl_specifiers,
+				      attributes,
+				      /*function_definition_allowed_p=*/true,
+				      member_p,
+				      declares_class_or_enum,
+				      &function_definition_p);
+
+  pop_deferring_access_checks ();
+
+  /* Clear any current qualification; whatever comes next is the start
+     of something new.  */
+  parser->scope = NULL_TREE;
+  parser->qualifying_scope = NULL_TREE;
+  parser->object_scope = NULL_TREE;
+  /* Look for a trailing `;' after the declaration.  */
+  if (!function_definition_p
+      && !cp_parser_require (parser, CPP_SEMICOLON, "`;'"))
+    cp_parser_skip_to_end_of_block_or_statement (parser);
+
+  return decl;
+}
+
+/* Parse a cast-expression that is not the operand of a unary "&".  */
+
+static tree
+cp_parser_simple_cast_expression (cp_parser *parser)
+{
+  return cp_parser_cast_expression (parser, /*address_p=*/false);
+}
+
+/* Parse a functional cast to TYPE.  Returns an expression
+   representing the cast.  */
+
+static tree
+cp_parser_functional_cast (cp_parser* parser, tree type)
+{
+  tree expression_list;
+  tree cast;
+
+  expression_list
+    = cp_parser_parenthesized_expression_list (parser, false,
+					       /*non_constant_p=*/NULL);
+
+  cast = build_functional_cast (type, expression_list);
+  /* [expr.const]/1: In an integral constant expression "only type
+     conversions to integral or enumeration type can be used".  */
+  if (cast != error_mark_node && !type_dependent_expression_p (type) 
+      && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (type)))
+    {
+      if (cp_parser_non_integral_constant_expression 
+	  (parser, "a call to a constructor"))
+	return error_mark_node;
+    }
+  return cast;
+}
+
+/* Save the tokens that make up the body of a member function defined
+   in a class-specifier.  The DECL_SPECIFIERS and DECLARATOR have
+   already been parsed.  The ATTRIBUTES are any GNU "__attribute__"
+   specifiers applied to the declaration.  Returns the FUNCTION_DECL
+   for the member function.  */
+
+static tree
+cp_parser_save_member_function_body (cp_parser* parser,
+				     tree decl_specifiers,
+				     tree declarator,
+				     tree attributes)
+{
+  cp_token_cache *cache;
+  tree fn;
+
+  /* Create the function-declaration.  */
+  fn = start_method (decl_specifiers, declarator, attributes);
+  /* If something went badly wrong, bail out now.  */
+  if (fn == error_mark_node)
+    {
+      /* If there's a function-body, skip it.  */
+      if (cp_parser_token_starts_function_definition_p 
+	  (cp_lexer_peek_token (parser->lexer)))
+	cp_parser_skip_to_end_of_block_or_statement (parser);
+      return error_mark_node;
+    }
+
+  /* Remember it, if there default args to post process.  */
+  cp_parser_save_default_args (parser, fn);
+
+  /* Create a token cache.  */
+  cache = cp_token_cache_new ();
+  /* Save away the tokens that make up the body of the 
+     function.  */
+  cp_parser_cache_group (parser, cache, CPP_CLOSE_BRACE, /*depth=*/0);
+  /* Handle function try blocks.  */
+  while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
+    cp_parser_cache_group (parser, cache, CPP_CLOSE_BRACE, /*depth=*/0);
+
+  /* Save away the inline definition; we will process it when the
+     class is complete.  */
+  DECL_PENDING_INLINE_INFO (fn) = cache;
+  DECL_PENDING_INLINE_P (fn) = 1;
+
+  /* We need to know that this was defined in the class, so that
+     friend templates are handled correctly.  */
+  DECL_INITIALIZED_IN_CLASS_P (fn) = 1;
+
+  /* We're done with the inline definition.  */
+  finish_method (fn);
+
+  /* Add FN to the queue of functions to be parsed later.  */
+  TREE_VALUE (parser->unparsed_functions_queues)
+    = tree_cons (NULL_TREE, fn, 
+		 TREE_VALUE (parser->unparsed_functions_queues));
+
+  return fn;
+}
+
+/* Parse a template-argument-list, as well as the trailing ">" (but
+   not the opening ">").  See cp_parser_template_argument_list for the
+   return value.  */
+
+static tree
+cp_parser_enclosed_template_argument_list (cp_parser* parser)
+{
+  tree arguments;
+  tree saved_scope;
+  tree saved_qualifying_scope;
+  tree saved_object_scope;
+  bool saved_greater_than_is_operator_p;
+
+  /* [temp.names]
+
+     When parsing a template-id, the first non-nested `>' is taken as
+     the end of the template-argument-list rather than a greater-than
+     operator.  */
+  saved_greater_than_is_operator_p 
+    = parser->greater_than_is_operator_p;
+  parser->greater_than_is_operator_p = false;
+  /* Parsing the argument list may modify SCOPE, so we save it
+     here.  */
+  saved_scope = parser->scope;
+  saved_qualifying_scope = parser->qualifying_scope;
+  saved_object_scope = parser->object_scope;
+  /* Parse the template-argument-list itself.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
+    arguments = NULL_TREE;
+  else
+    arguments = cp_parser_template_argument_list (parser);
+  /* Look for the `>' that ends the template-argument-list. If we find
+     a '>>' instead, it's probably just a typo.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
+    {
+      if (!saved_greater_than_is_operator_p)
+	{
+	  /* If we're in a nested template argument list, the '>>' has to be
+	    a typo for '> >'. We emit the error message, but we continue
+	    parsing and we push a '>' as next token, so that the argument
+	    list will be parsed correctly..  */
+	  cp_token* token;
+	  error ("`>>' should be `> >' within a nested template argument list");
+	  token = cp_lexer_peek_token (parser->lexer);
+	  token->type = CPP_GREATER;
+	}
+      else
+	{
+	  /* If this is not a nested template argument list, the '>>' is
+	    a typo for '>'. Emit an error message and continue.  */
+	  error ("spurious `>>', use `>' to terminate a template argument list");
+	  cp_lexer_consume_token (parser->lexer);
+	}
+    }
+  else if (!cp_parser_require (parser, CPP_GREATER, "`>'"))
+    error ("missing `>' to terminate the template argument list");
+  /* The `>' token might be a greater-than operator again now.  */
+  parser->greater_than_is_operator_p 
+    = saved_greater_than_is_operator_p;
+  /* Restore the SAVED_SCOPE.  */
+  parser->scope = saved_scope;
+  parser->qualifying_scope = saved_qualifying_scope;
+  parser->object_scope = saved_object_scope;
+
+  return arguments;
+}
+
+/* MEMBER_FUNCTION is a member function, or a friend.  If default
+   arguments, or the body of the function have not yet been parsed,
+   parse them now.  */
+
+static void
+cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
+{
+  cp_lexer *saved_lexer;
+
+  /* If this member is a template, get the underlying
+     FUNCTION_DECL.  */
+  if (DECL_FUNCTION_TEMPLATE_P (member_function))
+    member_function = DECL_TEMPLATE_RESULT (member_function);
+
+  /* There should not be any class definitions in progress at this
+     point; the bodies of members are only parsed outside of all class
+     definitions.  */
+  my_friendly_assert (parser->num_classes_being_defined == 0, 20010816);
+  /* While we're parsing the member functions we might encounter more
+     classes.  We want to handle them right away, but we don't want
+     them getting mixed up with functions that are currently in the
+     queue.  */
+  parser->unparsed_functions_queues
+    = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);
+
+  /* Make sure that any template parameters are in scope.  */
+  maybe_begin_member_template_processing (member_function);
+
+  /* If the body of the function has not yet been parsed, parse it
+     now.  */
+  if (DECL_PENDING_INLINE_P (member_function))
+    {
+      tree function_scope;
+      cp_token_cache *tokens;
+
+      /* The function is no longer pending; we are processing it.  */
+      tokens = DECL_PENDING_INLINE_INFO (member_function);
+      DECL_PENDING_INLINE_INFO (member_function) = NULL;
+      DECL_PENDING_INLINE_P (member_function) = 0;
+      /* If this was an inline function in a local class, enter the scope
+	 of the containing function.  */
+      function_scope = decl_function_context (member_function);
+      if (function_scope)
+	push_function_context_to (function_scope);
+      
+      /* Save away the current lexer.  */
+      saved_lexer = parser->lexer;
+      /* Make a new lexer to feed us the tokens saved for this function.  */
+      parser->lexer = cp_lexer_new_from_tokens (tokens);
+      parser->lexer->next = saved_lexer;
+      
+      /* Set the current source position to be the location of the first
+	 token in the saved inline body.  */
+      cp_lexer_peek_token (parser->lexer);
+      
+      /* Let the front end know that we going to be defining this
+	 function.  */
+      start_function (NULL_TREE, member_function, NULL_TREE,
+		      SF_PRE_PARSED | SF_INCLASS_INLINE);
+      
+      /* Now, parse the body of the function.  */
+      cp_parser_function_definition_after_declarator (parser,
+						      /*inline_p=*/true);
+      
+      /* Leave the scope of the containing function.  */
+      if (function_scope)
+	pop_function_context_from (function_scope);
+      /* Restore the lexer.  */
+      parser->lexer = saved_lexer;
+    }
+
+  /* Remove any template parameters from the symbol table.  */
+  maybe_end_member_template_processing ();
+
+  /* Restore the queue.  */
+  parser->unparsed_functions_queues 
+    = TREE_CHAIN (parser->unparsed_functions_queues);
+}
+
+/* If DECL contains any default args, remember it on the unparsed
+   functions queue.  */
+
+static void
+cp_parser_save_default_args (cp_parser* parser, tree decl)
+{
+  tree probe;
+
+  for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
+       probe;
+       probe = TREE_CHAIN (probe))
+    if (TREE_PURPOSE (probe))
+      {
+	TREE_PURPOSE (parser->unparsed_functions_queues)
+	  = tree_cons (NULL_TREE, decl, 
+		       TREE_PURPOSE (parser->unparsed_functions_queues));
+	break;
+      }
+  return;
+}
+
+/* FN is a FUNCTION_DECL which may contains a parameter with an
+   unparsed DEFAULT_ARG.  Parse the default args now.  */
+
+static void
+cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
+{
+  cp_lexer *saved_lexer;
+  cp_token_cache *tokens;
+  bool saved_local_variables_forbidden_p;
+  tree parameters;
+
+  /* While we're parsing the default args, we might (due to the
+     statement expression extension) encounter more classes.  We want
+     to handle them right away, but we don't want them getting mixed
+     up with default args that are currently in the queue.  */
+  parser->unparsed_functions_queues
+    = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);
+
+  for (parameters = TYPE_ARG_TYPES (TREE_TYPE (fn));
+       parameters;
+       parameters = TREE_CHAIN (parameters))
+    {
+      if (!TREE_PURPOSE (parameters)
+	  || TREE_CODE (TREE_PURPOSE (parameters)) != DEFAULT_ARG)
+	continue;
+  
+       /* Save away the current lexer.  */
+      saved_lexer = parser->lexer;
+       /* Create a new one, using the tokens we have saved.  */
+      tokens =  DEFARG_TOKENS (TREE_PURPOSE (parameters));
+      parser->lexer = cp_lexer_new_from_tokens (tokens);
+
+       /* Set the current source position to be the location of the
+     	  first token in the default argument.  */
+      cp_lexer_peek_token (parser->lexer);
+
+       /* Local variable names (and the `this' keyword) may not appear
+     	  in a default argument.  */
+      saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
+      parser->local_variables_forbidden_p = true;
+       /* Parse the assignment-expression.  */
+      if (DECL_CLASS_SCOPE_P (fn))
+	push_nested_class (DECL_CONTEXT (fn));
+      TREE_PURPOSE (parameters) = cp_parser_assignment_expression (parser);
+      if (DECL_CLASS_SCOPE_P (fn))
+	pop_nested_class ();
+
+      /* If the token stream has not been completely used up, then
+	 there was extra junk after the end of the default
+	 argument.  */
+      if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
+	cp_parser_error (parser, "expected `,'");
+
+       /* Restore saved state.  */
+      parser->lexer = saved_lexer;
+      parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
+    }
+
+  /* Restore the queue.  */
+  parser->unparsed_functions_queues 
+    = TREE_CHAIN (parser->unparsed_functions_queues);
+}
+
+/* Parse the operand of `sizeof' (or a similar operator).  Returns
+   either a TYPE or an expression, depending on the form of the
+   input.  The KEYWORD indicates which kind of expression we have
+   encountered.  */
+
+static tree
+cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
+{
+  static const char *format;
+  tree expr = NULL_TREE;
+  const char *saved_message;
+  bool saved_integral_constant_expression_p;
+
+  /* Initialize FORMAT the first time we get here.  */
+  if (!format)
+    format = "types may not be defined in `%s' expressions";
+
+  /* Types cannot be defined in a `sizeof' expression.  Save away the
+     old message.  */
+  saved_message = parser->type_definition_forbidden_message;
+  /* And create the new one.  */
+  parser->type_definition_forbidden_message 
+    = xmalloc (strlen (format) 
+	       + strlen (IDENTIFIER_POINTER (ridpointers[keyword]))
+	       + 1 /* `\0' */);
+  sprintf ((char *) parser->type_definition_forbidden_message,
+	   format, IDENTIFIER_POINTER (ridpointers[keyword]));
+
+  /* The restrictions on constant-expressions do not apply inside
+     sizeof expressions.  */
+  saved_integral_constant_expression_p = parser->integral_constant_expression_p;
+  parser->integral_constant_expression_p = false;
+
+  /* Do not actually evaluate the expression.  */
+  ++skip_evaluation;
+  /* If it's a `(', then we might be looking at the type-id
+     construction.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
+    {
+      tree type;
+      bool saved_in_type_id_in_expr_p;
+
+      /* We can't be sure yet whether we're looking at a type-id or an
+	 expression.  */
+      cp_parser_parse_tentatively (parser);
+      /* Consume the `('.  */
+      cp_lexer_consume_token (parser->lexer);
+      /* Parse the type-id.  */
+      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;
+      /* Now, look for the trailing `)'.  */
+      cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
+      /* If all went well, then we're done.  */
+      if (cp_parser_parse_definitely (parser))
+	{
+	  /* Build a list of decl-specifiers; right now, we have only
+	     a single type-specifier.  */
+	  type = build_tree_list (NULL_TREE,
+				  type);
+
+	  /* Call grokdeclarator to figure out what type this is.  */
+	  expr = grokdeclarator (NULL_TREE,
+				 type,
+				 TYPENAME,
+				 /*initialized=*/0,
+				 /*attrlist=*/NULL);
+	}
+    }
+
+  /* If the type-id production did not work out, then we must be
+     looking at the unary-expression production.  */
+  if (!expr)
+    expr = cp_parser_unary_expression (parser, /*address_p=*/false);
+  /* Go back to evaluating expressions.  */
+  --skip_evaluation;
+
+  /* Free the message we created.  */
+  free ((char *) parser->type_definition_forbidden_message);
+  /* And restore the old one.  */
+  parser->type_definition_forbidden_message = saved_message;
+  parser->integral_constant_expression_p = saved_integral_constant_expression_p;
+
+  return expr;
+}
+
+/* If the current declaration has no declarator, return true.  */
+
+static bool
+cp_parser_declares_only_class_p (cp_parser *parser)
+{
+  /* If the next token is a `;' or a `,' then there is no 
+     declarator.  */
+  return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
+	  || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
+}
+
+/* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
+   Returns TRUE iff `friend' appears among the DECL_SPECIFIERS.  */
+
+static bool
+cp_parser_friend_p (tree decl_specifiers)
+{
+  while (decl_specifiers)
+    {
+      /* See if this decl-specifier is `friend'.  */
+      if (TREE_CODE (TREE_VALUE (decl_specifiers)) == IDENTIFIER_NODE
+	  && C_RID_CODE (TREE_VALUE (decl_specifiers)) == RID_FRIEND)
+	return true;
+
+      /* Go on to the next decl-specifier.  */
+      decl_specifiers = TREE_CHAIN (decl_specifiers);
+    }
+
+  return false;
+}
+
+/* If the next token is of the indicated TYPE, consume it.  Otherwise,
+   issue an error message indicating that TOKEN_DESC was expected.
+   
+   Returns the token consumed, if the token had the appropriate type.
+   Otherwise, returns NULL.  */
+
+static cp_token *
+cp_parser_require (cp_parser* parser,
+                   enum cpp_ttype type,
+                   const char* token_desc)
+{
+  if (cp_lexer_next_token_is (parser->lexer, type))
+    return cp_lexer_consume_token (parser->lexer);
+  else
+    {
+      /* Output the MESSAGE -- unless we're parsing tentatively.  */
+      if (!cp_parser_simulate_error (parser))
+	{
+	  char *message = concat ("expected ", token_desc, NULL);
+	  cp_parser_error (parser, message);
+	  free (message);
+	}
+      return NULL;
+    }
+}
+
+/* Like cp_parser_require, except that tokens will be skipped until
+   the desired token is found.  An error message is still produced if
+   the next token is not as expected.  */
+
+static void
+cp_parser_skip_until_found (cp_parser* parser, 
+                            enum cpp_ttype type, 
+                            const char* token_desc)
+{
+  cp_token *token;
+  unsigned nesting_depth = 0;
+
+  if (cp_parser_require (parser, type, token_desc))
+    return;
+
+  /* Skip tokens until the desired token is found.  */
+  while (true)
+    {
+      /* Peek at the next token.  */
+      token = cp_lexer_peek_token (parser->lexer);
+      /* If we've reached the token we want, consume it and 
+	 stop.  */
+      if (token->type == type && !nesting_depth)
+	{
+	  cp_lexer_consume_token (parser->lexer);
+	  return;
+	}
+      /* If we've run out of tokens, stop.  */
+      if (token->type == CPP_EOF)
+	return;
+      if (token->type == CPP_OPEN_BRACE 
+	  || token->type == CPP_OPEN_PAREN
+	  || token->type == CPP_OPEN_SQUARE)
+	++nesting_depth;
+      else if (token->type == CPP_CLOSE_BRACE 
+	       || token->type == CPP_CLOSE_PAREN
+	       || token->type == CPP_CLOSE_SQUARE)
+	{
+	  if (nesting_depth-- == 0)
+	    return;
+	}
+      /* Consume this token.  */
+      cp_lexer_consume_token (parser->lexer);
+    }
+}
+
+/* If the next token is the indicated keyword, consume it.  Otherwise,
+   issue an error message indicating that TOKEN_DESC was expected.
+   
+   Returns the token consumed, if the token had the appropriate type.
+   Otherwise, returns NULL.  */
+
+static cp_token *
+cp_parser_require_keyword (cp_parser* parser,
+                           enum rid keyword,
+                           const char* token_desc)
+{
+  cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
+
+  if (token && token->keyword != keyword)
+    {
+      dyn_string_t error_msg;
+
+      /* Format the error message.  */
+      error_msg = dyn_string_new (0);
+      dyn_string_append_cstr (error_msg, "expected ");
+      dyn_string_append_cstr (error_msg, token_desc);
+      cp_parser_error (parser, error_msg->s);
+      dyn_string_delete (error_msg);
+      return NULL;
+    }
+
+  return token;
+}
+
+/* Returns TRUE iff TOKEN is a token that can begin the body of a
+   function-definition.  */
+
+static bool 
+cp_parser_token_starts_function_definition_p (cp_token* token)
+{
+  return (/* An ordinary function-body begins with an `{'.  */
+	  token->type == CPP_OPEN_BRACE
+	  /* A ctor-initializer begins with a `:'.  */
+	  || token->type == CPP_COLON
+	  /* A function-try-block begins with `try'.  */
+	  || token->keyword == RID_TRY
+	  /* The named return value extension begins with `return'.  */
+	  || token->keyword == RID_RETURN);
+}
+
+/* Returns TRUE iff the next token is the ":" or "{" beginning a class
+   definition.  */
+
+static bool
+cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
+{
+  cp_token *token;
+
+  token = cp_lexer_peek_token (parser->lexer);
+  return (token->type == CPP_OPEN_BRACE || token->type == CPP_COLON);
+}
+
+/* Returns TRUE iff the next token is the "," or ">" ending a
+   template-argument. ">>" is also accepted (after the full
+   argument was parsed) because it's probably a typo for "> >",
+   and there is a specific diagnostic for this.  */
+
+static bool
+cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
+{
+  cp_token *token;
+
+  token = cp_lexer_peek_token (parser->lexer);
+  return (token->type == CPP_COMMA || token->type == CPP_GREATER 
+	  || token->type == CPP_RSHIFT);
+}
+
+/* Returns TRUE iff the n-th token is a ">", or the n-th is a "[" and the
+   (n+1)-th is a ":" (which is a possible digraph typo for "< ::").  */
+
+static bool
+cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser, 
+						     size_t n)
+{
+  cp_token *token;
+
+  token = cp_lexer_peek_nth_token (parser->lexer, n);
+  if (token->type == CPP_LESS)
+    return true;
+  /* Check for the sequence `<::' in the original code. It would be lexed as
+     `[:', where `[' is a digraph, and there is no whitespace before
+     `:'.  */
+  if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
+    {
+      cp_token *token2;
+      token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
+      if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
+	return true;
+    }
+  return false;
+}
+ 
+/* Returns the kind of tag indicated by TOKEN, if it is a class-key,
+   or none_type otherwise.  */
+
+static enum tag_types
+cp_parser_token_is_class_key (cp_token* token)
+{
+  switch (token->keyword)
+    {
+    case RID_CLASS:
+      return class_type;
+    case RID_STRUCT:
+      return record_type;
+    case RID_UNION:
+      return union_type;
+      
+    default:
+      return none_type;
+    }
+}
+
+/* Issue an error message if the CLASS_KEY does not match the TYPE.  */
+
+static void
+cp_parser_check_class_key (enum tag_types class_key, tree type)
+{
+  if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
+    pedwarn ("`%s' tag used in naming `%#T'",
+	    class_key == union_type ? "union"
+	     : class_key == record_type ? "struct" : "class", 
+	     type);
+}
+			   
+/* Issue an error message if DECL is redeclared with different
+   access than its original declaration [class.access.spec/3].
+   This applies to nested classes and nested class templates.
+   [class.mem/1].  */
+
+static void cp_parser_check_access_in_redeclaration (tree decl)
+{
+  if (!CLASS_TYPE_P (TREE_TYPE (decl)))
+    return;
+
+  if ((TREE_PRIVATE (decl)
+       != (current_access_specifier == access_private_node))
+      || (TREE_PROTECTED (decl)
+	  != (current_access_specifier == access_protected_node)))
+    error ("%D redeclared with different access", decl);
+}
+
+/* Look for the `template' keyword, as a syntactic disambiguator.
+   Return TRUE iff it is present, in which case it will be 
+   consumed.  */
+
+static bool
+cp_parser_optional_template_keyword (cp_parser *parser)
+{
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
+    {
+      /* The `template' keyword can only be used within templates;
+	 outside templates the parser can always figure out what is a
+	 template and what is not.  */
+      if (!processing_template_decl)
+	{
+	  error ("`template' (as a disambiguator) is only allowed "
+		 "within templates");
+	  /* If this part of the token stream is rescanned, the same
+	     error message would be generated.  So, we purge the token
+	     from the stream.  */
+	  cp_lexer_purge_token (parser->lexer);
+	  return false;
+	}
+      else
+	{
+	  /* Consume the `template' keyword.  */
+	  cp_lexer_consume_token (parser->lexer);
+	  return true;
+	}
+    }
+
+  return false;
+}
+
+/* The next token is a CPP_NESTED_NAME_SPECIFIER.  Consume the token,
+   set PARSER->SCOPE, and perform other related actions.  */
+
+static void
+cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
+{
+  tree value;
+  tree check;
+
+  /* Get the stored value.  */
+  value = cp_lexer_consume_token (parser->lexer)->value;
+  /* Perform any access checks that were deferred.  */
+  for (check = TREE_PURPOSE (value); check; check = TREE_CHAIN (check))
+    perform_or_defer_access_check (TREE_PURPOSE (check), TREE_VALUE (check));
+  /* Set the scope from the stored value.  */
+  parser->scope = TREE_VALUE (value);
+  parser->qualifying_scope = TREE_TYPE (value);
+  parser->object_scope = NULL_TREE;
+}
+
+/* Add tokens to CACHE until an non-nested END token appears.  */
+
+static void
+cp_parser_cache_group (cp_parser *parser, 
+		       cp_token_cache *cache,
+		       enum cpp_ttype end,
+		       unsigned depth)
+{
+  while (true)
+    {
+      cp_token *token;
+
+      /* Abort a parenthesized expression if we encounter a brace.  */
+      if ((end == CPP_CLOSE_PAREN || depth == 0)
+	  && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
+	return;
+      /* If we've reached the end of the file, stop.  */
+      if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
+	return;
+      /* Consume the next token.  */
+      token = cp_lexer_consume_token (parser->lexer);
+      /* Add this token to the tokens we are saving.  */
+      cp_token_cache_push_token (cache, token);
+      /* See if it starts a new group.  */
+      if (token->type == CPP_OPEN_BRACE)
+	{
+	  cp_parser_cache_group (parser, cache, CPP_CLOSE_BRACE, depth + 1);
+	  if (depth == 0)
+	    return;
+	}
+      else if (token->type == CPP_OPEN_PAREN)
+	cp_parser_cache_group (parser, cache, CPP_CLOSE_PAREN, depth + 1);
+      else if (token->type == end)
+	return;
+    }
+}
+
+/* Begin parsing tentatively.  We always save tokens while parsing
+   tentatively so that if the tentative parsing fails we can restore the
+   tokens.  */
+
+static void
+cp_parser_parse_tentatively (cp_parser* parser)
+{
+  /* Enter a new parsing context.  */
+  parser->context = cp_parser_context_new (parser->context);
+  /* Begin saving tokens.  */
+  cp_lexer_save_tokens (parser->lexer);
+  /* In order to avoid repetitive access control error messages,
+     access checks are queued up until we are no longer parsing
+     tentatively.  */
+  push_deferring_access_checks (dk_deferred);
+}
+
+/* Commit to the currently active tentative parse.  */
+
+static void
+cp_parser_commit_to_tentative_parse (cp_parser* parser)
+{
+  cp_parser_context *context;
+  cp_lexer *lexer;
+
+  /* Mark all of the levels as committed.  */
+  lexer = parser->lexer;
+  for (context = parser->context; context->next; context = context->next)
+    {
+      if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
+	break;
+      context->status = CP_PARSER_STATUS_KIND_COMMITTED;
+      while (!cp_lexer_saving_tokens (lexer))
+	lexer = lexer->next;
+      cp_lexer_commit_tokens (lexer);
+    }
+}
+
+/* Abort the currently active tentative parse.  All consumed tokens
+   will be rolled back, and no diagnostics will be issued.  */
+
+static void
+cp_parser_abort_tentative_parse (cp_parser* parser)
+{
+  cp_parser_simulate_error (parser);
+  /* Now, pretend that we want to see if the construct was
+     successfully parsed.  */
+  cp_parser_parse_definitely (parser);
+}
+
+/* Stop parsing tentatively.  If a parse error has occurred, restore the
+   token stream.  Otherwise, commit to the tokens we have consumed.
+   Returns true if no error occurred; false otherwise.  */
+
+static bool
+cp_parser_parse_definitely (cp_parser* parser)
+{
+  bool error_occurred;
+  cp_parser_context *context;
+
+  /* Remember whether or not an error occurred, since we are about to
+     destroy that information.  */
+  error_occurred = cp_parser_error_occurred (parser);
+  /* Remove the topmost context from the stack.  */
+  context = parser->context;
+  parser->context = context->next;
+  /* If no parse errors occurred, commit to the tentative parse.  */
+  if (!error_occurred)
+    {
+      /* Commit to the tokens read tentatively, unless that was
+	 already done.  */
+      if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
+	cp_lexer_commit_tokens (parser->lexer);
+
+      pop_to_parent_deferring_access_checks ();
+    }
+  /* Otherwise, if errors occurred, roll back our state so that things
+     are just as they were before we began the tentative parse.  */
+  else
+    {
+      cp_lexer_rollback_tokens (parser->lexer);
+      pop_deferring_access_checks ();
+    }
+  /* Add the context to the front of the free list.  */
+  context->next = cp_parser_context_free_list;
+  cp_parser_context_free_list = context;
+
+  return !error_occurred;
+}
+
+/* Returns true if we are parsing tentatively -- but have decided that
+   we will stick with this tentative parse, even if errors occur.  */
+
+static bool
+cp_parser_committed_to_tentative_parse (cp_parser* parser)
+{
+  return (cp_parser_parsing_tentatively (parser)
+	  && parser->context->status == CP_PARSER_STATUS_KIND_COMMITTED);
+}
+
+/* Returns nonzero iff an error has occurred during the most recent
+   tentative parse.  */
+   
+static bool
+cp_parser_error_occurred (cp_parser* parser)
+{
+  return (cp_parser_parsing_tentatively (parser)
+	  && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
+}
+
+/* Returns nonzero if GNU extensions are allowed.  */
+
+static bool
+cp_parser_allow_gnu_extensions_p (cp_parser* parser)
+{
+  return parser->allow_gnu_extensions_p;
+}
+
+
+
+/* The parser.  */
+
+static GTY (()) cp_parser *the_parser;
+
+/* External interface.  */
+
+/* Parse one entire translation unit.  */
+
+void
+c_parse_file (void)
+{
+  bool error_occurred;
+
+  the_parser = cp_parser_new ();
+  push_deferring_access_checks (flag_access_control
+				? dk_no_deferred : dk_no_check);
+  error_occurred = cp_parser_translation_unit (the_parser);
+  the_parser = NULL;
+}
+
+/* This variable must be provided by every front end.  */
+
+int yydebug;
+
+#include "gt-cp-parser.h"