osprey/kgccfe/gnu/cp/decl.c

Go to the documentation of this file.

/* Process declarations and variables for C compiler.
   Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   2001, 2002, 2003  Free Software Foundation, Inc.
   Contributed by Michael Tiemann (tiemann@cygnus.com)

This file is part of GNU CC.

GNU CC 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.

GNU CC 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 GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


/* Process declarations and symbol lookup for C front end.
   Also constructs types; the standard scalar types at initialization,
   and structure, union, array and enum types when they are declared.  */

/* ??? not all decl nodes are given the most useful possible
   line numbers.  For example, the CONST_DECLs for enum values.  */

#include "config.h"
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "expr.h"
#include "flags.h"
#include "cp-tree.h"
#include "tree-inline.h"
#include "decl.h"
#include "lex.h"
#include "output.h"
#include "except.h"
#include "toplev.h"
#include "hashtab.h"
#include "ggc.h"
#include "tm_p.h"
#include "target.h"
#include "c-common.h"
#include "c-pragma.h"
#include "diagnostic.h"
#include "debug.h"
#include "timevar.h"
#include "input.h"

static tree grokparms       PARAMS ((tree));
static const char *redeclaration_error_message  PARAMS ((tree, tree));

static void push_binding_level PARAMS ((struct cp_binding_level *, int,
              int));
static void pop_binding_level PARAMS ((void));
static void suspend_binding_level PARAMS ((void));
static void resume_binding_level PARAMS ((struct cp_binding_level *));
static struct cp_binding_level *make_binding_level PARAMS ((void));
static void declare_namespace_level PARAMS ((void));
static int decl_jump_unsafe PARAMS ((tree));
static void storedecls PARAMS ((tree));
static void require_complete_types_for_parms PARAMS ((tree));
static int ambi_op_p PARAMS ((enum tree_code));
static int unary_op_p PARAMS ((enum tree_code));
static cxx_saved_binding *store_bindings (tree, cxx_saved_binding *);
static tree lookup_tag_reverse PARAMS ((tree, tree));
static tree lookup_name_real PARAMS ((tree, int, int, int));
static void push_local_name PARAMS ((tree));
static void warn_extern_redeclared_static PARAMS ((tree, tree));
static tree grok_reference_init PARAMS ((tree, tree, tree, tree *));
static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
            enum overload_flags, tree,
            tree, int, int, int, int, int, int, tree));
static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
static tree follow_tag_typedef PARAMS ((tree));
static tree lookup_tag PARAMS ((enum tree_code, tree,
            struct cp_binding_level *, int));
static void set_identifier_type_value_with_scope
  PARAMS ((tree, tree, struct cp_binding_level *));
static void record_unknown_type PARAMS ((tree, const char *));
static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
                                      enum built_in_class, const char *,
              tree));
static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
          int));
static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct cp_binding_level*));
static void check_for_uninitialized_const_var PARAMS ((tree));
static hashval_t typename_hash PARAMS ((const void *));
static int typename_compare PARAMS ((const void *, const void *));
static void push_binding PARAMS ((tree, tree, struct cp_binding_level*));
static int add_binding PARAMS ((tree, tree));
static void pop_binding PARAMS ((tree, tree));
static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
static cxx_binding *find_binding (tree, tree, cxx_binding *);
static tree select_decl (cxx_binding *, int);
static int lookup_flags PARAMS ((int, int));
static tree qualify_lookup PARAMS ((tree, int));
static tree record_builtin_java_type PARAMS ((const char *, int));
static const char *tag_name PARAMS ((enum tag_types code));
static void find_class_binding_level PARAMS ((void));
static struct cp_binding_level *innermost_nonclass_level PARAMS ((void));
static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
static int walk_globals_r PARAMS ((tree, void *));
static int walk_vtables_r PARAMS ((tree, void*));
static void add_decl_to_level PARAMS ((tree, struct cp_binding_level *));
static tree make_label_decl PARAMS ((tree, int));
static void use_label PARAMS ((tree));
static void check_previous_goto_1 PARAMS ((tree, struct cp_binding_level *, tree,
             const char *, int));
static void check_previous_goto PARAMS ((struct named_label_use_list *));
static void check_switch_goto PARAMS ((struct cp_binding_level *));
static void check_previous_gotos PARAMS ((tree));
static void pop_label PARAMS ((tree, tree));
static void pop_labels PARAMS ((tree));
static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
static void layout_var_decl PARAMS ((tree));
static void maybe_commonize_var PARAMS ((tree));
static tree check_initializer (tree, tree, int, tree *);
static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
static void save_function_data PARAMS ((tree));
static void check_function_type PARAMS ((tree, tree));
static void begin_constructor_body PARAMS ((void));
static void finish_constructor_body PARAMS ((void));
static void begin_destructor_body PARAMS ((void));
static void finish_destructor_body PARAMS ((void));
static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
static tree get_atexit_node PARAMS ((void));
static tree get_dso_handle_node PARAMS ((void));
static tree start_cleanup_fn PARAMS ((void));
static void end_cleanup_fn PARAMS ((void));
static tree cp_make_fname_decl PARAMS ((tree, int));
static void initialize_predefined_identifiers PARAMS ((void));
static tree check_special_function_return_type
  PARAMS ((special_function_kind, tree, tree));
static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
static void store_parm_decls PARAMS ((tree));
static int cp_missing_noreturn_ok_p PARAMS ((tree));
static void initialize_local_var (tree, tree);
static void expand_static_init (tree, tree);
static tree next_initializable_field (tree);
static tree reshape_init (tree, tree *);

/* Erroneous argument lists can use this *IFF* they do not modify it.  */
tree error_mark_list;

/* The following symbols are subsumed in the cp_global_trees array, and
   listed here individually for documentation purposes.

   C++ extensions
  tree wchar_decl_node;

  tree vtable_entry_type;
  tree delta_type_node;
  tree __t_desc_type_node;
        tree ti_desc_type_node;
  tree bltn_desc_type_node, ptr_desc_type_node;
  tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
  tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
  tree ptm_desc_type_node;
  tree base_desc_type_node;

  tree class_type_node, record_type_node, union_type_node, enum_type_node;
  tree unknown_type_node;

   Array type `vtable_entry_type[]'

  tree vtbl_type_node;
  tree vtbl_ptr_type_node;

   Namespaces,

  tree std_node;
  tree abi_node;

   A FUNCTION_DECL which can call `abort'.  Not necessarily the
   one that the user will declare, but sufficient to be called
   by routines that want to abort the program.

  tree abort_fndecl;

   The FUNCTION_DECL for the default `::operator delete'.

  tree global_delete_fndecl;

   Used by RTTI
  tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
  tree tinfo_var_id;

*/

tree cp_global_trees[CPTI_MAX];

/* Indicates that there is a type value in some namespace, although
   that is not necessarily in scope at the moment.  */

static GTY(()) tree global_type_node;

/* Expect only namespace names now.  */
static int only_namespace_names;

/* Used only for jumps to as-yet undefined labels, since jumps to
   defined labels can have their validity checked immediately.  */

struct named_label_use_list GTY(())
{
  struct cp_binding_level *binding_level;
  tree names_in_scope;
  tree label_decl;
  const char *filename_o_goto;
  int lineno_o_goto;
  struct named_label_use_list *next;
};

#define named_label_uses cp_function_chain->x_named_label_uses

#define local_names cp_function_chain->x_local_names

/* A list of objects which have constructors or destructors
   which reside in the global scope.  The decl is stored in
   the TREE_VALUE slot and the initializer is stored
   in the TREE_PURPOSE slot.  */
tree static_aggregates;

/* -- end of C++ */

/* A node for the integer constants 2, and 3.  */

tree integer_two_node, integer_three_node;

/* Similar, for last_function_parm_tags.  */
tree last_function_parms;

/* A list of all LABEL_DECLs in the function that have names.  Here so
   we can clear out their names' definitions at the end of the
   function, and so we can check the validity of jumps to these labels.  */

struct named_label_list GTY(())
{
  struct cp_binding_level *binding_level;
  tree names_in_scope;
  tree old_value;
  tree label_decl;
  tree bad_decls;
  struct named_label_list *next;
  unsigned int in_try_scope : 1;
  unsigned int in_catch_scope : 1;
};

#define named_labels cp_function_chain->x_named_labels

/* The name of the anonymous namespace, throughout this translation
   unit.  */
tree anonymous_namespace_name;

/* The number of function bodies which we are currently processing.
   (Zero if we are at namespace scope, one inside the body of a
   function, two inside the body of a function in a local class, etc.)  */
int function_depth;

/* States indicating how grokdeclarator() should handle declspecs marked
   with __attribute__((deprecated)).  An object declared as
   __attribute__((deprecated)) suppresses warnings of uses of other
   deprecated items.  */
   
enum deprecated_states {
  DEPRECATED_NORMAL,
  DEPRECATED_SUPPRESS
};

static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;

/* Set by add_implicitly_declared_members() to keep those members from
   being flagged as deprecated or reported as using deprecated
   types.  */
int adding_implicit_members = 0;

/* True if a declaration with an `extern' linkage specifier is being
   processed.  */
bool have_extern_spec;


/* Compute the chain index of a binding_entry given the HASH value of its
   name and the total COUNT of chains.  COUNT is assumed to be a power
   of 2.  */
#define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))

/* A free list of "binding_entry"s awaiting for re-use.  */
static GTY((deletable("")))  binding_entry free_binding_entry;

/* Create a binding_entry object for (NAME, TYPE).  */
static inline binding_entry
binding_entry_make (tree name, tree type)
{
  binding_entry entry;

  if (free_binding_entry)
    {
      entry = free_binding_entry;
      free_binding_entry = entry->chain;
    }
  else
    entry = ggc_alloc (sizeof (struct binding_entry_s));

  entry->name = name;
  entry->type = type;

  return entry;
}

/* Put ENTRY back on the free list.  */
static inline void
binding_entry_free (binding_entry entry)
{
  entry->chain = free_binding_entry;
  free_binding_entry = entry;
}

/* The datatype used to implement the mapping from names to types at
   a given scope.  */
struct binding_table_s GTY(())
{
  /* Array of chains of "binding_entry"s  */
  binding_entry * GTY((length ("%h.chain_count"))) chain;

  /* The number of chains in this table.  This is the length of the
     the member "chaiin" considered as an array.  */
  size_t chain_count;

  /* Number of "binding_entry"s in this table.  */
  size_t entry_count;
};

/* These macros indicate the initial chains count for binding_table.  */
#define SCOPE_DEFAULT_HT_SIZE                        (1 << 3)
#define CLASS_SCOPE_HT_SIZE                          (1 << 3)
#define NAMESPACE_ORDINARY_HT_SIZE                   (1 << 5)
#define NAMESPACE_STD_HT_SIZE                        (1 << 8)
#define GLOBAL_SCOPE_HT_SIZE                         (1 << 8)

/* Construct TABLE with an initial CHAIN_COUNT.  */
static inline void
binding_table_construct (binding_table table, size_t chain_count)
{
  table->chain_count = chain_count;
  table->entry_count = 0;
  table->chain = ggc_alloc_cleared
    (table->chain_count * sizeof (binding_entry));
}

/* Free TABLE by making its entries ready for reuse. */
static inline void
binding_table_free (binding_table table)
{
  size_t i;
  if (table == NULL)
    return;
  
  for (i = 0; i < table->chain_count; ++i)
    {
      while (table->chain[i] != NULL)
        {
          binding_entry entry = table->chain[i];
          table->chain[i] = entry->chain;
          binding_entry_free (entry);
        }
    }
  table->entry_count = 0;
}

/* Allocate a table with CHAIN_COUNT, assumed to be a power of two.  */
static inline binding_table
binding_table_new (size_t chain_count)
{
  binding_table table = ggc_alloc (sizeof (struct binding_table_s));
  binding_table_construct (table, chain_count);
  return table;
}

/* Expand TABLE to twice its current chain_count.  */
static void
binding_table_expand (binding_table table)
{
  const size_t old_chain_count = table->chain_count;
  const size_t old_entry_count = table->entry_count;
  const size_t new_chain_count = 2 * old_chain_count;
  binding_entry *old_chains = table->chain;
  size_t i;
  
  binding_table_construct (table, new_chain_count);
  for (i = 0; i < old_chain_count; ++i)
    {
      binding_entry entry = old_chains[i];
      for (; entry != NULL; entry = old_chains[i])
        {
          const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
          const size_t j = ENTRY_INDEX (hash, new_chain_count);

          old_chains[i] = entry->chain;
          entry->chain = table->chain[j];
          table->chain[j] = entry;
        }
    }
  table->entry_count = old_entry_count;
}

/* Insert a binding for NAME to TYPe into TABLE.  */
static inline void
binding_table_insert (binding_table table, tree name, tree type)
{
  const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
  const size_t i = ENTRY_INDEX (hash, table->chain_count);
  binding_entry entry = binding_entry_make (name, type);
  
  entry->chain = table->chain[i];
  table->chain[i] = entry;
  ++table->entry_count;

  if (3 * table->chain_count < 5 * table->entry_count)
    binding_table_expand (table);
}

/* Return the binding_entry, if any, that maps NAME.  */
binding_entry
binding_table_find (binding_table table, tree name)
{
  const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
  binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
  
  while (entry != NULL && entry->name != name)
    entry = entry->chain;

  return entry;
}

/* Return the binding_entry, if any, that maps name to an anonymous type.  */
static inline tree
binding_table_find_anon_type (binding_table table, tree name)
{
  const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
  binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];

  while (entry != NULL && TYPE_IDENTIFIER (entry->type) != name)
    entry = entry->chain;

  return entry ? entry->type : NULL;
}

/* Return the binding_entry, if any, that has TYPE as target.  If NAME
   is non-null, then set the domain and rehash that entry.  */
static inline binding_entry
binding_table_reverse_maybe_remap (binding_table table, tree type, tree name)
{
  const size_t chain_count = table->chain_count;
  binding_entry entry = NULL;
  binding_entry *p = NULL;
  size_t i;

  for (i = 0; i < chain_count && entry == NULL; ++i)
    {
      p = &table->chain[i];
      while (*p != NULL && entry == NULL)
        if ((*p)->type == type)
          entry = *p;
        else
          p = &(*p)->chain;
    }
  
  if (entry != NULL && name != NULL && entry->name != name)
    {
      /* Remove the bucket from the previous chain.  */
      *p = (*p)->chain;

      /* Remap the name type to type.  */
      i = ENTRY_INDEX (IDENTIFIER_HASH_VALUE (name), chain_count);
      entry->chain = table->chain[i];
      entry->name = name;
      table->chain[i] = entry;
    }

  return entry;
}

/* Remove from TABLE all entries that map to anonymous enums or
   class-types.  */
static void
binding_table_remove_anonymous_types (binding_table table)
{
  const size_t chain_count = table->chain_count;
  size_t i;

  for (i = 0; i < chain_count; ++i)
    {
      binding_entry *p = &table->chain[i];

      while (*p != NULL)
        if (ANON_AGGRNAME_P ((*p)->name))
          {
            binding_entry e = *p;
            *p = (*p)->chain;
            --table->entry_count;
            binding_entry_free (e);
          }
        else
          p = &(*p)->chain;
    }
}

/* Apply PROC -- with DATA -- to all entries in TABLE.  */
void
binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
{
  const size_t chain_count = table->chain_count;
  size_t i;
  
  for (i = 0; i < chain_count; ++i)
    {
      binding_entry entry = table->chain[i];
      for (; entry != NULL; entry = entry->chain)
        proc (entry, data);
    }
}


/* For each binding contour we allocate a binding_level structure
   which records the names defined in that contour.
   Contours include:
    0) the global one
    1) one for each function definition,
       where internal declarations of the parameters appear.
    2) one for each compound statement,
       to record its declarations.

   The current meaning of a name can be found by searching the levels
   from the current one out to the global one.

   Off to the side, may be the class_binding_level.  This exists only
   to catch class-local declarations.  It is otherwise nonexistent.

   Also there may be binding levels that catch cleanups that must be
   run when exceptions occur.  Thus, to see whether a name is bound in
   the current scope, it is not enough to look in the
   CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
   instead.  */

/* Note that the information in the `names' component of the global contour
   is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */

struct cp_binding_level GTY(())
  {
    /* A chain of _DECL nodes for all variables, constants, functions,
       and typedef types.  These are in the reverse of the order
       supplied.  There may be OVERLOADs on this list, too, but they
       are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
    tree names;

    /* Count of elements in names chain.  */
    size_t names_size;

    /* A chain of NAMESPACE_DECL nodes.  */
    tree namespaces;

    /* An array of static functions and variables (for namespaces only) */
    varray_type static_decls;

    /* A chain of VTABLE_DECL nodes.  */
    tree vtables; 

    /* A dictionary for looking up enums or class-types names.  */
    binding_table type_decls;

    /* A list of USING_DECL nodes.  */
    tree usings;

    /* A list of used namespaces. PURPOSE is the namespace,
       VALUE the common ancestor with this binding_level's namespace.  */
    tree using_directives;

    /* If this binding level is the binding level for a class, then
       class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
       is the name of an entity bound in the class.  The TREE_TYPE is
       the DECL bound by this name in the class.  */
    tree class_shadowed;

    /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
       is used for all binding levels. In addition the TREE_VALUE is the
       IDENTIFIER_TYPE_VALUE before we entered the class.  */
    tree type_shadowed;

    /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
       label in this scope.  The TREE_PURPOSE is the previous value of
       the IDENTIFIER_LABEL VALUE.  */
    tree shadowed_labels;

    /* For each level (except not the global one),
       a chain of BLOCK nodes for all the levels
       that were entered and exited one level down.  */
    tree blocks;

    /* The _TYPE node for this level, if parm_flag == 2.  */
    tree this_class;

    /* The binding level which this one is contained in (inherits from).  */
    struct cp_binding_level *level_chain;

    /* List of VAR_DECLS saved from a previous for statement.
       These would be dead in ISO-conforming code, but might
       be referenced in ARM-era code.  These are stored in a
       TREE_LIST; the TREE_VALUE is the actual declaration.  */
    tree dead_vars_from_for;

    /* 1 for the level that holds the parameters of a function.
       2 for the level that holds a class declaration.  */
    unsigned parm_flag : 2;

    /* 1 means make a BLOCK for this level regardless of all else.
       2 for temporary binding contours created by the compiler.  */
    unsigned keep : 2;

    /* Nonzero if this level "doesn't exist" for tags.  */
    unsigned tag_transparent : 1;

    /* Nonzero if this level can safely have additional
       cleanup-needing variables added to it.  */
    unsigned more_cleanups_ok : 1;
    unsigned have_cleanups : 1;

    /* Nonzero if this scope is for storing the decls for template
       parameters and generic decls; these decls will be discarded and
       replaced with a TEMPLATE_DECL.  */
    unsigned template_parms_p : 1;

    /* Nonzero if this scope corresponds to the `<>' in a
       `template <>' clause.  Whenever this flag is set,
       TEMPLATE_PARMS_P will be set as well.  */
    unsigned template_spec_p : 1;

    /* This is set for a namespace binding level.  */
    unsigned namespace_p : 1;

    /* True if this level is that of a for-statement where we need to
       worry about ambiguous (ARM or ISO) scope rules.  */
    unsigned is_for_scope : 1;

    /* True if this level corresponds to a TRY block.  Currently this
       information is only available while building the tree structure.  */
    unsigned is_try_scope : 1;

    /* True if this level corresponds to a CATCH block.  Currently this
       information is only available while building the tree structure.  */
    unsigned is_catch_scope : 1;

    /* Three bits left for this word.  */

    /* Binding depth at which this level began.  */
    unsigned binding_depth;
  };

#define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)

/* True if SCOPE designates the global scope binding contour.  */
#define global_scope_p(SCOPE)  \
  ((SCOPE) == NAMESPACE_LEVEL (global_namespace))

/* The binding level currently in effect.  */

#define current_binding_level     \
  (cfun && cp_function_chain->bindings    \
   ? cp_function_chain->bindings    \
   : scope_chain->bindings)

/* The binding level of the current class, if any.  */

#define class_binding_level scope_chain->class_bindings

/* A chain of binding_level structures awaiting reuse.  */

static GTY((deletable (""))) struct cp_binding_level *free_binding_level;

/* Nonzero means unconditionally make a BLOCK for the next level pushed.  */

static int keep_next_level_flag;

/* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
   UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
   time the VAR_DECL was declared, the type was incomplete.  */

static GTY(()) tree incomplete_vars;

#ifndef ENABLE_SCOPE_CHECKING
#  define ENABLE_SCOPE_CHECKING 0
#else
#  define ENABLE_SCOPE_CHECKING 1
#endif

static unsigned binding_depth = 0;
static int is_class_level = 0;

static void
indent (unsigned depth)
{
  unsigned i;

  for (i = 0; i < depth * 2; i++)
    putc (' ', stderr);
}

static tree pushdecl_with_scope PARAMS ((tree, struct cp_binding_level *));

static void
push_binding_level (newlevel, tag_transparent, keep)
     struct cp_binding_level *newlevel;
     int tag_transparent, keep;
{
  /* Add this level to the front of the chain (stack) of levels that
     are active.  */
  memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
  newlevel->level_chain = current_binding_level;
  current_binding_level = newlevel;
  newlevel->tag_transparent = tag_transparent;
  newlevel->more_cleanups_ok = 1;

  newlevel->keep = keep;
  if (ENABLE_SCOPE_CHECKING)
    {
      newlevel->binding_depth = binding_depth;
      indent (binding_depth);
      verbatim ("push %s level %p line %d\n",
                (is_class_level) ? "class" : "block",
                (void *) newlevel, lineno);
      is_class_level = 0;
      binding_depth++;
    }
}

/* Find the innermost enclosing class scope, and reset
   CLASS_BINDING_LEVEL appropriately.  */

static void
find_class_binding_level ()
{
  struct cp_binding_level *level = current_binding_level;

  while (level && level->parm_flag != 2)
    level = level->level_chain;
  if (level && level->parm_flag == 2)
    class_binding_level = level;
  else
    class_binding_level = 0;
}

static void
pop_binding_level ()
{
  if (NAMESPACE_LEVEL (global_namespace))
    /* Cannot pop a level, if there are none left to pop.  */
    my_friendly_assert (!global_scope_p (current_binding_level), 20030527);
  /* Pop the current level, and free the structure for reuse.  */
  if (ENABLE_SCOPE_CHECKING)
    {
      indent (--binding_depth);
      verbatim ("pop  %s level %p line %d\n",
                (is_class_level) ? "class" : "block",
                (void *) current_binding_level, lineno);
      if (is_class_level != (current_binding_level == class_binding_level))
        {
          indent (binding_depth);
          verbatim ("XXX is_class_level != (current_binding_level "
                    "== class_binding_level)\n");
        }
      is_class_level = 0;
    }
  {
    register struct cp_binding_level *level = current_binding_level;
    current_binding_level = current_binding_level->level_chain;
    level->level_chain = free_binding_level;
    if (level->parm_flag != 2)
      binding_table_free (level->type_decls);
    else
      level->type_decls = NULL;
    my_friendly_assert (!ENABLE_SCOPE_CHECKING
                        || level->binding_depth == binding_depth, 20030529);
    free_binding_level = level;
    find_class_binding_level ();
  }
}

static void
suspend_binding_level ()
{
  if (class_binding_level)
    current_binding_level = class_binding_level;

  if (NAMESPACE_LEVEL (global_namespace))
    my_friendly_assert (!global_scope_p (current_binding_level), 20030527);
  /* Suspend the current level.  */
  if (ENABLE_SCOPE_CHECKING)
    {
      indent (--binding_depth);
      verbatim("suspend  %s level %p line %d\n",
               (is_class_level) ? "class" : "block",
               (void *) current_binding_level, lineno);
      if (is_class_level != (current_binding_level == class_binding_level))
        {
          indent (binding_depth);
          verbatim ("XXX is_class_level != (current_binding_level "
                    "== class_binding_level)\n");
        }
      is_class_level = 0;
    }
  current_binding_level = current_binding_level->level_chain;
  find_class_binding_level ();
}

static void
resume_binding_level (b)
     struct cp_binding_level *b;
{
  /* Resuming binding levels is meant only for namespaces,
     and those cannot nest into classes.  */
  my_friendly_assert(!class_binding_level, 386);
  /* Also, resuming a non-directly nested namespace is a no-no.  */
  my_friendly_assert(b->level_chain == current_binding_level, 386);
  current_binding_level = b;
  if (ENABLE_SCOPE_CHECKING)
    {
      b->binding_depth = binding_depth;
      indent (binding_depth);
      verbatim ("resume %s level %p line %d\n",
                (is_class_level) ? "class" : "block", (void *) b, lineno);
      is_class_level = 0;
      binding_depth++;
    }
}

/* Create a new `struct cp_binding_level'.  */

static
struct cp_binding_level *
make_binding_level ()
{
  /* NOSTRICT */
  return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_binding_level));
}

/* Nonzero if we are currently in the global binding level.  */

int
global_bindings_p ()
{
  return global_scope_p (current_binding_level);
}

/* Return the innermost binding level that is not for a class scope.  */

static struct cp_binding_level *
innermost_nonclass_level ()
{
  struct cp_binding_level *b;

  b = current_binding_level;
  while (b->parm_flag == 2)
    b = b->level_chain;

  return b;
}

/* Nonzero if we are currently in a toplevel binding level.  This
   means either the global binding level or a namespace in a toplevel
   binding level.  Since there are no non-toplevel namespace levels,
   this really means any namespace or template parameter level.  We
   also include a class whose context is toplevel.  */

int
toplevel_bindings_p ()
{
  struct cp_binding_level *b = innermost_nonclass_level ();

  return b->namespace_p || b->template_parms_p;
}

/* Nonzero if this is a namespace scope, or if we are defining a class
   which is itself at namespace scope, or whose enclosing class is
   such a class, etc.  */

int
namespace_bindings_p ()
{
  struct cp_binding_level *b = innermost_nonclass_level ();

  return b->namespace_p;
}

/* If KEEP is nonzero, make a BLOCK node for the next binding level,
   unconditionally.  Otherwise, use the normal logic to decide whether
   or not to create a BLOCK.  */

void
keep_next_level (keep)
     int keep;
{
  keep_next_level_flag = keep;
}

/* Nonzero if the current level needs to have a BLOCK made.  */

int
kept_level_p ()
{
  return (current_binding_level->blocks != NULL_TREE
    || current_binding_level->keep
    || current_binding_level->names != NULL_TREE
    || (current_binding_level->type_decls != NULL
        && !current_binding_level->tag_transparent));
}

/* Returns the kind of the innermost scope.  */

bool
innermost_scope_is_class_p ()
{
  return current_binding_level->parm_flag == 2;
}

static void
declare_namespace_level ()
{
  current_binding_level->namespace_p = 1;
}

/* Returns nonzero if this scope was created to store template
   parameters.  */

int
template_parm_scope_p ()
{
  return current_binding_level->template_parms_p;
}

/* Returns the kind of template specialization we are currently
   processing, given that it's declaration contained N_CLASS_SCOPES
   explicit scope qualifications.  */

tmpl_spec_kind
current_tmpl_spec_kind (n_class_scopes)
     int n_class_scopes;
{
  int n_template_parm_scopes = 0;
  int seen_specialization_p = 0;
  int innermost_specialization_p = 0;
  struct cp_binding_level *b;

  /* Scan through the template parameter scopes.  */
  for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
    {
      /* If we see a specialization scope inside a parameter scope,
   then something is wrong.  That corresponds to a declaration
   like:

      template <class T> template <> ...

   which is always invalid since [temp.expl.spec] forbids the
   specialization of a class member template if the enclosing
   class templates are not explicitly specialized as well.  */
      if (b->template_spec_p)
  {
    if (n_template_parm_scopes == 0)
      innermost_specialization_p = 1;
    else
      seen_specialization_p = 1;
  }
      else if (seen_specialization_p == 1)
  return tsk_invalid_member_spec;

      ++n_template_parm_scopes;
    }

  /* Handle explicit instantiations.  */
  if (processing_explicit_instantiation)
    {
      if (n_template_parm_scopes != 0)
  /* We've seen a template parameter list during an explicit
     instantiation.  For example:

       template <class T> template void f(int);

     This is erroneous.  */
  return tsk_invalid_expl_inst;
      else
  return tsk_expl_inst;
    }

  if (n_template_parm_scopes < n_class_scopes)
    /* We've not seen enough template headers to match all the
       specialized classes present.  For example:

         template <class T> void R<T>::S<T>::f(int);

       This is invalid; there needs to be one set of template
       parameters for each class.  */
    return tsk_insufficient_parms;
  else if (n_template_parm_scopes == n_class_scopes)
    /* We're processing a non-template declaration (even though it may
       be a member of a template class.)  For example:

         template <class T> void S<T>::f(int);

       The `class T' maches the `S<T>', leaving no template headers
       corresponding to the `f'.  */
    return tsk_none;
  else if (n_template_parm_scopes > n_class_scopes + 1)
    /* We've got too many template headers.  For example:

         template <> template <class T> void f (T);

       There need to be more enclosing classes.  */
    return tsk_excessive_parms;
  else
    /* This must be a template.  It's of the form:

         template <class T> template <class U> void S<T>::f(U);

       This is a specialization if the innermost level was a
       specialization; otherwise it's just a definition of the
       template.  */
    return innermost_specialization_p ? tsk_expl_spec : tsk_template;
}

void
set_class_shadows (shadows)
     tree shadows;
{
  class_binding_level->class_shadowed = shadows;
}

/* Enter a new binding level.
   If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
   not for that of tags.  */

void
pushlevel (tag_transparent)
     int tag_transparent;
{
  struct cp_binding_level *newlevel;

  if (cfun && !doing_semantic_analysis_p ())
    return;

  /* Reuse or create a struct for this binding level.  */
  if (!ENABLE_SCOPE_CHECKING && free_binding_level)
    {
      newlevel = free_binding_level;
      free_binding_level = free_binding_level->level_chain;
    }
  else
    newlevel = make_binding_level ();

  push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
  keep_next_level_flag = 0;
}

/* We're defining an object of type TYPE.  If it needs a cleanup, but
   we're not allowed to add any more objects with cleanups to the current
   scope, create a new binding level.  */

void
maybe_push_cleanup_level (type)
     tree type;
{
  if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
      && current_binding_level->more_cleanups_ok == 0)
    {
      keep_next_level (2);
      pushlevel (1);
      clear_last_expr ();
      add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
    }
}
  
/* Enter a new scope.  The KIND indicates what kind of scope is being
   created.  */

void
begin_scope (sk)
     scope_kind sk;
{
  pushlevel (0);

  switch (sk)
    {
    case sk_template_spec:
      current_binding_level->template_spec_p = 1;
      /* Fall through.  */

    case sk_template_parms:
      current_binding_level->template_parms_p = 1;
      break;

    default:
      abort ();
    }
}

/* Exit the current scope.  */

void
finish_scope ()
{
  poplevel (0, 0, 0);
}

void
note_level_for_for ()
{
  current_binding_level->is_for_scope = 1;
}

/* Record that the current binding level represents a try block.  */

void
note_level_for_try ()
{
  current_binding_level->is_try_scope = 1;
}

/* Record that the current binding level represents a catch block.  */

void
note_level_for_catch ()
{
  current_binding_level->is_catch_scope = 1;
}

/* For a binding between a name and an entity at a block scope,
   this is the `struct cp_binding_level' for the block.  */
#define BINDING_LEVEL(NODE) ((NODE)->scope.level)

/* A free list of "cxx_binding"s, connected by their PREVIOUS.  */

static GTY((deletable (""))) cxx_binding *free_bindings;

/* Make DECL the innermost binding for ID.  The LEVEL is the binding
   level at which this declaration is being bound.  */

static void
push_binding (id, decl, level)
     tree id;
     tree decl;
     struct cp_binding_level* level;
{
  cxx_binding *binding;

  if (free_bindings)
    {
      binding = free_bindings;
      free_bindings = binding->previous;
    }
  else
    binding = cxx_binding_make ();

  /* Now, fill in the binding information.  */
  BINDING_VALUE (binding) = decl;
  BINDING_TYPE (binding) = NULL_TREE;
  BINDING_LEVEL (binding) = level;
  INHERITED_VALUE_BINDING_P (binding) = 0;
  LOCAL_BINDING_P (binding) = (level != class_binding_level);
  BINDING_HAS_LEVEL_P (binding) = 1;

  /* And put it on the front of the list of bindings for ID.  */
  binding->previous = IDENTIFIER_BINDING (id);
  IDENTIFIER_BINDING (id) = binding;
}

/* ID is already bound in the current scope.  But, DECL is an
   additional binding for ID in the same scope.  This is the `struct
   stat' hack whereby a non-typedef class-name or enum-name can be
   bound at the same level as some other kind of entity.  It's the
   responsibility of the caller to check that inserting this name is
   valid here.  Returns nonzero if the new binding was successful.  */
static int
add_binding (id, decl)
     tree id;
     tree decl;
{
  cxx_binding *binding = IDENTIFIER_BINDING (id);
  int ok = 1;

  timevar_push (TV_NAME_LOOKUP);
  if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
    /* The new name is the type name.  */
    BINDING_TYPE (binding) = decl;
  else if (!BINDING_VALUE (binding))
    /* This situation arises when push_class_level_binding moves an
       inherited type-binding out of the way to make room for a new
       value binding.  */
    BINDING_VALUE (binding) = decl;
  else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
     && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
    {
      /* The old binding was a type name.  It was placed in
   BINDING_VALUE because it was thought, at the point it was
   declared, to be the only entity with such a name.  Move the
   type name into the type slot; it is now hidden by the new
   binding.  */
      BINDING_TYPE (binding) = BINDING_VALUE (binding);
      BINDING_VALUE (binding) = decl;
      INHERITED_VALUE_BINDING_P (binding) = 0;
    }
  else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
     && TREE_CODE (decl) == TYPE_DECL
     && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
     && (same_type_p (TREE_TYPE (decl),
          TREE_TYPE (BINDING_VALUE (binding)))
         /* If either type involves template parameters, we must
      wait until instantiation.  */
         || uses_template_parms (TREE_TYPE (decl))
         || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
    /* We have two typedef-names, both naming the same type to have
       the same name.  This is OK because of:

         [dcl.typedef]

   In a given scope, a typedef specifier can be used to redefine
   the name of any type declared in that scope to refer to the
   type to which it already refers.  */
    ok = 0;
  /* There can be two block-scope declarations of the same variable,
     so long as they are `extern' declarations.  However, there cannot
     be two declarations of the same static data member:

       [class.mem]

       A member shall not be declared twice in the
       member-specification.  */
  else if (TREE_CODE (decl) == VAR_DECL
     && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
     && DECL_EXTERNAL (decl)
     && DECL_EXTERNAL (BINDING_VALUE (binding))
     && !DECL_CLASS_SCOPE_P (decl))
    {
      duplicate_decls (decl, BINDING_VALUE (binding));
      ok = 0;
    }
  else
    {
      error ("declaration of `%#D'", decl);
      cp_error_at ("conflicts with previous declaration `%#D'",
       BINDING_VALUE (binding));
      ok = 0;
    }

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
}

/* Add DECL to the list of things declared in B.  */

static void
add_decl_to_level (decl, b)
     tree decl;
     struct cp_binding_level *b;
{
  if (TREE_CODE (decl) == NAMESPACE_DECL 
      && !DECL_NAMESPACE_ALIAS (decl))
    {
      TREE_CHAIN (decl) = b->namespaces;
      b->namespaces = decl;
    }
  else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
    {
      TREE_CHAIN (decl) = b->vtables;
      b->vtables = decl;
    }
  else       
    {
      /* We build up the list in reverse order, and reverse it later if
         necessary.  */
      TREE_CHAIN (decl) = b->names;
      b->names = decl;
      b->names_size++;

      /* If appropriate, add decl to separate list of statics */
      if (b->namespace_p)
  if ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
      || (TREE_CODE (decl) == FUNCTION_DECL
    && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
    VARRAY_PUSH_TREE (b->static_decls, decl);
    }
}

/* Bind DECL to ID in the current_binding_level, assumed to be a local
   binding level.  If PUSH_USING is set in FLAGS, we know that DECL
   doesn't really belong to this binding level, that it got here
   through a using-declaration.  */

void
push_local_binding (id, decl, flags)
     tree id;
     tree decl;
     int flags;
{
  struct cp_binding_level *b;

  /* Skip over any local classes.  This makes sense if we call
     push_local_binding with a friend decl of a local class.  */
  b = current_binding_level;
  while (b->parm_flag == 2)
    b = b->level_chain;

  if (lookup_name_current_level (id))
    {
      /* Supplement the existing binding.  */
      if (!add_binding (id, decl))
  /* It didn't work.  Something else must be bound at this
     level.  Do not add DECL to the list of things to pop
     later.  */
  return;
    }
  else
    /* Create a new binding.  */
    push_binding (id, decl, b);

  if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
    /* We must put the OVERLOAD into a TREE_LIST since the
       TREE_CHAIN of an OVERLOAD is already used.  Similarly for
       decls that got here through a using-declaration.  */
    decl = build_tree_list (NULL_TREE, decl);

  /* And put DECL on the list of things declared by the current
     binding level.  */
  add_decl_to_level (decl, b);
}

/* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
   binding was successful.  */

int
push_class_binding (id, decl)
     tree id;
     tree decl;
{
  int result = 1;
  cxx_binding *binding = IDENTIFIER_BINDING (id);
  tree context;

  timevar_push (TV_NAME_LOOKUP);
  /* Note that we declared this value so that we can issue an error if
     this is an invalid redeclaration of a name already used for some
     other purpose.  */
  note_name_declared_in_class (id, decl);

  if (binding && BINDING_LEVEL (binding) == class_binding_level)
    /* Supplement the existing binding.  */
    result = add_binding (id, decl);
  else
    /* Create a new binding.  */
    push_binding (id, decl, class_binding_level);

  /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
     class-level declaration.  Note that we do not use DECL here
     because of the possibility of the `struct stat' hack; if DECL is
     a class-name or enum-name we might prefer a field-name, or some
     such.  */
  IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));

  /* If this is a binding from a base class, mark it as such.  */
  binding = IDENTIFIER_BINDING (id);
  if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
    {
      /* Any implicit typename must be from a base-class.  The
   context for an implicit typename declaration is always
   the derived class in which the lookup was done, so the checks
   based on the context of DECL below will not trigger.  */
      if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
  INHERITED_VALUE_BINDING_P (binding) = 1;
      else
  {
    if (TREE_CODE (decl) == OVERLOAD)
      context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
    else
      {
        my_friendly_assert (DECL_P (decl), 0);
        context = context_for_name_lookup (decl);
      }

    if (is_properly_derived_from (current_class_type, context))
      INHERITED_VALUE_BINDING_P (binding) = 1;
    else
      INHERITED_VALUE_BINDING_P (binding) = 0;
  }
    }
  else if (BINDING_VALUE (binding) == decl)
    /* We only encounter a TREE_LIST when push_class_decls detects an
       ambiguity.  Such an ambiguity can be overridden by a definition
       in this class.  */
    INHERITED_VALUE_BINDING_P (binding) = 1;

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result);
}

/* Remove the binding for DECL which should be the innermost binding
   for ID.  */

static void
pop_binding (id, decl)
     tree id;
     tree decl;
{
  cxx_binding *binding;

  if (id == NULL_TREE)
    /* It's easiest to write the loops that call this function without
       checking whether or not the entities involved have names.  We
       get here for such an entity.  */
    return;

  /* Get the innermost binding for ID.  */
  binding = IDENTIFIER_BINDING (id);

  /* The name should be bound.  */
  my_friendly_assert (binding != NULL, 0);

  /* The DECL will be either the ordinary binding or the type
     binding for this identifier.  Remove that binding.  */
  if (BINDING_VALUE (binding) == decl)
    BINDING_VALUE (binding) = NULL_TREE;
  else if (BINDING_TYPE (binding) == decl)
    BINDING_TYPE (binding) = NULL_TREE;
  else
    abort ();

  if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
    {
      /* We're completely done with the innermost binding for this
   identifier.  Unhook it from the list of bindings.  */
      IDENTIFIER_BINDING (id) = binding->previous;

      /* Add it to the free list.  */
      binding->previous = free_bindings;
      free_bindings = binding;

      /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
   it.  */
      BINDING_LEVEL (binding) = NULL;
    }
}

/* When a label goes out of scope, check to see if that label was used
   in a valid manner, and issue any appropriate warnings or errors.  */

static void
pop_label (label, old_value)
     tree label;
     tree old_value;
{
  if (!processing_template_decl && doing_semantic_analysis_p ())
    {
      if (DECL_INITIAL (label) == NULL_TREE)
  {
    cp_error_at ("label `%D' used but not defined", label);
    /* Avoid crashing later.  */
    define_label (input_filename, 1, DECL_NAME (label));
  }
      else if (warn_unused_label && !TREE_USED (label))
  cp_warning_at ("label `%D' defined but not used", label);
    }

  SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
}

/* At the end of a function, all labels declared within the function
   go out of scope.  BLOCK is the top-level block for the
   function.  */

static void
pop_labels (block)
     tree block;
{
  struct named_label_list *link;

  /* Clear out the definitions of all label names, since their scopes
     end here.  */
  for (link = named_labels; link; link = link->next)
    {
      pop_label (link->label_decl, link->old_value);
      /* Put the labels into the "variables" of the top-level block,
   so debugger can see them.  */
      TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
      BLOCK_VARS (block) = link->label_decl;
    }

  named_labels = NULL;
}

/* Exit a binding level.
   Pop the level off, and restore the state of the identifier-decl mappings
   that were in effect when this level was entered.

   If KEEP == 1, this level had explicit declarations, so
   and create a "block" (a BLOCK node) for the level
   to record its declarations and subblocks for symbol table output.

   If FUNCTIONBODY is nonzero, this level is the body of a function,
   so create a block as if KEEP were set and also clear out all
   label names.

   If REVERSE is nonzero, reverse the order of decls before putting
   them into the BLOCK.  */

tree
poplevel (keep, reverse, functionbody)
     int keep;
     int reverse;
     int functionbody;
{
  register tree link;
  /* The chain of decls was accumulated in reverse order.
     Put it into forward order, just for cleanliness.  */
  tree decls;
  int tmp = functionbody;
  int real_functionbody;
  tree subblocks;
  tree block = NULL_TREE;
  tree decl;
  int leaving_for_scope;

  timevar_push (TV_NAME_LOOKUP);

  if (cfun && !doing_semantic_analysis_p ())
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);

  my_friendly_assert (current_binding_level->parm_flag != 2,
          19990916);

  real_functionbody = (current_binding_level->keep == 2
           ? ((functionbody = 0), tmp) : functionbody);
  subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;

  my_friendly_assert (!current_binding_level->class_shadowed,
          19990414);

  /* We used to use KEEP == 2 to indicate that the new block should go
     at the beginning of the list of blocks at this binding level,
     rather than the end.  This hack is no longer used.  */
  my_friendly_assert (keep == 0 || keep == 1, 0);

  if (current_binding_level->keep == 1)
    keep = 1;

  /* Any uses of undefined labels, and any defined labels, now operate
     under constraints of next binding contour.  */
  if (cfun && !functionbody)
    {
      struct cp_binding_level *level_chain;
      level_chain = current_binding_level->level_chain;
      if (level_chain)
  {
    struct named_label_use_list *uses;
    struct named_label_list *labels;
    for (labels = named_labels; labels; labels = labels->next)
      if (labels->binding_level == current_binding_level)
        {
    tree decl;
    if (current_binding_level->is_try_scope)
      labels->in_try_scope = 1;
    if (current_binding_level->is_catch_scope)
      labels->in_catch_scope = 1;
    for (decl = labels->names_in_scope; decl;
         decl = TREE_CHAIN (decl))
      if (decl_jump_unsafe (decl))
        labels->bad_decls = tree_cons (NULL_TREE, decl,
               labels->bad_decls);
    labels->binding_level = level_chain;
    labels->names_in_scope = level_chain->names;
        }

    for (uses = named_label_uses; uses; uses = uses->next)
      if (uses->binding_level == current_binding_level)
        {
    uses->binding_level = level_chain;
    uses->names_in_scope = level_chain->names;
        }
  }
    }

  /* Get the decls in the order they were written.
     Usually current_binding_level->names is in reverse order.
     But parameter decls were previously put in forward order.  */

  if (reverse)
    current_binding_level->names
      = decls = nreverse (current_binding_level->names);
  else
    decls = current_binding_level->names;

  /* Output any nested inline functions within this block
     if they weren't already output.  */
  for (decl = decls; decl; decl = TREE_CHAIN (decl))
    if (TREE_CODE (decl) == FUNCTION_DECL
  && ! TREE_ASM_WRITTEN (decl)
  && DECL_INITIAL (decl) != NULL_TREE
  && TREE_ADDRESSABLE (decl)
  && decl_function_context (decl) == current_function_decl)
      {
  /* If this decl was copied from a file-scope decl
     on account of a block-scope extern decl,
     propagate TREE_ADDRESSABLE to the file-scope decl.  */
  if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
    TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
  else
    {
      push_function_context ();
      output_inline_function (decl);
      pop_function_context ();
    }
      }

  /* When not in function-at-a-time mode, expand_end_bindings will
     warn about unused variables.  But, in function-at-a-time mode
     expand_end_bindings is not passed the list of variables in the
     current scope, and therefore no warning is emitted.  So, we
     explicitly warn here.  */
  if (!processing_template_decl)
    warn_about_unused_variables (getdecls ());

  /* If there were any declarations or structure tags in that level,
     or if this level is a function body,
     create a BLOCK to record them for the life of this function.  */
  block = NULL_TREE;
  if (keep == 1 || functionbody)
    block = make_node (BLOCK);
  if (block != NULL_TREE)
    {
      BLOCK_VARS (block) = decls;
      BLOCK_SUBBLOCKS (block) = subblocks;
    }

  /* In each subblock, record that this is its superior.  */
  if (keep >= 0)
    for (link = subblocks; link; link = TREE_CHAIN (link))
      BLOCK_SUPERCONTEXT (link) = block;

  /* We still support the old for-scope rules, whereby the variables
     in a for-init statement were in scope after the for-statement
     ended.  We only use the new rules in flag_new_for_scope is
     nonzero.  */
  leaving_for_scope
    = current_binding_level->is_for_scope && flag_new_for_scope == 1;

  /* Remove declarations for all the DECLs in this level.  */
  for (link = decls; link; link = TREE_CHAIN (link))
    {
      if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
          && DECL_NAME (link))
  {
    cxx_binding *outer_binding
      = IDENTIFIER_BINDING (DECL_NAME (link))->previous;
    tree ns_binding;

    if (!outer_binding)
      ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
    else
      ns_binding = NULL_TREE;

    if (outer_binding
        && (BINDING_LEVEL (outer_binding)
      == current_binding_level->level_chain))
      /* We have something like:

           int i;
           for (int i; ;);

         and we are leaving the `for' scope.  There's no reason to
         keep the binding of the inner `i' in this case.  */
      pop_binding (DECL_NAME (link), link);
    else if ((outer_binding
        && (TREE_CODE (BINDING_VALUE (outer_binding))
      == TYPE_DECL))
       || (ns_binding
           && TREE_CODE (ns_binding) == TYPE_DECL))
      /* Here, we have something like:

     typedef int I;

     void f () {
       for (int I; ;);
     }

         We must pop the for-scope binding so we know what's a
         type and what isn't.  */
      pop_binding (DECL_NAME (link), link);
    else
      {
        /* Mark this VAR_DECL as dead so that we can tell we left it
     there only for backward compatibility.  */
        DECL_DEAD_FOR_LOCAL (link) = 1;

        /* Keep track of what should of have happenned when we
     popped the binding.  */
        if (outer_binding && BINDING_VALUE (outer_binding))
    DECL_SHADOWED_FOR_VAR (link)
      = BINDING_VALUE (outer_binding);

        /* Add it to the list of dead variables in the next
     outermost binding to that we can remove these when we
     leave that binding.  */
        current_binding_level->level_chain->dead_vars_from_for
    = tree_cons (NULL_TREE, link,
           current_binding_level->level_chain->
           dead_vars_from_for);

        /* Although we don't pop the cxx_binding, we do clear
     its BINDING_LEVEL since the level is going away now.  */
        BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
    = 0;
      }
  }
      else
  {
    /* Remove the binding.  */
    decl = link;
    if (TREE_CODE (decl) == TREE_LIST)
      decl = TREE_VALUE (decl);
    if (DECL_P (decl))
      pop_binding (DECL_NAME (decl), decl);
    else if (TREE_CODE (decl) == OVERLOAD)
      pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
    else
      abort ();
  }
    }

  /* Remove declarations for any `for' variables from inner scopes
     that we kept around.  */
  for (link = current_binding_level->dead_vars_from_for;
       link; link = TREE_CHAIN (link))
    pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));

  /* Restore the IDENTIFIER_TYPE_VALUEs.  */
  for (link = current_binding_level->type_shadowed;
       link; link = TREE_CHAIN (link))
    SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));

  /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
  for (link = current_binding_level->shadowed_labels;
       link;
       link = TREE_CHAIN (link))
    pop_label (TREE_VALUE (link), TREE_PURPOSE (link));

  /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
     list if a `using' declaration put them there.  The debugging
     back-ends won't understand OVERLOAD, so we remove them here.
     Because the BLOCK_VARS are (temporarily) shared with
     CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
     popped all the bindings.  */
  if (block)
    {
      tree* d;

      for (d = &BLOCK_VARS (block); *d; )
  {
    if (TREE_CODE (*d) == TREE_LIST)
      *d = TREE_CHAIN (*d);
    else
      d = &TREE_CHAIN (*d);
  }
    }

  /* If the level being exited is the top level of a function,
     check over all the labels.  */
  if (functionbody)
    {
      /* Since this is the top level block of a function, the vars are
   the function's parameters.  Don't leave them in the BLOCK
   because they are found in the FUNCTION_DECL instead.  */
      BLOCK_VARS (block) = 0;
      pop_labels (block);
    }

  tmp = current_binding_level->keep;

  pop_binding_level ();
  if (functionbody)
    DECL_INITIAL (current_function_decl) = block;
  else if (block)
    current_binding_level->blocks
      = chainon (current_binding_level->blocks, block);

  /* If we did not make a block for the level just exited,
     any blocks made for inner levels
     (since they cannot be recorded as subblocks in that level)
     must be carried forward so they will later become subblocks
     of something else.  */
  else if (subblocks)
    current_binding_level->blocks
      = chainon (current_binding_level->blocks, subblocks);

  /* Each and every BLOCK node created here in `poplevel' is important
     (e.g. for proper debugging information) so if we created one
     earlier, mark it as "used".  */
  if (block)
    TREE_USED (block) = 1;

  /* Take care of compiler's internal binding structures.  */
  if (tmp == 2)
    {
      tree scope_stmts;

      scope_stmts
  = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
      if (block)
  {
    SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
    SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
  }

      block = poplevel (keep, reverse, functionbody);
    }

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
}

/* Delete the node BLOCK from the current binding level.
   This is used for the block inside a stmt expr ({...})
   so that the block can be reinserted where appropriate.  */

void
delete_block (block)
     tree block;
{
  tree t;
  if (current_binding_level->blocks == block)
    current_binding_level->blocks = TREE_CHAIN (block);
  for (t = current_binding_level->blocks; t;)
    {
      if (TREE_CHAIN (t) == block)
  TREE_CHAIN (t) = TREE_CHAIN (block);
      else
  t = TREE_CHAIN (t);
    }
  TREE_CHAIN (block) = NULL_TREE;
  /* Clear TREE_USED which is always set by poplevel.
     The flag is set again if insert_block is called.  */
  TREE_USED (block) = 0;
}

/* Insert BLOCK at the end of the list of subblocks of the
   current binding level.  This is used when a BIND_EXPR is expanded,
   to handle the BLOCK node inside the BIND_EXPR.  */

void
insert_block (block)
     tree block;
{
  TREE_USED (block) = 1;
  current_binding_level->blocks
    = chainon (current_binding_level->blocks, block);
}

/* Set the BLOCK node for the innermost scope
   (the one we are currently in).  */

void
set_block (block)
    tree block ATTRIBUTE_UNUSED;
{
  /* The RTL expansion machinery requires us to provide this callback,
     but it is not applicable in function-at-a-time mode.  */
  my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
}

/* Do a pushlevel for class declarations.  */

void
pushlevel_class ()
{
  register struct cp_binding_level *newlevel;

  /* Reuse or create a struct for this binding level.  */
  if (!ENABLE_SCOPE_CHECKING && free_binding_level)
    {
      newlevel = free_binding_level;
      free_binding_level = free_binding_level->level_chain;
    }
  else
    newlevel = make_binding_level ();

  if (ENABLE_SCOPE_CHECKING)
    is_class_level = 1;

  push_binding_level (newlevel, 0, 0);

  class_binding_level = current_binding_level;
  class_binding_level->parm_flag = 2;
  class_binding_level->this_class = current_class_type;
}

/* ...and a poplevel for class declarations.  */

void
poplevel_class ()
{
  register struct cp_binding_level *level = class_binding_level;
  tree shadowed;

  timevar_push (TV_NAME_LOOKUP);

  my_friendly_assert (level != 0, 354);

  /* If we're leaving a toplevel class, don't bother to do the setting
     of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
     shouldn't even be used when current_class_type isn't set, and second,
     if we don't touch it here, we're able to use the cache effect if the
     next time we're entering a class scope, it is the same class.  */
  if (current_class_depth != 1)
    {
      struct cp_binding_level* b;

      /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
      for (shadowed = level->class_shadowed;
     shadowed;
     shadowed = TREE_CHAIN (shadowed))
  IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;

      /* Find the next enclosing class, and recreate
   IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
      b = level->level_chain;
      while (b && b->parm_flag != 2)
  b = b->level_chain;

      if (b)
  for (shadowed = b->class_shadowed;
       shadowed;
       shadowed = TREE_CHAIN (shadowed))
    {
      cxx_binding *binding;

      binding = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
      while (binding && BINDING_LEVEL (binding) != b)
        binding = binding->previous;

      if (binding)
        IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
    = BINDING_VALUE (binding);
    }
    }
  else
    /* Remember to save what IDENTIFIER's were bound in this scope so we
       can recover from cache misses.  */
    {
      previous_class_type = current_class_type;
      previous_class_values = class_binding_level->class_shadowed;
    }
  for (shadowed = level->type_shadowed;
       shadowed;
       shadowed = TREE_CHAIN (shadowed))
    SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));

  /* Remove the bindings for all of the class-level declarations.  */
  for (shadowed = level->class_shadowed;
       shadowed;
       shadowed = TREE_CHAIN (shadowed))
    pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));

  /* Now, pop out of the binding level which we created up in the
     `pushlevel_class' routine.  */
  if (ENABLE_SCOPE_CHECKING)
    is_class_level = 1;

  pop_binding_level ();

  timevar_pop (TV_NAME_LOOKUP);
}

/* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
   for any names in enclosing classes.  */

void
clear_identifier_class_values ()
{
  tree t;

  if (!class_binding_level)
    return;

  for (t = class_binding_level->class_shadowed;
       t;
       t = TREE_CHAIN (t))
    IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
}

/* Returns nonzero if T is a virtual function table.  */

int
vtable_decl_p (t, data)
     tree t;
     void *data ATTRIBUTE_UNUSED;
{
  return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
}

/* Returns nonzero if T is a TYPE_DECL for a type with virtual
   functions.  */

int
vtype_decl_p (t, data)
     tree t;
     void *data ATTRIBUTE_UNUSED;
{
  return (TREE_CODE (t) == TYPE_DECL
    && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
    && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
}

/* Return the declarations that are members of the namespace NS.  */

tree
cp_namespace_decls (ns)
     tree ns;
{
  return NAMESPACE_LEVEL (ns)->names;
}

struct walk_globals_data {
  walk_globals_pred p;
  walk_globals_fn f;
  void *data;
};

/* Walk the vtable declarations in NAMESPACE.  Whenever one is found
   for which P returns nonzero, call F with its address.  If any call
   to F returns a nonzero value, return a nonzero value.  */

static int
walk_vtables_r (namespace, data)
     tree namespace;
     void *data;
{
  struct walk_globals_data* wgd = (struct walk_globals_data *) data;
  walk_globals_fn f = wgd->f;
  void *d = wgd->data;
  tree decl = NAMESPACE_LEVEL (namespace)->vtables;
  int result = 0;

  for (; decl ; decl = TREE_CHAIN (decl))
    result |= (*f) (&decl, d);

  return result;
}

/* Walk the vtable declarations.  Whenever one is found for which P
   returns nonzero, call F with its address.  If any call to F
   returns a nonzero value, return a nonzero value.  */
int
walk_vtables (p, f, data)
     walk_globals_pred p;
     walk_globals_fn f;
     void *data;
{    
  struct walk_globals_data wgd;
  wgd.p = p;    
  wgd.f = f;
  wgd.data = data;

  return walk_namespaces (walk_vtables_r, &wgd);
}

/* Walk all the namespaces contained NAMESPACE, including NAMESPACE
   itself, calling F for each.  The DATA is passed to F as well.  */

static int
walk_namespaces_r (namespace, f, data)
     tree namespace;
     walk_namespaces_fn f;
     void *data;
{
  int result = 0;
  tree current = NAMESPACE_LEVEL (namespace)->namespaces;     

  result |= (*f) (namespace, data);

  for (; current; current = TREE_CHAIN (current))
    result |= walk_namespaces_r (current, f, data);

  return result;
}

/* Walk all the namespaces, calling F for each.  The DATA is passed to
   F as well.  */

int
walk_namespaces (f, data)
     walk_namespaces_fn f;
     void *data;
{
  return walk_namespaces_r (global_namespace, f, data);
}

/* Walk the global declarations in NAMESPACE.  Whenever one is found
   for which P returns nonzero, call F with its address.  If any call
   to F returns a nonzero value, return a nonzero value.  */

static int
walk_globals_r (namespace, data)
     tree namespace;
     void *data;
{
  struct walk_globals_data* wgd = (struct walk_globals_data *) data;
  walk_globals_pred p = wgd->p;
  walk_globals_fn f = wgd->f;
  void *d = wgd->data;
  tree *t;
  int result = 0;

  t = &NAMESPACE_LEVEL (namespace)->names;

  while (*t)
    {
      tree glbl = *t;

      if ((*p) (glbl, d))
  result |= (*f) (t, d);

      /* If F changed *T, then *T still points at the next item to
   examine.  */
      if (*t == glbl)
  t = &TREE_CHAIN (*t);
    }

  return result;
}

/* Walk the global declarations.  Whenever one is found for which P
   returns nonzero, call F with its address.  If any call to F
   returns a nonzero value, return a nonzero value.  */

int
walk_globals (p, f, data)
     walk_globals_pred p;
     walk_globals_fn f;
     void *data;
{
  struct walk_globals_data wgd;
  wgd.p = p;
  wgd.f = f;
  wgd.data = data;

  return walk_namespaces (walk_globals_r, &wgd);
}

/* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
   DATA is non-NULL, this is the last time we will call
   wrapup_global_declarations for this NAMESPACE.  */

int
wrapup_globals_for_namespace (namespace, data)
     tree namespace;
     void *data;
{
  struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
  varray_type statics = level->static_decls;
  tree *vec = &VARRAY_TREE (statics, 0);
  int len = VARRAY_ACTIVE_SIZE (statics);
  int last_time = (data != 0);

  if (last_time)
    {
      check_global_declarations (vec, len);
      return 0;
    }

  /* Write out any globals that need to be output.  */
  return wrapup_global_declarations (vec, len);
}


/* For debugging.  */
static int no_print_functions = 0;
static int no_print_builtins = 0;

/* Called from print_binding_level through binding_table_foreach to
   print the content of binding ENTRY.  DATA is a pointer to line offset
   marker.  */
static void
bt_print_entry (binding_entry entry, void *data)
{
  int *p = (int *) data;
  int len;

  if (entry->name == NULL)
    len = 3;
  else if (entry->name == TYPE_IDENTIFIER (entry->type))
    len = 2;
  else
    len = 4;

  *p += len;

  if (*p > 5)
    {
      fprintf (stderr, "\n\t");
      *p = len;
    }
  if (entry->name == NULL)
    {
      print_node_brief (stderr, "<unnamed-typedef", entry->type, 0);
      fprintf (stderr, ">");
    }
  else if (entry->name == TYPE_IDENTIFIER (entry->type))
    print_node_brief (stderr, "", entry->type, 0);
  else
    {
      print_node_brief (stderr, "<typedef", entry->name, 0);
      print_node_brief (stderr, "", entry->type, 0);
      fprintf (stderr, ">");
    }
}

void
print_binding_level (lvl)
     struct cp_binding_level *lvl;
{
  tree t;
  int i = 0, len;
  fprintf (stderr, " blocks=");
  fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
  if (lvl->tag_transparent)
    fprintf (stderr, " tag-transparent");
  if (lvl->more_cleanups_ok)
    fprintf (stderr, " more-cleanups-ok");
  if (lvl->have_cleanups)
    fprintf (stderr, " have-cleanups");
  fprintf (stderr, "\n");
  if (lvl->names)
    {
      fprintf (stderr, " names:\t");
      /* We can probably fit 3 names to a line?  */
      for (t = lvl->names; t; t = TREE_CHAIN (t))
  {
    if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
      continue;
    if (no_print_builtins
        && (TREE_CODE (t) == TYPE_DECL)
        && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
      continue;

    /* Function decls tend to have longer names.  */
    if (TREE_CODE (t) == FUNCTION_DECL)
      len = 3;
    else
      len = 2;
    i += len;
    if (i > 6)
      {
        fprintf (stderr, "\n\t");
        i = len;
      }
    print_node_brief (stderr, "", t, 0);
    if (t == error_mark_node)
      break;
  }
      if (i)
        fprintf (stderr, "\n");
    }
  if (lvl->type_decls)
    {
      fprintf (stderr, " tags:\t");
      i = 0;
      binding_table_foreach (lvl->type_decls, bt_print_entry, &i);
      if (i)
  fprintf (stderr, "\n");
    }
  if (lvl->class_shadowed)
    {
      fprintf (stderr, " class-shadowed:");
      for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
  {
    fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
  }
      fprintf (stderr, "\n");
    }
  if (lvl->type_shadowed)
    {
      fprintf (stderr, " type-shadowed:");
      for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
        {
    fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
        }
      fprintf (stderr, "\n");
    }
}

void
print_other_binding_stack (stack)
     struct cp_binding_level *stack;
{
  struct cp_binding_level *level;
  for (level = stack; !global_scope_p (level); level = level->level_chain)
    {
      fprintf (stderr, "binding level ");
      fprintf (stderr, HOST_PTR_PRINTF, level);
      fprintf (stderr, "\n");
      print_binding_level (level);
    }
}

void
print_binding_stack ()
{
  struct cp_binding_level *b;
  fprintf (stderr, "current_binding_level=");
  fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
  fprintf (stderr, "\nclass_binding_level=");
  fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
  fprintf (stderr, "\nNAMESPACE_LEVEL (global_namespace)=");
  fprintf (stderr, HOST_PTR_PRINTF,
           (void *) NAMESPACE_LEVEL (global_namespace));
  fprintf (stderr, "\n");
  if (class_binding_level)
    {
      for (b = class_binding_level; b; b = b->level_chain)
  if (b == current_binding_level)
    break;
      if (b)
  b = class_binding_level;
      else
  b = current_binding_level;
    }
  else
    b = current_binding_level;
  print_other_binding_stack (b);
  fprintf (stderr, "global:\n");
  print_binding_level (NAMESPACE_LEVEL (global_namespace));
}

/* Namespace binding access routines.   */

/* Check whether the a binding for the name to scope is known.
   Returns the binding found, or NULL.  */

static inline cxx_binding *
find_binding (tree name, tree scope, cxx_binding *front)
{
  cxx_binding *iter;
  cxx_binding *prev = NULL;

  timevar_push (TV_NAME_LOOKUP);

  for (iter = front; iter; iter = iter->previous)
    {
      if (BINDING_SCOPE (iter) == scope)
  {
    /* Move binding found to the front of the list, so
             subsequent lookups will find it faster.  */
    if (prev)
      {
        prev->previous = iter->previous;
        iter->previous = front;
        IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
      }
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, iter);
  }
      prev = iter;
    }
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL);
}

/* Return the binding for NAME in SCOPE, if any.  Otherwise, return NULL.  */
cxx_binding *
cxx_scope_find_binding_for_name (tree scope, tree name)
{
  cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
  if (b)
    {
      scope = ORIGINAL_NAMESPACE (scope);
      /* Fold-in case where NAME is used only once.  */
      if (scope == BINDING_SCOPE (b) && b->previous == NULL)
        return b;
      return find_binding (name, scope, b);
    }
  return b;
}


/* Always returns a binding for name in scope.
   If no binding is found, make a new one.  */

cxx_binding *
binding_for_name (tree name, tree scope)
{
  cxx_binding *result;

  scope = ORIGINAL_NAMESPACE (scope);
  result = cxx_scope_find_binding_for_name (scope, name);
  if (result)
    return result;
  /* Not found, make a new one.  */
  result = cxx_binding_make ();
  result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
  BINDING_TYPE (result) = NULL_TREE;
  BINDING_VALUE (result) = NULL_TREE;
  BINDING_SCOPE (result) = scope;
  result->is_local = false;
  result->value_is_inherited = false;
  result->has_level = false;
  IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
  return result;
}

/* Return the binding value for name in scope.  */

tree
namespace_binding (tree name, tree scope)
{
  cxx_binding *b =
    cxx_scope_find_binding_for_name (scope ? scope : global_namespace, name);

  return b ? b->value : NULL_TREE;
}

/* Set the binding value for name in scope.  */

void
set_namespace_binding (name, scope, val)
     tree name;
     tree scope;
     tree val;
{
  cxx_binding *b;

  timevar_push (TV_NAME_LOOKUP);
  if (scope == NULL_TREE)
    scope = global_namespace;

  b = binding_for_name (name, scope);
  BINDING_VALUE (b) = val;
  timevar_pop (TV_NAME_LOOKUP);
}

/* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
   select a name that is unique to this compilation unit.  */

void
push_namespace (name)
     tree name;
{
  tree d = NULL_TREE;
  int need_new = 1;
  int implicit_use = 0;
  int global = 0;
  
  timevar_push (TV_NAME_LOOKUP);
  
  if (!global_namespace)
    {
      /* This must be ::.  */
      my_friendly_assert (name == get_identifier ("::"), 377);
      global = 1;
    }
  else if (!name)
    {
      /* The name of anonymous namespace is unique for the translation
         unit.  */
      if (!anonymous_namespace_name)
        anonymous_namespace_name = get_file_function_name ('N');
      name = anonymous_namespace_name;
      d = IDENTIFIER_NAMESPACE_VALUE (name);
      if (d)
        /* Reopening anonymous namespace.  */
        need_new = 0;
      implicit_use = 1;
    }
  else
    {
      /* Check whether this is an extended namespace definition.  */
      d = IDENTIFIER_NAMESPACE_VALUE (name);
      if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
        {
          need_new = 0;
          if (DECL_NAMESPACE_ALIAS (d))
            {
              error ("namespace alias `%D' not allowed here, assuming `%D'",
                        d, DECL_NAMESPACE_ALIAS (d));
              d = DECL_NAMESPACE_ALIAS (d);
            }
        }
    }

  if (need_new)
    {
      /* Make a new namespace, binding the name to it.  */
      d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
      /* The global namespace is not pushed, and the global binding
   level is set elsewhere.  */
      if (!global)
  {
    DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
    d = pushdecl (d);
    pushlevel (0);
    declare_namespace_level ();
    NAMESPACE_LEVEL (d) = current_binding_level;
          current_binding_level->type_decls =
            binding_table_new (name == std_identifier
                               ? NAMESPACE_STD_HT_SIZE
                               : NAMESPACE_ORDINARY_HT_SIZE);
    VARRAY_TREE_INIT (current_binding_level->static_decls,
          name != std_identifier ? 10 : 200,
          "Static declarations");
  }
    }
  else
    resume_binding_level (NAMESPACE_LEVEL (d));

  if (implicit_use)
    do_using_directive (d);
  /* Enter the name space.  */
  current_namespace = d;

  timevar_pop (TV_NAME_LOOKUP);
}

/* Pop from the scope of the current namespace.  */

void
pop_namespace ()
{
  my_friendly_assert (current_namespace != global_namespace, 20010801);
  current_namespace = CP_DECL_CONTEXT (current_namespace);
  /* The binding level is not popped, as it might be re-opened later.  */
  suspend_binding_level ();
}

/* Push into the scope of the namespace NS, even if it is deeply
   nested within another namespace.  */

void
push_nested_namespace (ns)
     tree ns;
{
  if (ns == global_namespace)
    push_to_top_level ();
  else
    {
      push_nested_namespace (CP_DECL_CONTEXT (ns));
      push_namespace (DECL_NAME (ns));
    }
}

/* Pop back from the scope of the namespace NS, which was previously
   entered with push_nested_namespace.  */

void
pop_nested_namespace (ns)
     tree ns;
{
  timevar_push (TV_NAME_LOOKUP);
  while (ns != global_namespace)
    {
      pop_namespace ();
      ns = CP_DECL_CONTEXT (ns);
    }

  pop_from_top_level ();
  timevar_pop (TV_NAME_LOOKUP);
}


/* Allocate storage for saving a C++ binding.  */
#define cxx_saved_binding_make() \
  (ggc_alloc (sizeof (cxx_saved_binding)))

struct cxx_saved_binding GTY(())
{
  /* Link that chains saved C++ bindings for a given name into a stack.  */
  cxx_saved_binding *previous;
  /* The name of the current binding.  */
  tree identifier;
  /* The binding we're saving.  */
  cxx_binding *binding;
  tree class_value;
  tree real_type_value;
};

/* Subroutines for reverting temporarily to top-level for instantiation
   of templates and such.  We actually need to clear out the class- and
   local-value slots of all identifiers, so that only the global values
   are at all visible.  Simply setting current_binding_level to the global
   scope isn't enough, because more binding levels may be pushed.  */
struct saved_scope *scope_chain;

static cxx_saved_binding *
store_bindings (tree names, cxx_saved_binding *old_bindings)
{
  tree t;
  cxx_saved_binding *search_bindings = old_bindings;

  timevar_push (TV_NAME_LOOKUP);
  for (t = names; t; t = TREE_CHAIN (t))
    {
      tree id;
      cxx_saved_binding *saved;
      cxx_saved_binding *t1;

      if (TREE_CODE (t) == TREE_LIST)
  id = TREE_PURPOSE (t);
      else
  id = DECL_NAME (t);

      if (!id
    /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
       we have no IDENTIFIER_BINDING if we have left the class
       scope, but cached the class-level declarations.  */
    || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
  continue;

      for (t1 = search_bindings; t1; t1 = t1->previous)
  if (t1->identifier == id)
    goto skip_it;

      my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
      saved = cxx_saved_binding_make ();
      saved->previous = old_bindings;
      saved->identifier = id;
      saved->binding = IDENTIFIER_BINDING (id);
      saved->class_value = IDENTIFIER_CLASS_VALUE (id);;
      saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
      IDENTIFIER_BINDING (id) = NULL;
      IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
      old_bindings = saved;
    skip_it:
      ;
    }
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings);
}

void
maybe_push_to_top_level (pseudo)
     int pseudo;
{
  struct saved_scope *s;
  struct cp_binding_level *b;
  cxx_saved_binding *old_bindings;
  int need_pop;

  timevar_push (TV_NAME_LOOKUP);

  s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));

  b = scope_chain ? current_binding_level : 0;

  /* If we're in the middle of some function, save our state.  */
  if (cfun)
    {
      need_pop = 1;
      push_function_context_to (NULL_TREE);
    }
  else
    need_pop = 0;

  old_bindings = NULL;
  if (scope_chain && previous_class_type)
    old_bindings = store_bindings (previous_class_values, old_bindings);

  /* Have to include the global scope, because class-scope decls
     aren't listed anywhere useful.  */
  for (; b; b = b->level_chain)
    {
      tree t;

      /* Template IDs are inserted into the global level. If they were
   inserted into namespace level, finish_file wouldn't find them
   when doing pending instantiations. Therefore, don't stop at
   namespace level, but continue until :: .  */
      if (global_scope_p (b) || (pseudo && b->template_parms_p))
  break;

      old_bindings = store_bindings (b->names, old_bindings);
      /* We also need to check class_shadowed to save class-level type
   bindings, since pushclass doesn't fill in b->names.  */
      if (b->parm_flag == 2)
  old_bindings = store_bindings (b->class_shadowed, old_bindings);

      /* Unwind type-value slots back to top level.  */
      for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
  SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
    }
  s->prev = scope_chain;
  s->old_bindings = old_bindings;
  s->bindings = b;
  s->need_pop_function_context = need_pop;
  s->function_decl = current_function_decl;
  s->last_parms = last_function_parms;

  scope_chain = s;
  current_function_decl = NULL_TREE;
  VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
  current_lang_name = lang_name_cplusplus;
  current_namespace = global_namespace;
  timevar_pop (TV_NAME_LOOKUP);
}

void
push_to_top_level ()
{
  maybe_push_to_top_level (0);
}

void
pop_from_top_level ()
{
  struct saved_scope *s = scope_chain;
  cxx_saved_binding *saved;

  timevar_push (TV_NAME_LOOKUP);

  /* Clear out class-level bindings cache.  */
  if (previous_class_type)
    invalidate_class_lookup_cache ();

  current_lang_base = 0;

  scope_chain = s->prev;
  for (saved = s->old_bindings; saved; saved = saved->previous)
    {
      tree id = saved->identifier;

      IDENTIFIER_BINDING (id) = saved->binding;
      IDENTIFIER_CLASS_VALUE (id) = saved->class_value;
      SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
    }

  /* If we were in the middle of compiling a function, restore our
     state.  */
  if (s->need_pop_function_context)
    pop_function_context_from (NULL_TREE);
  current_function_decl = s->function_decl;
  last_function_parms = s->last_parms;

  timevar_pop (TV_NAME_LOOKUP);
}

/* Push a definition of struct, union or enum tag "name".
   into binding_level "b".   "type" should be the type node,
   We assume that the tag "name" is not already defined.

   Note that the definition may really be just a forward reference.
   In that case, the TYPE_SIZE will be a NULL_TREE.

   C++ gratuitously puts all these tags in the name space.  */

/* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
   record the shadowed value for this binding contour.  TYPE is
   the type that ID maps to.  */

static void
set_identifier_type_value_with_scope (id, type, b)
     tree id;
     tree type;
     struct cp_binding_level *b;
{
  if (!b->namespace_p)
    {
      /* Shadow the marker, not the real thing, so that the marker
   gets restored later.  */
      tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
      b->type_shadowed
  = tree_cons (id, old_type_value, b->type_shadowed);
    }
  else
    {
      cxx_binding *binding = binding_for_name (id, current_namespace);
      BINDING_TYPE (binding) = type;
      /* Store marker instead of real type.  */
      type = global_type_node;
    }
  SET_IDENTIFIER_TYPE_VALUE (id, type);
}

/* As set_identifier_type_value_with_scope, but using current_binding_level.  */

void
set_identifier_type_value (id, type)
     tree id;
     tree type;
{
  set_identifier_type_value_with_scope (id, type, current_binding_level);
}

/* Return the type associated with id.  */

tree
identifier_type_value (id)
     tree id;
{
  timevar_push (TV_NAME_LOOKUP);
  /* There is no type with that name, anywhere.  */
  if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
  /* This is not the type marker, but the real thing.  */
  if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
  /* Have to search for it. It must be on the global level, now.
     Ask lookup_name not to return non-types.  */
  id = lookup_name_real (id, 2, 1, 0);
  if (id)
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
}

/* Pop off extraneous binding levels left over due to syntax errors.

   We don't pop past namespaces, as they might be valid.  */

void
pop_everything ()
{
  if (ENABLE_SCOPE_CHECKING)
    verbatim ("XXX entering pop_everything ()\n");
  while (!toplevel_bindings_p ())
    {
      if (current_binding_level->parm_flag == 2)
  pop_nested_class ();
      else
  poplevel (0, 0, 0);
    }
  if (ENABLE_SCOPE_CHECKING)
    verbatim ("XXX leaving pop_everything ()\n");
}

/* The type TYPE is being declared.  If it is a class template, or a
   specialization of a class template, do any processing required and
   perform error-checking.  If IS_FRIEND is nonzero, this TYPE is
   being declared a friend.  B is the binding level at which this TYPE
   should be bound.

   Returns the TYPE_DECL for TYPE, which may have been altered by this
   processing.  */

static tree
maybe_process_template_type_declaration (type, globalize, b)
     tree type;
     int globalize;
     struct cp_binding_level* b;
{
  tree decl = TYPE_NAME (type);

  if (processing_template_parmlist)
    /* You can't declare a new template type in a template parameter
       list.  But, you can declare a non-template type:

         template <class A*> struct S;

       is a forward-declaration of `A'.  */
    ;
  else
    {
      maybe_check_template_type (type);

      my_friendly_assert (IS_AGGR_TYPE (type)
        || TREE_CODE (type) == ENUMERAL_TYPE, 0);


      if (processing_template_decl)
  {
    /* This may change after the call to
       push_template_decl_real, but we want the original value.  */
    tree name = DECL_NAME (decl);

    decl = push_template_decl_real (decl, globalize);
    /* If the current binding level is the binding level for the
       template parameters (see the comment in
       begin_template_parm_list) and the enclosing level is a class
       scope, and we're not looking at a friend, push the
       declaration of the member class into the class scope.  In the
       friend case, push_template_decl will already have put the
       friend into global scope, if appropriate.  */
    if (TREE_CODE (type) != ENUMERAL_TYPE
        && !globalize && b->template_parms_p
        && b->level_chain->parm_flag == 2)
      {
        finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
        /* Put this tag on the list of tags for the class, since
     that won't happen below because B is not the class
     binding level, but is instead the pseudo-global level.  */
              if (b->level_chain->type_decls == NULL)
                b->level_chain->type_decls =
                  binding_table_new (SCOPE_DEFAULT_HT_SIZE);
              binding_table_insert (b->level_chain->type_decls, name, type);
        if (!COMPLETE_TYPE_P (current_class_type))
    {
      maybe_add_class_template_decl_list (current_class_type,
                  type, /*friend_p=*/0);
      CLASSTYPE_NESTED_UDTS (current_class_type) =
                    b->level_chain->type_decls;
    }
      }
  }
    }

  return decl;
}

/* In C++, you don't have to write `struct S' to refer to `S'; you
   can just use `S'.  We accomplish this by creating a TYPE_DECL as
   if the user had written `typedef struct S S'.  Create and return
   the TYPE_DECL for TYPE.  */

tree
create_implicit_typedef (name, type)
     tree name;
     tree type;
{
  tree decl;

  decl = build_decl (TYPE_DECL, name, type);
  DECL_ARTIFICIAL (decl) = 1;
  /* There are other implicit type declarations, like the one *within*
     a class that allows you to write `S::S'.  We must distinguish
     amongst these.  */
  SET_DECL_IMPLICIT_TYPEDEF_P (decl);
  TYPE_NAME (type) = decl;

  return decl;
}

/* Remember a local name for name-mangling purposes.  */

static void
push_local_name (decl)
     tree decl;
{
  size_t i, nelts;
  tree t, name;

  timevar_push (TV_NAME_LOOKUP);

  if (!local_names)
    VARRAY_TREE_INIT (local_names, 8, "local_names");

  name = DECL_NAME (decl);

  nelts = VARRAY_ACTIVE_SIZE (local_names);
  for (i = 0; i < nelts; i++)
    {
      t = VARRAY_TREE (local_names, i);
      if (DECL_NAME (t) == name)
  {
    if (!DECL_LANG_SPECIFIC (decl))
      retrofit_lang_decl (decl);
    DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
    if (DECL_LANG_SPECIFIC (t))
      DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
    else
      DECL_DISCRIMINATOR (decl) = 1;

    VARRAY_TREE (local_names, i) = decl;
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
  }
    }

  VARRAY_PUSH_TREE (local_names, decl);
  timevar_pop (TV_NAME_LOOKUP);
}

/* Push a tag name NAME for struct/class/union/enum type TYPE.
   Normally put it into the inner-most non-tag-transparent scope,
   but if GLOBALIZE is true, put it in the inner-most non-class scope.
   The latter is needed for implicit declarations.  */

void
pushtag (name, type, globalize)
     tree name, type;
     int globalize;
{
  register struct cp_binding_level *b;

  timevar_push (TV_NAME_LOOKUP);

  b = current_binding_level;
  while (b->tag_transparent
   || (b->parm_flag == 2
       && (globalize
     /* We may be defining a new type in the initializer
        of a static member variable. We allow this when
        not pedantic, and it is particularly useful for
        type punning via an anonymous union.  */
     || COMPLETE_TYPE_P (b->this_class))))
    b = b->level_chain;

  if (b->type_decls == NULL)
    b->type_decls = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
  binding_table_insert (b->type_decls, name, type);

  if (name)
    {
      /* Do C++ gratuitous typedefing.  */
      if (IDENTIFIER_TYPE_VALUE (name) != type)
        {
          register tree d = NULL_TREE;
    int in_class = 0;
    tree context = TYPE_CONTEXT (type);

    if (! context)
      {
        tree cs = current_scope ();

        if (! globalize)
    context = cs;
        else if (cs != NULL_TREE && TYPE_P (cs))
    /* When declaring a friend class of a local class, we want
       to inject the newly named class into the scope
       containing the local class, not the namespace scope.  */
    context = decl_function_context (get_type_decl (cs));
      }
    if (!context)
      context = current_namespace;

    if ((b->template_parms_p && b->level_chain->parm_flag == 2)
        || b->parm_flag == 2)
      in_class = 1;

    if (current_lang_name == lang_name_java)
      TYPE_FOR_JAVA (type) = 1;

    d = create_implicit_typedef (name, type);
    DECL_CONTEXT (d) = FROB_CONTEXT (context);
    if (! in_class)
      set_identifier_type_value_with_scope (name, type, b);

    d = maybe_process_template_type_declaration (type,
                   globalize, b);

    if (b->parm_flag == 2)
      {
        if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
    /* Put this TYPE_DECL on the TYPE_FIELDS list for the
       class.  But if it's a member template class, we
       want the TEMPLATE_DECL, not the TYPE_DECL, so this
       is done later.  */
    finish_member_declaration (d);
        else
    pushdecl_class_level (d);
      }
    else
      d = pushdecl_with_scope (d, b);

    /* FIXME what if it gets a name from typedef?  */
    if (ANON_AGGRNAME_P (name))
      DECL_IGNORED_P (d) = 1;

    TYPE_CONTEXT (type) = DECL_CONTEXT (d);

    /* If this is a local class, keep track of it.  We need this
       information for name-mangling, and so that it is possible to find
       all function definitions in a translation unit in a convenient
       way.  (It's otherwise tricky to find a member function definition
       it's only pointed to from within a local class.)  */
    if (TYPE_CONTEXT (type)
        && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
        && !processing_template_decl)
      VARRAY_PUSH_TREE (local_classes, type);
        }
      if (b->parm_flag == 2)
  {
    if (!COMPLETE_TYPE_P (current_class_type))
      {
        maybe_add_class_template_decl_list (current_class_type,
              type, /*friend_p=*/0);
        CLASSTYPE_NESTED_UDTS (current_class_type) = b->type_decls;
      }
  }
    }

  if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
    /* Use the canonical TYPE_DECL for this node.  */
    TYPE_STUB_DECL (type) = TYPE_NAME (type);
  else
    {
      /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
   will be the tagged type we just added to the current
   binding level.  This fake NULL-named TYPE_DECL node helps
   dwarfout.c to know when it needs to output a
   representation of a tagged type, and it also gives us a
   convenient place to record the "scope start" address for
   the tagged type.  */

      tree d = build_decl (TYPE_DECL, NULL_TREE, type);
      TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
    }

  timevar_pop (TV_NAME_LOOKUP);
}

/* Counter used to create anonymous type names.  */

static int anon_cnt = 0;

/* Return an IDENTIFIER which can be used as a name for
   anonymous structs and unions.  */

tree
make_anon_name ()
{
  char buf[32];

  sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
  return get_identifier (buf);
}

/* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
   This keeps dbxout from getting confused.  */

void
clear_anon_tags ()
{
  register struct cp_binding_level *b;
  static int last_cnt = 0;

  /* Fast out if no new anon names were declared.  */
  if (last_cnt == anon_cnt)
    return;

  b = current_binding_level;
  while (b->tag_transparent)
    b = b->level_chain;
  if (b->type_decls != NULL)
    binding_table_remove_anonymous_types (b->type_decls);
  last_cnt = anon_cnt;
}

/* Subroutine of duplicate_decls: return truthvalue of whether
   or not types of these decls match.

   For C++, we must compare the parameter list so that `int' can match
   `int&' in a parameter position, but `int&' is not confused with
   `const int&'.  */

int
decls_match (newdecl, olddecl)
     tree newdecl, olddecl;
{
  int types_match;

  if (newdecl == olddecl)
    return 1;

  if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
    /* If the two DECLs are not even the same kind of thing, we're not
       interested in their types.  */
    return 0;

  if (TREE_CODE (newdecl) == FUNCTION_DECL)
    {
      tree f1 = TREE_TYPE (newdecl);
      tree f2 = TREE_TYPE (olddecl);
      tree p1 = TYPE_ARG_TYPES (f1);
      tree p2 = TYPE_ARG_TYPES (f2);

      if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
    && ! (DECL_EXTERN_C_P (newdecl)
    && DECL_EXTERN_C_P (olddecl)))
  return 0;

      if (TREE_CODE (f1) != TREE_CODE (f2))
        return 0;

      if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
  {
    if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
        && (DECL_BUILT_IN (olddecl)
#ifndef NO_IMPLICIT_EXTERN_C
            || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
            || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
#endif
        ))
      {
        types_match = self_promoting_args_p (p1);
        if (p1 == void_list_node)
    TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
      }
#ifndef NO_IMPLICIT_EXTERN_C
    else if (p1 == NULL_TREE
       && (DECL_EXTERN_C_P (olddecl)
                 && DECL_IN_SYSTEM_HEADER (olddecl)
                 && !DECL_CLASS_SCOPE_P (olddecl))
       && (DECL_EXTERN_C_P (newdecl)
                 && DECL_IN_SYSTEM_HEADER (newdecl)
                 && !DECL_CLASS_SCOPE_P (newdecl)))
      {
        types_match = self_promoting_args_p (p2);
        TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
      }
#endif
    else
      types_match = compparms (p1, p2);
  }
      else
  types_match = 0;
    }
  else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
    {
      if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
        DECL_TEMPLATE_PARMS (olddecl)))
  return 0;

      if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
    != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
  return 0;

      if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
  types_match = 1;
      else
  types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
           DECL_TEMPLATE_RESULT (newdecl));
    }
  else
    {
      if (TREE_TYPE (newdecl) == error_mark_node)
  types_match = TREE_TYPE (olddecl) == error_mark_node;
      else if (TREE_TYPE (olddecl) == NULL_TREE)
  types_match = TREE_TYPE (newdecl) == NULL_TREE;
      else if (TREE_TYPE (newdecl) == NULL_TREE)
  types_match = 0;
      else
  types_match = comptypes (TREE_TYPE (newdecl),
         TREE_TYPE (olddecl),
         COMPARE_REDECLARATION);
    }

  return types_match;
}

/* If NEWDECL is `static' and an `extern' was seen previously,
   warn about it.  OLDDECL is the previous declaration.

   Note that this does not apply to the C++ case of declaring
   a variable `extern const' and then later `const'.

   Don't complain about built-in functions, since they are beyond
   the user's control.  */

static void
warn_extern_redeclared_static (newdecl, olddecl)
     tree newdecl, olddecl;
{
  static const char *const explicit_extern_static_warning
    = "`%D' was declared `extern' and later `static'";
  static const char *const implicit_extern_static_warning
    = "`%D' was declared implicitly `extern' and later `static'";

  tree name;

  if (TREE_CODE (newdecl) == TYPE_DECL
      || TREE_CODE (newdecl) == TEMPLATE_DECL
      || TREE_CODE (newdecl) == CONST_DECL)
    return;

  /* Don't get confused by static member functions; that's a different
     use of `static'.  */
  if (TREE_CODE (newdecl) == FUNCTION_DECL
      && DECL_STATIC_FUNCTION_P (newdecl))
    return;

  /* If the old declaration was `static', or the new one isn't, then
     then everything is OK.  */
  if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
    return;

  /* It's OK to declare a builtin function as `static'.  */
  if (TREE_CODE (olddecl) == FUNCTION_DECL
      && DECL_ARTIFICIAL (olddecl))
    return;

  name = DECL_ASSEMBLER_NAME (newdecl);
  pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
        ? implicit_extern_static_warning
        : explicit_extern_static_warning, newdecl);
  cp_pedwarn_at ("previous declaration of `%D'", olddecl);
}

/* Handle when a new declaration NEWDECL has the same name as an old
   one OLDDECL in the same binding contour.  Prints an error message
   if appropriate.

   If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
   Otherwise, return 0.  */

int
duplicate_decls (newdecl, olddecl)
     tree newdecl, olddecl;
{
  unsigned olddecl_uid = DECL_UID (olddecl);
  int olddecl_friend = 0, types_match = 0;
  int new_defines_function = 0;

  if (newdecl == olddecl)
    return 1;

  types_match = decls_match (newdecl, olddecl);

  /* If either the type of the new decl or the type of the old decl is an
     error_mark_node, then that implies that we have already issued an
     error (earlier) for some bogus type specification, and in that case,
     it is rather pointless to harass the user with yet more error message
     about the same declaration, so just pretend the types match here.  */
  if (TREE_TYPE (newdecl) == error_mark_node
      || TREE_TYPE (olddecl) == error_mark_node)
    types_match = 1;

  if (DECL_P (olddecl)
      && TREE_CODE (newdecl) == FUNCTION_DECL
      && TREE_CODE (olddecl) == FUNCTION_DECL
      && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
    {
      if (DECL_DECLARED_INLINE_P (newdecl)
    && DECL_UNINLINABLE (newdecl)
    && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
  /* Already warned elsewhere.  */;
      else if (DECL_DECLARED_INLINE_P (olddecl)
         && DECL_UNINLINABLE (olddecl)
         && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
  /* Already warned.  */;
      else if (DECL_DECLARED_INLINE_P (newdecl)
         && DECL_UNINLINABLE (olddecl)
         && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
  {
    warning_with_decl (newdecl,
           "function `%s' redeclared as inline");
    warning_with_decl (olddecl,
           "previous declaration of function `%s' with attribute noinline");
  }
      else if (DECL_DECLARED_INLINE_P (olddecl)
         && DECL_UNINLINABLE (newdecl)
         && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
  {
    warning_with_decl (newdecl,
           "function `%s' redeclared with attribute noinline");
    warning_with_decl (olddecl,
           "previous declaration of function `%s' was inline");
  }
    }

  /* Check for redeclaration and other discrepancies.  */
  if (TREE_CODE (olddecl) == FUNCTION_DECL
      && DECL_ARTIFICIAL (olddecl))
    {
      if (TREE_CODE (newdecl) != FUNCTION_DECL)
  {
          /* Avoid warnings redeclaring anticipated built-ins.  */
          if (DECL_ANTICIPATED (olddecl))
            return 0;

    /* If you declare a built-in or predefined function name as static,
       the old definition is overridden, but optionally warn this was a
       bad choice of name.  */
    if (! TREE_PUBLIC (newdecl))
      {
        if (warn_shadow)
    warning ("shadowing %s function `%#D'",
          DECL_BUILT_IN (olddecl) ? "built-in" : "library",
          olddecl);
        /* Discard the old built-in function.  */
        return 0;
      }
    /* If the built-in is not ansi, then programs can override
       it even globally without an error.  */
    else if (! DECL_BUILT_IN (olddecl))
      warning ("library function `%#D' redeclared as non-function `%#D'",
      olddecl, newdecl);
    else
      {
        error ("declaration of `%#D'", newdecl);
        error ("conflicts with built-in declaration `%#D'",
      olddecl);
      }
    return 0;
  }
      else if (!types_match)
  {
          /* Avoid warnings redeclaring anticipated built-ins.  */
          if (DECL_ANTICIPATED (olddecl))
            ;  /* Do nothing yet.  */
    else if ((DECL_EXTERN_C_P (newdecl)
        && DECL_EXTERN_C_P (olddecl))
       || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
         TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
      {
        /* A near match; override the builtin.  */

        if (TREE_PUBLIC (newdecl))
    {
      warning ("new declaration `%#D'", newdecl);
      warning ("ambiguates built-in declaration `%#D'",
            olddecl);
    }
        else if (warn_shadow)
    warning ("shadowing %s function `%#D'",
          DECL_BUILT_IN (olddecl) ? "built-in" : "library",
          olddecl);
      }
    else
      /* Discard the old built-in function.  */
      return 0;

    /* Replace the old RTL to avoid problems with inlining.  */
    SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
  }
      /* Even if the types match, prefer the new declarations type
   for anitipated built-ins, for exception lists, etc...  */
      else if (DECL_ANTICIPATED (olddecl))
  TREE_TYPE (olddecl) = TREE_TYPE (newdecl);

      /* Whether or not the builtin can throw exceptions has no
   bearing on this declarator.  */
      TREE_NOTHROW (olddecl) = 0;

      if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
  {
    /* If a builtin function is redeclared as `static', merge
       the declarations, but make the original one static.  */
    DECL_THIS_STATIC (olddecl) = 1;
    TREE_PUBLIC (olddecl) = 0;

    /* Make the old declaration consistent with the new one so
       that all remnants of the builtin-ness of this function
       will be banished.  */
    SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
    SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
  }
    }
  else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
    {
      if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
     && TREE_CODE (newdecl) != TYPE_DECL
     && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
     && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
    || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
        && TREE_CODE (olddecl) != TYPE_DECL
        && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
        && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
      == TYPE_DECL))))
  {
    /* We do nothing special here, because C++ does such nasty
       things with TYPE_DECLs.  Instead, just let the TYPE_DECL
       get shadowed, and know that if we need to find a TYPE_DECL
       for a given name, we can look in the IDENTIFIER_TYPE_VALUE
       slot of the identifier.  */
    return 0;
  }

      if ((TREE_CODE (newdecl) == FUNCTION_DECL
     && DECL_FUNCTION_TEMPLATE_P (olddecl))
    || (TREE_CODE (olddecl) == FUNCTION_DECL
        && DECL_FUNCTION_TEMPLATE_P (newdecl)))
  return 0;

      error ("`%#D' redeclared as different kind of symbol", newdecl);
      if (TREE_CODE (olddecl) == TREE_LIST)
  olddecl = TREE_VALUE (olddecl);
      cp_error_at ("previous declaration of `%#D'", olddecl);

      /* New decl is completely inconsistent with the old one =>
   tell caller to replace the old one.  */

      return 0;
    }
  else if (!types_match)
    {
      if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
  /* These are certainly not duplicate declarations; they're
     from different scopes.  */
  return 0;

      if (TREE_CODE (newdecl) == TEMPLATE_DECL)
  {
    /* The name of a class template may not be declared to refer to
       any other template, class, function, object, namespace, value,
       or type in the same scope.  */
    if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
        || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
      {
        error ("declaration of template `%#D'", newdecl);
        cp_error_at ("conflicts with previous declaration `%#D'",
         olddecl);
      }
    else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
       && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
       && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
         TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
       && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
             DECL_TEMPLATE_PARMS (olddecl))
       /* Template functions can be disambiguated by
          return type.  */
       && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
           TREE_TYPE (TREE_TYPE (olddecl))))
      {
        error ("new declaration `%#D'", newdecl);
        cp_error_at ("ambiguates old declaration `%#D'", olddecl);
      }
    return 0;
  }
      if (TREE_CODE (newdecl) == FUNCTION_DECL)
  {
    if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
      {
        error ("declaration of C function `%#D' conflicts with",
      newdecl);
        cp_error_at ("previous declaration `%#D' here", olddecl);
      }
    else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
            TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
      {
        error ("new declaration `%#D'", newdecl);
        cp_error_at ("ambiguates old declaration `%#D'", olddecl);
      }
    else
      return 0;
  }

      /* Already complained about this, so don't do so again.  */
      else if (current_class_type == NULL_TREE
         || !DECL_ASSEMBLER_NAME_SET_P (newdecl)
         || (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) 
       != current_class_type))
  {
    error ("conflicting types for `%#D'", newdecl);
    cp_error_at ("previous declaration as `%#D'", olddecl);
  }
    }
  else if (TREE_CODE (newdecl) == FUNCTION_DECL
      && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
     && (!DECL_TEMPLATE_INFO (newdecl)
         || (DECL_TI_TEMPLATE (newdecl)
       != DECL_TI_TEMPLATE (olddecl))))
    || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
        && (!DECL_TEMPLATE_INFO (olddecl)
      || (DECL_TI_TEMPLATE (olddecl)
          != DECL_TI_TEMPLATE (newdecl))))))
    /* It's OK to have a template specialization and a non-template
       with the same type, or to have specializations of two
       different templates with the same type.  Note that if one is a
       specialization, and the other is an instantiation of the same
       template, that we do not exit at this point.  That situation
       can occur if we instantiate a template class, and then
       specialize one of its methods.  This situation is valid, but
       the declarations must be merged in the usual way.  */
    return 0;
  else if (TREE_CODE (newdecl) == FUNCTION_DECL
     && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
    && !DECL_USE_TEMPLATE (newdecl))
         || (DECL_TEMPLATE_INSTANTIATION (newdecl)
       && !DECL_USE_TEMPLATE (olddecl))))
    /* One of the declarations is a template instantiation, and the
       other is not a template at all.  That's OK.  */
    return 0;
  else if (TREE_CODE (newdecl) == NAMESPACE_DECL
           && DECL_NAMESPACE_ALIAS (newdecl)
           && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
    /* Redeclaration of namespace alias, ignore it.  */
    return 1;
  else
    {
      const char *errmsg = redeclaration_error_message (newdecl, olddecl);
      if (errmsg)
  {
    error (errmsg, newdecl);
    if (DECL_NAME (olddecl) != NULL_TREE)
      cp_error_at ((DECL_INITIAL (olddecl)
        && namespace_bindings_p ())
       ? "`%#D' previously defined here"
       : "`%#D' previously declared here", olddecl);
    return 0;
  }
      else if (TREE_CODE (olddecl) == FUNCTION_DECL
         && DECL_INITIAL (olddecl) != NULL_TREE
         && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
         && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
  {
    /* Prototype decl follows defn w/o prototype.  */
    cp_warning_at ("prototype for `%#D'", newdecl);
    cp_warning_at ("follows non-prototype definition here", olddecl);
  }
      else if (TREE_CODE (olddecl) == FUNCTION_DECL
         && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
  {
    /* extern "C" int foo ();
       int foo () { bar (); }
       is OK.  */
    if (current_lang_depth () == 0)
      SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
    else
      {
        cp_error_at ("previous declaration of `%#D' with %L linkage",
         olddecl, DECL_LANGUAGE (olddecl));
        error ("conflicts with new declaration with %L linkage",
      DECL_LANGUAGE (newdecl));
      }
  }

      if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
  ;
      else if (TREE_CODE (olddecl) == FUNCTION_DECL)
  {
    tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
    tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
    int i = 1;

    if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
      t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);

    for (; t1 && t1 != void_list_node;
         t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
      if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
        {
    if (1 == simple_cst_equal (TREE_PURPOSE (t1),
             TREE_PURPOSE (t2)))
      {
        pedwarn ("default argument given for parameter %d of `%#D'",
           i, newdecl);
        cp_pedwarn_at ("after previous specification in `%#D'",
                 olddecl);
      }
    else
      {
        error ("default argument given for parameter %d of `%#D'",
            i, newdecl);
        cp_error_at ("after previous specification in `%#D'",
         olddecl);
      }
        }

    if (DECL_DECLARED_INLINE_P (newdecl) 
        && ! DECL_DECLARED_INLINE_P (olddecl)
        && TREE_ADDRESSABLE (olddecl) && warn_inline)
      {
        warning ("`%#D' was used before it was declared inline",
        newdecl);
        cp_warning_at ("previous non-inline declaration here",
           olddecl);
      }
  }
    }

  /* Do not merge an implicit typedef with an explicit one.  In:

       class A;
       ...
       typedef class A A __attribute__ ((foo));

     the attribute should apply only to the typedef.  */
  if (TREE_CODE (olddecl) == TYPE_DECL
      && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
    || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
    return 0;

  /* If new decl is `static' and an `extern' was seen previously,
     warn about it.  */
  warn_extern_redeclared_static (newdecl, olddecl);

  /* We have committed to returning 1 at this point.  */
  if (TREE_CODE (newdecl) == FUNCTION_DECL)
    {
      /* Now that functions must hold information normally held
   by field decls, there is extra work to do so that
   declaration information does not get destroyed during
   definition.  */
      if (DECL_VINDEX (olddecl))
  DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
      if (DECL_CONTEXT (olddecl))
  DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
      DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
      DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
      DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
      DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
      DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
      DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
      if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
  SET_OVERLOADED_OPERATOR_CODE
    (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
      new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;

      /* Optionally warn about more than one declaration for the same
         name, but don't warn about a function declaration followed by a
         definition.  */
      if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
    && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
    /* Don't warn about extern decl followed by definition.  */
    && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
    /* Don't warn about friends, let add_friend take care of it.  */
    && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
  {
    warning ("redundant redeclaration of `%D' in same scope", newdecl);
    cp_warning_at ("previous declaration of `%D'", olddecl);
  }
    }

  /* Deal with C++: must preserve virtual function table size.  */
  if (TREE_CODE (olddecl) == TYPE_DECL)
    {
      register tree newtype = TREE_TYPE (newdecl);
      register tree oldtype = TREE_TYPE (olddecl);

      if (newtype != error_mark_node && oldtype != error_mark_node
    && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
  CLASSTYPE_FRIEND_CLASSES (newtype)
    = CLASSTYPE_FRIEND_CLASSES (oldtype);
\
      DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
    }

  /* Copy all the DECL_... slots specified in the new decl
     except for any that we copy here from the old type.  */
  DECL_ATTRIBUTES (newdecl)
    = (*targetm.merge_decl_attributes) (olddecl, newdecl);

  if (TREE_CODE (newdecl) == TEMPLATE_DECL)
    {
      TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
      DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
  = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
       DECL_TEMPLATE_SPECIALIZATIONS (newdecl));

      /* If the new declaration is a definition, update the file and
   line information on the declaration.  */
      if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
    && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
  {
    DECL_SOURCE_LOCATION (olddecl) 
      = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
      = DECL_SOURCE_LOCATION (newdecl);
  }

      return 1;
    }

  if (types_match)
    {
      /* Automatically handles default parameters.  */
      tree oldtype = TREE_TYPE (olddecl);
      tree newtype;

      /* Merge the data types specified in the two decls.  */
      newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));

      /* If merge_types produces a non-typedef type, just use the old type.  */
      if (TREE_CODE (newdecl) == TYPE_DECL
    && newtype == DECL_ORIGINAL_TYPE (newdecl))
  newtype = oldtype;

      if (TREE_CODE (newdecl) == VAR_DECL)
  {
    DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
    DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
  }

      /* Do this after calling `merge_types' so that default
   parameters don't confuse us.  */
      else if (TREE_CODE (newdecl) == FUNCTION_DECL
    && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
        != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
  {
    TREE_TYPE (newdecl) = build_exception_variant (newtype,
               TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
    TREE_TYPE (olddecl) = build_exception_variant (newtype,
               TYPE_RAISES_EXCEPTIONS (oldtype));

    if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
        && DECL_SOURCE_LINE (olddecl) != 0
        && flag_exceptions
        && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
                               TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
      {
        error ("declaration of `%F' throws different exceptions",
      newdecl);
        cp_error_at ("than previous declaration `%F'", olddecl);
      }
  }
      TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;

      /* Lay the type out, unless already done.  */
      if (! same_type_p (newtype, oldtype)
    && TREE_TYPE (newdecl) != error_mark_node
    && !(processing_template_decl && uses_template_parms (newdecl)))
  layout_type (TREE_TYPE (newdecl));

      if ((TREE_CODE (newdecl) == VAR_DECL
     || TREE_CODE (newdecl) == PARM_DECL
     || TREE_CODE (newdecl) == RESULT_DECL
     || TREE_CODE (newdecl) == FIELD_DECL
     || TREE_CODE (newdecl) == TYPE_DECL)
    && !(processing_template_decl && uses_template_parms (newdecl)))
  layout_decl (newdecl, 0);

      /* Merge the type qualifiers.  */
      if (TREE_READONLY (newdecl))
  TREE_READONLY (olddecl) = 1;
      if (TREE_THIS_VOLATILE (newdecl))
  TREE_THIS_VOLATILE (olddecl) = 1;

      /* Merge the initialization information.  */
      if (DECL_INITIAL (newdecl) == NULL_TREE
    && DECL_INITIAL (olddecl) != NULL_TREE)
  {
    DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
    DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
    if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
        && DECL_LANG_SPECIFIC (newdecl)
        && DECL_LANG_SPECIFIC (olddecl))
      DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
  }

      /* Merge the section attribute.
         We want to issue an error if the sections conflict but that must be
   done later in decl_attributes since we are called before attributes
   are assigned.  */
      if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
  DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);

      if (TREE_CODE (newdecl) == FUNCTION_DECL)
  {
    DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
      |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
    DECL_NO_LIMIT_STACK (newdecl)
      |= DECL_NO_LIMIT_STACK (olddecl);
    /* Keep the old RTL.  */
    COPY_DECL_RTL (olddecl, newdecl);
  }
      else if (TREE_CODE (newdecl) == VAR_DECL 
         && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
  {
    /* Keep the old RTL.  We cannot keep the old RTL if the old
       declaration was for an incomplete object and the new
       declaration is not since many attributes of the RTL will
       change.  */
    COPY_DECL_RTL (olddecl, newdecl);
  }
    }
  /* If cannot merge, then use the new type and qualifiers,
     and don't preserve the old rtl.  */
  else
    {
      /* Clean out any memory we had of the old declaration.  */
      tree oldstatic = value_member (olddecl, static_aggregates);
      if (oldstatic)
  TREE_VALUE (oldstatic) = error_mark_node;

      TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
      TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
      TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
      TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
    }

  /* Merge the storage class information.  */
  merge_weak (newdecl, olddecl);

  DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
  DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
  TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
  TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
  if (! DECL_EXTERNAL (olddecl))
    DECL_EXTERNAL (newdecl) = 0;

  if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
    {
      DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
      DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
      DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
      DECL_TEMPLATE_INSTANTIATED (newdecl)
  |= DECL_TEMPLATE_INSTANTIATED (olddecl);
      /* Don't really know how much of the language-specific
   values we should copy from old to new.  */
      DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
      DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 = 
  DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
      DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
      DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
      DECL_INITIALIZED_IN_CLASS_P (newdecl)
        |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
      olddecl_friend = DECL_FRIEND_P (olddecl);

      /* Only functions have DECL_BEFRIENDING_CLASSES.  */
      if (TREE_CODE (newdecl) == FUNCTION_DECL
    || DECL_FUNCTION_TEMPLATE_P (newdecl))
  {
    DECL_BEFRIENDING_CLASSES (newdecl)
      = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
           DECL_BEFRIENDING_CLASSES (olddecl));
    /* DECL_THUNKS is only valid for virtual functions,
       otherwise it is a DECL_FRIEND_CONTEXT.  */
    if (DECL_VIRTUAL_P (newdecl))
      DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
  }
    }

  if (TREE_CODE (newdecl) == FUNCTION_DECL)
    {
      if (DECL_TEMPLATE_INSTANTIATION (olddecl)
    && !DECL_TEMPLATE_INSTANTIATION (newdecl))
  {
    /* If newdecl is not a specialization, then it is not a
       template-related function at all.  And that means that we
       shoud have exited above, returning 0.  */
    my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
            0);

    if (TREE_USED (olddecl))
      /* From [temp.expl.spec]:

         If a template, a member template or the member of a class
         template is explicitly specialized then that
         specialization shall be declared before the first use of
         that specialization that would cause an implicit
         instantiation to take place, in every translation unit in
         which such a use occurs.  */
      error ("explicit specialization of %D after first use",
          olddecl);

    SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);

    /* [temp.expl.spec/14] We don't inline explicit specialization
       just because the primary template says so.  */
  }
      else
  {
    if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
      DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);

    DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);

    /* If either decl says `inline', this fn is inline, unless 
       its definition was passed already.  */
    if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
      DECL_INLINE (olddecl) = 1;
    DECL_INLINE (newdecl) = DECL_INLINE (olddecl);

    DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
      = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
  }

      /* Preserve abstractness on cloned [cd]tors.  */
      DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);

      if (! types_match)
  {
    SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
    COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
    SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
  }
      if (! types_match || new_defines_function)
  {
    /* These need to be copied so that the names are available.
       Note that if the types do match, we'll preserve inline
       info and other bits, but if not, we won't.  */
    DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
    DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
  }
      if (new_defines_function)
  /* If defining a function declared with other language
     linkage, use the previously declared language linkage.  */
  SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
      else if (types_match)
  {
    /* If redeclaring a builtin function, and not a definition,
       it stays built in.  */
    if (DECL_BUILT_IN (olddecl))
      {
        DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
        DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
        /* If we're keeping the built-in definition, keep the rtl,
     regardless of declaration matches.  */
        SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
      }
    else
      DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);

    DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
    /* Don't clear out the arguments if we're redefining a function.  */
    if (DECL_ARGUMENTS (olddecl))
      DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
  }
    }
  else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
    NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);

  /* Now preserve various other info from the definition.  */
  TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
  TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
  DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
  COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);

  if (TREE_CODE (newdecl) == FUNCTION_DECL)
    {
      int function_size;

      function_size = sizeof (struct tree_decl);

      memcpy ((char *) olddecl + sizeof (struct tree_common),
        (char *) newdecl + sizeof (struct tree_common),
        function_size - sizeof (struct tree_common));

      if (DECL_TEMPLATE_INSTANTIATION (newdecl))
  {
    /* If newdecl is a template instantiation, it is possible that
       the following sequence of events has occurred:

       o A friend function was declared in a class template.  The
       class template was instantiated.

       o The instantiation of the friend declaration was
       recorded on the instantiation list, and is newdecl.

       o Later, however, instantiate_class_template called pushdecl
       on the newdecl to perform name injection.  But, pushdecl in
       turn called duplicate_decls when it discovered that another
       declaration of a global function with the same name already
       existed.

       o Here, in duplicate_decls, we decided to clobber newdecl.

       If we're going to do that, we'd better make sure that
       olddecl, and not newdecl, is on the list of
       instantiations so that if we try to do the instantiation
       again we won't get the clobbered declaration.  */

    tree tmpl = DECL_TI_TEMPLATE (newdecl);
    tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);

    for (; decls; decls = TREE_CHAIN (decls))
      if (TREE_VALUE (decls) == newdecl)
        TREE_VALUE (decls) = olddecl;
  }
    }
  else
    {
      memcpy ((char *) olddecl + sizeof (struct tree_common),
        (char *) newdecl + sizeof (struct tree_common),
        sizeof (struct tree_decl) - sizeof (struct tree_common)
        + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
    }

  DECL_UID (olddecl) = olddecl_uid;
  if (olddecl_friend)
    DECL_FRIEND_P (olddecl) = 1;

  /* NEWDECL contains the merged attribute lists.
     Update OLDDECL to be the same.  */
  DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);

  /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
     so that encode_section_info has a chance to look at the new decl
     flags and attributes.  */
  if (DECL_RTL_SET_P (olddecl)
      && (TREE_CODE (olddecl) == FUNCTION_DECL
    || (TREE_CODE (olddecl) == VAR_DECL
        && TREE_STATIC (olddecl))))
    make_decl_rtl (olddecl, NULL);

  return 1;
}

/* Record a decl-node X as belonging to the current lexical scope.
   Check for errors (such as an incompatible declaration for the same
   name already seen in the same scope).

   Returns either X or an old decl for the same name.
   If an old decl is returned, it may have been smashed
   to agree with what X says.  */

tree
pushdecl (x)
     tree x;
{
  register tree t;
  register tree name;
  int need_new_binding;

  timevar_push (TV_NAME_LOOKUP);

  /* We shouldn't be calling pushdecl when we're generating RTL for a
     function that we already did semantic analysis on previously.  */
  my_friendly_assert (!cfun || doing_semantic_analysis_p (),
          19990913);

  need_new_binding = 1;

  if (DECL_TEMPLATE_PARM_P (x))
    /* Template parameters have no context; they are not X::T even
       when declared within a class or namespace.  */
    ;
  else
    {
      if (current_function_decl && x != current_function_decl
    /* A local declaration for a function doesn't constitute
             nesting.  */
    && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
    /* A local declaration for an `extern' variable is in the
       scope of the current namespace, not the current
       function.  */
    && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
    && !DECL_CONTEXT (x))
  DECL_CONTEXT (x) = current_function_decl;

      /* If this is the declaration for a namespace-scope function,
   but the declaration itself is in a local scope, mark the
   declaration.  */
      if (TREE_CODE (x) == FUNCTION_DECL
    && DECL_NAMESPACE_SCOPE_P (x)
    && current_function_decl
    && x != current_function_decl)
  DECL_LOCAL_FUNCTION_P (x) = 1;
    }

  name = DECL_NAME (x);
  if (name)
    {
      int different_binding_level = 0;

      if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
  name = TREE_OPERAND (name, 0);

      /* In case this decl was explicitly namespace-qualified, look it
   up in its namespace context.  */
      if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
    && namespace_bindings_p ())
  t = namespace_binding (name, DECL_CONTEXT (x));
      else
  t = lookup_name_current_level (name);

      /* [basic.link] If there is a visible declaration of an entity
   with linkage having the same name and type, ignoring entities
   declared outside the innermost enclosing namespace scope, the
   block scope declaration declares that same entity and
   receives the linkage of the previous declaration.  */
      if (! t && current_function_decl && x != current_function_decl
    && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
    && DECL_EXTERNAL (x))
  {
    /* Look in block scope.  */
    t = IDENTIFIER_VALUE (name);
    /* Or in the innermost namespace.  */
    if (! t)
      t = namespace_binding (name, DECL_CONTEXT (x));
    /* Does it have linkage?  Note that if this isn't a DECL, it's an
       OVERLOAD, which is OK.  */
    if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
      t = NULL_TREE;
    if (t)
      different_binding_level = 1;
  }

      /* If we are declaring a function, and the result of name-lookup
   was an OVERLOAD, look for an overloaded instance that is
   actually the same as the function we are declaring.  (If
   there is one, we have to merge our declaration with the
   previous declaration.)  */
      if (t && TREE_CODE (t) == OVERLOAD)
  {
    tree match;

    if (TREE_CODE (x) == FUNCTION_DECL)
      for (match = t; match; match = OVL_NEXT (match))
        {
    if (decls_match (OVL_CURRENT (match), x))
      break;
        }
    else
      /* Just choose one.  */
      match = t;

    if (match)
      t = OVL_CURRENT (match);
    else
      t = NULL_TREE;
  }

      if (t == error_mark_node)
  {
    /* error_mark_node is 0 for a while during initialization!  */
    t = NULL_TREE;
    cp_error_at ("`%#D' used prior to declaration", x);
  }
      else if (t != NULL_TREE)
  {
    if (different_binding_level)
      {
        if (decls_match (x, t))
    /* The standard only says that the local extern
       inherits linkage from the previous decl; in
       particular, default args are not shared.  It would
       be nice to propagate inlining info, though.  FIXME.  */
    TREE_PUBLIC (x) = TREE_PUBLIC (t);
      }
    else if (TREE_CODE (t) == PARM_DECL)
      {
        if (DECL_CONTEXT (t) == NULL_TREE)
    /* This is probaby caused by too many errors, but calling
       abort will say that if errors have occurred.  */
    abort ();

        /* Check for duplicate params.  */
        if (duplicate_decls (x, t))
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
      }
    else if ((DECL_EXTERN_C_FUNCTION_P (x)
        || DECL_FUNCTION_TEMPLATE_P (x))
       && is_overloaded_fn (t))
      /* Don't do anything just yet.  */;
    else if (t == wchar_decl_node)
      {
        if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
    pedwarn ("redeclaration of `wchar_t' as `%T'",
          TREE_TYPE (x));

        /* Throw away the redeclaration.  */
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
      }
    else if (TREE_CODE (t) != TREE_CODE (x))
      {
        if (duplicate_decls (x, t))
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
      }
    else if (duplicate_decls (x, t))
      {
        if (TREE_CODE (t) == TYPE_DECL)
    SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
        else if (TREE_CODE (t) == FUNCTION_DECL)
    check_default_args (t);

        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
      }
    else if (DECL_MAIN_P (x))
      {
        /* A redeclaration of main, but not a duplicate of the
     previous one.

     [basic.start.main]

           This function shall not be overloaded.  */
        cp_error_at ("invalid redeclaration of `%D'", t);
        error ("as `%D'", x);
        /* We don't try to push this declaration since that
     causes a crash.  */
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
      }
  }

      check_template_shadow (x);

      /* If this is a function conjured up by the backend, massage it
   so it looks friendly.  */
      if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
  {
    retrofit_lang_decl (x);
    SET_DECL_LANGUAGE (x, lang_c);
  }

      if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
  {
    t = push_overloaded_decl (x, PUSH_LOCAL);
    if (t != x)
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
    if (!namespace_bindings_p ())
      /* We do not need to create a binding for this name;
         push_overloaded_decl will have already done so if
         necessary.  */
      need_new_binding = 0;
  }
      else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
  {
    t = push_overloaded_decl (x, PUSH_GLOBAL);
    if (t == x)
      add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
  }

      /* If declaring a type as a typedef, copy the type (unless we're
   at line 0), and install this TYPE_DECL as the new type's typedef
   name.  See the extensive comment in ../c-decl.c (pushdecl).  */
      if (TREE_CODE (x) == TYPE_DECL)
  {
    tree type = TREE_TYPE (x);
    if (DECL_SOURCE_LINE (x) == 0)
            {
        if (TYPE_NAME (type) == 0)
          TYPE_NAME (type) = x;
            }
          else if (type != error_mark_node && TYPE_NAME (type) != x
       /* We don't want to copy the type when all we're
          doing is making a TYPE_DECL for the purposes of
          inlining.  */
       && (!TYPE_NAME (type)
           || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
            {
        DECL_ORIGINAL_TYPE (x) = type;
              type = build_type_copy (type);
        TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
              TYPE_NAME (type) = x;
              TREE_TYPE (x) = type;
            }

    if (type != error_mark_node
        && TYPE_NAME (type)
        && TYPE_IDENTIFIER (type))
            set_identifier_type_value_with_scope (DECL_NAME (x), type,
              current_binding_level);

  }

      /* Multiple external decls of the same identifier ought to match.

   We get warnings about inline functions where they are defined.
   We get warnings about other functions from push_overloaded_decl.

   Avoid duplicate warnings where they are used.  */
      if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
  {
    tree decl;

    decl = IDENTIFIER_NAMESPACE_VALUE (name);
    if (decl && TREE_CODE (decl) == OVERLOAD)
      decl = OVL_FUNCTION (decl);

    if (decl && decl != error_mark_node
        && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
        /* If different sort of thing, we already gave an error.  */
        && TREE_CODE (decl) == TREE_CODE (x)
        && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
      {
        pedwarn ("type mismatch with previous external decl", x);
        cp_pedwarn_at ("previous external decl of `%#D'", decl);
      }
  }

      /* This name is new in its binding level.
   Install the new declaration and return it.  */
      if (namespace_bindings_p ())
  {
    /* Install a global value.  */

    /* If the first global decl has external linkage,
       warn if we later see static one.  */
    if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
      TREE_PUBLIC (name) = 1;

    /* Bind the name for the entity.  */
    if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
      && t != NULL_TREE)
        && (TREE_CODE (x) == TYPE_DECL
      || TREE_CODE (x) == VAR_DECL
      || TREE_CODE (x) == NAMESPACE_DECL
      || TREE_CODE (x) == CONST_DECL
      || TREE_CODE (x) == TEMPLATE_DECL))
      SET_IDENTIFIER_NAMESPACE_VALUE (name, x);

    /* Don't forget if the function was used via an implicit decl.  */
    if (IDENTIFIER_IMPLICIT_DECL (name)
        && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
      TREE_USED (x) = 1;

    /* Don't forget if its address was taken in that way.  */
    if (IDENTIFIER_IMPLICIT_DECL (name)
        && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
      TREE_ADDRESSABLE (x) = 1;

    /* Warn about mismatches against previous implicit decl.  */
    if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
        /* If this real decl matches the implicit, don't complain.  */
        && ! (TREE_CODE (x) == FUNCTION_DECL
        && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
      warning
        ("`%D' was previously implicitly declared to return `int'", x);

    /* If new decl is `static' and an `extern' was seen previously,
       warn about it.  */
    if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
      warn_extern_redeclared_static (x, t);
  }
      else
  {
    /* Here to install a non-global value.  */
    tree oldlocal = IDENTIFIER_VALUE (name);
    tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);

    if (need_new_binding)
      {
        push_local_binding (name, x, 0);
        /* Because push_local_binding will hook X on to the
     current_binding_level's name list, we don't want to
     do that again below.  */
        need_new_binding = 0;
      }

    /* If this is a TYPE_DECL, push it into the type value slot.  */
    if (TREE_CODE (x) == TYPE_DECL)
      set_identifier_type_value_with_scope (name, TREE_TYPE (x),
              current_binding_level);

    /* Clear out any TYPE_DECL shadowed by a namespace so that
       we won't think this is a type.  The C struct hack doesn't
       go through namespaces.  */
    if (TREE_CODE (x) == NAMESPACE_DECL)
      set_identifier_type_value_with_scope (name, NULL_TREE,
              current_binding_level);

    if (oldlocal)
      {
        tree d = oldlocal;

        while (oldlocal
         && TREE_CODE (oldlocal) == VAR_DECL
         && DECL_DEAD_FOR_LOCAL (oldlocal))
    oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);

        if (oldlocal == NULL_TREE)
    oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
      }

    /* If this is an extern function declaration, see if we
       have a global definition or declaration for the function.  */
    if (oldlocal == NULL_TREE
        && DECL_EXTERNAL (x)
        && oldglobal != NULL_TREE
        && TREE_CODE (x) == FUNCTION_DECL
        && TREE_CODE (oldglobal) == FUNCTION_DECL)
      {
        /* We have one.  Their types must agree.  */
        if (decls_match (x, oldglobal))
    /* OK */;
        else
    {
      warning ("extern declaration of `%#D' doesn't match", x);
      cp_warning_at ("global declaration `%#D'", oldglobal);
    }
      }
    /* If we have a local external declaration,
       and no file-scope declaration has yet been seen,
       then if we later have a file-scope decl it must not be static.  */
    if (oldlocal == NULL_TREE
        && oldglobal == NULL_TREE
        && DECL_EXTERNAL (x)
        && TREE_PUBLIC (x))
      TREE_PUBLIC (name) = 1;

    /* Warn if shadowing an argument at the top level of the body.  */
    if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
        /* Inline decls shadow nothing.  */
        && !DECL_FROM_INLINE (x)
        && TREE_CODE (oldlocal) == PARM_DECL
        /* Don't check the `this' parameter.  */
        && !DECL_ARTIFICIAL (oldlocal))
      {
        bool err = false;

        /* Don't complain if it's from an enclosing function.  */
        if (DECL_CONTEXT (oldlocal) == current_function_decl
      && TREE_CODE (x) != PARM_DECL)
    {
      /* Go to where the parms should be and see if we find
         them there.  */
      struct cp_binding_level *b = current_binding_level->level_chain;

      /* ARM $8.3 */
      if (b->parm_flag == 1)
        {
          error ("declaration of `%#D' shadows a parameter",
        name);
          err = true;
        }
    }

        if (warn_shadow && !err)
    shadow_warning ("a parameter", name, oldlocal);
      }

    /* Maybe warn if shadowing something else.  */
    else if (warn_shadow && !DECL_EXTERNAL (x)
        /* No shadow warnings for internally generated vars.  */
        && ! DECL_ARTIFICIAL (x)
        /* No shadow warnings for vars made for inlining.  */
        && ! DECL_FROM_INLINE (x))
      {
        if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
           && current_class_ptr
           && !TREE_STATIC (name))
    warning ("declaration of `%s' shadows a member of `this'",
          IDENTIFIER_POINTER (name));
        else if (oldlocal != NULL_TREE
           && TREE_CODE (oldlocal) == VAR_DECL)
    shadow_warning ("a previous local", name, oldlocal);
        else if (oldglobal != NULL_TREE
           && TREE_CODE (oldglobal) == VAR_DECL)
    /* XXX shadow warnings in outer-more namespaces */
    shadow_warning ("a global declaration", name, oldglobal);
      }
  }

      if (TREE_CODE (x) == FUNCTION_DECL)
  check_default_args (x);

      if (TREE_CODE (x) == VAR_DECL)
  maybe_register_incomplete_var (x);
    }

  if (need_new_binding)
    add_decl_to_level (x,
           DECL_NAMESPACE_SCOPE_P (x)
           ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
           : current_binding_level);

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
}

/* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
   caller to set DECL_CONTEXT properly.  */

static tree
pushdecl_with_scope (x, level)
     tree x;
     struct cp_binding_level *level;
{
  register struct cp_binding_level *b;
  tree function_decl = current_function_decl;

  timevar_push (TV_NAME_LOOKUP);

  current_function_decl = NULL_TREE;
  if (level->parm_flag == 2)
    {
      b = class_binding_level;
      class_binding_level = level;
      pushdecl_class_level (x);
      class_binding_level = b;
    }
  else
    {
      b = current_binding_level;
      current_binding_level = level;
      x = pushdecl (x);
      current_binding_level = b;
    }
  current_function_decl = function_decl;
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
}

/* Like pushdecl, only it places X in the current namespace,
   if appropriate.  */

tree
pushdecl_namespace_level (x)
     tree x;
{
  register struct cp_binding_level *b = current_binding_level;
  register tree t;

  timevar_push (TV_NAME_LOOKUP);
  t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));

  /* Now, the type_shadowed stack may screw us.  Munge it so it does
     what we want.  */
  if (TREE_CODE (x) == TYPE_DECL)
    {
      tree name = DECL_NAME (x);
      tree newval;
      tree *ptr = (tree *)0;
      for (; !global_scope_p (b); b = b->level_chain)
        {
          tree shadowed = b->type_shadowed;
          for (; shadowed; shadowed = TREE_CHAIN (shadowed))
            if (TREE_PURPOSE (shadowed) == name)
              {
    ptr = &TREE_VALUE (shadowed);
    /* Can't break out of the loop here because sometimes
       a binding level will have duplicate bindings for
       PT names.  It's gross, but I haven't time to fix it.  */
              }
        }
      newval = TREE_TYPE (x);
      if (ptr == (tree *)0)
        {
          /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
             up here if this is changed to an assertion.  --KR  */
    SET_IDENTIFIER_TYPE_VALUE (name, newval);
  }
      else
        {
    *ptr = newval;
        }
    }
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}

/* Like pushdecl, only it places X in the global scope if appropriate.
   Calls cp_finish_decl to register the variable, initializing it with
   *INIT, if INIT is non-NULL.  */

static tree
pushdecl_top_level_1 (tree x, tree *init)
{
  timevar_push (TV_NAME_LOOKUP);
  push_to_top_level ();
  x = pushdecl_namespace_level (x);
  if (init)
    cp_finish_decl (x, *init, NULL_TREE, 0);
  pop_from_top_level ();
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
}

/* Like pushdecl, only it places X in the global scope if appropriate.  */

tree
pushdecl_top_level (tree x)
{
  return pushdecl_top_level_1 (x, NULL);
}

/* Like pushdecl, only it places X in the global scope if
   appropriate.  Calls cp_finish_decl to register the variable,
   initializing it with INIT.  */

tree
pushdecl_top_level_and_finish (tree x, tree init)
{
  return pushdecl_top_level_1 (x, &init);
}

/* Make the declaration of X appear in CLASS scope.  */

bool
pushdecl_class_level (x)
     tree x;
{
  tree name;
  bool is_valid = true;

  timevar_push (TV_NAME_LOOKUP);
  /* Get the name of X.  */
  if (TREE_CODE (x) == OVERLOAD)
    name = DECL_NAME (get_first_fn (x));
  else
    name = DECL_NAME (x);

  if (name)
    {
      is_valid = push_class_level_binding (name, x);
      if (TREE_CODE (x) == TYPE_DECL)
  set_identifier_type_value (name, TREE_TYPE (x));
    }
  else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
    {
      /* If X is an anonymous aggregate, all of its members are
   treated as if they were members of the class containing the
   aggregate, for naming purposes.  */
      tree f;

      for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
  {
    push_srcloc (DECL_SOURCE_FILE (f), DECL_SOURCE_LINE (f));
    if (!pushdecl_class_level (f))
      is_valid = false;
    pop_srcloc ();
  }
    }
  timevar_pop (TV_NAME_LOOKUP);

  return is_valid;
}

/* Enter DECL into the symbol table, if that's appropriate.  Returns
   DECL, or a modified version thereof.  */

tree
maybe_push_decl (decl)
     tree decl;
{
  tree type = TREE_TYPE (decl);

  /* Add this decl to the current binding level, but not if it comes
     from another scope, e.g. a static member variable.  TEM may equal
     DECL or it may be a previous decl of the same name.  */
  if (decl == error_mark_node
      || (TREE_CODE (decl) != PARM_DECL
    && DECL_CONTEXT (decl) != NULL_TREE
    /* Definitions of namespace members outside their namespace are
       possible.  */
    && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
      || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
      || TREE_CODE (type) == UNKNOWN_TYPE
      /* The declaration of a template specialization does not affect
   the functions available for overload resolution, so we do not
   call pushdecl.  */
      || (TREE_CODE (decl) == FUNCTION_DECL
    && DECL_TEMPLATE_SPECIALIZATION (decl)))
    return decl;
  else
    return pushdecl (decl);
}

/* Make the declaration(s) of X appear in CLASS scope under the name
   NAME.  Returns true if the binding is valid.  */

bool
push_class_level_binding (tree name, tree x)
{
  cxx_binding *binding;
  
  timevar_push (TV_NAME_LOOKUP);
  /* The class_binding_level will be NULL if x is a template
     parameter name in a member template.  */
  if (!class_binding_level)
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);

  /* Make sure that this new member does not have the same name
     as a template parameter.  */
  if (TYPE_BEING_DEFINED (current_class_type))
    check_template_shadow (x);

  /* If this declaration shadows a declaration from an enclosing
     class, then we will need to restore IDENTIFIER_CLASS_VALUE when
     we leave this class.  Record the shadowed declaration here.  */
  binding = IDENTIFIER_BINDING (name);
  if (binding
      && ((TREE_CODE (x) == OVERLOAD
     && BINDING_VALUE (binding)
     && is_overloaded_fn (BINDING_VALUE (binding)))
    || INHERITED_VALUE_BINDING_P (binding)))
    {
      tree shadow;
      tree old_decl;

      /* If the old binding was from a base class, and was for a tag
   name, slide it over to make room for the new binding.  The
   old binding is still visible if explicitly qualified with a
   class-key.  */
      if (INHERITED_VALUE_BINDING_P (binding)
    && BINDING_VALUE (binding)
    && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
    && DECL_ARTIFICIAL (BINDING_VALUE (binding))
    && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
  {
    old_decl = BINDING_TYPE (binding);
    BINDING_TYPE (binding) = BINDING_VALUE (binding);
    BINDING_VALUE (binding) = NULL_TREE;
    INHERITED_VALUE_BINDING_P (binding) = 0;
  }
      else
  old_decl = BINDING_VALUE (binding);

      /* Find the previous binding of name on the class-shadowed
         list, and update it.  */
      for (shadow = class_binding_level->class_shadowed;
     shadow;
     shadow = TREE_CHAIN (shadow))
  if (TREE_PURPOSE (shadow) == name
      && TREE_TYPE (shadow) == old_decl)
    {
      BINDING_VALUE (binding) = x;
      INHERITED_VALUE_BINDING_P (binding) = 0;
      TREE_TYPE (shadow) = x;
      IDENTIFIER_CLASS_VALUE (name) = x;
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
    }
    }

  /* If we didn't replace an existing binding, put the binding on the
     stack of bindings for the identifier, and update the shadowed list.  */
  if (push_class_binding (name, x))
    {
      class_binding_level->class_shadowed
  = tree_cons (name, NULL,
         class_binding_level->class_shadowed);
      /* Record the value we are binding NAME to so that we can know
   what to pop later.  */
      TREE_TYPE (class_binding_level->class_shadowed) = x;
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
    }

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
}

/* Insert another USING_DECL into the current binding level, returning
   this declaration. If this is a redeclaration, do nothing, and
   return NULL_TREE if this not in namespace scope (in namespace
   scope, a using decl might extend any previous bindings).  */

tree
push_using_decl (scope, name)
     tree scope;
     tree name;
{
  tree decl;

  timevar_push (TV_NAME_LOOKUP);

  my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
  my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
  for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
    if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
      break;
  if (decl)
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
          namespace_bindings_p () ? decl : NULL_TREE);
  decl = build_lang_decl (USING_DECL, name, void_type_node);
  DECL_INITIAL (decl) = scope;
  TREE_CHAIN (decl) = current_binding_level->usings;
  current_binding_level->usings = decl;
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}

/* Add namespace to using_directives. Return NULL_TREE if nothing was
   changed (i.e. there was already a directive), or the fresh
   TREE_LIST otherwise.  */

tree
push_using_directive (used)
     tree used;
{
  tree ud = current_binding_level->using_directives;
  tree iter, ancestor;

  timevar_push (TV_NAME_LOOKUP);

  /* Check if we already have this.  */
  if (purpose_member (used, ud) != NULL_TREE)
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);

  ancestor = namespace_ancestor (current_decl_namespace (), used);
  ud = current_binding_level->using_directives;
  ud = tree_cons (used, ancestor, ud);
  current_binding_level->using_directives = ud;

  /* Recursively add all namespaces used.  */
  for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
    push_using_directive (TREE_PURPOSE (iter));

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
}

/* DECL is a FUNCTION_DECL for a non-member function, which may have
   other definitions already in place.  We get around this by making
   the value of the identifier point to a list of all the things that
   want to be referenced by that name.  It is then up to the users of
   that name to decide what to do with that list.

   DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
   DECL_TEMPLATE_RESULT.  It is dealt with the same way.

   FLAGS is a bitwise-or of the following values:
     PUSH_LOCAL: Bind DECL in the current scope, rather than at
                 namespace scope.
     PUSH_USING: DECL is being pushed as the result of a using
                 declaration.

   The value returned may be a previous declaration if we guessed wrong
   about what language DECL should belong to (C or C++).  Otherwise,
   it's always DECL (and never something that's not a _DECL).  */

tree
push_overloaded_decl (decl, flags)
     tree decl;
     int flags;
{
  tree name = DECL_NAME (decl);
  tree old;
  tree new_binding;
  int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));

  timevar_push (TV_NAME_LOOKUP);

  if (doing_global)
    old = namespace_binding (name, DECL_CONTEXT (decl));
  else
    old = lookup_name_current_level (name);

  if (old)
    {
      if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
  {
    tree t = TREE_TYPE (old);
    if (IS_AGGR_TYPE (t) && warn_shadow
        && (! DECL_IN_SYSTEM_HEADER (decl)
      || ! DECL_IN_SYSTEM_HEADER (old)))
      warning ("`%#D' hides constructor for `%#T'", decl, t);
    old = NULL_TREE;
  }
      else if (is_overloaded_fn (old))
        {
          tree tmp;

    for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
      {
        tree fn = OVL_CURRENT (tmp);

        if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
      && !(flags & PUSH_USING)
      && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
        TYPE_ARG_TYPES (TREE_TYPE (decl))))
    error ("`%#D' conflicts with previous using declaration `%#D'",
        decl, fn);

        if (duplicate_decls (decl, fn))
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
      }
  }
      else if (old == error_mark_node)
  /* Ignore the undefined symbol marker.  */
  old = NULL_TREE;
      else
  {
    cp_error_at ("previous non-function declaration `%#D'", old);
    error ("conflicts with function declaration `%#D'", decl);
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
  }
    }

  if (old || TREE_CODE (decl) == TEMPLATE_DECL)
    {
      if (old && TREE_CODE (old) != OVERLOAD)
  new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
      else
  new_binding = ovl_cons (decl, old);
      if (flags & PUSH_USING)
  OVL_USED (new_binding) = 1;
    }
  else
    /* NAME is not ambiguous.  */
    new_binding = decl;

  if (doing_global)
    set_namespace_binding (name, current_namespace, new_binding);
  else
    {
      /* We only create an OVERLOAD if there was a previous binding at
   this level, or if decl is a template. In the former case, we
   need to remove the old binding and replace it with the new
   binding.  We must also run through the NAMES on the binding
   level where the name was bound to update the chain.  */

      if (TREE_CODE (new_binding) == OVERLOAD && old)
  {
    tree *d;

    for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
         *d;
         d = &TREE_CHAIN (*d))
      if (*d == old
    || (TREE_CODE (*d) == TREE_LIST
        && TREE_VALUE (*d) == old))
        {
    if (TREE_CODE (*d) == TREE_LIST)
      /* Just replace the old binding with the new.  */
      TREE_VALUE (*d) = new_binding;
    else
      /* Build a TREE_LIST to wrap the OVERLOAD.  */
      *d = tree_cons (NULL_TREE, new_binding,
          TREE_CHAIN (*d));

    /* And update the cxx_binding node.  */
    BINDING_VALUE (IDENTIFIER_BINDING (name))
      = new_binding;
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
        }

    /* We should always find a previous binding in this case.  */
    abort ();
  }

      /* Install the new binding.  */
      push_local_binding (name, new_binding, flags);
    }

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}

/* Generate an implicit declaration for identifier FUNCTIONID
   as a function of type int ().  Print a warning if appropriate.  */

tree
implicitly_declare (functionid)
     tree functionid;
{
  register tree decl;

  /* We used to reuse an old implicit decl here,
     but this loses with inline functions because it can clobber
     the saved decl chains.  */
  decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);

  DECL_EXTERNAL (decl) = 1;
  TREE_PUBLIC (decl) = 1;

  /* ISO standard says implicit declarations are in the innermost block.
     So we record the decl in the standard fashion.  */
  pushdecl (decl);
  rest_of_decl_compilation (decl, NULL, 0, 0);

  if (warn_implicit
      /* Only one warning per identifier.  */
      && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
    {
      pedwarn ("implicit declaration of function `%#D'", decl);
    }

  SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);

  return decl;
}

/* Return zero if the declaration NEWDECL is valid
   when the declaration OLDDECL (assumed to be for the same name)
   has already been seen.
   Otherwise return an error message format string with a %s
   where the identifier should go.  */

static const char *
redeclaration_error_message (newdecl, olddecl)
     tree newdecl, olddecl;
{
  if (TREE_CODE (newdecl) == TYPE_DECL)
    {
      /* Because C++ can put things into name space for free,
   constructs like "typedef struct foo { ... } foo"
   would look like an erroneous redeclaration.  */
      if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
  return 0;
      else
  return "redefinition of `%#D'";
    }
  else if (TREE_CODE (newdecl) == FUNCTION_DECL)
    {
      /* If this is a pure function, its olddecl will actually be
   the original initialization to `0' (which we force to call
   abort()).  Don't complain about redefinition in this case.  */
      if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
  return 0;

      /* If both functions come from different namespaces, this is not
   a redeclaration - this is a conflict with a used function.  */
      if (DECL_NAMESPACE_SCOPE_P (olddecl)
    && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
  return "`%D' conflicts with used function";

      /* We'll complain about linkage mismatches in
         warn_extern_redeclared_static.  */

      /* Defining the same name twice is no good.  */
      if (DECL_INITIAL (olddecl) != NULL_TREE
    && DECL_INITIAL (newdecl) != NULL_TREE)
  {
    if (DECL_NAME (olddecl) == NULL_TREE)
      return "`%#D' not declared in class";
    else
      return "redefinition of `%#D'";
  }
      return 0;
    }
  else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
    {
      if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
     && (DECL_TEMPLATE_RESULT (newdecl)
         != DECL_TEMPLATE_RESULT (olddecl))
     && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
     && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
    || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
        && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
        && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
  return "redefinition of `%#D'";
      return 0;
    }
  else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
    {
      /* Objects declared at top level:  */
      /* If at least one is a reference, it's ok.  */
      if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
  return 0;
      /* Reject two definitions.  */
      return "redefinition of `%#D'";
    }
  else
    {
      /* Objects declared with block scope:  */
      /* Reject two definitions, and reject a definition
   together with an external reference.  */
      if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
  return "redeclaration of `%#D'";
      return 0;
    }
}

/* Create a new label, named ID.  */

static tree
make_label_decl (id, local_p)
     tree id;
     int local_p;
{
  tree decl;

  decl = build_decl (LABEL_DECL, id, void_type_node);
  if (expanding_p)
    /* Make sure every label has an rtx.  */
    label_rtx (decl);

  DECL_CONTEXT (decl) = current_function_decl;
  DECL_MODE (decl) = VOIDmode;
  C_DECLARED_LABEL_FLAG (decl) = local_p;

  /* Say where one reference is to the label, for the sake of the
     error if it is not defined.  */
  DECL_SOURCE_LINE (decl) = lineno;
  DECL_SOURCE_FILE (decl) = input_filename;

  /* Record the fact that this identifier is bound to this label.  */
  SET_IDENTIFIER_LABEL_VALUE (id, decl);

  return decl;
}

/* Record this label on the list of used labels so that we can check
   at the end of the function to see whether or not the label was
   actually defined, and so we can check when the label is defined whether
   this use is valid.  */

static void
use_label (decl)
     tree decl;
{
  if (named_label_uses == NULL
      || named_label_uses->names_in_scope != current_binding_level->names
      || named_label_uses->label_decl != decl)
    {
      struct named_label_use_list *new_ent;
      new_ent = ((struct named_label_use_list *)
     ggc_alloc (sizeof (struct named_label_use_list)));
      new_ent->label_decl = decl;
      new_ent->names_in_scope = current_binding_level->names;
      new_ent->binding_level = current_binding_level;
      new_ent->lineno_o_goto = lineno;
      new_ent->filename_o_goto = input_filename;
      new_ent->next = named_label_uses;
      named_label_uses = new_ent;
    }
}

/* Look for a label named ID in the current function.  If one cannot
   be found, create one.  (We keep track of used, but undefined,
   labels, and complain about them at the end of a function.)  */

tree
lookup_label (id)
     tree id;
{
  tree decl;
  struct named_label_list *ent;

  timevar_push (TV_NAME_LOOKUP);

  /* You can't use labels at global scope.  */
  if (current_function_decl == NULL_TREE)
    {
      error ("label `%s' referenced outside of any function",
       IDENTIFIER_POINTER (id));
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
    }

  /* See if we've already got this label.  */
  decl = IDENTIFIER_LABEL_VALUE (id);
  if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);

  /* Record this label on the list of labels used in this function.
     We do this before calling make_label_decl so that we get the
     IDENTIFIER_LABEL_VALUE before the new label is declared.  */
  ent = ((struct named_label_list *)
   ggc_alloc_cleared (sizeof (struct named_label_list)));
  ent->old_value = IDENTIFIER_LABEL_VALUE (id);
  ent->next = named_labels;
  named_labels = ent;

  /* We need a new label.  */
  decl = make_label_decl (id, /*local_p=*/0);

  /* Now fill in the information we didn't have before.  */
  ent->label_decl = decl;

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}

/* Declare a local label named ID.  */

tree
declare_local_label (id)
     tree id;
{
  tree decl;

  /* Add a new entry to the SHADOWED_LABELS list so that when we leave
     this scope we can restore the old value of
     IDENTIFIER_TYPE_VALUE.  */
  current_binding_level->shadowed_labels
    = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
     current_binding_level->shadowed_labels);
  /* Look for the label.  */
  decl = make_label_decl (id, /*local_p=*/1);
  /* Now fill in the information we didn't have before.  */
  TREE_VALUE (current_binding_level->shadowed_labels) = decl;

  return decl;
}

/* Returns nonzero if it is ill-formed to jump past the declaration of
   DECL.  Returns 2 if it's also a real problem.  */

static int
decl_jump_unsafe (decl)
     tree decl;
{
  if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
    return 0;

  if (DECL_INITIAL (decl) == NULL_TREE
      && pod_type_p (TREE_TYPE (decl)))
    return 0;

  /* This is really only important if we're crossing an initialization.
     The POD stuff is just pedantry; why should it matter if the class
     contains a field of pointer to member type?  */
  if (DECL_INITIAL (decl)
      || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
    return 2;
  return 1;
}

/* Check that a single previously seen jump to a newly defined label
   is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
   the jump context; NAMES are the names in scope in LEVEL at the jump
   context; FILE and LINE are the source position of the jump or 0.  */

static void
check_previous_goto_1 (decl, level, names, file, line)
     tree decl;
     struct cp_binding_level *level;
     tree names;
     const char *file;
     int line;
{
  int identified = 0;
  int saw_eh = 0;
  struct cp_binding_level *b = current_binding_level;
  for (; b; b = b->level_chain)
    {
      tree new_decls = b->names;
      tree old_decls = (b == level ? names : NULL_TREE);
      for (; new_decls != old_decls;
     new_decls = TREE_CHAIN (new_decls))
  {
    int problem = decl_jump_unsafe (new_decls);
    if (! problem)
      continue;

    if (! identified)
      {
        if (decl)
    pedwarn ("jump to label `%D'", decl);
        else
    pedwarn ("jump to case label");

        if (file)
    pedwarn_with_file_and_line (file, line, "  from here");
        identified = 1;
      }

    if (problem > 1)
      cp_error_at ("  crosses initialization of `%#D'",
       new_decls);
    else
      cp_pedwarn_at ("  enters scope of non-POD `%#D'",
         new_decls);
  }

      if (b == level)
  break;
      if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
  {
    if (! identified)
      {
        if (decl)
    pedwarn ("jump to label `%D'", decl);
        else
    pedwarn ("jump to case label");

        if (file)
    pedwarn_with_file_and_line (file, line, "  from here");
        identified = 1;
      }
    if (b->is_try_scope)
      error ("  enters try block");
    else
      error ("  enters catch block");
    saw_eh = 1;
  }
    }
}

static void
check_previous_goto (use)
     struct named_label_use_list *use;
{
  check_previous_goto_1 (use->label_decl, use->binding_level,
       use->names_in_scope, use->filename_o_goto,
       use->lineno_o_goto);
}

static void
check_switch_goto (level)
     struct cp_binding_level *level;
{
  check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
}

/* Check that any previously seen jumps to a newly defined label DECL
   are OK.  Called by define_label.  */

static void
check_previous_gotos (decl)
     tree decl;
{
  struct named_label_use_list **usep;

  if (! TREE_USED (decl))
    return;

  for (usep = &named_label_uses; *usep; )
    {
      struct named_label_use_list *use = *usep;
      if (use->label_decl == decl)
  {
    check_previous_goto (use);
    *usep = use->next;
  }
      else
  usep = &(use->next);
    }
}

/* Check that a new jump to a label DECL is OK.  Called by
   finish_goto_stmt.  */

void
check_goto (decl)
     tree decl;
{
  int identified = 0;
  tree bad;
  struct named_label_list *lab;

  /* We can't know where a computed goto is jumping.  So we assume
     that it's OK.  */
  if (! DECL_P (decl))
    return;

  /* If the label hasn't been defined yet, defer checking.  */
  if (! DECL_INITIAL (decl))
    {
      use_label (decl);
      return;
    }

  for (lab = named_labels; lab; lab = lab->next)
    if (decl == lab->label_decl)
      break;

  /* If the label is not on named_labels it's a gcc local label, so
     it must be in an outer scope, so jumping to it is always OK.  */
  if (lab == 0)
    return;

  if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
      && !identified)
    {
      cp_pedwarn_at ("jump to label `%D'", decl);
      pedwarn ("  from here");
      identified = 1;
    }

  for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
    {
      tree b = TREE_VALUE (bad);
      int u = decl_jump_unsafe (b);

      if (u > 1 && DECL_ARTIFICIAL (b))
  /* Can't skip init of __exception_info.  */
  cp_error_at ("  enters catch block", b);
      else if (u > 1)
  cp_error_at ("  skips initialization of `%#D'", b);
      else
  cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
    }

  if (lab->in_try_scope)
    error ("  enters try block");
  else if (lab->in_catch_scope)
    error ("  enters catch block");
}

/* Define a label, specifying the location in the source file.
   Return the LABEL_DECL node for the label.  */

tree
define_label (filename, line, name)
     const char *filename;
     int line;
     tree name;
{
  tree decl = lookup_label (name);
  struct named_label_list *ent;
  register struct cp_binding_level *p;

  timevar_push (TV_NAME_LOOKUP);

  for (ent = named_labels; ent; ent = ent->next)
    if (ent->label_decl == decl)
      break;

  /* After labels, make any new cleanups in the function go into their
     own new (temporary) binding contour.  */
  for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
    p->more_cleanups_ok = 0;

  if (name == get_identifier ("wchar_t"))
    pedwarn ("label named wchar_t");

  if (DECL_INITIAL (decl) != NULL_TREE)
    error ("duplicate label `%D'", decl);
  else
    {
      /* Mark label as having been defined.  */
      DECL_INITIAL (decl) = error_mark_node;
      /* Say where in the source.  */
      DECL_SOURCE_FILE (decl) = filename;
      DECL_SOURCE_LINE (decl) = line;
      if (ent)
  {
    ent->names_in_scope = current_binding_level->names;
    ent->binding_level = current_binding_level;
  }
      check_previous_gotos (decl);
    }

  timevar_pop (TV_NAME_LOOKUP);
  return decl;
}

struct cp_switch
{
  struct cp_binding_level *level;
  struct cp_switch *next;
  /* The SWITCH_STMT being built.  */
  tree switch_stmt;
  /* A splay-tree mapping the low element of a case range to the high
     element, or NULL_TREE if there is no high element.  Used to
     determine whether or not a new case label duplicates an old case
     label.  We need a tree, rather than simply a hash table, because
     of the GNU case range extension.  */
  splay_tree cases;
};

/* A stack of the currently active switch statements.  The innermost
   switch statement is on the top of the stack.  There is no need to
   mark the stack for garbage collection because it is only active
   during the processing of the body of a function, and we never
   collect at that point.  */

static struct cp_switch *switch_stack;

/* Called right after a switch-statement condition is parsed.
   SWITCH_STMT is the switch statement being parsed.  */

void
push_switch (switch_stmt)
     tree switch_stmt;
{
  struct cp_switch *p
    = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
  p->level = current_binding_level;
  p->next = switch_stack;
  p->switch_stmt = switch_stmt;
  p->cases = splay_tree_new (case_compare, NULL, NULL);
  switch_stack = p;
}

void
pop_switch ()
{
  struct cp_switch *cs;

  cs = switch_stack;
  splay_tree_delete (cs->cases);
  switch_stack = switch_stack->next;
  free (cs);
}

/* Note that we've seen a definition of a case label, and complain if this
   is a bad place for one.  */

tree
finish_case_label (low_value, high_value)
     tree low_value;
     tree high_value;
{
  tree cond, r;
  register struct cp_binding_level *p;

  if (! switch_stack)
    {
      if (high_value)
  error ("case label not within a switch statement");
      else if (low_value)
  error ("case label `%E' not within a switch statement",
      low_value);
      else
  error ("`default' label not within a switch statement");
      return NULL_TREE;
    }

  if (processing_template_decl)
    {
      tree label;

      /* For templates, just add the case label; we'll do semantic
   analysis at instantiation-time.  */
      label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
      return add_stmt (build_case_label (low_value, high_value, label));
    }

  /* Find the condition on which this switch statement depends.  */
  cond = SWITCH_COND (switch_stack->switch_stmt);
  if (cond && TREE_CODE (cond) == TREE_LIST)
    cond = TREE_VALUE (cond);

  r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
  if (r == error_mark_node)
    r = NULL_TREE;

  check_switch_goto (switch_stack->level);

  /* After labels, make any new cleanups in the function go into their
     own new (temporary) binding contour.  */
  for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
    p->more_cleanups_ok = 0;

  return r;
}

/* Return the list of declarations of the current level.
   Note that this list is in reverse order unless/until
   you nreverse it; and when you do nreverse it, you must
   store the result back using `storedecls' or you will lose.  */

tree
getdecls ()
{
  return current_binding_level->names;
}

/* Store the list of declarations of the current level.
   This is done for the parameter declarations of a function being defined,
   after they are modified in the light of any missing parameters.  */

static void
storedecls (decls)
     tree decls;
{
  current_binding_level->names = decls;
}

/* Set the current binding TABLE for type declarations..  This is a
   temporary workaround of the fact that the data structure classtypes
   does not currently carry its allocated cxx_scope structure.  */
void
cxx_remember_type_decls (binding_table table)
{
  current_binding_level->type_decls = table;
}


/* Return the type that should be used when TYPE's name is preceded
   by a tag such as 'struct' or 'union', or null if the name cannot
   be used in this way.

   For example, when processing the third line of:

  struct A;
  typedef struct A A;
  struct A;

   lookup of A will find the typedef.  Given A's typedef, this function
   will return the type associated with "struct A".  For the tag to be
   anything other than TYPE, TYPE must be a typedef whose original type
   has the same name and context as TYPE itself.

   It is not valid for a typedef of an anonymous type to be used with
   an explicit tag:

       typedef struct { ... } B;
       struct B;

   Return null for this case.  */

static tree
follow_tag_typedef (type)
     tree type;
{
  tree original;

  original = original_type (type);
  if (! TYPE_NAME (original))
    return NULL_TREE;
  if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
      && (CP_DECL_CONTEXT (TYPE_NAME (original))
    == CP_DECL_CONTEXT (TYPE_NAME (type)))
      && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
    return original;
  else
    return NULL_TREE;
}

/* Given NAME, an IDENTIFIER_NODE,
   return the structure (or union or enum) definition for that name.
   Searches binding levels from BINDING_LEVEL up to the global level.
   If THISLEVEL_ONLY is nonzero, searches only the specified context
   (but skips any tag-transparent contexts to find one that is
   meaningful for tags).
   FORM says which kind of type the caller wants;
   it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
   If the wrong kind of type is found, and it's not a template, an error is
   reported.  */

static tree
lookup_tag (form, name, binding_level, thislevel_only)
     enum tree_code form;
     tree name;
     struct cp_binding_level *binding_level;
     int thislevel_only;
{
  register struct cp_binding_level *level;
  /* Nonzero if, we should look past a template parameter level, even
     if THISLEVEL_ONLY.  */
  int allow_template_parms_p = 1;
  bool type_is_anonymous = ANON_AGGRNAME_P (name);

  timevar_push (TV_NAME_LOOKUP);

  for (level = binding_level; level; level = level->level_chain)
    {
      register tree tail;
      if (type_is_anonymous && level->type_decls != NULL)
        {
          tree type = binding_table_find_anon_type (level->type_decls, name);
          /* There's no need for error checking here, because
             anon names are unique throughout the compilation.  */
          if (type != NULL)
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
        }
      else if (level->namespace_p)
  /* Do namespace lookup.  */
  for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
    {
      cxx_binding *binding =
              cxx_scope_find_binding_for_name (tail, name);
            tree old;

      /* If we just skipped past a template parameter level,
         even though THISLEVEL_ONLY, and we find a template
         class declaration, then we use the _TYPE node for the
         template.  See the example below.  */
      if (thislevel_only && !allow_template_parms_p
    && binding && BINDING_VALUE (binding)
    && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (binding)))
        old = TREE_TYPE (BINDING_VALUE (binding));
      else if (binding)
        old = BINDING_TYPE (binding);
            else
              old = NULL;

      if (old)
        {
    /* We've found something at this binding level.  If it is
       a typedef, extract the tag it refers to.  Lookup fails
       if the typedef doesn't refer to a taggable type.  */
    old = follow_tag_typedef (old);
    if (!old)
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
    if (TREE_CODE (old) != form
        && (form == ENUMERAL_TYPE
      || TREE_CODE (old) == ENUMERAL_TYPE))
      {
        error ("`%#D' redeclared as %C", old, form);
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
      }
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old);
        }
      if (thislevel_only || tail == global_namespace)
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
    }
      else if (level->type_decls != NULL)
        {
          binding_entry entry = binding_table_find (level->type_decls, name);
          if (entry != NULL)
            {
              enum tree_code code = TREE_CODE (entry->type);

              if (code != form
                  && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
                {
                  /* Definition isn't the kind we were looking for.  */
                  error ("`%#D' redeclared as %C", entry->type, form);
                  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
                }
              POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->type);
            }
        }
      if (thislevel_only && ! level->tag_transparent)
  {
    if (level->template_parms_p && allow_template_parms_p)
      {
        /* We must deal with cases like this:

             template <class T> struct S;
       template <class T> struct S {};

     When looking up `S', for the second declaration, we
     would like to find the first declaration.  But, we
     are in the pseudo-global level created for the
     template parameters, rather than the (surrounding)
     namespace level.  Thus, we keep going one more level,
     even though THISLEVEL_ONLY is nonzero.  */
        allow_template_parms_p = 0;
        continue;
      }
    else
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
  }
    }
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
}

#if 0
void
set_current_level_tags_transparency (tags_transparent)
     int tags_transparent;
{
  current_binding_level->tag_transparent = tags_transparent;
}
#endif

/* Given a type, find the tag that was defined for it and return the tag name.
   Otherwise return 0.  However, the value can never be 0
   in the cases in which this is used.

   C++: If NAME is nonzero, this is the new name to install.  This is
   done when replacing anonymous tags with real tag names.  */

static tree
lookup_tag_reverse (type, name)
     tree type;
     tree name;
{
  register struct cp_binding_level *level;

  timevar_push (TV_NAME_LOOKUP);

  for (level = current_binding_level; level; level = level->level_chain)
    {
      binding_entry entry = level->type_decls == NULL
        ? NULL
        : binding_table_reverse_maybe_remap (level->type_decls, type, name);
      if (entry)
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->name);
    }
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
}

/* Look up NAME in the NAMESPACE.  */

tree
lookup_namespace_name (namespace, name)
     tree namespace, name;
{
  tree val;
  tree template_id = NULL_TREE;
  cxx_binding binding;

  timevar_push (TV_NAME_LOOKUP);

  my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);

  if (TREE_CODE (name) == NAMESPACE_DECL)
    /* This happens for A::B<int> when B is a namespace.  */
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
  else if (TREE_CODE (name) == TEMPLATE_DECL)
    {
      /* This happens for A::B where B is a template, and there are no
   template arguments.  */
      error ("invalid use of `%D'", name);
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
    }

  namespace = ORIGINAL_NAMESPACE (namespace);

  if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
    {
      template_id = name;
      name = TREE_OPERAND (name, 0);
      if (TREE_CODE (name) == OVERLOAD)
  name = DECL_NAME (OVL_CURRENT (name));
      else if (DECL_P (name))
  name = DECL_NAME (name);
    }

  my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);

  cxx_binding_clear (&binding);
  if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);

  if (binding.value)
    {
      val = binding.value;

      if (template_id)
  {
    if (DECL_CLASS_TEMPLATE_P (val))
      val = lookup_template_class (val,
           TREE_OPERAND (template_id, 1),
           /*in_decl=*/NULL_TREE,
           /*context=*/NULL_TREE,
           /*entering_scope=*/0,
                                   tf_error | tf_warning);
    else if (DECL_FUNCTION_TEMPLATE_P (val)
       || TREE_CODE (val) == OVERLOAD)
      val = lookup_template_function (val,
              TREE_OPERAND (template_id, 1));
    else
      {
        error ("`%D::%D' is not a template",
      namespace, name);
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
      }
  }

      /* If we have a single function from a using decl, pull it out.  */
      if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
  val = OVL_FUNCTION (val);

      /* Ignore built-in functions that haven't been prototyped yet.  */
      if (!val || !DECL_P(val)
          || !DECL_LANG_SPECIFIC(val)
          || !DECL_ANTICIPATED (val))
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
    }

  error ("`%D' undeclared in namespace `%D'", name, namespace);
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}

/* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */

static hashval_t
typename_hash (k)
     const void * k;
{
  hashval_t hash;
  tree t = (tree) k;

  hash = (htab_hash_pointer (TYPE_CONTEXT (t))
    ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));

  return hash;
}

/* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */

static int
typename_compare (k1, k2)
     const void * k1;
     const void * k2;
{
  tree t1;
  tree t2;
  tree d1;
  tree d2;

  t1 = (tree) k1;
  t2 = (tree) k2;
  d1 = TYPE_NAME (t1);
  d2 = TYPE_NAME (t2);

  return (DECL_NAME (d1) == DECL_NAME (d2)
    && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
    && ((TREE_TYPE (t1) != NULL_TREE)
        == (TREE_TYPE (t2) != NULL_TREE))
    && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
    && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
}

/* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
   the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
   is non-NULL, this type is being created by the implicit typename
   extension, and BASE_TYPE is a type named `t' in some base class of
   `T' which depends on template parameters.

   Returns the new TYPENAME_TYPE.  */

static GTY ((param_is (union tree_node))) htab_t typename_htab;

tree
build_typename_type (context, name, fullname, base_type)
     tree context;
     tree name;
     tree fullname;
     tree base_type;
{
  tree t;
  tree d;
  PTR *e;

  if (typename_htab == NULL)
    {
      typename_htab = htab_create_ggc (61, &typename_hash, 
               &typename_compare, NULL);
    }

  /* Build the TYPENAME_TYPE.  */
  t = make_aggr_type (TYPENAME_TYPE);
  TYPE_CONTEXT (t) = FROB_CONTEXT (context);
  TYPENAME_TYPE_FULLNAME (t) = fullname;
  TREE_TYPE (t) = base_type;

  /* Build the corresponding TYPE_DECL.  */
  d = build_decl (TYPE_DECL, name, t);
  TYPE_NAME (TREE_TYPE (d)) = d;
  TYPE_STUB_DECL (TREE_TYPE (d)) = d;
  DECL_CONTEXT (d) = FROB_CONTEXT (context);
  DECL_ARTIFICIAL (d) = 1;

  /* See if we already have this type.  */
  e = htab_find_slot (typename_htab, t, INSERT);
  if (*e)
    t = (tree) *e;
  else
    *e = t;

  return t;
}

/* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
   unless an error occurs, in which case error_mark_node is returned.
   If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
   set, we return that, rather than the _TYPE it corresponds to, in
   other cases we look through the type decl.  If TF_ERROR is set,
   complain about errors, otherwise be quiet.  */

tree
make_typename_type (context, name, complain)
     tree context, name;
     tsubst_flags_t complain;
{
  tree fullname;

  if (TYPE_P (name))
    {
      if (!(TYPE_LANG_SPECIFIC (name)
      && (CLASSTYPE_IS_TEMPLATE (name)
    || CLASSTYPE_USE_TEMPLATE (name))))
  name = TYPE_IDENTIFIER (name);
      else
  /* Create a TEMPLATE_ID_EXPR for the type.  */
  name = build_nt (TEMPLATE_ID_EXPR,
       CLASSTYPE_TI_TEMPLATE (name),
       CLASSTYPE_TI_ARGS (name));
    }
  else if (TREE_CODE (name) == TYPE_DECL)
    name = DECL_NAME (name);

  fullname = name;

  if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
    {
      name = TREE_OPERAND (name, 0);
      if (TREE_CODE (name) == TEMPLATE_DECL)
  name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
    }
  if (TREE_CODE (name) == TEMPLATE_DECL)
    {
      error ("`%D' used without template parameters", name);
      return error_mark_node;
    }
  if (TREE_CODE (name) != IDENTIFIER_NODE)
    abort ();

  if (TREE_CODE (context) == NAMESPACE_DECL)
    {
      /* We can get here from typename_sub0 in the explicit_template_type
   expansion.  Just fail.  */
      if (complain & tf_error)
  error ("no class template named `%#T' in `%#T'",
      name, context);
      return error_mark_node;
    }

  if (! uses_template_parms (context)
      || currently_open_class (context))
    {
      if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
  {
    tree tmpl = NULL_TREE;
    if (IS_AGGR_TYPE (context))
      tmpl = lookup_field (context, name, 0, 0);
    if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
      {
        if (complain & tf_error)
    error ("no class template named `%#T' in `%#T'",
        name, context);
        return error_mark_node;
      }

    if (complain & tf_error)
      {
        if (complain & tf_parsing)
    type_access_control (context, tmpl);
        else
    enforce_access (context, tmpl);
      }

    return lookup_template_class (tmpl,
          TREE_OPERAND (fullname, 1),
          NULL_TREE, context,
          /*entering_scope=*/0,
                                  tf_error | tf_warning);
  }
      else
  {
          tree t;

    if (!IS_AGGR_TYPE (context))
      {
        if (complain & tf_error)
    error ("no type named `%#T' in `%#T'", name, context);
        return error_mark_node;
      }

    t = lookup_field (context, name, 0, 1);
    if (t)
      {
        if (TREE_CODE (t) != TYPE_DECL)
    {
      if (complain & tf_error)
        error ("no type named `%#T' in `%#T'", name, context);
      return error_mark_node;
    }

        if (complain & tf_error)
    {
            if (complain & tf_parsing)
        type_access_control (context, t);
      else
        enforce_access (context, t);
    }

        if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
    t = TREE_TYPE (t);
        if (IMPLICIT_TYPENAME_P (t))
    {
      /* Lookup found an implicit typename that we had
         injected into the current scope. Doing things
         properly would have located the exact same type,
         so there is no error here.  We must remove the
         implicitness so that we do not warn about it.  */
      t = copy_node (t);
      TREE_TYPE (t) = NULL_TREE;
    }
        
        return t;
      }
  }
    }

  /* If the CONTEXT is not a template type, then either the field is
     there now or its never going to be.  */
  if (!uses_template_parms (context))
    {
      if (complain & tf_error)
  error ("no type named `%#T' in `%#T'", name, context);
      return error_mark_node;
    }

  return build_typename_type (context, name, fullname,  NULL_TREE);
}

/* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
   unless an error occurs, in which case error_mark_node is returned.
   If we locate a TYPE_DECL, we return that, rather than the _TYPE it
   corresponds to.  If COMPLAIN zero, don't complain about any errors
   that occur.  */

tree
make_unbound_class_template (context, name, complain)
     tree context, name;
     tsubst_flags_t complain;
{
  tree t;
  tree d;

  if (TYPE_P (name))
    name = TYPE_IDENTIFIER (name);
  else if (DECL_P (name))
    name = DECL_NAME (name);
  if (TREE_CODE (name) != IDENTIFIER_NODE)
    abort ();

  if (!uses_template_parms (context)
      || currently_open_class (context))
    {
      tree tmpl = NULL_TREE;

      if (IS_AGGR_TYPE (context))
  tmpl = lookup_field (context, name, 0, 0);

      if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
  {
    if (complain & tf_error)
      error ("no class template named `%#T' in `%#T'", name, context);
    return error_mark_node;
  }
      
      if (complain & tf_error)
  {
    if (complain & tf_parsing)
      type_access_control (context, tmpl);
    else
      enforce_access (context, tmpl);
  }

      return tmpl;
    }

  /* Build the UNBOUND_CLASS_TEMPLATE.  */
  t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
  TYPE_CONTEXT (t) = FROB_CONTEXT (context);
  TREE_TYPE (t) = NULL_TREE;

  /* Build the corresponding TEMPLATE_DECL.  */
  d = build_decl (TEMPLATE_DECL, name, t);
  TYPE_NAME (TREE_TYPE (d)) = d;
  TYPE_STUB_DECL (TREE_TYPE (d)) = d;
  DECL_CONTEXT (d) = FROB_CONTEXT (context);
  DECL_ARTIFICIAL (d) = 1;

  return t;
}

/* Select the right _DECL from multiple choices.  */

static tree
select_decl (cxx_binding *binding, int flags)
{
  tree val;
  
  timevar_push (TV_NAME_LOOKUP);

  val = BINDING_VALUE (binding);

  if (LOOKUP_NAMESPACES_ONLY (flags))
    {
      /* We are not interested in types.  */
      if (val && TREE_CODE (val) == NAMESPACE_DECL)
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
    }

  /* If we could have a type and
     we have nothing or we need a type and have none.  */
  if (BINDING_TYPE (binding)
      && (!val || ((flags & LOOKUP_PREFER_TYPES)
                   && TREE_CODE (val) != TYPE_DECL)))
    val = TYPE_STUB_DECL (BINDING_TYPE (binding));
  /* Don't return non-types if we really prefer types.  */
  else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
     && (TREE_CODE (val) != TEMPLATE_DECL
         || !DECL_CLASS_TEMPLATE_P (val)))
    val = NULL_TREE;

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
}

/* Unscoped lookup of a global: iterate over current namespaces,
   considering using-directives.  If SPACESP is non-NULL, store a list
   of the namespaces we've considered in it.  */

tree
unqualified_namespace_lookup (name, flags, spacesp)
     tree name;
     int flags;
     tree *spacesp;
{
  tree initial = current_decl_namespace ();
  tree scope = initial;
  tree siter;
  struct cp_binding_level *level;
  tree val = NULL_TREE;
  cxx_binding binding;

  timevar_push (TV_NAME_LOOKUP);
  cxx_binding_clear (&binding);
  if (spacesp)
    *spacesp = NULL_TREE;

  for (; !val; scope = CP_DECL_CONTEXT (scope))
    {
      cxx_binding *b;
      if (spacesp)
  *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
      b = cxx_scope_find_binding_for_name (scope, name);

      /* Ignore anticipated built-in functions.  */
      if (b && BINDING_VALUE (b) && DECL_P (BINDING_VALUE (b))
          && DECL_LANG_SPECIFIC (BINDING_VALUE (b))
          && DECL_ANTICIPATED (BINDING_VALUE (b)))
        /* Keep binding cleared.  */;
      else if (b)
        {
          /* Initialize binding for this context.  */
          binding.value = BINDING_VALUE (b);
          binding.type = BINDING_TYPE (b);
        }

      /* Add all _DECLs seen through local using-directives.  */
      for (level = current_binding_level;
     !level->namespace_p;
     level = level->level_chain)
  if (!lookup_using_namespace (name, &binding, level->using_directives,
                                     scope, flags, spacesp))
    /* Give up because of error.  */
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);

      /* Add all _DECLs seen through global using-directives.  */
      /* XXX local and global using lists should work equally.  */
      siter = initial;
      while (1)
  {
    if (!lookup_using_namespace (name, &binding,
                                       DECL_NAMESPACE_USING (siter),
               scope, flags, spacesp))
      /* Give up because of error.  */
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
    if (siter == scope) break;
    siter = CP_DECL_CONTEXT (siter);
  }

      val = select_decl (&binding, flags);
      if (scope == global_namespace)
  break;
    }
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
}

/* Combine prefer_type and namespaces_only into flags.  */

static int
lookup_flags (prefer_type, namespaces_only)
  int prefer_type, namespaces_only;
{
  if (namespaces_only)
    return LOOKUP_PREFER_NAMESPACES;
  if (prefer_type > 1)
    return LOOKUP_PREFER_TYPES;
  if (prefer_type > 0)
    return LOOKUP_PREFER_BOTH;
  return 0;
}

/* Given a lookup that returned VAL, use FLAGS to decide if we want to
   ignore it or not.  Subroutine of lookup_name_real.  */

static tree
qualify_lookup (val, flags)
     tree val;
     int flags;
{
  if (val == NULL_TREE)
    return val;
  if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
    return val;
  if ((flags & LOOKUP_PREFER_TYPES)
      && (TREE_CODE (val) == TYPE_DECL
    || ((flags & LOOKUP_TEMPLATES_EXPECTED)
        && DECL_CLASS_TEMPLATE_P (val))))
    return val;
  if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
    return NULL_TREE;
  return val;
}

/* Any other BINDING overrides an implicit TYPENAME.  Warn about
   that.  */

static void
warn_about_implicit_typename_lookup (typename, binding)
     tree typename;
     tree binding;
{
  tree subtype = TREE_TYPE (TREE_TYPE (typename));
  tree name = DECL_NAME (typename);

  if (! (TREE_CODE (binding) == TEMPLATE_DECL
   && CLASS_TYPE_P (subtype)
   && CLASSTYPE_TEMPLATE_INFO (subtype)
   && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
      && ! (TREE_CODE (binding) == TYPE_DECL
      && same_type_p (TREE_TYPE (binding), subtype)))
    {
      warning ("lookup of `%D' finds `%#D'",
      name, binding);
      warning ("  instead of `%D' from dependent base class",
      typename);
      warning ("  (use `typename %T::%D' if that's what you meant)",
      constructor_name (current_class_type), name);
    }
}

/* Check to see whether or not DECL is a variable that would have been
   in scope under the ARM, but is not in scope under the ANSI/ISO
   standard.  If so, issue an error message.  If name lookup would
   work in both cases, but return a different result, this function
   returns the result of ANSI/ISO lookup.  Otherwise, it returns
   DECL.  */

tree
check_for_out_of_scope_variable (tree decl)
{
  tree shadowed;

  /* We only care about out of scope variables.  */
  if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
    return decl;

  shadowed = DECL_SHADOWED_FOR_VAR (decl);
  while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
   && DECL_DEAD_FOR_LOCAL (shadowed))
    shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
  if (!shadowed)
    shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
  if (shadowed)
    {
      if (!DECL_ERROR_REPORTED (decl))
  {
    warning ("name lookup of `%D' changed",
          DECL_NAME (decl));
    cp_warning_at ("  matches this `%D' under ISO standard rules",
       shadowed);
    cp_warning_at ("  matches this `%D' under old rules", decl);
    DECL_ERROR_REPORTED (decl) = 1;
  }
      return shadowed;
    }

  /* If we have already complained about this declaration, there's no
     need to do it again.  */
  if (DECL_ERROR_REPORTED (decl))
    return decl;

  DECL_ERROR_REPORTED (decl) = 1;
  if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
    {
      error ("name lookup of `%D' changed for new ISO `for' scoping",
       DECL_NAME (decl));
      cp_error_at ("  cannot use obsolete binding at `%D' because it has a destructor", decl);
      return error_mark_node;
    }
  else
    {
      pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
         DECL_NAME (decl));
      cp_pedwarn_at ("  using obsolete binding at `%D'", decl);
    }

  return decl;
}

/* Look up NAME in the current binding level and its superiors in the
   namespace of variables, functions and typedefs.  Return a ..._DECL
   node of some kind representing its definition if there is only one
   such declaration, or return a TREE_LIST with all the overloaded
   definitions if there are many, or return 0 if it is undefined.

   If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
   If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
   If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
   Otherwise we prefer non-TYPE_DECLs.

   If NONCLASS is nonzero, we don't look for the NAME in class scope,
   using IDENTIFIER_CLASS_VALUE.  */

static tree
lookup_name_real (name, prefer_type, nonclass, namespaces_only)
     tree name;
     int prefer_type, nonclass, namespaces_only;
{
  tree t;
  tree val = NULL_TREE;
  int yylex = 0;
  tree from_obj = NULL_TREE;
  int flags;
  int val_is_implicit_typename = 0;
  cxx_binding *iter;

  timevar_push (TV_NAME_LOOKUP);

  /* Hack: copy flag set by parser, if set.  */
  if (only_namespace_names)
    namespaces_only = 1;

  if (prefer_type == -2)
    {
      extern int looking_for_typename;
      tree type = NULL_TREE;

      yylex = 1;
      prefer_type = looking_for_typename;

      flags = lookup_flags (prefer_type, namespaces_only);
      /* If the next thing is '<', class templates are types.  */
      if (looking_for_template)
        flags |= LOOKUP_TEMPLATES_EXPECTED;

      if (got_scope)
  type = got_scope;
      else if (got_object != error_mark_node)
  type = got_object;

      if (type)
  {
    if (type == error_mark_node)
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
    if (IMPLICIT_TYPENAME_P (type))
      type = TREE_TYPE (type);

    if (TYPE_P (type))
      type = complete_type (type);

    if (TREE_CODE (type) == VOID_TYPE)
      type = global_namespace;
    if (TREE_CODE (type) == NAMESPACE_DECL)
      {
              cxx_binding b;
              cxx_binding_clear (&b);
        flags |= LOOKUP_COMPLAIN;
        if (!qualified_lookup_using_namespace (name, type, &b, flags))
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
        val = select_decl (&b, flags);
      }
    else if (! IS_AGGR_TYPE (type)
       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
       || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
       || TREE_CODE (type) == TYPENAME_TYPE)
      /* Someone else will give an error about this if needed.  */
      val = NULL_TREE;
    else if (type == current_class_type)
      val = IDENTIFIER_CLASS_VALUE (name);
    else
      {
        val = lookup_member (type, name, 0, prefer_type);
        if (!uses_template_parms (type))
    type_access_control (type, val);

        /* Restore the containing TYPENAME_TYPE if we looked
     through it before.  */
        if (got_scope && got_scope != type
      && val && TREE_CODE (val) == TYPE_DECL
      && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
    {
      val = TREE_TYPE (val);
      val = build_typename_type (got_scope, name,
               TYPENAME_TYPE_FULLNAME (val),
               TREE_TYPE (val));
      val = TYPE_STUB_DECL (val);
    }
      }
  }
      else
  val = NULL_TREE;

      if (got_scope)
  goto done;
      else if (got_object && val)
  {
    from_obj = val;
    val = NULL_TREE;
  }
    }
  else
    {
      flags = lookup_flags (prefer_type, namespaces_only);
      /* If we're not parsing, we need to complain.  */
      flags |= LOOKUP_COMPLAIN;
    }

  /* Conversion operators are handled specially because ordinary
     unqualified name lookup will not find template conversion
     operators.  */
  if (IDENTIFIER_TYPENAME_P (name)) 
    {
      struct cp_binding_level *level;

      for (level = current_binding_level; 
     level && !level->namespace_p; 
     level = level->level_chain)
  {
    tree class_type;
    tree operators;
    
    /* A conversion operator can only be declared in a class 
       scope.  */
    if (level->parm_flag != 2)
      continue;
    
    /* Lookup the conversion operator in the class.  */
    class_type = level->this_class;
    operators = lookup_fnfields (class_type, name, /*protect=*/0);
    if (operators)
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
  }

      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
    }

  /* First, look in non-namespace scopes.  */

  if (current_class_type == NULL_TREE)
    nonclass = 1;

  for (iter = IDENTIFIER_BINDING (name); iter; iter = iter->previous)
    {
      tree binding;

      if (!LOCAL_BINDING_P (iter) && nonclass)
  /* We're not looking for class-scoped bindings, so keep going.  */
  continue;

      /* If this is the kind of thing we're looking for, we're done.  */
      if (qualify_lookup (BINDING_VALUE (iter), flags))
  binding = BINDING_VALUE (iter);
      else if ((flags & LOOKUP_PREFER_TYPES)
         && qualify_lookup (BINDING_TYPE (iter), flags))
  binding = BINDING_TYPE (iter);
      else
  binding = NULL_TREE;

      /* Handle access control on types from enclosing or base classes.  */
      if (binding && ! yylex
    && BINDING_LEVEL (iter) && BINDING_LEVEL (iter)->parm_flag == 2)
  type_access_control (BINDING_LEVEL (iter)->this_class, binding);

      if (binding
    && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
  {
    if (val_is_implicit_typename && !yylex)
      warn_about_implicit_typename_lookup (val, binding);
    val = binding;
    val_is_implicit_typename
      = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
    if (!val_is_implicit_typename)
      break;
  }
    }

  /* The name might be from an enclosing class of the current scope.  */
  if (!val && !nonclass && current_class_type)
    val = qualify_lookup (lookup_nested_field (name, !yylex), flags);

  /* Now lookup in namespace scopes.  */
  if (!val || val_is_implicit_typename)
    {
      t = unqualified_namespace_lookup (name, flags, 0);
      if (t)
  {
    if (val_is_implicit_typename && !yylex)
      warn_about_implicit_typename_lookup (val, t);
    val = t;
  }
    }

 done:
  if (val)
    {
      /* This should only warn about types used in qualified-ids.  */
      if (from_obj && from_obj != val)
  {
    if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
        && TREE_CODE (val) == TYPE_DECL
        && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
      pedwarn ("\
lookup of `%D' in the scope of `%#T' (`%#D') \
does not match lookup in the current scope (`%#D')",
      name, got_object, from_obj, val);

    /* We don't change val to from_obj if got_object depends on
       template parms because that breaks implicit typename for
       destructor calls.  */
    if (! uses_template_parms (got_object))
      val = from_obj;
  }

      /* If we have a single function from a using decl, pull it out.  */
      if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
  val = OVL_FUNCTION (val);
    }
  else if (from_obj)
    val = from_obj;

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
}

tree
lookup_name_nonclass (name)
     tree name;
{
  return lookup_name_real (name, 0, 1, 0);
}

tree
lookup_function_nonclass (name, args)
     tree name;
     tree args;
{
  return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
}

tree
lookup_name_namespace_only (name)
     tree name;
{
  /* type-or-namespace, nonclass, namespace_only */
  return lookup_name_real (name, 1, 1, 1);
}

tree
lookup_name (name, prefer_type)
     tree name;
     int prefer_type;
{
  return lookup_name_real (name, prefer_type, 0, 0);
}

/* Similar to `lookup_name' but look only in the innermost non-class
   binding level.  */

tree
lookup_name_current_level (name)
     tree name;
{
  struct cp_binding_level *b;
  tree t = NULL_TREE;

  timevar_push (TV_NAME_LOOKUP);

  b = current_binding_level;
  while (b->parm_flag == 2)
    b = b->level_chain;

  if (b->namespace_p)
    {
      t = IDENTIFIER_NAMESPACE_VALUE (name);

      /* extern "C" function() */
      if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
  t = TREE_VALUE (t);
    }
  else if (IDENTIFIER_BINDING (name)
     && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
    {
      while (1)
  {
    if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));

    if (b->keep == 2)
      b = b->level_chain;
    else
      break;
  }
    }

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}

/* Like lookup_name_current_level, but for types.  */

tree
lookup_type_current_level (name)
     tree name;
{
  register tree t = NULL_TREE;
  
  timevar_push (TV_NAME_LOOKUP);

  my_friendly_assert (! current_binding_level->namespace_p, 980716);

  if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
      && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
    {
      struct cp_binding_level *b = current_binding_level;
      while (1)
  {
    if (purpose_member (name, b->type_shadowed))
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
            REAL_IDENTIFIER_TYPE_VALUE (name));
    if (b->keep == 2)
      b = b->level_chain;
    else
      break;
  }
    }

  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}

void
begin_only_namespace_names ()
{
  only_namespace_names = 1;
}

void
end_only_namespace_names ()
{
  only_namespace_names = 0;
}

/* Push the declarations of builtin types into the namespace.
   RID_INDEX is the index of the builtin type
   in the array RID_POINTERS.  NAME is the name used when looking
   up the builtin type.  TYPE is the _TYPE node for the builtin type.  */

void
record_builtin_type (rid_index, name, type)
     enum rid rid_index;
     const char *name;
     tree type;
{
  tree rname = NULL_TREE, tname = NULL_TREE;
  tree tdecl = NULL_TREE;

  if ((int) rid_index < (int) RID_MAX)
    rname = ridpointers[(int) rid_index];
  if (name)
    tname = get_identifier (name);

  TYPE_BUILT_IN (type) = 1;

  if (tname)
    {
      tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
      set_identifier_type_value (tname, NULL_TREE);
      if ((int) rid_index < (int) RID_MAX)
  /* Built-in types live in the global namespace.  */
  SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
    }
  if (rname != NULL_TREE)
    {
      if (tname != NULL_TREE)
  {
    set_identifier_type_value (rname, NULL_TREE);
    SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
  }
      else
  {
    tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
    set_identifier_type_value (rname, NULL_TREE);
  }
    }
}

/* Record one of the standard Java types.
 * Declare it as having the given NAME.
 * If SIZE > 0, it is the size of one of the integral types;
 * otherwise it is the negative of the size of one of the other types.  */

static tree
record_builtin_java_type (name, size)
     const char *name;
     int size;
{
  tree type, decl;
  if (size > 0)
    type = make_signed_type (size);
  else if (size > -32)
    { /* "__java_char" or ""__java_boolean".  */
      type = make_unsigned_type (-size);
      /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
    }
  else
    { /* "__java_float" or ""__java_double".  */
      type = make_node (REAL_TYPE);
      TYPE_PRECISION (type) = - size;
      layout_type (type);
    }
  record_builtin_type (RID_MAX, name, type);
  decl = TYPE_NAME (type);

  /* Suppress generate debug symbol entries for these types,
     since for normal C++ they are just clutter.
     However, push_lang_context undoes this if extern "Java" is seen.  */
  DECL_IGNORED_P (decl) = 1;

  TYPE_FOR_JAVA (type) = 1;
  return type;
}

/* Push a type into the namespace so that the back-ends ignore it.  */

static void
record_unknown_type (type, name)
     tree type;
     const char *name;
{
  tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
  /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
  DECL_IGNORED_P (decl) = 1;
  TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
  TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
  TYPE_ALIGN (type) = 1;
  TYPE_USER_ALIGN (type) = 0;
  TYPE_MODE (type) = TYPE_MODE (void_type_node);
}

/* An string for which we should create an IDENTIFIER_NODE at
   startup.  */

typedef struct predefined_identifier
{
  /* The name of the identifier.  */
  const char *const name;
  /* The place where the IDENTIFIER_NODE should be stored.  */
  tree *const node;
  /* Nonzero if this is the name of a constructor or destructor.  */
  const int ctor_or_dtor_p;
} predefined_identifier;

/* Create all the predefined identifiers.  */

static void
initialize_predefined_identifiers ()
{
  const predefined_identifier *pid;

  /* A table of identifiers to create at startup.  */
  static const predefined_identifier predefined_identifiers[] = {
    { "C++", &lang_name_cplusplus, 0 },
    { "C", &lang_name_c, 0 },
    { "Java", &lang_name_java, 0 },
    { CTOR_NAME, &ctor_identifier, 1 },
    { "__base_ctor", &base_ctor_identifier, 1 },
    { "__comp_ctor", &complete_ctor_identifier, 1 },
    { DTOR_NAME, &dtor_identifier, 1 },
    { "__comp_dtor", &complete_dtor_identifier, 1 },
    { "__base_dtor", &base_dtor_identifier, 1 },
    { "__deleting_dtor", &deleting_dtor_identifier, 1 },
    { IN_CHARGE_NAME, &in_charge_identifier, 0 },
    { "nelts", &nelts_identifier, 0 },
    { THIS_NAME, &this_identifier, 0 },
    { VTABLE_DELTA_NAME, &delta_identifier, 0 },
    { VTABLE_PFN_NAME, &pfn_identifier, 0 },
    { "_vptr", &vptr_identifier, 0 },
    { "__vtt_parm", &vtt_parm_identifier, 0 },
    { "std", &std_identifier, 0 },
    { NULL, NULL, 0 }
  };

  for (pid = predefined_identifiers; pid->name; ++pid)
    {
      *pid->node = get_identifier (pid->name);
      if (pid->ctor_or_dtor_p)
  IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
    }
}

/* Create the predefined scalar types of C,
   and some nodes representing standard constants (0, 1, (void *)0).
   Initialize the global binding level.
   Make definitions for built-in primitive functions.  */

void
cxx_init_decl_processing ()
{
  tree void_ftype;
  tree void_ftype_ptr;

  /* Create all the identifiers we need.  */
  initialize_predefined_identifiers ();

  /* Fill in back-end hooks.  */
  lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;

  /* Create the global variables.  */
  push_to_top_level ();

  /* Enter the global namespace.  */
  my_friendly_assert (global_namespace == NULL_TREE, 375);
  push_namespace (get_identifier ("::"));
  global_namespace = current_namespace;
  current_lang_name = NULL_TREE;

  /* Adjust various flags based on command-line settings.  */
  if (!flag_permissive)
    flag_pedantic_errors = 1;
  if (!flag_no_inline)
    {
      flag_inline_trees = 1;
      flag_no_inline = 1;
    }
  if (flag_inline_functions)
    {
      flag_inline_trees = 2;
      flag_inline_functions = 0;
    }

  /* Force minimum function alignment if using the least significant
     bit of function pointers to store the virtual bit.  */
  if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
      && force_align_functions_log < 1)
    force_align_functions_log = 1;

  /* Initially, C.  */
  current_lang_name = lang_name_c;

  current_function_decl = NULL_TREE;
  current_binding_level = NULL_BINDING_LEVEL;
  free_binding_level = NULL_BINDING_LEVEL;

  build_common_tree_nodes (flag_signed_char);

  error_mark_list = build_tree_list (error_mark_node, error_mark_node);
  TREE_TYPE (error_mark_list) = error_mark_node;

  /* Make the binding_level structure for global names.  */
  pushlevel (0);
  current_binding_level->type_decls = binding_table_new (GLOBAL_SCOPE_HT_SIZE);
  /* The global level is the namespace level of ::.  */
  NAMESPACE_LEVEL (global_namespace) = current_binding_level;
  declare_namespace_level ();

  VARRAY_TREE_INIT (current_binding_level->static_decls,
        200,
        "Static declarations");

  /* Create the `std' namespace.  */
  push_namespace (std_identifier);
  std_node = current_namespace;
  pop_namespace ();

  c_common_nodes_and_builtins ();

  java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
  java_short_type_node = record_builtin_java_type ("__java_short", 16);
  java_int_type_node = record_builtin_java_type ("__java_int", 32);
  java_long_type_node = record_builtin_java_type ("__java_long", 64);
  java_float_type_node = record_builtin_java_type ("__java_float", -32);
  java_double_type_node = record_builtin_java_type ("__java_double", -64);
  java_char_type_node = record_builtin_java_type ("__java_char", -16);
  java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);

  integer_two_node = build_int_2 (2, 0);
  TREE_TYPE (integer_two_node) = integer_type_node;
  integer_three_node = build_int_2 (3, 0);
  TREE_TYPE (integer_three_node) = integer_type_node;

  boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
  TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
  TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
  TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
  TYPE_PRECISION (boolean_type_node) = 1;
  record_builtin_type (RID_BOOL, "bool", boolean_type_node);
  boolean_false_node = build_int_2 (0, 0);
  TREE_TYPE (boolean_false_node) = boolean_type_node;
  boolean_true_node = build_int_2 (1, 0);
  TREE_TYPE (boolean_true_node) = boolean_type_node;

  empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);

#if 0
  record_builtin_type (RID_MAX, NULL, string_type_node);
#endif

  delta_type_node = ptrdiff_type_node;
  vtable_index_type = ptrdiff_type_node;

  vtt_parm_type = build_pointer_type (const_ptr_type_node);
  void_ftype = build_function_type (void_type_node, void_list_node);
  void_ftype_ptr = build_function_type (void_type_node,
          tree_cons (NULL_TREE,
               ptr_type_node, 
               void_list_node));
  void_ftype_ptr
    = build_exception_variant (void_ftype_ptr, empty_except_spec);

  /* C++ extensions */

  unknown_type_node = make_node (UNKNOWN_TYPE);
  record_unknown_type (unknown_type_node, "unknown type");

  /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
  TREE_TYPE (unknown_type_node) = unknown_type_node;

  /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
     result.  */
  TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
  TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;

  {
    /* Make sure we get a unique function type, so we can give
       its pointer type a name.  (This wins for gdb.) */
    tree vfunc_type = make_node (FUNCTION_TYPE);
    TREE_TYPE (vfunc_type) = integer_type_node;
    TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
    layout_type (vfunc_type);

    vtable_entry_type = build_pointer_type (vfunc_type);
  }
  record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);

  vtbl_type_node
    = build_cplus_array_type (vtable_entry_type, NULL_TREE);
  layout_type (vtbl_type_node);
  vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
  record_builtin_type (RID_MAX, NULL, vtbl_type_node);
  vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
  layout_type (vtbl_ptr_type_node);
  record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);

  push_namespace (get_identifier ("__cxxabiv1"));
  abi_node = current_namespace;
  pop_namespace ();

  global_type_node = make_node (LANG_TYPE);
  record_unknown_type (global_type_node, "global type");

  /* Now, C++.  */
  current_lang_name = lang_name_cplusplus;

  {
    tree bad_alloc_type_node, newtype, deltype;
    tree ptr_ftype_sizetype;

    push_namespace (std_identifier);
    bad_alloc_type_node 
      = xref_tag (class_type, get_identifier ("bad_alloc"), 
      /*attributes=*/NULL_TREE, 1);
    pop_namespace ();
    ptr_ftype_sizetype 
      = build_function_type (ptr_type_node,
           tree_cons (NULL_TREE,
          size_type_node,
          void_list_node));
    newtype = build_exception_variant
      (ptr_ftype_sizetype, add_exception_specifier
       (NULL_TREE, bad_alloc_type_node, -1));
    deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
    push_cp_library_fn (NEW_EXPR, newtype);
    push_cp_library_fn (VEC_NEW_EXPR, newtype);
    global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
    push_cp_library_fn (VEC_DELETE_EXPR, deltype);
  }

  abort_fndecl
    = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);

  /* Perform other language dependent initializations.  */
  init_class_processing ();
  init_search_processing ();
  init_rtti_processing ();

  if (flag_exceptions)
    init_exception_processing ();

  if (! supports_one_only ())
    flag_weak = 0;

  make_fname_decl = cp_make_fname_decl;
  start_fname_decls ();

  /* Show we use EH for cleanups.  */
  using_eh_for_cleanups ();

  /* Maintain consistency.  Perhaps we should just complain if they
     say -fwritable-strings?  */
  if (flag_writable_strings)
    flag_const_strings = 0;
}

/* Generate an initializer for a function naming variable from
   NAME. NAME may be NULL, in which case we generate a special
   ERROR_MARK node which should be replaced later.  */

tree
cp_fname_init (name)
     const char *name;
{
  tree domain = NULL_TREE;
  tree type;
  tree init = NULL_TREE;
  size_t length = 0;

  if (name)
    {
      length = strlen (name);
      domain = build_index_type (size_int (length));
      init = build_string (length + 1, name);
    }
  
  type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
  type = build_cplus_array_type (type, domain);

  if (init)
    TREE_TYPE (init) = type;
  else
    /* We don't know the value until instantiation time. Make
       something which will be digested now, but replaced later.  */
    init = build (ERROR_MARK, type);
  
  return init;
}

/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
   decl, NAME is the initialization string and TYPE_DEP indicates whether
   NAME depended on the type of the function. We make use of that to detect
   __PRETTY_FUNCTION__ inside a template fn. This is being done
   lazily at the point of first use, so we musn't push the decl now.  */

static tree
cp_make_fname_decl (id, type_dep)
     tree id;
     int type_dep;
{
  const char *const name = (type_dep && processing_template_decl
          ? NULL : fname_as_string (type_dep));
  tree init = cp_fname_init (name);
  tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));

  /* As we don't push the decl here, we must set the context.  */
  DECL_CONTEXT (decl) = current_function_decl;
  DECL_PRETTY_FUNCTION_P (decl) = type_dep;
      
  TREE_STATIC (decl) = 1;
  TREE_READONLY (decl) = 1;
  DECL_ARTIFICIAL (decl) = 1;
  DECL_INITIAL (decl) = init;
  
  TREE_USED (decl) = 1;

  cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);

  if (!current_function_decl)
    rest_of_decl_compilation (decl, 0, 1, 0);

  return decl;
}

/* Make a definition for a builtin function named NAME in the current
   namespace, whose data type is TYPE and whose context is CONTEXT.
   TYPE should be a function type with argument types.

   CLASS and CODE tell later passes how to compile calls to this function.
   See tree.h for possible values.

   If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
   the name to be called if we can't opencode the function.
   If ATTRS is nonzero, use that for the function's attribute
   list.  */

static tree
builtin_function_1 (name, type, context, code, class, libname, attrs)
     const char *name;
     tree type;
     tree context;
     int code;
     enum built_in_class class;
     const char *libname;
     tree attrs;
{
  tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
  DECL_BUILT_IN_CLASS (decl) = class;
  DECL_FUNCTION_CODE (decl) = code;
  DECL_CONTEXT (decl) = context;

  pushdecl (decl);

  /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
     we cannot change DECL_ASSEMBLER_NAME until we have installed this
     function in the namespace.  */
  if (libname)
    SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
  make_decl_rtl (decl, NULL);

  /* Warn if a function in the namespace for users
     is used without an occasion to consider it declared.  */
  if (name[0] != '_' || name[1] != '_')
    DECL_ANTICIPATED (decl) = 1;

  /* Possibly apply some default attributes to this built-in function.  */
  if (attrs)
    decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
  else
    decl_attributes (&decl, NULL_TREE, 0);

  return decl;
}

/* Entry point for the benefit of c_common_nodes_and_builtins.

   Make a defintion for a builtin function named NAME and whose data type
   is TYPE.  TYPE should be a function type with argument types.  This
   function places the anticipated declaration in the global namespace
   and additionally in the std namespace if appropriate.

   CLASS and CODE tell later passes how to compile calls to this function.
   See tree.h for possible values.

   If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
   the name to be called if we can't opencode the function.

   If ATTRS is nonzero, use that for the function's attribute
   list.  */

tree
builtin_function (name, type, code, class, libname, attrs)
     const char *name;
     tree type;
     int code;
     enum built_in_class class;
     const char *libname;
     tree attrs;
{
  /* All builtins that don't begin with an '_' should additionally
     go in the 'std' namespace.  */
  if (name[0] != '_')
    {
      push_namespace (std_identifier);
      builtin_function_1 (name, type, std_node, code, class, libname, attrs);
      pop_namespace ();
    }

  return builtin_function_1 (name, type, NULL_TREE, code,
           class, libname, attrs);
}

/* Generate a FUNCTION_DECL with the typical flags for a runtime library
   function.  Not called directly.  */

static tree
build_library_fn_1 (name, operator_code, type)
     tree name;
     enum tree_code operator_code;
     tree type;
{
  tree fn = build_lang_decl (FUNCTION_DECL, name, type);
  DECL_EXTERNAL (fn) = 1;
  TREE_PUBLIC (fn) = 1;
  DECL_ARTIFICIAL (fn) = 1;
  TREE_NOTHROW (fn) = 1;
  SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
  SET_DECL_LANGUAGE (fn, lang_c);
  return fn;
}

/* Returns the _DECL for a library function with C linkage.
   We assume that such functions never throw; if this is incorrect,
   callers should unset TREE_NOTHROW.  */

tree
build_library_fn (name, type)
     tree name;
     tree type;
{
  return build_library_fn_1 (name, ERROR_MARK, type);
}

/* Returns the _DECL for a library function with C++ linkage.  */

static tree
build_cp_library_fn (name, operator_code, type)
     tree name;
     enum tree_code operator_code;
     tree type;
{
  tree fn = build_library_fn_1 (name, operator_code, type);
  TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
  DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
  SET_DECL_LANGUAGE (fn, lang_cplusplus);
  set_mangled_name_for_decl (fn);
  return fn;
}

/* Like build_library_fn, but takes a C string instead of an
   IDENTIFIER_NODE.  */

tree
build_library_fn_ptr (name, type)
     const char *name;
     tree type;
{
  return build_library_fn (get_identifier (name), type);
}

/* Like build_cp_library_fn, but takes a C string instead of an
   IDENTIFIER_NODE.  */

tree
build_cp_library_fn_ptr (name, type)
     const char *name;
     tree type;
{
  return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
}

/* Like build_library_fn, but also pushes the function so that we will
   be able to find it via IDENTIFIER_GLOBAL_VALUE.  */

tree
push_library_fn (name, type)
     tree name, type;
{
  tree fn = build_library_fn (name, type);
  pushdecl_top_level (fn);
  return fn;
}

/* Like build_cp_library_fn, but also pushes the function so that it
   will be found by normal lookup.  */

static tree
push_cp_library_fn (operator_code, type)
     enum tree_code operator_code;
     tree type;
{
  tree fn = build_cp_library_fn (ansi_opname (operator_code),
         operator_code,
         type);
  pushdecl (fn);
  return fn;
}

/* Like push_library_fn, but takes a TREE_LIST of parm types rather than
   a FUNCTION_TYPE.  */

tree
push_void_library_fn (name, parmtypes)
     tree name, parmtypes;
{
  tree type = build_function_type (void_type_node, parmtypes);
  return push_library_fn (name, type);
}

/* Like push_library_fn, but also note that this function throws
   and does not return.  Used for __throw_foo and the like.  */

tree
push_throw_library_fn (name, type)
     tree name, type;
{
  tree fn = push_library_fn (name, type);
  TREE_THIS_VOLATILE (fn) = 1;
  TREE_NOTHROW (fn) = 0;
  return fn;
}

/* Apply default attributes to a function, if a system function with default
   attributes.  */

void
cxx_insert_default_attributes (decl)
     tree decl;
{
  if (!DECL_EXTERN_C_FUNCTION_P (decl))
    return;
  if (!TREE_PUBLIC (decl))
    return;
  c_common_insert_default_attributes (decl);
}

/* When we call finish_struct for an anonymous union, we create
   default copy constructors and such.  But, an anonymous union
   shouldn't have such things; this function undoes the damage to the
   anonymous union type T.

   (The reason that we create the synthesized methods is that we don't
   distinguish `union { int i; }' from `typedef union { int i; } U'.
   The first is an anonymous union; the second is just an ordinary
   union type.)  */

void
fixup_anonymous_aggr (t)
     tree t;
{
  tree *q;

  /* Wipe out memory of synthesized methods */
  TYPE_HAS_CONSTRUCTOR (t) = 0;
  TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
  TYPE_HAS_INIT_REF (t) = 0;
  TYPE_HAS_CONST_INIT_REF (t) = 0;
  TYPE_HAS_ASSIGN_REF (t) = 0;
  TYPE_HAS_CONST_ASSIGN_REF (t) = 0;

  /* Splice the implicitly generated functions out of the TYPE_METHODS
     list.  */
  q = &TYPE_METHODS (t);
  while (*q)
    {
      if (DECL_ARTIFICIAL (*q))
  *q = TREE_CHAIN (*q);
      else
  q = &TREE_CHAIN (*q);
    }

  /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
  if (TYPE_METHODS (t))
    cp_error_at ("an anonymous union cannot have function members", t);

  /* Anonymous aggregates cannot have fields with ctors, dtors or complex
     assignment operators (because they cannot have these methods themselves).
     For anonymous unions this is already checked because they are not allowed
     in any union, otherwise we have to check it.  */
  if (TREE_CODE (t) != UNION_TYPE)
    {
      tree field, type;

      for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
  if (TREE_CODE (field) == FIELD_DECL)
    {
      type = TREE_TYPE (field);
      if (CLASS_TYPE_P (type))
        {
          if (TYPE_NEEDS_CONSTRUCTING (type))
      cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
             field);
    if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
      cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
             field);
    if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
      cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
             field);
        }
    }
    }
}

/* Make sure that a declaration with no declarator is well-formed, i.e.
   just defines a tagged type or anonymous union.

   Returns the type defined, if any.  */

tree
check_tag_decl (declspecs)
     tree declspecs;
{
  int found_type = 0;
  int saw_friend = 0;
  int saw_typedef = 0;
  tree ob_modifier = NULL_TREE;
  register tree link;
  register tree t = NULL_TREE;

  for (link = declspecs; link; link = TREE_CHAIN (link))
    {
      register tree value = TREE_VALUE (link);

      if (TYPE_P (value)
    || TREE_CODE (value) == TYPE_DECL
    || (TREE_CODE (value) == IDENTIFIER_NODE
        && IDENTIFIER_GLOBAL_VALUE (value)
        && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
  {
    ++found_type;

    if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
      {
        if (! in_system_header)
    pedwarn ("redeclaration of C++ built-in type `%T'", value);
        return NULL_TREE;
      }

    if (TYPE_P (value)
        && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
      || TREE_CODE (value) == ENUMERAL_TYPE))
      {
        my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
        t = value;
      }
  }
      else if (value == ridpointers[(int) RID_TYPEDEF])
        saw_typedef = 1;
      else if (value == ridpointers[(int) RID_FRIEND])
  {
    if (current_class_type == NULL_TREE
        || current_scope () != current_class_type)
      ob_modifier = value;
    else
      saw_friend = 1;
  }
      else if (value == ridpointers[(int) RID_STATIC]
         || value == ridpointers[(int) RID_EXTERN]
         || value == ridpointers[(int) RID_AUTO]
         || value == ridpointers[(int) RID_REGISTER]
         || value == ridpointers[(int) RID_INLINE]
         || value == ridpointers[(int) RID_VIRTUAL]
         || value == ridpointers[(int) RID_CONST]
         || value == ridpointers[(int) RID_VOLATILE]
         || value == ridpointers[(int) RID_EXPLICIT]
         || value == ridpointers[(int) RID_THREAD])
  ob_modifier = value;
    }

  if (found_type > 1)
    error ("multiple types in one declaration");

  if (t == NULL_TREE && ! saw_friend)
    pedwarn ("declaration does not declare anything");

  /* Check for an