Release FreeBSD 1.1upstream/1.1.0_cvsrelease/1.1.0_cvs

This commit was manufactured to restore the state of the 1.1-RELEASE image.
Releases prior to 5.3-RELEASE are omitting the secure/ and crypto/ subdirs.

31 files changed, 0 insertions, 65347 deletions

diff --git a/gnu/gcc2/cc1plus/Makefile b/gnu/gcc2/cc1plus/Makefile
deleted file mode 100644
index 2d7210fbb832..000000000000
--- a/gnu/gcc2/cc1plus/Makefile
+++ /dev/null
@@ -1,24 +0,0 @@
-PROG=		gcc1plus
-BINDIR=		/usr/libexec
-SRCS=		cp-parse.c cp-decl.c cp-decl2.c cp-typeck.c cp-type2.c \
-		cp-tree.c cp-ptree.c cp-cvt.c cp-search.c cp-lex.c \
-		cp-gc.c cp-call.c cp-class.c cp-init.c cp-method.c \
-		cp-except.c cp-expr.c cp-pt.c cp-edsel.c cp-xref.c \
-		cp-spew.c
-
-CFLAGS+=	-I. -I$(.CURDIR) -I$(.CURDIR)/../lib
-NOMAN=		noman
-YFLAGS=
-
-.if exists(${.CURDIR}/../lib/obj)
-LDADD=	-L${.CURDIR}/../lib/obj -lgcc2
-DPADD=	${.CURDIR}../lib/obj/libgcc2.a
-.else
-LDADD=	-L${.CURDIR}/../lib/ -lgcc2
-DPADD=	${.CURDIR}../lib/libgcc2.a
-.endif
-
-LDADD+=	-lgnumalloc
-DPADD+=	${LIBGNUMALLOC}
-
-.include <bsd.prog.mk>
diff --git a/gnu/gcc2/cc1plus/cp-call.c b/gnu/gcc2/cc1plus/cp-call.c
deleted file mode 100644
index b0650cad5661..000000000000
--- a/gnu/gcc2/cc1plus/cp-call.c
+++ /dev/null
@@ -1,2823 +0,0 @@
-/* Functions related to invoking methods and overloaded functions.
-   Copyright (C) 1987, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* High-level class interface. */
-
-#include "config.h"
-#include "tree.h"
-#include <stdio.h>
-#include "cp-tree.h"
-#include "flags.h"
-
-#include "obstack.h"
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-extern void sorry ();
-
-extern int inhibit_warnings;
-extern int flag_assume_nonnull_objects;
-extern tree ctor_label, dtor_label;
-
-/* From cp-typeck.c:  */
-extern tree unary_complex_lvalue ();
-
-/* Compute the ease with which a conversion can be performed
-   between an expected and the given type.  */
-static int convert_harshness ();
-
-#define EVIL_HARSHNESS(ARG) ((ARG) & 1)
-#define ELLIPSIS_HARSHNESS(ARG) ((ARG) & 2)
-#define USER_HARSHNESS(ARG) ((ARG) & 4)
-#define CONTRAVARIANT_HARSHNESS(ARG) ((ARG) & 8)
-#define BASE_DERIVED_HARSHNESS(ARG) ((ARG) & 16)
-#define INT_TO_BD_HARSHNESS(ARG) (((ARG) << 5) | 16)
-#define INT_FROM_BD_HARSHNESS(ARG) ((ARG) >> 5)
-#define INT_TO_EASY_HARSHNESS(ARG) ((ARG) << 5)
-#define INT_FROM_EASY_HARSHNESS(ARG) ((ARG) >> 5)
-#define ONLY_EASY_HARSHNESS(ARG) (((ARG) & 31) == 0)
-#define CONST_HARSHNESS(ARG) ((ARG) & 2048)
-
-/* Ordering function for overload resolution.  */
-int
-rank_for_overload (x, y)
-     struct candidate *x, *y;
-{
-  if (y->evil - x->evil)
-    return y->evil - x->evil;
-  if (CONST_HARSHNESS (y->harshness[0]) ^ CONST_HARSHNESS (x->harshness[0]))
-    return y->harshness[0] - x->harshness[0];
-  if (y->ellipsis - x->ellipsis)
-    return y->ellipsis - x->ellipsis;
-  if (y->user - x->user)
-    return y->user - x->user;
-  if (y->b_or_d - x->b_or_d)
-    return y->b_or_d - x->b_or_d;
-  return y->easy - x->easy;
-}
-
-/* TYPE is the type we wish to convert to.  PARM is the parameter
-   we have to work with.  We use a somewhat arbitrary cost function
-   to measure this conversion.  */
-static int
-convert_harshness (type, parmtype, parm)
-     register tree type, parmtype;
-     tree parm;
-{
-  register enum tree_code codel = TREE_CODE (type);
-  register enum tree_code coder = TREE_CODE (parmtype);
-
-#ifdef GATHER_STATISTICS
-  n_convert_harshness++;
-#endif
-
-  if (TYPE_MAIN_VARIANT (parmtype) == TYPE_MAIN_VARIANT (type))
-    return 0;
-
-  if (coder == ERROR_MARK)
-    return 1;
-
-  if (codel == POINTER_TYPE
-      && (coder == METHOD_TYPE || coder == FUNCTION_TYPE))
-    {
-      tree p1, p2;
-      int harshness, new_harshness;
-
-      /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be.  */
-      type = TREE_TYPE (type);
-
-      if (coder != TREE_CODE (type))
-	return 1;
-
-      harshness = 0;
-
-      /* We allow the default conversion between function type
-	 and pointer-to-function type for free.  */
-      if (type == parmtype)
-	return 0;
-
-      /* Compare return types.  */
-      p1 = TREE_TYPE (type);
-      p2 = TREE_TYPE (parmtype);
-      new_harshness = convert_harshness (p1, p2, NULL_TREE);
-      if (new_harshness & 1)
-	return 1;
-
-      if (BASE_DERIVED_HARSHNESS (new_harshness))
-	{
-	  tree binfo;
-
-	  /* This only works for pointers.  */
-	  if (TREE_CODE (p1) != POINTER_TYPE
-	      && TREE_CODE (p1) != REFERENCE_TYPE)
-	    return 1;
-
-	  p1 = TREE_TYPE (p1);
-	  p2 = TREE_TYPE (p2);
-	  if (CONTRAVARIANT_HARSHNESS (new_harshness))
-	    binfo = get_binfo (p2, p1, 0);
-	  else
-	    binfo = get_binfo (p1, p2, 0);
-
-	  if (! BINFO_OFFSET_ZEROP (binfo))
-	    {
-	      static int explained = 0;
-	      if (CONTRAVARIANT_HARSHNESS (new_harshness))
-		message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p2, p1);
-	      else
-		message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p1, p2);
-
-	      if (! explained++)
-		sorry ("(because pointer values change during conversion)");
-	      return 1;
-	    }
-	}
-
-      harshness |= new_harshness;
-
-      p1 = TYPE_ARG_TYPES (type);
-      p2 = TYPE_ARG_TYPES (parmtype);
-      while (p1 && TREE_VALUE (p1) != void_type_node
-	     && p2 && TREE_VALUE (p2) != void_type_node)
-	{
-	  new_harshness = convert_harshness (TREE_VALUE (p1), TREE_VALUE (p2), NULL_TREE);
-	  if (EVIL_HARSHNESS (new_harshness))
-	    return 1;
-
-	  if (BASE_DERIVED_HARSHNESS (new_harshness))
-	    {
-	      /* This only works for pointers and references. */
-	      if (TREE_CODE (TREE_VALUE (p1)) != POINTER_TYPE
-		  && TREE_CODE (TREE_VALUE (p1)) != REFERENCE_TYPE)
-		return 1;
-	      new_harshness ^= CONTRAVARIANT_HARSHNESS (new_harshness);
-	      harshness |= new_harshness;
-	    }
-	  /* This trick allows use to accumulate easy type
-	     conversions without messing up the bits that encode
-	     info about more involved things.  */
-	  else if (ONLY_EASY_HARSHNESS (new_harshness))
-	    harshness += new_harshness;
-	  else
-	    harshness |= new_harshness;
-	  p1 = TREE_CHAIN (p1);
-	  p2 = TREE_CHAIN (p2);
-	}
-      if (p1 == p2)
-	return harshness;
-      if (p2)
-	return p1 ? 1 : (harshness | ELLIPSIS_HARSHNESS (-1));
-      if (p1)
-	return harshness | (TREE_PURPOSE (p1) == NULL_TREE);
-    }
-  else if (codel == POINTER_TYPE && coder == OFFSET_TYPE)
-    {
-      /* XXX: Note this is set a few times, but it's never actually
-	 used! (bpk) */
-      int harshness;
-
-      /* Get to the OFFSET_TYPE that this might be.  */
-      type = TREE_TYPE (type);
-
-      if (coder != TREE_CODE (type))
-	return 1;
-
-      harshness = 0;
-
-      if (TYPE_OFFSET_BASETYPE (type) == TYPE_OFFSET_BASETYPE (parmtype))
-	harshness = 0;
-      else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (type),
-			       TYPE_OFFSET_BASETYPE (parmtype)))
-	harshness = INT_TO_BD_HARSHNESS (1);
-      else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (parmtype),
-			       TYPE_OFFSET_BASETYPE (type)))
-	harshness = CONTRAVARIANT_HARSHNESS (-1);
-      else
-	return 1;
-      /* Now test the OFFSET_TYPE's target compatibility.  */
-      type = TREE_TYPE (type);
-      parmtype = TREE_TYPE (parmtype);
-    }
-
-  if (coder == UNKNOWN_TYPE)
-    {
-      if (codel == FUNCTION_TYPE
-	  || codel == METHOD_TYPE
-	  || (codel == POINTER_TYPE
-	      && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
-		  || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)))
-	return 0;
-      return 1;
-    }
-
-  if (coder == VOID_TYPE)
-    return 1;
-
-  if (codel == ENUMERAL_TYPE || codel == INTEGER_TYPE)
-    {
-      /* Control equivalence of ints an enums.  */
-
-      if (codel == ENUMERAL_TYPE
-	  && flag_int_enum_equivalence == 0)
-	{
-	  /* Enums can be converted to ints, but not vice-versa.  */
-	  if (coder != ENUMERAL_TYPE
-	      || TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (parmtype))
-	    return 1;
-	}
-
-      /* else enums and ints (almost) freely interconvert.  */
-
-      if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
-	{
-	  int easy = TREE_UNSIGNED (type) ^ TREE_UNSIGNED (parmtype);
-	  if (codel != coder)
-	    easy += 1;
-	  if (TYPE_MODE (type) != TYPE_MODE (parmtype))
-	    easy += 2;
-	  return INT_TO_EASY_HARSHNESS (easy);
-	}
-      else if (coder == REAL_TYPE)
-	return INT_TO_EASY_HARSHNESS (4);
-    }
-
-  if (codel == REAL_TYPE)
-    if (coder == REAL_TYPE)
-      /* Shun converting between float and double if a choice exists.  */
-      {
-	if (TYPE_MODE (type) != TYPE_MODE (parmtype))
-	  return INT_TO_EASY_HARSHNESS (2);
-	return 0;
-      }
-    else if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
-      return INT_TO_EASY_HARSHNESS (4);
-
-  /* convert arrays which have not previously been converted.  */
-  if (codel == ARRAY_TYPE)
-    codel = POINTER_TYPE;
-  if (coder == ARRAY_TYPE)
-    coder = POINTER_TYPE;
-
-  /* Conversions among pointers */
-  if (codel == POINTER_TYPE && coder == POINTER_TYPE)
-    {
-      register tree ttl = TYPE_MAIN_VARIANT (TREE_TYPE (type));
-      register tree ttr = TYPE_MAIN_VARIANT (TREE_TYPE (parmtype));
-      int penalty = 4 * (ttl != ttr);
-      /* Anything converts to void *.  void * converts to anything.
-	 Since these may be `const void *' (etc.) use VOID_TYPE
-	 instead of void_type_node.
-	 Otherwise, the targets must be the same,
-	 except that we do allow (at some cost) conversion
-	 between signed and unsinged pointer types.  */
-
-      if ((TREE_CODE (ttl) == METHOD_TYPE
-	   || TREE_CODE (ttl) == FUNCTION_TYPE)
-	  && TREE_CODE (ttl) == TREE_CODE (ttr))
-	{
-	  if (comptypes (ttl, ttr, -1))
-	    return INT_TO_EASY_HARSHNESS (penalty);
-	  return 1;
-	}
-
-      if (!(TREE_CODE (ttl) == VOID_TYPE
-	    || TREE_CODE (ttr) == VOID_TYPE
-	    || (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (ttr)
-		&& (ttl = unsigned_type (ttl),
-		    ttr = unsigned_type (ttr),
-		    penalty = 10, 0))
-	    || (comp_target_types (ttl, ttr, 0))))
-	return 1;
-
-      if (penalty == 10)
-	return INT_TO_EASY_HARSHNESS (10);
-      if (ttr == ttl)
-	return INT_TO_BD_HARSHNESS (0);
-
-      if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
-	{
-	  int b_or_d = get_base_distance (ttl, ttr, 0, 0);
-	  if (b_or_d < 0)
-	    {
-	      b_or_d = get_base_distance (ttr, ttl, 0, 0);
-	      if (b_or_d < 0)
-		return 1;
-	      return CONTRAVARIANT_HARSHNESS (-1);
-	    }
-	  return INT_TO_BD_HARSHNESS (b_or_d);
-	}
-      /* If converting from a `class*' to a `void*', make it
-	 less favorable than any inheritance relationship.  */
-      if (TREE_CODE (ttl) == VOID_TYPE && IS_AGGR_TYPE (ttr))
-	return INT_TO_BD_HARSHNESS (CLASSTYPE_MAX_DEPTH (ttr)+1);
-      return INT_TO_EASY_HARSHNESS (penalty);
-    }
-
-  if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
-    {
-      /* This is not a bad match, but don't let it beat
-	 integer-enum combinations.  */
-      if (parm && integer_zerop (parm))
-	return INT_TO_EASY_HARSHNESS (4);
-    }
-
-  /* C++: one of the types must be a reference type.  */
-  {
-    tree ttl, ttr;
-    register tree intype = TYPE_MAIN_VARIANT (parmtype);
-    register enum tree_code form = TREE_CODE (intype);
-    int penalty;
-
-    if (codel == REFERENCE_TYPE || coder == REFERENCE_TYPE)
-      {
-	ttl = TYPE_MAIN_VARIANT (type);
-
-	if (codel == REFERENCE_TYPE)
-	  {
-	    ttl = TREE_TYPE (ttl);
-
-	    /* When passing a non-const argument into a const reference,
-	       dig it a little, so a non-const reference is preferred over
-	       this one. (mrs) */
-	    if (parm && TREE_READONLY (ttl) && ! TREE_READONLY (parm))
-	      penalty = 2;
-	    else
-	      penalty = 0;
-
-	    ttl = TYPE_MAIN_VARIANT (ttl);
-
-	    if (form == OFFSET_TYPE)
-	      {
-		intype = TREE_TYPE (intype);
-		form = TREE_CODE (intype);
-	      }
-
-	    if (form == REFERENCE_TYPE)
-	      {
-		intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
-
-		if (ttl == intype)
-		  return 0;
-		penalty = 2;
-	      }
-	    else
-	      {
-		/* Can reference be built up?  */
-		if (ttl == intype && penalty == 0) {
-		  /* Because the READONLY bits and VOLATILE bits are not
-		     always in the type, this extra check is necessary.  The
-		     problem should be fixed someplace else, and this extra
-		     code removed.
-
-		     Also, if type if a reference, the readonly bits could
-		     either be in the outer type (with reference) or on the
-		     inner type (the thing being referenced).  (mrs)  */
-		  if (parm
-		      && ((TREE_READONLY (parm)
-			  && ! (TYPE_READONLY (type)
-				|| (TREE_CODE (type) == REFERENCE_TYPE
-				    && TYPE_READONLY (TREE_TYPE (type)))))
-			  || (TREE_SIDE_EFFECTS (parm)
-			      && ! (TYPE_VOLATILE (type)
-				    || (TREE_CODE (type) == REFERENCE_TYPE
-					&& TYPE_VOLATILE (TREE_TYPE (type)))))))
-		     
-		    penalty = 2;
-		  else
-		    return 0;
-		}
-		else
-		  penalty = 2;
-	      }
-	  }
-	else if (form == REFERENCE_TYPE)
-	  {
-	    if (parm)
-	      {
-		tree tmp = convert_from_reference (parm);
-		intype = TYPE_MAIN_VARIANT (TREE_TYPE (tmp));
-	      }
-	    else
-	      {
-		intype = parmtype;
-		do
-		  {
-		    intype = TREE_TYPE (intype);
-		  }
-		while (TREE_CODE (intype) == REFERENCE_TYPE);
-		intype = TYPE_MAIN_VARIANT (intype);
-	      }
-
-	    if (ttl == intype)
-	      return 0;
-	    else
-	      penalty = 2;
-	  }
-
-	if (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (intype))
-	  {
-	    ttl = unsigned_type (ttl);
-	    intype = unsigned_type (intype);
-	    penalty += 2;
-	  }
-
-	ttr = intype;
-
-	/* If the initializer is not an lvalue, then it does not
-	   matter if we make life easier for the programmer
-	   by creating a temporary variable with which to
-	   hold the result.  */
-	if (parm && (coder == INTEGER_TYPE
-		     || coder == ENUMERAL_TYPE
-		     || coder == REAL_TYPE)
-	    && ! lvalue_p (parm))
-	  return (convert_harshness (ttl, ttr, NULL_TREE)
-		  | INT_TO_EASY_HARSHNESS (penalty));
-
-	if (ttl == ttr)
-	  {
-	    if (penalty)
-	      return INT_TO_EASY_HARSHNESS (penalty);
-	    return INT_TO_BD_HARSHNESS (0);
-	  }
-
-	/* Pointers to voids always convert for pointers.  But
-	   make them less natural than more specific matches.  */
-	if (TREE_CODE (ttl) == POINTER_TYPE && TREE_CODE (ttr) == POINTER_TYPE)
-	  if (TREE_TYPE (ttl) == void_type_node
-	      || TREE_TYPE (ttr) == void_type_node)
-	    return INT_TO_EASY_HARSHNESS (penalty+1);
-
-	if (parm && codel != REFERENCE_TYPE)
-	  return (convert_harshness (ttl, ttr, NULL_TREE)
-		  | INT_TO_EASY_HARSHNESS (penalty));
-
-	/* Here it does matter.  If this conversion is from
-	   derived to base, allow it.  Otherwise, types must
-	   be compatible in the strong sense.  */
-	if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
-	  {
-	    int b_or_d = get_base_distance (ttl, ttr, 0, 0);
-	    if (b_or_d < 0)
-	      {
-		b_or_d = get_base_distance (ttr, ttl, 0, 0);
-		if (b_or_d < 0)
-		  return 1;
-		return CONTRAVARIANT_HARSHNESS (-1);
-	      }
-	    /* Say that this conversion is relatively painless.
-	       If it turns out that there is a user-defined X(X&)
-	       constructor, then that will be invoked, but that's
-	       preferable to dealing with other user-defined conversions
-	       that may produce surprising results.  */
-	    return INT_TO_BD_HARSHNESS (b_or_d);
-	  }
-
-	if (comp_target_types (ttl, intype, 1))
-	  return INT_TO_EASY_HARSHNESS (penalty);
-      }
-  }
-  if (codel == RECORD_TYPE && coder == RECORD_TYPE)
-    {
-      int b_or_d = get_base_distance (type, parmtype, 0, 0);
-      if (b_or_d < 0)
-	{
-	  b_or_d = get_base_distance (parmtype, type, 0, 0);
-	  if (b_or_d < 0)
-	    return 1;
-	  return CONTRAVARIANT_HARSHNESS (-1);
-	}
-      return INT_TO_BD_HARSHNESS (b_or_d);
-    }
-  return 1;
-}
-
-/* Algorithm: Start out with no strikes against.  For each argument
-   which requires a (subjective) hard conversion (such as between
-   floating point and integer), issue a strike.  If there are the same
-   number of formal and actual parameters in the list, there will be at
-   least on strike, otherwise an exact match would have been found.  If
-   there are not the same number of arguments in the type lists, we are
-   not dead yet: a `...' means that we can have more parms then were
-   declared, and if we wind up in the default argument section of the
-   list those can be used as well.  If an exact match could be found for
-   one of those cases, return it immediately.  Otherwise, rank the fields
-   so that fields with fewer strikes are tried first.
-
-   Conversions between builtin and user-defined types are allowed, but
-   no function involving such a conversion is preferred to one which
-   does not require such a conversion.  Furthermore, such conversions
-   must be unique.  */
-
-void
-compute_conversion_costs (function, tta_in, cp, arglen)
-     tree function;
-     tree tta_in;
-     struct candidate *cp;
-     int arglen;
-{
-  tree ttf_in = TYPE_ARG_TYPES (TREE_TYPE (function));
-  tree ttf = ttf_in;
-  tree tta = tta_in;
-
-  /* Start out with no strikes against.  */
-  int evil_strikes = 0;
-  int ellipsis_strikes = 0;
-  int user_strikes = 0;
-  int b_or_d_strikes = 0;
-  int easy_strikes = 0;
-
-  int strike_index = 0, win, lose;
-
-#ifdef GATHER_STATISTICS
-  n_compute_conversion_costs++;
-#endif
-
-  cp->function = function;
-  cp->arg = tta ? TREE_VALUE (tta) : NULL_TREE;
-  cp->u.bad_arg = 0;		/* optimistic!  */
-
-  bzero (cp->harshness, (arglen+1) * sizeof (short));
-
-  while (ttf && tta)
-    {
-      int harshness;
-
-      if (ttf == void_list_node)
-	break;
-
-      if (type_unknown_p (TREE_VALUE (tta)))
-	{	  
-	  /* Must perform some instantiation here.  */
-	  tree rhs = TREE_VALUE (tta);
-	  tree lhstype = TREE_VALUE (ttf);
-
-	  /* Keep quiet about possible contravariance violations.  */
-	  int old_inhibit_warnings = inhibit_warnings;
-	  inhibit_warnings = 1;
-
-	  /* @@ This is to undo what `grokdeclarator' does to
-	     parameter types.  It really should go through
-	     something more general.  */
-
-	  TREE_TYPE (tta) = unknown_type_node;
-	  rhs = instantiate_type (lhstype, rhs, 0);
-	  inhibit_warnings = old_inhibit_warnings;
-
-	  if (TREE_CODE (rhs) == ERROR_MARK)
-	    harshness = 1;
-	  else
-	    {
-	      harshness = convert_harshness (lhstype, TREE_TYPE (rhs), rhs);
-	      /* harshness |= 2; */
-	    }
-	}
-      else
-	harshness = convert_harshness (TREE_VALUE (ttf), TREE_TYPE (TREE_VALUE (tta)), TREE_VALUE (tta));
-
-      cp->harshness[strike_index] = harshness;
-      if (EVIL_HARSHNESS (harshness)
-	  || CONTRAVARIANT_HARSHNESS (harshness))
-	{
-	  cp->u.bad_arg = strike_index;
-	  evil_strikes = 1;
-	}
-     else if (ELLIPSIS_HARSHNESS (harshness))
-	{
-	  ellipsis_strikes += 1;
-	}
-#if 0
-      /* This is never set by `convert_harshness'.  */
-      else if (USER_HARSHNESS (harshness))
-	{
-	  user_strikes += 1;
-	}
-#endif
-      else if (BASE_DERIVED_HARSHNESS (harshness))
-	{
-	  b_or_d_strikes += INT_FROM_BD_HARSHNESS (harshness);
-	}
-      else
-	easy_strikes += INT_FROM_EASY_HARSHNESS (harshness);
-      ttf = TREE_CHAIN (ttf);
-      tta = TREE_CHAIN (tta);
-      strike_index += 1;
-    }
-
-  if (tta)
-    {
-      /* ran out of formals, and parmlist is fixed size.  */
-      if (ttf /* == void_type_node */)
-	{
-	  cp->evil = 1;
-	  cp->u.bad_arg = -1;
-	  return;
-	}
-    }
-  else if (ttf && ttf != void_list_node)
-    {
-      /* ran out of actuals, and no defaults.  */
-      if (TREE_PURPOSE (ttf) == NULL_TREE)
-	{
-	  cp->evil = 1;
-	  cp->u.bad_arg = -2;
-	  return;
-	}
-      /* Store index of first default.  */
-      cp->harshness[arglen] = strike_index+1;
-    }
-  else cp->harshness[arglen] = 0;
-
-  /* Argument list lengths work out, so don't need to check them again.  */
-  if (evil_strikes)
-    {
-      /* We do not check for derived->base conversions here, since in
-	 no case would they give evil strike counts, unless such conversions
-	 are somehow ambiguous.  */
-
-      /* See if any user-defined conversions apply.
-         But make sure that we do not loop.  */
-      static int dont_convert_types = 0;
-
-      if (dont_convert_types)
-	{
-	  cp->evil = 1;
-	  return;
-	}
-
-      win = 0;			/* Only get one chance to win.  */
-      ttf = TYPE_ARG_TYPES (TREE_TYPE (function));
-      tta = tta_in;
-      strike_index = 0;
-      evil_strikes = 0;
-
-      while (ttf && tta)
-	{
-	  if (ttf == void_list_node)
-	    break;
-
-	  lose = cp->harshness[strike_index];
-	  if (EVIL_HARSHNESS (lose)
-	      || CONTRAVARIANT_HARSHNESS (lose))
-	    {
-	      tree actual_type = TREE_TYPE (TREE_VALUE (tta));
-	      tree formal_type = TREE_VALUE (ttf);
-
-	      dont_convert_types = 1;
-
-	      if (TREE_CODE (formal_type) == REFERENCE_TYPE)
-		formal_type = TREE_TYPE (formal_type);
-	      if (TREE_CODE (actual_type) == REFERENCE_TYPE)
-		actual_type = TREE_TYPE (actual_type);
-
-	      if (formal_type != error_mark_node
-		  && actual_type != error_mark_node)
-		{
-		  formal_type = TYPE_MAIN_VARIANT (formal_type);
-		  actual_type = TYPE_MAIN_VARIANT (actual_type);
-
-		  if (TYPE_HAS_CONSTRUCTOR (formal_type))
-		    {
-		      /* If it has a constructor for this type, try to use it.  */
-		      if (convert_to_aggr (formal_type, TREE_VALUE (tta), 0, 1)
-			  != error_mark_node)
-			{
-			  /* @@ There is no way to save this result yet.
-			     @@ So success is NULL_TREE for now.  */
-			  win++;
-			}
-		    }
-		  if (TYPE_LANG_SPECIFIC (actual_type) && TYPE_HAS_CONVERSION (actual_type))
-		    {
-		      if (TREE_CODE (formal_type) == INTEGER_TYPE
-			  && TYPE_HAS_INT_CONVERSION (actual_type))
-			win++;
-		      else if (TREE_CODE (formal_type) == REAL_TYPE
-			       && TYPE_HAS_REAL_CONVERSION (actual_type))
-			win++;
-		      else
-			{
-			  tree conv = build_type_conversion (CALL_EXPR, TREE_VALUE (ttf), TREE_VALUE (tta), 0);
-			  if (conv)
-			    {
-			      if (conv == error_mark_node)
-				win += 2;
-			      else
-				win++;
-			    }
-			  else if (TREE_CODE (TREE_VALUE (ttf)) == REFERENCE_TYPE)
-			    {
-			      conv = build_type_conversion (CALL_EXPR, formal_type, TREE_VALUE (tta), 0);
-			      if (conv)
-				{
-				  if (conv == error_mark_node)
-				    win += 2;
-				  else
-				    win++;
-				}
-			    }
-			}
-		    }
-		}
-	      dont_convert_types = 0;
-
-	      if (win == 1)
-		{
-		  user_strikes += 1;
-		  cp->harshness[strike_index] = USER_HARSHNESS (-1);
-		  win = 0;
-		}
-	      else
-		{
-		  if (cp->u.bad_arg > strike_index)
-		    cp->u.bad_arg = strike_index;
-
-		  evil_strikes = win ? 2 : 1;
-		  break;
-		}
-	    }
-
-	  ttf = TREE_CHAIN (ttf);
-	  tta = TREE_CHAIN (tta);
-	  strike_index += 1;
-	}
-    }
-
-  /* Const member functions get a small penalty because defaulting
-     to const is less useful than defaulting to non-const. */
-  /* This is bogus, it does not correspond to anything in the ARM.
-     This code will be fixed when this entire section is rewritten
-     to conform to the ARM.  (mrs)  */
-  if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
-    {
-      if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (ttf_in))))
-	{
-	  cp->harshness[0] += INT_TO_EASY_HARSHNESS (1);
-	  ++easy_strikes;
-	}
-      else
-	{
-	  /* Calling a non-const member function from a const member function
-	     is probably invalid, but for now we let it only draw a warning.
-	     We indicate that such a mismatch has occurred by setting the
-	     harshness to a maximum value.  */
-	  if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in))) == POINTER_TYPE
-	      && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in))))))
-	    cp->harshness[0] |= CONST_HARSHNESS (-1);
-	}
-    }
-
-  cp->evil = evil_strikes;
-  cp->ellipsis = ellipsis_strikes;
-  cp->user = user_strikes;
-  cp->b_or_d = b_or_d_strikes;
-  cp->easy = easy_strikes;
-}
-
-/* When one of several possible overloaded functions and/or methods
-   can be called, choose the best candidate for overloading.
-
-   BASETYPE is the context from which we start method resolution
-   or NULL if we are comparing overloaded functions.
-   CANDIDATES is the array of candidates we have to choose from.
-   N_CANDIDATES is the length of CANDIDATES.
-   PARMS is a TREE_LIST of parameters to the function we'll ultimately
-   choose.  It is modified in place when resolving methods.  It is not
-   modified in place when resolving overloaded functions.
-   LEN is the length of the parameter list.  */
-
-static struct candidate *
-ideal_candidate (basetype, candidates, n_candidates, parms, len)
-     tree basetype;
-     struct candidate *candidates;
-     int n_candidates;
-     tree parms;
-     int len;
-{
-  struct candidate *cp = candidates + n_candidates;
-  int index, i;
-  tree ttf;
-
-  qsort (candidates,		/* char *base */
-	 n_candidates,		/* int nel */
-	 sizeof (struct candidate), /* int width */
-	 rank_for_overload);	/* int (*compar)() */
-
-  /* If the best candidate requires user-defined conversions,
-     and its user-defined conversions are a strict subset
-     of all other candidates requiring user-defined conversions,
-     then it is, in fact, the best.  */
-  for (i = -1; cp + i != candidates; i--)
-    if (cp[i].user == 0)
-      break;
-
-  if (i < -1)
-    {
-      tree ttf0;
-
-      /* Check that every other candidate requires those conversions
-	 as a strict subset of their conversions.  */
-      if (cp[i].user == cp[-1].user)
-	goto non_subset;
-
-      /* Look at subset relationship more closely.  */
-      while (i != -1)
-	{
-	  for (ttf = TYPE_ARG_TYPES (TREE_TYPE (cp[i].function)),
-	       ttf0 = TYPE_ARG_TYPES (TREE_TYPE (cp[-1].function)),
-	       index = 0;
-	       index < len;
-	       ttf = TREE_CHAIN (ttf), ttf0 = TREE_CHAIN (ttf0), index++)
-	    if (USER_HARSHNESS (cp[i].harshness[index]))
-	      {
-		/* If our "best" candidate also needs a conversion,
-		   it must be the same one.  */
-		if (USER_HARSHNESS (cp[-1].harshness[index])
-		    && TREE_VALUE (ttf) != TREE_VALUE (ttf0))
-		  goto non_subset;
-	      }
-	  i++;
-	}
-      /* The best was the best.  */
-      return cp - 1;
-    non_subset:
-      /* Use other rules for determining "bestness".  */
-      ;
-    }
-
-  /* If the best two candidates we find require user-defined
-     conversions, we may need to report and error message.  */
-  if (cp[-1].user && cp[-2].user
-      && (cp[-1].b_or_d || cp[-2].b_or_d == 0))
-    {
-      /* If the best two methods found involved user-defined
-	 type conversions, then we must see whether one
-	 of them is exactly what we wanted.  If not, then
-	 we have an ambiguity.  */
-      int best = 0;
-      tree tta = parms;
-      tree f1;
-#if 0
-      /* for LUCID */
-      tree p1;
-#endif
-
-      /* Stash all of our parameters in safe places
-	 so that we can perform type conversions in place.  */
-      while (tta)
-	{
-	  TREE_PURPOSE (tta) = TREE_VALUE (tta);
-	  tta = TREE_CHAIN (tta);
-	}
-
-      i = 0;
-      do
-	{
-	  int exact_conversions = 0;
-
-	  i -= 1;
-	  tta = parms;
-	  if (DECL_STATIC_FUNCTION_P (cp[i].function))
-	    tta = TREE_CHAIN (tta);
-	  /* special note, we don't go through len parameters, because we
-	     may only need len-1 parameters because of a call to a static
-	     member. */
-	  for (ttf = TYPE_ARG_TYPES (TREE_TYPE (cp[i].function)), index = 0;
-	       tta;
-	       tta = TREE_CHAIN (tta), ttf = TREE_CHAIN (ttf), index++)
-	    {
-	      if (USER_HARSHNESS (cp[i].harshness[index]))
-		{
-		  tree this_parm = build_type_conversion (CALL_EXPR, TREE_VALUE (ttf), TREE_PURPOSE (tta), 2);
-		  if (basetype != NULL_TREE)
-		    TREE_VALUE (tta) = this_parm;
-		  if (this_parm)
-		    {
-		      if (TREE_CODE (this_parm) != CONVERT_EXPR
-			  && (TREE_CODE (this_parm) != NOP_EXPR
-			      || comp_target_types (TREE_TYPE (this_parm),
-						    TREE_TYPE (TREE_OPERAND (this_parm, 0)), 1)))
-			exact_conversions += 1;
-		    }
-		  else if (PROMOTES_TO_AGGR_TYPE (TREE_VALUE (ttf), REFERENCE_TYPE))
-		    {
-		      /* To get here we had to have succeeded via
-			 a constructor.  */
-		      TREE_VALUE (tta) = TREE_PURPOSE (tta);
-		      exact_conversions += 1;
-		    }
-		}
-	    }
-	  if (exact_conversions == cp[i].user)
-	    {
-	      if (best == 0)
-		{
-		  best = i;
-		  f1 = cp[best].function;
-#if 0
-		  /* For LUCID */
-		  p1 = TYPE_ARG_TYPES (TREE_TYPE (f1));
-#endif
-		}
-	      else
-		{
-		  /* Don't complain if next best is from base class.  */
-		  tree f2 = cp[i].function;
-
-		  if (TREE_CODE (TREE_TYPE (f1)) == METHOD_TYPE
-		      && TREE_CODE (TREE_TYPE (f2)) == METHOD_TYPE
-		      && BASE_DERIVED_HARSHNESS (cp[i].harshness[0])
-		      && cp[best].harshness[0] < cp[i].harshness[0])
-		    {
-#if 0
-		      tree p2 = TYPE_ARG_TYPES (TREE_TYPE (f2));
-		      /* For LUCID.  */
-		      if (! compparms (TREE_CHAIN (p1), TREE_CHAIN (p2), 1))
-			goto ret0;
-		      else
-#endif
-			continue;
-		    }
-		  else
-		    {
-		      /* Ensure that there's nothing ambiguous about these
-			 two fns.  */
-		      int identical = 1;
-		      for (index = 0; index < len; index++)
-			{
-			  /* Type conversions must be piecewise equivalent.  */
-			  if (USER_HARSHNESS (cp[best].harshness[index])
-			      != USER_HARSHNESS (cp[i].harshness[index]))
-			    goto ret0;
-			  /* If there's anything we like better about the
-			     other function, consider it ambiguous.  */
-			  if (cp[i].harshness[index] < cp[best].harshness[index])
-			    goto ret0;
-			  /* If any single one it diffent, then the whole is
-			     not identical.  */
-			  if (cp[i].harshness[index] != cp[best].harshness[index])
-			    identical = 0;
-			}
-
-		      /* If we can't tell the difference between the two, it
-			 is ambiguous.  */
-		      if (identical)
-			goto ret0;
-
-		      /* If we made it to here, it means we're satisfied that
-			 BEST is still best.  */
-		      continue;
-		    }
-		}
-	    }
-	} while (cp + i != candidates);
-
-      if (best)
-	{
-	  int exact_conversions = cp[best].user;
-	  tta = parms;
-	  if (DECL_STATIC_FUNCTION_P (cp[best].function))
-	    tta = TREE_CHAIN (parms);
-	  for (ttf = TYPE_ARG_TYPES (TREE_TYPE (cp[best].function)), index = 0;
-	       exact_conversions > 0;
-	       tta = TREE_CHAIN (tta), ttf = TREE_CHAIN (ttf), index++)
-	    {
-	      if (USER_HARSHNESS (cp[best].harshness[index]))
-		{
-		  /* We must now fill in the slot we left behind.
-		     @@ This could be optimized to use the value previously
-		     @@ computed by build_type_conversion in some cases.  */
-		  if (basetype != NULL_TREE)
-		    TREE_VALUE (tta) = convert (TREE_VALUE (ttf), TREE_PURPOSE (tta));
-		  exact_conversions -= 1;
-		}
-	      else TREE_VALUE (tta) = TREE_PURPOSE (tta);
-	    }
-	  return cp + best;
-	}
-      goto ret0;
-    }
-  /* If the best two candidates we find both use default parameters,
-     we may need to report and error.  Don't need to worry if next-best
-     candidate is forced to use user-defined conversion when best is not.  */
-  if (cp[-2].user == 0
-      && cp[-1].harshness[len] != 0 && cp[-2].harshness[len] != 0)
-    {
-      tree tt1 = TYPE_ARG_TYPES (TREE_TYPE (cp[-1].function));
-      tree tt2 = TYPE_ARG_TYPES (TREE_TYPE (cp[-2].function));
-      unsigned i = cp[-1].harshness[len];
-
-      if (cp[-2].harshness[len] < i)
-	i = cp[-2].harshness[len];
-      while (--i > 0)
-	{
-	  if (TYPE_MAIN_VARIANT (TREE_VALUE (tt1))
-	      != TYPE_MAIN_VARIANT (TREE_VALUE (tt2)))
-	    /* These lists are not identical, so we can choose our best candidate.  */
-	    return cp - 1;
-	  tt1 = TREE_CHAIN (tt1);
-	  tt2 = TREE_CHAIN (tt2);
-	}
-      /* To get here, both lists had the same parameters up to the defaults
-	 which were used.  This is an ambiguous request.  */
-      goto ret0;
-    }
-
-  /* Otherwise, return our best candidate.  Note that if we get candidates
-     from independent base classes, we have an ambiguity, even if one
-     argument list look a little better than another one.  */
-  if (cp[-1].b_or_d && basetype && TYPE_USES_MULTIPLE_INHERITANCE (basetype))
-    {
-      int i = n_candidates - 1, best = i;
-      tree base1 = NULL_TREE;
-
-      if (TREE_CODE (TREE_TYPE (candidates[i].function)) == FUNCTION_TYPE)
-	return cp - 1;
-
-      for (; i >= 0 && candidates[i].user == 0 && candidates[i].evil == 0; i--)
-	{
-	  if (TREE_CODE (TREE_TYPE (candidates[i].function)) == METHOD_TYPE)
-	    {
-	      tree newbase = DECL_CLASS_CONTEXT (candidates[i].function);
-
-	      if (base1 != NULL_TREE)
-		{
-		  /* newbase could be a base or a parent of base1 */
-		  if (newbase != base1 && ! UNIQUELY_DERIVED_FROM_P (newbase, base1)
-		      && ! UNIQUELY_DERIVED_FROM_P (base1, newbase))
-		    {
-		      error_with_aggr_type (basetype, "ambiguous request for function from distinct base classes of type `%s'");
-		      error ("  first candidate is `%s'",
-			     fndecl_as_string (0, candidates[best].function, 1));
-		      error ("  second candidate is `%s'",
-			     fndecl_as_string (0, candidates[i].function, 1));
-		      cp[-1].evil = 1;
-		      return cp - 1;
-		    }
-		}
-	      else
-		{
-		  best = i;
-		  base1 = newbase;
-		}
-	    }
-	  else return cp - 1;
-	}
-    }
-
-  /* Don't accept a candidate as being ideal if it's indistinguishable
-     from another candidate.  */
-  if (rank_for_overload (cp-1, cp-2) == 0)
-    {
-      /* If the types are distinguishably different (like
-	 `long' vs. `unsigned long'), that's ok.  But if they are arbitrarily
-	 different, such as `int (*)(void)' vs. `void (*)(int)',
-	 that's not ok.  */
-      tree p1 = TYPE_ARG_TYPES (TREE_TYPE (cp[-1].function));
-      tree p2 = TYPE_ARG_TYPES (TREE_TYPE (cp[-2].function));
-      while (p1 && p2)
-	{
-	  if (TREE_CODE (TREE_VALUE (p1)) == POINTER_TYPE
-	      && TREE_CODE (TREE_TYPE (TREE_VALUE (p1))) == FUNCTION_TYPE
-	      && TREE_VALUE (p1) != TREE_VALUE (p2))
-	    return 0;
-	  p1 = TREE_CHAIN (p1);
-	  p2 = TREE_CHAIN (p2);
-	}
-      if (p1 || p2)
-	return 0;
-    }
-
-  return cp - 1;
-
- ret0:
-  /* In the case where there is no ideal candidate, restore
-     TREE_VALUE slots of PARMS from TREE_PURPOSE slots.  */
-  while (parms)
-    {
-      TREE_VALUE (parms) = TREE_PURPOSE (parms);
-      parms = TREE_CHAIN (parms);
-    }
-  return 0;
-}
-
-/* Assume that if the class referred to is not in the
-   current class hierarchy, that it may be remote.
-   PARENT is assumed to be of aggregate type here.  */
-static int
-may_be_remote (parent)
-     tree parent;
-{
-  if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent) == 0)
-    return 0;
-
-  if (current_class_type == NULL_TREE)
-    return 0;
-  if (parent == current_class_type)
-    return 0;
-
-  if (UNIQUELY_DERIVED_FROM_P (parent, current_class_type))
-    return 0;
-  return 1;
-}
-
-tree
-build_vfield_ref (datum, type)
-     tree datum, type;
-{
-  tree rval;
-  int old_assume_nonnull_objects = flag_assume_nonnull_objects;
-
-  if (datum == error_mark_node)
-    return error_mark_node;
-
-  /* Vtable references are always made from non-null objects.  */
-  flag_assume_nonnull_objects = 1;
-  if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
-    datum = convert_from_reference (datum);
-
-  if (! TYPE_USES_COMPLEX_INHERITANCE (type))
-    rval = build (COMPONENT_REF, TREE_TYPE (CLASSTYPE_VFIELD (type)),
-		  datum, CLASSTYPE_VFIELD (type));
-  else
-    rval = build_component_ref (datum, DECL_NAME (CLASSTYPE_VFIELD (type)), 0, 0);
-  flag_assume_nonnull_objects = old_assume_nonnull_objects;
-
-  return rval;
-}
-
-/* Build a call to a member of an object.  I.e., one that overloads
-   operator ()(), or is a pointer-to-function or pointer-to-method.  */
-static tree
-build_field_call (basetype_path, instance_ptr, name, parms, err_name)
-     tree basetype_path;
-     tree instance_ptr, name, parms;
-     char *err_name;
-{
-  tree field, instance;
-
-  if (instance_ptr == current_class_decl)
-    {
-      /* Check to see if we really have a reference to an instance variable
-	 with `operator()()' overloaded.  */
-      field = IDENTIFIER_CLASS_VALUE (name);
-
-      if (field == NULL_TREE)
-	{
-	  error ("`this' has no member named `%s'", err_name);
-	  return error_mark_node;
-	}
-
-      if (TREE_CODE (field) == FIELD_DECL)
-	{
-	  /* If it's a field, try overloading operator (),
-	     or calling if the field is a pointer-to-function.  */
-	  instance = build_component_ref_1 (C_C_D, field, 0);
-	  if (instance == error_mark_node)
-	    return error_mark_node;
-
-	  if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance))
-	      && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance)))
-	    return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, instance, parms, NULL_TREE);
-
-	  if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
-	    if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == FUNCTION_TYPE)
-	      return build_function_call (instance, parms);
-	    else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == METHOD_TYPE)
-	      return build_function_call (instance, tree_cons (NULL_TREE, current_class_decl, parms));
-	}
-      return NULL_TREE;
-    }
-
-  /* Check to see if this is not really a reference to an instance variable
-     with `operator()()' overloaded.  */
-  field = lookup_field (basetype_path, name, 1, 0);
-
-  /* This can happen if the reference was ambiguous
-     or for visibility violations.  */
-  if (field == error_mark_node)
-    return error_mark_node;
-  if (field)
-    {
-      tree basetype;
-      tree ftype = TREE_TYPE (field);
-
-      if (TYPE_LANG_SPECIFIC (ftype) && TYPE_OVERLOADS_CALL_EXPR (ftype))
-	{
-	  /* Make the next search for this field very short.  */
-	  basetype = DECL_FIELD_CONTEXT (field);
-	  instance_ptr = convert_pointer_to (basetype, instance_ptr);
-
-	  instance = build_indirect_ref (instance_ptr, NULL);
-	  return build_opfncall (CALL_EXPR, LOOKUP_NORMAL,
-				 build_component_ref_1 (instance, field, 0),
-				 parms, NULL_TREE);
-	}
-      if (TREE_CODE (ftype) == POINTER_TYPE)
-	{
-	  if (TREE_CODE (TREE_TYPE (ftype)) == FUNCTION_TYPE
-	      || TREE_CODE (TREE_TYPE (ftype)) == METHOD_TYPE)
-	    {
-	      /* This is a member which is a pointer to function.  */
-	      tree ref
-		= build_component_ref_1 (build_indirect_ref (instance_ptr,
-							     NULL),
-					 field, LOOKUP_COMPLAIN);
-	      if (ref == error_mark_node)
-		return error_mark_node;
-	      return build_function_call (ref, parms);
-	    }
-	}
-      else if (TREE_CODE (ftype) == METHOD_TYPE)
-	{
-	  error ("invalid call via pointer-to-member function");
-	  return error_mark_node;
-	}
-      else
-	return NULL_TREE;
-    }
-  return NULL_TREE;
-}
-
-tree
-find_scoped_type (type, inner_name, inner_types)
-     tree type, inner_name, inner_types;
-{
-  tree tags = CLASSTYPE_TAGS (type);
-
-  while (tags)
-    {
-      /* The TREE_PURPOSE of an enum tag (which becomes a member of the
-	 enclosing class) is set to the name for the enum type.  So, if
-	 inner_name is `bar', and we strike `baz' for `enum bar { baz }',
-	 then this test will be true.  */
-      if (TREE_PURPOSE (tags) == inner_name)
-	{
-	  if (inner_types == NULL_TREE)
-	    return DECL_NESTED_TYPENAME (TYPE_NAME (TREE_VALUE (tags)));
-	  return resolve_scope_to_name (TREE_VALUE (tags), inner_types);
-	}
-      tags = TREE_CHAIN (tags);
-    }
-
-  /* Look for a TYPE_DECL.  */
-  for (tags = TYPE_FIELDS (type); tags; tags = TREE_CHAIN (tags))
-    if (TREE_CODE (tags) == TYPE_DECL && DECL_NAME (tags) == inner_name)
-      {
-	/* Code by raeburn.  */
-	if (inner_types == NULL_TREE)
-	  return DECL_NESTED_TYPENAME (tags);
-	return resolve_scope_to_name (TREE_TYPE (tags), inner_types);
-      }
-
-  return NULL_TREE;
-}
-
-/* Resolve an expression NAME1::NAME2::...::NAMEn to
-   the name that names the above nested type.  INNER_TYPES
-   is a chain of nested type names (held together by SCOPE_REFs);
-   OUTER_TYPE is the type we know to enclose INNER_TYPES.
-   Returns NULL_TREE if there is an error.  */
-tree
-resolve_scope_to_name (outer_type, inner_types)
-     tree outer_type, inner_types;
-{
-  register tree tmp;
-  tree inner_name;
-
-  if (outer_type == NULL_TREE && current_class_type != NULL_TREE)
-    {
-      /* We first try to look for a nesting in our current class context,
-         then try any enclosing classes.  */
-      tree type = current_class_type;
-      
-      while (type && (TREE_CODE (type) == RECORD_TYPE
-		      || TREE_CODE (type) == UNION_TYPE))
-        {
-          tree rval = resolve_scope_to_name (type, inner_types);
-
-	  if (rval != NULL_TREE)
-	    return rval;
-	  type = DECL_CONTEXT (TYPE_NAME (type));
-	}
-    }
-
-  if (TREE_CODE (inner_types) == SCOPE_REF)
-    {
-      inner_name = TREE_OPERAND (inner_types, 0);
-      inner_types = TREE_OPERAND (inner_types, 1);
-    }
-  else
-    {
-      inner_name = inner_types;
-      inner_types = NULL_TREE;
-    }
-
-  if (outer_type == NULL_TREE)
-    {
-      /* If we have something that's already a type by itself,
-	 use that.  */
-      if (IDENTIFIER_HAS_TYPE_VALUE (inner_name))
-	{
-	  if (inner_types)
-	    return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name),
-					  inner_types);
-	  return inner_name;
-	}
-      return NULL_TREE;
-    }
-
-  if (! IS_AGGR_TYPE (outer_type))
-    return NULL_TREE;
-
-  /* Look for member classes or enums.  */
-  tmp = find_scoped_type (outer_type, inner_name, inner_types);
-
-  /* If it's not a type in this class, then go down into the
-     base classes and search there.  */
-  if (! tmp && TYPE_BINFO (outer_type))
-    {
-      tree binfos = TYPE_BINFO_BASETYPES (outer_type);
-      int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-      for (i = 0; i < n_baselinks; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-	  tmp = find_scoped_type (BINFO_TYPE (base_binfo),
-				  inner_name, inner_types);
-	  if (tmp)
-	    return tmp;
-	}
-      tmp = NULL_TREE;
-    }
-
-  return tmp;
-}
-
-/* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
-   This is how virtual function calls are avoided.  */
-tree
-build_scoped_method_call (exp, scopes, name, parms)
-     tree exp;
-     tree scopes;
-     tree name;
-     tree parms;
-{
-  /* Because this syntactic form does not allow
-     a pointer to a base class to be `stolen',
-     we need not protect the derived->base conversion
-     that happens here.
-     
-     @@ But we do have to check visibility privileges later.  */
-  tree basename = resolve_scope_to_name (NULL_TREE, scopes);
-  tree basetype, binfo, decl;
-  tree type = TREE_TYPE (exp);
-
-  if (type == error_mark_node
-      || basename == NULL_TREE
-      || ! is_aggr_typedef (basename, 1))
-    return error_mark_node;
-
-  if (! IS_AGGR_TYPE (type))
-    {
-      error ("base object of scoped method call is not of aggregate type");
-      return error_mark_node;
-    }
-
-  basetype = IDENTIFIER_TYPE_VALUE (basename);
-
-  if (binfo = binfo_or_else (basetype, type))
-    {
-      if (binfo == error_mark_node)
-	return error_mark_node;
-      if (TREE_CODE (exp) == INDIRECT_REF)
-	decl = build_indirect_ref (convert_pointer_to (binfo,
-						       build_unary_op (ADDR_EXPR, exp, 0)), NULL);
-      else
-	decl = build_scoped_ref (exp, scopes);
-
-      /* Call to a destructor.  */
-      if (TREE_CODE (name) == BIT_NOT_EXPR)
-	{
-	  /* Explicit call to destructor.  */
-	  name = TREE_OPERAND (name, 0);
-	  if (! is_aggr_typedef (name, 1))
-	    return error_mark_node;
-	  if (TREE_TYPE (decl) != IDENTIFIER_TYPE_VALUE (name))
-	    {
-	      error_with_aggr_type (TREE_TYPE (decl),
-				    "qualified type `%s' does not match destructor type `%s'",
-				    IDENTIFIER_POINTER (name));
-	      return error_mark_node;
-	    }
-	  if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl)))
-	    error_with_aggr_type (TREE_TYPE (decl), "type `%s' has no destructor");
-	  return build_delete (TREE_TYPE (decl), decl, integer_two_node,
-			       LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR,
-			       0, 0);
-	}
-
-      /* Call to a method.  */
-      return build_method_call (decl, name, parms, NULL_TREE,
-				LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
-    }
-  return error_mark_node;
-}
-
-/* Build something of the form ptr->method (args)
-   or object.method (args).  This can also build
-   calls to constructors, and find friends.
-
-   Member functions always take their class variable
-   as a pointer.
-
-   INSTANCE is a class instance.
-
-   NAME is the NAME field of the struct, union, or class
-   whose type is that of INSTANCE.
-
-   PARMS help to figure out what that NAME really refers to.
-
-   BASETYPE_PATH, if non-NULL, tells which basetypes of INSTANCE
-   we should be traversed before starting our search.  We need
-   this information to get protected accesses correct.
-
-   FLAGS is the logical disjunction of zero or more LOOKUP_
-   flags.  See cp-tree.h for more info.
-
-   If this is all OK, calls build_function_call with the resolved
-   member function.
-
-   This function must also handle being called to perform
-   initialization, promotion/coercion of arguments, and
-   instantiation of default parameters.
-
-   Note that NAME may refer to an instance variable name.  If
-   `operator()()' is defined for the type of that field, then we return
-   that result.  */
-tree
-build_method_call (instance, name, parms, basetype_path, flags)
-     tree instance, name, parms, basetype_path;
-     int flags;
-{
-  register tree function, fntype, value_type;
-  register tree basetype, save_basetype;
-  register tree baselink, result, method_name, parmtypes, parm;
-  tree last;
-  int pass;
-  enum visibility_type visibility;
-
-  /* Range of cases for vtable optimization.  */
-  enum vtable_needs { not_needed, maybe_needed, unneeded, needed };
-  enum vtable_needs need_vtbl = not_needed;
-
-  char *err_name;
-  char *name_kind;
-  int ever_seen = 0;
-  tree instance_ptr = NULL_TREE;
-  int all_virtual = flag_all_virtual;
-  int static_call_context = 0;
-  tree saw_private = NULL_TREE;
-  tree saw_protected = NULL_TREE;
-
-  /* Keep track of `const' and `volatile' objects.  */
-  int constp, volatilep;
-
-#ifdef GATHER_STATISTICS
-  n_build_method_call++;
-#endif
-
-  if (instance == error_mark_node
-      || name == error_mark_node
-      || parms == error_mark_node
-      || (instance != NULL_TREE && TREE_TYPE (instance) == error_mark_node))
-    return error_mark_node;
-
-  /* This is the logic that magically deletes the second argument to
-     operator delete, if it is not needed. */
-  if (name == ansi_opname[(int) DELETE_EXPR] && list_length (parms)==2)
-    {
-      tree save_last = TREE_CHAIN (parms);
-      tree result;
-      /* get rid of unneeded argument */
-      TREE_CHAIN (parms) = NULL_TREE;
-      result = build_method_call (instance, name, parms, basetype_path,
-				  (LOOKUP_SPECULATIVELY|flags)
-				  &~LOOKUP_COMPLAIN);
-      /* If it works, return it. */
-      if (result && result != error_mark_node)
-	return build_method_call (instance, name, parms, basetype_path, flags);
-      /* If it doesn't work, two argument delete must work */
-      TREE_CHAIN (parms) = save_last;
-    }
-
-#if 0
-  /* C++ 2.1 does not allow this, but ANSI probably will.  */
-  if (TREE_CODE (name) == BIT_NOT_EXPR)
-    {
-      error ("invalid call to destructor, use qualified name `%s::~%s'",
-	     IDENTIFIER_POINTER (name), IDENTIFIER_POINTER (name));
-      return error_mark_node;
-    }
-#else
-  if (TREE_CODE (name) == BIT_NOT_EXPR)
-    {
-      flags |= LOOKUP_DESTRUCTOR;
-      name = TREE_OPERAND (name, 0);
-      if (! is_aggr_typedef (name, 1))
-	return error_mark_node;
-      if (parms)
-	error ("destructors take no parameters");
-      basetype = IDENTIFIER_TYPE_VALUE (name);
-      if (! TYPE_HAS_DESTRUCTOR (basetype))
-	{
-#if 0 /* ARM says tp->~T() without T::~T() is valid.  */
-	  error_with_aggr_type (basetype, "type `%s' has no destructor");
-#endif
-	  /* A destructive destructor wouldn't be a bad idea, but let's
-	     not bother for now.  */
-	  return build_c_cast (void_type_node, instance);
-	}
-      instance = default_conversion (instance);
-      if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
-	instance_ptr = instance;
-      else
-	instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
-      return build_delete (build_pointer_type (basetype),
-			   instance_ptr, integer_two_node,
-			   LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0, 0);
-    }
-#endif
-
-  /* Initialize name for error reporting.  */
-  if (IDENTIFIER_TYPENAME_P (name))
-    err_name = "type conversion operator";
-  else if (IDENTIFIER_OPNAME_P (name))
-    {
-      char *p = operator_name_string (name);
-      err_name = (char *)alloca (strlen (p) + 10);
-      sprintf (err_name, "operator %s", p);
-    }
-  else if (TREE_CODE (name) == SCOPE_REF)
-    err_name = IDENTIFIER_POINTER (TREE_OPERAND (name, 1));
-  else
-    err_name = IDENTIFIER_POINTER (name);
-
-  if (IDENTIFIER_OPNAME_P (name))
-    GNU_xref_call (current_function_decl,  IDENTIFIER_POINTER (name));
-  else
-    GNU_xref_call (current_function_decl, err_name);
-
-  if (instance == NULL_TREE)
-    {
-      basetype = NULL_TREE;
-      /* Check cases where this is really a call to raise
-	 an exception.  */
-      if (current_class_type && TREE_CODE (name) == IDENTIFIER_NODE)
-	{
-	  basetype = purpose_member (name, CLASSTYPE_TAGS (current_class_type));
-	  if (basetype)
-	    basetype = TREE_VALUE (basetype);
-	}
-      else if (TREE_CODE (name) == SCOPE_REF
-	       && TREE_CODE (TREE_OPERAND (name, 0)) == IDENTIFIER_NODE)
-	{
-	  if (! is_aggr_typedef (TREE_OPERAND (name, 0), 1))
-	    return error_mark_node;
-	  basetype = purpose_member (TREE_OPERAND (name, 1),
-				     CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name, 0))));
-	  if (basetype)
-	    basetype = TREE_VALUE (basetype);
-	}
-
-      if (basetype != NULL_TREE)
-	;
-      /* call to a constructor... */
-      else if (IDENTIFIER_HAS_TYPE_VALUE (name))
-	{
-	  basetype = IDENTIFIER_TYPE_VALUE (name);
-	  name = constructor_name (basetype);
-	}
-      else
-	{
-	  tree typedef_name = lookup_name (name, 1);
-	  if (typedef_name && TREE_CODE (typedef_name) == TYPE_DECL)
-	    {
-	      /* Canonicalize the typedef name.  */
-	      basetype = TREE_TYPE (typedef_name);
-	      name = TYPE_IDENTIFIER (basetype);
-	    }
-	  else
-	    {
-	      error ("no constructor named `%s' in visible scope",
-		     IDENTIFIER_POINTER (name));
-	      return error_mark_node;
-	    }
-	}
-
-      if (! IS_AGGR_TYPE (basetype))
-	{
-	non_aggr_error:
-	  if ((flags & LOOKUP_COMPLAIN) && TREE_CODE (basetype) != ERROR_MARK)
-	    error ("request for member `%s' in something not a structure or union", err_name);
-
-	  return error_mark_node;
-	}
-    }
-  else if (instance == C_C_D || instance == current_class_decl)
-    {
-      /* When doing initialization, we side-effect the TREE_TYPE of
-	 C_C_D, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE.  */
-      basetype = TREE_TYPE (C_C_D);
-
-      /* Anything manifestly `this' in constructors and destructors
-	 has a known type, so virtual function tables are not needed.  */
-      if (TYPE_VIRTUAL_P (basetype)
-	  && !(flags & LOOKUP_NONVIRTUAL))
-	need_vtbl = (dtor_label || ctor_label)
-	  ? unneeded : maybe_needed;
-
-      instance = C_C_D;
-      instance_ptr = current_class_decl;
-      result = build_field_call (TYPE_BINFO (current_class_type),
-				 instance_ptr, name, parms, err_name);
-
-      if (result)
-	return result;
-    }
-  else if (TREE_CODE (instance) == RESULT_DECL)
-    {
-      basetype = TREE_TYPE (instance);
-      /* Should we ever have to make a virtual function reference
-	 from a RESULT_DECL, know that it must be of fixed type
-	 within the scope of this function.  */
-      if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype))
-	need_vtbl = maybe_needed;
-      instance_ptr = build1 (ADDR_EXPR, TYPE_POINTER_TO (basetype), instance);
-    }
-  else if (instance == current_exception_object)
-    {
-      instance_ptr = build1 (ADDR_EXPR, TYPE_POINTER_TO (current_exception_type),
-			    TREE_OPERAND (current_exception_object, 0));
-      mark_addressable (TREE_OPERAND (current_exception_object, 0));
-      result = build_field_call (TYPE_BINFO (current_exception_type),
-				 instance_ptr, name, parms, err_name);
-      if (result)
-	return result;
-      error ("exception member `%s' cannot be invoked", err_name);
-      return error_mark_node;
-    }
-  else
-    {
-      /* The MAIN_VARIANT of the type that `instance_ptr' winds up being.  */
-      tree inst_ptr_basetype;
-
-      static_call_context = (TREE_CODE (instance) == NOP_EXPR
-			     && TREE_OPERAND (instance, 0) == error_mark_node);
-
-      /* the base type of an instance variable is pointer to class */
-      basetype = TREE_TYPE (instance);
-
-      if (TREE_CODE (basetype) == REFERENCE_TYPE)
-	{
-	  basetype = TYPE_MAIN_VARIANT (TREE_TYPE (basetype));
-	  if (! IS_AGGR_TYPE (basetype))
-	    goto non_aggr_error;
-	  /* Call to convert not needed because we are remaining
-	     within the same type.  */
-	  instance_ptr = build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), instance);
-	  inst_ptr_basetype = basetype;
-	}
-      else
-	{
-	  if (TREE_CODE (basetype) == POINTER_TYPE)
-	    {
-	      basetype = TREE_TYPE (basetype);
-	      instance_ptr = instance;
-	    }
-
-	  if (! IS_AGGR_TYPE (basetype))
-	    goto non_aggr_error;
-
-	  if (! instance_ptr)
-	    {
-	      if ((lvalue_p (instance)
-		   && (instance_ptr = build_unary_op (ADDR_EXPR, instance, 0)))
-		  || (instance_ptr = unary_complex_lvalue (ADDR_EXPR, instance)))
-		{
-		  if (instance_ptr == error_mark_node)
-		    return error_mark_node;
-		}
-	      else if (TREE_CODE (instance) == NOP_EXPR
-		       || TREE_CODE (instance) == CONSTRUCTOR)
-		{
-		  /* A cast is not an lvalue.  Initialize a fresh temp
-		     with the value we are casting from, and proceed with
-		     that temporary.  We can't cast to a reference type,
-		     so that simplifies the initialization to something
-		     we can manage.  */
-		  tree temp = get_temp_name (TREE_TYPE (instance), 0);
-		  if (IS_AGGR_TYPE (TREE_TYPE (instance)))
-		    expand_aggr_init (temp, instance, 0);
-		  else
-		    {
-		      store_init_value (temp, instance);
-		      expand_decl_init (temp);
-		    }
-		  instance = temp;
-		  instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
-		}
-	      else
-		{
-		  if (TREE_CODE (instance) != CALL_EXPR)
-		    my_friendly_abort (125);
-		  if (TYPE_NEEDS_CONSTRUCTOR (basetype))
-		    instance = build_cplus_new (basetype, instance, 0);
-		  else
-		    {
-		      instance = get_temp_name (basetype, 0);
-		      TREE_ADDRESSABLE (instance) = 1;
-		    }
-		  instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
-		}
-	      /* @@ Should we call comp_target_types here?  */
-	      inst_ptr_basetype = TREE_TYPE (TREE_TYPE (instance_ptr));
-	      if (TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (inst_ptr_basetype))
-		basetype = inst_ptr_basetype;
-	      else
-		{
-		  instance_ptr = convert (TYPE_POINTER_TO (basetype), instance_ptr);
-		  if (instance_ptr == error_mark_node)
-		    return error_mark_node;
-		}
-	    }
-	  else
-	    inst_ptr_basetype = TREE_TYPE (TREE_TYPE (instance_ptr));
-	}
-
-      if (basetype_path == NULL_TREE)
-	basetype_path = TYPE_BINFO (inst_ptr_basetype);
-
-      result = build_field_call (basetype_path, instance_ptr, name, parms, err_name);
-      if (result)
-	return result;
-
-      if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype))
-	{
-	  if (TREE_SIDE_EFFECTS (instance_ptr))
-	    {
-	      /* This action is needed because the instance is needed
-		 for providing the base of the virtual function table.
-		 Without using a SAVE_EXPR, the function we are building
-		 may be called twice, or side effects on the instance
-		 variable (such as a post-increment), may happen twice.  */
-	      instance_ptr = save_expr (instance_ptr);
-	      instance = build_indirect_ref (instance_ptr, NULL);
-	    }
-	  else if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
-	    {
-	      /* This happens when called for operator new ().  */
-	      instance = build_indirect_ref (instance, NULL);
-	    }
-
-	  need_vtbl = maybe_needed;
-	}
-    }
-
-  if (TYPE_SIZE (basetype) == 0)
-    {
-      /* This is worth complaining about, I think.  */
-      error_with_aggr_type (basetype, "cannot lookup method in incomplete type `%s'");
-      return error_mark_node;
-    }
-
-  save_basetype = basetype;
-
-#if 0
-  if (all_virtual == 1
-      && (! strncmp (IDENTIFIER_POINTER (name), OPERATOR_METHOD_FORMAT,
-		     OPERATOR_METHOD_LENGTH)
-	  || instance_ptr == NULL_TREE
-	  || (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype) == 0)))
-    all_virtual = 0;
-#endif
-
-  last = NULL_TREE;
-  for (parmtypes = NULL_TREE, parm = parms; parm; parm = TREE_CHAIN (parm))
-    {
-      tree t = TREE_TYPE (TREE_VALUE (parm));
-      if (TREE_CODE (t) == OFFSET_TYPE)
-	{
-	  /* Convert OFFSET_TYPE entities to their normal selves.  */
-	  TREE_VALUE (parm) = resolve_offset_ref (TREE_VALUE (parm));
-	  t = TREE_TYPE (TREE_VALUE (parm));
-	}
-      if (TREE_CODE (t) == ARRAY_TYPE)
-	{
-	  /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
-	     This eliminates needless calls to `compute_conversion_costs'.  */
-	  TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
-	  t = TREE_TYPE (TREE_VALUE (parm));
-	}
-      if (t == error_mark_node)
-	return error_mark_node;
-      last = build_tree_list (NULL_TREE, t);
-      parmtypes = chainon (parmtypes, last);
-    }
-
-  if (instance)
-    {
-      constp = TREE_READONLY (instance);
-      volatilep = TREE_THIS_VOLATILE (instance);
-      parms = tree_cons (NULL_TREE, instance_ptr, parms);
-    }
-  else
-    {
-      /* Raw constructors are always in charge.  */
-      if (TYPE_USES_VIRTUAL_BASECLASSES (basetype)
-	  && ! (flags & LOOKUP_HAS_IN_CHARGE))
-	{
-	  flags |= LOOKUP_HAS_IN_CHARGE;
-	  parms = tree_cons (NULL_TREE, integer_one_node, parms);
-	  parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes);
-	}
-
-      if (flag_this_is_variable > 0)
-	{
-	  constp = 0;
-	  volatilep = 0;
-	  parms = tree_cons (NULL_TREE, build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), integer_zero_node), parms);
-	}
-      else
-	{
-	  constp = 0;
-	  volatilep = 0;
-	  instance_ptr = build_new (NULL_TREE, basetype, void_type_node, 0);
-	  if (instance_ptr == error_mark_node)
-	    return error_mark_node;
-	  instance_ptr = save_expr (instance_ptr);
-	  TREE_CALLS_NEW (instance_ptr) = 1;
-	  instance = build_indirect_ref (instance_ptr, NULL);
-
-	  /* If it's a default argument initialized from a ctor, what we get
-	     from instance_ptr will match the arglist for the FUNCTION_DECL
-	     of the constructor.  */
-	  if (parms && TREE_CODE (TREE_VALUE (parms)) == CALL_EXPR
-	      && TREE_OPERAND (TREE_VALUE (parms), 1)
-	      && TREE_CALLS_NEW (TREE_VALUE (TREE_OPERAND (TREE_VALUE (parms), 1))))
-	    parms = build_tree_list (NULL_TREE, instance_ptr);
-	  else
-	    parms = tree_cons (NULL_TREE, instance_ptr, parms);
-	}
-    }
-  parmtypes = tree_cons (NULL_TREE,
-			 build_pointer_type (build_type_variant (basetype, constp, volatilep)),
-			 parmtypes);
-  if (last == NULL_TREE)
-    last = parmtypes;
-
-  /* Look up function name in the structure type definition.  */
-
-  if ((IDENTIFIER_HAS_TYPE_VALUE (name)
-       && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name)))
-      || name == constructor_name (basetype))
-    {
-      tree tmp = NULL_TREE;
-      if (IDENTIFIER_TYPE_VALUE (name) == basetype
-	  || name == constructor_name (basetype))
-	tmp = TYPE_BINFO (basetype);
-      else
-	tmp = get_binfo (IDENTIFIER_TYPE_VALUE (name), basetype, 0);
-      
-      if (tmp != NULL_TREE)
-	{
-	  name_kind = "constructor";
-	  
-	  if (TYPE_USES_VIRTUAL_BASECLASSES (basetype)
-	      && ! (flags & LOOKUP_HAS_IN_CHARGE))
-	    {
-	      /* Constructors called for initialization
-		 only are never in charge.  */
-	      tree tmplist;
-	      
-	      flags |= LOOKUP_HAS_IN_CHARGE;
-	      tmplist = tree_cons (NULL_TREE, integer_zero_node,
-				   TREE_CHAIN (parms));
-	      TREE_CHAIN (parms) = tmplist;
-	      tmplist = tree_cons (NULL_TREE, integer_type_node, TREE_CHAIN (parmtypes));
-	      TREE_CHAIN (parmtypes) = tmplist;
-	    }
-	  basetype = BINFO_TYPE (tmp);
-	}
-      else
-	name_kind = "method";
-    }
-  else name_kind = "method";
-  
-  if (basetype_path == NULL_TREE)
-    basetype_path = TYPE_BINFO (basetype);
-  result = lookup_fnfields (basetype_path, name,
-			    (flags & LOOKUP_COMPLAIN));
-  if (result == error_mark_node)
-    return error_mark_node;
-
-
-  /* Now, go look for this method name.  We do not find destructors here.
-
-     Putting `void_list_node' on the end of the parmtypes
-     fakes out `build_decl_overload' into doing the right thing.  */
-  TREE_CHAIN (last) = void_list_node;
-  method_name = build_decl_overload (name, parmtypes,
-				     1 + (name == constructor_name (save_basetype)));
-  TREE_CHAIN (last) = NULL_TREE;
-
-  for (pass = 0; pass < 2; pass++)
-    {
-      struct candidate *candidates;
-      struct candidate *cp;
-      int len;
-      unsigned best = 1;
-
-      /* This increments every time we go up the type hierarchy.
-	 The idea is to prefer a function of the derived class if possible. */
-      int b_or_d = 0;
-
-      baselink = result;
-
-      if (pass > 0)
-	{
-	  candidates
-	    = (struct candidate *) alloca ((ever_seen+1)
-					   * sizeof (struct candidate));
-	  cp = candidates;
-	  len = list_length (parms);
-
-	  /* First see if a global function has a shot at it.  */
-	  if (flags & LOOKUP_GLOBAL)
-	    {
-	      tree friend_parms;
-	      tree parm = TREE_VALUE (parms);
-
-	      if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE)
-		friend_parms = parms;
-	      else if (TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE)
-		{
-		  tree new_type;
-		  parm = build_indirect_ref (parm, "friendifying parms (compiler error)");
-		  new_type = build_reference_type (TREE_TYPE (parm));
-		  /* It is possible that this should go down a layer. */
-		  new_type = build_type_variant (new_type,
-						 TREE_READONLY (parm),
-						 TREE_THIS_VOLATILE (parm));
-		  parm = convert (new_type, parm);
-		  friend_parms = tree_cons (NULL_TREE, parm, TREE_CHAIN (parms));
-		}
-	      else
-		my_friendly_abort (167);
-
-	      cp->harshness
-		= (unsigned short *)alloca ((len+1) * sizeof (short));
-	      result = build_overload_call (name, friend_parms, 0, cp);
-	      /* If it turns out to be the one we were actually looking for
-		 (it was probably a friend function), the return the
-		 good result.  */
-	      if (TREE_CODE (result) == CALL_EXPR)
-		return result;
-
-	      while (cp->evil == 0)
-		{
-		  /* non-standard uses: set the field to 0 to indicate
-		     we are using a non-member function.  */
-		  cp->u.field = 0;
-		  if (cp->harshness[len] == 0
-		      && cp->harshness[len] == 0
-		      && cp->user == 0 && cp->b_or_d == 0
-		      && cp->easy < best)
-		    best = cp->easy;
-		  cp += 1;
-		}
-	    }
-	}
-
-      while (baselink)
-	{
-	  /* We have a hit (of sorts). If the parameter list is
-	     "error_mark_node", or some variant thereof, it won't
-	     match any methods.  Since we have verified that the is
-	     some method vaguely matching this one (in name at least),
-	     silently return.
-	     
-	     Don't stop for friends, however.  */
-	  tree basetypes = TREE_PURPOSE (baselink);
-
-	  function = TREE_VALUE (baselink);
-	  if (TREE_CODE (basetypes) == TREE_LIST)
-	    basetypes = TREE_VALUE (basetypes);
-	  basetype = BINFO_TYPE (basetypes);
-
-	  /* Cast the instance variable to the appropriate type.  */
-	  TREE_VALUE (parmtypes) = TYPE_POINTER_TO (basetype);
-
-	  if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function)))
-	    function = DECL_CHAIN (function);
-
-	  for (; function; function = DECL_CHAIN (function))
-	    {
-#ifdef GATHER_STATISTICS
-	      n_inner_fields_searched++;
-#endif
-	      ever_seen++;
-
-	      /* Not looking for friends here.  */
-	      if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE
-		  && ! DECL_STATIC_FUNCTION_P (function))
-		continue;
-
-	      if (pass == 0
-		  && DECL_ASSEMBLER_NAME (function) == method_name)
-		{
-		  if (flags & LOOKUP_PROTECT)
-		    {
-		      visibility = compute_visibility (basetypes, function);
-		      if (visibility == visibility_protected
-			  && flags & LOOKUP_PROTECTED_OK)
-			visibility = visibility_public;
-		    }
-
-		  if ((flags & LOOKUP_PROTECT) == 0
-		      || visibility == visibility_public)
-		    goto found_and_ok;
-		  else if (visibility == visibility_private)
-		    saw_private = function;
-		  else if (visibility == visibility_protected)
-		    saw_protected = function;
-		  /* If we fail on the exact match, we have
-		     an immediate failure.  */
-		  goto found;
-		}
-	      if (pass > 0)
-		{
-		  tree these_parms = parms;
-
-#ifdef GATHER_STATISTICS
-		  n_inner_fields_searched++;
-#endif
-		  cp->harshness
-		    = (unsigned short *)alloca ((len+1) * sizeof (short));
-		  if (DECL_STATIC_FUNCTION_P (function))
-		    these_parms = TREE_CHAIN (these_parms);
-		  compute_conversion_costs (function, these_parms, cp, len);
-		  cp->b_or_d += b_or_d;
-		  if (cp->evil == 0)
-		    {
-		      cp->u.field = function;
-		      cp->function = function;
-		      if (flags & LOOKUP_PROTECT)
-			{
-			  enum visibility_type this_v;
-			  this_v = compute_visibility (basetypes, function);
-			  if (this_v == visibility_protected
-			      && (flags & LOOKUP_PROTECTED_OK))
-			    this_v = visibility_public;
-			  if (this_v != visibility_public)
-			    {
-			      if (this_v == visibility_private)
-				saw_private = function;
-			      else
-				saw_protected = function;
-			      continue;
-			    }
-			}
-
-		      /* No "two-level" conversions.  */
-		      if (flags & LOOKUP_NO_CONVERSION && cp->user != 0)
-			continue;
-
-		      /* If we used default parameters, we must
-			 check to see whether anyone else might
-			 use them also, and report a possible
-			 ambiguity.  */
-		      if (! TYPE_USES_MULTIPLE_INHERITANCE (save_basetype)
-			  && cp->harshness[len] == 0
-			  && CONST_HARSHNESS (cp->harshness[0]) == 0
-			  && cp->user == 0 && cp->b_or_d == 0
-			  && cp->easy < best)
-			{
-			  if (! DECL_STATIC_FUNCTION_P (function))
-			    TREE_VALUE (parms) = cp->arg;
-			  if (best == 1)
-			    goto found_and_maybe_warn;
-			}
-		      cp++;
-		    }
-		}
-	    }
-	  /* Now we have run through one link's member functions.
-	     arrange to head-insert this link's links.  */
-	  baselink = next_baselink (baselink);
-	  b_or_d += 1;
-	}
-      if (pass == 0)
-	{
-	  /* No exact match could be found.  Now try to find match
-	     using default conversions.  */
-	  if ((flags & LOOKUP_GLOBAL) && IDENTIFIER_GLOBAL_VALUE (name))
-	    if (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == FUNCTION_DECL)
-	      ever_seen += 1;
-	    else if (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TREE_LIST)
-	      ever_seen += list_length (IDENTIFIER_GLOBAL_VALUE (name));
-
-	  if (ever_seen == 0)
-	    {
-	      if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
-		  == LOOKUP_SPECULATIVELY)
-		return NULL_TREE;
-	      if (flags & LOOKUP_GLOBAL)
-		error ("no global or non-hidden member function `%s' defined", err_name);
-	      else
-		error_with_aggr_type (save_basetype, "no non-hidden member function `%s::%s' defined", err_name);
-	      return error_mark_node;
-	    }
-	  continue;
-	}
-
-      if (cp - candidates != 0)
-	{
-	  /* Rank from worst to best.  Then cp will point to best one.
-	     Private fields have their bits flipped.  For unsigned
-	     numbers, this should make them look very large.
-	     If the best alternate has a (signed) negative value,
-	     then all we ever saw were private members.  */
-	  if (cp - candidates > 1)
-	    {
-	      cp = ideal_candidate (save_basetype, candidates,
-				    cp - candidates, parms, len);
-	      if (cp == (struct candidate *)0)
-		{
-		  error ("ambiguous type conversion requested for %s `%s'",
-			 name_kind, err_name);
-		  return error_mark_node;
-		}
-	      if (cp->evil)
-		return error_mark_node;
-	    }
-	  else if (cp[-1].evil == 2)
-	    {
-	      error ("ambiguous type conversion requested for %s `%s'",
-		     name_kind, err_name);
-	      return error_mark_node;
-	    }
-	  else cp--;
-
-	  /* The global function was the best, so use it.  */
-	  if (cp->u.field == 0)
-	    {
-	      /* We must convert the instance pointer into a reference type.
-		 Global overloaded functions can only either take
-		 aggregate objects (which come for free from references)
-		 or reference data types anyway.  */
-	      TREE_VALUE (parms) = copy_node (instance_ptr);
-	      TREE_TYPE (TREE_VALUE (parms)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr)));
-	      return build_function_call (cp->function, parms);
-	    }
-
-	  function = cp->function;
-	  if (! DECL_STATIC_FUNCTION_P (function))
-	    TREE_VALUE (parms) = cp->arg;
-	  goto found_and_maybe_warn;
-	}
-
-      if ((flags & ~LOOKUP_GLOBAL) & (LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY))
-	{
-	  char *tag_name, *buf;
-
-	  if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
-	      == LOOKUP_SPECULATIVELY)
-	    return NULL_TREE;
-
-	  if (DECL_STATIC_FUNCTION_P (cp->function))
-	    parms = TREE_CHAIN (parms);
-	  if (ever_seen)
-	    {
-	      if (((HOST_WIDE_INT)saw_protected|(HOST_WIDE_INT)saw_private) == 0)
-		{
-		  if (flags & LOOKUP_SPECULATIVELY)
-		    return NULL_TREE;
-		  if (static_call_context && TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
-		    error_with_aggr_type (TREE_TYPE (TREE_TYPE (instance_ptr)),
-					  "object missing in call to `%s::%s'",
-					  err_name);
-		  else
-		    report_type_mismatch (cp, parms, name_kind, err_name);
-		}
-	      else
-		{
-		  char buf[80];
-		  char *msg;
-		  tree seen = saw_private;
-
-		  if (saw_private)
-		    {
-		      if (saw_protected)
-			msg = "%s `%%s' (and the like) are private or protected";
-		      else
-			msg = "the %s `%%s' is private";
-		    }
-		  else
-		    {
-		      msg = "the %s `%%s' is protected";
-		      seen = saw_protected;
-		    }
-		  sprintf (buf, msg, name_kind);
-		  error_with_decl (seen, buf);
-		  error ("within this context");
-		}
-	      return error_mark_node;
-	    }
-
-	  if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
-	      == LOOKUP_COMPLAIN)
-	    {
-	      if (TREE_CODE (save_basetype) == RECORD_TYPE)
-		tag_name = "structure";
-	      else
-		tag_name = "union";
-
-	      buf = (char *)alloca (30 + strlen (err_name));
-	      strcpy (buf, "%s has no method named `%s'");
-	      error (buf, tag_name, err_name);
-	      return error_mark_node;
-	    }
-	  return NULL_TREE;
-	}
-      continue;
-
-    found_and_maybe_warn:
-      if (CONST_HARSHNESS (cp->harshness[0]))
-	{
-	  if (flags & LOOKUP_COMPLAIN)
-	    {
-	      error_with_decl (cp->function, "non-const member function `%s'");
-	      error ("called for const object at this point in file");
-	    }
-	  /* Not good enough for a match.  */
-	  else
-	    return error_mark_node;
-	}
-      goto found_and_ok;
-    }
-  /* Silently return error_mark_node.  */
-  return error_mark_node;
-
- found:
-  if (visibility == visibility_private)
-    {
-      if (flags & LOOKUP_COMPLAIN)
-	{
-	  error_with_file_and_line (DECL_SOURCE_FILE (function),
-				    DECL_SOURCE_LINE (function),
-				    TREE_PRIVATE (function)
-				    ? "%s `%s' is private"
-				    : "%s `%s' is from private base class",
-				    name_kind,
-				    lang_printable_name (function));
-	  error ("within this context");
-	}
-      return error_mark_node;
-    }
-  else if (visibility == visibility_protected)
-    {
-      if (flags & LOOKUP_COMPLAIN)
-	{
-	  error_with_file_and_line (DECL_SOURCE_FILE (function),
-				    DECL_SOURCE_LINE (function),
-				    TREE_PROTECTED (function)
-				    ? "%s `%s' is protected"
-				    : "%s `%s' has protected visibility from this point",
-				    name_kind,
-				    lang_printable_name (function));
-	  error ("within this context");
-	}
-      return error_mark_node;
-    }
-  my_friendly_abort (1);
-
- found_and_ok:
-
-  /* From here on down, BASETYPE is the type that INSTANCE_PTR's
-     type (if it exists) is a pointer to.  */
-  function = DECL_MAIN_VARIANT (function);
-  /* Declare external function if necessary. */
-  assemble_external (function);
-
-  fntype = TREE_TYPE (function);
-  if (TREE_CODE (fntype) == POINTER_TYPE)
-    fntype = TREE_TYPE (fntype);
-  basetype = DECL_CLASS_CONTEXT (function);
-
-  /* If we are referencing a virtual function from an object
-     of effectively static type, then there is no need
-     to go through the virtual function table.  */
-  if (need_vtbl == maybe_needed)
-    {
-      int fixed_type = resolves_to_fixed_type_p (instance, 0);
-
-      if (all_virtual == 1
-	  && DECL_VINDEX (function)
-	  && may_be_remote (basetype))
-	need_vtbl = needed;
-      else if (DECL_VINDEX (function))
-	need_vtbl = fixed_type ? unneeded : needed;
-      else
-	need_vtbl = not_needed;
-    }
-
-  if (TREE_CODE (fntype) == METHOD_TYPE && static_call_context
-      && !DECL_CONSTRUCTOR_P (function))
-    {
-      /* Let's be nice to the user for now, and give reasonable
-	 default behavior.  */
-      instance_ptr = current_class_decl;
-      if (instance_ptr)
-	{
-	  if (basetype != current_class_type)
-	    {
-	      tree binfo = get_binfo (basetype, current_class_type, 1);
-	      if (binfo == NULL_TREE)
-		{
-		  error_not_base_type (function, current_class_type);
-		  return error_mark_node;
-		}
-	      else if (basetype == error_mark_node)
-		return error_mark_node;
-	    }
-	}
-      else if (! TREE_STATIC (function))
-	{
-	  error_with_aggr_type (basetype, "cannot call member function `%s::%s' without object",
-				err_name);
-	  return error_mark_node;
-	}
-    }
-
-  value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node;
-
-  if (TYPE_SIZE (value_type) == 0)
-    {
-      if (flags & LOOKUP_COMPLAIN)
-	incomplete_type_error (0, value_type);
-      return error_mark_node;
-    }
-
-  /* We do not pass FUNCTION into `convert_arguments', because by
-     now everything should be ok.  If not, then we have a serious error.  */
-  if (DECL_STATIC_FUNCTION_P (function))
-    parms = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
-			       TREE_CHAIN (parms), NULL_TREE, LOOKUP_NORMAL);
-  else if (need_vtbl == unneeded)
-    {
-      int sub_flags = DECL_CONSTRUCTOR_P (function) ? flags : LOOKUP_NORMAL;
-      basetype = TREE_TYPE (instance);
-      if (TYPE_METHOD_BASETYPE (TREE_TYPE (function)) != TYPE_MAIN_VARIANT (basetype)
-	  && TYPE_USES_COMPLEX_INHERITANCE (basetype))
-	{
-	  basetype = DECL_CLASS_CONTEXT (function);
-	  instance_ptr = convert_pointer_to (basetype, instance_ptr);
-	  instance = build_indirect_ref (instance_ptr, NULL);
-	}
-      parms = tree_cons (NULL_TREE, instance_ptr,
-			 convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), NULL_TREE, sub_flags));
-    }
-  else
-    {
-      if ((flags & LOOKUP_NONVIRTUAL) == 0)
-	basetype = DECL_CONTEXT (function);
-
-      /* First parm could be integer_zerop with casts like
-	 ((Object*)0)->Object::IsA()  */
-      if (!integer_zerop (TREE_VALUE (parms)))
-	{
-	  instance_ptr = convert_pointer_to (build_type_variant (basetype, constp, volatilep),
-					     TREE_VALUE (parms));
-	  if (TREE_CODE (instance_ptr) == COND_EXPR)
-	    {
-	      instance_ptr = save_expr (instance_ptr);
-	      instance = build_indirect_ref (instance_ptr, NULL);
-	    }
-	  else if (TREE_CODE (instance_ptr) == NOP_EXPR
-		   && TREE_CODE (TREE_OPERAND (instance_ptr, 0)) == ADDR_EXPR
-		   && TREE_OPERAND (TREE_OPERAND (instance_ptr, 0), 0) == instance)
-	    ;
-	  /* The call to `convert_pointer_to' may return error_mark_node.  */
-	  else if (TREE_CODE (instance_ptr) == ERROR_MARK)
-	    return instance_ptr;
-	  else if (instance == NULL_TREE
-		   || TREE_CODE (instance) != INDIRECT_REF
-		   || TREE_OPERAND (instance, 0) != instance_ptr)
-	    instance = build_indirect_ref (instance_ptr, NULL);
-	}
-      parms = tree_cons (NULL_TREE, instance_ptr,
-			 convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), NULL_TREE, LOOKUP_NORMAL));
-    }
-
-#if 0
-  /* Constructors do not overload method calls.  */
-  else if (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype)
-	   && name != TYPE_IDENTIFIER (basetype)
-	   && (TREE_CODE (function) != FUNCTION_DECL
-	       || strncmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)),
-			   OPERATOR_METHOD_FORMAT,
-			   OPERATOR_METHOD_LENGTH))
-#if 0
-	   && (may_be_remote (basetype)
-	       || (C_C_D ? TREE_TYPE (instance) != current_class_type : 1))
-#else
-	   /* This change by Larry Ketcham.  */
-  	   && (may_be_remote (basetype) || instance != C_C_D)
-#endif
-	   )
-    {
-      tree fn_as_int;
-
-      parms = TREE_CHAIN (parms);
-
-      if (!all_virtual && TREE_CODE (function) == FUNCTION_DECL)
-	fn_as_int = build_unary_op (ADDR_EXPR, function, 0);
-      else
-	fn_as_int = convert (TREE_TYPE (default_conversion (function)), DECL_VINDEX (function));
-      if (all_virtual == 1)
-	fn_as_int = convert (integer_type_node, fn_as_int);
-
-      result = build_opfncall (METHOD_CALL_EXPR, LOOKUP_NORMAL, instance, fn_as_int, parms);
-
-      if (result == NULL_TREE)
-	{
-	  compiler_error ("could not overload `operator->()(...)'");
-	  return error_mark_node;
-	}
-      else if (result == error_mark_node)
-	return error_mark_node;
-
-#if 0
-      /* Do this if we want the result of operator->() to inherit
-	 the type of the function it is subbing for.  */
-      TREE_TYPE (result) = value_type;
-#endif
-
-      return result;
-    }
-#endif
-
-  if (need_vtbl == needed)
-    {
-      function = build_vfn_ref (&TREE_VALUE (parms), instance, DECL_VINDEX (function));
-      TREE_TYPE (function) = build_pointer_type (fntype);
-    }
-
-  if (TREE_CODE (function) == FUNCTION_DECL)
-    GNU_xref_call (current_function_decl,
-		   IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)));
-
-  if (TREE_CODE (function) == FUNCTION_DECL)
-    {
-      if (DECL_INLINE (function))
-	function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
-      else
-	{
-	  assemble_external (function);
-	  TREE_USED (function) = 1;
-	  function = default_conversion (function);
-	}
-    }
-  else
-    function = default_conversion (function);
-
-  result =
-    build_nt (CALL_EXPR, function, parms, NULL_TREE);
-
-  TREE_TYPE (result) = value_type;
-  TREE_SIDE_EFFECTS (result) = 1;
-  TREE_RAISES (result)
-    = TYPE_RAISES_EXCEPTIONS (fntype) || (parms && TREE_RAISES (parms));
-  return result;
-}
-
-/* Similar to `build_method_call', but for overloaded non-member functions.
-   The name of this function comes through NAME.  The name depends
-   on PARMS.
-
-   Note that this function must handle simple `C' promotions,
-   as well as variable numbers of arguments (...), and
-   default arguments to boot.
-
-   If the overloading is successful, we return a tree node which
-   contains the call to the function.
-
-   If overloading produces candidates which are probable, but not definite,
-   we hold these candidates.  If FINAL_CP is non-zero, then we are free
-   to assume that final_cp points to enough storage for all candidates that
-   this function might generate.  The `harshness' array is preallocated for
-   the first candidate, but not for subsequent ones.
-
-   Note that the DECL_RTL of FUNCTION must be made to agree with this
-   function's new name.  */
-
-tree
-build_overload_call_real (fnname, parms, complain, final_cp, buildxxx)
-     tree fnname, parms;
-     int complain;
-     struct candidate *final_cp;
-     int buildxxx;
-{
-  /* must check for overloading here */
-  tree overload_name, functions, function, parm;
-  tree parmtypes = NULL_TREE, last = NULL_TREE;
-  register tree outer;
-  int length;
-  int parmlength = list_length (parms);
-
-  struct candidate *candidates, *cp;
-
-  if (final_cp)
-    {
-      final_cp[0].evil = 0;
-      final_cp[0].user = 0;
-      final_cp[0].b_or_d = 0;
-      final_cp[0].easy = 0;
-      final_cp[0].function = 0;
-      /* end marker.  */
-      final_cp[1].evil = 1;
-    }
-
-  for (parm = parms; parm; parm = TREE_CHAIN (parm))
-    {
-      register tree t = TREE_TYPE (TREE_VALUE (parm));
-
-      if (t == error_mark_node)
-	{
-	  if (final_cp)
-	    final_cp->evil = 1;
-	  return error_mark_node;
-	}
-      if (TREE_CODE (t) == ARRAY_TYPE || TREE_CODE (t) == OFFSET_TYPE)
-	{
-	  /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
-	     Also convert OFFSET_TYPE entities to their normal selves.
-	     This eliminates needless calls to `compute_conversion_costs'.  */
-	  TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
-	  t = TREE_TYPE (TREE_VALUE (parm));
-	}
-      last = build_tree_list (NULL_TREE, t);
-      parmtypes = chainon (parmtypes, last);
-    }
-  if (last)
-    TREE_CHAIN (last) = void_list_node;
-  else
-    parmtypes = void_list_node;
-  overload_name = build_decl_overload (fnname, parmtypes, 0);
-
-  /* Now check to see whether or not we can win.
-     Note that if we are called from `build_method_call',
-     then we cannot have a mis-match, because we would have
-     already found such a winning case.  */
-
-  if (IDENTIFIER_GLOBAL_VALUE (overload_name))
-    if (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (overload_name)) != TREE_LIST)
-      return build_function_call (DECL_MAIN_VARIANT (IDENTIFIER_GLOBAL_VALUE (overload_name)), parms);
-
-  functions = IDENTIFIER_GLOBAL_VALUE (fnname);
-
-  if (functions == NULL_TREE)
-    {
-      if (complain)
-	error ("only member functions apply");
-      if (final_cp)
-	final_cp->evil = 1;
-      return error_mark_node;
-    }
-
-  if (TREE_CODE (functions) == FUNCTION_DECL)
-    {
-      functions = DECL_MAIN_VARIANT (functions);
-      if (final_cp)
-	{
-	  /* We are just curious whether this is a viable alternative or not.  */
-	  compute_conversion_costs (functions, parms, final_cp, parmlength);
-	  return functions;
-	}
-      else
-	return build_function_call (functions, parms);
-    }
-
-  if (TREE_VALUE (functions) == NULL_TREE)
-    {
-      if (complain)
-	error ("function `%s' declared overloaded, but no instances of that function declared",
-	       IDENTIFIER_POINTER (TREE_PURPOSE (functions)));
-      if (final_cp)
-	final_cp->evil = 1;
-      return error_mark_node;
-    }
-
-  if (TREE_CODE (TREE_VALUE (functions)) == TREE_LIST)
-    {
-      register tree outer;
-      length = 0;
-
-      /* The list-of-lists should only occur for class things.  */
-      my_friendly_assert (functions == IDENTIFIER_CLASS_VALUE (fnname), 168);
-
-      for (outer = functions; outer; outer = TREE_CHAIN (outer))
-	{
-	  /* member functions.  */
-	  length += decl_list_length (TREE_VALUE (TREE_VALUE (outer)));
-	  /* friend functions.  */
-	  length += list_length (TREE_TYPE (TREE_VALUE (outer)));
-	}
-    }
-  else
-    {
-      length = list_length (functions);
-    }
-
-  if (final_cp)
-    candidates = final_cp;
-  else
-    candidates = (struct candidate *)alloca ((length+1) * sizeof (struct candidate));
-
-  cp = candidates;
-
-  my_friendly_assert (TREE_CODE (TREE_VALUE (functions)) != TREE_LIST, 169);
-  /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST.  */
-
-  for (outer = functions; outer; outer = TREE_CHAIN (outer))
-    {
-      int template_cost = 0;
-      function = TREE_VALUE (outer);
-      if (TREE_CODE (function) != FUNCTION_DECL
-	  && ! (TREE_CODE (function) == TEMPLATE_DECL
-		&& ! DECL_TEMPLATE_IS_CLASS (function)
-		&& TREE_CODE (DECL_TEMPLATE_RESULT (function)) == FUNCTION_DECL))
-	{
-	  enum tree_code code = TREE_CODE (function);
-	  if (code == TEMPLATE_DECL)
-	    code = TREE_CODE (DECL_TEMPLATE_RESULT (function));
-	  if (code == CONST_DECL)
-	    error_with_decl (function, "enumeral value `%s' conflicts with function of same name");
-	  else if (code == VAR_DECL)
-	    if (TREE_STATIC (function))
-	      error_with_decl (function, "variable `%s' conflicts with function of same name");
-	    else
-	      error_with_decl (function, "constant field `%s' conflicts with function of same name");
-	  else if (code == TYPE_DECL)
-	    continue;
-	  else my_friendly_abort (2);
-	  error ("at this point in file");
-	  continue;
-	}
-      if (TREE_CODE (function) == TEMPLATE_DECL)
-	{
-	  int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function));
-	  tree *targs = (tree *) alloca (sizeof (tree) * ntparms);
-	  int i;
-
-	  i = type_unification (DECL_TEMPLATE_PARMS (function), targs,
-				TYPE_ARG_TYPES (TREE_TYPE (function)),
-				parms, &template_cost);
-	  if (i == 0)
-	    function = instantiate_template (function, targs);
-	}
-      if (TREE_CODE (function) == TEMPLATE_DECL)
-	/* Unconverted template -- failed match.  */
-	cp->evil = 1, cp->function = function, cp->u.bad_arg = -4;
-      else
-	{
-	  function = DECL_MAIN_VARIANT (function);
-
-	  /* Can't use alloca here, since result might be
-	     passed to calling function.  */
-	  cp->harshness
-	    = (unsigned short *)oballoc ((parmlength+1) * sizeof (short));
-	  compute_conversion_costs (function, parms, cp, parmlength);
-	  /* Should really add another field...  */
-	  cp->easy = cp->easy * 128 + template_cost;
-	  if (cp[0].evil == 0)
-	    {
-	      cp[1].evil = 1;
-	      if (final_cp
-		  && cp[0].user == 0 && cp[0].b_or_d == 0
-		  && template_cost == 0
-		  && cp[0].easy <= 1)
-		{
-		  final_cp[0].easy = cp[0].easy;
-		  return function;
-		}
-	      cp++;
-	    }
-	}
-    }
-
-  if (cp - candidates)
-    {
-      tree rval = error_mark_node;
-
-      /* Leave marker.  */
-      cp[0].evil = 1;
-      if (cp - candidates > 1)
-	{
-	  struct candidate *best_cp
-	    = ideal_candidate (NULL_TREE, candidates,
-			       cp - candidates, parms, parmlength);
-	  if (best_cp == (struct candidate *)0)
-	    {
-	      if (complain)
-		error ("call of overloaded `%s' is ambiguous", IDENTIFIER_POINTER (fnname));
-	      return error_mark_node;
-	    }
-	  else
-	    rval = best_cp->function;
-	}
-      else
-	{
-	  cp -= 1;
-	  if (cp->evil > 1)
-	    {
-	      if (complain)
-		error ("type conversion ambiguous");
-	    }
-	  else
-	    rval = cp->function;
-	}
-
-      if (final_cp)
-	return rval;
-
-      return buildxxx ? build_function_call_maybe (rval, parms)
-        : build_function_call (rval, parms);
-    }
-  else if (complain)
-    {
-      tree name;
-      char *err_name;
-
-      /* Initialize name for error reporting.  */
-      if (TREE_CODE (functions) == TREE_LIST)
-	name = TREE_PURPOSE (functions);
-      else if (TREE_CODE (functions) == ADDR_EXPR)
-      /* Since the implicit `operator new' and `operator delete' functions
-	 are set up to have IDENTIFIER_GLOBAL_VALUEs that are unary ADDR_EXPRs
-	 by default_conversion(), we must compensate for that here by
-	 using the name of the ADDR_EXPR's operand.  */
-	name = DECL_NAME (TREE_OPERAND (functions, 0));
-      else
-	name = DECL_NAME (functions);
-
-      if (IDENTIFIER_OPNAME_P (name))
-	{
-	  char *opname = operator_name_string (name);
-	  err_name = (char *)alloca (strlen (opname) + 12);
-	  sprintf (err_name, "operator %s", opname);
-	}
-      else
-	err_name = IDENTIFIER_POINTER (name);
-
-      report_type_mismatch (cp, parms, "function", err_name);
-    }
-  return error_mark_node;
-}
-
-tree
-build_overload_call (fnname, parms, complain, final_cp)
-     tree fnname, parms;
-     int complain;
-     struct candidate *final_cp;
-{
-  return build_overload_call_real (fnname, parms, complain, final_cp, 0);
-}
-
-tree
-build_overload_call_maybe (fnname, parms, complain, final_cp)
-     tree fnname, parms;
-     int complain;
-     struct candidate *final_cp;
-{
-  return build_overload_call_real (fnname, parms, complain, final_cp, 1);
-}
diff --git a/gnu/gcc2/cc1plus/cp-class.c b/gnu/gcc2/cc1plus/cp-class.c
deleted file mode 100644
index 49e8581dd362..000000000000
--- a/gnu/gcc2/cc1plus/cp-class.c
+++ /dev/null
@@ -1,4274 +0,0 @@
-/* Functions related to building classes and their related objects.
-   Copyright (C) 1987, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* High-level class interface. */
-
-#include "config.h"
-#include "tree.h"
-#include <stdio.h>
-#include "cp-tree.h"
-#include "flags.h"
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-#include "cp-decl.h"
-#endif
-
-#include "obstack.h"
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-extern struct obstack permanent_obstack;
-
-/* Way of stacking class types.  */
-static tree *current_class_base, *current_class_stack;
-static int current_class_stacksize;
-int current_class_depth;
-
-struct class_level
-{
-  /* The previous class level.  */
-  struct class_level *level_chain;
-
-  /* The class instance variable, as a PARM_DECL.  */
-  tree decl;
-  /* The class instance variable, as an object.  */
-  tree object;
-  /* The virtual function table pointer
-     for the class instance variable.  */
-  tree vtable_decl;
-
-  /* Name of the current class.  */
-  tree name;
-  /* Type of the current class.  */
-  tree type;
-
-  /* Flags for this class level.  */
-  int this_is_variable;
-  int memoized_lookups;
-  int save_memoized;
-  int unused;
-};
-
-tree current_class_decl, C_C_D;	/* PARM_DECL: the class instance variable */
-tree current_vtable_decl;
-
-/* The following two can be derived from the previous one */
-tree current_class_name;	/* IDENTIFIER_NODE: name of current class */
-tree current_class_type;	/* _TYPE: the type of the current class */
-static tree prev_class_type;	/* _TYPE: the previous type that was a class */
-
-static tree get_vfield_name PROTO((tree));
-tree the_null_vtable_entry;
-
-/* Way of stacking language names.  */
-tree *current_lang_base, *current_lang_stack;
-static int current_lang_stacksize;
-
-/* Names of languages we recognize.  */
-tree lang_name_c, lang_name_cplusplus;
-tree current_lang_name;
-
-/* When layout out an aggregate type, the size of the
-   basetypes (virtual and non-virtual) is passed to layout_record
-   via this node.  */
-static tree base_layout_decl;
-
-/* Variables shared between cp-class.c and cp-call.c.  */
-
-int n_vtables = 0;
-int n_vtable_entries = 0;
-int n_vtable_searches = 0;
-int n_vtable_elems = 0;
-int n_convert_harshness = 0;
-int n_compute_conversion_costs = 0;
-int n_build_method_call = 0;
-int n_inner_fields_searched = 0;
-
-/* Virtual baseclass things.  */
-tree
-build_vbase_pointer (exp, type)
-     tree exp, type;
-{
-  char *name;
-
-  name = (char *) alloca (TYPE_NAME_LENGTH (type) + sizeof (VBASE_NAME) + 1);
-  sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (type));
-  return build_component_ref (exp, get_identifier (name), 0, 0);
-}
-
-/* Build multi-level access to EXPR using hierarchy path PATH.
-   CODE is PLUS_EXPR if we are going with the grain,
-   and MINUS_EXPR if we are not (in which case, we cannot traverse
-   virtual baseclass links).
-
-   TYPE is the type we want this path to have on exit.
-
-   ALIAS_THIS is non-zero if EXPR in an expression involving `this'.  */
-tree
-build_vbase_path (code, type, expr, path, alias_this)
-     enum tree_code code;
-     tree type, expr, path;
-     int alias_this;
-{
-  register int changed = 0;
-  tree last = NULL_TREE, last_virtual = NULL_TREE;
-  int nonnull = 0;
-  int fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
-  tree null_expr = 0, nonnull_expr;
-  tree basetype;
-  tree offset = integer_zero_node;
-
-  if (!fixed_type_p && TREE_SIDE_EFFECTS (expr))
-    expr = save_expr (expr);
-  nonnull_expr = expr;
-
-  if (BINFO_INHERITANCE_CHAIN (path))
-    {
-      tree reverse_path = NULL_TREE;
-
-      while (path)
-	{
-	  tree r = copy_node (path);
-	  BINFO_INHERITANCE_CHAIN (r) = reverse_path;
-	  reverse_path = r;
-	  path = BINFO_INHERITANCE_CHAIN (path);
-	}
-      path = reverse_path;
-    }
-
-  basetype = BINFO_TYPE (path);
-
-  while (path)
-    {
-      if (TREE_VIA_VIRTUAL (path))
-	{
-	  last_virtual = BINFO_TYPE (path);
-	  if (code == PLUS_EXPR)
-	    {
-	      changed = ! fixed_type_p;
-
-	      if (changed)
-		{
-		  extern int flag_assume_nonnull_objects;
-		  tree ind;
-
-		  if (last)
-		    nonnull_expr = convert_pointer_to (last, nonnull_expr);
-		  ind = build_indirect_ref (nonnull_expr, NULL);
-		  nonnull_expr = build_vbase_pointer (ind, last_virtual);
-		  if (nonnull == 0 && !flag_assume_nonnull_objects
-		      && null_expr == NULL_TREE)
-		    {
-		      null_expr = build1 (NOP_EXPR, TYPE_POINTER_TO (last_virtual), integer_zero_node);
-		      expr = build (COND_EXPR, TYPE_POINTER_TO (last_virtual),
-				    build (EQ_EXPR, integer_type_node, expr,
-					   integer_zero_node),
-				    null_expr, nonnull_expr);
-		    }
-		}
-	      /* else we'll figure out the offset below.  */
-
-	      /* Happens in the case of parse errors.  */
-	      if (nonnull_expr == error_mark_node)
-		return error_mark_node;
-	    }
-	  else
-	    {
-	      error_with_aggr_type (last_virtual, "cannot cast up from virtual baseclass `%s'");
-	      return error_mark_node;
-	    }
-	}
-      last = path;
-      path = BINFO_INHERITANCE_CHAIN (path);
-    }
-  /* LAST is now the last basetype assoc on the path.  */
-
-  /* A pointer to a virtual base member of a non-null object
-     is non-null.  Therefore, we only need to test for zeroness once.
-     Make EXPR the canonical expression to deal with here.  */
-  if (null_expr)
-    {
-      TREE_OPERAND (expr, 2) = nonnull_expr;
-      TREE_TYPE (TREE_OPERAND (expr, 1)) = TREE_TYPE (nonnull_expr);
-    }
-  else
-    expr = nonnull_expr;
-
-  /* If we go through any virtual base pointers, make sure that
-     casts to BASETYPE from the last virtual base class use
-     the right value for BASETYPE.  */
-  if (changed)
-    {
-      tree intype = TREE_TYPE (TREE_TYPE (expr));
-      if (TYPE_MAIN_VARIANT (intype) == BINFO_TYPE (last))
-	basetype = intype;
-      else
-	{
-	  tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (intype), 0);
-	  basetype = last;
-	  offset = BINFO_OFFSET (binfo);
-	}
-    }
-  else
-    {
-      if (last_virtual)
-	{
-	  offset = BINFO_OFFSET (binfo_member (last_virtual,
-					       CLASSTYPE_VBASECLASSES (basetype)));
-	  offset = size_binop (PLUS_EXPR, offset, BINFO_OFFSET (last));
-	}
-      else
-	offset = BINFO_OFFSET (last);
-
-#if 0
-      /* why unconditionally set this? (mrs) see deja-gnu/g++.mike/net15.C
-	 for a test case. */
-      code = PLUS_EXPR;
-#endif
-    }
-
-  if (TREE_INT_CST_LOW (offset))
-    {
-      /* For multiple inheritance: if `this' can be set by any
-	 function, then it could be 0 on entry to any function.
-	 Preserve such zeroness here.  Otherwise, only in the
-	 case of constructors need we worry, and in those cases,
-	 it will be zero, or initialized to some legal value to
-	 which we may add.  */
-      if (nonnull == 0 && (alias_this == 0 || flag_this_is_variable > 0))
-	{
-	  if (null_expr)
-	    TREE_TYPE (null_expr) = type;
-	  else
-	    null_expr = build1 (NOP_EXPR, type, integer_zero_node);
-	  if (TREE_SIDE_EFFECTS (expr))
-	    expr = save_expr (expr);
-
-	  return build (COND_EXPR, type,
-			build (EQ_EXPR, integer_type_node, expr, integer_zero_node),
-			null_expr,
-			build (code, type, expr, offset));
-	}
-      else return build (code, type, expr, offset);
-    }
-
-  /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
-     be used multiple times in initialization of multiple inheritance.  */
-  if (null_expr)
-    {
-      TREE_TYPE (expr) = type;
-      return expr;
-    }
-  else
-    return build1 (NOP_EXPR, type, expr);
-}
-
-/* Virtual function things.  */
-
-/* Virtual functions to be dealt with after laying out our
-   base classes.  Usually this is used only when classes have virtual
-   baseclasses, but it can happen also when classes have non-virtual
-   baseclasses if the derived class overrides baseclass functions
-   at different offsets.  */
-static tree pending_hard_virtuals;
-static int doing_hard_virtuals;
-
-/* The names of the entries in the virtual table structure.  */
-static tree delta_name, pfn_name;
-
-/* XXX This is set but never used.  (bpk) */
-#if 0
-/* Temporary binfo list to memoize lookups of the left-most non-virtual
-   baseclass B in a lattice topped by T.  B can appear multiple times
-   in the lattice.
-   TREE_PURPOSE is B's TYPE_MAIN_VARIANT.
-   TREE_VALUE is the path by which B is reached from T.
-   TREE_TYPE is B's real type.
-
-   If TREE_TYPE is NULL_TREE, it means that B was reached via
-   a virtual baseclass.
-   N.B.: This list consists of nodes on the temporary obstack.  */
-static tree leftmost_baseclasses;
-#endif
-
-/* Build an entry in the virtual function table.
-   DELTA is the offset for the `this' pointer.
-   PFN is an ADDR_EXPR containing a pointer to the virtual function.
-   Note that the index (DELTA2) in the virtual function table
-   is always 0.  */
-tree
-build_vtable_entry (delta, pfn)
-     tree delta, pfn;
-{
-  tree elems = tree_cons (NULL_TREE, delta,
-			  tree_cons (NULL_TREE, integer_zero_node,
-				     build_tree_list (NULL_TREE, pfn)));
-  tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
-
-  /* DELTA is constructed by `size_int', which means it may be an
-     unsigned quantity on some platforms.  Therefore, we cannot use
-     `int_fits_type_p', because when DELTA is really negative,
-     `force_fit_type' will make it look like a very large number.  */
-
-  if ((TREE_INT_CST_LOW (TYPE_MAX_VALUE (short_integer_type_node))
-       < TREE_INT_CST_LOW (delta))
-      || (TREE_INT_CST_LOW (delta)
-	  < TREE_INT_CST_LOW (TYPE_MIN_VALUE (short_integer_type_node))))
-    sorry ("object size exceeds built-in limit for virtual function table implementation");
-
-  TREE_CONSTANT (entry) = 1;
-  TREE_STATIC (entry) = 1;
-  TREE_READONLY (entry) = 1;
-
-#ifdef GATHER_STATISTICS
-  n_vtable_entries += 1;
-#endif
-
-  return entry;
-}
-
-/* Given an object INSTANCE, return an expression which yields
-   the virtual function corresponding to INDEX.  There are many special
-   cases for INSTANCE which we take care of here, mainly to avoid
-   creating extra tree nodes when we don't have to.  */
-tree
-build_vfn_ref (ptr_to_instptr, instance, index)
-     tree *ptr_to_instptr, instance;
-     tree index;
-{
-  extern int building_cleanup;
-  tree vtbl, aref;
-  tree basetype = TREE_TYPE (instance);
-
-  if (TREE_CODE (basetype) == REFERENCE_TYPE)
-    basetype = TREE_TYPE (basetype);
-
-  if (instance == C_C_D)
-    {
-      if (current_vtable_decl == NULL_TREE
-	  || current_vtable_decl == error_mark_node
-	  || !UNIQUELY_DERIVED_FROM_P (DECL_FCONTEXT (CLASSTYPE_VFIELD (current_class_type)), basetype))
-	vtbl = build_indirect_ref (build_vfield_ref (instance, basetype), NULL);
-      else
-	vtbl = current_vtable_decl;
-    }
-  else
-    {
-      if (optimize)
-	{
-	  /* Try to figure out what a reference refers to, and
-	     access its virtual function table directly.  */
-	  tree ref = NULL_TREE;
-
-	  if (TREE_CODE (instance) == INDIRECT_REF
-	      && TREE_CODE (TREE_TYPE (TREE_OPERAND (instance, 0))) == REFERENCE_TYPE)
-	    ref = TREE_OPERAND (instance, 0);
-	  else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
-	    ref = instance;
-
-	  if (ref && TREE_CODE (ref) == VAR_DECL
-	      && DECL_INITIAL (ref))
-	    {
-	      tree init = DECL_INITIAL (ref);
-
-	      while (TREE_CODE (init) == NOP_EXPR
-		     || TREE_CODE (init) == NON_LVALUE_EXPR)
-		init = TREE_OPERAND (init, 0);
-	      if (TREE_CODE (init) == ADDR_EXPR)
-		{
-		  init = TREE_OPERAND (init, 0);
-		  if (IS_AGGR_TYPE (TREE_TYPE (init))
-		      && (TREE_CODE (init) == PARM_DECL
-			  || TREE_CODE (init) == VAR_DECL))
-		    instance = init;
-		}
-	    }
-	}
-
-      if (IS_AGGR_TYPE (TREE_TYPE (instance))
-	  && (TREE_CODE (instance) == RESULT_DECL
-	      || TREE_CODE (instance) == PARM_DECL
-	      || TREE_CODE (instance) == VAR_DECL))
-	vtbl = TYPE_BINFO_VTABLE (basetype);
-      else
-	vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
-				   NULL);
-    }
-  assemble_external (vtbl);
-  aref = build_array_ref (vtbl, index);
-  if (!building_cleanup && TREE_CODE (aref) == INDIRECT_REF)
-    TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
-
-  *ptr_to_instptr = build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
-			   *ptr_to_instptr,
-			   convert (integer_type_node, build_component_ref (aref, delta_name, 0, 0)));
-  return build_component_ref (aref, pfn_name, 0, 0);
-}
-
-/* Set TREE_PUBLIC and/or TREE_EXTERN on the vtable DECL,
-   based on TYPE and other static flags.
-
-   Note that anything public is tagged TREE_PUBLIC, whether
-   it's public in this file or in another one.  */
-
-static void
-import_export_vtable (decl, type)
-  tree decl, type;
-{
-  if (write_virtuals >= 2)
-    {
-      if (CLASSTYPE_INTERFACE_UNKNOWN (type) == 0)
-	{
-	  TREE_PUBLIC (decl) = 1;
-	  DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type);
-	}
-    }
-  else if (write_virtuals != 0)
-    {
-      TREE_PUBLIC (decl) = 1;
-      if (write_virtuals < 0)
-	DECL_EXTERNAL (decl) = 1;
-    }
-}
-
-/* Return the name of the virtual function table (as an IDENTIFIER_NODE)
-   for the given TYPE.  */
-static tree
-get_vtable_name (type)
-     tree type;
-{
-  tree type_id = build_typename_overload (type);
-  char *buf = (char *)alloca (sizeof (VTABLE_NAME_FORMAT)
-			      + IDENTIFIER_LENGTH (type_id) + 2);
-  char *ptr = IDENTIFIER_POINTER (type_id);
-  int i;
-  for (i = 0; ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++) ;
-  while (ptr[i] >= '0' && ptr[i] <= '9')
-    i += 1;
-  sprintf (buf, VTABLE_NAME_FORMAT, ptr+i);
-  return get_identifier (buf);
-}
-
-/* Build a virtual function for type TYPE.
-   If BINFO is non-NULL, build the vtable starting with the initial
-   approximation that it is the same as the one which is the head of
-   the association list.  */
-static tree
-build_vtable (binfo, type)
-     tree binfo, type;
-{
-  tree name = get_vtable_name (type);
-  tree virtuals, decl;
-
-  if (binfo)
-    {
-      virtuals = copy_list (BINFO_VIRTUALS (binfo));
-      decl = build_decl (VAR_DECL, name, TREE_TYPE (BINFO_VTABLE (binfo)));
-    }
-  else
-    {
-      virtuals = NULL_TREE;
-      decl = build_decl (VAR_DECL, name, void_type_node);
-    }
-
-#ifdef GATHER_STATISTICS
-  n_vtables += 1;
-  n_vtable_elems += list_length (virtuals);
-#endif
-
-  /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
-  import_export_vtable (decl, type);
-
-  IDENTIFIER_GLOBAL_VALUE (name) = decl = pushdecl_top_level (decl);
-  /* Initialize the association list for this type, based
-     on our first approximation.  */
-  TYPE_BINFO_VTABLE (type) = decl;
-  TYPE_BINFO_VIRTUALS (type) = virtuals;
-
-  TREE_STATIC (decl) = 1;
-  DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
-			   DECL_ALIGN (decl));
-
-  if (binfo && write_virtuals >= 0)
-    DECL_VIRTUAL_P (decl) = 1;
-#if 0
-  /* Remember which class this vtable is really for.  */
-  if (binfo)
-    DECL_VPARENT (decl) = BINFO_TYPE (binfo);
-  else
-    DECL_VPARENT (decl) = type;
-#endif
-  DECL_CONTEXT (decl) = type;
-
-  binfo = TYPE_BINFO (type);
-  SET_BINFO_VTABLE_PATH_MARKED (binfo);
-  SET_BINFO_NEW_VTABLE_MARKED (binfo);
-  return decl;
-}
-
-/* Give TYPE a new virtual function table which is initialized
-   with a skeleton-copy of its original initialization.  The only
-   entry that changes is the `delta' entry, so we can really
-   share a lot of structure.
-
-   FOR_TYPE is the derived type which caused this table to
-   be needed.
-
-   BINFO is the type association which provided TYPE for FOR_TYPE.
-
-   The way we update BASE_BINFO's vtable information is just to change the
-   association information in FOR_TYPE's association list.  */
-static void
-prepare_fresh_vtable (binfo, base_binfo, for_type)
-     tree binfo, base_binfo, for_type;
-{
-  tree basetype = BINFO_TYPE (binfo);
-  tree orig_decl = BINFO_VTABLE (binfo);
-  tree name = build_type_pathname (VTABLE_NAME_FORMAT, basetype, for_type);
-  tree new_decl = build_decl (VAR_DECL, name, TREE_TYPE (orig_decl));
-  tree path;
-  int result;
-
-  /* Remember which class this vtable is really for.  */
-#if 0
-  DECL_VPARENT (new_decl) = BINFO_TYPE (base_binfo);
-#endif
-  DECL_CONTEXT (new_decl) = for_type;
-
-  TREE_STATIC (new_decl) = 1;
-  BINFO_VTABLE (binfo) = pushdecl_top_level (new_decl);
-  DECL_VIRTUAL_P (new_decl) = 1;
-  DECL_ALIGN (new_decl) = DECL_ALIGN (orig_decl);
-
-  /* Make fresh virtual list, so we can smash it later.  */
-  BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
-  /* Install the value for `headof' if that's what we're doing.  */
-  if (flag_dossier)
-    TREE_VALUE (TREE_CHAIN (BINFO_VIRTUALS (binfo)))
-      = build_vtable_entry (size_binop (MINUS_EXPR, integer_zero_node, BINFO_OFFSET (binfo)),
-			    FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (TREE_CHAIN (BINFO_VIRTUALS (binfo)))));
-
-#ifdef GATHER_STATISTICS
-  n_vtables += 1;
-  n_vtable_elems += list_length (BINFO_VIRTUALS (binfo));
-#endif
-
-  /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
-  import_export_vtable (new_decl, for_type);
-
-  if (TREE_VIA_VIRTUAL (binfo))
-    my_friendly_assert (binfo == binfo_member (BINFO_TYPE (binfo),
-				   CLASSTYPE_VBASECLASSES (current_class_type)),
-			170);
-  SET_BINFO_NEW_VTABLE_MARKED (binfo);
-  SET_BINFO_VTABLE_PATH_MARKED (binfo);
-
-  /* Mark all types between FOR_TYPE and TYPE as having been
-     touched, so that if we change virtual function table entries,
-     new vtables will be initialized.  We may reach the virtual
-     baseclass via ambiguous intervening baseclasses.  This
-     loop makes sure we get through to the actual baseclass we marked.
-
-     Also, update the vtable entries to reflect the overrides
-     of the top-most class (short of the top type).  */
-
-  do
-    {
-      result = get_base_distance (basetype, for_type, 0, &path);
-      for_type = path;
-      while (path)
-	{
-	  tree path_binfo = path;
-	  tree path_type = BINFO_TYPE (path);
-
-	  if (TREE_VIA_VIRTUAL (path))
-	    path_binfo = binfo_member (path_type,
-				       CLASSTYPE_VBASECLASSES (current_class_type));
-
-	  SET_BINFO_VTABLE_PATH_MARKED (path_binfo);
-	  if (BINFO_INHERITANCE_CHAIN (path)
-	      && CLASSTYPE_VFIELD (path_type) != NULL_TREE
-	      && (DECL_NAME (CLASSTYPE_VFIELD (BINFO_TYPE (binfo)))
-		  == DECL_NAME (CLASSTYPE_VFIELD (path_type)))
-	      /* This is the baseclass just before the original FOR_TYPE.  */
-	      && BINFO_INHERITANCE_CHAIN (BINFO_INHERITANCE_CHAIN (path)) == NULL_TREE)
-	    {
-	      tree old_virtuals = TREE_CHAIN (BINFO_VIRTUALS (binfo));
-	      tree new_virtuals = TREE_CHAIN (BINFO_VIRTUALS (path_binfo));
-	      if (flag_dossier)
-		{
-		  old_virtuals = TREE_CHAIN (old_virtuals);
-		  new_virtuals = TREE_CHAIN (new_virtuals);
-		}
-	      while (old_virtuals)
-		{
-		  TREE_VALUE (old_virtuals) = TREE_VALUE (new_virtuals);
-		  old_virtuals = TREE_CHAIN (old_virtuals);
-		  new_virtuals = TREE_CHAIN (new_virtuals);
-		}
-	    }
-	  path = BINFO_INHERITANCE_CHAIN (path);
-	}
-    }
-  while (result == -2);
-}
-
-/* Access the virtual function table entry that logically
-   contains BASE_FNDECL.  VIRTUALS is the virtual function table's
-   initializer.  */
-static tree
-get_vtable_entry (virtuals, base_fndecl)
-     tree virtuals, base_fndecl;
-{
-  unsigned HOST_WIDE_INT i = (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
-#ifdef VTABLE_USES_MASK
-	   && 0
-#endif
-	   ? (TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl))
-	      & (((unsigned HOST_WIDE_INT)1<<(BITS_PER_WORD-1))-1))
-	   : TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl)));
-
-#ifdef GATHER_STATISTICS
-  n_vtable_searches += i;
-#endif
-
-  while (i > 0)
-    {
-      virtuals = TREE_CHAIN (virtuals);
-      i -= 1;
-    }
-  return virtuals;
-}
-
-/* Put new entry ENTRY into virtual function table initializer
-   VIRTUALS.  The virtual function table is for type CONTEXT.
-
-   Also update DECL_VINDEX (FNDECL).  */
-
-static void
-modify_vtable_entry (old_entry_in_list, new_entry, fndecl, context)
-     tree old_entry_in_list, new_entry, fndecl, context;
-{
-  tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (old_entry_in_list));
-  tree vindex;
-
-  /* We can't put in the really right offset information
-     here, since we have not yet laid out the class to
-     take into account virtual base classes.  */
-  TREE_VALUE (old_entry_in_list) = new_entry;
-  vindex = DECL_VINDEX (TREE_OPERAND (base_pfn, 0));
-  if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
-    DECL_VINDEX (fndecl) = vindex;
-  else
-    {
-      if (! tree_int_cst_equal (DECL_VINDEX (fndecl), vindex))
-	{
-	  tree elts = CONSTRUCTOR_ELTS (new_entry);
-	  tree vfield = CLASSTYPE_VFIELD (context);
-
-	  if (! doing_hard_virtuals)
-	    {
-	      pending_hard_virtuals
-		= tree_cons (fndecl, FNADDR_FROM_VTABLE_ENTRY (new_entry),
-			     pending_hard_virtuals);
-	      TREE_TYPE (pending_hard_virtuals) = TREE_OPERAND (base_pfn, 0);
-	      return;
-	    }
-
-#if 0
-	  my_friendly_abort (3);
-
-	  /* Compute the relative offset of vtable we are really looking for.  */
-	  TREE_VALUE (elts) = size_binop (PLUS_EXPR,
-					  size_int (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (vfield))
-/* ??? This may be wrong. */
-						    / BITS_PER_UNIT),
-					  TREE_VALUE (elts));
-	  /* Say what index to use when we use that vtable.  */
-#ifndef VTABLE_USES_MASK
-	  vindex = build_int_2 (TREE_INT_CST_LOW (vindex)
-				& ~((unsigned HOST_WIDE_INT) 1
-				    << (BITS_PER_WORD -1)), 0);
-#endif
-	  TREE_VALUE (TREE_CHAIN (elts)) = vindex;
-#endif
-	}
-    }
-}
-
-/* Check to ensure that the virtual function table slot in VFIELD,
-   found by DECL_VINDEX of the BASE_FNDECL is in fact from a parent
-   virtual function table that is the same parent as for the
-   BASE_FNDECL given to us.  */
-
-static int
-related_vslot (base_fndecl, vfields, type)
-     tree base_fndecl, vfields, type;
-{
-  tree base_context = TYPE_MAIN_VARIANT (DECL_CONTEXT (base_fndecl));
-  tree base;
-  tree path;
-  int distance;
-
-  if (TREE_CODE (vfields) != TREE_LIST)
-    abort ();
-  base = VF_NORMAL_VALUE (vfields);
-  if (base == NULL_TREE)
-    base = VF_BASETYPE_VALUE (vfields);
-
-  /* The simple right way to do this is to ensure that the context of
-     the base virtual function is found along the leftmost path
-     between the most derived type associated with the vfield and the
-     current type.  */
-  distance = get_base_distance (base, type, 0, &path);
-  if (distance == -1)
-    abort ();
-  while (path)
-    {
-      if (BINFO_TYPE (path) == base_context)
-	return 1;
-      path = BINFO_INHERITANCE_CHAIN (path);
-    }
-
-  /* given:
-		Rr
-	       / \
-	      Mm  Hh
-	       \ /
-	        P
-
-     make sure we fill in P's vtable for H with overrides of r,
-     but be cautious of virtual base classes.  */
-  /* Combine the two below after debugging. */
-  if (get_base_distance (base_context, base, 0, &path) != -1)
-    {
-      while (path)
-	{
-	  if (TREE_VIA_VIRTUAL (path))
-	    return 0;
-	  path = BINFO_INHERITANCE_CHAIN (path);
-	}
-      return 1;
-    }
-  return 0;
-}
-
-/* Modify virtual function tables in lattice topped by T to
-   place FNDECL in tables which previously held BASE_FNDECL.
-   PFN is just FNDECL wrapped in an ADDR_EXPR, so that it
-   is suitable for placement directly into an initializer.
-
-   All distinct virtual function tables that this type uses
-   must be updated.  */
-static void
-modify_vtable_entries (t, fndecl, base_fndecl, pfn)
-     tree t;
-     tree fndecl, base_fndecl, pfn;
-{
-  tree base_offset, offset;
-  tree base_context = DECL_CLASS_CONTEXT (base_fndecl);
-  tree context = DECL_CLASS_CONTEXT (fndecl);
-  tree vfield = CLASSTYPE_VFIELD (t);
-  tree vfields, vbases;
-
-  DECL_CONTEXT (fndecl) = DECL_CONTEXT (base_fndecl);
-
-  offset = integer_zero_node;
-  if (context != t && TYPE_USES_COMPLEX_INHERITANCE (t))
-    {
-      offset = virtual_offset (context, CLASSTYPE_VBASECLASSES (t), offset);
-      if (offset == NULL_TREE)
-	{
-	  tree binfo = binfo_value (context, t);
-	  offset = BINFO_OFFSET (binfo);
-	}
-    }
-
-  /* For each layer of base class (i.e., the first base class, and each
-     virtual base class from that one), modify the virtual function table
-     of the derived class to contain the new virtual function.
-     A class has as many vfields as it has virtual base classes (total).  */
-  for (vfields = CLASSTYPE_VFIELDS (t); vfields; vfields = TREE_CHAIN (vfields))
-    {
-      int normal = 1;
-      tree binfo, this_offset;
-      tree base, path;
-
-/* This can go away when the new searching strategy as a little mileage on it. */
-#define NEW_SEARCH 1
-#if NEW_SEARCH
-      if (!related_vslot (base_fndecl, vfields, t))
-	  continue;
-#endif
-
-      /* Find the right base class for this derived class, call it BASE.  */
-      base = VF_BASETYPE_VALUE (vfields);
-
-#if NEW_SEARCH == 0
-      if (base != base_context)
-	{
-	  /* If BASE_FNDECL is not contained in the vtable accessed by
-	     the vslot, don't try to modify the vtable.
-	     
-	     Virtual functions from virtual baseclasses are not in derived
-	     virtual function tables.  This is an implementation decision;
-	     it keeps there from being a combinatorial explosion in the
-	     number of different vtables which must be maintained.  */
-
-	  /* In this case, we need to know whether BASE is derived
-	     from BASE_CONTEXT in any case, even the case where the
-	     derivation is ambiguous.  */
-	  int distance = get_base_distance (base, base_context, 0, (tree *)0);
-	  if (distance < 0 && distance != -2)
-	    continue;
-
-	  /* BASE_FNDECL is defined in a class derived from
-	     the base class owning this VFIELD.  */
-	}
-#endif
-
-      /* Get the path starting from the deepest base class CONTEXT
-	 of T (i.e., first defn of BASE_FNDECL).  */
-      get_base_distance (base_context, t, 0, &path);
-
-      /* Get our best approximation of what to use for constructing
-	 the virtual function table for T.  */
-      do
-	{
-	  /* Walk from base toward derived, stopping at the
-	     most derived baseclass that matters.  That baseclass
-	     is exactly the one which provides the vtable along
-	     the VFIELD spine, but no more.  */
-	  if (TREE_VIA_VIRTUAL (path))
-	    {
-	      base = path;
-	      binfo = binfo_member (BINFO_TYPE (base), CLASSTYPE_VBASECLASSES (t));
-	      break;
-	    }
-	  if (BINFO_INHERITANCE_CHAIN (path) == NULL_TREE
-	      || (BINFO_TYPE (BINFO_BASETYPE (BINFO_INHERITANCE_CHAIN (path), 0))
-		  != BINFO_TYPE (path))
-	      || BINFO_INHERITANCE_CHAIN (BINFO_INHERITANCE_CHAIN (path)) == NULL_TREE)
-	    {
-	      base = path;
-	      binfo = base;
-	      break;
-	    }
-	  path = BINFO_INHERITANCE_CHAIN (path);
-	}
-      while (1);
-
-      /* Find the right offset for the this pointer based on the base
-	 class we just found.  */
-      base_offset = BINFO_OFFSET (binfo);
-      this_offset = size_binop (MINUS_EXPR, offset, base_offset);
-
-      /* Make sure we can modify the derived association with immunity.  */
-      if (TREE_USED (TYPE_BINFO (t)))
-	TYPE_BINFO (t) = copy_binfo (TYPE_BINFO (t));
-
-      /* We call this case NORMAL iff this virtual function table
-	 pointer field has its storage reserved in this class.
-	 This is normally the case without virtual baseclasses
-	 or off-center multiple baseclasses.  */
-      normal = (vfield != NULL_TREE
-		&& VF_BASETYPE_VALUE (vfields) == DECL_FCONTEXT (vfield)
-		&& (VF_BINFO_VALUE (vfields) == NULL_TREE
-		    || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields))));
-
-      if (normal && VF_BINFO_VALUE (vfields))
-	/* Everything looks normal so far...check that we are really
-	   working from VFIELD's basetype, and not some other appearance
-	   of that basetype in the lattice.  */
-	normal = (VF_BINFO_VALUE (vfields)
-		  == get_binfo (VF_BASETYPE_VALUE (vfields), t, 0));
-
-      if (normal)
-	{
-	  /* In this case, it is *type*'s vtable we are modifying.
-	     We start with the approximation that it's vtable is that
-	     of the immediate base class.  */
-	  base_context = t;
-	  binfo = TYPE_BINFO (t);
-	  if (! BINFO_NEW_VTABLE_MARKED (binfo))
-	    build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
-	}
-      else
-	{
-	  /* This is our very own copy of `basetype' to play with.
-	     Later, we will fill in all the virtual functions
-	     that override the virtual functions in these base classes
-	     which are not defined by the current type.  */
-	  if (! BINFO_NEW_VTABLE_MARKED (binfo))
-	    prepare_fresh_vtable (binfo, base, t);
-	}
-
-      modify_vtable_entry (get_vtable_entry (BINFO_VIRTUALS (binfo), base_fndecl),
-			   build_vtable_entry (this_offset, pfn),
-			   fndecl, base_context);
-    }
-  for (vbases = CLASSTYPE_VBASECLASSES (t); vbases; vbases = TREE_CHAIN (vbases))
-    {
-      tree this_offset;
-      tree base, path;
-
-      if (! BINFO_VTABLE (vbases))
-	/* There are only two ways that a type can fail to have
-	   virtual functions: neither it nor any of its base
-	   types define virtual functions (in which case
-	   no updating need be done), or virtual functions
-	   accessible to it come from virtual base classes
-	   (in which case we have or will get them modified
-	   in other passes of this loop).  */
-	continue;
-
-      base = BINFO_TYPE (vbases);
-      path = NULL_TREE;
-
-      if (base != base_context
-	  && get_base_distance (base_context, base, 0, &path) == -1)
-	continue;
-
-      if (path)
-	this_offset = size_binop (MINUS_EXPR, offset, BINFO_OFFSET (path));
-      else
-	this_offset = offset;
-
-      /* Doesn't matter if not actually from this virtual base class,
-         but shouldn't come from deeper virtual baseclasses.  The enclosing
-	 loop should take care of such baseclasses.  */
-      while (path)
-	{
-	  if (TREE_VIA_VIRTUAL (path))
-	    goto skip;
-	  path = BINFO_INHERITANCE_CHAIN (path);
-	}
-
-      base_offset = BINFO_OFFSET (vbases);
-      this_offset = size_binop (MINUS_EXPR, this_offset, base_offset);
-
-      /* Make sure we can modify the derived association with immunity.  */
-      if (TREE_USED (TYPE_BINFO (t)))
-	TYPE_BINFO (t) = copy_binfo (TYPE_BINFO (t));
-
-      /* This is our very own copy of `basetype' to play with.  */
-      if (! BINFO_NEW_VTABLE_MARKED (vbases))
-	{
-	  tree context_binfo = binfo_value (base_context, base);
-	  prepare_fresh_vtable (vbases, context_binfo, t);
-	}
-      modify_vtable_entry (get_vtable_entry (BINFO_VIRTUALS (vbases), base_fndecl),
-			   build_vtable_entry (this_offset, pfn),
-			   fndecl, base_context);
-    skip: {}
-    }
-}
-
-static tree
-add_virtual_function (pending_virtuals, has_virtual, x, t)
-     tree pending_virtuals;
-     int *has_virtual;
-     tree x;
-     tree t; /* Structure type. */
-{
-  int debug_vbase = 1;
-
-  /* FUNCTION_TYPEs and OFFSET_TYPEs no longer freely
-     convert to void *.  Make such a conversion here.  */
-  tree vfn = build1 (ADDR_EXPR, ptr_type_node, x);
-  TREE_CONSTANT (vfn) = 1;
-
-  /* current_class_type may be NULL_TREE in case of error.  */
-  if (current_class_type)
-    TREE_ADDRESSABLE (x) = CLASSTYPE_VTABLE_NEEDS_WRITING (current_class_type);
-
-  /* If the virtual function is a redefinition of a prior one,
-     figure out in which base class the new definition goes,
-     and if necessary, make a fresh virtual function table
-     to hold that entry.  */
-  if (DECL_VINDEX (x) == error_mark_node)
-    {
-      tree entry = build_vtable_entry (integer_zero_node, vfn);
-
-      if (flag_dossier && *has_virtual == 0)
-	{
-	  /* CLASSTYPE_DOSSIER is only used as a Boolean (NULL or not). */
-	  CLASSTYPE_DOSSIER (t) = integer_one_node;
-	  *has_virtual = 1;
-        }
-
-      /* Build a new INT_CST for this DECL_VINDEX.  */
-#ifdef VTABLE_USES_MASK
-      SET_DECL_VINDEX (x, build_int_2 (++(*has_virtual), 0));
-#else
-      {
-	static tree index_table[256];
-	tree index;
-	int i = ++(*has_virtual);
-
-	if (i >= 256 || index_table[i] == 0)
-	  {
-	    index = build_int_2 (((unsigned HOST_WIDE_INT) 1
-				  << (BITS_PER_WORD - 1)) | i, ~0);
-	    if (i < 256)
-	      index_table[i] = index;
-	  }
-	else
-	  index = index_table[i];
-
-	DECL_VINDEX (x) = index;
-      }
-#endif
-      pending_virtuals = tree_cons (DECL_VINDEX (x), entry, pending_virtuals);
-    }
-  /* Happens if declared twice in class or we're not in a class definition.
-     We will give error later or we've already given it.  */
-  else if (TREE_CODE (DECL_VINDEX (x)) == INTEGER_CST
-	   || current_class_type == NULL_TREE)
-    return pending_virtuals;
-  else if (debug_vbase && TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
-    {
-      /* Need an entry in some other virtual function table.
-         Deal with this after we have laid out our virtual base classes.  */
-      pending_hard_virtuals = temp_tree_cons (x, vfn, pending_hard_virtuals);
-    }
-  else
-    {
-      /* Need an entry in some other virtual function table.
-         We can do this now.  */
-      tree base_fndecl_list = DECL_VINDEX (x), base_fndecls, prev = 0;
-      tree vtable_context = DECL_FCONTEXT (CLASSTYPE_VFIELD (current_class_type));
-      tree true_base_fndecl = 0;
-
-      /* First assign DECL_VINDEX from the base vfn with which
-	 we share our vtable.  */
-      base_fndecls = base_fndecl_list;
-      while (base_fndecls)
-	{
-	  if (TREE_CHAIN (base_fndecls) == NULL_TREE
-	      || DECL_FCONTEXT (CLASSTYPE_VFIELD (DECL_CLASS_CONTEXT (TREE_VALUE (base_fndecls)))) == vtable_context)
-	    {
-	      true_base_fndecl = TREE_VALUE (base_fndecls);
-	      modify_vtable_entries (current_class_type, x,
-				     true_base_fndecl, vfn);
-	      if (prev)
-		TREE_CHAIN (prev) = TREE_CHAIN (base_fndecls);
-	      else
-		base_fndecl_list = prev;
-	      break;
-	    }
-	  prev = base_fndecls;
-	  base_fndecls = TREE_CHAIN (base_fndecls);
-	}
-
-      /* Now fill in the rest of the vtables.  */
-      base_fndecls = base_fndecl_list;
-      while (base_fndecls)
-	{
-	  /* If we haven't found one we like, first one wins.  */
-	  if (true_base_fndecl == 0)
-	    true_base_fndecl = TREE_VALUE (base_fndecls);
-
-	  modify_vtable_entries (current_class_type, x,
-				 TREE_VALUE (base_fndecls), vfn);
-	  base_fndecls = TREE_CHAIN (base_fndecls);
-	}
-
-      DECL_CONTEXT (x) = DECL_CONTEXT (true_base_fndecl);
-    }
-  return pending_virtuals;
-}
-
-/* Obstack on which to build the vector of class methods.  */
-struct obstack class_obstack;
-extern struct obstack *current_obstack;
-
-/* Add method METHOD to class TYPE.  This is used when a method
-   has been defined which did not initially appear in the class definition,
-   and helps cut down on spurious error messages.
-
-   FIELDS is the entry in the METHOD_VEC vector entry of the class type where
-   the method should be added.  */
-void
-add_method (type, fields, method)
-     tree type, *fields, method;
-{
-  /* We must make a copy of METHOD here, since we must be sure that
-     we have exclusive title to this method's DECL_CHAIN.  */
-  tree decl;
-
-  push_obstacks (&permanent_obstack, &permanent_obstack);
-  {
-    decl = copy_node (method);
-    if (DECL_RTL (decl) == 0
-        && (!processing_template_decl
-            || !uses_template_parms (decl)))
-      {
-	make_function_rtl (decl);
-	DECL_RTL (method) = DECL_RTL (decl);
-      }
-  }
-
-  if (fields && *fields)
-    {
-      /* Take care not to hide destructor.  */
-      DECL_CHAIN (decl) = DECL_CHAIN (*fields);
-      DECL_CHAIN (*fields) = decl;
-    }
-  else if (CLASSTYPE_METHOD_VEC (type) == 0)
-    {
-      tree method_vec = make_node (TREE_VEC);
-      if (TYPE_IDENTIFIER (type) == DECL_NAME (decl))
-	{
-	  TREE_VEC_ELT (method_vec, 0) = decl;
-	  TREE_VEC_LENGTH (method_vec) = 1;
-	}
-      else
-	{
-	  /* ??? Is it possible for there to have been enough room in the
-	     current chunk for the tree_vec structure but not a tree_vec
-	     plus a tree*?  Will this work in that case?  */
-	  obstack_free (current_obstack, method_vec);
-	  obstack_blank (current_obstack, sizeof (struct tree_vec) + sizeof (tree *));
-	  TREE_VEC_ELT (method_vec, 1) = decl;
-	  TREE_VEC_LENGTH (method_vec) = 2;
-	  obstack_finish (current_obstack);
-	}
-      CLASSTYPE_METHOD_VEC (type) = method_vec;
-    }
-  else
-    {
-      tree method_vec = CLASSTYPE_METHOD_VEC (type);
-      int len = TREE_VEC_LENGTH (method_vec);
-
-      /* Adding a new ctor or dtor.  This is easy because our
-         METHOD_VEC always has a slot for such entries.  */
-      if (TYPE_IDENTIFIER (type) == DECL_NAME (decl))
-	{
-	  /* TREE_VEC_ELT (method_vec, 0) = decl; */
-	  if (decl != TREE_VEC_ELT (method_vec, 0))
-	    {
-	      DECL_CHAIN (decl) = TREE_VEC_ELT (method_vec, 0);
-	      TREE_VEC_ELT (method_vec, 0) = decl;
-	    }
-	}
-      else
-	{
-	  /* This is trickier.  We try to extend the TREE_VEC in-place,
-	     but if that does not work, we copy all its data to a new
-	     TREE_VEC that's large enough.  */
-	  struct obstack *ob = &class_obstack;
-	  tree *end = (tree *)obstack_next_free (ob);
-
-	  if (end != TREE_VEC_END (method_vec))
-	    {
-	      ob = current_obstack;
-	      TREE_VEC_LENGTH (method_vec) += 1;
-	      TREE_VEC_ELT (method_vec, len) = NULL_TREE;
-	      method_vec = copy_node (method_vec);
-	      TREE_VEC_LENGTH (method_vec) -= 1;
-	    }
-	  else
-	    {
-	      tree tmp_vec = (tree) obstack_base (ob);
-	      if (obstack_room (ob) < sizeof (tree))
-		{
-		  obstack_blank (ob, sizeof (struct tree_common)
-				 + tree_code_length[(int) TREE_VEC]
-				   * sizeof (char *)
-				 + len * sizeof (tree));
-		  tmp_vec = (tree) obstack_base (ob);
-		  bcopy (method_vec, tmp_vec,
-			 (sizeof (struct tree_common)
-			  + tree_code_length[(int) TREE_VEC] * sizeof (char *)
-			  + (len-1) * sizeof (tree)));
-		  method_vec = tmp_vec;
-		}
-	      else
-		obstack_blank (ob, sizeof (tree));
-	    }
-
-	  obstack_finish (ob);
-	  TREE_VEC_ELT (method_vec, len) = decl;
-	  TREE_VEC_LENGTH (method_vec) = len + 1;
-	  CLASSTYPE_METHOD_VEC (type) = method_vec;
-
-	  if (TYPE_BINFO_BASETYPES (type) && CLASSTYPE_BASELINK_VEC (type))
-	    {
-	      /* ??? May be better to know whether these can be extended?  */
-	      tree baselink_vec = CLASSTYPE_BASELINK_VEC (type);
-
-	      TREE_VEC_LENGTH (baselink_vec) += 1;
-	      CLASSTYPE_BASELINK_VEC (type) = copy_node (baselink_vec);
-	      TREE_VEC_LENGTH (baselink_vec) -= 1;
-
-	      TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), len) = 0;
-	    }
-	}
-    }
-  DECL_CONTEXT (decl) = type;
-  DECL_CLASS_CONTEXT (decl) = type;
-
-  pop_obstacks ();
-}
-
-/* Subroutines of finish_struct.  */
-
-/* Look through the list of fields for this struct, deleting
-   duplicates as we go.  This must be recursive to handle
-   anonymous unions.
-
-   FIELD is the field which may not appear anywhere in FIELDS.
-   FIELD_PTR, if non-null, is the starting point at which
-   chained deletions may take place.
-   The value returned is the first acceptable entry found
-   in FIELDS.
-
-   Note that anonymous fields which are not of UNION_TYPE are
-   not duplicates, they are just anonymous fields.  This happens
-   when we have unnamed bitfields, for example.  */
-static tree
-delete_duplicate_fields_1 (field, field_ptr, fields)
-     tree field, *field_ptr, fields;
-{
-  tree x;
-  tree prev = field_ptr ? *field_ptr : 0;
-  if (DECL_NAME (field) == 0)
-    {
-      if (TREE_CODE (TREE_TYPE (field)) != UNION_TYPE)
-	return fields;
-
-      for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x))
-	fields = delete_duplicate_fields_1 (x, field_ptr, fields);
-      if (prev)
-	TREE_CHAIN (prev) = fields;
-      return fields;
-    }
-  else
-    {
-      for (x = fields; x; prev = x, x = TREE_CHAIN (x))
-	{
-	  if (DECL_NAME (x) == 0)
-	    {
-	      if (TREE_CODE (TREE_TYPE (x)) != UNION_TYPE)
-		continue;
-	      TYPE_FIELDS (TREE_TYPE (x))
-		= delete_duplicate_fields_1 (field, (tree *)0, TYPE_FIELDS (TREE_TYPE (x)));
-	      if (TYPE_FIELDS (TREE_TYPE (x)) == 0)
-		{
-		  if (prev == 0)
-		    fields = TREE_CHAIN (fields);
-		  else
-		    TREE_CHAIN (prev) = TREE_CHAIN (x);
-		}
-	    }
-	  else
-	    {
-	      if (DECL_NAME (field) == DECL_NAME (x))
-		{
-		  if (TREE_CODE (field) == CONST_DECL
-		      && TREE_CODE (x) == CONST_DECL)
-		    error_with_decl (x, "duplicate enum value `%s'");
-		  else if (TREE_CODE (field) == CONST_DECL
-			   || TREE_CODE (x) == CONST_DECL)
-		    error_with_decl (x, "duplicate field `%s' (as enum and non-enum)");
-		  else if (TREE_CODE (field) == TYPE_DECL
-			   && TREE_CODE (x) == TYPE_DECL)
-		    error_with_decl (x, "duplicate class scope type `%s'");
-		  else if (TREE_CODE (field) == TYPE_DECL
-			   || TREE_CODE (x) == TYPE_DECL)
-		    error_with_decl (x, "duplicate field `%s' (as type and non-type)");
-		  else
-		    error_with_decl (x, "duplicate member `%s'");
-		  if (prev == 0)
-		    fields = TREE_CHAIN (fields);
-		  else
-		    TREE_CHAIN (prev) = TREE_CHAIN (x);
-		}
-	    }
-	}
-    }
-  return fields;
-}
-
-static void
-delete_duplicate_fields (fields)
-     tree fields;
-{
-  tree x;
-  for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x))
-    TREE_CHAIN (x) = delete_duplicate_fields_1 (x, &x, TREE_CHAIN (x));
-}
-
-/* Change the visibility of T::FDECL to VISIBILITY.
-   Return 1 if change was legit, otherwise return 0.  */
-static int
-alter_visibility (t, fdecl, visibility)
-     tree t;
-     tree fdecl;
-     enum visibility_type visibility;
-{
-  tree elem = purpose_member (t, DECL_VISIBILITY (fdecl));
-  if (elem && TREE_VALUE (elem) != (tree)visibility)
-    {
-      if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
-	{
-	  error_with_decl (TREE_TYPE (fdecl), "conflicting visibility specifications for method `%s', ignored");
-	}
-      else error ("conflicting visibility specifications for field `%s', ignored", IDENTIFIER_POINTER (DECL_NAME (fdecl)));
-    }
-  else if (TREE_PRIVATE (fdecl) && visibility != visibility_private)
-    error_with_decl (fdecl, "cannot make private `%s' non-private");
-  else if (TREE_PROTECTED (fdecl) && visibility == visibility_public)
-    error_with_decl (fdecl, "cannot make protected `%s' public");
-  /* ARM 11.3: an access declaration may not be used to restrict access
-     to a member that is accessible in the base class.  */
-  else if (TREE_PUBLIC (fdecl)
-	   && (visibility == visibility_private
-	       || visibility == visibility_protected))
-    error_with_decl (fdecl, "cannot reduce visibility of public member `%s'");
-  else if (elem == NULL_TREE)
-    {
-      DECL_VISIBILITY (fdecl) = tree_cons (t, (tree)visibility,
-					   DECL_VISIBILITY (fdecl));
-      return 1;
-    }
-  return 0;
-}
-
-static tree
-get_vfield_offset (binfo)
-     tree binfo;
-{
-  return size_binop (PLUS_EXPR,
-		     DECL_FIELD_BITPOS (CLASSTYPE_VFIELD (BINFO_TYPE (binfo))),
-		     BINFO_OFFSET (binfo));
-}
-
-/* If FOR_TYPE needs to reinitialize virtual function table pointers
-   for TYPE's sub-objects, add such reinitializations to BASE_INIT_LIST.
-   Returns BASE_INIT_LIST appropriately modified.  */
-
-static tree
-maybe_fixup_vptrs (for_type, binfo, base_init_list)
-     tree for_type, binfo, base_init_list;
-{
-  /* Now reinitialize any slots that don't fall under our virtual
-     function table pointer.  */
-  tree vfields = CLASSTYPE_VFIELDS (BINFO_TYPE (binfo));
-  while (vfields)
-    {
-      tree base_binfo = get_binfo (VF_BASETYPE_VALUE (vfields), for_type, 0);
-      if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (VF_BASETYPE_VALUE (vfields)))
-	{
-	  tree base_offset = get_vfield_offset (base_binfo);
-	  if (! tree_int_cst_equal (base_offset, get_vfield_offset (TYPE_BINFO (for_type)))
-	      && ! tree_int_cst_equal (base_offset, get_vfield_offset (binfo)))
-	    base_init_list = tree_cons (error_mark_node, base_binfo,
-					base_init_list);
-	}
-      vfields = TREE_CHAIN (vfields);
-    }
-  return base_init_list;
-}
-
-/* If TYPE does not have a constructor, then the compiler must
-   manually deal with all of the initialization this type requires.
-
-   If a base initializer exists only to fill in the virtual function
-   table pointer, then we mark that fact with the TREE_VIRTUAL bit.
-   This way, we avoid multiple initializations of the same field by
-   each virtual function table up the class hierarchy.
-
-   Virtual base class pointers are not initialized here.  They are
-   initialized only at the "top level" of object creation.  If we
-   initialized them here, we would have to skip a lot of work.  */
-
-static void
-build_class_init_list (type)
-     tree type;
-{
-  tree base_init_list = NULL_TREE;
-  tree member_init_list = NULL_TREE;
-
-  /* Since we build member_init_list and base_init_list using
-     tree_cons, backwards fields the all through work.  */
-  tree x;
-  tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
-  int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  for (x = TYPE_FIELDS (type); x; x = TREE_CHAIN (x))
-    {
-      if (TREE_CODE (x) != FIELD_DECL)
-	continue;
-
-      if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (x))
-	  || DECL_INITIAL (x) != NULL_TREE)
-	member_init_list = tree_cons (x, type, member_init_list);
-    }
-  member_init_list = nreverse (member_init_list);
-
-  /* We will end up doing this last.  Need special marker
-     to avoid infinite regress.  */
-  if (TYPE_VIRTUAL_P (type))
-    {
-      base_init_list = build_tree_list (error_mark_node, TYPE_BINFO (type));
-      if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (type) == 0)
-	TREE_VALUE (base_init_list) = NULL_TREE;
-      TREE_ADDRESSABLE (base_init_list) = 1;
-    }
-
-  /* Each base class which needs to have initialization
-     of some kind gets to make such requests known here.  */
-  for (i = n_baseclasses-1; i >= 0; i--)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-      tree blist;
-
-      /* Don't initialize virtual baseclasses this way.  */
-      if (TREE_VIA_VIRTUAL (base_binfo))
-	continue;
-
-      if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo)))
-	{
-	  /* ...and the last shall come first...  */
-	  base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
-	  base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
-	  continue;
-	}
-
-      if ((blist = CLASSTYPE_BASE_INIT_LIST (BINFO_TYPE (base_binfo))) == NULL_TREE)
-	/* Nothing to initialize.  */
-	continue;
-
-      /* ...ditto...  */
-      base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
-
-      /* This is normally true for single inheritance.
-	 The win is we can shrink the chain of initializations
-	 to be done by only converting to the actual type
-	 we are interested in.  */
-      if (TREE_VALUE (blist)
-	  && TREE_CODE (TREE_VALUE (blist)) == TREE_VEC
-	  && tree_int_cst_equal (BINFO_OFFSET (base_binfo),
-				 BINFO_OFFSET (TREE_VALUE (blist))))
-	{
-	  if (base_init_list)
-	    {
-	      /* Does it do more than just fill in a
-		 virtual function table pointer?  */
-	      if (! TREE_ADDRESSABLE (blist))
-		base_init_list = build_tree_list (blist, base_init_list);
-	      /* Can we get by just with the virtual function table
-		 pointer that it fills in?  */
-	      else if (TREE_ADDRESSABLE (base_init_list)
-		       && TREE_VALUE (base_init_list) == 0)
-		base_init_list = blist;
-	      /* Maybe, but it is not obvious as the previous case.  */
-	      else if (! CLASSTYPE_NEEDS_VIRTUAL_REINIT (type))
-		{
-		  tree last = tree_last (base_init_list);
-		  while (TREE_VALUE (last)
-			 && TREE_CODE (TREE_VALUE (last)) == TREE_LIST)
-		    last = tree_last (TREE_VALUE (last));
-		  if (TREE_VALUE (last) == 0)
-		    base_init_list = build_tree_list (blist, base_init_list);
-		}
-	    }
-	  else
-	    base_init_list = blist;
-	}
-      else
-	{
-	  /* The function expand_aggr_init knows how to do the
-	     initialization of `basetype' without getting
-	     an explicit `blist'.  */
-	  if (base_init_list)
-	    base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
-	  else
-	    base_init_list = CLASSTYPE_BINFO_AS_LIST (BINFO_TYPE (base_binfo));
-	}
-    }
-
-  if (base_init_list)
-    if (member_init_list)
-      CLASSTYPE_BASE_INIT_LIST (type) = build_tree_list (base_init_list, member_init_list);
-    else
-      CLASSTYPE_BASE_INIT_LIST (type) = base_init_list;
-  else if (member_init_list)
-    CLASSTYPE_BASE_INIT_LIST (type) = member_init_list;
-}
-
-struct base_info
-{
-  int has_virtual;
-  int max_has_virtual;
-  int n_ancestors;
-  tree vfield;
-  tree vfields;
-  char needs_default_ctor;
-  char cant_have_default_ctor;
-  char needs_const_ctor;
-  char cant_have_const_ctor;
-  char members_need_dtors;
-  char needs_virtual_dtor;
-};
-
-/* Record information about type T derived from its base classes.
-   Store most of that information in T itself, and place the
-   remaining information in the struct BASE_INFO.
-
-   Propagate basetype offsets throughout the lattice.  Note that the
-   lattice topped by T is really a pair: it's a DAG that gives the
-   structure of the derivation hierarchy, and it's a list of the
-   virtual baseclasses that appear anywhere in the DAG.  When a vbase
-   type appears in the DAG, it's offset is 0, and it's children start
-   their offsets from that point.  When a vbase type appears in the list,
-   its offset is the offset it has in the hierarchy, and its children's
-   offsets include that offset in theirs.
-
-   Returns the index of the first base class to have virtual functions,
-   or zero if no such base class.  */
-
-static int
-finish_base_struct (t, b, binfos)
-     tree t;
-     struct base_info *b;
-     tree binfos;
-{
-  int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-  int first_vfn_base_index = -1;
-  bzero (b, sizeof (struct base_info));
-
-  for (i = 0; i < n_baseclasses; i++)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-      tree basetype = BINFO_TYPE (base_binfo);
-
-      /* If the type of basetype is incomplete, then
-	 we already complained about that fact
-	 (and we should have fixed it up as well).  */
-      if (TYPE_SIZE (basetype) == 0)
-	{
-	  int j;
-	  /* The base type is of incomplete type.  It is
-	     probably best to pretend that it does not
-	     exist.  */
-	  if (i == n_baseclasses-1)
-	    TREE_VEC_ELT (binfos, i) = NULL_TREE;
-	  TREE_VEC_LENGTH (binfos) -= 1;
-	  n_baseclasses -= 1;
-	  for (j = i; j+1 < n_baseclasses; j++)
-	    TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
-	}
-
-      if (TYPE_NEEDS_DESTRUCTOR (basetype))
-	b->members_need_dtors = 1;
-      if (TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
-	b->needs_default_ctor = 1;
-      else if (TYPE_HAS_CONSTRUCTOR (basetype))
-	b->cant_have_default_ctor = 1;
-      if (TYPE_GETS_CONST_INIT_REF (basetype))
-	b->needs_const_ctor = 1;
-      else if (TYPE_GETS_INIT_REF (basetype))
-	b->cant_have_const_ctor = 1;
-
-      CLASSTYPE_ALTERS_VISIBILITIES_P (t)
-	|= CLASSTYPE_ALTERS_VISIBILITIES_P (basetype);
-
-      b->n_ancestors += CLASSTYPE_N_SUPERCLASSES (basetype);
-      TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
-      TYPE_NEEDS_CONSTRUCTOR (t) |= TYPE_NEEDS_CONSTRUCTOR (basetype);
-      TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (basetype);
-      TYPE_GETS_ASSIGNMENT (t) |= TYPE_GETS_ASSIGNMENT (basetype);
-      TYPE_GETS_INIT_REF (t) |= TYPE_GETS_INIT_REF (basetype);
-
-      TYPE_OVERLOADS_CALL_EXPR (t) |= TYPE_OVERLOADS_CALL_EXPR (basetype);
-      TYPE_OVERLOADS_ARRAY_REF (t) |= TYPE_OVERLOADS_ARRAY_REF (basetype);
-      TYPE_OVERLOADS_ARROW (t) |= TYPE_OVERLOADS_ARROW (basetype);
-
-      if (! TREE_VIA_VIRTUAL (base_binfo)
-#if 0
-	  /* This cannot be done, as prepare_fresh_vtable wants to modify
-	     binfos associated with vfields anywhere in the hierarchy, not
-	     just immediate base classes.  Due to unsharing, the compiler
-	     might consume 3% more memory on a real program.
-	     */
-	  && ! BINFO_OFFSET_ZEROP (base_binfo)
-#endif
-	  && BINFO_BASETYPES (base_binfo))
-	{
-	  tree base_binfos = BINFO_BASETYPES (base_binfo);
-	  tree chain = NULL_TREE;
-	  int j;
-
-	  /* Now unshare the structure beneath BASE_BINFO.  */
-	  for (j = TREE_VEC_LENGTH (base_binfos)-1;
-	       j >= 0; j--)
-	    {
-	      tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
-	      if (! TREE_VIA_VIRTUAL (base_base_binfo))
-		TREE_VEC_ELT (base_binfos, j)
-		  = make_binfo (BINFO_OFFSET (base_base_binfo),
-				BINFO_TYPE (base_base_binfo),
-				BINFO_VTABLE (base_base_binfo),
-				BINFO_VIRTUALS (base_base_binfo),
-				chain);
-	      chain = TREE_VEC_ELT (base_binfos, j);
-	      TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
-	      TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
-	    }
-
-	  /* Completely unshare potentially shared data, and
-	     update what is ours.  */
-	  propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
-	}
-
-      if (! TREE_VIA_VIRTUAL (base_binfo))
-	CLASSTYPE_N_SUPERCLASSES (t) += 1;
-
-      if (TYPE_VIRTUAL_P (basetype))
-	{
-	  /* If there's going to be a destructor needed, make
-	     sure it will be virtual.  */
-	  b->needs_virtual_dtor = 1;
-
-	  /* Don't borrow virtuals from virtual baseclasses.  */
-	  if (TREE_VIA_VIRTUAL (base_binfo))
-	    continue;
-
-	  if (first_vfn_base_index < 0)
-	    {
-	      first_vfn_base_index = i;
-
-	      b->has_virtual = CLASSTYPE_VSIZE (basetype);
-	      b->vfield = CLASSTYPE_VFIELD (basetype);
-	      b->vfields = CLASSTYPE_VFIELDS (basetype);
-	      CLASSTYPE_VFIELD (t) = b->vfield;
-	    }
-	  else
-	    {
-	      /* Only add unique vfields, and flatten them out as we go.  */
-	      tree vfields = CLASSTYPE_VFIELDS (basetype);
-	      while (vfields)
-		{
-		  if (VF_BINFO_VALUE (vfields) == NULL_TREE
-		      || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
-		    {
-		      tree value = VF_BASETYPE_VALUE (vfields);
-		      b->vfields = tree_cons (base_binfo, value, b->vfields);
-		      if (DECL_NAME (CLASSTYPE_VFIELD (value))
-			  == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
-			VF_NORMAL_VALUE (b->vfields) = basetype;
-		      else
-			VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
-		    }
-		  vfields = TREE_CHAIN (vfields);
-		}
-
-	      if (b->has_virtual == 0)
-		{
-		  first_vfn_base_index = i;
-		  b->has_virtual = CLASSTYPE_VSIZE (basetype);
-		  b->vfield = CLASSTYPE_VFIELD (basetype);
-		  CLASSTYPE_VFIELD (t) = b->vfield;
-		}
-	    }
-	}
-    }
-
-  {
-    tree vfields;
-    /* Find the base class with the largest number of virtual functions.  */
-    for (vfields = b->vfields; vfields; vfields = TREE_CHAIN (vfields))
-      {
-	if (CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields)) > b->max_has_virtual)
-	  b->max_has_virtual = CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields));
-	if (VF_DERIVED_VALUE (vfields)
-	    && CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields)) > b->max_has_virtual)
-	  b->max_has_virtual = CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields));
-      }
-  }
-
-  if (b->vfield == 0)
-    /* If all virtual functions come only from virtual baseclasses.  */
-    return -1;
-  return first_vfn_base_index;
-}
-
-static int
-typecode_p (type, code)
-     tree type;
-     enum tree_code code;
-{
-  return (TREE_CODE (type) == code
-	  || (TREE_CODE (type) == REFERENCE_TYPE
-	      && TREE_CODE (TREE_TYPE (type)) == code));
-}
-
-/* Set memoizing fields and bits of T (and its variants) for later use.
-   MAX_HAS_VIRTUAL is the largest size of any T's virtual function tables.  */
-static void
-finish_struct_bits (t, max_has_virtual)
-     tree t;
-     int max_has_virtual;
-{
-  int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
-  tree method_vec = CLASSTYPE_METHOD_VEC (t);
-
-  /* Fix up variants (if any).  */
-  tree variants = TYPE_NEXT_VARIANT (t);
-  while (variants)
-    {
-      /* These fields are in the _TYPE part of the node, not in
-	 the TYPE_LANG_SPECIFIC component, so they are not shared.  */
-      TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
-      TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
-      TYPE_NEEDS_CONSTRUCTOR (variants) = TYPE_NEEDS_CONSTRUCTOR (t);
-      TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
-      TYPE_NEEDS_DESTRUCTOR (variants) = TYPE_NEEDS_DESTRUCTOR (t);
-
-      TYPE_USES_COMPLEX_INHERITANCE (variants) = TYPE_USES_COMPLEX_INHERITANCE (t);
-      TYPE_VIRTUAL_P (variants) = TYPE_VIRTUAL_P (t);
-      TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
-      /* Copy whatever these are holding today.  */
-      TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
-      TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
-      variants = TYPE_NEXT_VARIANT (variants);
-    }
-
-  if (n_baseclasses && max_has_virtual)
-    {
-      /* Done by `finish_struct' for classes without baseclasses.  */
-      int has_abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (t) != 0;
-      tree binfos = TYPE_BINFO_BASETYPES (t);
-      for (i = n_baseclasses-1; i >= 0; i--)
-	{
-	  has_abstract_virtuals
-	    |= (CLASSTYPE_ABSTRACT_VIRTUALS (BINFO_TYPE (TREE_VEC_ELT (binfos, i))) != 0);
-	  if (has_abstract_virtuals)
-	    break;
-	}
-      if (has_abstract_virtuals)
-	CLASSTYPE_ABSTRACT_VIRTUALS (t) = get_abstract_virtuals (t);
-    }
-
-  if (n_baseclasses)
-    {
-      /* Notice whether this class has type conversion functions defined.
-	 Also report whether joining two types yields an ambiguity in the
-	 virtual function table, e.g.,
-	 
-	 struct A { virtual int f (); };
-	 struct B { virtual int f (); };
-	 struct C : A, B { / * no f (); * / };	/ / error, ambiguous
-	 */
-      tree binfo = TYPE_BINFO (t);
-      tree binfos = BINFO_BASETYPES (binfo);
-      int n_binfos = list_length (binfo);
-      tree vbases = CLASSTYPE_VBASECLASSES (t), basetype;
-      int n_vbases = list_length (vbases), j;
-
-      build_mi_virtuals (n_binfos+n_vbases*n_baseclasses, max_has_virtual);
-      /* Fill in virtual function table with values which do not come
-	 "normal"ly, i.e., those which come from virtual and/or
-	 non-leftmost base classes.  */
-      for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
-	{
-	  if (TREE_VIA_VIRTUAL (binfo))
-	    /* Virtual functions from virtual baseclasses are done below.  */;
-	  else if (CLASSTYPE_VSIZE (BINFO_TYPE (binfo)))
-	    {
-	      tree virtuals = TREE_CHAIN (BINFO_VIRTUALS (binfo));
-	      if (flag_dossier)
-		virtuals = TREE_CHAIN (virtuals);
-	      add_mi_virtuals (++i, virtuals);
-	    }
-	}
-      for (; vbases; vbases = TREE_CHAIN (vbases))
-	{
-	  basetype = BINFO_TYPE (vbases);
-	  if (CLASSTYPE_VSIZE (basetype))
-	    for (j = n_baseclasses-1; j >= 0; j--)
-	      {
-		tree this_binfo = TREE_VEC_ELT (binfos, j);
-		if (UNIQUELY_DERIVED_FROM_P (basetype, this_binfo))
-		  {
-		    tree virtuals = TREE_CHAIN (BINFO_VIRTUALS (vbases));
-		    if (flag_dossier)
-		      virtuals = TREE_CHAIN (virtuals);
-		    add_mi_virtuals (++i, virtuals);
-		  }
-	      }
-	}
-      for (i = n_baseclasses-1; i >= 0; i--)
-	{
-	  basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
-
-	  if (TYPE_HAS_CONVERSION (basetype))
-	    {
-	      TYPE_HAS_CONVERSION (t) = 1;
-	      TYPE_HAS_INT_CONVERSION (t) |= TYPE_HAS_INT_CONVERSION (basetype);
-	      TYPE_HAS_REAL_CONVERSION (t) |= TYPE_HAS_REAL_CONVERSION (basetype);
-	    }
-	  if (CLASSTYPE_MAX_DEPTH (basetype) >= CLASSTYPE_MAX_DEPTH (t))
-	    CLASSTYPE_MAX_DEPTH (t) = CLASSTYPE_MAX_DEPTH (basetype) + 1;
-	}
-      report_ambiguous_mi_virtuals (n_binfos+n_vbases*n_baseclasses, t);
-#if 0
-      /* Now that we know what the virtual function table looks like,
-	 fix up offsets in the presence of virtual base classes.  */
-      if (n_vbases)
-	fixup_vbase_offsets (t);
-#endif
-    }
-
-  /* Need to test METHOD_VEC here in case all methods
-     (conversions and otherwise) are inherited.  */
-  if (TYPE_HAS_CONVERSION (t) && method_vec != NULL_TREE)
-    {
-      tree first_conversions[last_conversion_type];
-      tree last_conversions[last_conversion_type];
-      enum conversion_type conv_index;
-      tree *tmp;
-      int i;
-
-      bzero (first_conversions, sizeof (first_conversions));
-      bzero (last_conversions, sizeof (last_conversions));
-      for (tmp = &TREE_VEC_ELT (method_vec, 1);
-	   tmp != TREE_VEC_END (method_vec); tmp += 1)
-	{
-	  /* ??? This should compare DECL_NAME (*tmp) == ansi_opname[TYPE_EXPR].  */
-	  if (IDENTIFIER_TYPENAME_P (DECL_ASSEMBLER_NAME (*tmp)))
-	    {
-	      tree fntype = TREE_TYPE (*tmp);
-	      tree return_type = TREE_TYPE (fntype);
-	      my_friendly_assert (TREE_CODE (fntype) == METHOD_TYPE, 171);
-
-	      if (typecode_p (return_type, POINTER_TYPE))
-		{
-		  if (TYPE_READONLY (TREE_TYPE (return_type)))
-		    conv_index = constptr_conv;
-		  else
-		    conv_index = ptr_conv;
-		}
-	      else if (typecode_p (return_type, INTEGER_TYPE))
-		{
-		  TYPE_HAS_INT_CONVERSION (t) = 1;
-		  conv_index = int_conv;
-		}
-	      else if (typecode_p (return_type, REAL_TYPE))
-		{
-		  TYPE_HAS_REAL_CONVERSION (t) = 1;
-		  conv_index = real_conv;
-		}
-	      else
-		continue;
-
-	      if (first_conversions[(int) conv_index] == NULL_TREE)
-		first_conversions[(int) conv_index] = *tmp;
-	      last_conversions[(int) conv_index] = *tmp;
-	    }
-	}
-
-      for (i = 0; i < (int) last_conversion_type; i++)
-	if (first_conversions[i] != last_conversions[i])
-	  CLASSTYPE_CONVERSION (t, i) = error_mark_node;
-	else
-	  CLASSTYPE_CONVERSION (t, i) = first_conversions[i];
-    }
-
-  /* If this type has constructors, force its mode to be BLKmode,
-     and force its TREE_ADDRESSABLE bit to be nonzero.  */
-  if (TYPE_NEEDS_CONSTRUCTING (t) || TYPE_NEEDS_DESTRUCTOR (t))
-    {
-      tree variants = t;
-
-      if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
-	DECL_MODE (TYPE_NAME (t)) = BLKmode;
-      while (variants)
-	{
-	  TYPE_MODE (variants) = BLKmode;
-	  TREE_ADDRESSABLE (variants) = 1;
-	  variants = TYPE_NEXT_VARIANT (variants);
-	}
-    }
-}
-
-/* Warn about duplicate methods in fn_fields.  Also compact method
-   lists so that lookup can be made faster.
-
-   Algorithm: Outer loop builds lists by method name.  Inner loop
-   checks for redundant method names within a list.
-
-   Data Structure: List of method lists.  The outer list is a
-   TREE_LIST, whose TREE_PURPOSE field is the field name and the
-   TREE_VALUE is the TREE_CHAIN of the FUNCTION_DECLs.  Friends are
-   chained in the same way as member functions, but they live in the
-   TREE_TYPE field of the outer list.  That allows them to be quickly
-   deleted, and requires no extra storage.
-
-   If there are any constructors/destructors, they are moved to the
-   front of the list.  This makes pushclass more efficient.
-
-   We also link each field which has shares a name with its baseclass
-   to the head of the list of fields for that base class.  This allows
-   us to reduce search time in places like `build_method_call' to
-   consider only reasonably likely functions.  */
-
-static tree
-finish_struct_methods (t, fn_fields, nonprivate_method)
-     tree t;
-     tree fn_fields;
-     int nonprivate_method;
-{
-  tree method_vec;
-  tree name = constructor_name (t);
-  int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
-
-  /* Now prepare to gather fn_fields into vector.  */
-  struct obstack *ambient_obstack = current_obstack;
-  current_obstack = &class_obstack;
-  method_vec = make_node (TREE_VEC);
-  /* Room has been saved for constructors and destructors.  */
-  current_obstack = ambient_obstack;
-  /* Now make this a live vector.  */
-  obstack_free (&class_obstack, method_vec);
-  obstack_blank (&class_obstack, sizeof (struct tree_vec));
-
-  while (fn_fields)
-    {
-      /* NEXT Pointer, TEST Pointer, and BASE Pointer.  */
-      tree nextp, *testp;
-      tree fn_name = DECL_NAME (fn_fields);
-      if (fn_name == NULL_TREE)
-	fn_name = name;
-
-      nextp = TREE_CHAIN (fn_fields);
-      TREE_CHAIN (fn_fields) = NULL_TREE;
-      /* Constructors are handled easily in search routines.
-	 Besides, we know we won't find any, so do not bother looking.  */
-      if (fn_name == name && TREE_VEC_ELT (method_vec, 0) == 0)
-	TREE_VEC_ELT (method_vec, 0) = fn_fields;
-      else
-	{
-	  testp = &TREE_VEC_ELT (method_vec, 0);
-	  if (*testp == NULL_TREE)
-	    testp++;
-	  while (((HOST_WIDE_INT) testp
-		  < (HOST_WIDE_INT) obstack_next_free (&class_obstack))
-		 && DECL_NAME (*testp) != fn_name)
-	    testp++;
-	  if ((HOST_WIDE_INT) testp
-	      < (HOST_WIDE_INT) obstack_next_free (&class_obstack))
-	    {
-	      tree x, prev_x;
-
-	      for (x = *testp; x; x = DECL_CHAIN (x))
-		{
-		  if (DECL_NAME (fn_fields) == ansi_opname[(int) DELETE_EXPR])
-		    {
-		      /* ANSI C++ June 5 1992 WP 12.5.5.1 */
-		      error_with_decl (fn_fields, "operator delete cannot be overloaded");
-		      error_with_decl (x, "previous declaration here");
-		    }
-		  if (DECL_ASSEMBLER_NAME (fn_fields) == DECL_ASSEMBLER_NAME (x))
-		    {
-		      /* We complain about multiple destructors on sight,
-			 so we do not repeat the warning here.  Friend-friend
-			 ambiguities are warned about outside this loop.  */
-		      if (! DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fn_fields)))
-			error_with_file_and_line (DECL_SOURCE_FILE (fn_fields),
-						  DECL_SOURCE_LINE (fn_fields),
-						  "ambiguous method `%s' in structure",
-						  lang_printable_name (fn_fields));
-		      break;
-		    }
-		  prev_x = x;
-		}
-	      if (x == 0)
-		if (*testp)
-		  DECL_CHAIN (prev_x) = fn_fields;
-		else
-		  *testp = fn_fields;
-	    }
-	  else
-	    {
-	      obstack_ptr_grow (&class_obstack, fn_fields);
-	      method_vec = (tree)obstack_base (&class_obstack);
-	    }
-	}
-      fn_fields = nextp;
-    }
-
-  TREE_VEC_LENGTH (method_vec)
-    = (tree *)obstack_next_free (&class_obstack) - (&TREE_VEC_ELT (method_vec, 0));
-  obstack_finish (&class_obstack);
-  CLASSTYPE_METHOD_VEC (t) = method_vec;
-
-  if (nonprivate_method == 0
-      && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
-      && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
-    {
-      tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
-      for (i = 0; i < n_baseclasses; i++)
-	if (TREE_VIA_PUBLIC (TREE_VEC_ELT (binfos, i))
-	    || TREE_VIA_PROTECTED (TREE_VEC_ELT (binfos, i)))
-	  {
-	    nonprivate_method = 1;
-	    break;
-	  }
-      if (nonprivate_method == 0)
-	warning ("all member functions in class `%s' are private",
-		 TYPE_NAME_STRING (t));
-    }
-
-  /* If there are constructors (and destructors), they are at the
-     front.  Place destructors at very front.  Also warn if all
-     constructors and/or destructors are private (in which case this
-     class is effectively unusable.  */
-  if (TYPE_HAS_DESTRUCTOR (t))
-    {
-      tree dtor, prev;
-
-      for (dtor = TREE_VEC_ELT (method_vec, 0); dtor; prev = dtor, dtor = DECL_CHAIN (dtor))
-	{
-	  if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (dtor)))
-	    {
-	      if (TREE_PRIVATE (dtor)
-		  && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
-		  && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
-		warning_with_decl (TYPE_NAME (t), "class `%s' only defines a private destructor and has no friends");
-	      break;
-	    }
-	}
-      /* Wild parse errors can cause this to happen.  */
-      if (dtor == NULL_TREE)
-	TYPE_HAS_DESTRUCTOR (t) = 0;
-      else if (dtor != TREE_VEC_ELT (method_vec, 0))
-	{
-	  DECL_CHAIN (prev) = DECL_CHAIN (dtor);
-	  DECL_CHAIN (dtor) = TREE_VEC_ELT (method_vec, 0);
-	  TREE_VEC_ELT (method_vec, 0) = dtor;
-	}
-    }
-
-  /* Now for each member function (except for constructors and
-     destructors), compute where member functions of the same
-     name reside in base classes.  */
-  if (n_baseclasses != 0
-      && TREE_VEC_LENGTH (method_vec) > 1)
-    {
-      int len = TREE_VEC_LENGTH (method_vec);
-      tree baselink_vec = make_tree_vec (len);
-      int any_links = 0;
-      tree baselink_binfo = build_tree_list (NULL_TREE, TYPE_BINFO (t));
-
-      for (i = 1; i < len; i++)
-	{
-	  TREE_VEC_ELT (baselink_vec, i)
-	    = get_baselinks (baselink_binfo, t, DECL_NAME (TREE_VEC_ELT (method_vec, i)));
-	  if (TREE_VEC_ELT (baselink_vec, i) != 0)
-	    any_links = 1;
-	}
-      if (any_links != 0)
-	CLASSTYPE_BASELINK_VEC (t) = baselink_vec;
-      else
-	obstack_free (current_obstack, baselink_vec);
-    }
-
-  /* Now add the methods to the TYPE_METHODS of T, arranged in a chain.  */
-  {
-    tree x, last_x = NULL_TREE;
-    int limit = TREE_VEC_LENGTH (method_vec);
-
-    for (i = 1; i < limit; i++)
-      {
-	for (x = TREE_VEC_ELT (method_vec, i); x; x = DECL_CHAIN (x))
-	  {
-	    if (last_x != NULL_TREE)
-	      TREE_CHAIN (last_x) = x;
-	    last_x = x;
-	  }
-      }
-
-    /* Put ctors and dtors at the front of the list.  */
-    x = TREE_VEC_ELT (method_vec, 0);
-    if (x)
-      {
-	while (DECL_CHAIN (x))
-	  {
-	    /* Let's avoid being circular about this.  */
-	    if (x == DECL_CHAIN (x))
-	      break;
-	    TREE_CHAIN (x) = DECL_CHAIN (x);
-	    x = DECL_CHAIN (x);
-	  }
-	if (TREE_VEC_LENGTH (method_vec) > 1)
-	  TREE_CHAIN (x) = TREE_VEC_ELT (method_vec, 1);
-	else
-	  TREE_CHAIN (x) = NULL_TREE;
-      }
-  }
-
-#if 0
-  TYPE_METHODS (t) = TREE_VEC_ELT (method_vec, 0)
-    ? TREE_VEC_ELT (method_vec, 0) : TREE_VEC_ELT (method_vec, 1);
-#else
-  TYPE_METHODS (t) = method_vec;
-#endif
-
-  return method_vec;
-}
-
-/* Emit error when a duplicate definition of a type is seen.  Patch up. */
-
-void
-duplicate_tag_error (t)
-     tree t;
-{
-  char *err_name;
-  tree name = TYPE_NAME (t);
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-  err_name = IDENTIFIER_POINTER (name);
-  if (TREE_CODE (t) == UNION_TYPE)
-    error ("redefinition of `union %s'", err_name);
-  else if (TREE_CODE (t) == RECORD_TYPE)
-    error ("redefinition of `struct %s'", err_name);
-  else
-    error ("redefinition of tag %s", err_name);
-
-  /* Pretend we haven't defined this type.  */
-
-  /* All of the component_decl's were TREE_CHAINed together in the parser.
-     finish_struct_methods walks these chains and assembles all methods with
-     the same base name into DECL_CHAINs. Now we don't need the parser chains
-     anymore, so we unravel them.
-   */
-  /*
-   * This used to be in finish_struct, but it turns out that the
-   * TREE_CHAIN is used by dbxout_type_methods and perhaps some other things...
-   */
-  if (CLASSTYPE_METHOD_VEC(t)) 
-    {
-      tree tv = CLASSTYPE_METHOD_VEC(t);
-      int i, len  = TREE_VEC_LENGTH (tv);
-      for (i = 0; i < len; i++)
-	{
-	  tree unchain = TREE_VEC_ELT (tv, i);
-	  while(unchain != NULL_TREE) 
-	    {
-	      TREE_CHAIN (unchain) = NULL_TREE;
-	      unchain = DECL_CHAIN(unchain);
-	    }
-	}
-    }
-
-  if (TYPE_LANG_SPECIFIC (t))
-    {
-      tree as_list = CLASSTYPE_AS_LIST (t);
-      tree binfo = TYPE_BINFO (t);
-      tree binfo_as_list = CLASSTYPE_BINFO_AS_LIST (t);
-      int interface_only = CLASSTYPE_INTERFACE_ONLY (t);
-      int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t);
-
-      bzero (TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
-      BINFO_BASETYPES(binfo) = NULL_TREE;
-
-      CLASSTYPE_AS_LIST (t) = as_list;
-      TYPE_BINFO (t) = binfo;
-      CLASSTYPE_BINFO_AS_LIST (t) = binfo_as_list;
-      CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
-      CLASSTYPE_INTERFACE_UNKNOWN (t) = interface_unknown;
-      CLASSTYPE_VBASE_SIZE (t) = integer_zero_node;
-      TYPE_REDEFINED (t) = 1;
-    }
-  TYPE_SIZE (t) = NULL_TREE;
-  TYPE_MODE (t) = VOIDmode;
-  TYPE_FIELDS (t) = NULL_TREE;
-  TYPE_METHODS (t) = NULL_TREE;
-  TYPE_VFIELD (t) = NULL_TREE;
-  TYPE_CONTEXT (t) = NULL_TREE;
-}
-
-/* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
-   (or C++ class declaration).
-
-   For C++, we must handle the building of derived classes.
-   Also, C++ allows static class members.  The way that this is
-   handled is to keep the field name where it is (as the DECL_NAME
-   of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
-   of the field.  layout_record and layout_union will know about this.
-
-   More C++ hair: inline functions have text in their
-   DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
-   meaningful tree structure.  After the struct has been laid out, set
-   things up so that this can happen.
-
-   And still more: virtual functions.  In the case of single inheritance,
-   when a new virtual function is seen which redefines a virtual function
-   from the base class, the new virtual function is placed into
-   the virtual function table at exactly the same address that
-   it had in the base class.  When this is extended to multiple
-   inheritance, the same thing happens, except that multiple virtual
-   function tables must be maintained.  The first virtual function
-   table is treated in exactly the same way as in the case of single
-   inheritance.  Additional virtual function tables have different
-   DELTAs, which tell how to adjust `this' to point to the right thing.
-
-   LIST_OF_FIELDLISTS is just that.  The elements of the list are
-   TREE_LIST elements, whose TREE_PURPOSE field tells what visibility
-   the list has, and the TREE_VALUE slot gives the actual fields.
-
-   If flag_all_virtual == 1, then we lay all functions into
-   the virtual function table, as though they were declared
-   virtual.  Constructors do not lay down in the virtual function table.
-
-   If flag_all_virtual == 2, then we lay all functions into
-   the virtual function table, such that virtual functions
-   occupy a space by themselves, and then all functions
-   of the class occupy a space by themselves.  This is illustrated
-   in the following diagram:
-
-   class A; class B : A;
-
-	Class A's vtbl:			Class B's vtbl:
-    --------------------------------------------------------------------
-   | A's virtual functions|		| B's virtual functions		|
-   |			  |		| (may inherit some from A).	|
-    --------------------------------------------------------------------
-   | All of A's functions |		| All of A's functions		|
-   | (such as a->A::f).	  |		| (such as b->A::f)		|
-    --------------------------------------------------------------------
-					| B's new virtual functions	|
-					| (not defined in A.)		|
-					 -------------------------------
-					| All of B's functions		|
-					| (such as b->B::f)		|
-					 -------------------------------
-
-   this allows the program to make references to any function, virtual
-   or otherwise in a type-consistent manner.  */
-
-tree
-finish_struct (t, list_of_fieldlists, warn_anon)
-     tree t;
-     tree list_of_fieldlists;
-     int warn_anon;
-{
-  extern int interface_only, interface_unknown;
-  int old;
-  int round_up_size = 1;
-  /* Set non-zero to debug using default functions.
-     Not set by program.  */
-  static int debug_default_functions = 0;
-
-  enum tree_code code = TREE_CODE (t);
-  register tree x, last_x, method_vec;
-  int needs_ctor = 0, needs_dtor = 0;
-  int members_need_dtors, needs_virtual_dtor;
-  tree name = TYPE_NAME (t), fields, fn_fields, tail;
-  enum visibility_type visibility;
-  int all_virtual;
-  int has_virtual;
-  int max_has_virtual;
-  tree pending_virtuals = NULL_TREE;
-  tree abstract_virtuals = NULL_TREE;
-  tree vfield;
-  tree vfields;
-  int needs_default_ctor;
-  int cant_have_default_ctor;
-  int needs_const_ctor;
-  int cant_have_const_ctor;
-
-  /* The index of the first base class which has virtual
-     functions.  Only applied to non-virtual baseclasses.  */
-  int first_vfn_base_index;
-
-  int n_baseclasses;
-  int any_default_members = 0;
-  char *err_name;
-  int const_sans_init = 0;
-  int ref_sans_init = 0;
-  int nonprivate_method = 0;
-  tree t_binfo = TYPE_BINFO (t);
-
-  if (TREE_CODE (name) == TYPE_DECL)
-    {
-      extern int lineno;
-
-      DECL_SOURCE_FILE (name) = input_filename;
-      /* For TYPE_DECL that are not typedefs (those marked with a line number
-	 of zero, we don't want to mark them as real typedefs.  If this fails
-	 one needs to make sure real typedefs have a previous line number,
-	 even if it is wrong, that way the below will fill in the right line
-	 number.  (mrs) */
-      if (DECL_SOURCE_LINE (name))
-	DECL_SOURCE_LINE (name) = lineno;
-      name = DECL_NAME (name);
-    }
-  err_name = IDENTIFIER_POINTER (name);
-
-  if (warn_anon && code != UNION_TYPE && ANON_AGGRNAME_P (name))
-    {
-      warning ("un-usable class ignored (anonymous classes and unions are useless)");
-      err_name = "(anon)";
-    }
-
-#if 0
-  /* This is set here, but it's never actually used anywhere.  (bpk) */
-  leftmost_baseclasses = NULL_TREE;
-#endif
-  if (TYPE_SIZE (t))
-    {
-      if (TREE_CODE (t) == UNION_TYPE)
-	error ("redefinition of `union %s'", err_name);
-      else if (TREE_CODE (t) == RECORD_TYPE)
-	error ("redefinition of `struct %s'", err_name);
-      else
-	my_friendly_abort (172);
-      popclass (0);
-      return t;
-    }
-
-  GNU_xref_decl (current_function_decl, t);
-
-  /* If this type was previously laid out as a forward reference,
-     make sure we lay it out again.  */
-
-  TYPE_SIZE (t) = 0;
-  CLASSTYPE_GOT_SEMICOLON (t) = 0;
-  CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
-  CLASSTYPE_INTERFACE_UNKNOWN (t) = interface_unknown;
-
-  if (flag_dossier)
-    build_t_desc (t, 0);
-
-  TYPE_BINFO (t) = NULL_TREE;
-
-  old = suspend_momentary ();
-
-  /* Install struct as DECL_FIELD_CONTEXT of each field decl.
-     Also process specified field sizes.
-     Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
-     The specified size is found in the DECL_INITIAL.
-     Store 0 there, except for ": 0" fields (so we can find them
-     and delete them, below).  */
-
-  if (t_binfo && BINFO_BASETYPES (t_binfo))
-    n_baseclasses = TREE_VEC_LENGTH (BINFO_BASETYPES (t_binfo));
-  else
-    n_baseclasses = 0;
-
-  if (n_baseclasses > 0)
-    {
-      struct base_info base_info;
-
-      /* If using multiple inheritance, this may cause variants of our
-	 basetypes to be used (instead of their canonical forms).  */
-      fields = layout_basetypes (t, BINFO_BASETYPES (t_binfo));
-      last_x = tree_last (fields);
-
-      first_vfn_base_index = finish_base_struct (t, &base_info,
-						 BINFO_BASETYPES (t_binfo));
-      has_virtual = base_info.has_virtual;
-      max_has_virtual = base_info.max_has_virtual;
-      CLASSTYPE_N_SUPERCLASSES (t) += base_info.n_ancestors;
-      vfield = base_info.vfield;
-      vfields = base_info.vfields;
-      needs_default_ctor = base_info.needs_default_ctor;
-      cant_have_default_ctor = base_info.cant_have_default_ctor;
-      needs_const_ctor = base_info.needs_const_ctor;
-      cant_have_const_ctor = base_info.cant_have_const_ctor;
-      members_need_dtors = base_info.members_need_dtors;
-      needs_virtual_dtor = base_info.needs_virtual_dtor;
-      n_baseclasses = TREE_VEC_LENGTH (BINFO_BASETYPES (t_binfo));
-    }
-  else
-    {
-      first_vfn_base_index = -1;
-      has_virtual = 0;
-      max_has_virtual = has_virtual;
-      vfield = NULL_TREE;
-      vfields = NULL_TREE;
-      fields = NULL_TREE;
-      last_x = NULL_TREE;
-      needs_default_ctor = 0;
-      cant_have_default_ctor = 0;
-      needs_const_ctor = 0;
-      cant_have_const_ctor = 0;
-      members_need_dtors = 0;
-      needs_virtual_dtor = 0;
-    }
-
-  if (write_virtuals == 3 && ! CLASSTYPE_INTERFACE_UNKNOWN (t)
-      && current_lang_name == lang_name_cplusplus)
-    {
-      CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
-      CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! interface_only;
-    }
-
-  /* The three of these are approximations which may later be
-     modified.  Needed at this point to make add_virtual_function
-     and modify_vtable_entries work.  */
-  TREE_CHAIN (t_binfo) = TYPE_BINFO (t);
-  TYPE_BINFO (t) = t_binfo;
-  CLASSTYPE_VFIELDS (t) = vfields;
-  CLASSTYPE_VFIELD (t) = vfield;
-
-  fn_fields = NULL_TREE;
-  tail = NULL_TREE;
-  if (last_x && list_of_fieldlists)
-    TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
-
-  if (flag_all_virtual == 1 && TYPE_OVERLOADS_METHOD_CALL_EXPR (t))
-    all_virtual = 1;
-  else
-    all_virtual = 0;
-
-  if (CLASSTYPE_DECLARED_CLASS (t) == 0)
-    {
-      nonprivate_method = 1;
-      if (list_of_fieldlists
-	  && TREE_PURPOSE (list_of_fieldlists) == (tree)visibility_default)
-	TREE_PURPOSE (list_of_fieldlists) = (tree)visibility_public;
-    }
-  else if (list_of_fieldlists
-	   && TREE_PURPOSE (list_of_fieldlists) == (tree)visibility_default)
-    TREE_PURPOSE (list_of_fieldlists) = (tree)visibility_private;
-
-  while (list_of_fieldlists)
-    {
-      visibility = (enum visibility_type)TREE_PURPOSE (list_of_fieldlists);
-
-      for (x = TREE_VALUE (list_of_fieldlists); x; x = TREE_CHAIN (x))
-	{
-	  TREE_PRIVATE (x) = visibility == visibility_private;
-	  TREE_PROTECTED (x) = visibility == visibility_protected;
-	  GNU_xref_member (current_class_name, x);
-
-          if (TREE_CODE (x) == TYPE_DECL
-              && TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE)
-            {
-#if 0
-	      /* @@ Um.  This doesn't seem to be handled properly, at
-		 least in my PT test cases.  Not sure if it's really
-		 supposed to work for non-PT cases.  Let's find out.  */
-              static tree t, d;
-              d = DECL_NAME (x);
-              t = TYPE_IDENTIFIER (TREE_TYPE (x));
-	      if (d == t) continue;
-	      if (IDENTIFIER_TEMPLATE (t))
-		{
-		  t = DECL_NAME (TREE_PURPOSE (IDENTIFIER_TEMPLATE (t)));
-		  my_friendly_assert (t == d, 173);
-		  continue;
-		}
-	      else if (IDENTIFIER_CLASS_VALUE (t))
-		my_friendly_assert (TREE_TYPE (DECL_NAME (d))
-				    == TREE_TYPE (DECL_NAME (TREE_TYPE (t))),
-				    174);
-	      else
-		abort ();
-#endif
-	      continue;
-	    }
-
-
-	  if (TREE_CODE (x) == FUNCTION_DECL)
-	    {
-	      /* Clear out this flag.
-
-	         @@ Doug may figure out how to break
-		 @@ this with nested classes and friends.  */
-	      DECL_IN_AGGR_P (x) = 0;
-
-	      nonprivate_method |= ! TREE_PRIVATE (x);
-
-	      /* If this was an evil function, don't keep it in class.  */
-	      if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
-		continue;
-
-	      if (last_x) TREE_CHAIN (last_x) = TREE_CHAIN (x);
-	      if (! fn_fields) fn_fields = x;
-	      else TREE_CHAIN (tail) = x;
-	      tail = x;
-
-#if 0
-	      /* ??? What if we have duplicate declarations
-		 in T's definition?  */
-	      if (DECL_CLASS_CONTEXT (x))
-		continue;
-#endif
-	      DECL_CLASS_CONTEXT (x) = t;
-
-	      DECL_FIELD_SIZE (x) = 0;
-
-	      /* The name of the field is the original field name
-		 Save this in auxiliary field for later overloading.  */
-	      if (DECL_VINDEX (x)
-		  || (all_virtual == 1 && ! DECL_CONSTRUCTOR_P (x)))
-		{
-		  pending_virtuals = add_virtual_function (pending_virtuals,
-							   &has_virtual, x, t);
-		  if (DECL_ABSTRACT_VIRTUAL_P (x))
-		    abstract_virtuals = tree_cons (NULL_TREE, x, abstract_virtuals);
-		}
-	      continue;
-	    }
-
-	  /* Handle visibility declarations.  */
-	  if (DECL_NAME (x) && TREE_CODE (DECL_NAME (x)) == SCOPE_REF)
-	    {
-	      tree fdecl = TREE_OPERAND (DECL_NAME (x), 1);
-
-	      if (last_x) TREE_CHAIN (last_x) = TREE_CHAIN (x);
-	      /* Make type T see field decl FDECL with
-		 the visibility VISIBILITY.  */
-	      if (TREE_CODE (fdecl) == TREE_LIST)
-		{
-		  fdecl = TREE_VALUE (fdecl);
-		  while (fdecl)
-		    {
-		      if (alter_visibility (t, fdecl, visibility) == 0)
-			break;
-		      fdecl = DECL_CHAIN (fdecl);
-		    }
-		}
-	      else alter_visibility (t, fdecl, visibility);
-	      CLASSTYPE_ALTERS_VISIBILITIES_P (t) = 1;
-	      continue;
-	    }
-
-	  /* If this is of reference type, check if it needs an init.  */
-	  if (TREE_CODE (x) != TYPE_DECL
-	      && TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE
-	      && DECL_INITIAL (x) == 0)
-	    ref_sans_init = 1;
-
-	  /* ``A local class cannot have static data members.'' ARM 9.4 */
-	  if (current_function_decl && TREE_STATIC (x))
-	    error_with_decl (x, "field `%s' in local class cannot be static");
-
-	  /* When this goes into scope, it will be a non-local reference.  */
-	  DECL_NONLOCAL (x) = 1;
-
-	  /* Perform error checking that did not get done in grokdeclarator.  */
-	  if (TREE_CODE (x) == FIELD_DECL || TREE_CODE (x) == VAR_DECL)
-	    {
-	      if (TREE_CODE (TREE_TYPE (x)) == FUNCTION_TYPE)
-		{
-		  error_with_decl (x, "field `%s' invalidly declared function type");
-		  TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
-		}
-	      else if (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE)
-		{
-		  error_with_decl (x, "field `%s' invalidly declared method type");
-		  TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
-		}
-	      else if (TREE_CODE (TREE_TYPE (x)) == OFFSET_TYPE)
-		{
-		  error_with_decl (x, "field `%s' invalidly declared offset type");
-		  TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
-		}
-	    }
-
-	  if (TREE_CODE (x) == FIELD_DECL)
-	    {
-	      /* If the field has a bogus type, don't bother with it.  */
-	      if (TREE_TYPE (x) != error_mark_node)
-		{
-		  /* Never let anything with uninheritable virtuals
-		     make it through without complaint.  */
-		  if (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
-		      && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (x)))
-		    abstract_virtuals_error (x, TREE_TYPE (x));
-
-		  if (TYPE_LANG_SPECIFIC (TREE_TYPE (x)))
-		    {
-		      if (TYPE_HAS_DEFAULT_CONSTRUCTOR (TREE_TYPE (x)))
-			needs_default_ctor = 1;
-		      if (TYPE_GETS_CONST_INIT_REF (TREE_TYPE (x)))
-			needs_const_ctor = 1;
-		      else if (TYPE_GETS_INIT_REF (TREE_TYPE (x)))
-			cant_have_const_ctor = 1;
-		    }
-		  else if (DECL_INITIAL (x) == NULL_TREE
-			   && (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (x))
-			       || TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE))
-		    cant_have_default_ctor = 1;
-		}
-
-	      /* If any field is const, the structure type is pseudo-const.  */
-	      if (TREE_READONLY (x))
-		{
-		  C_TYPE_FIELDS_READONLY (t) = 1;
-		  if (DECL_INITIAL (x) == 0)
-		    const_sans_init = 1;
-		}
-	      else 
-		{
-		  /* A field that is pseudo-const makes the structure likewise.  */
-		  tree t1 = TREE_TYPE (x);
-		  while (TREE_CODE (t1) == ARRAY_TYPE)
-		    t1 = TREE_TYPE (t1);
-		  if (IS_AGGR_TYPE (t1))
-		    {
-		      if (C_TYPE_FIELDS_READONLY (t1))
-			C_TYPE_FIELDS_READONLY (t) = 1;
-		      if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (t1))
-			const_sans_init = 1;
-		    }
-		}
-	    }
-	  else if (TREE_CODE (x) == VAR_DECL && TREE_CODE (t) == UNION_TYPE)
-	    /* Unions cannot have static members.  */
-	    error_with_decl (x, "field `%s' declared static in union");
-
-	  if (! fields) fields = x;
-	  DECL_FIELD_CONTEXT (x) = t;
-	  /* We could be making an extern "C" function a friend. */
-	  if (DECL_LANG_SPECIFIC (x))
-	    DECL_CLASS_CONTEXT (x) = t;
-	  DECL_FIELD_SIZE (x) = 0;
-
-	  /* We set DECL_BIT_FIELD tentatively in grokbitfield.
-	     If the type and width are valid, we'll keep it set.
-	     Otherwise, the flag is cleared.  */
-	  if (DECL_BIT_FIELD (x))
-	    {
-	      DECL_BIT_FIELD (x) = 0;
-	      /* Invalid bit-field size done by grokfield.  */
-	      /* Detect invalid bit-field type.  */
-	      if (DECL_INITIAL (x)
-		  && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
-		  && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
-		{
-		  error_with_decl (x, "bit-field `%s' has invalid type");
-		  DECL_INITIAL (x) = NULL;
-		}
-	      if (DECL_INITIAL (x) && pedantic
-		  && TREE_TYPE (x) != integer_type_node
-		  && TREE_TYPE (x) != unsigned_type_node
-		  && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
-		warning_with_decl (x, "bit-field `%s' type invalid in ANSI C++");
-
-	      /* Detect and ignore out of range field width.  */
-	      if (DECL_INITIAL (x))
-		{
-		  register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
-
-		  if (width < 0)
-		    {
-		      DECL_INITIAL (x) = NULL;
-		      warning_with_decl (x, "negative width in bit-field `%s'");
-		    }
-		  else if (width == 0 && DECL_NAME (x) != 0)
-		    {
-		      error_with_decl (x, "zero width for bit-field `%s'");
-		      DECL_INITIAL (x) = NULL;
-		    }
-		  else if ((unsigned)width > TYPE_PRECISION (TREE_TYPE (x)))
-		    {
-		      DECL_INITIAL (x) = NULL;
-		      warning_with_decl (x, "width of `%s' exceeds its type");
-		    }
-		}
-
-	      /* Process valid field width.  */
-	      if (DECL_INITIAL (x))
-		{
-		  register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
-
-		  if (width == 0)
-		    {
-#ifdef EMPTY_FIELD_BOUNDARY
-		      /* field size 0 => mark following field as "aligned" */
-		      if (TREE_CHAIN (x))
-			DECL_ALIGN (TREE_CHAIN (x))
-			  = MAX (DECL_ALIGN (TREE_CHAIN (x)), EMPTY_FIELD_BOUNDARY);
-		      /* field of size 0 at the end => round up the size.  */
-		      else
-			round_up_size = EMPTY_FIELD_BOUNDARY;
-#endif
-#ifdef PCC_BITFIELD_TYPE_MATTERS
-		      DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
-					    TYPE_ALIGN (TREE_TYPE (x)));
-#endif
-		    }
-		  else
-		    {
-		      DECL_INITIAL (x) = NULL_TREE;
-		      DECL_FIELD_SIZE (x) = width;
-		      DECL_BIT_FIELD (x) = 1;
-		      /* Traditionally a bit field is unsigned
-			 even if declared signed.  */
-		      if (flag_traditional
-			  && TREE_CODE (TREE_TYPE (x)) == INTEGER_TYPE)
-			TREE_TYPE (x) = unsigned_type_node;
-		    }
-		}
-	      else
-		/* Non-bit-fields are aligned for their type.  */
-		DECL_ALIGN (x) = MAX (DECL_ALIGN (x), TYPE_ALIGN (TREE_TYPE (x)));
-	    }
-	  else if (TREE_CODE (x) == FIELD_DECL)
-	    {
-	      tree type = TREE_TYPE (x);
-	      if (TREE_CODE (type) == ARRAY_TYPE)
-		type = TREE_TYPE (type);
-	      if (code == UNION_TYPE && IS_AGGR_TYPE (type))
-		{
-		  if (TYPE_NEEDS_CONSTRUCTING (type)
-		      || TYPE_NEEDS_DESTRUCTOR (type))
-		    error_with_decl (x, "member `%s' with constructor or destructor not allowed in union");
-		  TYPE_GETS_ASSIGNMENT (t) |= TYPE_GETS_ASSIGNMENT (type);
-		  TYPE_GETS_INIT_REF (t) |= TYPE_GETS_INIT_REF (type);
-		}
-	      else if (code == RECORD_TYPE)
-		{
-		  /* Array of record type doesn't matter for this bit.  */
-		  TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
-		  if (IS_AGGR_TYPE (type))
-		    {
-		      needs_ctor |= TYPE_NEEDS_CONSTRUCTOR (type);
-		      needs_dtor |= TYPE_NEEDS_DESTRUCTOR (type);
-		      members_need_dtors |= TYPE_NEEDS_DESTRUCTOR (type);
-		      TYPE_GETS_CONST_INIT_REF (t) |= TYPE_GETS_CONST_INIT_REF (type);
-		      TYPE_GETS_ASSIGNMENT (t) |= TYPE_GETS_ASSIGNMENT (type);
-		      TYPE_GETS_INIT_REF (t) |= TYPE_GETS_INIT_REF (type);
-		    }
-		}
-	      if (DECL_INITIAL (x) != NULL_TREE)
-		{
-		  /* `build_class_init_list' does not recognize non-FIELD_DECLs.  */
-		  if (code == UNION_TYPE && any_default_members != 0)
-		    error ("multiple fields in union initialized");
-		  any_default_members = 1;
-		}
-	    }
-	  last_x = x;
-	}
-      list_of_fieldlists = TREE_CHAIN (list_of_fieldlists);
-      /* link the tail while we have it! */
-      if (last_x)
-	{
-	  TREE_CHAIN (last_x) = NULL_TREE;
-
-	  if (list_of_fieldlists
-	      && TREE_VALUE (list_of_fieldlists)
-	      && TREE_CODE (TREE_VALUE (list_of_fieldlists)) != FUNCTION_DECL)
-	    TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
-	}
-    }
-
-  if (tail) TREE_CHAIN (tail) = NULL_TREE;
-
-  /* If this type has any constant members which did not come
-     with their own initialization, mark that fact here.  It is
-     not an error here, since such types can be saved either by their
-     constructors, or by fortuitous initialization.  */
-  CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) = const_sans_init;
-  CLASSTYPE_REF_FIELDS_NEED_INIT (t) = ref_sans_init;
-  CLASSTYPE_ABSTRACT_VIRTUALS (t) = abstract_virtuals;
-
-  if (members_need_dtors && !TYPE_HAS_DESTRUCTOR (t))
-    {
-      /* Here we must cons up a destructor on the fly.  */
-      tree dtor = cons_up_default_function (t, name,
-					    needs_virtual_dtor != 0);
-
-      /* If we couldn't make it work, then pretend we didn't need it.  */
-      if (dtor == void_type_node)
-	TYPE_NEEDS_DESTRUCTOR (t) = 0;
-      else
-	{
-	  if (! fn_fields) fn_fields = dtor;
-	  else TREE_CHAIN (tail) = dtor;
-	  tail = dtor;
-
-	  if (DECL_VINDEX (dtor) == NULL_TREE
-	      && ! CLASSTYPE_DECLARED_EXCEPTION (t)
-	      && (needs_virtual_dtor
-		  || pending_virtuals != NULL_TREE
-		  || pending_hard_virtuals != NULL_TREE))
-	    DECL_VINDEX (dtor) = error_mark_node;
-	  if (DECL_VINDEX (dtor))
-	    pending_virtuals = add_virtual_function (pending_virtuals,
-						     &has_virtual, dtor, NULL_TREE);
-	  nonprivate_method = 1;
-	  TYPE_HAS_DESTRUCTOR (t) = 1;
-	}
-    }
-
-  if (debug_default_functions)
-    {
-      if ((TYPE_NEEDS_CONSTRUCTOR (t) || TYPE_HAS_CONSTRUCTOR (t) || needs_ctor)
-	  && ! TYPE_HAS_INIT_REF (t))
-	{
-	  tree default_fn = cons_up_default_function (t, name, 4);
-	  TREE_CHAIN (default_fn) = fn_fields;
-	  fn_fields = default_fn;
-	  TYPE_HAS_INIT_REF (t) = 1;
-	  default_fn = cons_up_default_function (t, name, 3);
-	  TREE_CHAIN (default_fn) = fn_fields;
-	  fn_fields = default_fn;
-	  nonprivate_method = 1;
-	}
-
-      if (! TYPE_HAS_DEFAULT_CONSTRUCTOR (t)
-	  && needs_default_ctor && ! cant_have_default_ctor)
-	{
-	  tree default_fn = cons_up_default_function (t, name, 2);
-	  TREE_CHAIN (default_fn) = fn_fields;
-	  fn_fields = default_fn;
-	  TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
-	  nonprivate_method = 1;
-	}
-    }
-
-  if (fn_fields)
-    {
-      method_vec = finish_struct_methods (t, fn_fields, nonprivate_method);
-
-      if (TYPE_HAS_CONSTRUCTOR (t)
-	  && ! CLASSTYPE_DECLARED_EXCEPTION (t)
-	  && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
-	  && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
-	{
-	  int nonprivate_ctor = 0;
-	  tree ctor;
-
-	  for (ctor = TREE_VEC_ELT (method_vec, 0);
-	       ctor;
-	       ctor = DECL_CHAIN (ctor))
-	    if (! TREE_PRIVATE (ctor))
-	      {
-		nonprivate_ctor = 1;
-		break;
-	      }
-	  if (nonprivate_ctor == 0)
-	    warning ("class `%s' only defines private constructors and has no friends",
-		     err_name);
-	}
-    }
-  else
-    {
-      method_vec = 0;
-
-      /* Just in case these got accidentally
-	 filled in by syntax errors.  */
-      TYPE_HAS_CONSTRUCTOR (t) = 0;
-      TYPE_HAS_DESTRUCTOR (t) = 0;
-    }
-
-  if (vfield == NULL_TREE && has_virtual)
-    {
-      /* We build this decl with ptr_type_node, and
-	 change the type when we know what it should be.  */
-      vfield = build_lang_field_decl (FIELD_DECL, get_vfield_name (t), ptr_type_node);
-      /* If you change any of the below, take a look at all the
-	 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
-	 them too. */
-      DECL_ASSEMBLER_NAME (vfield) = get_identifier (VFIELD_BASE);
-      CLASSTYPE_VFIELD (t) = vfield;
-      DECL_VIRTUAL_P (vfield) = 1;
-      DECL_FIELD_CONTEXT (vfield) = t;
-      DECL_CLASS_CONTEXT (vfield) = t;
-      DECL_FCONTEXT (vfield) = t;
-      DECL_FIELD_SIZE (vfield) = 0;
-      DECL_ALIGN (vfield) = TYPE_ALIGN (ptr_type_node);
-      if (CLASSTYPE_DOSSIER (t))
-	{
-	  /* vfield is always first entry in structure.  */
-	  TREE_CHAIN (vfield) = fields;
-	  fields = vfield;
-	}
-      else if (last_x)
-	{
-	  my_friendly_assert (TREE_CHAIN (last_x) == 0, 175);
-	  TREE_CHAIN (last_x) = vfield;
-	  last_x = vfield;
-	}
-      else fields = vfield;
-      vfields = chainon (vfields, CLASSTYPE_AS_LIST (t));
-    }
-
-  /* Now DECL_INITIAL is null on all members except for zero-width bit-fields.
-     And they have already done their work.
-
-     C++: maybe we will support default field initialization some day...  */
-
-  /* Delete all zero-width bit-fields from the front of the fieldlist */
-  while (fields && DECL_BIT_FIELD (fields)
-	 && DECL_INITIAL (fields))
-    fields = TREE_CHAIN (fields);
-  /* Delete all such fields from the rest of the fields.  */
-  for (x = fields; x;)
-    {
-      if (TREE_CHAIN (x) && DECL_BIT_FIELD (TREE_CHAIN (x))
-	  && DECL_INITIAL (TREE_CHAIN (x)))
-	TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
-      else x = TREE_CHAIN (x);
-    }
-  /* Delete all duplicate fields from the fields */
-  delete_duplicate_fields (fields);
-
-  /* Now we have the final fieldlist for the data fields.  Record it,
-     then lay out the structure or union (including the fields).  */
-
-  TYPE_FIELDS (t) = fields;
-
-  /* If there's a :0 field at the end, round the size to the
-     EMPTY_FIELD_BOUNDARY.  */
-  TYPE_ALIGN (t) = round_up_size;
-
-  /* Pass layout information about base classes to layout_type, if any.  */
-
-  if (n_baseclasses)
-    {
-      tree pseudo_basetype = TREE_TYPE (base_layout_decl);
-
-      TREE_CHAIN (base_layout_decl) = TYPE_FIELDS (t);
-      TYPE_FIELDS (t) = base_layout_decl;
-
-      TYPE_SIZE (pseudo_basetype) = CLASSTYPE_SIZE (t);
-      TYPE_MODE (pseudo_basetype) = TYPE_MODE (t);
-      TYPE_ALIGN (pseudo_basetype) = CLASSTYPE_ALIGN (t);
-      DECL_ALIGN (base_layout_decl) = TYPE_ALIGN (pseudo_basetype);
-    }
-
-  layout_type (t);
-
-  if (n_baseclasses)
-    TYPE_FIELDS (t) = TREE_CHAIN (TYPE_FIELDS (t));
-
-  /* C++: do not let empty structures exist.  */
-  if (integer_zerop (TYPE_SIZE (t)))
-    TYPE_SIZE (t) = TYPE_SIZE (char_type_node);
-
-  /* Set the TYPE_DECL for this type to contain the right
-     value for DECL_OFFSET, so that we can use it as part
-     of a COMPONENT_REF for multiple inheritance.  */
-
-  if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
-    layout_decl (TYPE_NAME (t), 0);
-
-  /* Now fix up any virtual base class types that we
-     left lying around.  We must get these done
-     before we try to lay out the virtual function table.  */
-  doing_hard_virtuals = 1;
-  pending_hard_virtuals = nreverse (pending_hard_virtuals);
-
-  if (TYPE_USES_VIRTUAL_BASECLASSES (t))
-    {
-      tree vbases;
-
-      max_has_virtual = layout_vbasetypes (t, max_has_virtual);
-      vbases = CLASSTYPE_VBASECLASSES (t);
-      CLASSTYPE_N_VBASECLASSES (t) = list_length (vbases);
-
-      /* This loop makes all the entries in the virtual function tables
-	 of interest contain the "latest" version of the functions
-	 we have defined.  */
-
-      while (vbases)
-	{
-	  tree virtuals = BINFO_VIRTUALS (vbases);
-
-	  if (virtuals)
-	    {
-	      /* Get past the `null' vtable entry...  */
-	      virtuals = TREE_CHAIN (virtuals);
-	      /* and the `dossier' vtable entry if we're doing dossiers.  */
-	      if (flag_dossier)
-		virtuals = TREE_CHAIN (virtuals);
-	    }
-
-	  while (virtuals != NULL_TREE)
-	    {
-	      tree pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals));
-	      tree base_fndecl = TREE_OPERAND (pfn, 0);
-	      tree decl = get_first_matching_virtual (TYPE_BINFO (t), base_fndecl,
-						      DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl)));
-	      tree context = DECL_CLASS_CONTEXT (decl);
-	      if (decl != base_fndecl && context != t)
-		{
-		  tree base_context = DECL_CLASS_CONTEXT (base_fndecl);
-		  tree binfo = NULL_TREE, these_virtuals;
-#if 0
-		  unsigned HOST_WIDE_INT i
-		    = (TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl))
-		       & (((unsigned HOST_WIDE_INT)1<<(BITS_PER_WORD-1))-1));
-#endif
-
-		  if (TYPE_USES_VIRTUAL_BASECLASSES (context))
-		    binfo = virtual_member (base_context,
-					    CLASSTYPE_VBASECLASSES (context));
-		  if (binfo == NULL_TREE)
-		    binfo = binfo_value (base_context, context);
-		  if (binfo != NULL_TREE)
-		    {
-#if 1
-		      pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (get_vtable_entry (BINFO_VIRTUALS (binfo), base_fndecl)));
-#else
-		      these_virtuals = BINFO_VIRTUALS (binfo);
-
-		      while (i-- > 0)
-			these_virtuals = TREE_CHAIN (these_virtuals);
-		      pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (these_virtuals));
-#endif
-		      modify_vtable_entries (t, decl, base_fndecl, pfn);
-		    }
-		}
-	      virtuals = TREE_CHAIN (virtuals);
-	    }
-	  /* Update dossier info with offsets for virtual baseclasses.  */
-	  if (flag_dossier && ! BINFO_NEW_VTABLE_MARKED (vbases))
-	    prepare_fresh_vtable (vbases, vbases, t);
-
-	  vbases = TREE_CHAIN (vbases);
-	}
-    }
-
-  while (pending_hard_virtuals)
-    {
-      /* Need an entry in some other virtual function table.  */
-      if (TREE_TYPE (pending_hard_virtuals))
-	{
-	  /* This is how we modify entries when a vfn's index changes
-	     between derived and base type.  */
-	  modify_vtable_entries (t, TREE_PURPOSE (pending_hard_virtuals),
-				 TREE_TYPE (pending_hard_virtuals),
-				 TREE_VALUE (pending_hard_virtuals));
-	}
-      else
-	{
-	  /* This is how we modify entries when a vfn comes from
-	     a virtual baseclass.  */
-	  tree base_fndecls = DECL_VINDEX (TREE_PURPOSE (pending_hard_virtuals));
-	  my_friendly_assert (base_fndecls != error_mark_node, 176);
-	  while (base_fndecls)
-	    {
-	      modify_vtable_entries (t, TREE_PURPOSE (pending_hard_virtuals),
-				     TREE_VALUE (base_fndecls),
-				     TREE_VALUE (pending_hard_virtuals));
-	      base_fndecls = TREE_CHAIN (base_fndecls);
-	    }
-	}
-      pending_hard_virtuals = TREE_CHAIN (pending_hard_virtuals);
-    }
-  doing_hard_virtuals = 0;
-
-  /* Under our model of GC, every C++ class gets its own virtual
-     function table, at least virtually.  */
-  if (pending_virtuals || CLASSTYPE_DOSSIER (t))
-    {
-      pending_virtuals = nreverse (pending_virtuals);
-      /* We must enter these virtuals into the table.  */
-      if (first_vfn_base_index < 0)
-	{
-	  if (flag_dossier)
-	    pending_virtuals = tree_cons (NULL_TREE,
-					  build_vtable_entry (integer_zero_node,
-							      build_t_desc (t, 0)),
-					  pending_virtuals);
-	  pending_virtuals = tree_cons (NULL_TREE, the_null_vtable_entry,
-					pending_virtuals);
-	  build_vtable (NULL_TREE, t);
-	}
-      else
-	{
-	  /* Here we know enough to change the type of our virtual
-	     function table, but we will wait until later this function.  */
-
-	  if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
-	    build_vtable (binfo_value (TYPE_BINFO_BASETYPE (t, first_vfn_base_index), t), t);
-
-	  /* Update the dossier pointer for this class.  */
-	  if (flag_dossier)
-	    TREE_VALUE (TREE_CHAIN (TYPE_BINFO_VIRTUALS (t)))
-	      = build_vtable_entry (integer_zero_node, build_t_desc (t, 0));
-	}
-
-      /* If this type has basetypes with constructors, then those
-	 constructors might clobber the virtual function table.  But
-	 they don't if the derived class shares the exact vtable of the base
-	 class.  */
-
-      CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
-    }
-  else if (first_vfn_base_index >= 0)
-    {
-      tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
-
-      /* This class contributes nothing new to the virtual function
-	 table.  However, it may have declared functions which
-	 went into the virtual function table "inherited" from the
-	 base class.  If so, we grab a copy of those updated functions,
-	 and pretend they are ours.  */
-
-      /* See if we should steal the virtual info from base class.  */
-      if (TYPE_BINFO_VTABLE (t) == NULL_TREE)
-	TYPE_BINFO_VTABLE (t) = BINFO_VTABLE (binfo);
-      if (TYPE_BINFO_VIRTUALS (t) == NULL_TREE)
-	TYPE_BINFO_VIRTUALS (t) = BINFO_VIRTUALS (binfo);
-      if (TYPE_BINFO_VTABLE (t) != BINFO_VTABLE (binfo))
-	CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
-    }
-
-  if (has_virtual > max_has_virtual)
-    max_has_virtual = has_virtual;
-  if (max_has_virtual || first_vfn_base_index >= 0)
-    {
-#ifdef VTABLE_USES_MASK
-      if (max_has_virtual >= VINDEX_MAX)
-	{
-	  error ("too many virtual functions for class `%s' (VINDEX_MAX < %d)",
-		 err_name, has_virtual);
-	}
-#endif
-      TYPE_VIRTUAL_P (t) = 1;
-      CLASSTYPE_VSIZE (t) = has_virtual;
-      if (first_vfn_base_index >= 0)
-	{
-	  if (pending_virtuals)
-	    TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t),
-						pending_virtuals);
-	}
-      else if (has_virtual)
-	{
-	  TYPE_BINFO_VIRTUALS (t) = pending_virtuals;
-	  if (write_virtuals >= 0)
-	    DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)) = 1;
-	}
-    }
-
-  /* Now lay out the virtual function table.  */
-  if (has_virtual)
-    {
-      tree atype, itype;
-
-      if (TREE_TYPE (vfield) == ptr_type_node)
-	{
-	  /* We must create a pointer to this table because
-	     the one inherited from base class does not exist.
-	     We will fill in the type when we know what it
-	     should really be.  Use `size_int' so values are memoized
-	     in common cases.  */
-	  itype = build_index_type (size_int (has_virtual));
-	  atype = build_array_type (vtable_entry_type, itype);
-	  layout_type (atype);
-	  TREE_TYPE (vfield) = build_pointer_type (atype);
-	}
-      else
-	{
-	  atype = TREE_TYPE (TREE_TYPE (vfield));
-
-	  if (has_virtual != TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (atype))))
-	    {
-	      /* We must extend (or create) the boundaries on this array,
-		 because we picked up virtual functions from multiple
-		 base classes.  */
-	      itype = build_index_type (size_int (has_virtual));
-	      atype = build_array_type (vtable_entry_type, itype);
-	      layout_type (atype);
-	      vfield = copy_node (vfield);
-	      TREE_TYPE (vfield) = build_pointer_type (atype);
-	    }
-	}
-
-      CLASSTYPE_VFIELD (t) = vfield;
-      if (TREE_TYPE (TYPE_BINFO_VTABLE (t)) != atype)
-	{
-	  TREE_TYPE (TYPE_BINFO_VTABLE (t)) = atype;
-	  layout_decl (TYPE_BINFO_VTABLE (t), 0);
-	  DECL_ALIGN (TYPE_BINFO_VTABLE (t))
-	    = MAX (TYPE_ALIGN (double_type_node),
-		   DECL_ALIGN (TYPE_BINFO_VTABLE (t)));
-	}
-    }
-  else if (first_vfn_base_index >= 0)
-    CLASSTYPE_VFIELD (t) = vfield;
-  CLASSTYPE_VFIELDS (t) = vfields;
-
-  /* Set all appropriate CLASSTYPE_... flags for this type
-     and its variants.  */
-  TYPE_NEEDS_CONSTRUCTOR (t) |= needs_ctor || TYPE_HAS_CONSTRUCTOR (t);
-  TYPE_NEEDS_CONSTRUCTING (t)
-    |= ((TYPE_NEEDS_CONSTRUCTOR (t)|TYPE_USES_VIRTUAL_BASECLASSES (t))
-	|| has_virtual || any_default_members
-	|| first_vfn_base_index >= 0);
-  TYPE_NEEDS_DESTRUCTOR (t) |= needs_dtor || TYPE_HAS_DESTRUCTOR (t);
-  finish_struct_bits (t, max_has_virtual);
-
-  /* Promote each bit-field's type to int if it is narrower than that.
-     There's more: complete the rtl for any static member objects which
-     is of the same type we're working on.
-  */
-  for (x = fields; x; x = TREE_CHAIN (x))
-    {
-      if (DECL_BIT_FIELD (x)
-	  && C_PROMOTING_INTEGER_TYPE_P (TREE_TYPE (x)))
-	TREE_TYPE (x) = TREE_UNSIGNED (TREE_TYPE (x))
-	  ? unsigned_type_node : integer_type_node;
-      if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
-	  && TREE_TYPE (x) == t)
-	{
-	  DECL_MODE (x) = TYPE_MODE (t);
-	  make_decl_rtl (x, NULL, 0);
-	}
-    }
-
-  /* Now add the tags, if any, to the list of TYPE_DECLs
-     defined for this type.  */
-  if (CLASSTYPE_TAGS (t))
-    {
-      x = CLASSTYPE_TAGS (t);
-      last_x = tree_last (TYPE_FIELDS (t));
-      while (x)
-	{
-	  tree tag = build_lang_decl (TYPE_DECL, TREE_PURPOSE (x), TREE_VALUE (x));
-	  DECL_CONTEXT (tag) = t;
-	  DECL_CLASS_CONTEXT (tag) = t;
-	  x = TREE_CHAIN (x);
-	  last_x = chainon (last_x, tag);
-	}
-      if (TYPE_FIELDS (t) == 0)
-	TYPE_FIELDS (t) = last_x;
-      CLASSTYPE_LOCAL_TYPEDECLS (t) = 1;
-    }
-
-  if (TYPE_HAS_CONSTRUCTOR (t))
-    {
-      tree vfields = CLASSTYPE_VFIELDS (t);
-
-      while (vfields)
-	{
-	  /* Mark the fact that constructor for T
-	     could affect anybody inheriting from T
-	     who wants to initialize vtables for VFIELDS's type.  */
-	  if (VF_DERIVED_VALUE (vfields))
-	    TREE_ADDRESSABLE (vfields) = 1;
-	  vfields = TREE_CHAIN (vfields);
-	}
-      if (any_default_members != 0)
-	build_class_init_list (t);
-    }
-  else if (TYPE_NEEDS_CONSTRUCTING (t))
-    build_class_init_list (t);
-
-  if (current_lang_name == lang_name_cplusplus)
-    {
-      if (! CLASSTYPE_DECLARED_EXCEPTION (t))
-	embrace_waiting_friends (t);
-
-      /* Write out inline function definitions.  */
-      do_inline_function_hair (t, CLASSTYPE_INLINE_FRIENDS (t));
-      CLASSTYPE_INLINE_FRIENDS (t) = 0;
-    }
-
-  if (CLASSTYPE_VSIZE (t) != 0)
-    {
-#if 0
-      if (!TYPE_USES_COMPLEX_INHERITANCE (t))
-	TYPE_NONCOPIED_PARTS (t) = build_tree_list (default_conversion (TYPE_BINFO_VTABLE (t)), vfield);
-#endif
-
-      if ((flag_this_is_variable & 1) == 0)
-	{
-	  tree vtbl_ptr = build_decl (VAR_DECL, get_identifier (VPTR_NAME),
-				      TREE_TYPE (vfield));
-	  DECL_REGISTER (vtbl_ptr) = 1;
-	  CLASSTYPE_VTBL_PTR (t) = vtbl_ptr;
-	}
-      if (DECL_FIELD_CONTEXT (vfield) != t)
-	{
-	  tree binfo = binfo_value (DECL_FIELD_CONTEXT (vfield), t);
-	  tree offset = BINFO_OFFSET (binfo);
-
-	  vfield = copy_node (vfield);
-	  copy_lang_decl (vfield);
-
-	  if (! integer_zerop (offset))
-	    offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
-	  DECL_FIELD_CONTEXT (vfield) = t;
-	  DECL_CLASS_CONTEXT (vfield) = t;
-	  DECL_FIELD_BITPOS (vfield)
-	    = size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
-	  CLASSTYPE_VFIELD (t) = vfield;
-	}
-      if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (t)
-	  && DECL_VINDEX (TREE_VEC_ELT (method_vec, 0)) == NULL_TREE)
-	warning ("class `%s' has virtual functions but non-virtual destructor",
-		 err_name);
-    }
-
-  /* Make the rtl for any new vtables we have created, and unmark
-     the base types we marked.  */
-  unmark_finished_struct (t);
-  TYPE_BEING_DEFINED (t) = 0;
-
-  if (flag_dossier && CLASSTYPE_VTABLE_NEEDS_WRITING (t))
-    {
-      tree variants;
-      tree tdecl;
-
-      /* Now instantiate its type descriptors.  */
-      tdecl = TREE_OPERAND (build_t_desc (t, 1), 0);
-      variants = TYPE_POINTER_TO (t);
-      build_type_variant (variants, 1, 0);
-      while (variants)
-	{
-	  build_t_desc (variants, 1);
-	  variants = TYPE_NEXT_VARIANT (variants);
-	}
-      variants = build_reference_type (t);
-      build_type_variant (variants, 1, 0);
-      while (variants)
-	{
-	  build_t_desc (variants, 1);
-	  variants = TYPE_NEXT_VARIANT (variants);
-	}
-#if 0
-      DECL_VPARENT (tdecl) = t;
-#endif
-      DECL_CONTEXT (tdecl) = t;
-    }
-  /* Still need to instantiate this C struct's type descriptor.  */
-  else if (flag_dossier && ! CLASSTYPE_DOSSIER (t))
-    build_t_desc (t, 1);
-
-  if (TYPE_NAME (t) && TYPE_IDENTIFIER (t))
-    undo_template_name_overload (TYPE_IDENTIFIER (t), 1);
-  if (current_class_type)
-    popclass (0);
-  else
-    error ("trying to finish struct, but kicked out due to previous parse errors.");
-
-  hack_incomplete_structures (t);
-
-  resume_momentary (old);
-
-  if (flag_cadillac)
-    cadillac_finish_struct (t);
-
-#if 0
-  /* This has to be done after we have sorted out what to do with
-     the enclosing type.  */
-  /* Be smarter about nested classes here.  If a type is nested,
-     only output it if we would output the enclosing type.  */
-  if (DECL_CONTEXT (TYPE_NAME (t))
-      && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (TYPE_NAME (t)))) == 't')
-    DECL_IGNORED_P (TYPE_NAME (t)) = TREE_ASM_WRITTEN (TYPE_NAME (t));
-#endif
-
-  /* If the type has methods, we want to think about cutting down
-     the amount of symbol table stuff we output.  The value stored in
-     the TYPE_DECL's DECL_IGNORED_P slot is a first approximation.
-     For example, if a member function is seen and we decide to
-     write out that member function, then we can change the value
-     of the DECL_IGNORED_P slot, and the type will be output when
-     that member function's debug info is written out.  */
-  if (CLASSTYPE_METHOD_VEC (t))
-    {
-      extern tree pending_vtables;
-
-      /* Don't output full info about any type
-	 which does not have its implementation defined here.  */
-      if (TYPE_VIRTUAL_P (t) && write_virtuals == 2)
-	DECL_IGNORED_P (TYPE_NAME (t))
-	  = (value_member (TYPE_IDENTIFIER (t), pending_vtables) == 0);
-      else if (CLASSTYPE_INTERFACE_ONLY (t))
-	DECL_IGNORED_P (TYPE_NAME (t)) = 1;
-      else if (CLASSTYPE_INTERFACE_UNKNOWN (t))
-	/* Only a first approximation!  */
-	DECL_IGNORED_P (TYPE_NAME (t)) = 1;
-    }
-  else if (CLASSTYPE_INTERFACE_ONLY (t))
-    DECL_IGNORED_P (TYPE_NAME (t)) = 1;
-
-  /* Finish debugging output for this type.  */
-  rest_of_type_compilation (t, global_bindings_p ());
-
-  return t;
-}
-
-/* Return non-zero if the effective type of INSTANCE is static.
-   Used to determine whether the virtual function table is needed
-   or not.
-
-   *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
-   of our knowledge of its type.  */
-int
-resolves_to_fixed_type_p (instance, nonnull)
-     tree instance;
-     int *nonnull;
-{
-  switch (TREE_CODE (instance))
-    {
-    case INDIRECT_REF:
-      /* Check that we are not going through a cast of some sort.  */
-      if (TREE_TYPE (instance)
-	  == TREE_TYPE (TREE_TYPE (TREE_OPERAND (instance, 0))))
-	instance = TREE_OPERAND (instance, 0);
-      /* fall through...  */
-    case CALL_EXPR:
-      /* This is a call to a constructor, hence it's never zero.  */
-      if (TREE_HAS_CONSTRUCTOR (instance))
-	{
-	  if (nonnull)
-	    *nonnull = 1;
-	  return 1;
-	}
-      return 0;
-
-    case SAVE_EXPR:
-      /* This is a call to a constructor, hence it's never zero.  */
-      if (TREE_HAS_CONSTRUCTOR (instance))
-	{
-	  if (nonnull)
-	    *nonnull = 1;
-	  return 1;
-	}
-      return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
-
-    case RTL_EXPR:
-      /* This is a call to `new', hence it's never zero.  */
-      if (TREE_CALLS_NEW (instance))
-	{
-	  if (nonnull)
-	    *nonnull = 1;
-	  return 1;
-	}
-      return 0;
-
-    case PLUS_EXPR:
-    case MINUS_EXPR:
-      if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
-	/* Propagate nonnull.  */
-	resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
-      if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
-	return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
-      return 0;
-
-    case NOP_EXPR:
-    case CONVERT_EXPR:
-      return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
-
-    case ADDR_EXPR:
-      if (nonnull)
-	*nonnull = 1;
-      return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
-
-    case COMPONENT_REF:
-      return resolves_to_fixed_type_p (TREE_OPERAND (instance, 1), nonnull);
-
-    case WITH_CLEANUP_EXPR:
-      if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
-	return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
-      /* fall through... */
-    case VAR_DECL:
-    case FIELD_DECL:
-      if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
-	  && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
-	{
-	  if (nonnull)
-	    *nonnull = 1;
-	  return 1;
-	}
-      /* fall through... */
-    case TARGET_EXPR:
-    case PARM_DECL:
-      if (IS_AGGR_TYPE (TREE_TYPE (instance)))
-	{
-	  if (nonnull)
-	    *nonnull = 1;
-	  return 1;
-	}
-      else if (nonnull)
-	{
-	  if (instance == current_class_decl
-	      && flag_this_is_variable <= 0)
-	    {
-	      /* Some people still use `this = 0' inside destructors.  */
-	      *nonnull = ! DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl));
-	      /* In a constructor, we know our type.  */
-	      if (flag_this_is_variable < 0)
-		return 1;
-	    }
-	  else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
-	    /* Reference variables should be references to objects.  */
-	    *nonnull = 1;
-	}
-      return 0;
-
-    default:
-      return 0;
-    }
-}
-
-void
-init_class_processing ()
-{
-  current_class_depth = 0;
-  current_class_stacksize = 10;
-  current_class_base = (tree *)xmalloc(current_class_stacksize * sizeof (tree));
-  current_class_stack = current_class_base;
-
-  current_lang_stacksize = 10;
-  current_lang_base = (tree *)xmalloc(current_lang_stacksize * sizeof (tree));
-  current_lang_stack = current_lang_base;
-
-  delta_name = get_identifier (VTABLE_DELTA_NAME);
-  pfn_name = get_identifier (VTABLE_PFN_NAME);
-
-  /* Keep these values lying around.  */
-  the_null_vtable_entry = build_vtable_entry (integer_zero_node, integer_zero_node);
-  base_layout_decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, error_mark_node);
-  TREE_TYPE (base_layout_decl) = make_node (RECORD_TYPE);
-
-  gcc_obstack_init (&class_obstack);
-}
-
-/* Set current scope to NAME. CODE tells us if this is a
-   STRUCT, UNION, or ENUM environment.
-
-   NAME may end up being NULL_TREE if this is an anonymous or
-   late-bound struct (as in "struct { ... } foo;")  */
-
-/* Here's a subroutine we need because C lacks lambdas.  */
-static void
-unuse_fields (type)
-     tree type;
-{
-  tree fields;
-
-  for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
-    {
-      if (TREE_CODE (fields) != FIELD_DECL)
-	continue;
-
-      TREE_USED (fields) = 0;
-      if (DECL_NAME (fields) == NULL_TREE
-	  && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
-	unuse_fields (TREE_TYPE (fields));
-    }
-}
-
-/* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
-   appropriate values, found by looking up the type definition of
-   NAME (as a CODE).
-
-   If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
-   which can be seen locally to the class.  They are shadowed by
-   any subsequent local declaration (including parameter names).
-
-   If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
-   which have static meaning (i.e., static members, static
-   member functions, enum declarations, etc).
-
-   If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
-   which can be seen locally to the class (as in 1), but
-   know that we are doing this for declaration purposes
-   (i.e. friend foo::bar (int)).
-
-   So that we may avoid calls to lookup_name, we cache the _TYPE
-   nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
-
-   For multiple inheritance, we perform a two-pass depth-first search
-   of the type lattice.  The first pass performs a pre-order search,
-   marking types after the type has had its fields installed in
-   the appropriate IDENTIFIER_CLASS_VALUE slot.  The second pass merely
-   unmarks the marked types.  If a field or member function name
-   appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
-   that name becomes `error_mark_node'.  */
-
-void
-pushclass (type, modify)
-     tree type;
-     int modify;
-{
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "pushclass");
-  debug_bindings_indentation += 4;
-#endif
-
-  push_memoized_context (type, modify);
-
-  current_class_depth++;
-  *current_class_stack++ = current_class_name;
-  *current_class_stack++ = current_class_type;
-  if (current_class_stack >= current_class_base + current_class_stacksize)
-    {
-      current_class_base =
-	(tree *)xrealloc (current_class_base,
-			  sizeof (tree) * (current_class_stacksize + 10));
-      current_class_stack = current_class_base + current_class_stacksize;
-      current_class_stacksize += 10;
-    }
-
-  current_class_name = TYPE_NAME (type);
-  if (TREE_CODE (current_class_name) == TYPE_DECL)
-    current_class_name = DECL_NAME (current_class_name);
-  current_class_type = type;
-
-  if (prev_class_type != NULL_TREE
-      && (type != prev_class_type
-	  || TYPE_SIZE (prev_class_type) == NULL_TREE
-	  /* ??? Is this necessary any more?  */
-	  || IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (prev_class_type)))
-      && (current_class_depth == 1 || modify == 3))
-    {
-      /* Forcibly remove any old class remnants.  */
-      popclass (-1);
-      prev_class_type = 0;
-    }
-
-  pushlevel_class ();
-
-  if (modify)
-    {
-      tree tags;
-      tree this_fndecl = current_function_decl;
-
-      if (current_function_decl
-	  && DECL_CONTEXT (current_function_decl)
-	  && TREE_CODE (DECL_CONTEXT (current_function_decl)) == FUNCTION_DECL)
-	current_function_decl = DECL_CONTEXT (current_function_decl);
-      else
-	current_function_decl = NULL_TREE;
-
-      if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
-        {
-          declare_uninstantiated_type_level ();
-	  overload_template_name (current_class_name, 0);
-        }
-      else if (type != prev_class_type)
-	{
-	  build_mi_matrix (type);
-	  push_class_decls (type);
-	  free_mi_matrix ();
-	  prev_class_type = type;
-	}
-      else
-	unuse_fields (type);
-
-      for (tags = CLASSTYPE_TAGS (type); tags; tags = TREE_CHAIN (tags))
-	{
-	  TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 1;
-	  if (! TREE_PURPOSE (tags))
-	    continue;
-	  pushtag (TREE_PURPOSE (tags), TREE_VALUE (tags));
-	  if (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags)) == NULL_TREE
-	      && TREE_CODE (TYPE_NAME (TREE_VALUE (tags))) == TYPE_DECL)
-	    IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags))
-	      = TYPE_NAME (TREE_VALUE (tags));
-	}
-
-      current_function_decl = this_fndecl;
-    }
-
-  if (flag_cadillac)
-    cadillac_push_class (type);
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
- 
-/* Get out of the current class scope. If we were in a class scope
-   previously, that is the one popped to.  The flag MODIFY tells
-   whether the current scope declarations needs to be modified
-   as a result of popping to the previous scope.  */
-void
-popclass (modify)
-     int modify;
-{
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "popclass");
-  debug_bindings_indentation += 4;
-#endif
-
-  if (flag_cadillac)
-    cadillac_pop_class ();
-
-  if (modify < 0)
-    {
-      /* Back this old class out completely.  */
-      tree tags = CLASSTYPE_TAGS (prev_class_type);
-
-      pop_class_decls (prev_class_type);
-      while (tags)
-	{
-	  TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
-	  IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags)) = NULL_TREE;
-	  tags = TREE_CHAIN (tags);
-	}
-      goto ret;
-    }
-
-  if (modify)
-    {
-      /* Just remove from this class what didn't make
-	 it into IDENTIFIER_CLASS_VALUE.  */
-      tree tags = CLASSTYPE_TAGS (current_class_type);
-
-      while (tags)
-	{
-	  TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
-	  if (TREE_PURPOSE (tags))
-	    IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (tags)) = NULL_TREE;
-	  tags = TREE_CHAIN (tags);
-	}
-    }
-  if (TREE_CODE (current_class_type) == UNINSTANTIATED_P_TYPE)
-    undo_template_name_overload (current_class_name, 0);
-  poplevel_class ();
-
-  current_class_depth--;
-  current_class_type = *--current_class_stack;
-  current_class_name = *--current_class_stack;
-
-  if (current_class_type)
-    {
-      if (CLASSTYPE_VTBL_PTR (current_class_type))
-	{
-	  current_vtable_decl = lookup_name (DECL_NAME (CLASSTYPE_VTBL_PTR (current_class_type)), 0);
-	  if (current_vtable_decl)
-	    current_vtable_decl = build_indirect_ref (current_vtable_decl,
-						      NULL);
-	}
-      current_class_decl = lookup_name (get_identifier (THIS_NAME), 0);
-      if (current_class_decl)
-	{
-	  if (TREE_CODE (TREE_TYPE (current_class_decl)) == POINTER_TYPE)
-	    {
-	      tree temp;
-	      /* Can't call build_indirect_ref here, because it has special
-		 logic to return C_C_D given this argument.  */
-	      C_C_D = build1 (INDIRECT_REF, current_class_type, current_class_decl);
-	      temp = TREE_TYPE (TREE_TYPE (current_class_decl));
-	      TREE_READONLY (C_C_D) = TYPE_READONLY (temp);
-	      TREE_SIDE_EFFECTS (C_C_D) = TYPE_VOLATILE (temp);
-	      TREE_THIS_VOLATILE (C_C_D) = TYPE_VOLATILE (temp);
-	    }
-	  else
-	    C_C_D = current_class_decl;
-	}
-      else C_C_D = NULL_TREE;
-    }
-  else
-    {
-      current_class_decl = NULL_TREE;
-      current_vtable_decl = NULL_TREE;
-      C_C_D = NULL_TREE;
-    }
-
-  pop_memoized_context (modify);
-
- ret:
-  ;
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-/* Set global variables CURRENT_LANG_NAME to appropriate value
-   so that behavior of name-mangling machinery is correct.  */
-
-void
-push_lang_context (name)
-     tree name;
-{
-  *current_lang_stack++ = current_lang_name;
-  if (current_lang_stack >= current_lang_base + current_lang_stacksize)
-    {
-      current_lang_base =
-	(tree *)xrealloc (current_lang_base,
-			  sizeof (tree) * (current_lang_stacksize + 10));
-      current_lang_stack = current_lang_base + current_lang_stacksize;
-      current_lang_stacksize += 10;
-    }
-
-  if (name == lang_name_cplusplus)
-    {
-      strict_prototype = strict_prototypes_lang_cplusplus;
-      current_lang_name = name;
-    }
-  else if (name == lang_name_c)
-    {
-      strict_prototype = strict_prototypes_lang_c;
-      current_lang_name = name;
-    }
-  else
-    error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
-
-  if (flag_cadillac)
-    cadillac_push_lang (name);
-}
-  
-/* Get out of the current language scope.  */
-void
-pop_lang_context ()
-{
-  if (flag_cadillac)
-    cadillac_pop_lang ();
-
-  current_lang_name = *--current_lang_stack;
-  if (current_lang_name == lang_name_cplusplus)
-    strict_prototype = strict_prototypes_lang_cplusplus;
-  else if (current_lang_name == lang_name_c)
-    strict_prototype = strict_prototypes_lang_c;
-}
-
-int
-root_lang_context_p ()
-{
-  return current_lang_stack == current_lang_base;
-}
-
-/* Type instantiation routines.  */
-
-/* This function will instantiate the type of the expression given
-   in RHS to match the type of LHSTYPE.  If LHSTYPE is NULL_TREE,
-   or other errors exist, the TREE_TYPE of RHS will be ERROR_MARK_NODE.
-
-   This function is used in build_modify_expr, convert_arguments,
-   build_c_cast, and compute_conversion_costs.  */
-tree
-instantiate_type (lhstype, rhs, complain)
-     tree lhstype, rhs;
-     int complain;
-{
-  if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
-    {
-      if (complain)
-	error ("not enough type information");
-      return error_mark_node;
-    }
-
-  if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
-    return rhs;
-
-  /* This should really only be used when attempting to distinguish
-     what sort of a pointer to function we have.  For now, any
-     arithmetic operation which is not supported on pointers
-     is rejected as an error.  */
-
-  switch (TREE_CODE (rhs))
-    {
-    case TYPE_EXPR:
-    case CONVERT_EXPR:
-    case SAVE_EXPR:
-    case CONSTRUCTOR:
-    case BUFFER_REF:
-      my_friendly_abort (177);
-      return error_mark_node;
-
-    case INDIRECT_REF:
-    case ARRAY_REF:
-      TREE_TYPE (rhs) = lhstype;
-      lhstype = build_pointer_type (lhstype);
-      TREE_OPERAND (rhs, 0)
-	= instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
-      if (TREE_OPERAND (rhs, 0) == error_mark_node)
-	return error_mark_node;
-
-      return rhs;
-
-    case NOP_EXPR:
-      rhs = copy_node (TREE_OPERAND (rhs, 0));
-      TREE_TYPE (rhs) = unknown_type_node;
-      return instantiate_type (lhstype, rhs, complain);
-
-    case COMPONENT_REF:
-      {
-	tree field = TREE_OPERAND (rhs, 1);
-	if (TREE_CODE (field) == TREE_LIST)
-	  {
-	    tree function = instantiate_type (lhstype, field, complain);
-	    if (function == error_mark_node)
-	      return error_mark_node;
-	    my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 185);
-	    if (DECL_VINDEX (function))
-	      {
-		tree base = TREE_OPERAND (rhs, 0);
-		tree base_ptr = build_unary_op (ADDR_EXPR, base, 0);
-		if (base_ptr == error_mark_node)
-		  return error_mark_node;
-		base_ptr = convert_pointer_to (DECL_CONTEXT (function), base_ptr);
-		if (base_ptr == error_mark_node)
-		  return error_mark_node;
-		return build_vfn_ref (&base_ptr, base, DECL_VINDEX (function));
-	      }
-	    return function;
-	  }
-
-	my_friendly_assert (TREE_CODE (field) == FIELD_DECL, 178);
-	my_friendly_assert (!(TREE_CODE (TREE_TYPE (field)) == FUNCTION_TYPE
-			      || TREE_CODE (TREE_TYPE (field)) == METHOD_TYPE),
-			    179);
-
-	TREE_TYPE (rhs) = lhstype;
-	/* First look for an exact match  */
-
-	while (field && TREE_TYPE (field) != lhstype)
-	  field = TREE_CHAIN (field);
-	if (field)
-	  {
-	    TREE_OPERAND (rhs, 1) = field;
-	    return rhs;
-	  }
-
-	/* No exact match found, look for a compatible function.  */
-	field = TREE_OPERAND (rhs, 1);
-	while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
-	  field = TREE_CHAIN (field);
-	if (field)
-	  {
-	    TREE_OPERAND (rhs, 1) = field;
-	    field = TREE_CHAIN (field);
-	    while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
-	      field = TREE_CHAIN (field);
-	    if (field)
-	      {
-		if (complain)
-		  error ("ambiguous overload for COMPONENT_REF requested");
-		return error_mark_node;
-	      }
-	  }
-	else
-	  {
-	    if (complain)
-	      error ("no appropriate overload exists for COMPONENT_REF");
-	    return error_mark_node;
-	  }
-	return rhs;
-      }
-
-    case TREE_LIST:
-      {
-	tree elem, baselink, name;
-	int globals = overloaded_globals_p (rhs);
-
-	/* If there's only one function we know about, return that.  */
-	if (globals > 0 && TREE_CHAIN (rhs) == NULL_TREE)
-	  return TREE_VALUE (rhs);
-
-	/* First look for an exact match.  Search either overloaded
-	   functions or member functions.  May have to undo what
-	   `default_conversion' might do to lhstype.  */
-
-	if (TREE_CODE (lhstype) == POINTER_TYPE)
-	  if (TREE_CODE (TREE_TYPE (lhstype)) == FUNCTION_TYPE
-	      || TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
-	    lhstype = TREE_TYPE (lhstype);
-	  else
-	    {
-	      if (complain)
-		error ("invalid type combination for overload");
-	      return error_mark_node;
-	    }
-
-	if (TREE_CODE (lhstype) != FUNCTION_TYPE && globals > 0)
-	  {
-	    if (complain)
-	      error ("cannot resolve overloaded function `%s' based on non-function type",
-		     IDENTIFIER_POINTER (TREE_PURPOSE (rhs)));
-	    return error_mark_node;
-	  }
-
-	if (globals > 0)
-	  {
-	    my_friendly_assert (TREE_CODE (TREE_VALUE (rhs)) == FUNCTION_DECL,
-				180);
-	    elem = rhs;
-	    while (elem)
-	      if (TREE_TYPE (TREE_VALUE (elem)) != lhstype)
-		elem = TREE_CHAIN (elem);
-	      else
-		return TREE_VALUE (elem);
-	    /* No exact match found, look for a compatible function.  */
-	    elem = rhs;
-	    while (elem && ! comp_target_types (lhstype, TREE_TYPE (TREE_VALUE (elem)), 1))
-	      elem = TREE_CHAIN (elem);
-	    if (elem)
-	      {
-		tree save_elem = TREE_VALUE (elem);
-		elem = TREE_CHAIN (elem);
-		while (elem && ! comp_target_types (lhstype, TREE_TYPE (TREE_VALUE (elem)), 0))
-		  elem = TREE_CHAIN (elem);
-		if (elem)
-		  {
-		    if (complain)
-		      error ("ambiguous overload for overloaded function requested");
-		    return error_mark_node;
-		  }
-		return save_elem;
-	      }
-	    if (complain)
-	      {
-		if (TREE_CHAIN (rhs))
-		  error ("no appropriate overload for overloaded function `%s' exists",
-			 IDENTIFIER_POINTER (TREE_PURPOSE (rhs)));
-		else
-		  error ("function `%s' has inappropriate type signature",
-			 IDENTIFIER_POINTER (TREE_PURPOSE (rhs)));
-	      }
-	    return error_mark_node;
-	  }
-
-	if (TREE_NONLOCAL_FLAG (rhs))
-	  {
-	    /* Got to get it as a baselink.  */
-	    rhs = lookup_fnfields (TYPE_BINFO (current_class_type),
-				   TREE_PURPOSE (rhs), 0);
-	  }
-	else
-	  {
-	    my_friendly_assert (TREE_CHAIN (rhs) == NULL_TREE, 181);
-	    if (TREE_CODE (TREE_VALUE (rhs)) == TREE_LIST)
-	      rhs = TREE_VALUE (rhs);
-	    my_friendly_assert (TREE_CODE (TREE_VALUE (rhs)) == FUNCTION_DECL,
-				182);
-	  }
-
-	for (baselink = rhs; baselink;
-	     baselink = next_baselink (baselink))
-	  {
-	    elem = TREE_VALUE (baselink);
-	    while (elem)
-	      if (TREE_TYPE (elem) != lhstype)
-		elem = TREE_CHAIN (elem);
-	      else
-		return elem;
-	  }
-
-	/* No exact match found, look for a compatible method.  */
-	for (baselink = rhs; baselink;
-	     baselink = next_baselink (baselink))
-	  {
-	    elem = TREE_VALUE (baselink);
-	    while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem), 1))
-	      elem = TREE_CHAIN (elem);
-	    if (elem)
-	      {
-		tree save_elem = elem;
-		elem = TREE_CHAIN (elem);
-		while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem), 0))
-		  elem = TREE_CHAIN (elem);
-		if (elem)
-		  {
-		    if (complain)
-		      error ("ambiguous overload for overloaded method requested");
-		    return error_mark_node;
-		  }
-		return save_elem;
-	      }
-	    name = DECL_NAME (TREE_VALUE (rhs));
-	    if (TREE_CODE (lhstype) == FUNCTION_TYPE && globals < 0)
-	      {
-		/* Try to instantiate from non-member functions.  */
-		rhs = IDENTIFIER_GLOBAL_VALUE (name);
-		if (rhs && TREE_CODE (rhs) == TREE_LIST)
-		  {
-		    /* This code seems to be missing a `return'.  */
-		    my_friendly_abort (4);
-		    instantiate_type (lhstype, rhs, complain);
-		  }
-	      }
-	  }
-	if (complain)
-	  error ("no static member functions named `%s'",
-		 IDENTIFIER_POINTER (name));
-	return error_mark_node;
-      }
-
-    case CALL_EXPR:
-      /* This is too hard for now.  */
-      my_friendly_abort (183);
-      return error_mark_node;
-
-    case PLUS_EXPR:
-    case MINUS_EXPR:
-    case COMPOUND_EXPR:
-      TREE_OPERAND (rhs, 0) = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
-      if (TREE_OPERAND (rhs, 0) == error_mark_node)
-	return error_mark_node;
-      TREE_OPERAND (rhs, 1) = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
-      if (TREE_OPERAND (rhs, 1) == error_mark_node)
-	return error_mark_node;
-
-      TREE_TYPE (rhs) = lhstype;
-      return rhs;
-
-    case MULT_EXPR:
-    case TRUNC_DIV_EXPR:
-    case FLOOR_DIV_EXPR:
-    case CEIL_DIV_EXPR:
-    case ROUND_DIV_EXPR:
-    case RDIV_EXPR:
-    case TRUNC_MOD_EXPR:
-    case FLOOR_MOD_EXPR:
-    case CEIL_MOD_EXPR:
-    case ROUND_MOD_EXPR:
-    case FIX_ROUND_EXPR:
-    case FIX_FLOOR_EXPR:
-    case FIX_CEIL_EXPR:
-    case FIX_TRUNC_EXPR:
-    case FLOAT_EXPR:
-    case NEGATE_EXPR:
-    case ABS_EXPR:
-    case MAX_EXPR:
-    case MIN_EXPR:
-    case FFS_EXPR:
-
-    case BIT_AND_EXPR:
-    case BIT_IOR_EXPR:
-    case BIT_XOR_EXPR:
-    case LSHIFT_EXPR:
-    case RSHIFT_EXPR:
-    case LROTATE_EXPR:
-    case RROTATE_EXPR:
-
-    case PREINCREMENT_EXPR:
-    case PREDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-      if (complain)
-	error ("illegal operation on uninstantiated type");
-      return error_mark_node;
-
-    case TRUTH_AND_EXPR:
-    case TRUTH_OR_EXPR:
-    case TRUTH_XOR_EXPR:
-    case LT_EXPR:
-    case LE_EXPR:
-    case GT_EXPR:
-    case GE_EXPR:
-    case EQ_EXPR:
-    case NE_EXPR:
-    case TRUTH_ANDIF_EXPR:
-    case TRUTH_ORIF_EXPR:
-    case TRUTH_NOT_EXPR:
-      if (complain)
-	error ("not enough type information");
-      return error_mark_node;
-
-    case COND_EXPR:
-      if (type_unknown_p (TREE_OPERAND (rhs, 0)))
-	{
-	  if (complain)
-	    error ("not enough type information");
-	  return error_mark_node;
-	}
-      TREE_OPERAND (rhs, 1) = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
-      if (TREE_OPERAND (rhs, 1) == error_mark_node)
-	return error_mark_node;
-      TREE_OPERAND (rhs, 2) = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), complain);
-      if (TREE_OPERAND (rhs, 2) == error_mark_node)
-	return error_mark_node;
-
-      TREE_TYPE (rhs) = lhstype;
-      return rhs;
-
-    case MODIFY_EXPR:
-      TREE_OPERAND (rhs, 1) = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
-      if (TREE_OPERAND (rhs, 1) == error_mark_node)
-	return error_mark_node;
-
-      TREE_TYPE (rhs) = lhstype;
-      return rhs;
-      
-    case ADDR_EXPR:
-      if (TREE_CODE (lhstype) != POINTER_TYPE)
-	{
-	  if (complain)
-	    error ("type for resolving address of overloaded function must be pointer type");
-	  return error_mark_node;
-	}
-      TREE_TYPE (rhs) = lhstype;
-      lhstype = TREE_TYPE (lhstype);
-      TREE_OPERAND (rhs, 0) = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
-      if (TREE_OPERAND (rhs, 0) == error_mark_node)
-	return error_mark_node;
-
-      mark_addressable (TREE_OPERAND (rhs, 0));
-      return rhs;
-
-    case ENTRY_VALUE_EXPR:
-      my_friendly_abort (184);
-      return error_mark_node;
-
-    case ERROR_MARK:
-      return error_mark_node;
-
-    default:
-      my_friendly_abort (185);
-      return error_mark_node;
-    }
-}
-
-/* Return the name of the virtual function pointer field
-   (as an IDENTIFIER_NODE) for the given TYPE.  Note that
-   this may have to look back through base types to find the
-   ultimate field name.  (For single inheritance, these could
-   all be the same name.  Who knows for multiple inheritance).  */
-static tree
-get_vfield_name (type)
-     tree type;
-{
-  tree binfo = TYPE_BINFO (type);
-  char *buf;
-
-  while (BINFO_BASETYPES (binfo)
-	 && TYPE_VIRTUAL_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
-	 && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
-    binfo = BINFO_BASETYPE (binfo, 0);
-
-  type = BINFO_TYPE (binfo);
-  buf = (char *)alloca (sizeof (VFIELD_NAME_FORMAT)
-			+ TYPE_NAME_LENGTH (type) + 2);
-  sprintf (buf, VFIELD_NAME_FORMAT, TYPE_NAME_STRING (type));
-  return get_identifier (buf);
-}
-
-void
-print_class_statistics ()
-{
-#ifdef GATHER_STATISTICS
-  fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
-  fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
-  fprintf (stderr, "build_method_call = %d (inner = %d)\n",
-	   n_build_method_call, n_inner_fields_searched);
-  if (n_vtables)
-    {
-      fprintf (stderr, "vtables = %d; vtable searches = %d\n",
-	       n_vtables, n_vtable_searches);
-      fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
-	       n_vtable_entries, n_vtable_elems);
-    }
-#endif
-}
diff --git a/gnu/gcc2/cc1plus/cp-class.h b/gnu/gcc2/cc1plus/cp-class.h
deleted file mode 100644
index 2c042d72741f..000000000000
--- a/gnu/gcc2/cc1plus/cp-class.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/* Variables and structures for overloading rules.
-   Copyright (C) 1993 Free Software Foundation, Inc.
-
-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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* The following structure is used when comparing various alternatives
-   for overloading.  The unsigned quantity `strikes.i' is used
-   for fast comparison of two possibilities.  This number is an
-   aggregate of four constituents:
-
-     EVIL: if this is non-zero, then the candidate should not be considered
-     ELLIPSIS: if this is non-zero, then some actual argument has been matched
-               against an ellipsis
-     USER: if this is non-zero, then a user-defined type conversion is needed
-     B_OR_D: if this is non-zero, then use a base pointer instead of the
-             type of the pointer we started with.
-     EASY: if this is non-zero, then we have a builtin conversion
-           (such as int to long, int to float, etc) to do.
-
-   If two candidates require user-defined type conversions, and the
-   type conversions are not identical, then an ambiguity error
-   is reported.
-
-   If two candidates agree on user-defined type conversions,
-   and one uses pointers of strictly higher type (derived where
-   another uses base), then that alternative is silently chosen.
-
-   If two candidates have a non-monotonic derived/base pointer
-   relationship, and/or a non-monotonic easy conversion relationship,
-   then a warning is emitted to show which paths are possible, and
-   which one is being chosen.
-
-   For example:
-
-   int i;
-   double x;
-
-   overload f;
-   int f (int, int);
-   double f (double, double);
-
-   f (i, x);	// draws a warning
-
-   struct B
-   {
-     f (int);
-   } *bb;
-   struct D : B
-   {
-     f (double);
-   } *dd;
-
-   dd->f (x);	// exact match
-   dd->f (i);	// draws warning
-
-   Note that this technique really only works for 255 arguments.  Perhaps
-   this is not enough.  */
-
-struct candidate
-{
-  tree function;		/* A FUNCTION_DECL */
-
-  unsigned char evil;		/* !0 if this will never convert.  */
-  unsigned char ellipsis;	/* !0 if a match against an ellipsis occurred */
-  unsigned char user;		/* !0 if at least one user-defined type conv.  */
-  unsigned short b_or_d;	/* count number of derived->base or
-				   base->derived conv.  */
-  unsigned short easy;		/* count number of builtin type conv.  */
-  tree arg;			/* first parm to function.  */
-  unsigned short *harshness;	/* Indexed by argument number, encodes
-				   evil, user, d_to_b, and easy strikes for
-				   that argument.
-				   At end of array, we store the index+1
-				   of where we started using default
-				   parameters, or 0 if there are none.  */
-  union
-    {
-      tree field;		/* If no evil strikes, the FUNCTION_DECL of
-				   the function (if a member function).  */
-      int bad_arg;		/* the index of the first bad argument:
-				   0 if no bad arguments
-				   > 0 is first bad argument
-				   -1 if extra actual arguments
-				   -2 if too few actual arguments.
-				   -3 if const/non const method mismatch.
-				   -4 if type unification failed.
-				   -5 if contravariance violation.  */
-    } u;
-};
-int rank_for_overload ();
-
-/* Variables shared between cp-class.c and cp-call.c.  */
-
-extern int n_vtables;
-extern int n_vtable_entries;
-extern int n_vtable_searches;
-extern int n_vtable_elems;
-extern int n_convert_harshness;
-extern int n_compute_conversion_costs;
-extern int n_build_method_call;
-extern int n_inner_fields_searched;
diff --git a/gnu/gcc2/cc1plus/cp-cvt.c b/gnu/gcc2/cc1plus/cp-cvt.c
deleted file mode 100644
index 998c5034925c..000000000000
--- a/gnu/gcc2/cc1plus/cp-cvt.c
+++ /dev/null
@@ -1,1790 +0,0 @@
-/* Language-level data type conversion for GNU C++.
-   Copyright (C) 1987, 1988, 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* This file contains the functions for converting C expressions
-   to different data types.  The only entry point is `convert'.
-   Every language front end must have a `convert' function
-   but what kind of conversions it does will depend on the language.  */
-
-#include "config.h"
-#include "tree.h"
-#include "flags.h"
-#include "cp-tree.h"
-#include "convert.h"
-
-#undef NULL
-#define NULL (char *)0
-
-/* Change of width--truncation and extension of integers or reals--
-   is represented with NOP_EXPR.  Proper functioning of many things
-   assumes that no other conversions can be NOP_EXPRs.
-
-   Conversion between integer and pointer is represented with CONVERT_EXPR.
-   Converting integer to real uses FLOAT_EXPR
-   and real to integer uses FIX_TRUNC_EXPR.
-
-   Here is a list of all the functions that assume that widening and
-   narrowing is always done with a NOP_EXPR:
-     In c-convert.c, convert_to_integer.
-     In c-typeck.c, build_binary_op_nodefault (boolean ops),
-        and truthvalue_conversion.
-     In expr.c: expand_expr, for operands of a MULT_EXPR.
-     In fold-const.c: fold.
-     In tree.c: get_narrower and get_unwidened.
-
-   C++: in multiple-inheritance, converting between pointers may involve
-   adjusting them by a delta stored within the class definition.  */
-
-/* Subroutines of `convert'.  */
-
-static tree
-cp_convert_to_pointer (type, expr)
-     tree type, expr;
-{
-  register tree intype = TREE_TYPE (expr);
-  register enum tree_code form = TREE_CODE (intype);
-  
-  if (form == POINTER_TYPE)
-    {
-      intype = TYPE_MAIN_VARIANT (intype);
-
-      if (TYPE_MAIN_VARIANT (type) != intype
-	  && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
-	  && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
-	{
-	  enum tree_code code = PLUS_EXPR;
-	  tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
-	  if (binfo == error_mark_node)
-	    return error_mark_node;
-	  if (binfo == NULL_TREE)
-	    {
-	      binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
-	      if (binfo == error_mark_node)
-		return error_mark_node;
-	      code = MINUS_EXPR;
-	    }
-	  if (binfo)
-	    {
-	      if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
-		  || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
-		  || ! BINFO_OFFSET_ZEROP (binfo))
-		{
-		  /* Need to get the path we took.  */
-		  tree path;
-
-		  if (code == PLUS_EXPR)
-		    get_base_distance (TREE_TYPE (type), TREE_TYPE (intype), 0, &path);
-		  else
-		    get_base_distance (TREE_TYPE (intype), TREE_TYPE (type), 0, &path);
-		  return build_vbase_path (code, type, expr, path, 0);
-		}
-	    }
-	}
-      return build1 (NOP_EXPR, type, expr);
-    }
-
-  my_friendly_assert (form != OFFSET_TYPE, 186);
-
-  if (IS_AGGR_TYPE (intype))
-    {
-      /* If we cannot convert to the specific pointer type,
-	 try to convert to the type `void *'.  */
-      tree rval;
-      rval = build_type_conversion (CONVERT_EXPR, type, expr, 1);
-      if (rval)
-	{
-	  if (rval == error_mark_node)
-	    error ("ambiguous pointer conversion");
-	  return rval;
-	}
-    }
-
-  return convert_to_pointer (type, expr);
-}
-
-/* Like convert, except permit conversions to take place which
-   are not normally allowed due to visibility restrictions
-   (such as conversion from sub-type to private super-type).  */
-static tree
-convert_to_pointer_force (type, expr)
-     tree type, expr;
-{
-  register tree intype = TREE_TYPE (expr);
-  register enum tree_code form = TREE_CODE (intype);
-  
-  if (integer_zerop (expr))
-    {
-      if (type == TREE_TYPE (null_pointer_node))
-	return null_pointer_node;
-      expr = build_int_2 (0, 0);
-      TREE_TYPE (expr) = type;
-      return expr;
-    }
-
-  if (form == POINTER_TYPE)
-    {
-      intype = TYPE_MAIN_VARIANT (intype);
-
-      if (TYPE_MAIN_VARIANT (type) != intype
-	  && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
-	  && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
-	{
-	  enum tree_code code = PLUS_EXPR;
-	  tree path;
-	  int distance = get_base_distance (TREE_TYPE (type),
-					    TREE_TYPE (intype), 0, &path);
-	  if (distance == -2)
-	    {
-	    ambig:
-	      error_with_aggr_type (TREE_TYPE (type), "type `%s' is ambiguous baseclass of `%s'",
-				    TYPE_NAME_STRING (TREE_TYPE (intype)));
-	      return error_mark_node;
-	    }
-	  if (distance == -1)
-	    {
-	      distance = get_base_distance (TREE_TYPE (intype),
-					    TREE_TYPE (type), 0, &path);
-	      if (distance == -2)
-		goto ambig;
-	      if (distance < 0)
-		/* Doesn't need any special help from us.  */
-		return build1 (NOP_EXPR, type, expr);
-
-	      code = MINUS_EXPR;
-	    }
-	  return build_vbase_path (code, type, expr, path, 0);
-	}
-      return build1 (NOP_EXPR, type, expr);
-    }
-
-  return cp_convert_to_pointer (type, expr);
-}
-
-/* We are passing something to a function which requires a reference.
-   The type we are interested in is in TYPE. The initial
-   value we have to begin with is in ARG.
-
-   FLAGS controls how we manage visibility checking.
-   CHECKCONST controls if we report error messages on const subversion.  */
-static tree
-build_up_reference (type, arg, flags, checkconst)
-     tree type, arg;
-     int flags, checkconst;
-{
-  tree rval, targ;
-  int literal_flag = 0;
-  tree argtype = TREE_TYPE (arg), basetype = argtype;
-  tree target_type = TREE_TYPE (type);
-  tree binfo = NULL_TREE;
-
-  my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
-  if (flags != 0
-      && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
-      && IS_AGGR_TYPE (argtype)
-      && IS_AGGR_TYPE (target_type))
-    {
-      binfo = get_binfo (target_type, argtype,
-			      (flags & LOOKUP_PROTECTED_OK) ? 3 : 2);
-      if ((flags & LOOKUP_PROTECT) && binfo == error_mark_node)
-	return error_mark_node;
-      if (basetype == NULL_TREE)
-	return (tree) error_not_base_type (target_type, argtype);
-      basetype = BINFO_TYPE (binfo);
-    }
-
-  /* Pass along const and volatile down into the type. */
-  if (TYPE_READONLY (type) || TYPE_VOLATILE (type))
-    target_type = build_type_variant (target_type, TYPE_READONLY (type),
-				      TYPE_VOLATILE (type));
-  targ = arg;
-  if (TREE_CODE (targ) == SAVE_EXPR)
-    targ = TREE_OPERAND (targ, 0);
-
-  switch (TREE_CODE (targ))
-    {
-    case INDIRECT_REF:
-      /* This is a call to a constructor which did not know what it was
-	 initializing until now: it needs to initialize a temporary.  */
-      if (TREE_HAS_CONSTRUCTOR (targ))
-	{
-	  tree temp = build_cplus_new (argtype, TREE_OPERAND (targ, 0), 1);
-	  TREE_HAS_CONSTRUCTOR (targ) = 0;
-	  return build_up_reference (type, temp, flags, 1);
-	}
-      /* Let &* cancel out to simplify resulting code.
-         Also, throw away intervening NOP_EXPRs.  */
-      arg = TREE_OPERAND (targ, 0);
-      if (TREE_CODE (arg) == NOP_EXPR || TREE_CODE (arg) == NON_LVALUE_EXPR
-	  || (TREE_CODE (arg) == CONVERT_EXPR && TREE_REFERENCE_EXPR (arg)))
-	arg = TREE_OPERAND (arg, 0);
-
-      /* in doing a &*, we have to get rid of the const'ness on the pointer
-	 value.  Haven't thought about volatile here.  Pointers come to mind
-	 here.  */
-      if (TREE_READONLY (arg))
-	{
-	  arg = copy_node (arg);
-	  TREE_READONLY (arg) = 0;
-	}
-
-      rval = build1 (CONVERT_EXPR, type, arg);
-      TREE_REFERENCE_EXPR (rval) = 1;
-
-      /* propagate the const flag on something like:
-
-	 class Base {
-	 public:
-	   int foo;
-	 };
-
-      class Derived : public Base {
-      public:
-	int bar;
-      };
-
-      void func(Base&);
-
-      void func2(const Derived& d) {
-	func(d);
-      }
-
-        on the d parameter.  The below could have been avoided, if the flags
-        were down in the tree, not sure why they are not.  (mrs) */
-      /* The below code may have to be propagated to other parts of this
-	 switch.  */
-      if (TREE_READONLY (targ) && !TREE_READONLY (arg)
-	  && (TREE_CODE (arg) == PARM_DECL || TREE_CODE (arg) == VAR_DECL)
-	  && TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE
-	  && (TYPE_READONLY (target_type) && checkconst))
-	{
-	  arg = copy_node (arg);
-	  TREE_READONLY (arg) = TREE_READONLY (targ);
-	}
-      literal_flag = TREE_CONSTANT (arg);
-
-      goto done_but_maybe_warn;
-
-      /* Get this out of a register if we happened to be in one by accident.
-	 Also, build up references to non-lvalues it we must.  */
-      /* For &x[y], return (&) x+y */
-    case ARRAY_REF:
-      if (mark_addressable (TREE_OPERAND (targ, 0)) == 0)
-	return error_mark_node;
-      rval = build_binary_op (PLUS_EXPR, TREE_OPERAND (targ, 0),
-			      TREE_OPERAND (targ, 1), 1);
-      TREE_TYPE (rval) = type;
-      if (TREE_CONSTANT (TREE_OPERAND (targ, 1))
-	  && staticp (TREE_OPERAND (targ, 0)))
-	TREE_CONSTANT (rval) = 1;
-      goto done;
-
-    case SCOPE_REF:
-      /* Could be a reference to a static member.  */
-      {
-	tree field = TREE_OPERAND (targ, 1);
-	if (TREE_STATIC (field))
-	  {
-	    rval = build1 (ADDR_EXPR, type, field);
-	    literal_flag = 1;
-	    goto done;
-	  }
-      }
-
-      /* We should have farmed out member pointers above.  */
-      my_friendly_abort (188);
-
-    case COMPONENT_REF:
-      rval = build_component_addr (targ, build_pointer_type (argtype),
-				   "attempt to make a reference to bit-field structure member `%s'");
-      TREE_TYPE (rval) = type;
-      literal_flag = staticp (TREE_OPERAND (targ, 0));
-
-      goto done_but_maybe_warn;
-
-      /* Anything not already handled and not a true memory reference
-	 needs to have a reference built up.  Do so silently for
-	 things like integers and return values from function,
-	 but complain if we need a reference to something declared
-	 as `register'.  */
-
-    case RESULT_DECL:
-      if (staticp (targ))
-	literal_flag = 1;
-      TREE_ADDRESSABLE (targ) = 1;
-      put_var_into_stack (targ);
-      break;
-
-    case PARM_DECL:
-      if (targ == current_class_decl)
-	{
-	  error ("address of `this' not available");
-#if 0
-	  /* This code makes the following core dump the compiler on a sun4,
-	     if the code below is used.
-
-	     class e_decl;
-	     class a_decl;
-	     typedef a_decl* a_ref;
-
-	     class a_s {
-	     public:
-	       a_s();
-	       void* append(a_ref& item);
-	     };
-	     class a_decl {
-	     public:
-	       a_decl (e_decl *parent);
-	       a_s  generic_s;
-	       a_s  decls;
-	       e_decl* parent;
-	     };
-
-	     class e_decl {
-	     public:
-	       e_decl();
-	       a_s implementations;
-	     };
-
-	     void foobar(void *);
-
-	     a_decl::a_decl(e_decl *parent) {
-	       parent->implementations.append(this);
-	     }
-	   */
-
-	  TREE_ADDRESSABLE (targ) = 1; /* so compiler doesn't die later */
-	  put_var_into_stack (targ);
-	  break;
-#else
-	  return error_mark_node;
-#endif
-	}
-      /* Fall through.  */
-    case VAR_DECL:
-    case CONST_DECL:
-      if (DECL_REGISTER (targ) && !TREE_ADDRESSABLE (targ))
-	warning ("address needed to build reference for `%s', which is declared `register'",
-		 IDENTIFIER_POINTER (DECL_NAME (targ)));
-      else if (staticp (targ))
-	literal_flag = 1;
-
-      TREE_ADDRESSABLE (targ) = 1;
-      put_var_into_stack (targ);
-      break;
-
-    case COMPOUND_EXPR:
-      {
-	tree real_reference = build_up_reference (type, TREE_OPERAND (targ, 1),
-						  LOOKUP_PROTECT, checkconst);
-	rval = build (COMPOUND_EXPR, type, TREE_OPERAND (targ, 0), real_reference);
-	TREE_CONSTANT (rval) = staticp (TREE_OPERAND (targ, 1));
-	return rval;
-      }
-
-    case MODIFY_EXPR:
-    case INIT_EXPR:
-      {
-	tree real_reference = build_up_reference (type, TREE_OPERAND (targ, 0),
-						  LOOKUP_PROTECT, checkconst);
-	rval = build (COMPOUND_EXPR, type, arg, real_reference);
-	TREE_CONSTANT (rval) = staticp (TREE_OPERAND (targ, 0));
-	return rval;
-      }
-
-    case COND_EXPR:
-      return build (COND_EXPR, type,
-		    TREE_OPERAND (targ, 0),
-		    build_up_reference (type, TREE_OPERAND (targ, 1),
-					LOOKUP_PROTECT, checkconst),
-		    build_up_reference (type, TREE_OPERAND (targ, 2),
-					LOOKUP_PROTECT, checkconst));
-
-    case WITH_CLEANUP_EXPR:
-      return build (WITH_CLEANUP_EXPR, type,
-		    build_up_reference (type, TREE_OPERAND (targ, 0),
-					LOOKUP_PROTECT, checkconst),
-		    0, TREE_OPERAND (targ, 2));
-
-    case BIND_EXPR:
-      arg = TREE_OPERAND (targ, 1);
-      if (arg == NULL_TREE)
-	{
-	  compiler_error ("({ ... }) expression not expanded when needed for reference");
-	  return error_mark_node;
-	}
-      rval = build1 (ADDR_EXPR, type, arg);
-      TREE_REFERENCE_EXPR (rval) = 1;
-      return rval;
-
-    default:
-      break;
-    }
-
-  if (TREE_ADDRESSABLE (targ) == 0)
-    {
-      tree temp;
-
-      if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (argtype))
-	{
-	  temp = build_cplus_new (argtype, targ, 1);
-	  rval = build1 (ADDR_EXPR, type, temp);
-	  goto done;
-	}
-      else
-	{
-	  temp = get_temp_name (argtype, 0);
-	  if (global_bindings_p ())
-	    {
-	      /* Give this new temp some rtl and initialize it.  */
-	      DECL_INITIAL (temp) = targ;
-	      TREE_STATIC (temp) = 1;
-	      finish_decl (temp, targ, NULL_TREE, 0);
-	      /* Do this after declaring it static.  */
-	      rval = build_unary_op (ADDR_EXPR, temp, 0);
-	      literal_flag = TREE_CONSTANT (rval);
-	      goto done;
-	    }
-	  else
-	    {
-	      rval = build_unary_op (ADDR_EXPR, temp, 0);
-	      /* Put a value into the rtl.  */
-	      if (IS_AGGR_TYPE (argtype))
-		{
-		  /* This may produce surprising results,
-		     since we commit to initializing the temp
-		     when the temp may not actually get used.  */
-		  expand_aggr_init (temp, targ, 0);
-		  TREE_TYPE (rval) = type;
-		  literal_flag = TREE_CONSTANT (rval);
-		  goto done;
-		}
-	      else
-		{
-		  if (binfo && !BINFO_OFFSET_ZEROP (binfo))
-		    rval = convert_pointer_to (target_type, rval);
-		  else
-		    TREE_TYPE (rval) = type;
-		  return build (COMPOUND_EXPR, type,
-				build (MODIFY_EXPR, argtype, temp, arg), rval);
-		}
-	    }
-	}
-    }
-  else
-    {
-      if (TREE_CODE (arg) == SAVE_EXPR)
-	my_friendly_abort (5);
-      rval = build1 (ADDR_EXPR, type, arg);
-    }
-
- done_but_maybe_warn:
-  if (checkconst && TREE_READONLY (arg) && ! TYPE_READONLY (target_type))
-    readonly_error (arg, "conversion to reference", 1);
-
- done:
-  if (TYPE_USES_COMPLEX_INHERITANCE (argtype))
-    {
-      TREE_TYPE (rval) = TYPE_POINTER_TO (argtype);
-      rval = convert_pointer_to (target_type, rval);
-      TREE_TYPE (rval) = type;
-    }
-  TREE_CONSTANT (rval) = literal_flag;
-  return rval;
-}
-
-/* For C++: Only need to do one-level references, but cannot
-   get tripped up on signed/unsigned differences.
-
-   If DECL is NULL_TREE it means convert as though casting (by force).
-   If it is ERROR_MARK_NODE, it means the conversion is implicit,
-   and that temporaries may be created.
-   Make sure the use of user-defined conversion operators is un-ambiguous.
-   Otherwise, DECL is a _DECL node which can be used in error reporting.
-
-   FNDECL, PARMNUM, and ERRTYPE are only used when checking for use of
-   volatile or const references where they aren't desired.  */
-
-tree
-convert_to_reference (decl, reftype, expr, fndecl, parmnum,
-		      errtype, strict, flags)
-
-     tree decl;
-     tree reftype, expr;
-     tree fndecl;
-     int parmnum;
-     char *errtype;
-     int strict, flags;
-{
-  register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
-  register tree intype = TREE_TYPE (expr);
-  register enum tree_code form = TREE_CODE (intype);
-  tree rval = NULL_TREE;
-
-  if (form == REFERENCE_TYPE)
-    intype = TREE_TYPE (intype);
-  intype = TYPE_MAIN_VARIANT (intype);
-
-  /* @@ Probably need to have a check for X(X&) here.  */
-
-  if (IS_AGGR_TYPE (intype))
-    {
-      rval = build_type_conversion (CONVERT_EXPR, reftype, expr, 1);
-      if (rval)
-	{
-	  if (rval == error_mark_node)
-	    error ("ambiguous pointer conversion");
-	  return rval;
-	}
-      else if (type != intype
-	       && (rval = build_type_conversion (CONVERT_EXPR, type, expr, 1)))
-	{
-	  if (rval == error_mark_node)
-	    return rval;
-	  if (TYPE_NEEDS_DESTRUCTOR (type))
-	    {
-	      rval = convert_to_reference (NULL_TREE, reftype, rval, NULL_TREE,
--1, (char *)NULL, strict, flags);
-	    }
-	  else
-	    {
-	      decl = get_temp_name (type, 0);
-	      rval = build (INIT_EXPR, type, decl, rval);
-	      rval = build (COMPOUND_EXPR, reftype, rval,
-			    convert_to_reference (NULL_TREE, reftype, decl,
-						  NULL_TREE, -1, (char*)NULL,
-						  strict, flags));
-	    }
-	}
-
-      if (form == REFERENCE_TYPE
-	  && type != intype
-	  && TYPE_USES_COMPLEX_INHERITANCE (intype))
-	{
-	  /* If it may move around, build a fresh reference.  */
-	  expr = convert_from_reference (expr);
-	  form = TREE_CODE (TREE_TYPE (expr));
-	}
-    }
-
-  /* @@ Perhaps this should try to go through a constructor first
-     @@ for proper initialization, but I am not sure when that
-     @@ is needed or desirable.
-
-     @@ The second disjunct is provided to make references behave
-     @@ as some people think they should, i.e., an interconvertibility
-     @@ between references to builtin types (such as short and
-     @@ unsigned short).  There should be no conversion between
-     @@ types whose codes are different, or whose sizes are different.  */
-
-  if (((IS_AGGR_TYPE (type) || IS_AGGR_TYPE (intype))
-       && comptypes (type, intype, strict))
-      || (!IS_AGGR_TYPE (type)
-	  && TREE_CODE (type) == TREE_CODE (intype)
-	  && int_size_in_bytes (type) == int_size_in_bytes (intype)))
-    {
-      /* Section 13.  */
-      /* Since convert_for_initialization didn't call convert_for_assignment,
-	 we have to do this checking here.  XXX We should have a common
-	 routine between here and convert_for_assignment.  */
-      if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
-	{
-	  register tree ttl = TREE_TYPE (reftype);
-	  register tree ttr = TREE_TYPE (TREE_TYPE (expr));
-
-	  if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
-	    warn_for_assignment ("%s of non-`const &' reference from `const &'",
-				 "reference to const given for argument %d of `%s'",
-				 errtype, fndecl, parmnum, pedantic);
-	  if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
-	    warn_for_assignment ("%s of non-`volatile &' reference from `volatile &'",
-				 "reference to volatile given for argument %d of `%s'",	
-				 errtype, fndecl, parmnum, pedantic);
-	}
-
-      /* If EXPR is of aggregate type, and is really a CALL_EXPR,
-	 then we don't need to convert it to reference type if
-	 it is only being used to initialize DECL which is also
-	 of the same aggregate type.  */
-      if (form == REFERENCE_TYPE
-	  || (decl != NULL_TREE && decl != error_mark_node
-	      && IS_AGGR_TYPE (type)
-	      && TREE_CODE (expr) == CALL_EXPR
-	      && TYPE_MAIN_VARIANT (type) == intype))
-	{
-	  if (decl && decl != error_mark_node)
-	    {
-	      tree e1 = build (INIT_EXPR, void_type_node, decl, expr);
-	      tree e2;
-
-	      TREE_SIDE_EFFECTS (e1) = 1;
-	      if (form == REFERENCE_TYPE)
-		e2 = build1 (NOP_EXPR, reftype, decl);
-	      else
-		{
-		  e2 = build_unary_op (ADDR_EXPR, decl, 0);
-		  TREE_TYPE (e2) = reftype;
-		  TREE_REFERENCE_EXPR (e2) = 1;
-		}
-	      return build_compound_expr (tree_cons (NULL_TREE, e1,
-						     build_tree_list (NULL_TREE, e2)));
-	    }
-	  expr = copy_node (expr);
-	  TREE_TYPE (expr) = reftype;
-	  return expr;
-	}
-      if (decl == error_mark_node)
-	flags |= LOOKUP_PROTECTED_OK;
-      return build_up_reference (reftype, expr, flags, decl!=NULL_TREE);
-    }
-
-  /* Definitely need to go through a constructor here.  */
-  if (TYPE_HAS_CONSTRUCTOR (type))
-    {
-      tree init = build_method_call (NULL_TREE, constructor_name (type),
-				     build_tree_list (NULL_TREE, expr),
-				     TYPE_BINFO (type), LOOKUP_NO_CONVERSION);
-
-      if (init != error_mark_node)
-	if (rval)
-	  {
-	    error ("both constructor and type conversion operator apply");
-	    return error_mark_node;
-	  }
-
-      init = build_method_call (NULL_TREE, constructor_name (type),
-				build_tree_list (NULL_TREE, expr),
-				TYPE_BINFO (type), LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
-
-      if (init == error_mark_node)
-	return error_mark_node;
-      rval = build_cplus_new (type, init, 1);
-      if (decl == error_mark_node)
-	flags |= LOOKUP_PROTECTED_OK;
-      return build_up_reference (reftype, rval, flags, decl!=NULL_TREE);
-    }
-
-  my_friendly_assert (form != OFFSET_TYPE, 189);
-
-  /* This is in two pieces for now, because pointer to first becomes
-     invalid once type_as_string is called again. */
-  error ("cannot convert type `%s'", type_as_string (intype));
-  error ("       to type `%s'", type_as_string (reftype));
-
-  return error_mark_node;
-}
-
-/* We are using a reference VAL for its value. Bash that reference all the
-   way down to its lowest form. */
-tree
-convert_from_reference (val)
-     tree val;
-{
-  tree type = TREE_TYPE (val);
-
-  if (TREE_CODE (type) == OFFSET_TYPE)
-    type = TREE_TYPE (type);
- if (TREE_CODE (type) == REFERENCE_TYPE)
-    {
-      tree target_type = TREE_TYPE (type);
-      tree nval;
-
-      /* This can happen if we cast to a reference type.  */
-      if (TREE_CODE (val) == ADDR_EXPR)
-	{
-	  nval = build1 (NOP_EXPR, build_pointer_type (target_type), val);
-	  nval = build_indirect_ref (nval, 0);
-	  /* The below was missing, are other important flags missing too? */
-	  TREE_SIDE_EFFECTS (nval) = TREE_SIDE_EFFECTS (val);
-	  return nval;
-	}
-
-      nval = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (target_type), val);
-
-      TREE_THIS_VOLATILE (nval) = TYPE_VOLATILE (target_type);
-      TREE_SIDE_EFFECTS (nval) = TYPE_VOLATILE (target_type);
-      TREE_READONLY (nval) = TYPE_READONLY (target_type);
-      /* The below was missing, are other important flags missing too? */
-      TREE_SIDE_EFFECTS (nval) = TREE_SIDE_EFFECTS (val);
-      return nval;
-    }
-  return val;
-}
-
-/* See if there is a constructor of type TYPE which will convert
-   EXPR.  The reference manual seems to suggest (8.5.6) that we need
-   not worry about finding constructors for base classes, then converting
-   to the derived class.
-
-   MSGP is a pointer to a message that would be an appropriate error
-   string.  If MSGP is NULL, then we are not interested in reporting
-   errors.  */
-tree
-convert_to_aggr (type, expr, msgp, protect)
-     tree type, expr;
-     char **msgp;
-     int protect;
-{
-  tree basetype = type;
-  tree name = TYPE_IDENTIFIER (basetype);
-  tree function, fndecl, fntype, parmtypes, parmlist, result;
-  tree method_name;
-  enum visibility_type visibility;
-  int can_be_private, can_be_protected;
-
-  if (! TYPE_HAS_CONSTRUCTOR (basetype))
-    {
-      if (msgp)
-	*msgp = "type `%s' does not have a constructor";
-      return error_mark_node;
-    }
-
-  visibility = visibility_public;
-  can_be_private = 0;
-  can_be_protected = IDENTIFIER_CLASS_VALUE (name) || name == current_class_name;
-
-  parmlist = build_tree_list (NULL_TREE, expr);
-  parmtypes = tree_cons (NULL_TREE, TREE_TYPE (expr), void_list_node);
-
-  if (TYPE_USES_VIRTUAL_BASECLASSES (basetype))
-    {
-      parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes);
-      parmlist = tree_cons (NULL_TREE, integer_one_node, parmlist);
-    }
-
-  /* The type of the first argument will be filled in inside the loop.  */
-  parmlist = tree_cons (NULL_TREE, integer_zero_node, parmlist);
-  parmtypes = tree_cons (NULL_TREE, TYPE_POINTER_TO (basetype), parmtypes);
-
-  method_name = build_decl_overload (name, parmtypes, 1);
-
-  /* constructors are up front.  */
-  fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0);
-  if (TYPE_HAS_DESTRUCTOR (basetype))
-    fndecl = DECL_CHAIN (fndecl);
-
-  while (fndecl)
-    {
-      if (DECL_ASSEMBLER_NAME (fndecl) == method_name)
-	{
-	  function = fndecl;
-	  if (protect)
-	    {
-	      if (TREE_PRIVATE (fndecl))
-		{
-		  can_be_private =
-		    (basetype == current_class_type
-		     || is_friend (basetype, current_function_decl)
-		     || purpose_member (basetype, DECL_VISIBILITY (fndecl)));
-		  if (! can_be_private)
-		    goto found;
-		}
-	      else if (TREE_PROTECTED (fndecl))
-		{
-		  if (! can_be_protected)
-		    goto found;
-		}
-	    }
-	  goto found_and_ok;
-	}
-      fndecl = DECL_CHAIN (fndecl);
-    }
-
-  /* No exact conversion was found.  See if an approximate
-     one will do.  */
-  fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0);
-  if (TYPE_HAS_DESTRUCTOR (basetype))
-    fndecl = DECL_CHAIN (fndecl);
-
-  {
-    int saw_private = 0;
-    int saw_protected = 0;
-    struct candidate *candidates =
-      (struct candidate *) alloca ((decl_list_length (fndecl)+1) * sizeof (struct candidate));
-    struct candidate *cp = candidates;
-
-    while (fndecl)
-      {
-	function = fndecl;
-	cp->harshness = (unsigned short *)alloca (3 * sizeof (short));
-	compute_conversion_costs (fndecl, parmlist, cp, 2);
-	if (cp->evil == 0)
-	  {
-	    cp->u.field = fndecl;
-	    if (protect)
-	      {
-		if (TREE_PRIVATE (fndecl))
-		  visibility = visibility_private;
-		else if (TREE_PROTECTED (fndecl))
-		  visibility = visibility_protected;
-		else
-		  visibility = visibility_public;
-	      }
-	    else
-	      visibility = visibility_public;
-
-	    if (visibility == visibility_private
-		? (basetype == current_class_type
-		   || is_friend (basetype, cp->function)
-		   || purpose_member (basetype, DECL_VISIBILITY (fndecl)))
-		: visibility == visibility_protected
-		? (can_be_protected
-		   || purpose_member (basetype, DECL_VISIBILITY (fndecl)))
-		: 1)
-	      {
-		if (cp->user == 0 && cp->b_or_d == 0
-		    && cp->easy <= 1)
-		  {
-		    goto found_and_ok;
-		  }
-		cp++;
-	      }
-	    else
-	      {
-		if (visibility == visibility_private)
-		  saw_private = 1;
-		else
-		  saw_protected = 1;
-	      }
-	  }
-	fndecl = DECL_CHAIN (fndecl);
-      }
-    if (cp - candidates)
-      {
-	/* Rank from worst to best.  Then cp will point to best one.
-	   Private fields have their bits flipped.  For unsigned
-	   numbers, this should make them look very large.
-	   If the best alternate has a (signed) negative value,
-	   then all we ever saw were private members.  */
-	if (cp - candidates > 1)
-	  qsort (candidates,	/* char *base */
-		 cp - candidates, /* int nel */
-		 sizeof (struct candidate), /* int width */
-		 rank_for_overload); /* int (*compar)() */
-
-	--cp;
-	if (cp->evil > 1)
-	  {
-	    if (msgp)
-	      *msgp = "ambiguous type conversion possible for `%s'";
-	    return error_mark_node;
-	  }
-
-	function = cp->function;
-	fndecl = cp->u.field;
-	goto found_and_ok;
-      }
-    else if (msgp)
-      {
-	if (saw_private)
-	  if (saw_protected)
-	    *msgp = "only private and protected conversions apply";
-	  else
-	    *msgp = "only private conversions apply";
-	else if (saw_protected)
-	  *msgp = "only protected conversions apply";
-      }
-    return error_mark_node;
-  }
-  /* NOTREACHED */
-
- not_found:
-  if (msgp) *msgp = "no appropriate conversion to type `%s'";
-  return error_mark_node;
- found:
-  if (visibility == visibility_private)
-    if (! can_be_private)
-      {
-	if (msgp)
-	  *msgp = TREE_PRIVATE (fndecl)
-	    ? "conversion to type `%s' is private"
-	    : "conversion to type `%s' is from private base class";
-	return error_mark_node;
-      }
-  if (visibility == visibility_protected)
-    if (! can_be_protected)
-      {
-	if (msgp)
-	  *msgp = TREE_PRIVATE (fndecl)
-	    ? "conversion to type `%s' is protected"
-	    : "conversion to type `%s' is from protected base class";
-	return error_mark_node;
-      }
-  function = fndecl;
- found_and_ok:
-
-  /* It will convert, but we don't do anything about it yet.  */
-  if (msgp == 0)
-    return NULL_TREE;
-
-  fntype = TREE_TYPE (function);
-  if (DECL_INLINE (function) && TREE_CODE (function) == FUNCTION_DECL)
-    function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
-  else
-    function = default_conversion (function);
-
-  result = build_nt (CALL_EXPR, function,
-		     convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
-					parmlist, NULL_TREE, LOOKUP_NORMAL),
-		     NULL_TREE);
-  TREE_TYPE (result) = TREE_TYPE (fntype);
-  TREE_SIDE_EFFECTS (result) = 1;
-  TREE_RAISES (result) = !! TYPE_RAISES_EXCEPTIONS (fntype);
-  return result;
-}
-
-/* Call this when we know (for any reason) that expr is
-   not, in fact, zero.  */
-tree
-convert_pointer_to (binfo, expr)
-     tree binfo, expr;
-{
-  register tree intype = TREE_TYPE (expr);
-  tree ptr_type;
-  tree type, rval;
-
-  if (TREE_CODE (binfo) == TREE_VEC)
-    type = BINFO_TYPE (binfo);
-  else if (IS_AGGR_TYPE (binfo))
-    {
-      type = binfo;
-      binfo = TYPE_BINFO (binfo);
-    }
-  else
-    {
-      type = binfo;
-      binfo = NULL_TREE;
-    }
-
-  ptr_type = build_pointer_type (type);
-  if (ptr_type == TYPE_MAIN_VARIANT (intype))
-    return expr;
-
-  if (intype == error_mark_node)
-    return error_mark_node;
-
-  my_friendly_assert (!integer_zerop (expr), 191);
-
-  if (TREE_CODE (type) == RECORD_TYPE
-      && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE
-      && type != TYPE_MAIN_VARIANT (TREE_TYPE (intype)))
-    {
-      tree path;
-      int distance
-	= get_base_distance (type, TYPE_MAIN_VARIANT (TREE_TYPE (intype)),
-			     0, &path);
-
-      /* This function shouldn't be called with unqualified arguments
-	 but if it is, give them an error message that they can read.
-	 */
-      if (distance < 0)
-	{
-	  error ("cannot convert a pointer of type `%s'",
-		 TYPE_NAME_STRING (TREE_TYPE (intype)));
-	  error_with_aggr_type (type, "to a pointer of type `%s'");
-
-	  return error_mark_node;
-	}
-
-      return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
-    }
-  rval = build1 (NOP_EXPR, ptr_type,
-		 TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
-  TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
-  return rval;
-}
-
-/* Same as above, but don't abort if we get an "ambiguous" baseclass.
-   There's only one virtual baseclass we are looking for, and once
-   we find one such virtual baseclass, we have found them all.  */
-
-tree
-convert_pointer_to_vbase (binfo, expr)
-     tree binfo;
-     tree expr;
-{
-  tree intype = TREE_TYPE (TREE_TYPE (expr));
-  tree binfos = TYPE_BINFO_BASETYPES (intype);
-  int i;
-
-  for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
-    {
-      tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
-      if (BINFO_TYPE (binfo) == basetype)
-	return convert_pointer_to (binfo, expr);
-      if (binfo_member (BINFO_TYPE (binfo), CLASSTYPE_VBASECLASSES (basetype)))
-	return convert_pointer_to_vbase (binfo, convert_pointer_to (basetype, expr));
-    }
-  my_friendly_abort (6);
-  /* NOTREACHED */
-  return NULL_TREE;
-}
-
-/* Create an expression whose value is that of EXPR,
-   converted to type TYPE.  The TREE_TYPE of the value
-   is always TYPE.  This function implements all reasonable
-   conversions; callers should filter out those that are
-   not permitted by the language being compiled.  */
-
-tree
-convert (type, expr)
-     tree type, expr;
-{
-  register tree e = expr;
-  register enum tree_code code = TREE_CODE (type);
-
-  if (type == TREE_TYPE (expr)
-      || TREE_CODE (expr) == ERROR_MARK)
-    return expr;
-  if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
-    return fold (build1 (NOP_EXPR, type, expr));
-  if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
-    return error_mark_node;
-  if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
-    {
-      error ("void value not ignored as it ought to be");
-      return error_mark_node;
-    }
-  if (code == VOID_TYPE)
-    {
-      tree rval = build_type_conversion (NOP_EXPR, type, e, 0);
-      /* If we can convert to void type via a type conversion, do so.  */
-      if (rval)
-	return rval;
-      return build1 (CONVERT_EXPR, type, e);
-    }
-#if 0
-  /* This is incorrect.  A truncation can't be stripped this way.
-     Extensions will be stripped by the use of get_unwidened.  */
-  if (TREE_CODE (expr) == NOP_EXPR)
-    return convert (type, TREE_OPERAND (expr, 0));
-#endif
-
-  /* Just convert to the type of the member.  */
-  if (code == OFFSET_TYPE)
-    {
-      type = TREE_TYPE (type);
-      code = TREE_CODE (type);
-    }
-
-  /* C++ */
-  if (code == REFERENCE_TYPE)
-    return fold (convert_to_reference (error_mark_node,
-				       type, e,
-				       NULL_TREE, -1, (char *)NULL,
-				       -1, LOOKUP_NORMAL));
-  else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
-    e = convert_from_reference (e);
-
-  if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
-    {
-      tree intype = TREE_TYPE (expr);
-      enum tree_code form = TREE_CODE (intype);
-      if (flag_int_enum_equivalence == 0
-	  && TREE_CODE (type) == ENUMERAL_TYPE
-	  && form == INTEGER_TYPE)
-	{
-	  if (pedantic)
-	    pedwarn ("anachronistic conversion from integer type to enumeral type `%s'",
-		     TYPE_NAME_STRING (type));
-	  if (flag_pedantic_errors)
-	    return error_mark_node;
-	}
-      if (form == OFFSET_TYPE)
-	error_with_decl (TYPE_NAME (TYPE_OFFSET_BASETYPE (intype)),
-			 "pointer-to-member expression object not composed with type `%s' object");
-      else if (IS_AGGR_TYPE (intype))
-	{
-	  tree rval;
-	  rval = build_type_conversion (CONVERT_EXPR, type, expr, 1);
-	  if (rval) return rval;
-	  error ("aggregate value used where an integer was expected");
-	  return error_mark_node;
-	}
-      return fold (convert_to_integer (type, e));
-    }
-  if (code == POINTER_TYPE)
-    return fold (cp_convert_to_pointer (type, e));
-  if (code == REAL_TYPE)
-    {
-      if (IS_AGGR_TYPE (TREE_TYPE (e)))
-	{
-	  tree rval;
-	  rval = build_type_conversion (CONVERT_EXPR, type, e, 1);
-	  if (rval)
-	    return rval;
-	  else
-	    error ("aggregate value used where a floating point value was expected");
-	}
-      return fold (convert_to_real (type, e));
-    }
-
-  /* New C++ semantics:  since assignment is now based on
-     memberwise copying,  if the rhs type is derived from the
-     lhs type, then we may still do a conversion.  */
-  if (IS_AGGR_TYPE_CODE (code))
-    {
-      tree dtype = TREE_TYPE (e);
-
-      if (TREE_CODE (dtype) == REFERENCE_TYPE)
-	{
-	  e = convert_from_reference (e);
-	  dtype = TREE_TYPE (e);
-	}
-      dtype = TYPE_MAIN_VARIANT (dtype);
-
-      /* Conversion between aggregate types.  New C++ semantics allow
-	 objects of derived type to be cast to objects of base type.
-	 Old semantics only allowed this between pointers.
-
-	 There may be some ambiguity between using a constructor
-	 vs. using a type conversion operator when both apply.  */
-
-      if (IS_AGGR_TYPE (dtype))
-	{
-	  tree binfo;
-
-	  tree conversion = TYPE_HAS_CONVERSION (dtype)
-	    ? build_type_conversion (CONVERT_EXPR, type, e, 1) : NULL_TREE;
-
-	  if (TYPE_HAS_CONSTRUCTOR (type))
-	    {
-	      tree rval = build_method_call (NULL_TREE, constructor_name (type),
-					     build_tree_list (NULL_TREE, e),
-					     TYPE_BINFO (type),
-					     conversion ? LOOKUP_NO_CONVERSION : 0);
-
-	      if (rval != error_mark_node)
-		{
-		  if (conversion)
-		    {
-		      error ("both constructor and type conversion operator apply");
-		      return error_mark_node;
-		    }
-		  /* call to constructor successful.  */
-		  rval = build_cplus_new (type, rval, 0);
-		  return rval;
-		}
-	    }
-	  /* Type conversion successful/applies.  */
-	  if (conversion)
-	    {
-	      if (conversion == error_mark_node)
-		error ("ambiguous pointer conversion");
-	      return conversion;
-	    }
-
-	  /* now try normal C++ assignment semantics.  */
-	  binfo = TYPE_BINFO (dtype);
-	  if (BINFO_TYPE (binfo) == type
-	      || (binfo = get_binfo (type, dtype, 1)))
-	    {
-	      if (binfo == error_mark_node)
-		return error_mark_node;
-	    }
-	  if (binfo != NULL_TREE)
-	    {
-	      if (lvalue_p (e))
-		{
-		  e = build_unary_op (ADDR_EXPR, e, 0);
-
-		  if (! BINFO_OFFSET_ZEROP (binfo))
-		    e = build (PLUS_EXPR, TYPE_POINTER_TO (type),
-			       e, BINFO_OFFSET (binfo));
-		  return build1 (INDIRECT_REF, type, e);
-		}
-
-	      sorry ("addressable aggregates");
-	      return error_mark_node;
-	    }
-	  error ("conversion between incompatible aggregate types requested");
-	  return error_mark_node;
-	}
-      /* conversion from non-aggregate to aggregate type requires constructor.  */
-      else if (TYPE_HAS_CONSTRUCTOR (type))
-	{
-	  tree rval;
-	  tree init = build_method_call (NULL_TREE, constructor_name (type),
-					 build_tree_list (NULL_TREE, e),
-					 TYPE_BINFO (type), LOOKUP_NORMAL);
-	  if (init == error_mark_node)
-	    {
-	      error_with_aggr_type (type, "in conversion to type `%s'");
-	      return error_mark_node;
-	    }
-	  rval = build_cplus_new (type, init, 0);
-	  return rval;
-	}
-    }
-
-  /* If TYPE or TREE_TYPE (EXPR) is not on the permanent_obstack,
-     then the it won't be hashed and hence compare as not equal,
-     even when it is.  */
-  if (code == ARRAY_TYPE
-      && TREE_TYPE (TREE_TYPE (expr)) == TREE_TYPE (type)
-      && index_type_equal (TYPE_DOMAIN (TREE_TYPE (expr)), TYPE_DOMAIN (type)))
-    return expr;
-
-  error ("conversion to non-scalar type requested");
-  return error_mark_node;
-}
-
-/* Like convert, except permit conversions to take place which
-   are not normally allowed due to visibility restrictions
-   (such as conversion from sub-type to private super-type).  */
-tree
-convert_force (type, expr)
-     tree type;
-     tree expr;
-{
-  register tree e = expr;
-  register enum tree_code code = TREE_CODE (type);
-
-  if (code == REFERENCE_TYPE)
-    return fold (convert_to_reference (0, type, e,
-				       NULL_TREE, -1, (char *)NULL,
-				       -1, 0));
-  else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
-    e = convert_from_reference (e);
-
-  if (code == POINTER_TYPE)
-    return fold (convert_to_pointer_force (type, e));
-
-  {
-    int old_equiv = flag_int_enum_equivalence;
-    flag_int_enum_equivalence = 1;
-    e = convert (type, e);
-    flag_int_enum_equivalence = old_equiv;
-  }
-  return e;
-}
-
-/* Subroutine of build_type_conversion.  */
-static tree
-build_type_conversion_1 (xtype, basetype, expr, typename, for_sure)
-     tree xtype, basetype;
-     tree expr;
-     tree typename;
-     int for_sure;
-{
-  tree first_arg = expr;
-  tree rval;
-  int flags;
-
-  if (for_sure == 0)
-    {
-      if (! lvalue_p (expr))
-	first_arg = build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), integer_zero_node);
-      flags = LOOKUP_PROTECT;
-    }
-  else
-    flags = LOOKUP_NORMAL;
-
-  rval = build_method_call (first_arg, constructor_name (typename),
-			    NULL_TREE, NULL_TREE, flags);
-  if (rval == error_mark_node)
-    {
-      if (for_sure == 0)
-	return NULL_TREE;
-      return error_mark_node;
-    }
-  if (first_arg != expr)
-    {
-      expr = build_up_reference (build_reference_type (TREE_TYPE (expr)), expr,
-				 LOOKUP_COMPLAIN, 1);
-      TREE_VALUE (TREE_OPERAND (rval, 1)) = build_unary_op (ADDR_EXPR, expr, 0);
-    }
-  if (TREE_CODE (TREE_TYPE (rval)) == REFERENCE_TYPE
-      && TREE_CODE (xtype) != REFERENCE_TYPE)
-    rval = default_conversion (rval);
-
-  if (pedantic
-      && TREE_TYPE (xtype)
-      && (TREE_READONLY (TREE_TYPE (TREE_TYPE (rval)))
-	  > TREE_READONLY (TREE_TYPE (xtype))))
-    pedwarn ("user-defined conversion casting away `const'");
-  return convert (xtype, rval);
-}
-
-/* Convert an aggregate EXPR to type XTYPE.  If a conversion
-   exists, return the attempted conversion.  This may
-   return ERROR_MARK_NODE if the conversion is not
-   allowed (references private members, etc).
-   If no conversion exists, NULL_TREE is returned.
-
-   If (FOR_SURE & 1) is non-zero, then we allow this type conversion
-   to take place immediately.  Otherwise, we build a SAVE_EXPR
-   which can be evaluated if the results are ever needed.
-
-   If FOR_SURE >= 2, then we only look for exact conversions.
-
-   TYPE may be a reference type, in which case we first look
-   for something that will convert to a reference type.  If
-   that fails, we will try to look for something of the
-   reference's target type, and then return a reference to that.  */
-tree
-build_type_conversion (code, xtype, expr, for_sure)
-     enum tree_code code;
-     tree xtype, expr;
-     int for_sure;
-{
-  /* C++: check to see if we can convert this aggregate type
-     into the required scalar type.  */
-  tree type, type_default;
-  tree typename = build_typename_overload (xtype), *typenames;
-  int n_variants = 0;
-  tree basetype, save_basetype;
-  tree rval;
-  int exact_conversion = for_sure >= 2;
-  for_sure &= 1;
-
-  if (expr == error_mark_node)
-    return error_mark_node;
-
-  basetype = TREE_TYPE (expr);
-  if (TREE_CODE (basetype) == REFERENCE_TYPE)
-    basetype = TREE_TYPE (basetype);
-
-  basetype = TYPE_MAIN_VARIANT (basetype);
-  if (! TYPE_LANG_SPECIFIC (basetype) || ! TYPE_HAS_CONVERSION (basetype))
-    return 0;
-
-  if (TREE_CODE (xtype) == POINTER_TYPE
-      || TREE_CODE (xtype) == REFERENCE_TYPE)
-    {
-      /* Prepare to match a variant of this type.  */
-      type = TYPE_MAIN_VARIANT (TREE_TYPE (xtype));
-      for (n_variants = 0; type; type = TYPE_NEXT_VARIANT (type))
-	n_variants++;
-      typenames = (tree *)alloca (n_variants * sizeof (tree));
-      for (n_variants = 0, type = TYPE_MAIN_VARIANT (TREE_TYPE (xtype));
-	   type; n_variants++, type = TYPE_NEXT_VARIANT (type))
-	{
-	  if (type == TREE_TYPE (xtype))
-	    typenames[n_variants] = typename;
-	  else if (TREE_CODE (xtype) == POINTER_TYPE)
-	    typenames[n_variants] = build_typename_overload (build_pointer_type (type));
-	  else
-	    typenames[n_variants] = build_typename_overload (build_reference_type (type));
-	}
-    }
-
-  save_basetype = basetype;
-  type = xtype;
-
-  while (TYPE_HAS_CONVERSION (basetype))
-    {
-      int i;
-      if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
-	return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-      for (i = 0; i < n_variants; i++)
-	if (typenames[i] != typename
-	    && lookup_fnfields (TYPE_BINFO (basetype), typenames[i], 0))
-	  return build_type_conversion_1 (xtype, basetype, expr, typenames[i], for_sure);
-
-      if (TYPE_BINFO_BASETYPES (basetype))
-	basetype = TYPE_BINFO_BASETYPE (basetype, 0);
-      else break;
-    }
-
-  if (TREE_CODE (type) == REFERENCE_TYPE)
-    {
-      tree first_arg = expr;
-      type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
-      basetype = save_basetype;
-
-      /* May need to build a temporary for this.  */
-      while (TYPE_HAS_CONVERSION (basetype))
-	{
-	  if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
-	    {
-	      int flags;
-
-	      if (for_sure == 0)
-		{
-		  if (! lvalue_p (expr))
-		    first_arg = build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), integer_zero_node);
-		  flags = LOOKUP_PROTECT;
-		}
-	      else
-		flags = LOOKUP_NORMAL;
-	      rval = build_method_call (first_arg, constructor_name (typename),
-					NULL_TREE, NULL_TREE, flags);
-	      if (rval == error_mark_node)
-		{
-		  if (for_sure == 0)
-		    return NULL_TREE;
-		  return error_mark_node;
-		}
-	      TREE_VALUE (TREE_OPERAND (rval, 1)) = expr;
-
-	      if (IS_AGGR_TYPE (type))
-		{
-		  tree init = build_method_call (NULL_TREE,
-						 constructor_name (type),
-						 build_tree_list (NULL_TREE, rval), NULL_TREE, LOOKUP_NORMAL);
-		  tree temp = build_cplus_new (type, init, 1);
-		  return build_up_reference (TYPE_REFERENCE_TO (type), temp,
-					     LOOKUP_COMPLAIN, 1);
-		}
-	      return convert (xtype, rval);
-	    }
-	  if (TYPE_BINFO_BASETYPES (basetype))
-	    basetype = TYPE_BINFO_BASETYPE (basetype, 0);
-	  else break;
-	}
-      /* No free conversions for reference types, right?.  */
-      return NULL_TREE;
-    }
-
-  if (exact_conversion)
-    return NULL_TREE;
-
-  /* No perfect match found, try default.  */
-  if (code == CONVERT_EXPR && TREE_CODE (type) == POINTER_TYPE)
-    type_default = ptr_type_node;
-  else if (type == void_type_node)
-    return NULL_TREE;
-  else
-    {
-      tree tmp = default_conversion (build1 (NOP_EXPR, type, integer_zero_node));
-      if (tmp == error_mark_node)
-	return NULL_TREE;
-      type_default = TREE_TYPE (tmp);
-    }
-
-  basetype = save_basetype;
-
-  if (type_default != type)
-    {
-      type = type_default;
-      typename = build_typename_overload (type);
-
-      while (TYPE_HAS_CONVERSION (basetype))
-	{
-	  if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
-	    return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-	  if (TYPE_BINFO_BASETYPES (basetype))
-	    basetype = TYPE_BINFO_BASETYPE (basetype, 0);
-	  else break;
-	}
-    }
-
- try_pointer:
-
-  if (type == ptr_type_node)
-    {
-      /* Try converting to some other pointer type
-	 with which void* is compatible, or in situations
-	 in which void* is appropriate (such as &&,||, and !).  */
-
-      while (TYPE_HAS_CONVERSION (basetype))
-	{
-	  if (CLASSTYPE_CONVERSION (basetype, ptr_conv) != 0)
-	    {
-	      if (CLASSTYPE_CONVERSION (basetype, ptr_conv) == error_mark_node)
-		return error_mark_node;
-	      typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, ptr_conv));
-	      return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-	    }
-	  if (TYPE_BINFO_BASETYPES (basetype))
-	    basetype = TYPE_BINFO_BASETYPE (basetype, 0);
-	  else break;
-	}
-    }
-  if (TREE_CODE (type) == POINTER_TYPE
-      && TYPE_READONLY (TREE_TYPE (type))
-      && TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
-    {
-      /* Try converting to some other pointer type
-	 with which const void* is compatible.  */
-
-      while (TYPE_HAS_CONVERSION (basetype))
-	{
-	  if (CLASSTYPE_CONVERSION (basetype, constptr_conv) != 0)
-	    {
-	      if (CLASSTYPE_CONVERSION (basetype, constptr_conv) == error_mark_node)
-		return error_mark_node;
-	      typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, constptr_conv));
-	      return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-	    }
-	  if (TYPE_BINFO_BASETYPES (basetype))
-	    basetype = TYPE_BINFO_BASETYPE (basetype, 0);
-	  else break;
-	}
-    }
-  /* Use the longer or shorter conversion that is appropriate.  Have
-     to check against 0 because the conversion may come from a baseclass.  */
-  if (TREE_CODE (type) == INTEGER_TYPE
-      && TYPE_HAS_INT_CONVERSION (basetype)
-      && CLASSTYPE_CONVERSION (basetype, int_conv) != 0
-      && CLASSTYPE_CONVERSION (basetype, int_conv) != error_mark_node)
-    {
-      typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, int_conv));
-      return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-    }
-  if (TREE_CODE (type) == REAL_TYPE
-      && TYPE_HAS_REAL_CONVERSION (basetype)
-      && CLASSTYPE_CONVERSION (basetype, real_conv) != 0
-      && CLASSTYPE_CONVERSION (basetype, real_conv) != error_mark_node)
-    {
-      typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, real_conv));
-      return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-    }
-
-  /* THIS IS A KLUDGE.  */
-  if (TREE_CODE (type) != POINTER_TYPE
-      && (code == TRUTH_ANDIF_EXPR
-	  || code == TRUTH_ORIF_EXPR
-	  || code == TRUTH_NOT_EXPR))
-    {
-      /* Here's when we can convert to a pointer.  */
-      type = ptr_type_node;
-      goto try_pointer;
-    }
-
-  /* THESE ARE TOTAL KLUDGES.  */
-  /* Default promotion yields no new alternatives, try
-     conversions which are anti-default, such as
-
-     double -> float or int -> unsigned or unsigned -> long
-
-     */
-  if (type_default == type
-      && (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == REAL_TYPE))
-    {
-      int not_again = 0;
-
-      if (type == double_type_node)
-	typename = build_typename_overload (float_type_node);
-      else if (type == integer_type_node)
-	typename = build_typename_overload (unsigned_type_node);
-      else if (type == unsigned_type_node)
-	typename = build_typename_overload (long_integer_type_node);
-
-    again:
-      basetype = save_basetype;
-      while (TYPE_HAS_CONVERSION (basetype))
-	{
-	  if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
-	    return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-	  if (TYPE_BINFO_BASETYPES (basetype))
-	    basetype = TYPE_BINFO_BASETYPE (basetype, 0);
-	  else break;
-	}
-      if (! not_again)
-	{
-	  if (type == integer_type_node)
-	    {
-	      typename = build_typename_overload (long_integer_type_node);
-	      not_again = 1;
-	      goto again;
-	    }
-	  else
-	    {
-	      typename = build_typename_overload (integer_type_node);
-	      not_again = 1;
-	      goto again;
-	    }
-	}
-    }
-
-  /* Now, try C promotions...
-
-     float -> int
-     int -> float, void *
-     void * -> int
-
-     Truthvalue conversions let us try to convert
-     to pointer if we were going for int, and to int
-     if we were looking for pointer.  */
-
-    basetype = save_basetype;
-    if (TREE_CODE (type) == REAL_TYPE
-	|| (TREE_CODE (type) == POINTER_TYPE
-	    && (code == TRUTH_ANDIF_EXPR
-		|| code == TRUTH_ORIF_EXPR
-		|| code == TRUTH_NOT_EXPR)))
-      type = integer_type_node;
-    else if (TREE_CODE (type) == INTEGER_TYPE)
-      if (TYPE_HAS_REAL_CONVERSION (basetype))
-	type = double_type_node;
-      else
-	return NULL_TREE;
-    else
-      return NULL_TREE;
-
-    typename = build_typename_overload (type);
-    while (TYPE_HAS_CONVERSION (basetype))
-      {
-	if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0))
-	  {
-	    rval = build_type_conversion_1 (xtype, basetype, expr, typename, for_sure);
-	    return rval;
-	  }
-	if (TYPE_BINFO_BASETYPES (basetype))
-	  basetype = TYPE_BINFO_BASETYPE (basetype, 0);
-	else
-	  break;
-      }
-
-  return NULL_TREE;
-}
-
-/* Must convert two aggregate types to non-aggregate type.
-   Attempts to find a non-ambiguous, "best" type conversion.
-
-   Return 1 on success, 0 on failure.
-
-   @@ What are the real semantics of this supposed to be??? */
-int
-build_default_binary_type_conversion (code, arg1, arg2)
-     enum tree_code code;
-     tree *arg1, *arg2;
-{
-  tree type1 = TREE_TYPE (*arg1);
-  tree type2 = TREE_TYPE (*arg2);
-  char *name1, *name2;
-
-  if (TREE_CODE (type1) == REFERENCE_TYPE)
-    type1 = TREE_TYPE (type1);
-  if (TREE_CODE (type2) == REFERENCE_TYPE)
-    type2 = TREE_TYPE (type2);
-
-  if (TREE_CODE (TYPE_NAME (type1)) != TYPE_DECL)
-    {
-      tree decl = typedecl_for_tag (type1);
-      if (decl)
-	error ("type conversion nonexistent for type `%s'",
-	       IDENTIFIER_POINTER (DECL_NAME (decl)));
-      else
-	error ("type conversion nonexistent for non-C++ type");
-      return 0;
-    }
-  if (TREE_CODE (TYPE_NAME (type2)) != TYPE_DECL)
-    {
-      tree decl = typedecl_for_tag (type2);
-      if (decl)
-	error ("type conversion nonexistent for type `%s'",
-	       IDENTIFIER_POINTER (decl));
-      else
-	error ("type conversion nonexistent for non-C++ type");
-      return 0;
-    }
-
-  name1 = TYPE_NAME_STRING (type1);
-  name2 = TYPE_NAME_STRING (type2);
-
-  if (!IS_AGGR_TYPE (type1) || !TYPE_HAS_CONVERSION (type1))
-    {
-      if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
-	error ("type conversion required for binary operation on types `%s' and `%s'",
-	       name1, name2);
-      else
-	error ("type conversion required for type `%s'", name1);
-      return 0;
-    }
-  else if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
-    {
-      error ("type conversion required for type `%s'", name2);
-      return 0;
-    }
-
-  if (TYPE_HAS_INT_CONVERSION (type1) && TYPE_HAS_REAL_CONVERSION (type1))
-    warning ("ambiguous type conversion for type `%s', defaulting to int", name1);
-  if (TYPE_HAS_INT_CONVERSION (type1))
-    {
-      *arg1 = build_type_conversion (code, integer_type_node, *arg1, 1);
-      *arg2 = build_type_conversion (code, integer_type_node, *arg2, 1);
-    }
-  else if (TYPE_HAS_REAL_CONVERSION (type1))
-    {
-      *arg1 = build_type_conversion (code, double_type_node, *arg1, 1);
-      *arg2 = build_type_conversion (code, double_type_node, *arg2, 1);
-    }
-  else
-    {
-      *arg1 = build_type_conversion (code, ptr_type_node, *arg1, 1);
-      if (*arg1 == error_mark_node)
-	error ("ambiguous pointer conversion");
-      *arg2 = build_type_conversion (code, ptr_type_node, *arg2, 1);
-      if (*arg1 != error_mark_node && *arg2 == error_mark_node)
-	error ("ambiguous pointer conversion");
-    }
-  if (*arg1 == 0)
-    {
-      if (*arg2 == 0 && type1 != type2)
-	error ("default type conversion for types `%s' and `%s' failed",
-	       name1, name2);
-      else
-	error ("default type conversion for type `%s' failed", name1);
-      return 0;
-    }
-  else if (*arg2 == 0)
-    {
-      error ("default type conversion for type `%s' failed", name2);
-      return 0;
-    }
-  return 1;
-}
-
-/* Must convert two aggregate types to non-aggregate type.
-   Attempts to find a non-ambiguous, "best" type conversion.
-
-   Return 1 on success, 0 on failure.
-
-   The type of the argument is expected to be of aggregate type here.
-
-   @@ What are the real semantics of this supposed to be??? */
-int
-build_default_unary_type_conversion (code, arg)
-     enum tree_code code;
-     tree *arg;
-{
-  tree type = TREE_TYPE (*arg);
-  tree id = TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
-    ? TYPE_IDENTIFIER (type) : TYPE_NAME (type);
-  char *name = IDENTIFIER_POINTER (id);
-
-  if (! TYPE_HAS_CONVERSION (type))
-    {
-      error ("type conversion required for type `%s'", name);
-      return 0;
-    }
-
-  if (TYPE_HAS_INT_CONVERSION (type) && TYPE_HAS_REAL_CONVERSION (type))
-    warning ("ambiguous type conversion for type `%s', defaulting to int", name);
-  if (TYPE_HAS_INT_CONVERSION (type))
-    *arg = build_type_conversion (code, integer_type_node, *arg, 1);
-  else if (TYPE_HAS_REAL_CONVERSION (type))
-    *arg = build_type_conversion (code, double_type_node, *arg, 1);
-  else
-    {
-      *arg = build_type_conversion (code, ptr_type_node, *arg, 1);
-      if (*arg == error_mark_node)
-	error ("ambiguous pointer conversion");
-    }
-  if (*arg == 0)
-    {
-      error ("default type conversion for type `%s' failed", name);
-      return 0;
-    }
-  return 1;
-}
diff --git a/gnu/gcc2/cc1plus/cp-decl.c b/gnu/gcc2/cc1plus/cp-decl.c
deleted file mode 100644
index b888baa16b73..000000000000
--- a/gnu/gcc2/cc1plus/cp-decl.c
+++ /dev/null
@@ -1,11551 +0,0 @@
-/* Process declarations and variables for C compiler.
-   Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, 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 <stdio.h>
-#include "config.h"
-#include "tree.h"
-#include "rtl.h"
-#include "flags.h"
-#include "cp-tree.h"
-#include "cp-decl.h"
-#include "cp-lex.h"
-#include <sys/types.h>
-#include <signal.h>
-#include "obstack.h"
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-extern struct obstack permanent_obstack;
-
-/* Stack of places to restore the search obstack back to.  */
-   
-/* Obstack used for remembering local class declarations (like
-   enums and static (const) members.  */
-#include "stack.h"
-static struct obstack decl_obstack;
-static struct stack_level *decl_stack;
-
-#undef NULL
-#define NULL (char *)0
-
-#ifndef CHAR_TYPE_SIZE
-#define CHAR_TYPE_SIZE BITS_PER_UNIT
-#endif
-
-#ifndef SHORT_TYPE_SIZE
-#define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
-#endif
-
-#ifndef INT_TYPE_SIZE
-#define INT_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef LONG_TYPE_SIZE
-#define LONG_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef LONG_LONG_TYPE_SIZE
-#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
-#endif
-
-#ifndef WCHAR_UNSIGNED
-#define WCHAR_UNSIGNED 0
-#endif
-
-#ifndef FLOAT_TYPE_SIZE
-#define FLOAT_TYPE_SIZE BITS_PER_WORD
-#endif
-
-#ifndef DOUBLE_TYPE_SIZE
-#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
-#endif
-
-#ifndef LONG_DOUBLE_TYPE_SIZE
-#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
-#endif
-
-/* We let tm.h override the types used here, to handle trivial differences
-   such as the choice of unsigned int or long unsigned int for size_t.
-   When machines start needing nontrivial differences in the size type,
-   it would be best to do something here to figure out automatically
-   from other information what type to use.  */
-
-#ifndef SIZE_TYPE
-#define SIZE_TYPE "long unsigned int"
-#endif
-
-#ifndef PTRDIFF_TYPE
-#define PTRDIFF_TYPE "long int"
-#endif
-
-#ifndef WCHAR_TYPE
-#define WCHAR_TYPE "int"
-#endif
-
-#define builtin_function(NAME, TYPE, CODE, LIBNAME) \
-  define_function (NAME, TYPE, CODE, (void (*)())pushdecl, LIBNAME)
-#define auto_function(NAME, TYPE, CODE) \
-  do {					\
-    tree __name = NAME;		\
-    tree __type = TYPE;			\
-    define_function (IDENTIFIER_POINTER (__name), __type, CODE,	\
-		     (void (*)())push_overloaded_decl_1,	\
-		     IDENTIFIER_POINTER (build_decl_overload (__name, TYPE_ARG_TYPES (__type), 0)));\
-  } while (0)
-
-static tree grokparms				PROTO((tree, int));
-static tree lookup_nested_type			PROTO((tree, tree));
-static char *redeclaration_error_message	PROTO((tree, tree));
-static int parmlist_is_random			PROTO((tree));
-static void grok_op_properties			PROTO((tree, int));
-static void expand_static_init			PROTO((tree, tree));
-static void deactivate_exception_cleanups	PROTO((void));
-
-tree define_function				PROTO((char *, tree, enum built_in_function, void (*)(), char *));
-
-/* a node which has tree code ERROR_MARK, and whose type is itself.
-   All erroneous expressions are replaced with this node.  All functions
-   that accept nodes as arguments should avoid generating error messages
-   if this node is one of the arguments, since it is undesirable to get
-   multiple error messages from one error in the input.  */
-
-tree error_mark_node;
-
-/* Erroneous argument lists can use this *IFF* they do not modify it.  */
-tree error_mark_list;
-
-/* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
-
-tree short_integer_type_node;
-tree integer_type_node;
-tree long_integer_type_node;
-tree long_long_integer_type_node;
-
-tree short_unsigned_type_node;
-tree unsigned_type_node;
-tree long_unsigned_type_node;
-tree long_long_unsigned_type_node;
-
-tree ptrdiff_type_node;
-
-tree unsigned_char_type_node;
-tree signed_char_type_node;
-tree char_type_node;
-tree wchar_type_node;
-tree signed_wchar_type_node;
-tree unsigned_wchar_type_node;
-
-tree float_type_node;
-tree double_type_node;
-tree long_double_type_node;
-
-tree intQI_type_node;
-tree intHI_type_node;
-tree intSI_type_node;
-tree intDI_type_node;
-
-tree unsigned_intQI_type_node;
-tree unsigned_intHI_type_node;
-tree unsigned_intSI_type_node;
-tree unsigned_intDI_type_node;
-
-/* a VOID_TYPE node, and the same, packaged in a TREE_LIST.  */
-
-tree void_type_node, void_list_node;
-tree void_zero_node;
-
-/* Nodes for types `void *' and `const void *'.  */
-
-tree ptr_type_node, const_ptr_type_node;
-
-/* Nodes for types `char *' and `const char *'.  */
-
-tree string_type_node, const_string_type_node;
-
-/* Type `char[256]' or something like it.
-   Used when an array of char is needed and the size is irrelevant.  */
-
-tree char_array_type_node;
-
-/* Type `int[256]' or something like it.
-   Used when an array of int needed and the size is irrelevant.  */
-
-tree int_array_type_node;
-
-/* Type `wchar_t[256]' or something like it.
-   Used when a wide string literal is created.  */
-
-tree wchar_array_type_node;
-
-/* type `int ()' -- used for implicit declaration of functions.  */
-
-tree default_function_type;
-
-/* function types `double (double)' and `double (double, double)', etc.  */
-
-tree double_ftype_double, double_ftype_double_double;
-tree int_ftype_int, long_ftype_long;
-
-/* Function type `void (void *, void *, int)' and similar ones.  */
-
-tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
-
-/* Function type `char *(char *, char *)' and similar ones */
-tree string_ftype_ptr_ptr, int_ftype_string_string;
-
-/* Function type `size_t (const char *)' */
-tree sizet_ftype_string;
-
-/* Function type `int (const void *, const void *, size_t)' */
-tree int_ftype_cptr_cptr_sizet;
-
-/* C++ extensions */
-tree vtable_entry_type;
-tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node;
-tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
-tree class_star_type_node;
-tree class_type_node, record_type_node, union_type_node, enum_type_node;
-tree exception_type_node, unknown_type_node;
-tree maybe_gc_cleanup;
-
-/* Used for virtual function tables.  */
-tree vtbl_mask;
-
-/* Array type `(void *)[]' */
-tree vtbl_type_node;
-
-/* Static decls which do not have static initializers have no
-   initializers as far as GNU C is concerned.  EMPTY_INIT_NODE
-   is a static initializer which makes varasm code place the decl
-   in data rather than in bss space.  Such gymnastics are necessary
-   to avoid the problem that the linker will not include a library
-   file if all the library appears to contribute are bss variables.  */
-
-tree empty_init_node;
-
-/* In a destructor, the point at which all derived class destroying
-   has been done, just before any base class destroying will be done.  */
-
-tree dtor_label;
-
-/* In a constructor, the point at which we are ready to return
-   the pointer to the initialized object.  */
-
-tree ctor_label;
-
-/* A FUNCTION_DECL which can call `unhandled_exception'.
-   Not necessarily the one that the user will declare,
-   but sufficient to be called by routines that want to abort the program.  */
-
-tree unhandled_exception_fndecl;
-
-/* 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;
-
-extern rtx cleanup_label, return_label;
-
-/* If original DECL_RESULT of current function was a register,
-   but due to being an addressable named return value, would up
-   on the stack, this variable holds the named return value's
-   original location.  */
-rtx original_result_rtx;
-
-/* Sequence of insns which represents base initialization.  */
-rtx base_init_insns;
-
-/* C++: Keep these around to reduce calls to `get_identifier'.
-   Identifiers for `this' in member functions and the auto-delete
-   parameter for destructors.  */
-tree this_identifier, in_charge_identifier;
-
-/* A list (chain of TREE_LIST nodes) of named label uses.
-   The TREE_PURPOSE field is the list of variables defined
-   the the label's scope defined at the point of use.
-   The TREE_VALUE field is the LABEL_DECL used.
-   The TREE_TYPE field holds `current_binding_level' at the
-   point of the label's use.
-
-   Used only for jumps to as-yet undefined labels, since
-   jumps to defined labels can have their validity checked
-   by stmt.c.  */
-
-static tree named_label_uses;
-
-/* 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;
-
-/* A list of functions which were declared inline, but later had their
-   address taken.  Used only for non-virtual member functions, since we can
-   find other functions easily enough.  */
-tree pending_addressable_inlines;
-
-/* A list of overloaded functions which we should forget ever
-   existed, such as functions declared in a function's scope,
-   once we leave that function's scope.  */
-static tree overloads_to_forget;
-
-/* -- end of C++ */
-
-/* Two expressions that are constants with value zero.
-   The first is of type `int', the second of type `void *'.  */
-
-tree integer_zero_node;
-tree null_pointer_node;
-
-/* A node for the integer constants 1, 2, and 3.  */
-
-tree integer_one_node, integer_two_node, integer_three_node;
-
-/* Nonzero if we have seen an invalid cross reference
-   to a struct, union, or enum, but not yet printed the message.  */
-
-tree pending_invalid_xref;
-/* File and line to appear in the eventual error message.  */
-char *pending_invalid_xref_file;
-int pending_invalid_xref_line;
-
-/* While defining an enum type, this is 1 plus the last enumerator
-   constant value.  */
-
-static tree enum_next_value;
-
-/* Parsing a function declarator leaves a list of parameter names
-   or a chain or parameter decls here.  */
-
-tree last_function_parms;
-
-/* Parsing a function declarator leaves here a chain of structure
-   and enum types declared in the parmlist.  */
-
-static tree last_function_parm_tags;
-
-/* After parsing the declarator that starts a function definition,
-   `start_function' puts here the list of parameter names or chain of decls.
-   `store_parm_decls' finds it here.  */
-
-static tree current_function_parms;
-
-/* Similar, for last_function_parm_tags.  */
-static tree current_function_parm_tags;
-
-/* A list (chain of TREE_LIST nodes) 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.  */
-
-static tree named_labels;
-
-/* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
-
-static tree shadowed_labels;
-
-#if 0 /* Not needed by C++ */
-/* Nonzero when store_parm_decls is called indicates a varargs function.
-   Value not meaningful after store_parm_decls.  */
-
-static int c_function_varargs;
-#endif
-
-/* The FUNCTION_DECL for the function currently being compiled,
-   or 0 if between functions.  */
-tree current_function_decl;
-
-/* Set to 0 at beginning of a function definition, set to 1 if
-   a return statement that specifies a return value is seen.  */
-
-int current_function_returns_value;
-
-/* Set to 0 at beginning of a function definition, set to 1 if
-   a return statement with no argument is seen.  */
-
-int current_function_returns_null;
-
-/* Set to 0 at beginning of a function definition, and whenever
-   a label (case or named) is defined.  Set to value of expression
-   returned from function when that value can be transformed into
-   a named return value.  */
-
-tree current_function_return_value;
-
-/* Nonzero means warn about multiple (redundant) decls for the same single
-   variable or function.  */
-
-extern int warn_redundant_decls;
-
-/* Set to nonzero by `grokdeclarator' for a function
-   whose return type is defaulted, if warnings for this are desired.  */
-
-static int warn_about_return_type;
-
-/* Nonzero when starting a function declared `extern inline'.  */
-
-static int current_extern_inline;
-
-/* Nonzero means give `double' the same size as `float'.  */
-
-extern int flag_short_double;
-
-/* Nonzero means don't recognize any builtin functions.  */
-
-extern int flag_no_builtin;
-
-/* Nonzero means do emit exported implementations of functions even if
-   they can be inlined.  */
-
-extern int flag_implement_inlines;
-
-/* Nonzero means handle things in ANSI, instead of GNU fashion.  This
-   flag should be tested for language behavior that's different between
-   ANSI and GNU, but not so horrible as to merit a PEDANTIC label.  */
-
-extern int flag_ansi;
-
-/* Pointers to the base and current top of the language name stack.  */
-
-extern tree *current_lang_base, *current_lang_stack;
-
-/* C and C++ flags are in cp-decl2.c.  */
-
-/* Set to 0 at beginning of a constructor, set to 1
-   if that function does an allocation before referencing its
-   instance variable.  */
-int current_function_assigns_this;
-int current_function_just_assigned_this;
-
-/* Set to 0 at beginning of a function.  Set non-zero when
-   store_parm_decls is called.  Don't call store_parm_decls
-   if this flag is non-zero!  */
-int current_function_parms_stored;
-
-/* Current end of entries in the gc obstack for stack pointer variables.  */
-
-int current_function_obstack_index;
-
-/* Flag saying whether we have used the obstack in this function or not.  */
-
-int current_function_obstack_usage;
-
-/* Flag used when debugging cp-spew.c */
-
-extern int spew_debug;
-
-/* Allocate a level of searching.  */
-struct stack_level *
-push_decl_level (stack, obstack)
-     struct stack_level *stack;
-     struct obstack *obstack;
-{
-  struct stack_level tem;
-  tem.prev = stack;
-
-  return push_stack_level (obstack, (char *)&tem, sizeof (tem));
-}
-
-/* Discard a level of decl allocation.  */
-
-static struct stack_level *
-pop_decl_level (stack)
-     struct stack_level *stack;
-{
-  tree *bp, *tp;
-  struct obstack *obstack = stack->obstack;
-  bp = stack->first;
-  tp = (tree *)obstack_next_free (obstack);
-  while (tp != bp)
-    {
-      --tp;
-      if (*tp != NULL_TREE)
-	IDENTIFIER_CLASS_VALUE (DECL_NAME (*tp)) = NULL_TREE;
-    }
-  return pop_stack_level (stack);
-}
-
-/* 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.
- */
-
-/* Note that the information in the `names' component of the global contour
-   is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
-
-struct binding_level
-  {
-    /* A chain of _DECL nodes for all variables, constants, functions,
-     * and typedef types.  These are in the reverse of the order supplied.
-     */
-    tree names;
-
-    /* A list of structure, union and enum definitions,
-     * for looking up tag names.
-     * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
-     * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
-     * or ENUMERAL_TYPE node.
-     *
-     * C++: the TREE_VALUE nodes can be simple types for component_bindings.
-     *
-     */
-    tree tags;
-
-    /* For each level, a list of shadowed outer-level local definitions
-       to be restored when this level is popped.
-       Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
-       whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
-    tree shadowed;
-
-    /* Same, for IDENTIFIER_CLASS_VALUE.  */
-    tree class_shadowed;
-
-    /* Same, for IDENTIFIER_TYPE_VALUE.  */
-    tree type_shadowed;
-
-    /* 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 BLOCK node for this level, if one has been preallocated.
-       If 0, the BLOCK is allocated (if needed) when the level is popped.  */
-    tree this_block;
-
-    /* The binding level which this one is contained in (inherits from).  */
-    struct binding_level *level_chain;
-
-    /* Number of decls in `names' that have incomplete 
-       structure or union types.  */
-    unsigned short n_incomplete;
-
-    /* 1 for the level that holds the parameters of a function.
-       2 for the level that holds a class declaration.
-       3 for levels that hold parameter declarations.  */
-    unsigned parm_flag : 4;
-
-    /* 1 means make a BLOCK for this level regardless of all else.
-       2 for temporary binding contours created by the compiler.  */
-    unsigned keep : 3;
-
-    /* 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 level can safely have additional
-       exception-raising statements added to it.  */
-    unsigned more_exceptions_ok : 1;
-    unsigned have_exceptions : 1;
-
-    /* Nonzero if we should accept any name as an identifier in
-       this scope.  This happens in some template definitions.  */
-    unsigned accept_any : 1;
-
-    /* Nonzero if this level is for completing a template class definition
-       inside a binding level that temporarily binds the parameters.  This
-       means that definitions here should not be popped off when unwinding
-       this binding level.  (Not actually implemented this way,
-       unfortunately.)  */
-    unsigned pseudo_global : 1;
-
-    /* Two bits left for this word.  */
-
-#if PARANOID
-    unsigned char depth;
-#endif
-  };
-
-#define NULL_BINDING_LEVEL (struct binding_level *) NULL
-  
-/* The binding level currently in effect.  */
-
-static struct binding_level *current_binding_level;
-
-/* The binding level of the current class, if any.  */
-
-static struct binding_level *class_binding_level;
-
-/* A chain of binding_level structures awaiting reuse.  */
-
-static struct binding_level *free_binding_level;
-
-/* The outermost binding level, for names of file scope.
-   This is created when the compiler is started and exists
-   through the entire run.  */
-
-static struct binding_level *global_binding_level;
-
-/* Binding level structures are initialized by copying this one.  */
-
-static struct binding_level clear_binding_level;
-
-/* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
-
-static int keep_next_level_flag;
-
-#if PARANOID
-/* Perform sanity checking on binding levels.  Normally not needed.  */
-void
-binding_levels_sane ()
-{
-  struct binding_level *b = current_binding_level;
-  static int n;
-  if (++n < 3)
-    return;
-  my_friendly_assert (global_binding_level != 0, 126);
-  my_friendly_assert (current_binding_level != 0, 127);
-  for (b = current_binding_level; b != global_binding_level; b = b->level_chain)
-    {
-      my_friendly_assert (b->level_chain != 0, 128);
-      my_friendly_assert (b->depth == 1 + b->level_chain->depth, 129);
-    }
-  if (class_binding_level)
-    for (b = class_binding_level;
-         b != global_binding_level && b != current_binding_level;
-         b = b->level_chain)
-    {
-      my_friendly_assert (b->level_chain != 0, 130);
-      my_friendly_assert (b->depth == 1 + b->level_chain->depth, 131);
-    }
-  my_friendly_assert (global_binding_level->depth == 0, 132);
-  my_friendly_assert (global_binding_level->level_chain == 0, 133);
-  return;
-}
-
-#else
-#define binding_levels_sane() ((void)(1))
-#endif
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-int debug_bindings_indentation;
-#endif
-
-static void
-#if !PARANOID && defined (__GNUC__)
-__inline
-#endif
-push_binding_level (newlevel, tag_transparent, keep)
-     struct binding_level *newlevel;
-     int tag_transparent, keep;
-{
-  binding_levels_sane();
-  /* Add this level to the front of the chain (stack) of levels that
-     are active.  */
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "pushing binding level ");
-  fprintf (stderr, HOST_PTR_PRINTF, newlevel);
-  fprintf (stderr, "\n");
-#endif
-  *newlevel = clear_binding_level;
-  if (class_binding_level)
-    {
-      newlevel->level_chain = class_binding_level;
-      class_binding_level = (struct binding_level *)0;
-    }
-  else
-    {
-      newlevel->level_chain = current_binding_level;
-    }
-  current_binding_level = newlevel;
-  newlevel->tag_transparent = tag_transparent;
-  newlevel->more_cleanups_ok = 1;
-  newlevel->more_exceptions_ok = 1;
-  newlevel->keep = keep;
-#if PARANOID
-  newlevel->depth = (newlevel->level_chain
-		     ? newlevel->level_chain->depth + 1
-		     : 0);
-#endif
-  binding_levels_sane();
-}
-
-static void
-#if !PARANOID && defined (__GNUC__)
-__inline
-#endif
-pop_binding_level ()
-{
-  binding_levels_sane();
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "popping binding level ");
-  fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
-  fprintf (stderr, "\n");
-#endif
-  if (global_binding_level)
-    {
-      /* cannot pop a level, if there are none left to pop. */
-      if (current_binding_level == global_binding_level)
-	my_friendly_abort (123);
-    }
-  /* Pop the current level, and free the structure for reuse.  */
-  {
-    register struct binding_level *level = current_binding_level;
-    current_binding_level = current_binding_level->level_chain;
-    level->level_chain = free_binding_level;
-#ifdef DEBUG_CP_BINDING_LEVELS
-    memset (level, 0x69, sizeof (*level));
-#else
-    free_binding_level = level;
-#if PARANOID
-    level->depth = ~0;	/* ~0 assumes that the depth is unsigned. */
-#endif
-#endif
-    if (current_binding_level->parm_flag == 2)
-      {
-	class_binding_level = current_binding_level;
-	do
-	  {
-	    current_binding_level = current_binding_level->level_chain;
-	  }
-	while (current_binding_level->parm_flag == 2);
-      }
-  }
-  binding_levels_sane();
-}
-
-/* Nonzero if we are currently in the global binding level.  */
-
-int
-global_bindings_p ()
-{
-  return current_binding_level == global_binding_level;
-}
-
-void
-keep_next_level ()
-{
-  keep_next_level_flag = 1;
-}
-
-/* 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->tags != NULL_TREE
-	      && !current_binding_level->tag_transparent));
-}
-
-/* Identify this binding level as a level of parameters.  */
-
-void
-declare_parm_level ()
-{
-  current_binding_level->parm_flag = 1;
-}
-
-/* Identify this binding level as a level of a default exception handler.  */
-
-void
-declare_implicit_exception ()
-{
-  current_binding_level->parm_flag = 3;
-}
-
-/* Nonzero if current binding contour contains expressions
-   that might raise exceptions.  */
-
-int
-have_exceptions_p ()
-{
-  return current_binding_level->have_exceptions;
-}
-
-void
-declare_uninstantiated_type_level ()
-{
-  current_binding_level->accept_any = 1;
-}
-
-int
-uninstantiated_type_level_p ()
-{
-  return current_binding_level->accept_any;
-}
-
-void
-declare_pseudo_global_level ()
-{
-  current_binding_level->pseudo_global = 1;
-}
-
-int
-pseudo_global_level_p ()
-{
-  return current_binding_level->pseudo_global;
-}
-
-/* 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;
-{
-  register struct binding_level *newlevel = NULL_BINDING_LEVEL;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "pushlevel");
-  debug_bindings_indentation += 4;
-#endif
-
-  /* If this is the top level of a function,
-     just make sure that NAMED_LABELS is 0.
-     They should have been set to 0 at the end of the previous function.  */
-
-  if (current_binding_level == global_binding_level)
-    my_friendly_assert (named_labels == NULL_TREE, 134);
-
-  /* Reuse or create a struct for this binding level.  */
-
-  if (free_binding_level)
-    {
-      newlevel = free_binding_level;
-      free_binding_level = free_binding_level->level_chain;
-    }
-  else
-    {
-      /* Create a new `struct binding_level'.  */
-      newlevel = (struct binding_level *) xmalloc (sizeof (struct binding_level));
-    }
-  push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
-  GNU_xref_start_scope ((int) newlevel);
-  keep_next_level_flag = 0;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-void
-pushlevel_temporary (tag_transparent)
-     int tag_transparent;
-{
-  pushlevel (tag_transparent);
-  current_binding_level->keep = 2;
-  clear_last_expr ();
-
-  /* Note we don't call push_momentary() here.  Otherwise, it would cause
-     cleanups to be allocated on the momentary obstack, and they will be
-     overwritten by the next statement.  */
-
-  expand_start_bindings (0);
-}
-
-/* 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 KEEP == 2, this level's subblocks go to the front,
-   not the back of the current binding level.  This happens,
-   for instance, when code for constructors and destructors
-   need to generate code at the end of a function which must
-   be moved up to the front of the function.
-
-   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 implicit_try_block = current_binding_level->parm_flag == 3;
-  int real_functionbody = current_binding_level->keep == 2
-    ? ((functionbody = 0), tmp) : functionbody;
-  tree tags = functionbody >= 0 ? current_binding_level->tags : 0;
-  tree subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
-  tree block = NULL_TREE;
-  tree decl;
-  int block_previously_created;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "poplevel");
-  debug_bindings_indentation += 4;
-#endif
-
-  binding_levels_sane();
-  GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
-		      (HOST_WIDE_INT) current_binding_level->level_chain,
-		      current_binding_level->parm_flag,
-		      current_binding_level->keep,
-		      current_binding_level->tag_transparent);
-
-  if (current_binding_level->keep == 1)
-    keep = 1;
-
-  /* This warning is turned off because it causes warnings for
-     declarations like `extern struct foo *x'.  */
-#if 0
-  /* Warn about incomplete structure types in this level.  */
-  for (link = tags; link; link = TREE_CHAIN (link))
-    if (TYPE_SIZE (TREE_VALUE (link)) == NULL_TREE)
-      {
-	tree type = TREE_VALUE (link);
-	char *errmsg;
-	switch (TREE_CODE (type))
-	  {
-	  case RECORD_TYPE:
-	    errmsg = "`struct %s' incomplete in scope ending here";
-	    break;
-	  case UNION_TYPE:
-	    errmsg = "`union %s' incomplete in scope ending here";
-	    break;
-	  case ENUMERAL_TYPE:
-	    errmsg = "`enum %s' incomplete in scope ending here";
-	    break;
-	  }
-	if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
-	  error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
-	else
-	  /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
-	  error (errmsg, TYPE_NAME_STRING (type));
-      }
-#endif /* 0 */
-
-  /* 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))
-      {
-	/* 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
-	  output_inline_function (decl);
-      }
-
-  /* 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;
-  block_previously_created = (current_binding_level->this_block != NULL_TREE);
-  if (block_previously_created)
-    block = current_binding_level->this_block;
-  else if (keep == 1 || functionbody)
-    block = make_node (BLOCK);
-  if (block != NULL_TREE)
-    {
-      BLOCK_VARS (block) = decls;
-      BLOCK_TYPE_TAGS (block) = tags;
-      BLOCK_SUBBLOCKS (block) = subblocks;
-      remember_end_note (block);
-    }
-
-  /* In each subblock, record that this is its superior.  */
-
-  if (keep >= 0)
-    for (link = subblocks; link; link = TREE_CHAIN (link))
-      BLOCK_SUPERCONTEXT (link) = block;
-
-  /* Clear out the meanings of the local variables of this level.  */
-
-  for (link = decls; link; link = TREE_CHAIN (link))
-    {
-      if (DECL_NAME (link) != NULL_TREE)
-	{
-	  /* If the ident. was used or addressed via a local extern decl,
-	     don't forget that fact.  */
-	  if (DECL_EXTERNAL (link))
-	    {
-	      if (TREE_USED (link))
-		TREE_USED (DECL_ASSEMBLER_NAME (link)) = 1;
-	      if (TREE_ADDRESSABLE (link))
-		TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
-	    }
-	  IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
-	}
-    }
-
-  /* Restore all name-meanings of the outer levels
-     that were shadowed by this level.  */
-
-  for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
-    IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
-  for (link = current_binding_level->class_shadowed;
-       link; link = TREE_CHAIN (link))
-    IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
-  for (link = current_binding_level->type_shadowed;
-       link; link = TREE_CHAIN (link))
-    IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
-
-  /* If the level being exited is the top level of a function,
-     check over all the labels.  */
-
-  if (functionbody)
-    {
-      /* If 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;
-
-      /* Clear out the definitions of all label names,
-	 since their scopes end here.  */
-
-      for (link = named_labels; link; link = TREE_CHAIN (link))
-	{
-	  register tree label = TREE_VALUE (link);
-
-	  if (DECL_INITIAL (label) == NULL_TREE)
-	    {
-	      error_with_decl (label, "label `%s' used but not defined");
-	      /* Avoid crashing later.  */
-	      define_label (input_filename, 1, DECL_NAME (label));
-	    }
-	  else if (warn_unused && !TREE_USED (label))
-	    warning_with_decl (label, 
-			       "label `%s' defined but not used");
-	  SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), 0);
-
-          /* Put the labels into the "variables" of the
-             top-level block, so debugger can see them.  */
-          TREE_CHAIN (label) = BLOCK_VARS (block);
-          BLOCK_VARS (block) = label;
-	}
-
-      named_labels = NULL_TREE;
-    }
-
-  /* Any uses of undefined labels now operate under constraints
-     of next binding contour.  */
-  {
-    struct binding_level *level_chain;
-    level_chain = current_binding_level->level_chain;
-    if (level_chain)
-      {
-	tree labels;
-	for (labels = named_label_uses; labels; labels = TREE_CHAIN (labels))
-	  if (TREE_TYPE (labels) == (tree)current_binding_level)
-	    {
-	      TREE_TYPE (labels) = (tree)level_chain;
-	      TREE_PURPOSE (labels) = level_chain->names;
-	    }
-      }
-  }
-
-  tmp = current_binding_level->keep;
-
-  pop_binding_level ();
-  if (functionbody)
-    DECL_INITIAL (current_function_decl) = block;
-  else if (block)
-    {
-      if (!block_previously_created)
-        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)
-    if (keep == 2)
-      current_binding_level->blocks = chainon (subblocks, current_binding_level->blocks);
-    else
-      current_binding_level->blocks
-        = chainon (current_binding_level->blocks, subblocks);
-
-  /* Take care of compiler's internal binding structures.  */
-  if (tmp == 2 && !implicit_try_block)
-    {
-#if 0
-      /* We did not call push_momentary for this
-	 binding contour, so there is nothing to pop.  */
-      pop_momentary ();
-#endif
-      expand_end_bindings (getdecls (), keep, 1);
-      block = poplevel (keep, reverse, real_functionbody);
-    }
-  if (block)
-    TREE_USED (block) = 1;
-  binding_levels_sane();
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-  return 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);
-}
-
-/* Add BLOCK to the current list of blocks for this binding contour.  */
-void
-add_block_current_level (block)
-     tree block;
-{
-  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)
-    register tree block;
-{
-  current_binding_level->this_block = block;
-}
-
-/* Do a pushlevel for class declarations.  */
-void
-pushlevel_class ()
-{
-  binding_levels_sane();
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "pushlevel_class");
-  debug_bindings_indentation += 4;
-#endif
-  pushlevel (0);
-  decl_stack = push_decl_level (decl_stack, &decl_obstack);
-  class_binding_level = current_binding_level;
-  class_binding_level->parm_flag = 2;
-  do
-    {
-      current_binding_level = current_binding_level->level_chain;
-    }
-  while (current_binding_level->parm_flag == 2);
-  binding_levels_sane();
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-/* ...and a poplevel for class declarations.  */
-tree
-poplevel_class ()
-{
-  register struct binding_level *level = class_binding_level;
-  tree block = NULL_TREE;
-  tree shadowed;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "poplevel_class");
-  debug_bindings_indentation += 4;
-#endif
-  binding_levels_sane();
-  if (level == (struct binding_level *)0)
-    {
-      while (current_binding_level && class_binding_level == (struct binding_level *)0)
-	block = poplevel (0, 0, 0);
-      if (current_binding_level == (struct binding_level *)0)
-	fatal ("syntax error too serious");
-      level = class_binding_level;
-    }
-  decl_stack = pop_decl_level (decl_stack);
-  for (shadowed = level->shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
-    IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
-  for (shadowed = level->class_shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
-    IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
-  for (shadowed = level->type_shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
-    IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
-
-  GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
-		      (HOST_WIDE_INT) class_binding_level->level_chain,
-		      class_binding_level->parm_flag,
-		      class_binding_level->keep,
-		      class_binding_level->tag_transparent);
-
-  class_binding_level = level->level_chain;
-  if (class_binding_level->parm_flag != 2)
-    class_binding_level = (struct binding_level *)0;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "popping class binding level ");
-  fprintf (stderr, HOST_PTR_PRINTF, level);
-  fprintf (stderr, "\n");
-  memset (level, 0x69, sizeof (*level));
-  debug_bindings_indentation -= 4;
-#else
-  level->level_chain = free_binding_level;
-  free_binding_level = level;
-#endif
-  binding_levels_sane();
-
-  return block;
-}
-
-/* For debugging.  */
-int no_print_functions = 0;
-int no_print_builtins = 0;
-
-void
-print_binding_level (lvl)
-     struct binding_level *lvl;
-{
-  tree t;
-  int i = 0, len;
-  fprintf (stderr, " blocks=");
-  fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
-  fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
-	   lvl->n_incomplete, lvl->parm_flag, lvl->keep);
-  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");
-  if (lvl->more_exceptions_ok)
-    fprintf (stderr, " more-exceptions-ok");
-  if (lvl->have_exceptions)
-    fprintf (stderr, " have-exceptions");
-  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 (TREE_CODE (t) == ERROR_MARK)
-	    break;
-	}
-      if (i)
-        fprintf (stderr, "\n");
-    }
-  if (lvl->tags)
-    {
-      fprintf (stderr, " tags:\t");
-      i = 0;
-      for (t = lvl->tags; t; t = TREE_CHAIN (t))
-	{
-	  if (TREE_PURPOSE (t) == NULL_TREE)
-	    len = 3;
-	  else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
-	    len = 2;
-	  else
-	    len = 4;
-	  i += len;
-	  if (i > 5)
-	    {
-	      fprintf (stderr, "\n\t");
-	      i = len;
-	    }
-	  if (TREE_PURPOSE (t) == NULL_TREE)
-	    {
-	      print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
-	      fprintf (stderr, ">");
-	    }
-	  else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
-	    print_node_brief (stderr, "", TREE_VALUE (t), 0);
-	  else
-	    {
-	      print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
-	      print_node_brief (stderr, "", TREE_VALUE (t), 0);
-	      fprintf (stderr, ">");
-	    }
-	}
-      if (i)
-	fprintf (stderr, "\n");
-    }
-  if (lvl->shadowed)
-    {
-      fprintf (stderr, " shadowed:");
-      for (t = lvl->shadowed; t; t = TREE_CHAIN (t))
-	{
-	  fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
-	}
-      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))
-        {
-#if 0
-          fprintf (stderr, "\n\t");
-          print_node_brief (stderr, "<", TREE_PURPOSE (t), 0);
-          if (TREE_VALUE (t))
-            print_node_brief (stderr, " ", TREE_VALUE (t), 0);
-          else
-            fprintf (stderr, " (none)");
-          fprintf (stderr, ">");
-#else
-	  fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
-#endif
-        }
-      fprintf (stderr, "\n");
-    }
-}
-
-void
-print_other_binding_stack (stack)
-     struct binding_level *stack;
-{
-  struct binding_level *level;
-  for (level = stack; level != global_binding_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 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, "\nglobal_binding_level=");
-  fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
-  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 (global_binding_level);
-}
-
-/* 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 {
-  struct binding_level *old_binding_level;
-  tree old_bindings;
-  struct saved_scope *prev;
-  tree class_name, class_type, class_decl, function_decl;
-  struct binding_level *class_bindings;
-};
-static struct saved_scope *current_saved_scope;
-extern tree prev_class_type;
-
-void
-push_to_top_level ()
-{
-  struct saved_scope *s =
-    (struct saved_scope *) xmalloc (sizeof (struct saved_scope));
-  struct binding_level *b = current_binding_level;
-  tree old_bindings = NULL_TREE;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  fprintf (stderr, "PUSH_TO_TOP_LEVEL\n");
-#endif
-
-  /* Have to include global_binding_level, because class-level decls
-     aren't listed anywhere useful.  */
-  for (; b; b = b->level_chain)
-    {
-      tree t;
-      for (t = b->names; t; t = TREE_CHAIN (t))
-	if (b != global_binding_level)
-	  {
-	    tree binding, t1, t2 = t;
-	    tree id = DECL_ASSEMBLER_NAME (t2);
-
-	    if (!id
-		|| (!IDENTIFIER_LOCAL_VALUE (id)
-		    && !IDENTIFIER_CLASS_VALUE (id)))
-	      continue;
-
-	    for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
-	      if (TREE_VEC_ELT (t1, 0) == id)
-		goto skip_it;
-	    
-	    binding = make_tree_vec (4);
-	    if (id)
-	      {
-		my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
-		TREE_VEC_ELT (binding, 0) = id;
-		TREE_VEC_ELT (binding, 1) = IDENTIFIER_TYPE_VALUE (id);
-		TREE_VEC_ELT (binding, 2) = IDENTIFIER_LOCAL_VALUE (id);
-		TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
-		IDENTIFIER_LOCAL_VALUE (id) = NULL_TREE;
-		IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
-		adjust_type_value (id);
-	      }
-	    TREE_CHAIN (binding) = old_bindings;
-	    old_bindings = binding;
-	    skip_it:
-	    ;
-	  }
-      /* Unwind type-value slots back to top level.  */
-      if (b != global_binding_level)
-        for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
-          SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
-    }
-
-  s->old_binding_level = current_binding_level;
-  current_binding_level = global_binding_level;
-
-  s->class_name = current_class_name;
-  s->class_type = current_class_type;
-  s->class_decl = current_class_decl;
-  s->function_decl = current_function_decl;
-  s->class_bindings = class_binding_level;
-  current_class_name = current_class_type = current_class_decl = NULL_TREE;
-  current_function_decl = NULL_TREE;
-  class_binding_level = (struct binding_level *)0;
-
-  s->prev = current_saved_scope;
-  s->old_bindings = old_bindings;
-  current_saved_scope = s;
-  binding_levels_sane();
-}
-
-void
-pop_from_top_level ()
-{
-  struct saved_scope *s = current_saved_scope;
-  tree t;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  fprintf (stderr, "POP_FROM_TOP_LEVEL\n");
-#endif
-
-  binding_levels_sane();
-  current_binding_level = s->old_binding_level;
-  current_saved_scope = s->prev;
-  for (t = s->old_bindings; t; t = TREE_CHAIN (t))
-    {
-      tree id = TREE_VEC_ELT (t, 0);
-      if (id)
-	{
-	  IDENTIFIER_TYPE_VALUE (id) = TREE_VEC_ELT (t, 1);
-	  IDENTIFIER_LOCAL_VALUE (id) = TREE_VEC_ELT (t, 2);
-	  IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
-	}
-    }
-  current_class_name = s->class_name;
-  current_class_type = s->class_type;
-  current_class_decl = s->class_decl;
-  if (current_class_type)
-    C_C_D = CLASSTYPE_INST_VAR (current_class_type);
-  else
-    C_C_D = NULL_TREE;
-  current_function_decl = s->function_decl;
-  class_binding_level = s->class_bindings;
-  free (s);
-  binding_levels_sane();
-}
-
-/* Push a definition of struct, union or enum tag "name".
-   "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.  */
-void
-set_identifier_type_value (id, type)
-     tree id;
-     tree type;
-{
-  if (current_binding_level != global_binding_level)
-    {
-      tree old_type_value = IDENTIFIER_TYPE_VALUE (id);
-      current_binding_level->type_shadowed
-	= tree_cons (id, old_type_value, current_binding_level->type_shadowed);
-    }
-  else if (class_binding_level)
-    {
-      tree old_type_value = IDENTIFIER_TYPE_VALUE (id);
-      class_binding_level->type_shadowed
-	= tree_cons (id, old_type_value, class_binding_level->type_shadowed);
-    }      
-  SET_IDENTIFIER_TYPE_VALUE (id, type);
-}
-
-/*
- * local values can need to be shadowed too, but it only happens
- * explicitly from pushdecl, in support of nested enums.
- */
-void
-set_identifier_local_value (id, type)
-     tree id;
-     tree type;
-{
-  if (current_binding_level != global_binding_level)
-    {
-      tree old_local_value = IDENTIFIER_LOCAL_VALUE (id);
-      current_binding_level->shadowed
-	= tree_cons (id, old_local_value, current_binding_level->shadowed);
-    }
-  else if (class_binding_level)
-    {
-      tree old_local_value = IDENTIFIER_LOCAL_VALUE (id);
-      class_binding_level->shadowed
-	= tree_cons (id, old_local_value, class_binding_level->shadowed);
-    }      
-  IDENTIFIER_LOCAL_VALUE (id) = type;
-}
-
-/* Subroutine "set_nested_typename" builds the nested-typename of
-   the type decl in question.  (Argument CLASSNAME can actually be
-   a function as well, if that's the smallest containing scope.)  */
-
-static void
-set_nested_typename (decl, classname, name, type)
-     tree decl, classname, name, type;
-{
-  my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 136);
-  if (classname != NULL_TREE)
-    {
-      char *buf;
-      my_friendly_assert (TREE_CODE (classname) == IDENTIFIER_NODE, 137);
-      my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 138);
-      buf = (char *) alloca (4 + IDENTIFIER_LENGTH (classname)
-			     + IDENTIFIER_LENGTH (name));
-      sprintf (buf, "%s::%s", IDENTIFIER_POINTER (classname),
-	       IDENTIFIER_POINTER (name));
-      DECL_NESTED_TYPENAME (decl) = get_identifier (buf);
-      SET_IDENTIFIER_TYPE_VALUE (DECL_NESTED_TYPENAME (decl), type);
-    }
-  else
-    DECL_NESTED_TYPENAME (decl) = name;
-}
-
-#if 0 /* not yet, should get fixed properly later */
-/* Create a TYPE_DECL node with the correct DECL_ASSEMBLER_NAME.
-   Other routines shouldn't use build_decl directly; they'll produce
-   incorrect results with `-g' unless they duplicate this code.
-
-   This is currently needed mainly for dbxout.c, but we can make
-   use of it in cp-method.c later as well.  */
-tree
-make_type_decl (name, type)
-     tree name, type;
-{
-  tree decl, id;
-  decl = build_decl (TYPE_DECL, name, type);
-  if (TYPE_NAME (type) == name)
-    /* Class/union/enum definition, or a redundant typedef for same.  */
-    {
-      id = get_identifier (build_overload_name (type, 1, 1));
-      DECL_ASSEMBLER_NAME (decl) = id;
-    }
-  else if (TYPE_NAME (type) != NULL_TREE)
-    /* Explicit typedef, or implicit typedef for template expansion.  */
-    DECL_ASSEMBLER_NAME (decl) = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
-  else
-    {
-      /* Typedef for unnamed struct; some other situations.
-	 TYPE_NAME is null; what's right here?  */
-    }
-  return decl;
-}
-
-#endif
-void
-pushtag (name, type)
-     tree name, type;
-{
-  register struct binding_level *b;
-
-  if (class_binding_level)
-    b = class_binding_level;
-  else
-    {
-      b = current_binding_level;
-      while (b->tag_transparent) b = b->level_chain;
-    }
-
-  if (b == global_binding_level)
-    b->tags = perm_tree_cons (name, type, b->tags);
-  else
-    b->tags = saveable_tree_cons (name, type, b->tags);
-
-  if (name)
-    {
-      /* Record the identifier as the type's name if it has none.  */
-
-      if (TYPE_NAME (type) == NULL_TREE)
-        TYPE_NAME (type) = name;
-      
-      /* Do C++ gratuitous typedefing.  */
-      if (IDENTIFIER_TYPE_VALUE (name) != type
-	  && (TREE_CODE (type) != RECORD_TYPE
-	      || class_binding_level == (struct binding_level *)0
-	      || !CLASSTYPE_DECLARED_EXCEPTION (type)))
-        {
-          register tree d;
-	  if (current_class_type == NULL_TREE
-	      || TYPE_SIZE (current_class_type) != NULL_TREE)
-	    {
-	      if (current_lang_name == lang_name_cplusplus)
-		d = lookup_nested_type (type, current_class_type ? TYPE_NAME (current_class_type) : NULL_TREE);
-	      else
-		d = NULL_TREE;
-
-	      if (d == NULL_TREE)
-		{
-#if 0 /* not yet, should get fixed properly later */
-		  d = make_type_decl (name, type);
-		  DECL_ASSEMBLER_NAME (d) = get_identifier (build_overload_name (type, 1, 1));
-#else
-		  d = build_decl (TYPE_DECL, name, type);
-		  DECL_ASSEMBLER_NAME (d) = get_identifier (build_overload_name (type, 1, 1));
-#endif
-		  /* mark the binding layer marker as internal. (mrs) */
-		  DECL_SOURCE_LINE (d) = 0;
-		  set_identifier_type_value (name, type);
-		}
-	      else
-		d = TYPE_NAME (d);
-
-	      /* If it is anonymous, then we are called from pushdecl,
-		 and we don't want to infinitely recurse.  Also, if the
-		 name is already in scope, we don't want to push it
-		 again--pushdecl is only for pushing new decls.  */
-	      if (! ANON_AGGRNAME_P (name)
-		  && TYPE_NAME (type)
-		  && (TREE_CODE (TYPE_NAME (type)) != TYPE_DECL
-		      || lookup_name (name, 1) != TYPE_NAME (type)))
-		{
-		  if (class_binding_level)
-		    d = pushdecl_class_level (d);
-		  else
-		    d = pushdecl (d);
-		}
-	    }
-	  else
-	    {
-	      /* Make nested declarations go into class-level scope.  */
-	      d = build_lang_field_decl (TYPE_DECL, name, type);
-	      set_identifier_type_value (name, type);
-	      d = pushdecl_class_level (d);
-	    }
-	  if (ANON_AGGRNAME_P (name))
-	    DECL_IGNORED_P (d) = 1;
-	  TYPE_NAME (type) = d;
-
-	  if ((current_class_type == NULL_TREE
-	       && current_function_decl == NULL_TREE)
-	      || current_lang_name != lang_name_cplusplus)
-	    /* Non-nested class.  */
-	    DECL_NESTED_TYPENAME (d) = name;
-	  else if (current_function_decl != NULL_TREE)
-	    {
-	      /* Function-nested class.  */
-	      set_nested_typename (d, DECL_ASSEMBLER_NAME (current_function_decl),
-				   name, type);
-	      /* This builds the links for classes nested in fn scope.  */
-	      DECL_CONTEXT (d) = current_function_decl;
-	    }
-	  else if (TYPE_SIZE (current_class_type) == NULL_TREE)
-	    {
-	      /* Class-nested class.  */
-	      set_nested_typename (d, DECL_NESTED_TYPENAME (TYPE_NAME (current_class_type)),
-				   name, type);
-	      /* This builds the links for classes nested in type scope.  */
-	      DECL_CONTEXT (d) = current_class_type;
-	      DECL_CLASS_CONTEXT (d) = current_class_type;
-	    }
-        }
-      if (b->parm_flag == 2)
-	{
-	  TREE_NONLOCAL_FLAG (type) = 1;
-	  IDENTIFIER_CLASS_VALUE (name) = TYPE_NAME (type);
-	  if (TYPE_SIZE (current_class_type) == NULL_TREE)
-	    CLASSTYPE_TAGS (current_class_type) = b->tags;
-	}
-    }
-
-  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.  */
-
-#if 0 /* not yet, should get fixed properly later */
-      TYPE_STUB_DECL (type) = pushdecl (make_type_decl (NULL, type));
-#else
-      TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
-#endif
-    }
-}
-
-/* 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 binding_level *b;
-  register tree tags;
-  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;
-  tags = b->tags;
-  while (tags)
-    {
-      /* A NULL purpose means we have already processed all tags
-	 from here to the end of the list.  */
-      if (TREE_PURPOSE (tags) == NULL_TREE)
-	break;
-      if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
-	TREE_PURPOSE (tags) = NULL_TREE;
-      tags = TREE_CHAIN (tags);
-    }
-  last_cnt = anon_cnt;
-}
-
-/* Subroutine of duplicate_decls: return truthvalue of whether
-   or not types of these decls match.  */
-static int
-decls_match (newdecl, olddecl)
-     tree newdecl, olddecl;
-{
-  int types_match;
-
-  if (TREE_CODE (newdecl) == FUNCTION_DECL && TREE_CODE (olddecl) == FUNCTION_DECL)
-    {
-      tree f1 = TREE_TYPE (newdecl);
-      tree f2 = TREE_TYPE (olddecl);
-      tree p1 = TYPE_ARG_TYPES (f1);
-      tree p2 = TYPE_ARG_TYPES (f2);
-
-      /* When we parse a static member function definition,
-	 we put together a FUNCTION_DECL which thinks its type
-	 is METHOD_TYPE.  Change that to FUNCTION_TYPE, and
-	 proceed.  */
-      if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
-	revert_static_member_fn (&f1, &newdecl, &p1);
-      else if (TREE_CODE (f2) == METHOD_TYPE
-	       && DECL_STATIC_FUNCTION_P (newdecl))
-	revert_static_member_fn (&f2, &olddecl, &p2);
-
-      /* Here we must take care of the case where new default
-	 parameters are specified.  Also, warn if an old
-	 declaration becomes ambiguous because default
-	 parameters may cause the two to be ambiguous.  */
-      if (TREE_CODE (f1) != TREE_CODE (f2))
-	{
-	  if (TREE_CODE (f1) == OFFSET_TYPE)
-	    compiler_error_with_decl (newdecl, "`%s' redeclared as member function");
-	  else
-	    compiler_error_with_decl (newdecl, "`%s' redeclared as non-member function");
-	  return 0;
-	}
-
-      if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (f1)),
-		     TYPE_MAIN_VARIANT (TREE_TYPE (f2)), 1))
-	types_match = compparms (p1, p2, 1);
-      else types_match = 0;
-    }
-  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
-	types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 1);
-    }
-
-  return types_match;
-}
-
-/* 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.  */
-
-static int
-duplicate_decls (newdecl, olddecl)
-     register tree newdecl, olddecl;
-{
-  extern struct obstack permanent_obstack;
-  unsigned olddecl_uid = DECL_UID (olddecl);
-  int olddecl_friend = 0, types_match;
-  int new_defines_function;
-  register unsigned saved_old_decl_uid;
-  register int saved_old_decl_friend_p;
-
-  if (TREE_CODE (olddecl) == TREE_LIST
-      && TREE_CODE (newdecl) == FUNCTION_DECL)
-    {
-      /* If a new decl finds a list of old decls, then
-	 we assume that the new decl has C linkage, and
-	 that the old decls have C++ linkage.  In this case,
-	 we must look through the list to see whether
-	 there is an ambiguity or not.  */
-      tree olddecls = olddecl;
-
-      /* If the overload list is empty, just install the decl.  */
-      if (TREE_VALUE (olddecls) == NULL_TREE)
-	{
-	  TREE_VALUE (olddecls) = newdecl;
-	  return 1;
-	}
-
-      while (olddecls)
-	{
-	  if (decls_match (newdecl, TREE_VALUE (olddecls)))
-	    {
-	      if (TREE_CODE (newdecl) == VAR_DECL)
-		;
-	      else if (DECL_LANGUAGE (newdecl)
-		       != DECL_LANGUAGE (TREE_VALUE (olddecls)))
-		{
-		  error_with_decl (newdecl, "declaration of `%s' with different language linkage");
-		  error_with_decl (TREE_VALUE (olddecls), "previous declaration here");
-		}
-	      types_match = 1;
-	      break;
-	    }
-	  olddecls = TREE_CHAIN (olddecls);
-	}
-      if (olddecls)
-	olddecl = TREE_VALUE (olddecl);
-      else
-	return 1;
-    }
-  else
-    {
-      if (TREE_CODE (olddecl) != TREE_LIST)
-	olddecl_friend = DECL_LANG_SPECIFIC (olddecl) && DECL_FRIEND_P (olddecl);
-      types_match = decls_match (newdecl, olddecl);
-    }
-
-  if ((TREE_TYPE (newdecl) && TREE_CODE (TREE_TYPE (newdecl)) == ERROR_MARK)
-      || (TREE_TYPE (olddecl) && TREE_CODE (TREE_TYPE (olddecl)) == ERROR_MARK))
-    types_match = 0;
-
-  /* If this decl has linkage, and the old one does too, maybe no error.  */
-  if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
-    {
-      error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
-      if (TREE_CODE (olddecl) == TREE_LIST)
-	olddecl = TREE_VALUE (olddecl);
-      error_with_decl (olddecl, "previous declaration of `%s'");
-
-      /* New decl is completely inconsistent with the old one =>
-	 tell caller to replace the old one.  */
-
-      return 0;
-    }
-
-  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);
-      if (DECL_CLASS_CONTEXT (olddecl))
-	DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
-      if (DECL_CHAIN (newdecl) == NULL_TREE)
-	DECL_CHAIN (newdecl) = DECL_CHAIN (olddecl);
-      if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
-	DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
-    }
-
-  if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
-      && IDENTIFIER_IMPLICIT_DECL (DECL_ASSEMBLER_NAME (newdecl)) == olddecl)
-    /* If -traditional, avoid error for redeclaring fcn
-       after implicit decl.  */
-    ;
-  else if (TREE_CODE (olddecl) == FUNCTION_DECL
-	   && DECL_BUILT_IN (olddecl))
-    {
-      if (!types_match)
-	{
-	  error_with_decl (newdecl, "declaration of `%s'");
-	  error_with_decl (olddecl, "conflicts with built-in declaration `%s'");
-	}
-    }
-  else if (!types_match)
-    {
-      tree oldtype = TREE_TYPE (olddecl);
-      tree newtype = TREE_TYPE (newdecl);
-      int give_error = 0;
-
-      /* Already complained about this, so don't do so again.  */
-      if (current_class_type == NULL_TREE
-	  || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
-	{
-	  give_error = 1;
-	  error_with_decl (newdecl, "conflicting types for `%s'");
-	}
-
-      /* Check for function type mismatch
-	 involving an empty arglist vs a nonempty one.  */
-      if (TREE_CODE (olddecl) == FUNCTION_DECL
-	  && comptypes (TREE_TYPE (oldtype),
-			TREE_TYPE (newtype), 1)
-	  && ((TYPE_ARG_TYPES (oldtype) == NULL_TREE
-	       && DECL_INITIAL (olddecl) == NULL_TREE)
-	      || (TYPE_ARG_TYPES (newtype) == NULL_TREE
-		  && DECL_INITIAL (newdecl) == NULL_TREE)))
-	{
-	  /* Classify the problem further.  */
-	  register tree t = TYPE_ARG_TYPES (oldtype);
-	  if (t == NULL_TREE)
-	    t = TYPE_ARG_TYPES (newtype);
-	  for (; t; t = TREE_CHAIN (t))
-	    {
-	      register tree type = TREE_VALUE (t);
-
-	      if (TREE_CHAIN (t) == NULL_TREE && type != void_type_node)
-		{
-		  error ("A parameter list with an ellipsis can't match");
-		  error ("an empty parameter name list declaration.");
-		  break;
-		}
-
-	      if (TYPE_MAIN_VARIANT (type) == float_type_node
-		  || C_PROMOTING_INTEGER_TYPE_P (type))
-		{
-		  error ("An argument type that has a default promotion");
-		  error ("can't match an empty parameter name list declaration.");
-		  break;
-		}
-	    }
-	}
-      if (give_error)
-	error_with_decl (olddecl, "previous declaration of `%s'");
-
-      /* There is one thing GNU C++ cannot tolerate: a constructor
-	 which takes the type of object being constructed.
-	 Farm that case out here.  */
-      if (TREE_CODE (newdecl) == FUNCTION_DECL
-	  && DECL_CONSTRUCTOR_P (newdecl))
-	{
-	  tree tmp = TREE_CHAIN (TYPE_ARG_TYPES (newtype));
-
-	  if (tmp != NULL_TREE
-	      && (TYPE_MAIN_VARIANT (TREE_VALUE (tmp))
-		  == TYPE_METHOD_BASETYPE (newtype)))
-	    {
-	      tree parm = TREE_CHAIN (DECL_ARGUMENTS (newdecl));
-	      tree argtypes
-		= hash_tree_chain (build_reference_type (TREE_VALUE (tmp)),
-				   TREE_CHAIN (tmp));
-
-	      DECL_ARG_TYPE (parm)
-		= TREE_TYPE (parm)
-		  = TYPE_REFERENCE_TO (TREE_VALUE (tmp));
-
-	      TREE_TYPE (newdecl) = newtype
-		= build_cplus_method_type (TYPE_METHOD_BASETYPE (newtype),
-					   TREE_TYPE (newtype), argtypes);
-	      error ("constructor cannot take as argument the type being constructed");
-	      SET_IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl), current_class_type);
-	    }
-	}
-    }
-  else
-    {
-      char *errmsg = redeclaration_error_message (newdecl, olddecl);
-      if (errmsg)
-	{
-	  error_with_decl (newdecl, errmsg);
-	  if (DECL_NAME (olddecl) != NULL_TREE)
-	    error_with_decl (olddecl,
-			     (DECL_INITIAL (olddecl)
-			      && current_binding_level == global_binding_level)
-			        ? "`%s' previously defined here"
-			        : "`%s' previously declared here");
-	}
-      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.  */
-	  warning_with_decl (newdecl, "prototype for `%s'");
-	  warning_with_decl (olddecl,
-			     "follows non-prototype definition here");
-	}
-
-      /* These bits are logically part of the type.  */
-      if (pedantic
-	  && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
-	      || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
-	error_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
-    }
-
-  /* Deal with C++: must preserve virtual function table size.  */
-  if (TREE_CODE (olddecl) == TYPE_DECL)
-    {
-      if (TYPE_LANG_SPECIFIC (TREE_TYPE (newdecl))
-          && TYPE_LANG_SPECIFIC (TREE_TYPE (olddecl)))
-	{
-	  CLASSTYPE_VSIZE (TREE_TYPE (newdecl))
-	    = CLASSTYPE_VSIZE (TREE_TYPE (olddecl));
-	  CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (newdecl))
-	    = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (olddecl));
-	}
-      /* why assert here?  Just because debugging information is
-	 messed up? (mrs) */
-      /* it happens on something like:
-	 	typedef struct Thing {
-                	Thing();
-		        int     x;
-		} Thing;
-      */
-#if 0
-      my_friendly_assert (DECL_IGNORED_P (olddecl) == DECL_IGNORED_P (newdecl), 139);
-#endif
-    }
-
-  /* Special handling ensues if new decl is a function definition.  */
-  new_defines_function = (TREE_CODE (newdecl) == FUNCTION_DECL
-			  && 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_SOURCE_LINE (olddecl) != 0
-      && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE))
-    {
-      warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
-      warning_with_decl (olddecl, "previous declaration of `%s'");
-    }
-
-  /* Copy all the DECL_... slots specified in the new decl
-     except for any that we copy here from the old type.  */
-
-  if (types_match)
-    {
-      /* Automatically handles default parameters.  */
-      tree oldtype = TREE_TYPE (olddecl);
-      /* Merge the data types specified in the two decls.  */
-      tree newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
-
-      if (TREE_CODE (newdecl) == VAR_DECL)
-	DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
-      /* Do this after calling `common_type' 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 ctype = NULL_TREE;
-	  ctype = DECL_CLASS_CONTEXT (newdecl);
-	  TREE_TYPE (newdecl) = build_exception_variant (ctype, newtype,
-							 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
-	  TREE_TYPE (olddecl) = build_exception_variant (ctype, newtype,
-							 TYPE_RAISES_EXCEPTIONS (oldtype));
-
-	  if (! compexcepttypes (TREE_TYPE (newdecl), TREE_TYPE(olddecl), 0))
-	    {
-	      error_with_decl (newdecl, "declaration of `%s' raises different exceptions...");
-	      error_with_decl (olddecl, "...from previous declaration here");
-	    }
-	}
-      TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
-
-      /* Lay the type out, unless already done.  */
-      if (oldtype != TREE_TYPE (newdecl))
-	{
-	  if (TREE_TYPE (newdecl) != error_mark_node)
-	    layout_type (TREE_TYPE (newdecl));
-	  if (TREE_CODE (newdecl) != FUNCTION_DECL
-	      && TREE_CODE (newdecl) != TYPE_DECL
-	      && TREE_CODE (newdecl) != CONST_DECL)
-	    layout_decl (newdecl, 0);
-	}
-      else
-	{
-	  /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
-	  DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
-	}
-
-      /* 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 (newdecl) = DECL_INITIAL (olddecl);
-      /* Keep the old rtl since we can safely use it, unless it's the
-	 call to abort() used for abstract virtuals.  */
-      if ((DECL_LANG_SPECIFIC (olddecl)
-	   && !DECL_ABSTRACT_VIRTUAL_P (olddecl))
-	  || DECL_RTL (olddecl) != DECL_RTL (abort_fndecl))
-	DECL_RTL (newdecl) = DECL_RTL (olddecl);
-    }
-  /* 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.  */
-  if (DECL_EXTERNAL (newdecl))
-    {
-      TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
-      DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
-
-      /* For functions, static overrides non-static.  */
-      if (TREE_CODE (newdecl) == FUNCTION_DECL)
-	{
-	  TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
-	  /* This is since we don't automatically
-	     copy the attributes of NEWDECL into OLDDECL.  */
-	  TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
-	  /* If this clears `static', clear it in the identifier too.  */
-	  if (! TREE_PUBLIC (olddecl))
-	    TREE_PUBLIC (DECL_ASSEMBLER_NAME (olddecl)) = 0;
-	}
-      else
-	TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
-    }
-  else
-    {
-      TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
-      /* A `const' which was not declared `extern' and is
-	 in static storage is invisible.  */
-      if (TREE_CODE (newdecl) == VAR_DECL
-	  && TREE_READONLY (newdecl) && TREE_STATIC (newdecl)
-	  && ! DECL_THIS_EXTERN (newdecl))
-	TREE_PUBLIC (newdecl) = 0;
-      TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
-    }
-
-  /* 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);
-
-  if (TREE_CODE (newdecl) == FUNCTION_DECL)
-    {
-      if (new_defines_function)
-	/* If defining a function declared with other language
-	   linkage, use the previously declared language linkage.  */
-	DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
-      else
-	{
-	  /* If redeclaring a builtin function, and not a definition,
-	     it stays built in.  */
-	  if (DECL_BUILT_IN (olddecl))
-	    {
-	      DECL_BUILT_IN (newdecl) = 1;
-	      DECL_SET_FUNCTION_CODE (newdecl, DECL_FUNCTION_CODE (olddecl));
-	      /* If we're keeping the built-in definition, keep the rtl,
-		 regardless of declaration matches.  */
-	      DECL_RTL (newdecl) = DECL_RTL (olddecl);
-	    }
-	  else
-	    DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
-
-	  DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
-	  if (DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl))
-	    /* Previously saved insns go together with
-	       the function's previous definition.  */
-	    DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
-	  /* Don't clear out the arguments if we're redefining a function.  */
-	  if (DECL_ARGUMENTS (olddecl))
-	    DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
-	}
-    }
-
-  /* Now preserve various other info from the definition.  */
-  TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
-  TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
-
-  /* Don't really know how much of the language-specific
-     values we should copy from old to new.  */
-#if 1
-  if (DECL_LANG_SPECIFIC (olddecl))
-    DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
-#endif
-
-  /* We are about to copy the contexts of newdecl into olddecl, so save a
-     few tidbits of information from olddecl that we may need to restore
-     after the copying takes place.  */
-
-  saved_old_decl_uid = DECL_UID (olddecl);
-  saved_old_decl_friend_p
-    = DECL_LANG_SPECIFIC (olddecl) ? DECL_FRIEND_P (olddecl) : 0;
-
-  if (TREE_CODE (newdecl) == FUNCTION_DECL)
-    {
-      int function_size;
-      struct lang_decl *ol = DECL_LANG_SPECIFIC (olddecl);
-      struct lang_decl *nl = DECL_LANG_SPECIFIC (newdecl);
-
-      function_size = sizeof (struct tree_decl);
-
-      bcopy ((char *) newdecl + sizeof (struct tree_common),
-	     (char *) olddecl + sizeof (struct tree_common),
-	     function_size - sizeof (struct tree_common));
-
-      if ((char *)newdecl + ((function_size + sizeof (struct lang_decl)
-			     + obstack_alignment_mask (&permanent_obstack))
-			     & ~ obstack_alignment_mask (&permanent_obstack))
-	  == obstack_next_free (&permanent_obstack))
-	{
-	  DECL_MAIN_VARIANT (newdecl) = olddecl;
-	  DECL_LANG_SPECIFIC (olddecl) = ol;
-	  bcopy ((char *)nl, (char *)ol, sizeof (struct lang_decl));
-
-	  obstack_free (&permanent_obstack, newdecl);
-	}
-      else if (LANG_DECL_PERMANENT (ol))
-	{
-	  if (DECL_MAIN_VARIANT (olddecl) == olddecl)
-	    {
-	      /* Save these lang_decls that would otherwise be lost.  */
-	      extern tree free_lang_decl_chain;
-	      tree free_lang_decl = (tree) ol;
-	      TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
-	      free_lang_decl_chain = free_lang_decl;
-	    }
-	  else
-	    {
-	      /* Storage leak.  */
-	    }
-	}
-    }
-  else
-    {
-      bcopy ((char *) newdecl + sizeof (struct tree_common),
-	     (char *) olddecl + sizeof (struct tree_common),
-	     sizeof (struct tree_decl) - sizeof (struct tree_common)
-	     + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
-    }
-
-  DECL_UID (olddecl) = olddecl_uid;
-  if (olddecl_friend)
-    DECL_FRIEND_P (olddecl) = 1;
-
-  /* Restore some pieces of information which were originally in olddecl.  */
-
-  DECL_UID (olddecl) = saved_old_decl_uid;
-  if (DECL_LANG_SPECIFIC (olddecl))
-    DECL_FRIEND_P (olddecl) |= saved_old_decl_friend_p;
-
-  return 1;
-}
-
-void
-adjust_type_value (id)
-     tree id;
-{
-  tree t;
-
-  if (current_binding_level != global_binding_level)
-    {
-      if (current_binding_level != class_binding_level)
-	{
-	  t = IDENTIFIER_LOCAL_VALUE (id);
-	  if (t && TREE_CODE (t) == TYPE_DECL)
-	    {
-	    set_it:
-	      SET_IDENTIFIER_TYPE_VALUE (id, TREE_TYPE (t));
-	      return;
-	    }
-	}
-      else
-	my_friendly_abort (7);
-
-      if (current_class_type)
-	{
-	  t = IDENTIFIER_CLASS_VALUE (id);
-	  if (t && TREE_CODE (t) == TYPE_DECL)
-	    goto set_it;
-	}
-    }
-
-  t = IDENTIFIER_GLOBAL_VALUE (id);
-  if (t && TREE_CODE (t) == TYPE_DECL)
-    goto set_it;
-  if (t && TREE_CODE (t) == TEMPLATE_DECL)
-    SET_IDENTIFIER_TYPE_VALUE (id, NULL_TREE);
-}
-
-/* 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;
-#if 0 /* not yet, should get fixed properly later */
-  register tree name;
-#else
-  register tree name = DECL_ASSEMBLER_NAME (x);
-#endif
-  register struct binding_level *b = current_binding_level;
-
-#if 0
-  static int nglobals; int len;
-
-  len = list_length (global_binding_level->names);
-  if (len < nglobals)
-    my_friendly_abort (8);
-  else if (len > nglobals)
-    nglobals = len;
-#endif
-
-  /* Don't change DECL_CONTEXT of virtual methods.  */
-  if (x != current_function_decl
-      && (TREE_CODE (x) != FUNCTION_DECL
-	  || !DECL_VIRTUAL_P (x)))
-    DECL_CONTEXT (x) = current_function_decl;
-  /* A local declaration for a function doesn't constitute nesting.  */
-  if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0)
-    DECL_CONTEXT (x) = 0;
-
-#if 0 /* not yet, should get fixed properly later */
-  /* For functions and class static data, we currently look up the encoded
-     form of the name.  For types, we want the real name.  The former will
-     probably be changed soon, according to MDT.  */
-  if (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
-    name = DECL_ASSEMBLER_NAME (x);
-  else
-    name = DECL_NAME (x);
-#else
-  /* Type are looked up using the DECL_NAME, as that is what the rest of the
-     compiler wants to use. */
-  if (TREE_CODE (x) == TYPE_DECL)
-    name = DECL_NAME (x);
-#endif
-
-  if (name)
-    {
-      char *file;
-      int line;
-
-      t = lookup_name_current_level (name);
-      if (t == error_mark_node)
-	{
-	  /* error_mark_node is 0 for a while during initialization!  */
-	  t = NULL_TREE;
-	  error_with_decl (x, "`%s' used prior to declaration");
-	}
-
-      if (t != NULL_TREE)
-	{
-	  if (TREE_CODE (t) == PARM_DECL)
-	    {
-	      if (DECL_CONTEXT (t) == NULL_TREE)
-		fatal ("parse errors have confused me too much");
-	    }
-	  file = DECL_SOURCE_FILE (t);
-	  line = DECL_SOURCE_LINE (t);
-	}
-
-      if (t != NULL_TREE && TREE_CODE (t) != TREE_CODE (x))
-	{
-	  if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (x) == 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.  */
-	      ;
-	    }
-	  else if (duplicate_decls (x, t))
-	    return t;
-	}
-      else if (t != NULL_TREE && duplicate_decls (x, t))
-	{
-	  /* If this decl is `static' and an `extern' was seen previously,
-	     that is erroneous.  But don't complain if -traditional,
-	     since traditional compilers don't complain.
-
-	     Note that this does not apply to the C++ case of declaring
-	     a variable `extern const' and then later `const'.  */
-	  if (!flag_traditional && TREE_PUBLIC (name)
-	      && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x) && ! DECL_INLINE (x))
-	    {
-	      /* Due to interference in memory reclamation (X may be
-		 obstack-deallocated at this point), we must guard against
-		 one really special case.  */
-	      if (current_function_decl == x)
-		current_function_decl = t;
-	      if (IDENTIFIER_IMPLICIT_DECL (name))
-		warning ("`%s' was declared implicitly `extern' and later `static'",
-			 lang_printable_name (t));
-	      else
-		warning ("`%s' was declared `extern' and later `static'",
-			 lang_printable_name (t));
-	      warning_with_file_and_line (file, line,
-					  "previous declaration of `%s'",
-					  lang_printable_name (t));
-	    }
-	  return t;
-	}
-
-      /* If declaring a type as a typedef, and the type has no known
-	 typedef name, install this TYPE_DECL as its typedef name.
-
-	 C++: If it had an anonymous aggregate or enum name,
-	 give it a `better' one.  */
-      if (TREE_CODE (x) == TYPE_DECL)
-	{
-	  tree name = TYPE_NAME (TREE_TYPE (x));
-
-	  if (name == NULL_TREE || TREE_CODE (name) != TYPE_DECL)
-	    {
-	      /* If these are different names, and we're at the global
-		 binding level, make two equivalent definitions.  */
-              name = x;
-              if (global_bindings_p ())
-                TYPE_NAME (TREE_TYPE (x)) = x;
-	    }
-	  else
-	    {
-	      tree tname = DECL_NAME (name);
-	      if (global_bindings_p () && ANON_AGGRNAME_P (tname))
-		{
-		  /* do gratuitous C++ typedefing, and make sure that
-		     we access this type either through TREE_TYPE field
-		     or via the tags list.  */
-		  TYPE_NAME (TREE_TYPE (x)) = x;
-		  pushtag (tname, TREE_TYPE (x));
-		}
-	    }
-	  my_friendly_assert (TREE_CODE (name) == TYPE_DECL, 140);
-	  if (DECL_NAME (name) && !DECL_NESTED_TYPENAME (name))
-	    set_nested_typename (x, current_class_name, DECL_NAME (name),
-				 TREE_TYPE (x));
-	  if (TYPE_NAME (TREE_TYPE (x)) && TYPE_IDENTIFIER (TREE_TYPE (x)))
-            set_identifier_type_value (DECL_NAME (x), TREE_TYPE (x));
-/* was using TYPE_IDENTIFIER (TREE_TYPE (x)) */
-	}
-
-      /* Multiple external decls of the same identifier ought to match.  */
-
-      if (DECL_EXTERNAL (x) && IDENTIFIER_GLOBAL_VALUE (name) != NULL_TREE
-	  && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
-	      || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name)))
-	  /* We get warnings about inline functions where they are defined.
-	     Avoid duplicate warnings where they are used.  */
-	  && !DECL_INLINE (x))
-	{
-	  if (! comptypes (TREE_TYPE (x),
-			   TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)), 1))
-	    {
-	      warning_with_decl (x,
-				 "type mismatch with previous external decl");
-	      warning_with_decl (IDENTIFIER_GLOBAL_VALUE (name),
-				 "previous external decl of `%s'");
-	    }
-	}
-
-      /* In PCC-compatibility mode, extern decls of vars with no current decl
-	 take effect at top level no matter where they are.  */
-      if (flag_traditional && DECL_EXTERNAL (x)
-	  && lookup_name (name, 0) == NULL_TREE)
-	b = global_binding_level;
-
-      /* This name is new in its binding level.
-	 Install the new declaration and return it.  */
-      if (b == global_binding_level)
-	{
-	  /* Install a global value.  */
-
-	  /* Rule for VAR_DECLs, but not for other kinds of _DECLs:
-	     A `const' which was not declared `extern' is invisible.  */
-	  if (TREE_CODE (x) == VAR_DECL
-	      && TREE_READONLY (x) && ! DECL_THIS_EXTERN (x))
-	    TREE_PUBLIC (x) = 0;
-
-	  /* 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;
-
-	  /* Don't install a TYPE_DECL if we already have another
-	     sort of _DECL with that name.  */
-	  if (TREE_CODE (x) != TYPE_DECL
-	      || t == NULL_TREE
-	      || TREE_CODE (t) == TYPE_DECL)
-#if 0
-	    /* This has not be thoroughly tested yet. */
-	    /* It allows better dwarf debugging. */
-	    IDENTIFIER_GLOBAL_VALUE (name)
-	      = TREE_CODE_CLASS (TREE_CODE (x)) == 'd'
-		? x : build_decl (TYPE_DECL, NULL, TREE_TYPE (x));
-#else
-	    IDENTIFIER_GLOBAL_VALUE (name) = x;
-#endif
-
-	  /* 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 ("`%s' was previously implicitly declared to return `int'",
-		     lang_printable_name (x));
-
-	  /* If this decl is `static' and an `extern' was seen previously,
-	     that is erroneous.  Don't do this for TYPE_DECLs.  */
-	  if (TREE_PUBLIC (name)
-	      && TREE_CODE (x) != TYPE_DECL
-	      && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
-	    {
-	      if (IDENTIFIER_IMPLICIT_DECL (name))
-		warning ("`%s' was declared implicitly `extern' and later `static'",
-			 lang_printable_name (x));
-	      else
-		warning ("`%s' was declared `extern' and later `static'",
-			 lang_printable_name (x));
-	    }
-	}
-      else
-	{
-	  /* Here to install a non-global value.  */
-	  tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
-	  tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
-	  set_identifier_local_value (name, x);
-
-	  /* 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) && !DECL_INLINE (x)
-	      && oldglobal != NULL_TREE
-	      && TREE_CODE (x) == FUNCTION_DECL
-	      && TREE_CODE (oldglobal) == FUNCTION_DECL)
-	    {
-	      /* We have one.  Their types must agree.  */
-	      if (! comptypes (TREE_TYPE (x), TREE_TYPE (oldglobal), 1))
-		warning_with_decl (x, "extern declaration of `%s' doesn't match global one");
-	      else
-		{
-		  /* Inner extern decl is inline if global one is.
-		     Copy enough to really inline it.  */
-		  if (DECL_INLINE (oldglobal))
-		    {
-		      DECL_INLINE (x) = DECL_INLINE (oldglobal);
-		      DECL_INITIAL (x) = (current_function_decl == oldglobal
-					  ? NULL_TREE : DECL_INITIAL (oldglobal));
-		      DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
-		      DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
-		      DECL_RESULT (x) = DECL_RESULT (oldglobal);
-		      TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
-		      DECL_ABSTRACT_ORIGIN (x) = oldglobal;
-		    }
-		  /* Inner extern decl is built-in if global one is.  */
-		  if (DECL_BUILT_IN (oldglobal))
-		    {
-		      DECL_BUILT_IN (x) = DECL_BUILT_IN (oldglobal);
-		      DECL_SET_FUNCTION_CODE (x, DECL_FUNCTION_CODE (oldglobal));
-		    }
-		  /* Keep the arg types from a file-scope fcn defn.  */
-		  if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != NULL_TREE
-		      && DECL_INITIAL (oldglobal)
-		      && TYPE_ARG_TYPES (TREE_TYPE (x)) == NULL_TREE)
-		    TREE_TYPE (x) = TREE_TYPE (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;
-	    }
-
-	  if (DECL_FROM_INLINE (x))
-	    /* Inline decls shadow nothing.  */;
-
-	  /* Warn if shadowing an argument at the top level of the body.  */
-	  else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
-	      && TREE_CODE (oldlocal) == PARM_DECL
-	      && TREE_CODE (x) != PARM_DECL)
-	    {
-	      /* Go to where the parms should be and see if we
-		 find them there.  */
-	      struct binding_level *b = current_binding_level->level_chain;
-
-	      if (cleanup_label)
-		b = b->level_chain;
-
-	      /* ARM $8.3 */
-	      if (b->parm_flag == 1)
-		pedwarn ("declaration of `%s' shadows a parameter",
-			 IDENTIFIER_POINTER (name));
-	    }
-	  /* Maybe warn if shadowing something else.  */
-	  else if (warn_shadow && !DECL_EXTERNAL (x)
-		   /* No shadow warnings for internally generated vars.  */
-		   && DECL_SOURCE_LINE (x) != 0
-		   /* No shadow warnings for vars made for inlining.  */
-		   && ! DECL_FROM_INLINE (x))
-	    {
-	      char *warnstring = NULL;
-
-	      if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
-		warnstring = "declaration of `%s' shadows a parameter";
-	      else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE)
-		warnstring = "declaration of `%s' shadows a member of `this'";
-	      else if (oldlocal != NULL_TREE)
-		warnstring = "declaration of `%s' shadows previous local";
-	      else if (oldglobal != NULL_TREE)
-		warnstring = "declaration of `%s' shadows global declaration";
-
-	      if (warnstring)
-		warning (warnstring, IDENTIFIER_POINTER (name));
-	    }
-
-	  /* If storing a local value, there may already be one (inherited).
-	     If so, record it for restoration when this binding level ends.  */
-	  if (oldlocal != NULL_TREE)
-	    b->shadowed = tree_cons (name, oldlocal, b->shadowed);
-	}
-
-      /* Keep count of variables in this level with incomplete type.  */
-      if (TREE_CODE (x) != TEMPLATE_DECL
-	  && TREE_CODE (x) != CPLUS_CATCH_DECL
-	  && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
-	  && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
-	{
-	  if (++b->n_incomplete == 0)
-	    error ("too many incomplete variables at this point");
-	}
-    }
-
-  if (TREE_CODE (x) == TYPE_DECL && name != NULL_TREE)
-    {
-      adjust_type_value (name);
-      if (current_class_name)
-	{
-	  if (!DECL_NESTED_TYPENAME (x))
-	    set_nested_typename (x, current_class_name, DECL_NAME (x),
-				 TREE_TYPE (x));
-	  adjust_type_value (DECL_NESTED_TYPENAME (x));
-	}
-    }
-
-  /* Put decls on list in reverse order.
-     We will reverse them later if necessary.  */
-  TREE_CHAIN (x) = b->names;
-  b->names = x;
-  if (! (b != global_binding_level || TREE_PERMANENT (x)))
-    my_friendly_abort (124);
-
-  return x;
-}
-
-/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
-   if appropriate.  */
-tree
-pushdecl_top_level (x)
-     tree x;
-{
-  register tree t;
-  register struct binding_level *b = current_binding_level;
-
-  current_binding_level = global_binding_level;
-  t = pushdecl (x);
-  current_binding_level = b;
-  if (class_binding_level)
-    b = class_binding_level;
-  /* 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 (; b != global_binding_level; 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
-        {
-#if 0
-	  /* Disabled this 11/10/92, since there are many cases which
-	     behave just fine when *ptr doesn't satisfy either of these.
-	     For example, nested classes declared as friends of their enclosing
-	     class will not meet this criteria.  (bpk) */
-	  my_friendly_assert (*ptr == NULL_TREE || *ptr == newval, 141);
-#endif
-	  *ptr = newval;
-        }
-    }
-  return t;
-}
-
-/* Like push_overloaded_decl, only it places X in GLOBAL_BINDING_LEVEL,
-   if appropriate.  */
-void
-push_overloaded_decl_top_level (x, forget)
-     tree x;
-     int forget;
-{
-  struct binding_level *b = current_binding_level;
-
-  current_binding_level = global_binding_level;
-  push_overloaded_decl (x, forget);
-  current_binding_level = b;
-}
-
-/* Make the declaration of X appear in CLASS scope.  */
-tree
-pushdecl_class_level (x)
-     tree x;
-{
-  /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
-     scope looks for the pre-mangled name.  */
-  register tree name = DECL_NAME (x);
-
-  if (name)
-    {
-      tree oldclass = IDENTIFIER_CLASS_VALUE (name);
-      if (oldclass)
-	class_binding_level->class_shadowed
-	  = tree_cons (name, oldclass, class_binding_level->class_shadowed);
-      IDENTIFIER_CLASS_VALUE (name) = x;
-      obstack_ptr_grow (&decl_obstack, x);
-      if (TREE_CODE (x) == TYPE_DECL && !DECL_NESTED_TYPENAME (x))
-	set_nested_typename (x, current_class_name, name, TREE_TYPE (x));
-    }
-  return x;
-}
-
-/* Tell caller how to interpret a TREE_LIST which contains
-   chains of FUNCTION_DECLS.  */
-int
-overloaded_globals_p (list)
-     tree list;
-{
-  my_friendly_assert (TREE_CODE (list) == TREE_LIST, 142);
-
-  /* Don't commit caller to seeing them as globals.  */
-  if (TREE_NONLOCAL_FLAG (list))
-    return -1;
-  /* Do commit caller to seeing them as globals.  */
-  if (TREE_CODE (TREE_PURPOSE (list)) == IDENTIFIER_NODE)
-    return 1;
-  /* Do commit caller to not seeing them as globals.  */
-  return 0;
-}
-
-/* DECL is a FUNCTION_DECL which may have other definitions already in place.
-   We get around this by making IDENTIFIER_GLOBAL_VALUE (DECL_NAME (DECL))
-   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_RESULT
-   slot.  It is dealt with the same way.
-
-   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, forgettable)
-     tree decl;
-     int forgettable;
-{
-  tree orig_name = DECL_NAME (decl);
-  tree glob = IDENTIFIER_GLOBAL_VALUE (orig_name);
-
-  DECL_OVERLOADED (decl) = 1;
-  if (glob)
-    {
-      if (TREE_CODE (glob) != TREE_LIST)
-	{
-	  if (DECL_LANGUAGE (decl) == lang_c)
-	    {
-	      if (TREE_CODE (glob) == FUNCTION_DECL)
-		{
-		  if (DECL_LANGUAGE (glob) == lang_c)
-		    {
-		      error_with_decl (decl, "C-language function `%s' overloaded here");
-		      error_with_decl (glob, "Previous C-language version of this function was `%s'");
-		    }
-		}
-	      else
-		my_friendly_abort (9);
-	    }
-	  if (forgettable
-	      && ! flag_traditional
-	      && TREE_PERMANENT (glob) == 1
-	      && !global_bindings_p ())
-	    overloads_to_forget = tree_cons (orig_name, glob, overloads_to_forget);
-	  /* We cache the value of builtin functions as ADDR_EXPRs
-	     in the name space.  Convert it to some kind of _DECL after
-	     remembering what to forget.  */
-	  if (TREE_CODE (glob) == ADDR_EXPR)
-	    glob = TREE_OPERAND (glob, 0);
-
-	  if (TREE_CODE (glob) == FUNCTION_DECL
-	      && DECL_LANGUAGE (glob) != DECL_LANGUAGE (decl)
-	      && comptypes (TREE_TYPE (glob), TREE_TYPE (decl), 1))
-	    {
-	      if (current_lang_stack == current_lang_base)
-		{
-		  DECL_LANGUAGE (decl) = DECL_LANGUAGE (glob);
-		  return glob;
-		}
-	      else
-		{
-		  error_with_decl (decl, "conflicting language contexts for declaration of `%s';");
-		  error_with_decl (glob, "conflicts with previous declaration here");
-		}
-	    }
-	  if (pedantic && TREE_CODE (glob) == VAR_DECL)
-	    {
-	      my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (glob)) == 'd', 143);
-	      error_with_decl (glob, "non-function declaration `%s'");
-	      error_with_decl (decl, "conflicts with function declaration `%s'");
-	    }
-	  glob = tree_cons (orig_name, glob, NULL_TREE);
-	  glob = tree_cons (TREE_PURPOSE (glob), decl, glob);
-	  IDENTIFIER_GLOBAL_VALUE (orig_name) = glob;
-	  TREE_TYPE (glob) = unknown_type_node;
-	  return decl;
-	}
-
-      if (TREE_VALUE (glob) == NULL_TREE)
-	{
-	  TREE_VALUE (glob) = decl;
-	  return decl;
-	}
-      if (TREE_CODE (decl) != TEMPLATE_DECL)
-        {
-          tree name = DECL_ASSEMBLER_NAME (decl);
-          tree tmp;
-	  
-	  for (tmp = glob; tmp; tmp = TREE_CHAIN (tmp))
-	    {
-	      if (TREE_CODE (TREE_VALUE (tmp)) == FUNCTION_DECL
-		  && DECL_LANGUAGE (TREE_VALUE (tmp)) != DECL_LANGUAGE (decl)
-		  && comptypes (TREE_TYPE (TREE_VALUE (tmp)), TREE_TYPE (decl),
-				1))
-		{
-		  error_with_decl (decl,
-				   "conflicting language contexts for declaration of `%s';");
-		  error_with_decl (TREE_VALUE (tmp),
-				   "conflicts with previous declaration here");
-		}
-	      if (TREE_CODE (TREE_VALUE (tmp)) != TEMPLATE_DECL
-		  && DECL_ASSEMBLER_NAME (TREE_VALUE (tmp)) == name)
-		return decl;
-	    }
-	}
-    }
-  if (DECL_LANGUAGE (decl) == lang_c)
-    {
-      tree decls = glob;
-      while (decls && DECL_LANGUAGE (TREE_VALUE (decls)) == lang_cplusplus)
-	decls = TREE_CHAIN (decls);
-      if (decls)
-	{
-	  error_with_decl (decl, "C-language function `%s' overloaded here");
-	  error_with_decl (TREE_VALUE (decls), "Previous C-language version of this function was `%s'");
-	}
-    }
-
-  if (forgettable
-      && ! flag_traditional
-      && (glob == NULL_TREE || TREE_PERMANENT (glob) == 1)
-      && !global_bindings_p ()
-      && !pseudo_global_level_p ())
-    overloads_to_forget = tree_cons (orig_name, glob, overloads_to_forget);
-  glob = tree_cons (orig_name, decl, glob);
-  IDENTIFIER_GLOBAL_VALUE (orig_name) = glob;
-  TREE_TYPE (glob) = unknown_type_node;
-  return 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;
-  int temp = allocation_temporary_p ();
-
-  push_obstacks_nochange ();
-
-  /* Save the decl permanently so we can warn if definition follows.
-     In ANSI C, warn_implicit is usually false, so the saves little space.
-     But in C++, it's usually true, hence the extra code.  */
-  if (temp && (flag_traditional || !warn_implicit
-	       || current_binding_level == global_binding_level))
-    end_temporary_allocation ();
-
-  /* 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;
-
-  /* ANSI standard says implicit declarations are in the innermost block.
-     So we record the decl in the standard fashion.
-     If flag_traditional is set, pushdecl does it top-level.  */
-  pushdecl (decl);
-  rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
-
-  if (warn_implicit
-      /* Only one warning per identifier.  */
-      && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
-    {
-      pedwarn ("implicit declaration of function `%s'",
-	       IDENTIFIER_POINTER (functionid));
-    }
-
-  SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
-
-  pop_obstacks ();
-
-  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 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 (TREE_TYPE (olddecl) == TREE_TYPE (newdecl))
-	return 0;
-      else
-	return "redefinition of `%s'";
-    }
-  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_ABSTRACT_VIRTUAL_P (olddecl))
-	return 0;
-
-      /* Declarations of functions can insist on internal linkage
-	 but they can't be inconsistent with internal linkage,
-	 so there can be no error on that account.
-	 However defining the same name twice is no good.  */
-      if (DECL_INITIAL (olddecl) != NULL_TREE
-	  && DECL_INITIAL (newdecl) != NULL_TREE
-	  /* However, defining once as extern inline and a second
-	     time in another way is ok.  */
-	  && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
-	       && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
-	{
-	  if (DECL_NAME (olddecl) == NULL_TREE)
-	    return "`%s' not declared in class";
-	  else
-	    return "redefinition of `%s'";
-	}
-      return 0;
-    }
-  else if (current_binding_level == global_binding_level)
-    {
-      /* 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.  */
-      if (DECL_INITIAL (olddecl) != NULL_TREE
-	  && DECL_INITIAL (newdecl) != NULL_TREE)
-	return "redefinition of `%s'";
-      /* Now we have two tentative defs, or one tentative and one real def.  */
-      /* Insist that the linkage match.  */
-      if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
-	return "conflicting declarations of `%s'";
-      return 0;
-    }
-  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 `%s'";
-      return 0;
-    }
-}
-
-/* Get the LABEL_DECL corresponding to identifier ID as a label.
-   Create one if none exists so far for the current function.
-   This function is called for both label definitions and label references.  */
-
-tree
-lookup_label (id)
-     tree id;
-{
-  register tree decl = IDENTIFIER_LABEL_VALUE (id);
-
-  if ((decl == NULL_TREE
-      || DECL_SOURCE_LINE (decl) == 0)
-      && (named_label_uses == 0
-	  || TREE_PURPOSE (named_label_uses) != current_binding_level->names
-	  || TREE_VALUE (named_label_uses) != decl))
-    {
-      named_label_uses
-	= tree_cons (current_binding_level->names, decl, named_label_uses);
-      TREE_TYPE (named_label_uses) = (tree)current_binding_level;
-    }
-
-  /* Use a label already defined or ref'd with this name.  */
-  if (decl != NULL_TREE)
-    {
-      /* But not if it is inherited and wasn't declared to be inheritable.  */
-      if (DECL_CONTEXT (decl) != current_function_decl
-	  && ! C_DECLARED_LABEL_FLAG (decl))
-	return shadow_label (id);
-      return decl;
-    }
-
-  decl = build_decl (LABEL_DECL, id, void_type_node);
-
-  /* A label not explicitly declared must be local to where it's ref'd.  */
-  DECL_CONTEXT (decl) = current_function_decl;
-
-  DECL_MODE (decl) = VOIDmode;
-
-  /* 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;
-
-  SET_IDENTIFIER_LABEL_VALUE (id, decl);
-
-  named_labels = tree_cons (NULL_TREE, decl, named_labels);
-  TREE_VALUE (named_label_uses) = decl;
-
-  return decl;
-}
-
-/* Make a label named NAME in the current function,
-   shadowing silently any that may be inherited from containing functions
-   or containing scopes.
-
-   Note that valid use, if the label being shadowed
-   comes from another scope in the same function,
-   requires calling declare_nonlocal_label right away.  */
-
-tree
-shadow_label (name)
-     tree name;
-{
-  register tree decl = IDENTIFIER_LABEL_VALUE (name);
-
-  if (decl != NULL_TREE)
-    {
-      shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
-      SET_IDENTIFIER_LABEL_VALUE (name, 0);
-      SET_IDENTIFIER_LABEL_VALUE (decl, 0);
-    }
-
-  return lookup_label (name);
-}
-
-/* Define a label, specifying the location in the source file.
-   Return the LABEL_DECL node for the label, if the definition is valid.
-   Otherwise return 0.  */
-
-tree
-define_label (filename, line, name)
-     char *filename;
-     int line;
-     tree name;
-{
-  tree decl = lookup_label (name);
-
-  /* After labels, make any new cleanups go into their
-     own new (temporary) binding contour.  */
-  current_binding_level->more_cleanups_ok = 0;
-
-  /* If label with this name is known from an outer context, shadow it.  */
-  if (decl != NULL_TREE && DECL_CONTEXT (decl) != current_function_decl)
-    {
-      shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
-      SET_IDENTIFIER_LABEL_VALUE (name, 0);
-      decl = lookup_label (name);
-    }
-
-  if (DECL_INITIAL (decl) != NULL_TREE)
-    {
-      error_with_decl (decl, "duplicate label `%s'");
-      return 0;
-    }
-  else
-    {
-      tree uses, prev;
-
-      /* 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;
-
-      for (prev = NULL_TREE, uses = named_label_uses;
-	   uses;
-	   prev = uses, uses = TREE_CHAIN (uses))
-	if (TREE_VALUE (uses) == decl)
-	  {
-	    struct binding_level *b = current_binding_level;
-	    while (b)
-	      {
-		tree new_decls = b->names;
-		tree old_decls = ((tree)b == TREE_TYPE (uses)
-				  ? TREE_PURPOSE (uses) : NULL_TREE);
-		while (new_decls != old_decls)
-		  {
-		    if (TREE_CODE (new_decls) == VAR_DECL
-			/* Don't complain about crossing initialization
-			   of internal entities.  They can't be accessed,
-			   and they should be cleaned up
-			   by the time we get to the label.  */
-			&& DECL_SOURCE_LINE (new_decls) != 0
-			&& ((DECL_INITIAL (new_decls) != NULL_TREE
-			     && DECL_INITIAL (new_decls) != error_mark_node)
-			    || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
-		      {
-			if (IDENTIFIER_ERROR_LOCUS (decl) == NULL_TREE)
-			  error_with_decl (decl, "invalid jump to label `%s'");
-			SET_IDENTIFIER_ERROR_LOCUS (decl, current_function_decl);
-			error_with_decl (new_decls, "crosses initialization of `%s'");
-		      }
-		    new_decls = TREE_CHAIN (new_decls);
-		  }
-		if ((tree)b == TREE_TYPE (uses))
-		  break;
-		b = b->level_chain;
-	      }
-
-	    if (prev)
-	      TREE_CHAIN (prev) = TREE_CHAIN (uses);
-	    else
-	      named_label_uses = TREE_CHAIN (uses);
-	  }
-      current_function_return_value = NULL_TREE;
-      return decl;
-    }
-}
-
-/* Same, but for CASE labels.  If DECL is NULL_TREE, it's the default.  */
-/* XXX Note decl is never actually used. (bpk) */
-void
-define_case_label (decl)
-     tree decl;
-{
-  tree cleanup = last_cleanup_this_contour ();
-  if (cleanup)
-    {
-      static int explained = 0;
-      error_with_decl (TREE_PURPOSE (cleanup), "destructor needed for `%s'");
-      error ("where case label appears here");
-      if (!explained)
-	{
-	  error ("(enclose actions of previous case statements requiring");
-	  error ("destructors in their own binding contours.)");
-	  explained = 1;
-	}
-    }
-
-  /* After labels, make any new cleanups go into their
-     own new (temporary) binding contour.  */
-
-  current_binding_level->more_cleanups_ok = 0;
-  current_function_return_value = NULL_TREE;
-}
-
-/* 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;
-}
-
-/* Return the list of type-tags (for structs, etc) of the current level.  */
-
-tree
-gettags ()
-{
-  return current_binding_level->tags;
-}
-
-/* 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;
-}
-
-/* Similarly, store the list of tags of the current level.  */
-
-static void
-storetags (tags)
-     tree tags;
-{
-  current_binding_level->tags = tags;
-}
-
-/* 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;
-     struct binding_level *binding_level;
-     tree name;
-     int thislevel_only;
-{
-  register struct binding_level *level;
-
-  for (level = binding_level; level; level = level->level_chain)
-    {
-      register tree tail;
-      if (ANON_AGGRNAME_P (name))
-	for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
-	  {
-	    /* There's no need for error checking here, because
-	       anon names are unique throughout the compilation.  */
-	    if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
-	      return TREE_VALUE (tail);
-	  }
-      else
-	for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
-	  {
-	    if (TREE_PURPOSE (tail) == name)
-	      {
-		enum tree_code code = TREE_CODE (TREE_VALUE (tail));
-		/* Should tighten this up; it'll probably permit
-		   UNION_TYPE and a struct template, for example.  */
-		if (code != form
-		    && !(form != ENUMERAL_TYPE
-			 && (code == TEMPLATE_DECL
-			     || code == UNINSTANTIATED_P_TYPE)))
-			   
-		  {
-		    /* Definition isn't the kind we were looking for.  */
-		    error ("`%s' defined as wrong kind of tag",
-			   IDENTIFIER_POINTER (name));
-		  }
-		return TREE_VALUE (tail);
-	      }
-	  }
-      if (thislevel_only && ! level->tag_transparent)
-	return NULL_TREE;
-      if (current_class_type && level->level_chain == global_binding_level)
-	{
-	  /* Try looking in this class's tags before heading into
-	     global binding level.  */
-	  tree context = current_class_type;
-	  while (context)
-	    {
-	      switch (TREE_CODE_CLASS (TREE_CODE (context)))
-		{
-		case 't':
-		  {
-		    tree these_tags = CLASSTYPE_TAGS (context);
-		    if (ANON_AGGRNAME_P (name))
-		      while (these_tags)
-			{
-			  if (TYPE_IDENTIFIER (TREE_VALUE (these_tags))
-			      == name)
-			    return TREE_VALUE (tail);
-			  these_tags = TREE_CHAIN (these_tags);
-			}
-		    else
-		      while (these_tags)
-			{
-			  if (TREE_PURPOSE (these_tags) == name)
-			    {
-			      if (TREE_CODE (TREE_VALUE (these_tags)) != form)
-				{
-				  error ("`%s' defined as wrong kind of tag in class scope",
-					 IDENTIFIER_POINTER (name));
-				}
-			      return TREE_VALUE (tail);
-			    }
-			  these_tags = TREE_CHAIN (these_tags);
-			}
-		    /* If this type is not yet complete, then don't
-		       look at its context.  */
-		    if (TYPE_SIZE (context) == NULL_TREE)
-		      goto no_context;
-		    /* Go to next enclosing type, if any.  */
-		    context = DECL_CONTEXT (TYPE_NAME (context));
-		    break;
-		  case 'd':
-		    context = DECL_CONTEXT (context);
-		    break;
-		  default:
-		    my_friendly_abort (10);
-		  }
-		  continue;
-		}
-	    no_context:
-	      break;
-	    }
-	}
-    }
-  return NULL_TREE;
-}
-
-void
-set_current_level_tags_transparency (tags_transparent)
-     int tags_transparent;
-{
-  current_binding_level->tag_transparent = tags_transparent;
-}
-
-/* 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 non-zero, 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 binding_level *level;
-
-  for (level = current_binding_level; level; level = level->level_chain)
-    {
-      register tree tail;
-      for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
-	{
-	  if (TREE_VALUE (tail) == type)
-	    {
-	      if (name)
-		TREE_PURPOSE (tail) = name;
-	      return TREE_PURPOSE (tail);
-	    }
-	}
-    }
-  return NULL_TREE;
-}
-
-/* Given type TYPE which was not declared in C++ language context,
-   attempt to find a name by which it is referred.  */
-tree
-typedecl_for_tag (tag)
-     tree tag;
-{
-  struct binding_level *b = current_binding_level;
-
-  if (TREE_CODE (TYPE_NAME (tag)) == TYPE_DECL)
-    return TYPE_NAME (tag);
-
-  while (b)
-    {
-      tree decls = b->names;
-      while (decls)
-	{
-	  if (TREE_CODE (decls) == TYPE_DECL && TREE_TYPE (decls) == tag)
-	    break;
-	  decls = TREE_CHAIN (decls);
-	}
-      if (decls)
-	return decls;
-      b = b->level_chain;
-    }
-  return NULL_TREE;
-}
-
-/* Called when we must retroactively globalize a type we previously
-   thought needed to be nested.  This happens, for example, when
-   a `friend class' declaration is seen for an undefined type.  */
-
-static void
-globalize_nested_type (type)
-     tree type;
-{
-  tree t, prev = NULL_TREE, d = TYPE_NAME (type);
-  struct binding_level *b;
-
-  my_friendly_assert (TREE_CODE (d) == TYPE_DECL, 144);
-  /* If the type value has already been globalized, then we're set.  */
-  if (IDENTIFIER_GLOBAL_VALUE (DECL_NAME (d)) == d)
-    return;
-  if (IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (d)))
-    {
-      /* If this type already made it into the global tags,
-	 silently return.  */
-      if (value_member (type, global_binding_level->tags))
-	return;
-    }
-
-  set_identifier_type_value (DECL_NESTED_TYPENAME (d), NULL_TREE);
-  DECL_NESTED_TYPENAME (d) = DECL_NAME (d);
-  DECL_CONTEXT (d) = NULL_TREE;
-  if (class_binding_level)
-    b = class_binding_level;
-  else
-    b = current_binding_level;
-  while (b != global_binding_level)
-    {
-      prev = NULL_TREE;
-      if (b->parm_flag == 2)
-	for (t = b->tags; t != NULL_TREE; prev = t, t = TREE_CHAIN (t))
-	  if (TREE_VALUE (t) == type)
-	    goto found;
-      b = b->level_chain;
-    }
-  /* We failed to find this tag anywhere up the binding chains.
-     B is now the global binding level... check there.  */
-  prev = NULL_TREE;
-  if (b->parm_flag == 2)
-    for (t = b->tags; t != NULL_TREE; prev = t, t = TREE_CHAIN (t))
-      if (TREE_VALUE (t) == type)
-	goto foundglobal;
-  /* It wasn't in global scope either, so this is an anonymous forward ref
-     of some kind; let it happen.  */
-  return;
-
-foundglobal:
-  print_node_brief (stderr, "Tried to globalize already-global type ",
-		    type, 0);
-  my_friendly_abort (11);
-
-found:
-  /* Pull the tag out of the nested binding contour.  */
-  if (prev)
-    TREE_CHAIN (prev) = TREE_CHAIN (t);
-  else
-    b->tags = TREE_CHAIN (t);
-  
-  set_identifier_type_value (TREE_PURPOSE (t), TREE_VALUE (t));
-  global_binding_level->tags
-    = perm_tree_cons (TREE_PURPOSE (t), TREE_VALUE (t),
-		      global_binding_level->tags);
-
-  /* Pull the tag out of the class's tags (if there).
-     It won't show up if it appears e.g. in a parameter declaration
-     or definition of a member function of this type.  */
-  if (current_class_type != NULL_TREE)
-    {
-      for (t = CLASSTYPE_TAGS (current_class_type), prev = NULL_TREE;
-	   t != NULL_TREE;
-	   prev = t, t = TREE_CHAIN (t))
-	if (TREE_VALUE (t) == type)
-	  break;
-
-      if (t != NULL_TREE)
-	{
-	  if (prev)
-	    TREE_CHAIN (prev) = TREE_CHAIN (t);
-	  else
-	    CLASSTYPE_TAGS (current_class_type) = TREE_CHAIN (t);
-	}
-    }
-
-  pushdecl_top_level (d);
-}
-
-static void
-maybe_globalize_type (type)
-     tree type;
-{
-  if ((((TREE_CODE (type) == RECORD_TYPE
-	 || TREE_CODE (type) == UNION_TYPE)
-	&& ! TYPE_BEING_DEFINED (type))
-       || TREE_CODE (type) == ENUMERAL_TYPE)
-      && TYPE_SIZE (type) == NULL_TREE
-      /* This part is gross.  We keep calling here with types that
-	 are instantiations of templates, when that type should is
-	 global, or doesn't have the type decl established yet,
-	 so globalizing will fail (because it won't find the type in any
-	 non-global scope).  So we short-circuit that path.  */
-      && !(TYPE_NAME (type) != NULL_TREE
-	   && TYPE_IDENTIFIER (type) != NULL_TREE
-	   && ! IDENTIFIER_HAS_TYPE_VALUE (TYPE_IDENTIFIER (type)))
-      )
-    globalize_nested_type (type);
-}
-
-/* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
-   Return the type value, or NULL_TREE if not found.  */
-static tree
-lookup_nested_type (type, context)
-     tree type;
-     tree context;
-{
-  if (context == NULL_TREE)
-    return NULL_TREE;
-  while (context)
-    {
-      switch (TREE_CODE (context))
-	{
-	case TYPE_DECL:
-	  {
-	    tree ctype = TREE_TYPE (context);
-	    tree match = value_member (type, CLASSTYPE_TAGS (ctype));
-	    if (match)
-	      return TREE_VALUE (match);
-	    context = DECL_CONTEXT (context);
-
-	    /* When we have a nested class whose member functions have
-	       local types (e.g., a set of enums), we'll arrive here
-	       with the DECL_CONTEXT as the actual RECORD_TYPE node for
-	       the enclosing class.  Instead, we want to make sure we
-	       come back in here with the TYPE_DECL, not the RECORD_TYPE.  */
-	    if (context && TREE_CODE (context) == RECORD_TYPE)
-	      context = TREE_CHAIN (context);
-	  }
-	  break;
-	case FUNCTION_DECL:
-	  return TYPE_IDENTIFIER (type) ? lookup_name (TYPE_IDENTIFIER (type), 1) : NULL_TREE;
-	  break;
-	default:
-	  my_friendly_abort (12);
-	}
-    }
-  return NULL_TREE;
-}
-
-/* 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.
-   If PREFER_TYPE is = 0, we prefer non-TYPE_DECLs.
-   If PREFER_TYPE is < 0, we arbitrate according to lexical context.  */
-
-tree
-lookup_name (name, prefer_type)
-     tree name;
-     int prefer_type;
-{
-  register tree val;
-
-  if (current_binding_level != global_binding_level
-      && IDENTIFIER_LOCAL_VALUE (name))
-    val = IDENTIFIER_LOCAL_VALUE (name);
-  /* In C++ class fields are between local and global scope,
-     just before the global scope.  */
-  else if (current_class_type)
-    {
-      val = IDENTIFIER_CLASS_VALUE (name);
-      if (val == NULL_TREE
-	  && TYPE_SIZE (current_class_type) == NULL_TREE
-	  && CLASSTYPE_LOCAL_TYPEDECLS (current_class_type))
-	{
-	  /* Try to find values from base classes
-	     if we are presently defining a type.
-	     We are presently only interested in TYPE_DECLs.  */
-	  val = lookup_field (current_class_type, name, 0, prefer_type < 0);
-	  if (val == error_mark_node)
-	    return val;
-	  if (val && TREE_CODE (val) != TYPE_DECL)
-	    val = NULL_TREE;
-	}
-
-      /* yylex() calls this with -2, since we should never start digging for
-	 the nested name at the point where we haven't even, for example,
-	 created the COMPONENT_REF or anything like that.  */
-      if (val == NULL_TREE)
-	val = lookup_nested_field (name, prefer_type != -2);
-
-      if (val == NULL_TREE)
-	val = IDENTIFIER_GLOBAL_VALUE (name);
-    }
-  else
-    val = IDENTIFIER_GLOBAL_VALUE (name);
-
-  if (val)
-    {
-      extern int looking_for_typename;
-
-      /* Arbitrate between finding a TYPE_DECL and finding
-	 other kinds of _DECLs.  */
-      if (TREE_CODE (val) == TYPE_DECL || looking_for_typename < 0)
-	return val;
-
-      if (IDENTIFIER_HAS_TYPE_VALUE (name))
-	{
-	  register tree val_as_type = TYPE_NAME (IDENTIFIER_TYPE_VALUE (name));
-
-	  if (val == val_as_type || prefer_type > 0
-	      || looking_for_typename > 0)
-	    return val_as_type;
-	  if (prefer_type == 0)
-	    return val;
-	  return arbitrate_lookup (name, val, val_as_type);
-	}
-      if (TREE_TYPE (val) == error_mark_node)
-	return error_mark_node;
-    }
-
-  return val;
-}
-
-/* Similar to `lookup_name' but look only at current binding level.  */
-
-tree
-lookup_name_current_level (name)
-     tree name;
-{
-  register tree t;
-
-  if (current_binding_level == global_binding_level)
-    return IDENTIFIER_GLOBAL_VALUE (name);
-
-  if (IDENTIFIER_LOCAL_VALUE (name) == NULL_TREE)
-    return 0;
-
-  for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
-    if (DECL_NAME (t) == name)
-      break;
-
-  return t;
-}
-
-/* Arrange for the user to get a source line number, even when the
-   compiler is going down in flames, so that she at least has a
-   chance of working around problems in the compiler.  We used to
-   call error(), but that let the segmentation fault continue
-   through; now, it's much more passive by asking them to send the
-   maintainers mail about the problem.  */
-
-static void
-sigsegv (sig)
-     int sig;
-{
-  signal (SIGSEGV, SIG_DFL);
-#ifdef SIGIOT
-  signal (SIGIOT, SIG_DFL);
-#endif
-#ifdef SIGILL
-  signal (SIGILL, SIG_DFL);
-#endif
-#ifdef SIGABRT
-  signal (SIGABRT, SIG_DFL);
-#endif
-  my_friendly_abort (0);
-}
-
-/* Array for holding types considered "built-in".  These types
-   are output in the module in which `main' is defined.  */
-static tree *builtin_type_tdescs_arr;
-static int builtin_type_tdescs_len, builtin_type_tdescs_max;
-
-/* Push the declarations of builtin types into the namespace.
-   RID_INDEX, if < RID_MAX 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.  */
-
-static void
-record_builtin_type (rid_index, name, type)
-     enum rid rid_index;
-     char *name;
-     tree type;
-{
-  tree rname = NULL_TREE, tname = NULL_TREE;
-  tree tdecl;
-
-  if ((int) rid_index < (int) RID_MAX)
-    rname = ridpointers[(int) rid_index];
-  if (name)
-    tname = get_identifier (name);
-
-  if (tname)
-    {
-#if 0 /* not yet, should get fixed properly later */
-      tdecl = pushdecl (make_type_decl (tname, type));
-#else
-      tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
-#endif
-      set_identifier_type_value (tname, NULL_TREE);
-      if ((int) rid_index < (int) RID_MAX)
-	IDENTIFIER_GLOBAL_VALUE (tname) = tdecl;
-    }
-  if (rname != NULL_TREE)
-    {
-      if (tname != NULL_TREE)
-	{
-	  set_identifier_type_value (rname, NULL_TREE);
-	  IDENTIFIER_GLOBAL_VALUE (rname) = tdecl;
-	}
-      else
-	{
-#if 0 /* not yet, should get fixed properly later */
-	  tdecl = pushdecl (make_type_decl (rname, type));
-#else
-	  tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
-#endif
-	  set_identifier_type_value (rname, NULL_TREE);
-	}
-    }
-
-  if (flag_dossier)
-    {
-      if (builtin_type_tdescs_len+5 >= builtin_type_tdescs_max)
-	{
-	  builtin_type_tdescs_max *= 2;
-	  builtin_type_tdescs_arr
-	    = (tree *)xrealloc (builtin_type_tdescs_arr,
-				builtin_type_tdescs_max * sizeof (tree));
-	}
-      builtin_type_tdescs_arr[builtin_type_tdescs_len++] = type;
-      if (TREE_CODE (type) != POINTER_TYPE)
-	{
-	  builtin_type_tdescs_arr[builtin_type_tdescs_len++]
-	    = build_pointer_type (type);
-	  builtin_type_tdescs_arr[builtin_type_tdescs_len++]
-	    = build_type_variant (TYPE_POINTER_TO (type), 1, 0);
-	}
-      if (TREE_CODE (type) != VOID_TYPE)
-	{
-	  builtin_type_tdescs_arr[builtin_type_tdescs_len++]
-	    = build_reference_type (type);
-	  builtin_type_tdescs_arr[builtin_type_tdescs_len++]
-	    = build_type_variant (TYPE_REFERENCE_TO (type), 1, 0);
-	}
-    }
-}
-
-static void
-output_builtin_tdesc_entries ()
-{
-  extern struct obstack permanent_obstack;
-
-  /* If there's more than one main in this file, don't crash.  */
-  if (builtin_type_tdescs_arr == 0)
-    return;
-
-  push_obstacks (&permanent_obstack, &permanent_obstack);
-  while (builtin_type_tdescs_len > 0)
-    {
-      tree type = builtin_type_tdescs_arr[--builtin_type_tdescs_len];
-      tree tdesc = build_t_desc (type, 0);
-      TREE_ASM_WRITTEN (tdesc) = 0;
-      build_t_desc (type, 2);
-    }
-  free (builtin_type_tdescs_arr);
-  builtin_type_tdescs_arr = 0;
-  pop_obstacks ();
-}
-
-/* Push overloaded decl, in global scope, with one argument so it
-   can be used as a callback from define_function.  */
-static void
-push_overloaded_decl_1 (x)
-     tree x;
-{
-  push_overloaded_decl (x, 0);
-}
-
-/* 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
-init_decl_processing ()
-{
-  tree decl;
-  register tree endlink, int_endlink, double_endlink, ptr_endlink;
-  tree fields[20];
-  /* Either char* or void*.  */
-  tree traditional_ptr_type_node;
-  /* Data type of memcpy.  */
-  tree memcpy_ftype;
-  int wchar_type_size;
-
-  /* Have to make these distinct before we try using them.  */
-  lang_name_cplusplus = get_identifier ("C++");
-  lang_name_c = get_identifier ("C");
-
-  /* Initially, C.  */
-  current_lang_name = lang_name_c;
-
-  current_function_decl = NULL_TREE;
-  named_labels = NULL_TREE;
-  named_label_uses = NULL_TREE;
-  current_binding_level = NULL_BINDING_LEVEL;
-  free_binding_level = NULL_BINDING_LEVEL;
-
-  /* Because most segmentation signals can be traced back into user
-     code, catch them and at least give the user a chance of working
-     around compiler bugs. */
-  signal (SIGSEGV, sigsegv);
-
-  /* We will also catch aborts in the back-end through sigsegv and give the
-     user a chance to see where the error might be, and to defeat aborts in
-     the back-end when there have been errors previously in their code. */
-#ifdef SIGIOT
-  signal (SIGIOT, sigsegv);
-#endif
-#ifdef SIGILL
-  signal (SIGILL, sigsegv);
-#endif
-#ifdef SIGABRT
-  signal (SIGABRT, sigsegv);
-#endif
-
-  gcc_obstack_init (&decl_obstack);
-  if (flag_dossier)
-    {
-      builtin_type_tdescs_max = 100;
-      builtin_type_tdescs_arr = (tree *)xmalloc (100 * sizeof (tree));
-    }
-
-  /* Must lay these out before anything else gets laid out.  */
-  error_mark_node = make_node (ERROR_MARK);
-  TREE_PERMANENT (error_mark_node) = 1;
-  TREE_TYPE (error_mark_node) = error_mark_node;
-  error_mark_list = build_tree_list (error_mark_node, error_mark_node);
-  TREE_TYPE (error_mark_list) = error_mark_node;
-
-  pushlevel (0);	/* make the binding_level structure for global names.  */
-  global_binding_level = current_binding_level;
-
-  this_identifier = get_identifier (THIS_NAME);
-  in_charge_identifier = get_identifier (IN_CHARGE_NAME);
-
-  /* Define `int' and `char' first so that dbx will output them first.  */
-
-  integer_type_node = make_signed_type (INT_TYPE_SIZE);
-  record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
-
-  /* Define `char', which is like either `signed char' or `unsigned char'
-     but not the same as either.  */
-
-  char_type_node =
-    (flag_signed_char
-     ? make_signed_type (CHAR_TYPE_SIZE)
-     : make_unsigned_type (CHAR_TYPE_SIZE));
-  record_builtin_type (RID_CHAR, "char", char_type_node);
-
-  long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
-  record_builtin_type (RID_LONG, "long int", long_integer_type_node);
-
-  unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
-  record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
-
-  long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
-  record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
-  record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
-
-  /* `unsigned long' is the standard type for sizeof.
-     Traditionally, use a signed type.
-     Note that stddef.h uses `unsigned long',
-     and this must agree, even of long and int are the same size.  */
-  if (flag_traditional)
-    sizetype = long_integer_type_node;
-  else
-    sizetype
-      = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
-
-  ptrdiff_type_node
-    = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
-
-  TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
-  TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
-  TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
-  TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
-  TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
-
-  short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
-  record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
-  long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
-  record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
-  short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
-  record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
-  record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
-  long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
-  record_builtin_type (RID_MAX, "long long unsigned int", long_long_unsigned_type_node);
-  record_builtin_type (RID_MAX, "long long unsigned", long_long_unsigned_type_node);
-
-  /* Define both `signed char' and `unsigned char'.  */
-  signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
-  record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
-  unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
-  record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
-
-  /* These are types that type_for_size and type_for_mode use.  */
-  intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
-  intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
-  intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
-  intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
-  unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
-  unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
-  unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
-  unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
-  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
-
-  float_type_node = make_node (REAL_TYPE);
-  TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
-  record_builtin_type (RID_FLOAT, NULL, float_type_node);
-  layout_type (float_type_node);
-
-  double_type_node = make_node (REAL_TYPE);
-  if (flag_short_double)
-    TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
-  else
-    TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
-  record_builtin_type (RID_DOUBLE, NULL, double_type_node);
-  layout_type (double_type_node);
-
-  long_double_type_node = make_node (REAL_TYPE);
-  TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
-  record_builtin_type (RID_MAX, "long double", long_double_type_node);
-  layout_type (long_double_type_node);
-
-  integer_zero_node = build_int_2 (0, 0);
-  TREE_TYPE (integer_zero_node) = integer_type_node;
-  integer_one_node = build_int_2 (1, 0);
-  TREE_TYPE (integer_one_node) = integer_type_node;
-  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;
-  empty_init_node = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
-
-  /* These are needed by stor-layout.c.  */
-  size_zero_node = size_int (0);
-  size_one_node = size_int (1);
-
-  void_type_node = make_node (VOID_TYPE);
-  record_builtin_type (RID_VOID, NULL, void_type_node);
-  layout_type (void_type_node); /* Uses integer_zero_node.  */
-  void_list_node = build_tree_list (NULL_TREE, void_type_node);
-  TREE_PARMLIST (void_list_node) = 1;
-
-  null_pointer_node = build_int_2 (0, 0);
-  TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
-  layout_type (TREE_TYPE (null_pointer_node));
-
-  /* Used for expressions that do nothing, but are not errors.  */
-  void_zero_node = build_int_2 (0, 0);
-  TREE_TYPE (void_zero_node) = void_type_node;
-
-  string_type_node = build_pointer_type (char_type_node);
-  const_string_type_node = build_pointer_type (build_type_variant (char_type_node, 1, 0));
-  record_builtin_type (RID_MAX, NULL, string_type_node);
-
-  /* make a type for arrays of 256 characters.
-     256 is picked randomly because we have a type for integers from 0 to 255.
-     With luck nothing will ever really depend on the length of this
-     array type.  */
-  char_array_type_node
-    = build_array_type (char_type_node, unsigned_char_type_node);
-  /* Likewise for arrays of ints.  */
-  int_array_type_node
-    = build_array_type (integer_type_node, unsigned_char_type_node);
-
-  /* This is just some anonymous class type.  Nobody should ever
-     need to look inside this envelope.  */
-  class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
-
-  default_function_type
-    = build_function_type (integer_type_node, NULL_TREE);
-  build_pointer_type (default_function_type);
-
-  ptr_type_node = build_pointer_type (void_type_node);
-  const_ptr_type_node = build_pointer_type (build_type_variant (void_type_node, 1, 0));
-  record_builtin_type (RID_MAX, NULL, ptr_type_node);
-  endlink = void_list_node;
-  int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
-  double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
-  ptr_endlink = tree_cons (NULL_TREE, ptr_type_node, endlink);
-
-  double_ftype_double
-    = build_function_type (double_type_node, double_endlink);
-
-  double_ftype_double_double
-    = build_function_type (double_type_node,
-			   tree_cons (NULL_TREE, double_type_node, double_endlink));
-
-  int_ftype_int
-    = build_function_type (integer_type_node, int_endlink);
-
-  long_ftype_long
-    = build_function_type (long_integer_type_node,
-			   tree_cons (NULL_TREE, long_integer_type_node, endlink));
-
-  void_ftype_ptr_ptr_int
-    = build_function_type (void_type_node,
-			   tree_cons (NULL_TREE, ptr_type_node,
-				      tree_cons (NULL_TREE, ptr_type_node,
-						 int_endlink)));
-
-  int_ftype_cptr_cptr_sizet
-    = build_function_type (integer_type_node,
-			   tree_cons (NULL_TREE, const_ptr_type_node,
-				      tree_cons (NULL_TREE, const_ptr_type_node,
-						 tree_cons (NULL_TREE,
-							    sizetype,
-							    endlink))));
-
-  void_ftype_ptr_int_int
-    = build_function_type (void_type_node,
-			   tree_cons (NULL_TREE, ptr_type_node,
-				      tree_cons (NULL_TREE, integer_type_node,
-						 int_endlink)));
-
-  string_ftype_ptr_ptr		/* strcpy prototype */
-    = build_function_type (string_type_node,
-			   tree_cons (NULL_TREE, string_type_node,
-				      tree_cons (NULL_TREE,
-						 const_string_type_node,
-						 endlink)));
-
-  int_ftype_string_string	/* strcmp prototype */
-    = build_function_type (integer_type_node,
-			   tree_cons (NULL_TREE, const_string_type_node,
-				      tree_cons (NULL_TREE,
-						 const_string_type_node,
-						 endlink)));
-
-  sizet_ftype_string		/* strlen prototype */
-    = build_function_type (sizetype,
-			   tree_cons (NULL_TREE, const_string_type_node,
-				      endlink));
-
-  traditional_ptr_type_node
-    = (flag_traditional ? string_type_node : ptr_type_node);
-
-  memcpy_ftype	/* memcpy prototype */
-    = build_function_type (traditional_ptr_type_node,
-			   tree_cons (NULL_TREE, ptr_type_node,
-				      tree_cons (NULL_TREE, const_ptr_type_node,
-						 tree_cons (NULL_TREE,
-							    sizetype,
-							    endlink))));
-
-#ifdef VTABLE_USES_MASK
-  /* This is primarily for virtual function definition.  We
-     declare an array of `void *', which can later be
-     converted to the appropriate function pointer type.
-     To do pointers to members, we need a mask which can
-     distinguish an index value into a virtual function table
-     from an address.  */
-  vtbl_mask = build_int_2 (~((HOST_WIDE_INT) VINDEX_MAX - 1), -1);
-#endif
-
-  vtbl_type_node
-    = build_array_type (ptr_type_node, NULL_TREE);
-  layout_type (vtbl_type_node);
-  vtbl_type_node = build_type_variant (vtbl_type_node, 1, 0);
-  record_builtin_type (RID_MAX, NULL, vtbl_type_node);
-
-  builtin_function ("__builtin_constant_p", int_ftype_int,
-		    BUILT_IN_CONSTANT_P, NULL_PTR);
-
-  builtin_function ("__builtin_alloca",
-		    build_function_type (ptr_type_node,
-					 tree_cons (NULL_TREE,
-						    sizetype,
-						    endlink)),
-		    BUILT_IN_ALLOCA, "alloca");
-#if 0
-  builtin_function ("alloca",
-		    build_function_type (ptr_type_node,
-					 tree_cons (NULL_TREE,
-						    sizetype,
-						    endlink)),
-		    BUILT_IN_ALLOCA, NULL_PTR);
-#endif
-
-  builtin_function ("__builtin_abs", int_ftype_int,
-		    BUILT_IN_ABS, NULL_PTR);
-  builtin_function ("__builtin_fabs", double_ftype_double,
-		    BUILT_IN_FABS, NULL_PTR);
-  builtin_function ("__builtin_labs", long_ftype_long,
-		    BUILT_IN_LABS, NULL_PTR);
-  builtin_function ("__builtin_ffs", int_ftype_int,
-		    BUILT_IN_FFS, NULL_PTR);
-  builtin_function ("__builtin_fsqrt", double_ftype_double,
-		    BUILT_IN_FSQRT, NULL_PTR);
-  builtin_function ("__builtin_sin", double_ftype_double, 
-		    BUILT_IN_SIN, "sin");
-  builtin_function ("__builtin_cos", double_ftype_double, 
-		    BUILT_IN_COS, "cos");
-  builtin_function ("__builtin_saveregs",
-		    build_function_type (ptr_type_node, NULL_TREE),
-		    BUILT_IN_SAVEREGS, NULL_PTR);
-/* EXPAND_BUILTIN_VARARGS is obsolete.  */
-#if 0
-  builtin_function ("__builtin_varargs",
-		    build_function_type (ptr_type_node,
-					 tree_cons (NULL_TREE,
-						    integer_type_node,
-						    endlink)),
-		    BUILT_IN_VARARGS, NULL_PTR);
-#endif
-  builtin_function ("__builtin_classify_type", default_function_type,
-		    BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
-  builtin_function ("__builtin_next_arg",
-		    build_function_type (ptr_type_node, endlink),
-		    BUILT_IN_NEXT_ARG, NULL_PTR);
-  builtin_function ("__builtin_args_info",
-		    build_function_type (integer_type_node,
-					 tree_cons (NULL_TREE,
-						    integer_type_node,
-						    endlink)),
-		    BUILT_IN_ARGS_INFO, NULL_PTR);
-
-  /* Currently under experimentation.  */
-  builtin_function ("__builtin_memcpy", memcpy_ftype,
-		    BUILT_IN_MEMCPY, "memcpy");
-  builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
-		    BUILT_IN_MEMCMP, "memcmp");
-  builtin_function ("__builtin_strcmp", int_ftype_string_string,
-		    BUILT_IN_STRCMP, "strcmp");
-  builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
-		    BUILT_IN_STRCPY, "strcpy");
-  builtin_function ("__builtin_strlen", sizet_ftype_string,
-		    BUILT_IN_STRLEN, "strlen");
-
-  if (!flag_no_builtin)
-    {
-#if 0 /* These do not work well with libg++.  */
-      builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
-      builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
-      builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
-#endif
-      builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
-      builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
-			NULL_PTR);
-      builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP, NULL_PTR);
-      builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY, NULL_PTR);
-      builtin_function ("strlen", sizet_ftype_string, BUILT_IN_STRLEN, NULL_PTR);
-      builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
-      builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
-    }
-
-#if 0
-  /* Support for these has not been written in either expand_builtin
-     or build_function_call.  */
-  builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, 0);
-  builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, 0);
-  builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR, 0);
-  builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL, 0);
-  builtin_function ("__builtin_fmod", double_ftype_double_double, BUILT_IN_FMOD, 0);
-  builtin_function ("__builtin_frem", double_ftype_double_double, BUILT_IN_FREM, 0);
-  builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int, BUILT_IN_MEMSET, 0);
-  builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP, 0);
-  builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN, 0);
-#endif
-
-  /* C++ extensions */
-
-  unknown_type_node = make_node (UNKNOWN_TYPE);
-#if 0 /* not yet, should get fixed properly later */
-  pushdecl (make_type_decl (get_identifier ("unknown type"),
-		       unknown_type_node));
-#else
-  decl = pushdecl (build_decl (TYPE_DECL, get_identifier ("unknown type"),
-			unknown_type_node));
-  /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
-  DECL_IGNORED_P (decl) = 1;
-#endif
-  TYPE_SIZE (unknown_type_node) = TYPE_SIZE (void_type_node);
-  TYPE_ALIGN (unknown_type_node) = 1;
-  TYPE_MODE (unknown_type_node) = TYPE_MODE (void_type_node);
-  /* 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;
-
-  /* This is special for C++ so functions can be overloaded. */
-  wchar_type_node
-    = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
-  wchar_type_size = TYPE_PRECISION (wchar_type_node);
-  signed_wchar_type_node = make_signed_type (wchar_type_size);
-  unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
-  wchar_type_node
-    = TREE_UNSIGNED (wchar_type_node)
-      ? unsigned_wchar_type_node
-      : signed_wchar_type_node;
-  record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
-
-  /* This is for wide string constants.  */
-  wchar_array_type_node
-    = build_array_type (wchar_type_node, unsigned_char_type_node);
-
-  /* This is a hack that should go away when we deliver the
-     real gc code.  */
-  if (flag_gc)
-    {
-      builtin_function ("__gc_main", default_function_type, NOT_BUILT_IN, 0);
-      pushdecl (lookup_name (get_identifier ("__gc_main"), 0));
-    }
-
-  /* Simplify life by making a "vtable_entry_type".  Give its
-     fields names so that the debugger can use them.  */
-
-  vtable_entry_type = make_lang_type (RECORD_TYPE);
-  fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier (VTABLE_DELTA_NAME), short_integer_type_node);
-  fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier (VTABLE_INDEX_NAME), short_integer_type_node);
-  fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier (VTABLE_PFN_NAME), ptr_type_node);
-  finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
-		       double_type_node);
-
-  /* Make this part of an invisible union.  */
-  fields[3] = copy_node (fields[2]);
-  TREE_TYPE (fields[3]) = short_integer_type_node;
-  DECL_NAME (fields[3]) = get_identifier (VTABLE_DELTA2_NAME);
-  DECL_MODE (fields[3]) = TYPE_MODE (short_integer_type_node);
-  DECL_SIZE (fields[3]) = TYPE_SIZE (short_integer_type_node);
-  TREE_UNSIGNED (fields[3]) = 0;
-  TREE_CHAIN (fields[2]) = fields[3];
-  vtable_entry_type = build_type_variant (vtable_entry_type, 1, 0);
-  record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
-
-  if (flag_dossier)
-    {
-      /* Must build __t_desc type.  Currently, type descriptors look like this:
-
-	 struct __t_desc
-	 {
-           const char *name;
-	   int size;
-	   int bits;
-	   struct __t_desc *points_to;
-	   int ivars_count, meths_count;
-	   struct __i_desc *ivars[];
-	   struct __m_desc *meths[];
-	   struct __t_desc *parents[];
-	   struct __t_desc *vbases[];
-	   int offsets[];
-	 };
-
-	 ...as per Linton's paper.  */
-
-      __t_desc_type_node = make_lang_type (RECORD_TYPE);
-      __i_desc_type_node = make_lang_type (RECORD_TYPE);
-      __m_desc_type_node = make_lang_type (RECORD_TYPE);
-      __t_desc_array_type = build_array_type (TYPE_POINTER_TO (__t_desc_type_node), NULL_TREE);
-      __i_desc_array_type = build_array_type (TYPE_POINTER_TO (__i_desc_type_node), NULL_TREE);
-      __m_desc_array_type = build_array_type (TYPE_POINTER_TO (__m_desc_type_node), NULL_TREE);
-
-      fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
-					 string_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("size"),
-					 unsigned_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("bits"),
-					 unsigned_type_node);
-      fields[3] = build_lang_field_decl (FIELD_DECL, get_identifier ("points_to"),
-					 TYPE_POINTER_TO (__t_desc_type_node));
-      fields[4] = build_lang_field_decl (FIELD_DECL,
-					 get_identifier ("ivars_count"),
-					 integer_type_node);
-      fields[5] = build_lang_field_decl (FIELD_DECL,
-					 get_identifier ("meths_count"),
-					 integer_type_node);
-      fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("ivars"),
-					 build_pointer_type (__i_desc_array_type));
-      fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("meths"),
-					 build_pointer_type (__m_desc_array_type));
-      fields[8] = build_lang_field_decl (FIELD_DECL, get_identifier ("parents"),
-					 build_pointer_type (__t_desc_array_type));
-      fields[9] = build_lang_field_decl (FIELD_DECL, get_identifier ("vbases"),
-					 build_pointer_type (__t_desc_array_type));
-      fields[10] = build_lang_field_decl (FIELD_DECL, get_identifier ("offsets"),
-					 build_pointer_type (integer_type_node));
-      finish_builtin_type (__t_desc_type_node, "__t_desc", fields, 10, integer_type_node);
-
-      /* ivar descriptors look like this:
-
-	 struct __i_desc
-	 {
-	   const char *name;
-	   int offset;
-	   struct __t_desc *type;
-	 };
-      */
-
-      fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
-					 string_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("offset"),
-					 integer_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("type"),
-					 TYPE_POINTER_TO (__t_desc_type_node));
-      finish_builtin_type (__i_desc_type_node, "__i_desc", fields, 2, integer_type_node);
-
-      /* method descriptors look like this:
-
-	 struct __m_desc
-	 {
-	   const char *name;
-	   int vindex;
-	   struct __t_desc *vcontext;
-	   struct __t_desc *return_type;
-	   void (*address)();
-	   short parm_count;
-	   short required_parms;
-	   struct __t_desc *parm_types[];
-	 };
-      */
-
-      fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
-					 string_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("vindex"),
-					 integer_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("vcontext"),
-					 TYPE_POINTER_TO (__t_desc_type_node));
-      fields[3] = build_lang_field_decl (FIELD_DECL, get_identifier ("return_type"),
-					 TYPE_POINTER_TO (__t_desc_type_node));
-      fields[4] = build_lang_field_decl (FIELD_DECL, get_identifier ("address"),
-					 build_pointer_type (default_function_type));
-      fields[5] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_count"),
-					 short_integer_type_node);
-      fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("required_parms"),
-					 short_integer_type_node);
-      fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_types"),
-					 build_pointer_type (build_array_type (TYPE_POINTER_TO (__t_desc_type_node), NULL_TREE)));
-      finish_builtin_type (__m_desc_type_node, "__m_desc", fields, 7, integer_type_node);
-    }
-
-  /* Now, C++.  */
-  current_lang_name = lang_name_cplusplus;
-  if (flag_dossier)
-    {
-      int i = builtin_type_tdescs_len;
-      while (i > 0)
-	{
-	  tree tdesc = build_t_desc (builtin_type_tdescs_arr[--i], 0);
-	  TREE_ASM_WRITTEN (tdesc) = 1;
-	  TREE_PUBLIC (TREE_OPERAND (tdesc, 0)) = 1;
-	}
-    }
-
-  auto_function (ansi_opname[(int) NEW_EXPR],
-		 build_function_type (ptr_type_node,
-				      tree_cons (NULL_TREE, sizetype,
-						 void_list_node)),
-		 NOT_BUILT_IN);
-  auto_function (ansi_opname[(int) DELETE_EXPR],
-		 build_function_type (void_type_node,
-				      tree_cons (NULL_TREE, ptr_type_node,
-						 void_list_node)),
-		 NOT_BUILT_IN);
-
-  abort_fndecl
-    = define_function ("abort",
-		       build_function_type (void_type_node, void_list_node),
-		       NOT_BUILT_IN, 0, 0);
-
-  unhandled_exception_fndecl
-    = define_function ("__unhandled_exception",
-		       build_function_type (void_type_node, NULL_TREE),
-		       NOT_BUILT_IN, 0, 0);
-
-  /* Perform other language dependent initializations.  */
-  init_class_processing ();
-  init_init_processing ();
-  init_search_processing ();
-
-  if (flag_handle_exceptions)
-    {
-      if (flag_handle_exceptions == 2)
-	/* Too much trouble to inline all the trys needed for this.  */
-	flag_this_is_variable = 2;
-      init_exception_processing ();
-    }
-  if (flag_gc)
-    init_gc_processing ();
-  if (flag_no_inline)
-    flag_inline_functions = 0, flag_default_inline = 0;
-  if (flag_cadillac)
-    init_cadillac ();
-
-  /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
-  declare_function_name ();
-
-  /* Warnings about failure to return values are too valuable to forego.  */
-  warn_return_type = 1;
-}
-
-/* Make a definition for a builtin function named NAME and whose data type
-   is TYPE.  TYPE should be a function type with argument types.
-   FUNCTION_CODE tells later passes how to compile calls to this function.
-   See tree.h for its possible values.
-
-   If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
-   the name to be called if we can't opencode the function.  */
-
-tree
-define_function (name, type, function_code, pfn, library_name)
-     char *name;
-     tree type;
-     enum built_in_function function_code;
-     void (*pfn)();
-     char *library_name;
-{
-  tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
-  DECL_EXTERNAL (decl) = 1;
-  TREE_PUBLIC (decl) = 1;
-
-  /* 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 (pfn) (*pfn) (decl);
-  if (library_name)
-    DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
-  make_function_rtl (decl);
-  if (function_code != NOT_BUILT_IN)
-    {
-      DECL_BUILT_IN (decl) = 1;
-      DECL_SET_FUNCTION_CODE (decl, function_code);
-    }
-  return decl;
-}
-
-/* Called when a declaration is seen that contains no names to declare.
-   If its type is a reference to a structure, union or enum inherited
-   from a containing scope, shadow that tag name for the current scope
-   with a forward reference.
-   If its type defines a new named structure or union
-   or defines an enum, it is valid but we need not do anything here.
-   Otherwise, it is an error.
-
-   C++: may have to grok the declspecs to learn about static,
-   complain for anonymous unions.  */
-
-void
-shadow_tag (declspecs)
-     tree declspecs;
-{
-  int found_tag = 0;
-  int warned = 0;
-  register tree link;
-  register enum tree_code code, ok_code = ERROR_MARK;
-  register tree t = NULL_TREE;
-
-  for (link = declspecs; link; link = TREE_CHAIN (link))
-    {
-      register tree value = TREE_VALUE (link);
-
-      code = TREE_CODE (value);
-      if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE)
-	/* Used to test also that TYPE_SIZE (value) != 0.
-	   That caused warning for `struct foo;' at top level in the file.  */
-	{
-	  register tree name = TYPE_NAME (value);
-
-	  if (name == NULL_TREE)
-	    name = lookup_tag_reverse (value, NULL_TREE);
-
-	  if (name && TREE_CODE (name) == TYPE_DECL)
-	    name = DECL_NAME (name);
-
-	  if (class_binding_level)
-	    t = lookup_tag (code, name, class_binding_level, 1);
-	  else
-	    t = lookup_tag (code, name, current_binding_level, 1);
-
-	  if (t == NULL_TREE)
-	    {
-	      push_obstacks (&permanent_obstack, &permanent_obstack);
-	      if (IS_AGGR_TYPE_CODE (code))
-		t = make_lang_type (code);
-	      else
-		t = make_node (code);
-	      pushtag (name, t);
-	      pop_obstacks ();
-	      ok_code = code;
-	      break;
-	    }
-	  else if (name != NULL_TREE || code == ENUMERAL_TYPE)
-	    ok_code = code;
-
-	  if (ok_code != ERROR_MARK)
-	    found_tag++;
-	  else
-	    {
-	      if (!warned)
-		pedwarn ("useless keyword or type name in declaration");
-	      warned = 1;
-	    }
-	}
-    }
-
-  /* This is where the variables in an anonymous union are
-     declared.  An anonymous union declaration looks like:
-     union { ... } ;
-     because there is no declarator after the union, the parser
-     sends that declaration here.  */
-  if (ok_code == UNION_TYPE
-      && t != NULL_TREE
-      && ((TREE_CODE (TYPE_NAME (t)) == IDENTIFIER_NODE
-	   && ANON_AGGRNAME_P (TYPE_NAME (t)))
-	  || (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
-	      && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))))
-    {
-      /* ANSI C++ June 5 1992 WP 9.5.3.  Anonymous unions may not have
-	 function members.  */
-      if (TYPE_FIELDS (t))
-	{
-	  tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0, NULL_TREE);
-	  finish_anon_union (decl);
-	}
-      else
-	error ("anonymous union cannot have a function member");
-    }
-  else if (ok_code == RECORD_TYPE
-	   && found_tag == 1
-	   && TYPE_LANG_SPECIFIC (t)
-	   && CLASSTYPE_DECLARED_EXCEPTION (t))
-    {
-      if (TYPE_SIZE (t))
-	error_with_aggr_type (t, "redeclaration of exception `%s'");
-      else
-	{
-	  tree ename, decl;
-
-	  push_obstacks (&permanent_obstack, &permanent_obstack);
-
-	  pushclass (t, 0);
-	  finish_exception (t, NULL_TREE);
-
-	  ename = TYPE_NAME (t);
-	  if (TREE_CODE (ename) == TYPE_DECL)
-	    ename = DECL_NAME (ename);
-	  decl = build_lang_field_decl (VAR_DECL, ename, t);
-	  finish_exception_decl (current_class_name, decl);
-	  end_exception_decls ();
-
-	  pop_obstacks ();
-	}
-    }
-  else if (!warned && found_tag > 1)
-    warning ("multiple types in one declaration");
-}
-
-/* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
-
-tree
-groktypename (typename)
-     tree typename;
-{
-  if (TREE_CODE (typename) != TREE_LIST)
-    return typename;
-  return grokdeclarator (TREE_VALUE (typename),
-			 TREE_PURPOSE (typename),
-			 TYPENAME, 0, NULL_TREE);
-}
-
-/* Decode a declarator in an ordinary declaration or data definition.
-   This is called as soon as the type information and variable name
-   have been parsed, before parsing the initializer if any.
-   Here we create the ..._DECL node, fill in its type,
-   and put it on the list of decls for the current context.
-   The ..._DECL node is returned as the value.
-
-   Exception: for arrays where the length is not specified,
-   the type is left null, to be filled in by `finish_decl'.
-
-   Function definitions do not come here; they go to start_function
-   instead.  However, external and forward declarations of functions
-   do go through here.  Structure field declarations are done by
-   grokfield and not through here.  */
-
-/* Set this to zero to debug not using the temporary obstack
-   to parse initializers.  */
-int debug_temp_inits = 1;
-
-tree
-start_decl (declarator, declspecs, initialized, raises)
-     tree declspecs, declarator;
-     int initialized;
-     tree raises;
-{
-  register tree decl;
-  register tree type, tem;
-  tree context;
-  extern int have_extern_spec;
-  extern int used_extern_spec;
-
-  int init_written = initialized;
-
-  /* This should only be done once on the top most decl. */
-  if (have_extern_spec && !used_extern_spec)
-    {
-      declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
-      used_extern_spec = 1;
-    }
-
-  decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, raises);
-  if (decl == NULL_TREE || decl == void_type_node)
-    return NULL_TREE;
-
-  type = TREE_TYPE (decl);
-
-  /* Don't lose if destructors must be executed at file-level.  */
-  if (TREE_STATIC (decl)
-      && TYPE_NEEDS_DESTRUCTOR (type)
-      && !TREE_PERMANENT (decl))
-    {
-      push_obstacks (&permanent_obstack, &permanent_obstack);
-      decl = copy_node (decl);
-      if (TREE_CODE (type) == ARRAY_TYPE)
-	{
-	  tree itype = TYPE_DOMAIN (type);
-	  if (itype && ! TREE_PERMANENT (itype))
-	    {
-	      itype = build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype)));
-	      type = build_cplus_array_type (TREE_TYPE (type), itype);
-	      TREE_TYPE (decl) = type;
-	    }
-	}
-      pop_obstacks ();
-    }
-
-  /* Interesting work for this is done in `finish_exception_decl'.  */
-  if (TREE_CODE (type) == RECORD_TYPE
-      && CLASSTYPE_DECLARED_EXCEPTION (type))
-    return decl;
-
-  /* Corresponding pop_obstacks is done in `finish_decl'.  */
-  push_obstacks_nochange ();
-
-  context
-    = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
-      ? DECL_CLASS_CONTEXT (decl)
-      : DECL_CONTEXT (decl);
-
-  if (processing_template_decl)
-    {
-      tree d;
-      if (TREE_CODE (decl) == FUNCTION_DECL)
-        {
-          /* Declarator is a call_expr; extract arguments from it, since
-             grokdeclarator didn't do it.  */
-          tree args;
-          args = copy_to_permanent (last_function_parms);
-          if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
-            {
-	      tree t = TREE_TYPE (decl);
-              tree decl;
-	      
-              t = TYPE_METHOD_BASETYPE (t); /* type method belongs to */
-	      if (TREE_CODE (t) != UNINSTANTIATED_P_TYPE)
-		{
-		  t = build_pointer_type (t); /* base type of `this' */
-#if 1
-		  /* I suspect this is wrong. */
-		  t = build_type_variant (t, flag_this_is_variable <= 0,
-					  0); /* type of `this' */
-#else
-		  t = build_type_variant (t, 0, 0); /* type of `this' */
-#endif
-		  t = build (PARM_DECL, t, this_identifier);
-		  TREE_CHAIN (t) = args;
-		  args = t;
-		}
-	    }
-          DECL_ARGUMENTS (decl) = args;
-        }
-      d = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), TREE_TYPE (decl));
-      TREE_PUBLIC (d) = TREE_PUBLIC (decl) = 0;
-      TREE_STATIC (d) = TREE_STATIC (decl);
-      DECL_EXTERNAL (d) = (DECL_EXTERNAL (decl)
-			   && !(context && !DECL_THIS_EXTERN (decl)));
-      DECL_TEMPLATE_RESULT (d) = decl;
-      DECL_OVERLOADED (d) = 1;
-      decl = d;
-    }
-
-  if (context && TYPE_SIZE (context) != NULL_TREE)
-    {
-      /* If it was not explicitly declared `extern',
-	 revoke any previous claims of DECL_EXTERNAL.  */
-      if (DECL_THIS_EXTERN (decl) == 0)
-	DECL_EXTERNAL (decl) = 0;
-      if (DECL_LANG_SPECIFIC (decl))
-	DECL_IN_AGGR_P (decl) = 0;
-      pushclass (context, 2);
-    }
-
-  /* If this type of object needs a cleanup, and control may
-     jump past it, make a new binding level so that it is cleaned
-     up only when it is initialized first.  */
-  if (TYPE_NEEDS_DESTRUCTOR (type)
-      && current_binding_level->more_cleanups_ok == 0)
-    pushlevel_temporary (1);
-
-  if (initialized)
-    /* Is it valid for this decl to have an initializer at all?
-       If not, set INITIALIZED to zero, which will indirectly
-       tell `finish_decl' to ignore the initializer once it is parsed.  */
-    switch (TREE_CODE (decl))
-      {
-      case TYPE_DECL:
-	/* typedef foo = bar  means give foo the same type as bar.
-	   We haven't parsed bar yet, so `finish_decl' will fix that up.
-	   Any other case of an initialization in a TYPE_DECL is an error.  */
-	if (pedantic || list_length (declspecs) > 1)
-	  {
-	    error ("typedef `%s' is initialized",
-		   IDENTIFIER_POINTER (DECL_NAME (decl)));
-	    initialized = 0;
-	  }
-	break;
-
-      case FUNCTION_DECL:
-	error ("function `%s' is initialized like a variable",
-	       IDENTIFIER_POINTER (DECL_NAME (decl)));
-	initialized = 0;
-	break;
-
-      default:
-	/* Don't allow initializations for incomplete types
-	   except for arrays which might be completed by the initialization.  */
-	if (TYPE_SIZE (type) != NULL_TREE)
-	  ;                     /* A complete type is ok.  */
-	else if (TREE_CODE (type) != ARRAY_TYPE)
-	  {
-	    error ("variable `%s' has initializer but incomplete type",
-		   IDENTIFIER_POINTER (DECL_NAME (decl)));
-	    initialized = 0;
-	  }
-	else if (TYPE_SIZE (TREE_TYPE (type)) == NULL_TREE)
-	  {
-	    error ("elements of array `%s' have incomplete type",
-		   IDENTIFIER_POINTER (DECL_NAME (decl)));
-	    initialized = 0;
-	  }
-      }
-
-  if (!initialized
-      && TREE_CODE (decl) != TYPE_DECL
-      && TREE_CODE (decl) != TEMPLATE_DECL
-      && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
-    {
-      if (TYPE_SIZE (type) == NULL_TREE)
-	{
-	  error ("aggregate `%s' has incomplete type and cannot be initialized",
-		 IDENTIFIER_POINTER (DECL_NAME (decl)));
-	  /* Change the type so that assemble_variable will give
-	     DECL an rtl we can live with: (mem (const_int 0)).  */
-	  TREE_TYPE (decl) = error_mark_node;
-	  type = error_mark_node;
-	}
-      else
-	{
-	  /* If any base type in the hierarchy of TYPE needs a constructor,
-	     then we set initialized to 1.  This way any nodes which are
-	     created for the purposes of initializing this aggregate
-	     will live as long as it does.  This is necessary for global
-	     aggregates which do not have their initializers processed until
-	     the end of the file.  */
-	  initialized = TYPE_NEEDS_CONSTRUCTING (type);
-	}
-    }
-
-  if (initialized)
-    {
-      if (current_binding_level != global_binding_level
-	  && DECL_EXTERNAL (decl))
-	warning ("declaration of `%s' has `extern' and is initialized",
-		 IDENTIFIER_POINTER (DECL_NAME (decl)));
-      DECL_EXTERNAL (decl) = 0;
-      if (current_binding_level == global_binding_level)
-	TREE_STATIC (decl) = 1;
-
-      /* Tell `pushdecl' this is an initialized decl
-	 even though we don't yet have the initializer expression.
-	 Also tell `finish_decl' it may store the real initializer.  */
-      DECL_INITIAL (decl) = error_mark_node;
-    }
-
-  /* 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 ((TREE_CODE (decl) != PARM_DECL && DECL_CONTEXT (decl) != NULL_TREE)
-      || (TREE_CODE (decl) == TEMPLATE_DECL && !global_bindings_p ())
-      || TREE_CODE (type) == LANG_TYPE)
-    tem = decl;
-  else
-    {
-      tem = pushdecl (decl);
-      if (TREE_CODE (tem) == TREE_LIST)
-	{
-	  tree tem2 = value_member (decl, tem);
-	  if (tem2 != NULL_TREE)
-	    tem = TREE_VALUE (tem2);
-	  else
-	    {
-	      while (tem && ! decls_match (decl, TREE_VALUE (tem)))
-		tem = TREE_CHAIN (tem);
-	      if (tem == NULL_TREE)
-		tem = decl;
-	      else
-		tem = TREE_VALUE (tem);
-	    }
-	}
-    }
-
-#if 0
-  /* We don't do this yet for GNU C++.  */
-  /* For a local variable, define the RTL now.  */
-  if (current_binding_level != global_binding_level
-      /* But not if this is a duplicate decl
-	 and we preserved the rtl from the previous one
-	 (which may or may not happen).  */
-      && DECL_RTL (tem) == NULL_RTX)
-    {
-      if (TYPE_SIZE (TREE_TYPE (tem)) != NULL_TREE)
-	expand_decl (tem);
-      else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
-	       && DECL_INITIAL (tem) != NULL_TREE)
-	expand_decl (tem);
-    }
-#endif
-
-  if (TREE_CODE (decl) == FUNCTION_DECL && DECL_OVERLOADED (decl))
-    /* @@ Also done in start_function.  */
-    tem = push_overloaded_decl (tem, 1);
-  else if (TREE_CODE (decl) == TEMPLATE_DECL)
-    {
-      tree result = DECL_TEMPLATE_RESULT (decl);
-      if (DECL_CONTEXT (result) != NULL_TREE)
-	{
-          tree type;
-          type = DECL_CONTEXT (result);
-          my_friendly_assert (TREE_CODE (type) == UNINSTANTIATED_P_TYPE, 145);
-          if (/* TREE_CODE (result) == VAR_DECL */ 1)
-            {
-#if 0
-              tree tmpl = UPT_TEMPLATE (type);
-	      
-	      fprintf (stderr, "%s:%d: adding ", __FILE__, __LINE__);
-	      print_node_brief (stderr, "", DECL_NAME (tem), 0);
-	      fprintf (stderr, " to class %s\n",
-		       IDENTIFIER_POINTER (DECL_NAME (tmpl)));
-              DECL_TEMPLATE_MEMBERS (tmpl)
-                = perm_tree_cons (DECL_NAME (tem), tem,
-				  DECL_TEMPLATE_MEMBERS (tmpl));
-#endif
-	      return tem;
-	    }
-          my_friendly_abort (13);
-        }
-      else if (TREE_CODE (result) == FUNCTION_DECL)
-        tem = push_overloaded_decl (tem, 0);
-      else if (TREE_CODE (result) == VAR_DECL
-	       || TREE_CODE (result) == TYPE_DECL)
-	{
-	  error ("invalid template `%s'",
-		 IDENTIFIER_POINTER (DECL_NAME (result)));
-	  return NULL_TREE;
-	}
-      else
-	my_friendly_abort (14);
-    }
-
-  if (init_written
-      && ! (TREE_CODE (tem) == PARM_DECL
-	    || (TREE_READONLY (tem)
-		&& (TREE_CODE (tem) == VAR_DECL
-		    || TREE_CODE (tem) == FIELD_DECL))))
-    {
-      /* When parsing and digesting the initializer,
-	 use temporary storage.  Do this even if we will ignore the value.  */
-      if (current_binding_level == global_binding_level && debug_temp_inits)
-	{
-	  if (TYPE_NEEDS_CONSTRUCTING (type) || TREE_CODE (type) == REFERENCE_TYPE)
-	    /* In this case, the initializer must lay down in permanent
-	       storage, since it will be saved until `finish_file' is run.   */
-	    ;
-	  else
-	    temporary_allocation ();
-	}
-    }
-
-  if (flag_cadillac)
-    cadillac_start_decl (tem);
-
-  return tem;
-}
-
-static void
-make_temporary_for_reference (decl, ctor_call, init, cleanupp)
-     tree decl, ctor_call, init;
-     tree *cleanupp;
-{
-  tree type = TREE_TYPE (decl);
-  tree target_type = TREE_TYPE (type);
-  tree tmp, tmp_addr;
-
-  if (ctor_call)
-    {
-      tmp_addr = TREE_VALUE (TREE_OPERAND (ctor_call, 1));
-      if (TREE_CODE (tmp_addr) == NOP_EXPR)
-	tmp_addr = TREE_OPERAND (tmp_addr, 0);
-      my_friendly_assert (TREE_CODE (tmp_addr) == ADDR_EXPR, 146);
-      tmp = TREE_OPERAND (tmp_addr, 0);
-    }
-  else
-    {
-      tmp = get_temp_name (target_type,
-			   current_binding_level == global_binding_level);
-      tmp_addr = build_unary_op (ADDR_EXPR, tmp, 0);
-    }
-
-  TREE_TYPE (tmp_addr) = build_pointer_type (target_type);
-  DECL_INITIAL (decl) = convert (TYPE_POINTER_TO (target_type), tmp_addr);
-  TREE_TYPE (DECL_INITIAL (decl)) = type;
-  if (TYPE_NEEDS_CONSTRUCTING (target_type))
-    {
-      if (current_binding_level == global_binding_level)
-	{
-	  /* lay this variable out now.  Otherwise `output_addressed_constants'
-	     gets confused by its initializer.  */
-	  make_decl_rtl (tmp, NULL_PTR, 1);
-	  static_aggregates = perm_tree_cons (init, tmp, static_aggregates);
-	}
-      else
-	{
-	  if (ctor_call != NULL_TREE)
-	    init = ctor_call;
-	  else
-	    init = build_method_call (tmp, constructor_name (target_type),
-				      build_tree_list (NULL_TREE, init),
-				      NULL_TREE, LOOKUP_NORMAL);
-	  DECL_INITIAL (decl) = build (COMPOUND_EXPR, type, init,
-				       DECL_INITIAL (decl));
-	  *cleanupp = maybe_build_cleanup (tmp);
-	}
-    }
-  else
-    {
-      DECL_INITIAL (tmp) = init;
-      TREE_STATIC (tmp) = current_binding_level == global_binding_level;
-      finish_decl (tmp, init, 0, 0);
-    }
-  if (TREE_STATIC (tmp))
-    preserve_initializer ();
-}
-
-/* Handle initialization of references.
-   These three arguments from from `finish_decl', and have the
-   same meaning here that they do there.  */
-/* quotes on semantics can be found in ARM 8.4.3. */
-static void
-grok_reference_init (decl, type, init, cleanupp)
-     tree decl, type, init;
-     tree *cleanupp;
-{
-  char *errstr = NULL;
-  int is_reference;
-  tree tmp;
-  tree this_ptr_type, actual_init;
-
-  if (init == NULL_TREE)
-    {
-      if (DECL_LANG_SPECIFIC (decl) == 0
-	  || DECL_IN_AGGR_P (decl) == 0)
-	{
-	  error ("variable declared as reference not initialized");
-	  if (TREE_CODE (decl) == VAR_DECL)
-	    SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
-	}
-      return;
-    }
-
-  if (TREE_CODE (init) == TREE_LIST)
-    init = build_compound_expr (init);
-  is_reference = TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE;
-  tmp = is_reference ? convert_from_reference (init) : init;
-
-  if (is_reference)
-    {
-      if (! comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
-		       TYPE_MAIN_VARIANT (TREE_TYPE (tmp)), 0))
-	errstr = "initialization of `%s' from dissimilar reference type";
-      else if (TYPE_READONLY (TREE_TYPE (type))
-	       >= TYPE_READONLY (TREE_TYPE (TREE_TYPE (init))))
-	{
-	  is_reference = 0;
-	  init = tmp;
-	}
-    }
-  else
-    {
-      if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
-	  && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
-	{
-	  /* Note: default conversion is only called in very
-	     special cases.  */
-	  init = default_conversion (init);
-	}
-      if (TREE_CODE (TREE_TYPE (type)) == TREE_CODE (TREE_TYPE (init)))
-	{
-	  if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
-			 TYPE_MAIN_VARIANT (TREE_TYPE (init)), 0))
-	    {
-	      /* This section implements ANSI C++ June 5 1992 WP 8.4.3.5. */
-
-	      /* A reference to a volatile T cannot be initialized with
-		 a const T, and vice-versa.  */
-	      if (TYPE_VOLATILE (TREE_TYPE (type)) && TREE_READONLY (init))
-		errstr = "cannot initialize a reference to a volatile T with a const T";
-	      else if (TYPE_READONLY (TREE_TYPE (type)) && TREE_THIS_VOLATILE (init))
-		errstr = "cannot initialize a reference to a const T with a volatile T";
-	      /* A reference to a plain T can be initialized only with
-		 a plain T.  */
-	      else if (!TYPE_VOLATILE (TREE_TYPE (type))
-		       && !TYPE_READONLY (TREE_TYPE (type)))
-		{
-		  if (TREE_READONLY (init))
-		    errstr = "cannot initialize a reference to T with a const T";
-		  else if (TREE_THIS_VOLATILE (init))
-		    errstr = "cannot initialize a reference to T with a volatile T";
-		}
-	    }
-	  else
-	    init = convert (TREE_TYPE (type), init);
-	}
-      else if (init != error_mark_node
-	       && ! comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
-			       TYPE_MAIN_VARIANT (TREE_TYPE (init)), 0))
-	errstr = "invalid type conversion for reference";
-    }
-
-  if (errstr)
-    {
-      /* Things did not go smoothly; look for operator& type conversion.  */
-      if (IS_AGGR_TYPE (TREE_TYPE (tmp)))
-	{
-	  tmp = build_type_conversion (CONVERT_EXPR, type, init, 0);
-	  if (tmp != NULL_TREE)
-	    {
-	      init = tmp;
-	      if (tmp == error_mark_node)
-		errstr = "ambiguous pointer conversion";
-	      else
-		errstr = NULL;
-	      is_reference = 1;
-	    }
-	  else
-	    {
-	      tmp = build_type_conversion (CONVERT_EXPR, TREE_TYPE (type), init, 0);
-	      if (tmp != NULL_TREE)
-		{
-		  init = tmp;
-		  if (tmp == error_mark_node)
-		    errstr = "ambiguous pointer conversion";
-		  else
-		    errstr = NULL;
-		  is_reference = 0;
-		}
-	    }
-	}
-      /* Look for constructor.  */
-      else if (IS_AGGR_TYPE (TREE_TYPE (type))
-	       && TYPE_HAS_CONSTRUCTOR (TREE_TYPE (type)))
-	{
-	  tmp = get_temp_name (TREE_TYPE (type),
-			       current_binding_level == global_binding_level);
-	  tmp = build_method_call (tmp, constructor_name (TREE_TYPE (type)),
-				   build_tree_list (NULL_TREE, init),
-				   NULL_TREE, LOOKUP_NORMAL);
-	  if (tmp == NULL_TREE || tmp == error_mark_node)
-	    {
-	      if (TREE_CODE (decl) == VAR_DECL)
-		SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
-	      error_with_decl (decl, "constructor failed to build reference initializer");
-	      return;
-	    }
-	  make_temporary_for_reference (decl, tmp, init, cleanupp);
-	  goto done;
-	}
-    }
-
-  if (errstr)
-    {
-      error_with_decl (decl, errstr);
-      if (TREE_CODE (decl) == VAR_DECL)
-	SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
-      return;
-    }
-
-  /* In the case of initialization, it is permissible
-     to assign one reference to another.  */
-  this_ptr_type = build_pointer_type (TREE_TYPE (type));
-
-  if (is_reference)
-    {
-      if (TREE_SIDE_EFFECTS (init))
-	DECL_INITIAL (decl) = save_expr (init);
-      else
-	DECL_INITIAL (decl) = init;
-    }
-  else if (lvalue_p (init))
-    {
-      tmp = build_unary_op (ADDR_EXPR, init, 0);
-      if (TREE_CODE (tmp) == ADDR_EXPR
-	  && TREE_CODE (TREE_OPERAND (tmp, 0)) == WITH_CLEANUP_EXPR)
-	{
-	  /* Associate the cleanup with the reference so that we
-	     don't get burned by "aggressive" cleanup policy.  */
-	  *cleanupp = TREE_OPERAND (TREE_OPERAND (tmp, 0), 2);
-	  TREE_OPERAND (TREE_OPERAND (tmp, 0), 2) = error_mark_node;
-	}
-      if (IS_AGGR_TYPE (TREE_TYPE (this_ptr_type)))
-	DECL_INITIAL (decl) = convert_pointer_to (TREE_TYPE (this_ptr_type), tmp);
-      else
-	DECL_INITIAL (decl) = convert (this_ptr_type, tmp);
-
-      DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
-      if (DECL_INITIAL (decl) == current_class_decl)
-	DECL_INITIAL (decl) = copy_node (current_class_decl);
-      TREE_TYPE (DECL_INITIAL (decl)) = type;
-    }
-  else if ((actual_init = unary_complex_lvalue (ADDR_EXPR, init)))
-    {
-      /* The initializer for this decl goes into its
-	 DECL_REFERENCE_SLOT.  Make sure that we can handle
-	 multiple evaluations without ill effect.  */
-      if (TREE_CODE (actual_init) == ADDR_EXPR
-	  && TREE_CODE (TREE_OPERAND (actual_init, 0)) == TARGET_EXPR)
-	actual_init = save_expr (actual_init);
-      DECL_INITIAL (decl) = convert_pointer_to (TREE_TYPE (this_ptr_type), actual_init);
-      DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
-      TREE_TYPE (DECL_INITIAL (decl)) = type;
-    }
-  else if (TYPE_READONLY (TREE_TYPE (type)))
-    /* Section 8.4.3 allows us to make a temporary for
-       the initialization of const&.  */
-    make_temporary_for_reference (decl, NULL_TREE, init, cleanupp);
-  else
-    {
-      error_with_decl (decl, "type mismatch in initialization of `%s' (use `const')");
-      DECL_INITIAL (decl) = error_mark_node;
-    }
-
- done:
-  /* ?? Can this be optimized in some cases to
-     hand back the DECL_INITIAL slot??  */
-  if (TYPE_SIZE (TREE_TYPE (type)))
-    {
-      init = convert_from_reference (decl);
-      if (TREE_PERMANENT (decl))
-	init = copy_to_permanent (init);
-      SET_DECL_REFERENCE_SLOT (decl, init);
-    }
-
-  if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
-    {
-      expand_static_init (decl, DECL_INITIAL (decl));
-      DECL_INITIAL (decl) = NULL_TREE;
-    }
-}
-
-/* Finish processing of a declaration;
-   install its line number and initial value.
-   If the length of an array type is not known before,
-   it must be determined now, from the initial value, or it is an error.
-
-   Call `pop_obstacks' iff NEED_POP is nonzero.
-
-   For C++, `finish_decl' must be fairly evasive:  it must keep initializers
-   for aggregates that have constructors alive on the permanent obstack,
-   so that the global initializing functions can be written at the end.
-
-   INIT0 holds the value of an initializer that should be allowed to escape
-   the normal rules.
-
-   For functions that take default parameters, DECL points to its
-   "maximal" instantiation.  `finish_decl' must then also declared its
-   subsequently lower and lower forms of instantiation, checking for
-   ambiguity as it goes.  This can be sped up later.  */
-
-void
-finish_decl (decl, init, asmspec_tree, need_pop)
-     tree decl, init;
-     tree asmspec_tree;
-     int need_pop;
-{
-  register tree type;
-  tree cleanup = NULL_TREE, ttype;
-  int was_incomplete;
-  int temporary = allocation_temporary_p ();
-  char *asmspec = NULL;
-  int was_readonly = 0;
-
-  /* If this is 0, then we did not change obstacks.  */
-  if (! decl)
-    {
-      if (init)
-	error ("assignment (not initialization) in declaration");
-      return;
-    }
-
-  if (asmspec_tree)
-    {
-      asmspec = TREE_STRING_POINTER (asmspec_tree);
-      /* Zero out old RTL, since we will rewrite it.  */
-      DECL_RTL (decl) = NULL_RTX;
-    }
-
-  /* If the type of the thing we are declaring either has
-     a constructor, or has a virtual function table pointer,
-     AND its initialization was accepted by `start_decl',
-     then we stayed on the permanent obstack through the
-     declaration, otherwise, changed obstacks as GCC would.  */
-
-  type = TREE_TYPE (decl);
-
-  was_incomplete = (DECL_SIZE (decl) == NULL_TREE);
-
-  /* Take care of TYPE_DECLs up front.  */
-  if (TREE_CODE (decl) == TYPE_DECL)
-    {
-      if (init && DECL_INITIAL (decl))
-	{
-	  /* typedef foo = bar; store the type of bar as the type of foo.  */
-	  TREE_TYPE (decl) = type = TREE_TYPE (init);
-	  DECL_INITIAL (decl) = init = NULL_TREE;
-	}
-      if (IS_AGGR_TYPE (type) && DECL_NAME (decl))
-	{
-	  if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
-	    warning ("shadowing previous type declaration of `%s'",
-		     IDENTIFIER_POINTER (DECL_NAME (decl)));
-	  set_identifier_type_value (DECL_NAME (decl), type);
-	  CLASSTYPE_GOT_SEMICOLON (type) = 1;
-	}
-      GNU_xref_decl (current_function_decl, decl);
-      rest_of_decl_compilation (decl, NULL_PTR,
-				DECL_CONTEXT (decl) == NULL_TREE, 0);
-      goto finish_end;
-    }
-  if (type != error_mark_node && IS_AGGR_TYPE (type)
-      && CLASSTYPE_DECLARED_EXCEPTION (type))
-    {
-      finish_exception_decl (NULL_TREE, decl);
-      CLASSTYPE_GOT_SEMICOLON (type) = 1;
-      goto finish_end;
-    }
-  if (TREE_CODE (decl) != FUNCTION_DECL)
-    {
-      ttype = target_type (type);
-#if 0 /* WTF?  -KR
-	 Leave this out until we can figure out why it was
-	 needed/desirable in the first place.  Then put a comment
-	 here explaining why.  Or just delete the code if no ill
-	 effects arise.  */
-      if (TYPE_NAME (ttype)
-	  && TREE_CODE (TYPE_NAME (ttype)) == TYPE_DECL
-	  && ANON_AGGRNAME_P (TYPE_IDENTIFIER (ttype)))
-	{
-	  tree old_id = TYPE_IDENTIFIER (ttype);
-	  char *newname = (char *)alloca (IDENTIFIER_LENGTH (old_id) + 2);
-	  /* Need to preserve template data for UPT nodes.  */
-	  tree old_template = IDENTIFIER_TEMPLATE (old_id);
-	  newname[0] = '_';
-	  bcopy (IDENTIFIER_POINTER (old_id), newname + 1,
-		 IDENTIFIER_LENGTH (old_id) + 1);
-	  old_id = get_identifier (newname);
-	  lookup_tag_reverse (ttype, old_id);
-	  TYPE_IDENTIFIER (ttype) = old_id;
-	  IDENTIFIER_TEMPLATE (old_id) = old_template;
-	}
-#endif
-    }
-
-  if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
-      && TYPE_NEEDS_CONSTRUCTING (type))
-    {
-
-      /* Currently, GNU C++ puts constants in text space, making them
-	 impossible to initialize.  In the future, one would hope for
-	 an operating system which understood the difference between
-	 initialization and the running of a program.  */
-      was_readonly = 1;
-      TREE_READONLY (decl) = 0;
-    }
-
-  if (TREE_CODE (decl) == FIELD_DECL)
-    {
-      if (init && init != error_mark_node)
-	my_friendly_assert (TREE_PERMANENT (init), 147);
-
-      if (asmspec)
-	{
-	  /* This must override the asm specifier which was placed
-	     by grokclassfn.  Lay this out fresh.
-	     
-	     @@ Should emit an error if this redefines an asm-specified
-	     @@ name, or if we have already used the function's name.  */
-	  DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
-	  DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
-	  make_decl_rtl (decl, asmspec, 0);
-	}
-    }
-  /* If `start_decl' didn't like having an initialization, ignore it now.  */
-  else if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
-    init = NULL_TREE;
-  else if (DECL_EXTERNAL (decl))
-    ;
-  else if (TREE_CODE (type) == REFERENCE_TYPE)
-    {
-      grok_reference_init (decl, type, init, &cleanup);
-      init = NULL_TREE;
-    }
-
-  GNU_xref_decl (current_function_decl, decl);
-
-  if (TREE_CODE (decl) == FIELD_DECL || DECL_EXTERNAL (decl))
-    ;
-  else if (TREE_CODE (decl) == CONST_DECL)
-    {
-      my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
-
-      DECL_INITIAL (decl) = init;
-
-      /* This will keep us from needing to worry about our obstacks.  */
-      my_friendly_assert (init != NULL_TREE, 149);
-      init = NULL_TREE;
-    }
-  else if (init)
-    {
-      if (TYPE_NEEDS_CONSTRUCTING (type))
-	{
-	  if (TREE_CODE (type) == ARRAY_TYPE)
-	    init = digest_init (type, init, (tree *) 0);
-	  else if (TREE_CODE (init) == CONSTRUCTOR
-		   && CONSTRUCTOR_ELTS (init) != NULL_TREE)
-	    {
-	      error_with_decl (decl, "`%s' must be initialized by constructor, not by `{...}'");
-	      init = error_mark_node;
-	    }
-#if 0
-	  /* fix this in `build_functional_cast' instead.
-	     Here's the trigger code:
-
-		struct ostream
-		{
-		  ostream ();
-		  ostream (int, char *);
-		  ostream (char *);
-		  operator char *();
-		  ostream (void *);
-		  operator void *();
-		  operator << (int);
-		};
-		int buf_size = 1024;
-		static char buf[buf_size];
-		const char *debug(int i) {
-		  char *b = &buf[0];
-		  ostream o = ostream(buf_size, b);
-		  o << i;
-		  return buf;
-		}
-		*/
-
-	  else if (TREE_CODE (init) == TARGET_EXPR
-		   && TREE_CODE (TREE_OPERAND (init, 1) == NEW_EXPR))
-	    {
-	      /* User wrote something like `foo x = foo (args)'  */
-	      my_friendly_assert (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL, 150);
-	      my_friendly_assert (DECL_NAME (TREE_OPERAND (init, 0)) == NULL_TREE, 151);
-
-	      /* User wrote exactly `foo x = foo (args)'  */
-	      if (TYPE_MAIN_VARIANT (type) == TREE_TYPE (init))
-		{
-		  init = build (CALL_EXPR, TREE_TYPE (init),
-				TREE_OPERAND (TREE_OPERAND (init, 1), 0),
-				TREE_OPERAND (TREE_OPERAND (init, 1), 1), 0);
-		  TREE_SIDE_EFFECTS (init) = 1;
-		}
-	    }
-#endif
-
-	  /* We must hide the initializer so that expand_decl
-	     won't try to do something it does not understand.  */
-	  if (current_binding_level == global_binding_level)
-	    {
-	      tree value = digest_init (type, empty_init_node, (tree *) 0);
-	      DECL_INITIAL (decl) = value;
-	    }
-	  else
-	    DECL_INITIAL (decl) = error_mark_node;
-	}
-      else
-	{
-	  if (TREE_CODE (init) != TREE_VEC)
-	    init = store_init_value (decl, init);
-
-	  if (init)
-	    /* Don't let anyone try to initialize this variable
-	       until we are ready to do so.  */
-	    DECL_INITIAL (decl) = error_mark_node;
-	}
-    }
-  else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
-	   && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
-    {
-      tree ctype = type;
-      while (TREE_CODE (ctype) == ARRAY_TYPE)
-	ctype = TREE_TYPE (ctype);
-      if (! TYPE_NEEDS_CONSTRUCTOR (ctype))
-	{
-	  if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
-	    error_with_decl (decl, "structure `%s' with uninitialized const members");
-	  if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
-	    error_with_decl (decl, "structure `%s' with uninitialized reference members");
-	}
-
-      if (TREE_CODE (decl) == VAR_DECL
-	  && !TYPE_NEEDS_CONSTRUCTING (type)
-	  && (TYPE_READONLY (type) || TREE_READONLY (decl)))
-	error_with_decl (decl, "uninitialized const `%s'");
-
-      /* Initialize variables in need of static initialization
-	 with `empty_init_node' to keep assemble_variable from putting them
-	 in the wrong program space.  (Common storage is okay for non-public
-	 uninitialized data; the linker can't match it with storage from other
-	 files, and we may save some disk space.)  */
-      if (flag_pic == 0
-	  && TREE_STATIC (decl)
-	  && TREE_PUBLIC (decl)
-	  && ! DECL_EXTERNAL (decl)
-	  && TREE_CODE (decl) == VAR_DECL
-	  && TYPE_NEEDS_CONSTRUCTING (type)
-	  && (DECL_INITIAL (decl) == NULL_TREE
-	      || DECL_INITIAL (decl) == error_mark_node))
-	{
-	  tree value = digest_init (type, empty_init_node, (tree *) 0);
-	  DECL_INITIAL (decl) = value;
-	}
-    }
-  else if (TREE_CODE (decl) == VAR_DECL
-	   && TREE_CODE (type) != REFERENCE_TYPE
-	   && (TYPE_READONLY (type) || TREE_READONLY (decl)))
-    {
-      /* ``Unless explicitly declared extern, a const object does not have
-	 external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
-	 However, if it's `const int foo = 1; const int foo;', don't complain
-	 about the second decl, since it does have an initializer before.  */
-      if (! DECL_INITIAL (decl) && (!pedantic || !current_class_type))
-	error_with_decl (decl, "uninitialized const `%s'");
-    }
-
-  /* For top-level declaration, the initial value was read in
-     the temporary obstack.  MAXINDEX, rtl, etc. to be made below
-     must go in the permanent obstack; but don't discard the
-     temporary data yet.  */
-
-  if (current_binding_level == global_binding_level && temporary)
-    end_temporary_allocation ();
-
-  /* Deduce size of array from initialization, if not already known.  */
-
-  if (TREE_CODE (type) == ARRAY_TYPE
-      && TYPE_DOMAIN (type) == NULL_TREE
-      && TREE_CODE (decl) != TYPE_DECL)
-    {
-      int do_default
-	= (TREE_STATIC (decl)
-	   /* Even if pedantic, an external linkage array
-	      may have incomplete type at first.  */
-	   ? pedantic && DECL_EXTERNAL (decl)
-	   : !DECL_EXTERNAL (decl));
-      tree initializer = init ? init : DECL_INITIAL (decl);
-      int failure = complete_array_type (type, initializer, do_default);
-
-      if (failure == 1)
-	error_with_decl (decl, "initializer fails to determine size of `%s'");
-
-      if (failure == 2)
-	{
-	  if (do_default)
-	    error_with_decl (decl, "array size missing in `%s'");
-	  else if (!pedantic && TREE_STATIC (decl))
-	    DECL_EXTERNAL (decl) = 1;
-	}
-
-      if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
-	  && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
-			      integer_zero_node))
-	error_with_decl (decl, "zero-size array `%s'");
-
-      layout_decl (decl, 0);
-    }
-
-  if (TREE_CODE (decl) == VAR_DECL)
-    {
-      if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
-	{
-	  /* A static variable with an incomplete type:
-	     that is an error if it is initialized or `static'.
-	     Otherwise, let it through, but if it is not `extern'
-	     then it may cause an error message later.  */
-	  if (!DECL_EXTERNAL (decl) || DECL_INITIAL (decl) != NULL_TREE)
-	    error_with_decl (decl, "storage size of `%s' isn't known");
-	  init = NULL_TREE;
-	}
-      else if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
-	{
-	  /* An automatic variable with an incomplete type: that is an error.
-	     Don't talk about array types here, since we took care of that
-	     message in grokdeclarator.  */
-	  error_with_decl (decl, "storage size of `%s' isn't known");
-	  TREE_TYPE (decl) = error_mark_node;
-	}
-      else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
-	/* Let debugger know it should output info for this type.  */
-	note_debug_info_needed (ttype);
-
-      if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
-	  && DECL_SIZE (decl) != NULL_TREE
-	  && ! TREE_CONSTANT (DECL_SIZE (decl)))
-	error_with_decl (decl, "storage size of `%s' isn't constant");
-
-      if (!DECL_EXTERNAL (decl) && TYPE_NEEDS_DESTRUCTOR (type))
-	{
-	  int yes = suspend_momentary ();
-
-	  /* If INIT comes from a functional cast, use the cleanup
-	     we built for that.  Otherwise, make our own cleanup.  */
-	  if (init && TREE_CODE (init) == WITH_CLEANUP_EXPR
-	      && comptypes (TREE_TYPE (decl), TREE_TYPE (init), 1))
-	    {
-	      cleanup = TREE_OPERAND (init, 2);
-	      init = TREE_OPERAND (init, 0);
-	      current_binding_level->have_cleanups = 1;
-	      current_binding_level->more_exceptions_ok = 0;
-	    }
-	  else
-	    cleanup = maybe_build_cleanup (decl);
-	  resume_momentary (yes);
-	}
-    }
-  /* PARM_DECLs get cleanups, too.  */
-  else if (TREE_CODE (decl) == PARM_DECL && TYPE_NEEDS_DESTRUCTOR (type))
-    {
-      if (temporary)
-	end_temporary_allocation ();
-      cleanup = maybe_build_cleanup (decl);
-      if (temporary)
-	resume_temporary_allocation ();
-    }
-
-  /* Output the assembler code and/or RTL code for variables and functions,
-     unless the type is an undefined structure or union.
-     If not, it will get done when the type is completed.  */
-
-  if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
-      || TREE_CODE (decl) == RESULT_DECL)
-    {
-      int toplev = current_binding_level == global_binding_level;
-      int was_temp
-	= ((flag_traditional
-	    || (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)))
-	   && allocation_temporary_p ());
-
-      if (was_temp)
-	end_temporary_allocation ();
-
-      /* If we are in need of a cleanup, get out of any implicit
-	 handlers that have been established so far.  */
-      if (cleanup && current_binding_level->parm_flag == 3)
-	{
-	  pop_implicit_try_blocks (decl);
-	  current_binding_level->more_exceptions_ok = 0;
-	}
-
-      if (TREE_CODE (decl) == VAR_DECL
-	  && current_binding_level != global_binding_level
-	  && ! TREE_STATIC (decl)
-	  && type_needs_gc_entry (type))
-	DECL_GC_OFFSET (decl) = size_int (++current_function_obstack_index);
-
-      if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
-	make_decl_rtl (decl, NULL_PTR, toplev);
-      else if (TREE_CODE (decl) == VAR_DECL
-	       && TREE_READONLY (decl)
-	       && DECL_INITIAL (decl) != NULL_TREE
-	       && DECL_INITIAL (decl) != error_mark_node
-	       && DECL_INITIAL (decl) != empty_init_node)
-	{
-	  DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
-
-	  if (asmspec)
-	    DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
-
-	  if (! toplev
-	      && TREE_STATIC (decl)
-	      && ! TREE_SIDE_EFFECTS (decl)
-	      && ! TREE_PUBLIC (decl)
-	      && ! DECL_EXTERNAL (decl)
-	      && ! TYPE_NEEDS_DESTRUCTOR (type)
-	      && DECL_MODE (decl) != BLKmode)
-	    {
-	      /* If this variable is really a constant, then fill its DECL_RTL
-		 slot with something which won't take up storage.
-		 If something later should take its address, we can always give
-		 it legitimate RTL at that time.  */
-	      DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
-	      store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
-	      TREE_ASM_WRITTEN (decl) = 1;
-	    }
-	  else if (toplev)
-	    {
-	      /* Keep GCC from complaining that this variable
-		 is defined but never used.  */
-	      TREE_USED (decl) = 1;
-	      /* If this is a static const, change its apparent linkage
-		 if it belongs to a #pragma interface.  */
-	      if (TREE_STATIC (decl) && !interface_unknown)
-		{
-		  TREE_PUBLIC (decl) = 1;
-		  DECL_EXTERNAL (decl) = interface_only;
-		}
-	      make_decl_rtl (decl, asmspec, toplev);
-	    }
-	  else
-	    rest_of_decl_compilation (decl, asmspec, toplev, 0);
-	}
-      else if (TREE_CODE (decl) == VAR_DECL
-	       && DECL_LANG_SPECIFIC (decl)
-	       && DECL_IN_AGGR_P (decl))
-	{
-	  if (TREE_STATIC (decl))
-	    if (init == NULL_TREE
-#ifdef DEFAULT_STATIC_DEFS
-		/* If this code is dead, then users must
-		   explicitly declare static member variables
-		   outside the class def'n as well.  */
-		&& TYPE_NEEDS_CONSTRUCTING (type)
-#endif
-		)
-	      {
-		DECL_EXTERNAL (decl) = 1;
-		make_decl_rtl (decl, asmspec, 1);
-	      }
-	    else
-	      rest_of_decl_compilation (decl, asmspec, toplev, 0);
-	  else
-	    /* Just a constant field.  Should not need any rtl.  */
-	    goto finish_end0;
-	}
-      else
-	rest_of_decl_compilation (decl, asmspec, toplev, 0);
-
-      if (was_temp)
-	resume_temporary_allocation ();
-
-      if (type != error_mark_node
-	  && TYPE_LANG_SPECIFIC (type)
-	  && CLASSTYPE_ABSTRACT_VIRTUALS (type))
-	abstract_virtuals_error (decl, type);
-      else if ((TREE_CODE (type) == FUNCTION_TYPE
-		|| TREE_CODE (type) == METHOD_TYPE)
-	       && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
-	       && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type)))
-	abstract_virtuals_error (decl, TREE_TYPE (type));
-
-      if (TREE_CODE (decl) == FUNCTION_DECL)
-	{
-	  /* C++: Handle overloaded functions with default parameters.  */
-	  if (DECL_OVERLOADED (decl))
-	    {
-	      tree parmtypes = TYPE_ARG_TYPES (type);
-	      tree prev = NULL_TREE;
-	      tree original_name = DECL_NAME (decl);
-	      struct lang_decl *tmp_lang_decl = DECL_LANG_SPECIFIC (decl);
-	      /* All variants will share an uncollectible lang_decl.  */
-	      copy_decl_lang_specific (decl);
-
-	      while (parmtypes && parmtypes != void_list_node)
-		{
-		  if (TREE_PURPOSE (parmtypes))
-		    {
-		      tree fnname, fndecl;
-		      tree *argp = prev
-			? & TREE_CHAIN (prev)
-			  : & TYPE_ARG_TYPES (type);
-
-		      *argp = NULL_TREE;
-		      fnname = build_decl_overload (original_name, TYPE_ARG_TYPES (type), 0);
-		      *argp = parmtypes;
-		      fndecl = build_decl (FUNCTION_DECL, fnname, type);
-		      DECL_EXTERNAL (fndecl) = DECL_EXTERNAL (decl);
-		      TREE_PUBLIC (fndecl) = TREE_PUBLIC (decl);
-		      DECL_INLINE (fndecl) = DECL_INLINE (decl);
-		      /* Keep G++ from thinking this function is unused.
-			 It is only used to speed up search in name space.  */
-		      TREE_USED (fndecl) = 1;
-		      TREE_ASM_WRITTEN (fndecl) = 1;
-		      DECL_INITIAL (fndecl) = NULL_TREE;
-		      DECL_LANG_SPECIFIC (fndecl) = DECL_LANG_SPECIFIC (decl);
-		      fndecl = pushdecl (fndecl);
-		      DECL_INITIAL (fndecl) = error_mark_node;
-		      DECL_RTL (fndecl) = DECL_RTL (decl);
-		    }
-		  prev = parmtypes;
-		  parmtypes = TREE_CHAIN (parmtypes);
-		}
-	      DECL_LANG_SPECIFIC (decl) = tmp_lang_decl;
-	    }
-	}
-      else if (DECL_EXTERNAL (decl))
-	;
-      else if (TREE_STATIC (decl) && type != error_mark_node)
-	{
-	  /* Cleanups for static variables are handled by `finish_file'.  */
-	  if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE)
-	    expand_static_init (decl, init);
-	  else if (TYPE_NEEDS_DESTRUCTOR (type))
-	    static_aggregates = perm_tree_cons (NULL_TREE, decl,
-						static_aggregates);
-
-	  /* Make entry in appropriate vector.  */
-	  if (flag_gc && type_needs_gc_entry (type))
-	    build_static_gc_entry (decl, type);
-	}
-      else if (current_binding_level != global_binding_level)
-	{
-	  /* This is a declared decl which must live until the
-	     end of the binding contour.  It may need a cleanup.  */
-
-	  /* Recompute the RTL of a local array now
-	     if it used to be an incomplete type.  */
-	  if (was_incomplete && ! TREE_STATIC (decl))
-	    {
-	      /* If we used it already as memory, it must stay in memory.  */
-	      TREE_ADDRESSABLE (decl) = TREE_USED (decl);
-	      /* If it's still incomplete now, no init will save it.  */
-	      if (DECL_SIZE (decl) == NULL_TREE)
-		DECL_INITIAL (decl) = NULL_TREE;
-	      expand_decl (decl);
-	    }
-	  else if (! TREE_ASM_WRITTEN (decl)
-		   && (TYPE_SIZE (type) != NULL_TREE
-		       || TREE_CODE (type) == ARRAY_TYPE))
-	    {
-	      /* Do this here, because we did not expand this decl's
-		 rtl in start_decl.  */
-	      if (DECL_RTL (decl) == NULL_RTX)
-		expand_decl (decl);
-	      else if (cleanup)
-		{
-		  expand_decl_cleanup (NULL_TREE, cleanup);
-		  /* Cleanup used up here.  */
-		  cleanup = NULL_TREE;
-		}
-	    }
-
-	  if (DECL_SIZE (decl) && type != error_mark_node)
-	    {
-	      /* Compute and store the initial value.  */
-	      expand_decl_init (decl);
-
-	      if (init || TYPE_NEEDS_CONSTRUCTING (type))
-		{
-		  emit_line_note (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
-		  expand_aggr_init (decl, init, 0);
-		}
-
-	      /* Set this to 0 so we can tell whether an aggregate
-		 which was initialized was ever used.  */
-	      if (TYPE_NEEDS_CONSTRUCTING (type))
-		TREE_USED (decl) = 0;
-
-	      /* Store the cleanup, if there was one.  */
-	      if (cleanup)
-		{
-		  if (! expand_decl_cleanup (decl, cleanup))
-		    error_with_decl (decl, "parser lost in parsing declaration of `%s'");
-		}
-	    }
-	}
-    finish_end0:
-
-      /* Undo call to `pushclass' that was done in `start_decl'
-	 due to initialization of qualified member variable.
-	 I.e., Foo::x = 10;  */
-      {
-	tree context = DECL_CONTEXT (decl);
-	if (context
-	    && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
-	    && (TREE_CODE (decl) == VAR_DECL
-		/* We also have a pushclass done that we need to undo here
-		   if we're at top level and declare a method.  */
-		|| (TREE_CODE (decl) == FUNCTION_DECL
-		    /* If size hasn't been set, we're still defining it,
-		       and therefore inside the class body; don't pop
-		       the binding level..  */
-		    && TYPE_SIZE (context) != NULL_TREE
-		    /* The binding level gets popped elsewhere for a
-		       friend declaration inside another class.  */
-		    && TYPE_IDENTIFIER (context) == current_class_name
-		    )))
-	  popclass (1);
-      }
-    }
-
- finish_end:
-
-  if (need_pop)
-    {
-      /* Resume permanent allocation, if not within a function.  */
-      /* The corresponding push_obstacks_nochange is in start_decl,
-	 start_method, groktypename, and in grokfield.  */
-      pop_obstacks ();
-    }
-
-  if (was_readonly)
-    TREE_READONLY (decl) = 1;
-
-  if (flag_cadillac)
-    cadillac_finish_decl (decl);
-}
-
-static void
-expand_static_init (decl, init)
-     tree decl;
-     tree init;
-{
-  tree oldstatic = value_member (decl, static_aggregates);
-  if (oldstatic)
-    {
-      if (TREE_PURPOSE (oldstatic))
-	error_with_decl (decl, "multiple initializations given for `%s'");
-    }
-  else if (current_binding_level != global_binding_level)
-    {
-      /* Emit code to perform this initialization but once.  */
-      tree temp;
-
-      /* Remember this information until end of file. */
-      push_obstacks (&permanent_obstack, &permanent_obstack);
-
-      /* Emit code to perform this initialization but once.  */
-      temp = get_temp_name (integer_type_node, 1);
-      rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
-      expand_start_cond (build_binary_op (EQ_EXPR, temp,
-					  integer_zero_node, 1), 0);
-      expand_assignment (temp, integer_one_node, 0, 0);
-      if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
-	{
-	  expand_aggr_init (decl, init, 0);
-	  do_pending_stack_adjust ();
-	}
-      else
-	expand_assignment (decl, init, 0, 0);
-      expand_end_cond ();
-      if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
-	{
-	  static_aggregates = perm_tree_cons (temp, decl, static_aggregates);
-	  TREE_STATIC (static_aggregates) = 1;
-	}
-
-      /* Resume old (possibly temporary) allocation. */
-      pop_obstacks ();
-    }
-  else
-    {
-      /* This code takes into account memory allocation
-	 policy of `start_decl'.  Namely, if TYPE_NEEDS_CONSTRUCTING
-	 does not hold for this object, then we must make permanent
-	 the storage currently in the temporary obstack.  */
-      if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
-	preserve_initializer ();
-      static_aggregates = perm_tree_cons (init, decl, static_aggregates);
-    }
-}
-
-/* Make TYPE a complete type based on INITIAL_VALUE.
-   Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
-   2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
-
-int
-complete_array_type (type, initial_value, do_default)
-     tree type, initial_value;
-     int do_default;
-{
-  register tree maxindex = NULL_TREE;
-  int value = 0;
-
-  if (initial_value)
-    {
-      /* Note MAXINDEX  is really the maximum index,
-	 one less than the size.  */
-      if (TREE_CODE (initial_value) == STRING_CST)
-	maxindex = build_int_2 (TREE_STRING_LENGTH (initial_value) - 1, 0);
-      else if (TREE_CODE (initial_value) == CONSTRUCTOR)
-	{
-	  register int nelts
-	    = list_length (CONSTRUCTOR_ELTS (initial_value));
-	  maxindex = build_int_2 (nelts - 1, 0);
-	}
-      else
-	{
-	  /* Make an error message unless that happened already.  */
-	  if (initial_value != error_mark_node)
-	    value = 1;
-
-	  /* Prevent further error messages.  */
-	  maxindex = build_int_2 (1, 0);
-	}
-    }
-
-  if (!maxindex)
-    {
-      if (do_default)
-	maxindex = build_int_2 (1, 0);
-      value = 2;
-    }
-
-  if (maxindex)
-    {
-      TYPE_DOMAIN (type) = build_index_type (maxindex);
-      if (!TREE_TYPE (maxindex))
-	TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
-    }
-
-  /* Lay out the type now that we can get the real answer.  */
-
-  layout_type (type);
-
-  return value;
-}
-
-/* Return zero if something is declared to be a member of type
-   CTYPE when in the context of CUR_TYPE.  STRING is the error
-   message to print in that case.  Otherwise, quietly return 1.  */
-static int
-member_function_or_else (ctype, cur_type, string)
-     tree ctype, cur_type;
-     char *string;
-{
-  if (ctype && ctype != cur_type)
-    {
-      error (string, TYPE_NAME_STRING (ctype));
-      return 0;
-    }
-  return 1;
-}
-
-/* Subroutine of `grokdeclarator'.  */
-
-/* CTYPE is class type, or null if non-class.
-   TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
-   or METHOD_TYPE.
-   DECLARATOR is the function's name.
-   VIRTUALP is truthvalue of whether the function is virtual or not.
-   FLAGS are to be passed through to `grokclassfn'.
-   QUALS are qualifiers indicating whether the function is `const'
-   or `volatile'.
-   RAISES is a list of exceptions that this function can raise.
-   CHECK is 1 if we must find this method in CTYPE, 0 if we should
-   not look, and -1 if we should not call `grokclassfn' at all.  */
-static tree
-grokfndecl (ctype, type, declarator, virtualp, flags, quals, raises, check, publicp)
-     tree ctype, type;
-     tree declarator;
-     int virtualp;
-     enum overload_flags flags;
-     tree quals, raises;
-     int check, publicp;
-{
-  tree cname, decl;
-  int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
-
-  if (ctype)
-    cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
-      ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
-  else
-    cname = NULL_TREE;
-
-  if (raises)
-    {
-      type = build_exception_variant (ctype, type, raises);
-      raises = TYPE_RAISES_EXCEPTIONS (type);
-    }
-  decl = build_lang_decl (FUNCTION_DECL, declarator, type);
-  /* propagate volatile out from type to decl */
-  if (TYPE_VOLATILE (type))
-      TREE_THIS_VOLATILE (decl) = 1;
-
-  /* Should probably propagate const out from type to decl I bet (mrs).  */
-  if (staticp)
-    {
-      DECL_STATIC_FUNCTION_P (decl) = 1;
-      DECL_CONTEXT (decl) = ctype;
-      DECL_CLASS_CONTEXT (decl) = ctype;
-    }
-
-  if (publicp)
-    TREE_PUBLIC (decl) = 1;
-
-  DECL_EXTERNAL (decl) = 1;
-  if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
-    {
-      error ("functions cannot have method qualifiers");
-      quals = NULL_TREE;
-    }
-
-  /* Only two styles of delete's are valid. */
-  if (declarator == ansi_opname[(int) DELETE_EXPR])
-    {
-      tree args = TYPE_ARG_TYPES (type);
-      int style1, style2;
-
-      if (ctype && args && TREE_CODE (type) == METHOD_TYPE)
-	/* remove this */
-	args = TREE_CHAIN (args);
-     
-      style1 = type_list_equal (args,
-				tree_cons (NULL_TREE, ptr_type_node,
-					   void_list_node));
-      style2 = style1 != 0 ? 0 :
-	type_list_equal (args,
-			 tree_cons (NULL_TREE, ptr_type_node,
-				    tree_cons (NULL_TREE, sizetype,
-					       void_list_node)));
-
-      if (ctype == NULL_TREE)
-	{
-	  if (! style1)
-	    /* ANSI C++ June 5 1992 WP 12.5.5.2 */
-	    error ("global operator delete must be declared as taking a single argument of type void*");
-	}
-      else
-	if (! style1 && ! style2)
-	  /* ANSI C++ June 5 1992 WP 12.5.4.1 */
-	  error ("operator delete cannot be overloaded");
-    }
-  else if (DECL_NAME (decl) == ansi_opname[(int) POSTINCREMENT_EXPR]
-	   || DECL_NAME (decl) == ansi_opname[(int) POSTDECREMENT_EXPR])
-    {
-      /* According to ARM $13.4.7, postfix operator++ must take an int as
-	 its second argument.  */
-      tree parmtypes, argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
-
-      if (argtypes)
-	{
-	  parmtypes = TREE_CHAIN (argtypes);
-	  if (parmtypes != NULL_TREE
-	      && TREE_VALUE (parmtypes) != void_type_node
-	      && TREE_VALUE (parmtypes) != integer_type_node)
-	    error ("postfix operator%s may only take `int' as its argument",
-		   POSTINCREMENT_EXPR ? "++" : "--");
-	}
-    }
-
-  /* Caller will do the rest of this.  */
-  if (check < 0)
-    return decl;
-
-  if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
-    {
-      tree tmp;
-      /* Just handle constructors here.  We could do this
-	 inside the following if stmt, but I think
-	 that the code is more legible by breaking this
-	 case out.  See comments below for what each of
-	 the following calls is supposed to do.  */
-      DECL_CONSTRUCTOR_P (decl) = 1;
-
-      grokclassfn (ctype, declarator, decl, flags, quals);
-      if (check)
-	check_classfn (ctype, declarator, decl);
-      grok_ctor_properties (ctype, decl);
-      if (check == 0)
-	{
-	  /* FIXME: this should only need to look at IDENTIFIER_GLOBAL_VALUE.  */
-	  tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
-	  if (tmp == NULL_TREE)
-	    IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl)) = decl;
-	  else if (TREE_CODE (tmp) != TREE_CODE (decl))
-	    error_with_decl (decl, "inconsistent declarations for `%s'");
-	  else
-	    {
-	      duplicate_decls (decl, tmp);
-	      decl = tmp;
-	      /* avoid creating circularities.  */
-	      DECL_CHAIN (decl) = NULL_TREE;
-	    }
-	  make_decl_rtl (decl, NULL_PTR, 1);
-	}
-    }
-  else
-    {
-      tree tmp;
-
-      /* Function gets the ugly name, field gets the nice one.
-	 This call may change the type of the function (because
-	 of default parameters)!  */
-      if (ctype != NULL_TREE)
-	grokclassfn (ctype, cname, decl, flags, quals);
-
-      if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
-	grok_op_properties (decl, virtualp);
-
-      if (ctype != NULL_TREE && check)
-	check_classfn (ctype, cname, decl);
-
-      if (ctype == NULL_TREE || check)
-	return decl;
-
-      /* Now install the declaration of this function so that
-	 others may find it (esp. its DECL_FRIENDLIST).
-	 Pretend we are at top level, we will get true
-	 reference later, perhaps.
-
-	 FIXME: This should only need to look at IDENTIFIER_GLOBAL_VALUE.  */
-      tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
-      if (tmp == NULL_TREE)
-	IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl)) = decl;
-      else if (TREE_CODE (tmp) != TREE_CODE (decl))
-	error_with_decl (decl, "inconsistent declarations for `%s'");
-      else
-	{
-	  duplicate_decls (decl, tmp);
-	  decl = tmp;
-	  /* avoid creating circularities.  */
-	  DECL_CHAIN (decl) = NULL_TREE;
-	}
-      make_decl_rtl (decl, NULL_PTR, 1);
-
-      /* If this declaration supersedes the declaration of
-	 a method declared virtual in the base class, then
-	 mark this field as being virtual as well.  */
-      {
-	tree binfos = BINFO_BASETYPES (TYPE_BINFO (ctype));
-	int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-	for (i = 0; i < n_baselinks; i++)
-	  {
-	    tree base_binfo = TREE_VEC_ELT (binfos, i);
-	    if (TYPE_VIRTUAL_P (BINFO_TYPE (base_binfo)) || flag_all_virtual == 1)
-	      {
-		tmp = get_first_matching_virtual (base_binfo, decl,
-						  flags == DTOR_FLAG);
-		if (tmp)
-		  {
-		    /* The TMP we really want is the one from the deepest
-		       baseclass on this path, taking care not to
-		       duplicate if we have already found it (via another
-		       path to its virtual baseclass.  */
-		    if (staticp)
-		      {
-			error_with_decl (decl, "method `%s' may not be declared static");
-			error_with_decl (tmp, "(since `%s' declared virtual in base class.)");
-			break;
-		      }
-		    virtualp = 1;
-
-		    if ((TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (base_binfo))
-			 || TYPE_USES_MULTIPLE_INHERITANCE (ctype))
-			&& BINFO_TYPE (base_binfo) != DECL_CONTEXT (tmp))
-		      tmp = get_first_matching_virtual (TYPE_BINFO (DECL_CONTEXT (tmp)),
-							decl, flags == DTOR_FLAG);
-		    if (value_member (tmp, DECL_VINDEX (decl)) == NULL_TREE)
-		      {
-			/* The argument types may have changed... */
-			tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
-			tree base_variant = TREE_TYPE (TREE_VALUE (argtypes));
-
-			argtypes = commonparms (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (tmp))),
-						TREE_CHAIN (argtypes));
-			/* But the return type has not.  */
-			type = build_cplus_method_type (base_variant, TREE_TYPE (type), argtypes);
-			if (raises)
-			  {
-			    type = build_exception_variant (ctype, type, raises);
-			    raises = TYPE_RAISES_EXCEPTIONS (type);
-			  }
-			TREE_TYPE (decl) = type;
-			DECL_VINDEX (decl)
-			  = tree_cons (NULL_TREE, tmp, DECL_VINDEX (decl));
-		      }
-		  }
-	      }
-	  }
-      }
-      if (virtualp)
-	{
-	  if (DECL_VINDEX (decl) == NULL_TREE)
-	    DECL_VINDEX (decl) = error_mark_node;
-	  IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
-	  if (ctype && CLASSTYPE_VTABLE_NEEDS_WRITING (ctype)
-	      /* If this function is derived from a template, don't
-		 make it public.  This shouldn't be here, but there's
-		 no good way to override the interface pragmas for one
-		 function or class only.  Bletch.  */
-	      && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (ctype)) == NULL_TREE
-	      && (write_virtuals == 2
-		  || (write_virtuals == 3
-		      && ! CLASSTYPE_INTERFACE_UNKNOWN (ctype))))
-	    TREE_PUBLIC (decl) = 1;
-	}
-    }
-  return decl;
-}
-
-static tree
-grokvardecl (type, declarator, specbits, initialized)
-     tree type;
-     tree declarator;
-     RID_BIT_TYPE specbits;
-     int initialized;
-{
-  tree decl;
-
-  /* This implements the "one definition rule" for global variables.
-     Note that declarator can come in as null when we're doing work
-     on an anonymous union.  */
-  if (declarator && IDENTIFIER_GLOBAL_VALUE (declarator)
-      && current_binding_level == global_binding_level
-      && TREE_STATIC (IDENTIFIER_GLOBAL_VALUE (declarator))
-      && (! (specbits & RIDBIT (RID_EXTERN))
-	  || initialized))
-    {
-      error ("redefinition of `%s'", IDENTIFIER_POINTER (declarator));
-      error_with_decl (IDENTIFIER_GLOBAL_VALUE (declarator),
-		       "previously defined here");
-    }
-
-  if (TREE_CODE (type) == OFFSET_TYPE)
-    {
-      /* If you declare a static member so that it
-	 can be initialized, the code will reach here.  */
-      tree field = lookup_field (TYPE_OFFSET_BASETYPE (type),
-				 declarator, 0, 0);
-      if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
-	{
-	  tree basetype = TYPE_OFFSET_BASETYPE (type);
-	  error ("`%s' is not a static member of class `%s'",
-		 IDENTIFIER_POINTER (declarator),
-		 TYPE_NAME_STRING (basetype));
-	  type = TREE_TYPE (type);
-	  decl = build_lang_field_decl (VAR_DECL, declarator, type);
-	  DECL_CONTEXT (decl) = basetype;
-	  DECL_CLASS_CONTEXT (decl) = basetype;
-	}
-      else
-	{
-	  tree f_type = TREE_TYPE (field);
-	  tree o_type = TREE_TYPE (type);
-
-	  if (TYPE_SIZE (f_type) == NULL_TREE)
-	    {
-	      if (TREE_CODE (f_type) != TREE_CODE (o_type)
-		  || (TREE_CODE (f_type) == ARRAY_TYPE
-		      && TREE_TYPE (f_type) != TREE_TYPE (o_type)))
-		error ("redeclaration of type for `%s'",
-		       IDENTIFIER_POINTER (declarator));
-	      else if (TYPE_SIZE (o_type) != NULL_TREE)
-		TREE_TYPE (field) = type;
-	    }
-	  else if (f_type != o_type)
-	    error ("redeclaration of type for `%s'",
-		   IDENTIFIER_POINTER (declarator));
-	  decl = field;
-	  if (initialized && DECL_INITIAL (decl)
-	      /* Complain about multiply-initialized
-		 member variables, but don't be faked
-		 out if initializer is faked up from `empty_init_node'.  */
-	      && (TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
-		  || CONSTRUCTOR_ELTS (DECL_INITIAL (decl)) != NULL_TREE))
-	    error_with_aggr_type (DECL_CONTEXT (decl),
-				  "multiple initializations of static member `%s::%s'",
-				  IDENTIFIER_POINTER (DECL_NAME (decl)));
-	}
-    }
-  else decl = build_decl (VAR_DECL, declarator, type);
-
-  if (specbits & RIDBIT (RID_EXTERN))
-    {
-      DECL_THIS_EXTERN (decl) = 1;
-      DECL_EXTERNAL (decl) = !initialized;
-    }
-
-  /* In class context, static means one per class,
-     public visibility, and static storage.  */
-  if (DECL_FIELD_CONTEXT (decl) != NULL_TREE
-      && IS_AGGR_TYPE (DECL_FIELD_CONTEXT (decl)))
-    {
-      TREE_PUBLIC (decl) = 1;
-      TREE_STATIC (decl) = 1;
-      DECL_EXTERNAL (decl) = !initialized;
-    }
-  /* At top level, either `static' or no s.c. makes a definition
-     (perhaps tentative), and absence of `static' makes it public.  */
-  else if (current_binding_level == global_binding_level)
-    {
-      TREE_PUBLIC (decl) = ! (specbits & RIDBIT (RID_STATIC));
-      TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
-    }
-  /* Not at top level, only `static' makes a static definition.  */
-  else
-    {
-      TREE_STATIC (decl) = !! (specbits & RIDBIT (RID_STATIC));
-      TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
-    }
-  return decl;
-}
-
-/* Given declspecs and a declarator,
-   determine the name and type of the object declared
-   and construct a ..._DECL node for it.
-   (In one case we can return a ..._TYPE node instead.
-    For invalid input we sometimes return 0.)
-
-   DECLSPECS is a chain of tree_list nodes whose value fields
-    are the storage classes and type specifiers.
-
-   DECL_CONTEXT says which syntactic context this declaration is in:
-     NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
-     FUNCDEF for a function definition.  Like NORMAL but a few different
-      error messages in each case.  Return value may be zero meaning
-      this definition is too screwy to try to parse.
-     MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
-      handle member functions (which have FIELD context).
-      Return value may be zero meaning this definition is too screwy to
-      try to parse.
-     PARM for a parameter declaration (either within a function prototype
-      or before a function body).  Make a PARM_DECL, or return void_type_node.
-     TYPENAME if for a typename (in a cast or sizeof).
-      Don't make a DECL node; just return the ..._TYPE node.
-     FIELD for a struct or union field; make a FIELD_DECL.
-     BITFIELD for a field with specified width.
-   INITIALIZED is 1 if the decl has an initializer.
-
-   In the TYPENAME case, DECLARATOR is really an absolute declarator.
-   It may also be so in the PARM case, for a prototype where the
-   argument type is specified but not the name.
-
-   This function is where the complicated C meanings of `static'
-   and `extern' are interpreted.
-
-   For C++, if there is any monkey business to do, the function which
-   calls this one must do it, i.e., prepending instance variables,
-   renaming overloaded function names, etc.
-
-   Note that for this C++, it is an error to define a method within a class
-   which does not belong to that class.
-
-   Except in the case where SCOPE_REFs are implicitly known (such as
-   methods within a class being redundantly qualified),
-   declarations which involve SCOPE_REFs are returned as SCOPE_REFs
-   (class_name::decl_name).  The caller must also deal with this.
-
-   If a constructor or destructor is seen, and the context is FIELD,
-   then the type gains the attribute TREE_HAS_x.  If such a declaration
-   is erroneous, NULL_TREE is returned.
-
-   QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
-   function, these are the qualifiers to give to the `this' pointer.
-
-   May return void_type_node if the declarator turned out to be a friend.
-   See grokfield for details.  */
-
-enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
-
-tree
-grokdeclarator (declarator, declspecs, decl_context, initialized, raises)
-     tree declspecs;
-     tree declarator;
-     enum decl_context decl_context;
-     int initialized;
-     tree raises;
-{
-  extern int current_class_depth;
-
-  RID_BIT_TYPE specbits = 0;
-  int nclasses = 0;
-  tree spec;
-  tree type = NULL_TREE;
-  int longlong = 0;
-  int constp;
-  int volatilep;
-  int virtualp, friendp, inlinep, staticp;
-  int explicit_int = 0;
-  int explicit_char = 0;
-  tree typedef_decl = NULL_TREE;
-  char *name;
-  tree typedef_type = NULL_TREE;
-  int funcdef_flag = 0;
-  enum tree_code innermost_code = ERROR_MARK;
-  int bitfield = 0;
-  int size_varies = 0;
-  /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
-     All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
-  tree init = NULL_TREE;
-
-  /* Keep track of what sort of function is being processed
-     so that we can warn about default return values, or explicit
-     return values which do not match prescribed defaults.  */
-  enum return_types return_type = return_normal;
-
-  tree dname = NULL_TREE;
-  tree ctype = current_class_type;
-  tree ctor_return_type = NULL_TREE;
-  enum overload_flags flags = NO_SPECIAL;
-  int seen_scope_ref = 0;
-  tree quals = NULL_TREE;
-
-  if (decl_context == FUNCDEF)
-    funcdef_flag = 1, decl_context = NORMAL;
-  else if (decl_context == MEMFUNCDEF)
-    funcdef_flag = -1, decl_context = FIELD;
-  else if (decl_context == BITFIELD)
-    bitfield = 1, decl_context = FIELD;
-
-  if (flag_traditional && allocation_temporary_p ())
-    end_temporary_allocation ();
-
-  /* Look inside a declarator for the name being declared
-     and get it as a string, for an error message.  */
-  {
-    tree type, last = NULL_TREE;
-    register tree decl = declarator;
-    name = NULL;
-
-    /* If we see something of the form `aggr_type xyzzy (a, b, c)'
-       it is either an old-style function declaration or a call to
-       a constructor.  The following conditional makes recognizes this
-       case as being a call to a constructor.  Too bad if it is not.  */
-
-    /* For Doug Lea, also grok `aggr_type xyzzy (a, b, c)[10][10][10]'.  */
-    while (decl && TREE_CODE (decl) == ARRAY_REF)
-      {
-	last = decl;
-	decl = TREE_OPERAND (decl, 0);
-      }
-
-    if (decl && declspecs
-        && TREE_CODE (decl) == CALL_EXPR
-        && TREE_OPERAND (decl, 0)
-        && (TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
-	    || TREE_CODE (TREE_OPERAND (decl, 0)) == SCOPE_REF))
-      {
-        type = TREE_CODE (TREE_VALUE (declspecs)) == IDENTIFIER_NODE
-          ? lookup_name (TREE_VALUE (declspecs), 1) :
-        (IS_AGGR_TYPE (TREE_VALUE (declspecs))
-         ? TYPE_NAME (TREE_VALUE (declspecs)) : NULL_TREE);
-
-        if (type && TREE_CODE (type) == TYPE_DECL
-            && IS_AGGR_TYPE (TREE_TYPE (type))
-            && parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
-          {
-            if (decl_context == FIELD
-                && TREE_CHAIN (TREE_OPERAND (decl, 1)))
-              {
-                /* That was an initializer list.  */
-                sorry ("initializer lists for field declarations");
-                decl = TREE_OPERAND (decl, 0);
-		if (last)
-		  {
-		    TREE_OPERAND (last, 0) = decl;
-		    decl = declarator;
-		  }
-                declarator = decl;
-                init = error_mark_node;
-                goto bot;
-              }
-            else
-              {
-		init = TREE_OPERAND (decl, 1);
-		if (last)
-		  {
-		    TREE_OPERAND (last, 0) = TREE_OPERAND (decl, 0);
-		    if (pedantic && init)
-		      {
-		      error ("arrays cannot take initializers");
-		      init = error_mark_node;
-		    }
-		  }
-		else
-		  declarator = TREE_OPERAND (declarator, 0);
-		decl = start_decl (declarator, declspecs, 1, NULL_TREE);
-		finish_decl (decl, init, NULL_TREE, 1);
-		return 0;
-              }
-          }
-
-        if (parmlist_is_random (TREE_OPERAND (decl, 1)))
-          {
-	    decl = TREE_OPERAND (decl, 0);
-	    if (TREE_CODE (decl) == SCOPE_REF)
-	      {
-		if (TREE_COMPLEXITY (decl))
-		  my_friendly_abort (15);
-		decl = TREE_OPERAND (decl, 1);
-	      }
-	    if (TREE_CODE (decl) == IDENTIFIER_NODE)
-	      name = IDENTIFIER_POINTER (decl);
-	    if (name)
-	      error ("bad parameter list specification for function `%s'",
-		     name);
-	    else
-	      error ("bad parameter list specification for function");
-            return void_type_node;
-          }
-      bot:
-        ;
-      }
-    else
-      /* It didn't look like we thought it would, leave the ARRAY_REFs on.  */
-      decl = declarator;
-
-    while (decl)
-      switch (TREE_CODE (decl))
-        {
-	case COND_EXPR:
-	  ctype = NULL_TREE;
-	  decl = TREE_OPERAND (decl, 0);
-	  break;
-
-	case BIT_NOT_EXPR:      /* for C++ destructors!  */
-	  {
-	    tree name = TREE_OPERAND (decl, 0);
-	    tree rename = NULL_TREE;
-
-	    my_friendly_assert (flags == NO_SPECIAL, 152);
-	    flags = DTOR_FLAG;
-	    return_type = return_dtor;
-	    my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
-	    if (ctype == NULL_TREE)
-	      {
-		if (current_class_type == NULL_TREE)
-		  {
-		    error ("destructors must be member functions");
-		    flags = NO_SPECIAL;
-		  }
-		else
-		  {
-		    tree t = constructor_name (current_class_name);
-		    if (t != name)
-		      rename = t;
-		  }
-	      }
-	    else
-	      {
-		tree t = constructor_name (ctype);
-		if (t != name)
-		  rename = t;
-	      }
-
-	    if (rename)
-	      {
-		error ("destructor `%s' must match class name `%s'",
-		       IDENTIFIER_POINTER (name),
-		       IDENTIFIER_POINTER (rename));
-		TREE_OPERAND (decl, 0) = rename;
-	      }
-	    decl = name;
-	  }
-	  break;
-
-	case ADDR_EXPR:         /* C++ reference declaration */
-	  /* fall through */
-	case ARRAY_REF:
-	case INDIRECT_REF:
-	  ctype = NULL_TREE;
-	  innermost_code = TREE_CODE (decl);
-	  decl = TREE_OPERAND (decl, 0);
-	  break;
-
-	case CALL_EXPR:
-	  innermost_code = TREE_CODE (decl);
-	  decl = TREE_OPERAND (decl, 0);
-	  if (decl_context == FIELD && ctype == NULL_TREE)
-	    ctype = current_class_type;
-	  if (ctype != NULL_TREE
-	      && decl != NULL_TREE && flags != DTOR_FLAG
-	      && decl == constructor_name (ctype))
-	    {
-	      return_type = return_ctor;
-	      ctor_return_type = ctype;
-	    }
-	  ctype = NULL_TREE;
-	  break;
-
-	case IDENTIFIER_NODE:
-	  dname = decl;
-	  name = IDENTIFIER_POINTER (decl);
-	  decl = NULL_TREE;
-	  break;
-
-	case RECORD_TYPE:
-	case UNION_TYPE:
-	case ENUMERAL_TYPE:
-	  /* Parse error puts this typespec where
-	     a declarator should go.  */
-	  error ("declarator name missing");
-	  dname = TYPE_NAME (decl);
-	  if (dname && TREE_CODE (dname) == TYPE_DECL)
-	    dname = DECL_NAME (dname);
-	  name = dname ? IDENTIFIER_POINTER (dname) : "<nameless>";
-	  declspecs = temp_tree_cons (NULL_TREE, decl, declspecs);
-	  decl = NULL_TREE;
-	  break;
-
-	case TYPE_EXPR:
-	  if (ctype == NULL_TREE)
-	    {
-	      /* ANSI C++ June 5 1992 WP 12.3.2 only describes
-		 conversion functions in terms of being declared
-		 as a member function.  */
-	      error ("operator `%s' must be declared as a member",
-		     IDENTIFIER_POINTER (TREE_VALUE (TREE_TYPE (decl))));
-	      return NULL_TREE;
-	    }
-	      
-	  ctype = NULL_TREE;
-	  my_friendly_assert (flags == NO_SPECIAL, 154);
-	  flags = TYPENAME_FLAG;
-	  name = "operator <typename>";
-	  /* Go to the absdcl.  */
-	  decl = TREE_OPERAND (decl, 0);
-	  return_type = return_conversion;
-	  break;
-
-	  /* C++ extension */
-	case SCOPE_REF:
-	  if (seen_scope_ref == 1)
-	    error ("multiple `::' terms in declarator invalid");
-	  seen_scope_ref += 1;
-	  {
-	    /* Perform error checking, and convert class names to types.
-	       We may call grokdeclarator multiple times for the same
-	       tree structure, so only do the conversion once.  In this
-	       case, we have exactly what we want for `ctype'.  */
-	    tree cname = TREE_OPERAND (decl, 0);
-	    if (cname == NULL_TREE)
-	      ctype = NULL_TREE;
-	    /* Can't use IS_AGGR_TYPE because CNAME might not be a type.  */
-	    else if (IS_AGGR_TYPE_CODE (TREE_CODE (cname))
-		     || TREE_CODE (cname) == UNINSTANTIATED_P_TYPE)
-	      ctype = cname;
-	    else if (! is_aggr_typedef (cname, 1))
-	      {
-		TREE_OPERAND (decl, 0) = NULL_TREE;
-	      }
-	    /* Must test TREE_OPERAND (decl, 1), in case user gives
-	       us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
-	    else if (TREE_OPERAND (decl, 1)
-		     && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
-	      {
-		TREE_OPERAND (decl, 0) = IDENTIFIER_TYPE_VALUE (cname);
-	      }
-	    else if (ctype == NULL_TREE)
-	      {
-		ctype = IDENTIFIER_TYPE_VALUE (cname);
-		TREE_OPERAND (decl, 0) = ctype;
-	      }
-	    else if (TREE_COMPLEXITY (decl) == current_class_depth)
-	      TREE_OPERAND (decl, 0) = ctype;
-	    else
-	      {
-		if (! UNIQUELY_DERIVED_FROM_P (IDENTIFIER_TYPE_VALUE (cname), ctype))
-		  {
-		    error ("type `%s' is not derived from type `%s'",
-			   IDENTIFIER_POINTER (cname),
-			   TYPE_NAME_STRING (ctype));
-		    TREE_OPERAND (decl, 0) = NULL_TREE;
-		  }
-		else
-		  {
-		    ctype = IDENTIFIER_TYPE_VALUE (cname);
-		    TREE_OPERAND (decl, 0) = ctype;
-		  }
-	      }
-
-	    decl = TREE_OPERAND (decl, 1);
-	    if (ctype)
-	      {
-		if (TREE_CODE (decl) == IDENTIFIER_NODE
-		    && constructor_name (ctype) == decl)
-		  {
-		    return_type = return_ctor;
-		    ctor_return_type = ctype;
-		  }
-		else if (TREE_CODE (decl) == BIT_NOT_EXPR
-			 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
-			 && constructor_name (ctype) == TREE_OPERAND (decl, 0))
-		  {
-		    return_type = return_dtor;
-		    ctor_return_type = ctype;
-		    flags = DTOR_FLAG;
-		    decl = TREE_OPERAND (decl, 0);
-		  }
-	      }
-	  }
-	  break;
-
-	case ERROR_MARK:
-	  decl = NULL_TREE;
-	  break;
-
-	default:
-	  my_friendly_abort (155);
-	}
-    if (name == NULL)
-      name = "type name";
-  }
-
-  /* A function definition's declarator must have the form of
-     a function declarator.  */
-
-  if (funcdef_flag && innermost_code != CALL_EXPR)
-    return 0;
-
-  /* Anything declared one level down from the top level
-     must be one of the parameters of a function
-     (because the body is at least two levels down).  */
-
-  /* This heuristic cannot be applied to C++ nodes! Fixed, however,
-     by not allowing C++ class definitions to specify their parameters
-     with xdecls (must be spec.d in the parmlist).
-
-     Since we now wait to push a class scope until we are sure that
-     we are in a legitimate method context, we must set oldcname
-     explicitly (since current_class_name is not yet alive).  */
-
-  if (decl_context == NORMAL
-      && current_binding_level->level_chain == global_binding_level)
-    decl_context = PARM;
-
-  /* Look through the decl specs and record which ones appear.
-     Some typespecs are defined as built-in typenames.
-     Others, the ones that are modifiers of other types,
-     are represented by bits in SPECBITS: set the bits for
-     the modifiers that appear.  Storage class keywords are also in SPECBITS.
-
-     If there is a typedef name or a type, store the type in TYPE.
-     This includes builtin typedefs such as `int'.
-
-     Set EXPLICIT_INT if the type is `int' or `char' and did not
-     come from a user typedef.
-
-     Set LONGLONG if `long' is mentioned twice.
-
-     For C++, constructors and destructors have their own fast treatment.  */
-
-  for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
-    {
-      register int i;
-      register tree id = TREE_VALUE (spec);
-
-      /* Certain parse errors slip through.  For example,
-	 `int class;' is not caught by the parser. Try
-	 weakly to recover here.  */
-      if (TREE_CODE (spec) != TREE_LIST)
-	return 0;
-
-      if (TREE_CODE (id) == IDENTIFIER_NODE)
-	{
-	  if (id == ridpointers[(int) RID_INT])
-	    {
-	      if (type)
-		error ("extraneous `int' ignored");
-	      else
-		{
-		  explicit_int = 1;
-		  type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
-		}
-	      goto found;
-	    }
-	  if (id == ridpointers[(int) RID_CHAR])
-	    {
-	      if (type)
-		error ("extraneous `char' ignored");
-	      else
-		{
-		  explicit_char = 1;
-		  type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
-		}
-	      goto found;
-	    }
-	  if (id == ridpointers[(int) RID_WCHAR])
-	    {
-	      if (type)
-		error ("extraneous `__wchar_t' ignored");
-	      else
-		{
-		  type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
-		}
-	      goto found;
-	    }
-	  /* C++ aggregate types.  */
-	  if (IDENTIFIER_HAS_TYPE_VALUE (id))
-	    {
-	      if (type)
-		error ("multiple declarations `%s' and `%s'",
-		       IDENTIFIER_POINTER (type),
-		       IDENTIFIER_POINTER (id));
-	      else
-		type = IDENTIFIER_TYPE_VALUE (id);
-	      goto found;
-	    }
-
-	  for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
-	    {
-	      if (ridpointers[i] == id)
-		{
-		  if (i == (int) RID_LONG && (specbits & RIDBIT (i)))
-		    {
-		      if (pedantic)
-			pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
-		      else if (longlong)
-		        error ("`long long long' is too long for GCC");
-		      else
-			longlong = 1;
-		    }
-		  else if (specbits & RIDBIT (i))
-		    warning ("duplicate `%s'", IDENTIFIER_POINTER (id));
-		  specbits |= RIDBIT (i);
-		  goto found;
-		}
-	    }
-	}
-      if (type)
-	error ("two or more data types in declaration of `%s'", name);
-      else if (TREE_CODE (id) == IDENTIFIER_NODE)
-	{
-	  register tree t = lookup_name (id, 1);
-	  if (!t || TREE_CODE (t) != TYPE_DECL)
-	    error ("`%s' fails to be a typedef or built in type",
-		   IDENTIFIER_POINTER (id));
-	  else
-	    {
-	      type = TREE_TYPE (t);
-	      typedef_decl = t;
-	    }
-	}
-      else if (TREE_CODE (id) != ERROR_MARK)
-	/* Can't change CLASS nodes into RECORD nodes here!  */
-	type = id;
-
-    found: {}
-    }
-
-  typedef_type = type;
-
-  /* No type at all: default to `int', and set EXPLICIT_INT
-     because it was not a user-defined typedef.  */
-
-  if (type == NULL_TREE)
-    {
-      explicit_int = -1;
-      if (return_type == return_dtor)
-	type = void_type_node;
-      else if (return_type == return_ctor)
-	type = TYPE_POINTER_TO (ctor_return_type);
-      else
-	{
-	  if (funcdef_flag && explicit_warn_return_type
-	      && return_type == return_normal
-	      && ! (specbits & (RIDBIT (RID_SIGNED) | RIDBIT (RID_UNSIGNED)
-				| RIDBIT (RID_LONG) | RIDBIT (RID_SHORT))))
-	    warn_about_return_type = 1;
-	  /* Save warning until we know what is really going on.  */
-	  type = integer_type_node;
-	}
-    }
-  else if (return_type == return_dtor)
-    {
-      error ("return type specification for destructor invalid");
-      type = void_type_node;
-    }
-  else if (return_type == return_ctor)
-    {
-      error ("return type specification for constructor invalid");
-      type = TYPE_POINTER_TO (ctor_return_type);
-    }
-  else if ((specbits & RIDBIT (RID_FRIEND))
-	   && IS_AGGR_TYPE (type)
-	   && ! TYPE_BEING_DEFINED (type)
-	   && TYPE_SIZE (type) == NULL_TREE
-	   && ! ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
-	   && current_function_decl == NULL_TREE
-	   && decl_context != PARM)
-    {
-      /* xref_tag will make friend class declarations look like
-	 nested class declarations.  Retroactively change that
-	 if the type has not yet been defined.
-
-	 ??? ANSI C++ doesn't say what to do in this case yet.  */
-      globalize_nested_type (type);
-    }
-
-  ctype = NULL_TREE;
-
-  /* Now process the modifiers that were specified
-     and check for invalid combinations.  */
-
-  /* Long double is a special combination.  */
-
-  if ((specbits & RIDBIT (RID_LONG))
-      && TYPE_MAIN_VARIANT (type) == double_type_node)
-    {
-      specbits &= ~ RIDBIT (RID_LONG);
-      type = build_type_variant (long_double_type_node, TYPE_READONLY (type),
-				 TYPE_VOLATILE (type));
-    }
-
-  /* Check all other uses of type modifiers.  */
-
-  if (specbits & (RIDBIT (RID_UNSIGNED) | RIDBIT (RID_SIGNED)
-		  | RIDBIT (RID_LONG) | RIDBIT (RID_SHORT)))
-    {
-      int ok = 0;
-
-      if (TREE_CODE (type) == REAL_TYPE)
-	error ("short, signed or unsigned invalid for `%s'", name);
-      else if (TREE_CODE (type) != INTEGER_TYPE || type == wchar_type_node)
-	error ("long, short, signed or unsigned invalid for `%s'", name);
-      else if ((specbits & RIDBIT (RID_LONG))
-	       && (specbits & RIDBIT (RID_SHORT)))
-	error ("long and short specified together for `%s'", name);
-      else if (((specbits & RIDBIT (RID_LONG))
-		|| (specbits & RIDBIT (RID_SHORT)))
-	       && explicit_char)
-	error ("long or short specified with char for `%s'", name);
-      else if (((specbits & RIDBIT (RID_LONG))
-		|| (specbits & RIDBIT (RID_SHORT)))
-	       && TREE_CODE (type) == REAL_TYPE)
-	error ("long or short specified with floating type for `%s'", name);
-      else if ((specbits & RIDBIT (RID_SIGNED))
-	       && (specbits & RIDBIT (RID_UNSIGNED)))
-	error ("signed and unsigned given together for `%s'", name);
-      else
-	{
-	  ok = 1;
-	  if (!explicit_int && !explicit_char && pedantic)
-	    {
-	      pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
-		       name);
-	      if (flag_pedantic_errors)
-		ok = 0;
-	    }
-	}
-
-      /* Discard the type modifiers if they are invalid.  */
-      if (! ok)
-	{
-	  specbits &= ~ (RIDBIT (RID_UNSIGNED) | RIDBIT (RID_SIGNED)
-			 | RIDBIT (RID_LONG) | RIDBIT (RID_SHORT));
-	  longlong = 0;
-	}
-    }
-
-  /* Decide whether an integer type is signed or not.
-     Optionally treat bitfields as signed by default.  */
-  if ((specbits & RIDBIT (RID_UNSIGNED))
-      /* Traditionally, all bitfields are unsigned.  */
-      || (bitfield && flag_traditional)
-      || (bitfield && ! flag_signed_bitfields
-	  && (explicit_int || explicit_char
-	      /* A typedef for plain `int' without `signed'
-		 can be controlled just like plain `int'.  */
-	      || ! (typedef_decl != NULL_TREE
-		    && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
-	  && TREE_CODE (type) != ENUMERAL_TYPE
-	  && !(specbits & RIDBIT (RID_SIGNED))))
-    {
-      if (longlong)
-	type = long_long_unsigned_type_node;
-      else if (specbits & RIDBIT (RID_LONG))
-	type = long_unsigned_type_node;
-      else if (specbits & RIDBIT (RID_SHORT))
-	type = short_unsigned_type_node;
-      else if (type == char_type_node)
-	type = unsigned_char_type_node;
-      else if (typedef_decl)
-	type = unsigned_type (type);
-      else
-	type = unsigned_type_node;
-    }
-  else if ((specbits & RIDBIT (RID_SIGNED))
-	   && type == char_type_node)
-    type = signed_char_type_node;
-  else if (longlong)
-    type = long_long_integer_type_node;
-  else if (specbits & RIDBIT (RID_LONG))
-    type = long_integer_type_node;
-  else if (specbits & RIDBIT (RID_SHORT))
-    type = short_integer_type_node;
-
-  /* Set CONSTP if this declaration is `const', whether by
-     explicit specification or via a typedef.
-     Likewise for VOLATILEP.  */
-
-  constp = !! (specbits & RIDBIT (RID_CONST)) + TYPE_READONLY (type);
-  volatilep = !! (specbits & RIDBIT (RID_VOLATILE)) + TYPE_VOLATILE (type);
-  staticp = 0;
-  inlinep = !! (specbits & RIDBIT (RID_INLINE));
-  if (constp > 1)
-    warning ("duplicate `const'");
-  if (volatilep > 1)
-    warning ("duplicate `volatile'");
-  virtualp = specbits & RIDBIT (RID_VIRTUAL);
-  if (specbits & RIDBIT (RID_STATIC))
-    staticp = 1 + (decl_context == FIELD);
-
-  if (virtualp && staticp == 2)
-    {
-      error ("member `%s' cannot be declared both virtual and static", name);
-      staticp = 0;
-    }
-  friendp = specbits & RIDBIT (RID_FRIEND);
-  specbits &= ~ (RIDBIT (RID_VIRTUAL) | RIDBIT (RID_FRIEND));
-
-  /* Warn if two storage classes are given. Default to `auto'.  */
-
-  if (specbits)
-    {
-      if (specbits & RIDBIT (RID_STATIC)) nclasses++;
-      if (specbits & RIDBIT (RID_EXTERN)) nclasses++;
-      if (decl_context == PARM && nclasses > 0)
-	error ("storage class specifiers invalid in parameter declarations");
-      if (specbits & RIDBIT (RID_TYPEDEF))
-	{
-	  if (decl_context == PARM)
-	    error ("typedef declaration invalid in parameter declaration");
-	  nclasses++;
-	}
-      if (specbits & RIDBIT (RID_AUTO)) nclasses++;
-      if (specbits & RIDBIT (RID_REGISTER)) nclasses++;
-    }
-
-  /* Give error if `virtual' is used outside of class declaration.  */
-  if (virtualp && current_class_name == NULL_TREE)
-    {
-      error ("virtual outside class declaration");
-      virtualp = 0;
-    }
-
-  /* Warn about storage classes that are invalid for certain
-     kinds of declarations (parameters, typenames, etc.).  */
-
-  if (nclasses > 1)
-    error ("multiple storage classes in declaration of `%s'", name);
-  else if (decl_context != NORMAL && nclasses > 0)
-    {
-      if (decl_context == PARM
-	  && ((specbits & RIDBIT (RID_REGISTER)) | RIDBIT (RID_AUTO)))
-	;
-      else if ((decl_context == FIELD
-		|| decl_context == TYPENAME)
-	       && (specbits & RIDBIT (RID_TYPEDEF)))
-	{
-	  /* A typedef which was made in a class's scope.  */
-	  tree loc_typedecl;
-	  register int i = sizeof (struct lang_decl_flags) / sizeof (int);
-	  register int *pi;
-	  struct binding_level *local_binding_level;
-
-	  /* keep `grokdeclarator' from thinking we are in PARM context.  */
-	  pushlevel (0);
-  	  /* poplevel_class may be called by grokdeclarator which is called in
-  	     start_decl which is called below. In this case, our pushed level
-  	     may vanish and poplevel mustn't be called. So remember what we
-  	     have pushed and pop only if that is matched by 
-  	     current_binding_level later. mnl@dtro.e-technik.th-darmstadt.de */
-  	  local_binding_level = current_binding_level;
-
-	  loc_typedecl = start_decl (declarator, declspecs, initialized, NULL_TREE);
-
-	  pi = (int *) permalloc (sizeof (struct lang_decl_flags));
-	  while (i > 0)
-	    pi[--i] = 0;
-	  DECL_LANG_SPECIFIC (loc_typedecl) = (struct lang_decl *) pi;
-	  /* This poplevel conflicts with the popclass over in
-	     grokdeclarator.  See ``This popclass conflicts'' */
-	  if (current_binding_level == local_binding_level)
-	    poplevel (0, 0, 0);
-
-#if 0
-	  if (TREE_CODE (TREE_TYPE (loc_typedecl)) == ENUMERAL_TYPE)
-	    {
-	      tree ref = lookup_tag (ENUMERAL_TYPE, DECL_NAME (loc_typedecl), current_binding_level, 0);
-	      if (! ref)
-		pushtag (DECL_NAME (loc_typedecl), TREE_TYPE (loc_typedecl));
-	    }
-#endif
-
-	  /* We used to check for a typedef hiding a previous decl in
-	     class scope, but delete_duplicate_fields_1 will now do
-	     that for us in the proper place.  */
-
-	  /* We reset loc_typedecl because the IDENTIFIER_CLASS_NAME is
-	     set by pushdecl_class_level.  */
-	  loc_typedecl = pushdecl_class_level (loc_typedecl);
-
-	  return loc_typedecl;
-	}
-      else if (decl_context == FIELD
- 	       /* C++ allows static class elements  */
- 	       && (specbits & RIDBIT (RID_STATIC)))
- 	/* C++ also allows inlines and signed and unsigned elements,
- 	   but in those cases we don't come in here.  */
-	;
-      else
-	{
-	  if (decl_context == FIELD)
-	    {
-	      tree tmp = TREE_OPERAND (declarator, 0);
-	      register int op = IDENTIFIER_OPNAME_P (tmp);
-	      error ("storage class specified for %s `%s'",
-		     op ? "member operator" : "structure field",
-		     op ? operator_name_string (tmp) : name);
-	    }
-	  else
-	    error ((decl_context == PARM
-		    ? "storage class specified for parameter `%s'"
-		    : "storage class specified for typename"), name);
-	  specbits &= ~ (RIDBIT (RID_REGISTER) | RIDBIT (RID_AUTO)
-			 | RIDBIT (RID_EXTERN));
-	}
-    }
-  else if ((specbits & RIDBIT (RID_EXTERN)) && initialized && !funcdef_flag)
-    {
-      if (current_binding_level == global_binding_level)
-	{
-	  /* It's common practice (and completely legal) to have a const
-	     be initialized and declared extern.  */
-	  if (! constp)
-	    warning ("`%s' initialized and declared `extern'", name);
-	}
-      else
-	error ("`%s' has both `extern' and initializer", name);
-    }
-  else if ((specbits & RIDBIT (RID_EXTERN)) && funcdef_flag
-	   && current_binding_level != global_binding_level)
-    error ("nested function `%s' declared `extern'", name);
-  else if (current_binding_level == global_binding_level)
-    {
-      if (specbits & RIDBIT (RID_AUTO))
-	error ("top-level declaration of `%s' specifies `auto'", name);
-#if 0
-      if (specbits & RIDBIT (RID_REGISTER))
-	error ("top-level declaration of `%s' specifies `register'", name);
-#endif
-#if 0
-      /* I'm not sure under what circumstances we should turn
-	 on the extern bit, and under what circumstances we should
-	 warn if other bits are turned on.  */
-      if (decl_context == NORMAL
-	  && ! (specbits & RIDBIT (RID_EXTERN))
-	  && ! root_lang_context_p ())
-	{
-	  specbits |= RIDBIT (RID_EXTERN);
-	}
-#endif
-    }
-
-  /* Now figure out the structure of the declarator proper.
-     Descend through it, creating more complex types, until we reach
-     the declared identifier (or NULL_TREE, in an absolute declarator).  */
-
-  while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
-    {
-      /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
-	 an INDIRECT_REF (for *...),
-	 a CALL_EXPR (for ...(...)),
-	 an identifier (for the name being declared)
-	 or a null pointer (for the place in an absolute declarator
-	 where the name was omitted).
-	 For the last two cases, we have just exited the loop.
-
-	 For C++ it could also be
-	 a SCOPE_REF (for class :: ...).  In this case, we have converted
-	 sensible names to types, and those are the values we use to
-	 qualify the member name.
-	 an ADDR_EXPR (for &...),
-	 a BIT_NOT_EXPR (for destructors)
-	 a TYPE_EXPR (for operator typenames)
-
-	 At this point, TYPE is the type of elements of an array,
-	 or for a function to return, or for a pointer to point to.
-	 After this sequence of ifs, TYPE is the type of the
-	 array or function or pointer, and DECLARATOR has had its
-	 outermost layer removed.  */
-
-      if (TREE_CODE (type) == ERROR_MARK)
-	{
-	  if (TREE_CODE (declarator) == SCOPE_REF)
-	    declarator = TREE_OPERAND (declarator, 1);
-	  else
-	    declarator = TREE_OPERAND (declarator, 0);
-	  continue;
-	}
-      if (quals != NULL_TREE
-	  && (declarator == NULL_TREE
-	      || TREE_CODE (declarator) != SCOPE_REF))
-	{
-	  if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
-	    ctype = TYPE_METHOD_BASETYPE (type);
-	  if (ctype != NULL_TREE)
-	    {
-#if 0 /* not yet, should get fixed properly later */
-	      tree dummy = make_type_decl (NULL_TREE, type);
-#else
-	      tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
-#endif
-	      ctype = grok_method_quals (ctype, dummy, quals);
-	      type = TREE_TYPE (dummy);
-	      quals = NULL_TREE;
-	    }
-	}
-      switch (TREE_CODE (declarator))
-	{
-	case ARRAY_REF:
-	  maybe_globalize_type (type);
-	  {
-	    register tree itype = NULL_TREE;
-	    register tree size = TREE_OPERAND (declarator, 1);
-
-	    declarator = TREE_OPERAND (declarator, 0);
-
-	    /* Check for some types that there cannot be arrays of.  */
-
-	    if (TYPE_MAIN_VARIANT (type) == void_type_node)
-	      {
-		error ("declaration of `%s' as array of voids", name);
-		type = error_mark_node;
-	      }
-
-	    if (TREE_CODE (type) == FUNCTION_TYPE)
-	      {
-		error ("declaration of `%s' as array of functions", name);
-		type = error_mark_node;
-	      }
-
-	    /* ARM $8.4.3: Since you can't have a pointer to a reference,
-	       you can't have arrays of references.  If we allowed them,
-	       then we'd be saying x[i] is legal for an array x, but
-	       then you'd have to ask: what does `*(x + i)' mean?  */
-	    if (TREE_CODE (type) == REFERENCE_TYPE)
-	      error ("declaration of `%s' as array of references", name);
-
-	    if (size == error_mark_node)
-	      type = error_mark_node;
-
-	    if (type == error_mark_node)
-	      continue;
-
-	    if (size)
-	      {
-		/* Must suspend_momentary here because the index
-		   type may need to live until the end of the function.
-		   For example, it is used in the declaration of a
-		   variable which requires destructing at the end of
-		   the function; then build_vec_delete will need this
-		   value.  */
-		int yes = suspend_momentary ();
-		/* might be a cast */
-		if (TREE_CODE (size) == NOP_EXPR
-		    && TREE_TYPE (size) == TREE_TYPE (TREE_OPERAND (size, 0)))
-		  size = TREE_OPERAND (size, 0);
-
-		/* If this is a template parameter, it'll be constant, but
-		   we don't know what the value is yet.  */
-		if (TREE_CODE (size) == TEMPLATE_CONST_PARM)
-		  goto dont_grok_size;
-
-		if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
-		    && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
-		  {
-		    error ("size of array `%s' has non-integer type", name);
-		    size = integer_one_node;
-		  }
-		if (TREE_READONLY_DECL_P (size))
-		  size = decl_constant_value (size);
-		if (pedantic && integer_zerop (size))
-		  pedwarn ("ANSI C++ forbids zero-size array `%s'", name);
-		if (TREE_CONSTANT (size))
-		  {
-		    if (INT_CST_LT (size, integer_zero_node))
-		      {
-			error ("size of array `%s' is negative", name);
-			size = integer_one_node;
-		      }
-		    itype = build_index_type (size_binop (MINUS_EXPR, size,
-							  integer_one_node));
-		  }
-		else
-		  {
-		    if (pedantic)
-		      pedwarn ("ANSI C++ forbids variable-size array `%s'", name);
-		  dont_grok_size:
-		    itype =
-		      build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
-		    /* Make sure the array size remains visibly nonconstant
-		       even if it is (eg) a const variable with known value.  */
-		    size_varies = 1;
-		    itype = variable_size (itype);
-		    itype = build_index_type (itype);
-		  }
-		resume_momentary (yes);
-	      }
-
-	    /* Build the array type itself.
-	       Merge any constancy or volatility into the target type.  */
-
-	    if (constp || volatilep)
-	      type = build_type_variant (type, constp, volatilep);
-
-	    type = build_cplus_array_type (type, itype);
-	    ctype = NULL_TREE;
-	  }
-	  break;
-
-	case CALL_EXPR:
-	  maybe_globalize_type (type);
-	  {
-	    tree arg_types;
-
-	    /* Declaring a function type.
-	       Make sure we have a valid type for the function to return.  */
-#if 0
-	    /* Is this an error?  Should they be merged into TYPE here?  */
-	    if (pedantic && (constp || volatilep))
-	      pedwarn ("function declared to return const or volatile result");
-#else
-	    /* Merge any constancy or volatility into the target type
-	       for the pointer.  */
-
-	    if (constp || volatilep)
-	      {
-		type = build_type_variant (type, constp, volatilep);
-		if (IS_AGGR_TYPE (type))
-		  build_pointer_type (type);
-		constp = 0;
-		volatilep = 0;
-	      }
-#endif
-
-	    /* Warn about some types functions can't return.  */
-
-	    if (TREE_CODE (type) == FUNCTION_TYPE)
-	      {
-		error ("`%s' declared as function returning a function", name);
-		type = integer_type_node;
-	      }
-	    if (TREE_CODE (type) == ARRAY_TYPE)
-	      {
-		error ("`%s' declared as function returning an array", name);
-		type = integer_type_node;
-	      }
-
-	    if (ctype == NULL_TREE
-		&& decl_context == FIELD
-		&& (friendp == 0 || dname == current_class_name))
-	      ctype = current_class_type;
-
-	    if (ctype && flags == TYPENAME_FLAG)
-	      TYPE_HAS_CONVERSION (ctype) = 1;
-	    if (ctype && constructor_name (ctype) == dname)
-	      {
-		/* We are within a class's scope. If our declarator name
-		   is the same as the class name, and we are defining
-		   a function, then it is a constructor/destructor, and
-		   therefore returns a void type.  */
-
-		if (flags == DTOR_FLAG)
-		  {
-		    /* ANSI C++ June 5 1992 WP 12.4.1.  A destructor may
-		       not be declared const or volatile.  A destructor
-		       may not be static.  */
-		    if (staticp == 2)
-		      error ("destructor cannot be static member function");
-		    if (TYPE_READONLY (type))
-		      {
-			error ("destructors cannot be declared `const'");
-			return void_type_node;
-		      }
-		    if (TYPE_VOLATILE (type))
-		      {
-			error ("destructors cannot be declared `volatile'");
-			return void_type_node;
-		      }
-		    if (decl_context == FIELD)
-		      {
-			if (! member_function_or_else (ctype, current_class_type,
-						       "destructor for alien class `%s' cannot be a member"))
-			  return void_type_node;
-		      }
-		  }
-		else            /* it's a constructor. */
-		  {
-		    /* ANSI C++ June 5 1992 WP 12.1.2.  A constructor may
-		       not be declared const or volatile.  A constructor may
-		       not be virtual.  A constructor may not be static.  */
-		    if (staticp == 2)
-		      error ("constructor cannot be static member function");
-		    if (virtualp)
-		      {
-			pedwarn ("constructors cannot be declared virtual");
-			virtualp = 0;
-		      }
-		    if (TYPE_READONLY (type))
-		      {
-			error ("constructors cannot be declared `const'");
-			return void_type_node;
- 		      }
-		    if (TYPE_VOLATILE (type))
-		      {
-			error ("constructors cannot be declared `volatile'");
-			return void_type_node;
-		      }
-		    if (specbits & ~(RIDBIT (RID_INLINE)|RIDBIT (RID_STATIC)))
-		      error ("return value type specifier for constructor ignored");
-		    type = TYPE_POINTER_TO (ctype);
-		    if (decl_context == FIELD)
-		      {
-			if (! member_function_or_else (ctype, current_class_type,
-						       "constructor for alien class `%s' cannot be member"))
-			  return void_type_node;
-			TYPE_HAS_CONSTRUCTOR (ctype) = 1;
-			if (return_type != return_ctor)
-			  return NULL_TREE;
-		      }
-		  }
-		if (decl_context == FIELD)
-		  staticp = 0;
-	      }
-	    else if (friendp && virtualp)
-	      {
-		/* Cannot be both friend and virtual.  */
-		error ("virtual functions cannot be friends");
-		specbits &= ~ RIDBIT (RID_FRIEND);
-	      }
-
-	    if (decl_context == NORMAL && friendp)
-	      error ("friend declaration not in class definition");
-
-	    /* Pick up type qualifiers which should be applied to `this'.  */
-	    quals = TREE_OPERAND (declarator, 2);
-
-	    /* Traditionally, declaring return type float means double.  */
-
-	    if (flag_traditional
-		&& TYPE_MAIN_VARIANT (type) == float_type_node)
-	      {
-		type = build_type_variant (double_type_node,
-					   TYPE_READONLY (type),
-					   TYPE_VOLATILE (type));
-	      }
-
-	    /* Construct the function type and go to the next
-	       inner layer of declarator.  */
-
-	    {
-	      int funcdef_p;
-	      tree inner_parms = TREE_OPERAND (declarator, 1);
-	      tree inner_decl = TREE_OPERAND (declarator, 0);
-
-	      declarator = TREE_OPERAND (declarator, 0);
-
-	      if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
-		inner_decl = TREE_OPERAND (inner_decl, 1);
-
-	      /* Say it's a definition only for the CALL_EXPR
-		 closest to the identifier.  */
-	      funcdef_p =
-		(inner_decl &&
-		 (TREE_CODE (inner_decl) == IDENTIFIER_NODE
-		  || TREE_CODE (inner_decl) == TYPE_EXPR)) ? funcdef_flag : 0;
-
-	      arg_types = grokparms (inner_parms, funcdef_p);
-	    }
-
-	    if (declarator)
-	      {
-		/* Get past destructors, etc.
-		   We know we have one because FLAGS will be non-zero.
-
-		   Complain about improper parameter lists here.  */
-		if (TREE_CODE (declarator) == BIT_NOT_EXPR)
-		  {
-		    declarator = TREE_OPERAND (declarator, 0);
-
-		    if (strict_prototype == 0 && arg_types == NULL_TREE)
-		      arg_types = void_list_node;
-		    else if (arg_types == NULL_TREE
-			     || arg_types != void_list_node)
-		      {
-			error ("destructors cannot be specified with parameters");
-			arg_types = void_list_node;
-		      }
-		  }
-	      }
-	    /* the top level const or volatile is attached semantically only
-	       to the function not the actual type. */
-	    if (TYPE_READONLY (type) || TYPE_VOLATILE (type))
-	      {
-		int constp = TYPE_READONLY (type);
-		int volatilep = TYPE_VOLATILE (type);
-		type = build_function_type (TYPE_MAIN_VARIANT (type),
-					    flag_traditional
-					    ? 0
-					    : arg_types);
-		type = build_type_variant (type, constp, volatilep);
-	      }
-	    else
-	      type = build_function_type (type,
-					  flag_traditional
-					  ? 0
-					  : arg_types);
-	  }
-	  break;
-
-	case ADDR_EXPR:
-	case INDIRECT_REF:
-	  maybe_globalize_type (type);
-
-	  /* Filter out pointers-to-references and references-to-references.
-	     We can get these if a TYPE_DECL is used.  */
-
-	  if (TREE_CODE (type) == REFERENCE_TYPE)
-	    {
-	      error ("cannot declare %s to references",
-		     TREE_CODE (declarator) == ADDR_EXPR
-		     ? "references" : "pointers");
-	      declarator = TREE_OPERAND (declarator, 0);
-	      continue;
-	    }
-
-	  /* Merge any constancy or volatility into the target type
-	     for the pointer.  */
-
-	  if (constp || volatilep)
-	    {
-	      type = build_type_variant (type, constp, volatilep);
-	      if (IS_AGGR_TYPE (type))
-		build_pointer_type (type);
-	      constp = 0;
-	      volatilep = 0;
-	    }
-
-	  if (TREE_CODE (declarator) == ADDR_EXPR)
-	    {
-	      if (TREE_CODE (type) == FUNCTION_TYPE)
-		{
-		  error ("cannot declare references to functions; use pointer to function instead");
-		  type = build_pointer_type (type);
-		}
-	      else
-		{
-		  if (TYPE_MAIN_VARIANT (type) == void_type_node)
-		    error ("invalid type: `void &'");
-		  else
-		    type = build_reference_type (type);
-		}
-	    }
-	  else
-	    type = build_pointer_type (type);
-
-	  /* Process a list of type modifier keywords (such as
-	     const or volatile) that were given inside the `*' or `&'.  */
-
-	  if (TREE_TYPE (declarator))
-	    {
-	      register tree typemodlist;
-	      int erred = 0;
-	      for (typemodlist = TREE_TYPE (declarator); typemodlist;
-		   typemodlist = TREE_CHAIN (typemodlist))
-		{
-		  if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
-		    constp++;
-		  else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
-		    volatilep++;
-		  else if (!erred)
-		    {
-		      erred = 1;
-		      error ("invalid type modifier within %s declarator",
-			     TREE_CODE (declarator) == ADDR_EXPR
-			     ? "reference" : "pointer");
-		    }
-		}
-	      if (constp > 1)
-		warning ("duplicate `const'");
-	      if (volatilep > 1)
-		warning ("duplicate `volatile'");
-	    }
-	  declarator = TREE_OPERAND (declarator, 0);
-	  ctype = NULL_TREE;
-	  break;
-
-	case SCOPE_REF:
-	  {
-	    /* We have converted type names to NULL_TREE if the
-	       name was bogus, or to a _TYPE node, if not.
-
-	       The variable CTYPE holds the type we will ultimately
-	       resolve to.  The code here just needs to build
-	       up appropriate member types.  */
-	    tree sname = TREE_OPERAND (declarator, 1);
-	    /* Destructors can have their visibilities changed as well.  */
-	    if (TREE_CODE (sname) == BIT_NOT_EXPR)
-	      sname = TREE_OPERAND (sname, 0);
-
-	    if (TREE_COMPLEXITY (declarator) == 0)
-	      /* This needs to be here, in case we are called
-		 multiple times.  */ ;
-	    else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
-	      /* don't fall out into global scope. Hides real bug? --eichin */ ;
-	    else if (TREE_COMPLEXITY (declarator) == current_class_depth)
-	      {
-		TREE_COMPLEXITY (declarator) -= 1;
-		/* This popclass conflicts with the poplevel over in
-		   grokdeclarator.  See ``This poplevel conflicts'' */
-		popclass (1);
-	      }
-	    else
-	      my_friendly_abort (16);
-
-	    if (TREE_OPERAND (declarator, 0) == NULL_TREE)
-	      {
-		/* We had a reference to a global decl, or
-		   perhaps we were given a non-aggregate typedef,
-		   in which case we cleared this out, and should just
-		   keep going as though it wasn't there.  */
-		declarator = sname;
-		continue;
-	      }
-	    ctype = TREE_OPERAND (declarator, 0);
-
-	    if (sname == NULL_TREE)
-	      goto done_scoping;
-
-	    if (TREE_CODE (sname) == IDENTIFIER_NODE)
-	      {
-		/* This is the `standard' use of the scoping operator:
-		   basetype :: member .  */
-
-		if (TYPE_MAIN_VARIANT (ctype) == current_class_type || friendp)
-		  {
-		    if (TREE_CODE (type) == FUNCTION_TYPE)
-		      type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
-						      TREE_TYPE (type), TYPE_ARG_TYPES (type));
-		    else
-		      {
-			if (TYPE_MAIN_VARIANT (ctype) != current_class_type)
-			  {
-			    error ("cannot declare member `%s::%s' within this class",
-				   TYPE_NAME_STRING (ctype), name);
-			    return void_type_node;
-			  }
-			else if (extra_warnings)
-			  warning ("extra qualification `%s' on member `%s' ignored",
-				   TYPE_NAME_STRING (ctype), name);
-			type = build_offset_type (ctype, type);
-		      }
-		  }
-		else if (TYPE_SIZE (ctype) != NULL_TREE
-			 || (specbits & RIDBIT (RID_TYPEDEF)))
-		  {
-		    tree t;
-		    /* have to move this code elsewhere in this function.
-		       this code is used for i.e., typedef int A::M; M *pm; */
-
-		    if (explicit_int == -1 && decl_context == FIELD
-			&& funcdef_flag == 0)
-		      {
-			/* The code in here should only be used to build
-			   stuff that will be grokked as visibility decls.  */
-			t = lookup_field (ctype, sname, 0, 0);
-			if (t)
-			  {
-			    t = build_lang_field_decl (FIELD_DECL, build_nt (SCOPE_REF, ctype, t), type);
-			    DECL_INITIAL (t) = init;
-			    return t;
-			  }
-			/* No such field, try member functions.  */
-			t = lookup_fnfields (TYPE_BINFO (ctype), sname, 0);
-			if (t)
-			  {
-			    if (flags == DTOR_FLAG)
-			      t = TREE_VALUE (t);
-			    else if (CLASSTYPE_METHOD_VEC (ctype)
-				     && TREE_VALUE (t) == TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), 0))
-			      {
-				/* Don't include destructor with constructors.  */
-				t = DECL_CHAIN (TREE_VALUE (t));
-				if (t == NULL_TREE)
-				  error ("class `%s' does not have any constructors", IDENTIFIER_POINTER (sname));
-				t = build_tree_list (NULL_TREE, t);
-			      }
-			    t = build_lang_field_decl (FIELD_DECL, build_nt (SCOPE_REF, ctype, t), type);
-			    DECL_INITIAL (t) = init;
-			    return t;
-			  }
-
-			if (flags == TYPENAME_FLAG)
-			  error_with_aggr_type (ctype, "type conversion is not a member of structure `%s'");
-			else
-			  error ("field `%s' is not a member of structure `%s'",
-				 IDENTIFIER_POINTER (sname),
-				 TYPE_NAME_STRING (ctype));
-		      }
-		    if (TREE_CODE (type) == FUNCTION_TYPE)
-		      type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
-						      TREE_TYPE (type), TYPE_ARG_TYPES (type));
-		    else
-		      {
-			if (current_class_type)
-			  {
-			    if (TYPE_MAIN_VARIANT (ctype) != current_class_type)
-			      {
-				error ("cannot declare member `%s::%s' within this class",
-				       TYPE_NAME_STRING (ctype), name);
-			      return void_type_node;
-			      }
-			    else if (extra_warnings)
-			      warning ("extra qualification `%s' on member `%s' ignored",
-				       TYPE_NAME_STRING (ctype), name);
-			  }
-			type = build_offset_type (ctype, type);
-		      }
-		  }
-		else if (uses_template_parms (ctype))
-		  {
-                    enum tree_code c;
-                    if (TREE_CODE (type) == FUNCTION_TYPE)
-		      {
-			type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
-							TREE_TYPE (type),
-							TYPE_ARG_TYPES (type));
-			c = FUNCTION_DECL;
-		      }
-  		  }
-		else
-		  sorry ("structure `%s' not yet defined",
-			 TYPE_NAME_STRING (ctype));
-		declarator = sname;
-	      }
-	    else if (TREE_CODE (sname) == TYPE_EXPR)
-	      {
-		/* A TYPE_EXPR will change types out from under us.
-		   So do the TYPE_EXPR now, and make this SCOPE_REF
-		   inner to the TYPE_EXPR's CALL_EXPR.
-
-		   This does not work if we don't get a CALL_EXPR back.
-		   I did not think about error recovery, hence the
-		   my_friendly_abort.  */
-
-		/* Get the CALL_EXPR.  */
-		sname = grokoptypename (sname, 0);
-		my_friendly_assert (TREE_CODE (sname) == CALL_EXPR, 157);
-		type = TREE_TYPE (TREE_OPERAND (sname, 0));
-		/* Scope the CALL_EXPR's name.  */
-		TREE_OPERAND (declarator, 1) = TREE_OPERAND (sname, 0);
-		/* Put the SCOPE_EXPR in the CALL_EXPR's innermost position.  */
-		TREE_OPERAND (sname, 0) = declarator;
-		/* Now work from the CALL_EXPR.  */
-		declarator = sname;
-		continue;
-	      }
-	    else if (TREE_CODE (sname) == SCOPE_REF)
-	      my_friendly_abort (17);
-	    else
-	      {
-	      done_scoping:
-		declarator = TREE_OPERAND (declarator, 1);
-		if (declarator && TREE_CODE (declarator) == CALL_EXPR)
-		  /* In this case, we will deal with it later.  */
-		  ;
-		else
-		  {
-		    if (TREE_CODE (type) == FUNCTION_TYPE)
-		      type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep), TREE_TYPE (type), TYPE_ARG_TYPES (type));
-		    else
-		      type = build_offset_type (ctype, type);
-		  }
-	      }
-	  }
-	  break;
-
-	case BIT_NOT_EXPR:
-	  declarator = TREE_OPERAND (declarator, 0);
-	  break;
-
-	case TYPE_EXPR:
-	  declarator = grokoptypename (declarator, 0);
-	  if (explicit_int != -1)
-	    if (comp_target_types (type,
-				   TREE_TYPE (TREE_OPERAND (declarator, 0)),
-				   1) == 0)
-	      error ("type conversion function declared to return incongruent type");
-	    else
-	      pedwarn ("return type specified for type conversion function");
-	  type = TREE_TYPE (TREE_OPERAND (declarator, 0));
-	  maybe_globalize_type (type);
-	  break;
-
-	case RECORD_TYPE:
-	case UNION_TYPE:
-	case ENUMERAL_TYPE:
-	  declarator = NULL_TREE;
-	  break;
-
-	case ERROR_MARK:
-	  declarator = NULL_TREE;
-	  break;
-
-	default:
-	  my_friendly_abort (158);
-	}
-    }
-
-  /* Now TYPE has the actual type.  */
-
-  /* If this is declaring a typedef name, return a TYPE_DECL.  */
-
-  if (specbits & RIDBIT (RID_TYPEDEF))
-    {
-      tree decl;
-
-      /* Note that the grammar rejects storage classes
-	 in typenames, fields or parameters.  */
-      if (constp || volatilep)
-	type = build_type_variant (type, constp, volatilep);
-
-      /* If the user declares "struct {...} foo" then `foo' will have
-	 an anonymous name.  Fill that name in now.  Nothing can
-	 refer to it, so nothing needs know about the name change.
-	 The TYPE_NAME field was filled in by build_struct_xref.  */
-      if (TYPE_NAME (type)
-	  && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
-	  && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
-	{
-	  /* replace the anonymous name with the real name everywhere.  */
-	  lookup_tag_reverse (type, declarator);
-	  TYPE_IDENTIFIER (type) = declarator;
-	}
-
-#if 0 /* not yet, should get fixed properly later */
-      decl = make_type_decl (declarator, type);
-#else
-      decl = build_decl (TYPE_DECL, declarator, type);
-#endif
-      if (quals)
-	{
-	  if (ctype == NULL_TREE)
-	    {
-	      if (TREE_CODE (type) != METHOD_TYPE)
-		error_with_decl (decl, "invalid type qualifier for non-method type");
-	      else
-		ctype = TYPE_METHOD_BASETYPE (type);
-	    }
-	  if (ctype != NULL_TREE)
-	    grok_method_quals (ctype, decl, quals);
-	}
-
-      if ((specbits & RIDBIT (RID_SIGNED))
-	  || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
-	C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
-
-      return decl;
-    }
-
-  /* Detect the case of an array type of unspecified size
-     which came, as such, direct from a typedef name.
-     We must copy the type, so that each identifier gets
-     a distinct type, so that each identifier's size can be
-     controlled separately by its own initializer.  */
-
-  if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
-      && TYPE_DOMAIN (type) == NULL_TREE)
-    {
-      type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
-    }
-
-  /* If this is a type name (such as, in a cast or sizeof),
-     compute the type and return it now.  */
-
-  if (decl_context == TYPENAME)
-    {
-      /* Note that the grammar rejects storage classes
-	 in typenames, fields or parameters.  */
-      if (constp || volatilep)
-	type = build_type_variant (type, constp, volatilep);
-
-      /* Special case: "friend class foo" looks like a TYPENAME context.  */
-      if (friendp)
-	{
-	  /* A friendly class?  */
-	  if (current_class_type)
-	    make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
-	  else
-	    error("trying to make class `%s' a friend of global scope",
-		  TYPE_NAME_STRING (type));
-	  type = void_type_node;
-	}
-      else if (quals)
-	{
-#if 0 /* not yet, should get fixed properly later */
-	  tree dummy = make_type_decl (declarator, type);
-#else
-	  tree dummy = build_decl (TYPE_DECL, declarator, type);
-#endif
-	  if (ctype == NULL_TREE)
-	    {
-	      my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
-	      ctype = TYPE_METHOD_BASETYPE (type);
-	    }
-	  grok_method_quals (ctype, dummy, quals);
-	  type = TREE_TYPE (dummy);
-	}
-
-      return type;
-    }
-
-  /* `void' at top level (not within pointer)
-     is allowed only in typedefs or type names.
-     We don't complain about parms either, but that is because
-     a better error message can be made later.  */
-
-  if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM)
-    {
-      if (declarator != NULL_TREE
-	  && TREE_CODE (declarator) == IDENTIFIER_NODE)
-	{
-	  if (IDENTIFIER_OPNAME_P (declarator))
-	    error ("operator `%s' declared void",
-		   operator_name_string (declarator));
-	  else
-	    error ("variable or field `%s' declared void", name);
-	}
-      else
-	error ("variable or field declared void");
-      type = integer_type_node;
-    }
-
-  /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
-     or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
-
-  {
-    register tree decl;
-
-    if (decl_context == PARM)
-      {
-	tree parmtype = type;
-
-	if (ctype)
-	  error ("cannot use `::' in parameter declaration");
-	bad_specifiers ("parameter", virtualp, quals != NULL_TREE,
-			friendp, raises != NULL_TREE);
-
-	/* A parameter declared as an array of T is really a pointer to T.
-	   One declared as a function is really a pointer to a function.
-	   One declared as a member is really a pointer to member.
-
-	   Don't be misled by references.  */
-
-	if (TREE_CODE (type) == REFERENCE_TYPE)
-	  type = TREE_TYPE (type);
-
-	if (TREE_CODE (type) == ARRAY_TYPE)
-	  {
-	    if (parmtype == type)
-	      {
-		/* Transfer const-ness of array into that of type
-		   pointed to.  */
-		type = build_pointer_type
-		  (build_type_variant (TREE_TYPE (type), constp, volatilep));
-		volatilep = constp = 0;
-	      }
-	    else
-	      type = build_pointer_type (TREE_TYPE (type));
-	  }
-	else if (TREE_CODE (type) == FUNCTION_TYPE)
-	  type = build_pointer_type (type);
-	else if (TREE_CODE (type) == OFFSET_TYPE)
-	  type = build_pointer_type (type);
-
-	if (TREE_CODE (parmtype) == REFERENCE_TYPE)
-	  {
-	    /* Transfer const-ness of reference into that of type pointed to.  */
-	    type = build_type_variant (build_reference_type (type), constp, volatilep);
-	    constp = volatilep = 0;
-	  }
-
-	decl = build_decl (PARM_DECL, declarator, type);
-
-	/* Compute the type actually passed in the parmlist,
-	   for the case where there is no prototype.
-	   (For example, shorts and chars are passed as ints.)
-	   When there is a prototype, this is overridden later.  */
-
-	DECL_ARG_TYPE (decl) = type;
-	if (TYPE_MAIN_VARIANT (type) == float_type_node)
-	  DECL_ARG_TYPE (decl) = build_type_variant (double_type_node,
-						     TYPE_READONLY (type),
-						     TYPE_VOLATILE (type));
-	else if (C_PROMOTING_INTEGER_TYPE_P (type))
-	  {
-	    tree argtype;
-
-	    /* Retain unsignedness if traditional or if not really
-	       getting wider.  */
-	    if (TREE_UNSIGNED (type)
-		&& (flag_traditional
-		    || TYPE_PRECISION (type)
-			== TYPE_PRECISION (integer_type_node)))
-	      argtype = unsigned_type_node;
-	    else
-	      argtype = integer_type_node;
-	    DECL_ARG_TYPE (decl) = build_type_variant (argtype,
-						       TYPE_READONLY (type),
-						       TYPE_VOLATILE (type));
-	  }
-      }
-    else if (decl_context == FIELD)
-      {
-	if (type == error_mark_node)
-	  {
-	    /* Happens when declaring arrays of sizes which
-	       are error_mark_node, for example.  */
-	    decl = NULL_TREE;
-	  }
-	else if (TREE_CODE (type) == FUNCTION_TYPE)
-	  {
-	    int publicp = 0;
-
-	    if (friendp == 0)
-	      {
-		if (ctype == NULL_TREE)
-		  ctype = current_class_type;
-
-		if (ctype == NULL_TREE)
-		  {
-		    register int op = IDENTIFIER_OPNAME_P (declarator);
-		    error ("can't make %s `%s' into a method -- not in a class",
-			   op ? "operator" : "function",
-			   op ? operator_name_string (declarator) : IDENTIFIER_POINTER (declarator));
-		    return void_type_node;
-		  }
-
-		/* ``A union may [ ... ] not [ have ] virtual functions.''
-		   ARM 9.5 */
-		if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
-		  {
-		    error ("function `%s' declared virtual inside a union",
-			   IDENTIFIER_POINTER (declarator));
-		    return void_type_node;
-		  }
-
-		/* Don't convert type of operators new and delete to
-		   METHOD_TYPE; they remain FUNCTION_TYPEs.  */
-		if (staticp < 2
-		    && declarator != ansi_opname[(int) NEW_EXPR]
-		    && declarator != ansi_opname[(int) DELETE_EXPR])
-		  type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
-						  TREE_TYPE (type), TYPE_ARG_TYPES (type));
-	      }
-
-	    /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
-	    publicp = ((specbits & RIDBIT (RID_EXTERN))
-		       || (ctype != NULL_TREE && funcdef_flag >= 0)
-#if 0
-		       /* These are replicated in each object, so we shouldn't
-			  set TREE_PUBLIC. */
-		       || (friendp
-			   && !(specbits & RIDBIT (RID_STATIC))
-			   && !(specbits & RIDBIT (RID_INLINE)))
-#endif
-		       );
-	    decl = grokfndecl (ctype, type, declarator,
-			       virtualp, flags, quals,
-			       raises, friendp ? -1 : 0, publicp);
-	    DECL_INLINE (decl) = inlinep;
-	  }
-	else if (TREE_CODE (type) == METHOD_TYPE)
-	  {
-	    /* All method decls are public, so tell grokfndecl to set
-	       TREE_PUBLIC, also.  */
-	    decl = grokfndecl (ctype, type, declarator,
-			       virtualp, flags, quals,
-			       raises, friendp ? -1 : 0, 1);
-	    DECL_INLINE (decl) = inlinep;
-	  }
-	else if (TREE_CODE (type) == RECORD_TYPE
-		 && CLASSTYPE_DECLARED_EXCEPTION (type))
-	  {
-	    /* Handle a class-local exception declaration.  */
-	    decl = build_lang_field_decl (VAR_DECL, declarator, type);
-	    if (ctype == NULL_TREE)
-	      ctype = current_class_type;
-	    finish_exception_decl (TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
-				   ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype), decl);
-	    return void_type_node;
-	  }
-	else if (TYPE_SIZE (type) == NULL_TREE && !staticp
-		 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
-	  {
-	    if (declarator)
-	      error ("field `%s' has incomplete type",
-		     IDENTIFIER_POINTER (declarator));
-	    else
-	      error ("field has incomplete type");
-
-	    /* If we're instantiating a template, tell them which
-	       instantiation made the field's type be incomplete.  */
-	    if (current_class_type
-		&& IDENTIFIER_TEMPLATE (current_class_type)
-		&& declspecs && TREE_VALUE (declspecs)
-		&& TREE_TYPE (TREE_VALUE (declspecs)) == type)
-	      error ("  in instantiation of template `%s'",
-		     TYPE_NAME_STRING (current_class_type));
-		
-	    type = error_mark_node;
-	    decl = NULL_TREE;
-	  }
-	else
-	  {
-	    if (friendp)
-	      {
-		if (declarator)
-		  error ("`%s' is neither function nor method; cannot be declared friend",
-			 IDENTIFIER_POINTER (declarator));
-		else
-		  {
-		    error ("invalid friend declaration");
-		    return void_type_node;
-		  }
-		friendp = 0;
-	      }
-	    decl = NULL_TREE;
-	  }
-
-	if (friendp)
-	  {
-	    tree t;
-
-	    /* Friends are treated specially.  */
-	    if (ctype == current_class_type)
-	      warning ("member functions are implicitly friends of their class");
-	    else if (decl && (t = DECL_NAME (decl)))
-	      {
-		/* ARM $13.4.3 */
-		if (t == ansi_opname[(int) MODIFY_EXPR])
-		  pedwarn ("operator `=' must be a member function");
-		else
-		  return do_friend (ctype, declarator, decl,
-				    last_function_parms, flags, quals);
-	      }
-	    else return void_type_node;
-	  }
-
-	/* Structure field.  It may not be a function, except for C++ */
-
-	if (decl == NULL_TREE)
-	  {
-	    bad_specifiers ("field", virtualp, quals != NULL_TREE,
-			    friendp, raises != NULL_TREE);
-
-	    /* ANSI C++ June 5 1992 WP 9.2.2 and 9.4.2.  A member-declarator
-	       cannot have an initializer, and a static member declaration must
-	       be defined elsewhere.  */
-	    if (initialized)
-	      {
-		if (staticp)
-		  error ("static member `%s' must be defined separately from its declaration",
-			  IDENTIFIER_POINTER (declarator));
-		/* Note that initialization of const members is not
-		   mentioned in the ARM or draft ANSI standard explicitly,
-		   and it appears to be in common practice.  However,
-		   reading the draft section 9.2.2, it does say that a
-		   member declarator can't have an initializer--it does
-		   not except constant members, which also qualify as
-		   member-declarators.  */
-		else if (!pedantic && (!constp || flag_ansi))
-		  warning ("ANSI C++ forbids initialization of %s `%s'",
-			   constp ? "const member" : "member",
-			   IDENTIFIER_POINTER (declarator));
-	      }
-
-	    if (staticp || (constp && initialized))
-	      {
-		/* C++ allows static class members.
-		   All other work for this is done by grokfield.
-		   This VAR_DECL is built by build_lang_field_decl.
-		   All other VAR_DECLs are built by build_decl.  */
-		decl = build_lang_field_decl (VAR_DECL, declarator, type);
-		if (staticp || TREE_CODE (type) == ARRAY_TYPE)
-		  TREE_STATIC (decl) = 1;
-		/* In class context, static means public visibility.  */
-		TREE_PUBLIC (decl) = 1;
-		DECL_EXTERNAL (decl) = !initialized;
-	      }
-	    else
-	      decl = build_lang_field_decl (FIELD_DECL, declarator, type);
-	  }
-      }
-    else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
-      {
-	int was_overloaded = 0;
-	tree original_name = declarator;
-	int publicp = 0;
-
-	if (! declarator) return NULL_TREE;
-
-	if (specbits & (RIDBIT (RID_AUTO) | RIDBIT (RID_REGISTER)))
-	  error ("invalid storage class for function `%s'", name);
-	/* Function declaration not at top level.
-	   Storage classes other than `extern' are not allowed
-	   and `extern' makes no difference.  */
-	if (current_binding_level != global_binding_level
-	    && (specbits & (RIDBIT (RID_STATIC) | RIDBIT (RID_INLINE)))
-	    && pedantic)
-	  pedwarn ("invalid storage class for function `%s'", name);
-
-	if (ctype == NULL_TREE)
-	  {
-	    if (virtualp)
-	      {
-		error ("virtual non-class function `%s'", name);
-		virtualp = 0;
-	      }
-
-	    /* ARM $13.4.3 */
-	    /* XXX: It's likely others should also be forbidden.  (bpk) */
-	    if (declarator == ansi_opname[(int) MODIFY_EXPR])
-	      warning ("operator `=' must be a member function");
-
-	    if (current_lang_name == lang_name_cplusplus
-		&& ! (IDENTIFIER_LENGTH (original_name) == 4
-		      && IDENTIFIER_POINTER (original_name)[0] == 'm'
-		      && strcmp (IDENTIFIER_POINTER (original_name), "main") == 0)
-		&& ! (IDENTIFIER_LENGTH (original_name) > 10
-		      && IDENTIFIER_POINTER (original_name)[0] == '_'
-		      && IDENTIFIER_POINTER (original_name)[1] == '_'
-		      && strncmp (IDENTIFIER_POINTER (original_name)+2, "builtin_", 8) == 0))
-	      {
-		/* Plain overloading: will not be grok'd by grokclassfn.  */
-		declarator = build_decl_overload (dname, TYPE_ARG_TYPES (type), 0);
-		was_overloaded = 1;
-	      }
-	  }
-	else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
-	  type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
-					  TREE_TYPE (type), TYPE_ARG_TYPES (type));
-
-	/* Record presence of `static'.  In C++, `inline' is like `static'.
-	   Methods of classes should be public, unless we're dropping them
-	   into some other file, so we don't clear TREE_PUBLIC for them.  */
-	publicp
-	  = ((ctype
-	      && ! CLASSTYPE_INTERFACE_UNKNOWN (ctype)
-	      && ! CLASSTYPE_INTERFACE_ONLY (ctype))
-	    || !(specbits & (RIDBIT (RID_STATIC)
-			     | RIDBIT (RID_INLINE))));
-
-	decl = grokfndecl (ctype, type, original_name,
-			   virtualp, flags, quals,
-			   raises,
-			   processing_template_decl ? 0 : friendp ? 2 : 1,
-			   publicp);
-
-	if (ctype == NULL_TREE)
-	  DECL_ASSEMBLER_NAME (decl) = declarator;
-
-	if (staticp == 1)
-	  {
-	    int illegal_static = 0;
-
-	    /* Don't allow a static member function in a class, and forbid
-	       declaring main to be static.  */
-	    if (TREE_CODE (type) == METHOD_TYPE)
-	      {
-		error_with_decl (decl,
-				 "cannot declare member function `%s' to have static linkage");
-		illegal_static = 1;
-	      }
-	    else if (! was_overloaded
-		     && ! ctype
-		     && IDENTIFIER_LENGTH (original_name) == 4
-		     && IDENTIFIER_POINTER (original_name)[0] == 'm'
-		     && ! strcmp (IDENTIFIER_POINTER (original_name), "main"))
-	      {
-		error ("cannot declare function `main' to have static linkage");
-		illegal_static = 1;
-	      }
-
-	    if (illegal_static)
-	      {
-		staticp = 0;
-		specbits &= ~ RIDBIT (RID_STATIC);
-	      }
-	  }
-
-	/* Record presence of `inline', if it is reasonable.  */
-	if (inlinep)
-	  {
-	    tree last = tree_last (TYPE_ARG_TYPES (type));
-
-	    if (! was_overloaded
-		&& ! ctype
-		&& ! strcmp (IDENTIFIER_POINTER (original_name), "main"))
-	      warning ("cannot inline function `main'");
-	    else if (last && last != void_list_node)
-	      warning ("inline declaration ignored for function with `...'");
-	    else
-	      /* Assume that otherwise the function can be inlined.  */
-	      DECL_INLINE (decl) = 1;
-
-	    if (specbits & RIDBIT (RID_EXTERN))
-	      {
-		current_extern_inline = 1;
-		if (pedantic)
-		  error ("ANSI C++ does not permit `extern inline'");
-		else if (flag_ansi)
-		  warning ("ANSI C++ does not permit `extern inline'");
-	      }
-	  }
-	if (was_overloaded)
-	  DECL_OVERLOADED (decl) = 1;
-      }
-    else
-      {
-	/* It's a variable.  */
-
-	bad_specifiers ("variable", virtualp, quals != NULL_TREE,
-			friendp, raises != NULL_TREE);
-	if (inlinep)
-	  warning ("variable declared `inline'");
-
-	/* An uninitialized decl with `extern' is a reference.  */
-	decl = grokvardecl (type, declarator, specbits, initialized);
-	if (ctype)
-	  {
-	    if (staticp == 1)
-	      {
-	        error ("cannot declare member `%s' to have static linkage",
-		       lang_printable_name (decl));
-	        staticp = 0;
-	        specbits &= ~ RIDBIT (RID_STATIC);
-	      }
-	    if (specbits & RIDBIT (RID_EXTERN))
-	      {
-	        error ("cannot explicitly declare member `%s' to have extern linkage",
-		       lang_printable_name (decl));
-	        specbits &= ~ RIDBIT (RID_EXTERN);
-	      }
-	  }
-      }
-
-    /* Record `register' declaration for warnings on &
-       and in case doing stupid register allocation.  */
-
-    if (specbits & RIDBIT (RID_REGISTER))
-      DECL_REGISTER (decl) = 1;
-
-    /* Record constancy and volatility.  */
-
-    if (constp)
-      TREE_READONLY (decl) = TREE_CODE (type) != REFERENCE_TYPE;
-    if (volatilep)
-      {
-	TREE_SIDE_EFFECTS (decl) = 1;
-	TREE_THIS_VOLATILE (decl) = 1;
-      }
-
-    return decl;
-  }
-}
-
-/* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
-   An empty exprlist is a parmlist.  An exprlist which
-   contains only identifiers at the global level
-   is a parmlist.  Otherwise, it is an exprlist.  */
-int
-parmlist_is_exprlist (exprs)
-     tree exprs;
-{
-  if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
-    return 0;
-
-  if (current_binding_level == global_binding_level)
-    {
-      /* At the global level, if these are all identifiers,
-	 then it is a parmlist.  */
-      while (exprs)
-	{
-	  if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
-	    return 1;
-	  exprs = TREE_CHAIN (exprs);
-	}
-      return 0;
-    }
-  return 1;
-}
-
-/* Make sure that the this list of PARMS has a chance of being
-   grokked by `grokparms'.
-
-   @@ This is really weak, but the grammar does not allow us
-   @@ to easily reject things that this has to catch as syntax errors.  */
-static int
-parmlist_is_random (parms)
-     tree parms;
-{
-  if (parms == NULL_TREE)
-    return 0;
-
-  if (TREE_CODE (parms) != TREE_LIST)
-    return 1;
-
-  while (parms)
-    {
-      if (parms == void_list_node)
-	return 0;
-
-      if (TREE_CODE (TREE_VALUE (parms)) != TREE_LIST)
-	return 1;
-      /* Don't get faked out by overloaded functions, which
-	 masquerade as TREE_LISTs!  */
-      if (TREE_TYPE (TREE_VALUE (parms)) == unknown_type_node)
-	return 1;
-      parms = TREE_CHAIN (parms);
-    }
-  return 0;
-}
-
-/* Subroutine of `grokparms'.  In a fcn definition, arg types must
-   be complete.
-
-   C++: also subroutine of `start_function'.  */
-static void
-require_complete_types_for_parms (parms)
-     tree parms;
-{
-  while (parms)
-    {
-      tree type = TREE_TYPE (parms);
-      if (TYPE_SIZE (type) == NULL_TREE)
-	{
-	  if (DECL_NAME (parms))
-	    error ("parameter `%s' has incomplete type",
-		   IDENTIFIER_POINTER (DECL_NAME (parms)));
-	  else
-	    error ("parameter has incomplete type");
-	  TREE_TYPE (parms) = error_mark_node;
-	}
-#if 0
-      /* If the arg types are incomplete in a declaration,
-	 they must include undefined tags.
-	 These tags can never be defined in the scope of the declaration,
-	 so the types can never be completed,
-	 and no call can be compiled successfully.  */
-      /* This is not the right behavior for C++, but not having
-	 it is also probably wrong.  */
-      else
-	{
-	  /* Now warn if is a pointer to an incomplete type.  */
-	  while (TREE_CODE (type) == POINTER_TYPE
-		 || TREE_CODE (type) == REFERENCE_TYPE)
-	    type = TREE_TYPE (type);
-	  type = TYPE_MAIN_VARIANT (type);
-	  if (TYPE_SIZE (type) == NULL_TREE)
-	    {
-	      if (DECL_NAME (parm) != NULL_TREE)
-		warning ("parameter `%s' points to incomplete type",
-			 IDENTIFIER_POINTER (DECL_NAME (parm)));
-	      else
-		warning ("parameter points to incomplete type");
-	    }
-	}
-#endif
-      parms = TREE_CHAIN (parms);
-    }
-}
-
-/* Decode the list of parameter types for a function type.
-   Given the list of things declared inside the parens,
-   return a list of types.
-
-   The list we receive can have three kinds of elements:
-   an IDENTIFIER_NODE for names given without types,
-   a TREE_LIST node for arguments given as typespecs or names with typespecs,
-   or void_type_node, to mark the end of an argument list
-   when additional arguments are not permitted (... was not used).
-
-   FUNCDEF_FLAG is nonzero for a function definition, 0 for
-   a mere declaration.  A nonempty identifier-list gets an error message
-   when FUNCDEF_FLAG is zero.
-   If FUNCDEF_FLAG is 1, then parameter types must be complete.
-   If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
-
-   If all elements of the input list contain types,
-   we return a list of the types.
-   If all elements contain no type (except perhaps a void_type_node
-   at the end), we return a null list.
-   If some have types and some do not, it is an error, and we
-   return a null list.
-
-   Also set last_function_parms to either
-   a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
-   A list of names is converted to a chain of PARM_DECLs
-   by store_parm_decls so that ultimately it is always a chain of decls.
-
-   Note that in C++, parameters can take default values.  These default
-   values are in the TREE_PURPOSE field of the TREE_LIST.  It is
-   an error to specify default values which are followed by parameters
-   that have no default values, or an ELLIPSES.  For simplicities sake,
-   only parameters which are specified with their types can take on
-   default values.  */
-
-static tree
-grokparms (first_parm, funcdef_flag)
-     tree first_parm;
-     int funcdef_flag;
-{
-  tree result = NULL_TREE;
-  tree decls = NULL_TREE;
-
-  if (first_parm != NULL_TREE
-      && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
-    {
-      if (! funcdef_flag)
-	warning ("parameter names (without types) in function declaration");
-      last_function_parms = first_parm;
-      return NULL_TREE;
-    }
-  else
-    {
-      /* Types were specified.  This is a list of declarators
-	 each represented as a TREE_LIST node.  */
-      register tree parm, chain;
-      int any_init = 0, any_error = 0, saw_void = 0;
-
-      if (first_parm != NULL_TREE)
-	{
-	  tree last_result = NULL_TREE;
-	  tree last_decl = NULL_TREE;
-
-	  for (parm = first_parm; parm != NULL_TREE; parm = chain)
-	    {
-	      tree type, list_node = parm;
-	      register tree decl = TREE_VALUE (parm);
-	      tree init = TREE_PURPOSE (parm);
-
-	      chain = TREE_CHAIN (parm);
-	      /* @@ weak defense against parse errors.  */
-	      if (decl != void_type_node && TREE_CODE (decl) != TREE_LIST)
-		{
-		  /* Give various messages as the need arises.  */
-		  if (TREE_CODE (decl) == STRING_CST)
-		    error ("invalid string constant `%s'",
-			   TREE_STRING_POINTER (decl));
-		  else if (TREE_CODE (decl) == INTEGER_CST)
-		    error ("invalid integer constant in parameter list, did you forget to give parameter name?");
-		  continue;
-		}
-
-	      if (decl != void_type_node)
-		{
-		  /* @@ May need to fetch out a `raises' here.  */
-		  decl = grokdeclarator (TREE_VALUE (decl),
-					 TREE_PURPOSE (decl),
-					 PARM, init != NULL_TREE, NULL_TREE);
-		  if (! decl)
-		    continue;
-		  type = TREE_TYPE (decl);
-		  if (TYPE_MAIN_VARIANT (type) == void_type_node)
-		    decl = void_type_node;
-		  else if (TREE_CODE (type) == METHOD_TYPE)
-		    {
-		      if (DECL_NAME (decl))
-			/* Cannot use `error_with_decl' here because
-			   we don't have DECL_CONTEXT set up yet.  */
-			error ("parameter `%s' invalidly declared method type",
-			       IDENTIFIER_POINTER (DECL_NAME (decl)));
-		      else
-			error ("parameter invalidly declared method type");
-		      type = build_pointer_type (type);
-		      TREE_TYPE (decl) = type;
-		    }
-		  else if (TREE_CODE (type) == OFFSET_TYPE)
-		    {
-		      if (DECL_NAME (decl))
-			error ("parameter `%s' invalidly declared offset type",
-			       IDENTIFIER_POINTER (DECL_NAME (decl)));
-		      else
-			error ("parameter invalidly declared offset type");
-		      type = build_pointer_type (type);
-		      TREE_TYPE (decl) = type;
-		    }
-                  else if (TREE_CODE (type) == RECORD_TYPE
-                           && TYPE_LANG_SPECIFIC (type)
-                           && CLASSTYPE_ABSTRACT_VIRTUALS (type))
-                    {
-                      abstract_virtuals_error (decl, type);
-                      any_error = 1;  /* seems like a good idea */
-                    }
-		}
-
-	      if (decl == void_type_node)
-		{
-		  if (result == NULL_TREE)
-		    {
-		      result = void_list_node;
-		      last_result = result;
-		    }
-		  else
-		    {
-		      TREE_CHAIN (last_result) = void_list_node;
-		      last_result = void_list_node;
-		    }
-		  saw_void = 1;
-		  if (chain
-		      && (chain != void_list_node || TREE_CHAIN (chain)))
-		    error ("`void' in parameter list must be entire list");
-		  break;
-		}
-
-	      /* Since there is a prototype, args are passed in their own types.  */
-	      DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
-#ifdef PROMOTE_PROTOTYPES
-	      if (C_PROMOTING_INTEGER_TYPE_P (type))
-		DECL_ARG_TYPE (decl) = integer_type_node;
-#endif
-	      if (!any_error)
-		{
-		  if (init)
-		    {
-		      any_init++;
-		      if (TREE_CODE (init) == SAVE_EXPR)
-			PARM_DECL_EXPR (init) = 1;
-		      else if (TREE_CODE (init) == VAR_DECL)
-			{
-			  if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init)))
-			    {
-			      /* ``Local variables may not be used in default
-				 argument expressions.'' dpANSI C++ 8.2.6 */
-			      /* If extern int i; within a function is not
-				 considered a local variable, then this code is
-				 wrong. */
-			      error_with_decl (init, "local variable `%s' may not be used as a default argument");
-			      any_error = 1;
-			    }
-			  else if (TREE_READONLY_DECL_P (init))
-			    init = decl_constant_value (init);
-			}
-		      else
-			init = require_instantiated_type (type, init, integer_zero_node);
-		    }
-		  else if (any_init)
-		    {
-		      error ("all trailing parameters must have default arguments");
-		      any_error = 1;
-		    }
-		}
-	      else
-		init = NULL_TREE;
-
-	      if (decls == NULL_TREE)
-		{
-		  decls = decl;
-		  last_decl = decls;
-		}
-	      else
-		{
-		  TREE_CHAIN (last_decl) = decl;
-		  last_decl = decl;
-		}
-	      if (TREE_PERMANENT (list_node))
-		{
-		  TREE_PURPOSE (list_node) = init;
-		  TREE_VALUE (list_node) = type;
-		  TREE_CHAIN (list_node) = NULL_TREE;
-		}
-	      else
-		list_node = saveable_tree_cons (init, type, NULL_TREE);
-	      if (result == NULL_TREE)
-		{
-		  result = list_node;
-		  last_result = result;
-		}
-	      else
-		{
-		  TREE_CHAIN (last_result) = list_node;
-		  last_result = list_node;
-		}
-	    }
-	  if (last_result)
-	    TREE_CHAIN (last_result) = NULL_TREE;
-	  /* If there are no parameters, and the function does not end
-	     with `...', then last_decl will be NULL_TREE.  */
-	  if (last_decl != NULL_TREE)
-	    TREE_CHAIN (last_decl) = NULL_TREE;
-	}
-    }
-
-  last_function_parms = decls;
-
-  /* In a fcn definition, arg types must be complete.  */
-  if (funcdef_flag > 0)
-    require_complete_types_for_parms (last_function_parms);
-
-  return result;
-}
-
-/* These memoizing functions keep track of special properties which
-   a class may have.  `grok_ctor_properties' notices whether a class
-   has a constructor of the for X(X&), and also complains
-   if the class has a constructor of the form X(X).
-   `grok_op_properties' takes notice of the various forms of
-   operator= which are defined, as well as what sorts of type conversion
-   may apply.  Both functions take a FUNCTION_DECL as an argument.  */
-void
-grok_ctor_properties (ctype, decl)
-     tree ctype, decl;
-{
-  tree parmtypes = FUNCTION_ARG_CHAIN (decl);
-  tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
-
-  if (parmtypes && TREE_CHAIN (parmtypes)
-      && TREE_CODE (TREE_VALUE (TREE_CHAIN (parmtypes))) == REFERENCE_TYPE
-      && TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (TREE_VALUE (TREE_CHAIN (parmtypes)))))
-    {
-      parmtypes = TREE_CHAIN (parmtypes);
-      parmtype = TREE_VALUE (parmtypes);
-    }
-
-  if (TREE_CODE (parmtype) == REFERENCE_TYPE
-      && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype)
-    {
-      if (TREE_CHAIN (parmtypes) == NULL_TREE
-	  || TREE_CHAIN (parmtypes) == void_list_node
-	  || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
-	{
-	  TYPE_HAS_INIT_REF (ctype) = 1;
-	  TYPE_GETS_INIT_REF (ctype) = 1;
-	  if (TYPE_READONLY (TREE_TYPE (parmtype)))
-	    TYPE_GETS_CONST_INIT_REF (ctype) = 1;
-	}
-      else
-	TYPE_GETS_INIT_AGGR (ctype) = 1;
-    }
-  else if (TYPE_MAIN_VARIANT (parmtype) == ctype)
-    {
-      if (TREE_CHAIN (parmtypes) != NULL_TREE
-	  && TREE_CHAIN (parmtypes) == void_list_node)
-	error ("invalid constructor; you probably meant `%s (%s&)'",
-	       TYPE_NAME_STRING (ctype),
-	       TYPE_NAME_STRING (ctype));
-      SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
-      TYPE_GETS_INIT_AGGR (ctype) = 1;
-    }
-  else if (TREE_CODE (parmtype) == VOID_TYPE
-	   || TREE_PURPOSE (parmtypes) != NULL_TREE)
-    TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
-}
-
-/* Do a little sanity-checking on how they declared their operator.  */
-static void
-grok_op_properties (decl, virtualp)
-     tree decl;
-     int virtualp;
-{
-  tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
-
-  if (DECL_STATIC_FUNCTION_P (decl))
-    {
-      if (DECL_NAME (decl) == ansi_opname[(int) NEW_EXPR])
-	{
-	  if (virtualp)
-	    error ("`operator new' cannot be declared virtual");
-
-	  /* Take care of function decl if we had syntax errors.  */
-	  if (argtypes == NULL_TREE)
-	    TREE_TYPE (decl) =
-	      build_function_type (ptr_type_node,
-				   hash_tree_chain (integer_type_node,
-						    void_list_node));
-	  else
-	    decl = coerce_new_type (TREE_TYPE (decl));
-	}
-      else if (DECL_NAME (decl) == ansi_opname[(int) DELETE_EXPR])
-	{
-	  if (virtualp)
-	    error ("`operator delete' cannot be declared virtual");
-
-	  if (argtypes == NULL_TREE)
-	    TREE_TYPE (decl) =
-	      build_function_type (void_type_node,
-				   hash_tree_chain (ptr_type_node,
-						    void_list_node));
-	  else
-	    decl = coerce_delete_type (TREE_TYPE (decl));
-	}
-      else
-	error_with_decl (decl, "`%s' cannot be a static member function");
-    }
-  else if (DECL_NAME (decl) == ansi_opname[(int) MODIFY_EXPR])
-    {
-      tree parmtypes;
-      tree parmtype;
-
-      if (argtypes == NULL_TREE)
-	{
-	  error_with_decl (decl, "too few arguments to `%s'");
-	  return;
-	}
-      parmtypes = TREE_CHAIN (argtypes);
-      parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
-
-      if (TREE_CODE (parmtype) == REFERENCE_TYPE
-	  && TREE_TYPE (parmtype) == current_class_type)
-	{
-	  TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
-	  TYPE_GETS_ASSIGN_REF (current_class_type) = 1;
-	  if (TYPE_READONLY (TREE_TYPE (parmtype)))
-	    TYPE_GETS_CONST_INIT_REF (current_class_type) = 1;
-	}
-    }
-}
-
-/* Get the struct, enum or union (CODE says which) with tag NAME.
-   Define the tag as a forward-reference if it is not defined.
-
-   C++: If a class derivation is given, process it here, and report
-   an error if multiple derivation declarations are not identical.
-
-   If this is a definition, come in through xref_tag and only look in
-   the current frame for the name (since C++ allows new names in any
-   scope.)  */
-
-/* avoid rewriting all callers of xref_tag */
-static int xref_next_defn = 0;
-
-tree
-xref_defn_tag (code_type_node, name, binfo)
-     tree code_type_node;
-     tree name, binfo;
-{
-  tree rv, ncp;
-  xref_next_defn = 1;
-
-  if (class_binding_level)
-    {
-      tree n1;
-      char *buf;
-      /* we need to build a new IDENTIFIER_NODE for name which nukes
-       * the pieces... */
-      n1 = IDENTIFIER_LOCAL_VALUE (current_class_name);
-      if (n1)
-	n1 = DECL_NAME (n1);
-      else
-	n1 = current_class_name;
-      
-      buf = (char *) alloca (4 + IDENTIFIER_LENGTH (n1)
-			     + IDENTIFIER_LENGTH (name));
-      
-      sprintf (buf, "%s::%s", IDENTIFIER_POINTER (n1),
-	       IDENTIFIER_POINTER (name));
-      ncp = get_identifier (buf);
-#ifdef SPEW_DEBUG
-      if (spew_debug)
-	printf("*** %s ***\n", IDENTIFIER_POINTER (ncp));
-#endif
-#if 0
-      IDENTIFIER_LOCAL_VALUE (name) =
-	build_lang_decl (TYPE_DECL, ncp, NULL_TREE);
-#endif
-      rv = xref_tag (code_type_node, name, binfo);
-      pushdecl_top_level (build_lang_decl (TYPE_DECL, ncp, rv));
-    }
-  else
-    {
-      rv = xref_tag (code_type_node, name, binfo);
-    }
-  xref_next_defn = 0;
-  return rv;
-}
-
-tree
-xref_tag (code_type_node, name, binfo)
-     tree code_type_node;
-     tree name, binfo;
-{
-  enum tag_types tag_code;
-  enum tree_code code;
-  int temp = 0;
-  int i, len;
-  register tree ref;
-  struct binding_level *b
-    = (class_binding_level ? class_binding_level : current_binding_level);
-
-  tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
-  switch (tag_code)
-    {
-    case record_type:
-    case class_type:
-    case exception_type:
-      code = RECORD_TYPE;
-      len = list_length (binfo);
-      break;
-    case union_type:
-      code = UNION_TYPE;
-      if (binfo)
-	{
-	  error ("derived union `%s' invalid", IDENTIFIER_POINTER (name));
-	  binfo = NULL_TREE;
-	}
-      len = 0;
-      break;
-    case enum_type:
-      code = ENUMERAL_TYPE;
-      break;
-    default:
-      my_friendly_abort (18);
-    }
-
-  /* If a cross reference is requested, look up the type
-     already defined for this tag and return it.  */
-  if (xref_next_defn)
-    {
-      /* If we know we are defining this tag, only look it up in this scope
-       * and don't try to find it as a type. */
-      xref_next_defn = 0;
-      ref = lookup_tag (code, name, b, 1);
-    }
-  else
-    {
-      ref = lookup_tag (code, name, b, 0);
-
-      if (! ref)
-	{
-	  /* Try finding it as a type declaration.  If that wins, use it.  */
-	  ref = lookup_name (name, 1);
-	  if (ref && TREE_CODE (ref) == TYPE_DECL
-	      && TREE_CODE (TREE_TYPE (ref)) == code)
-	    ref = TREE_TYPE (ref);
-	  else
-	    ref = NULL_TREE;
-	}
-    }
-
-  push_obstacks_nochange ();
-
-  if (! ref)
-    {
-      /* If no such tag is yet defined, create a forward-reference node
-	 and record it as the "definition".
-	 When a real declaration of this type is found,
-	 the forward-reference will be altered into a real type.  */
-
-      /* In C++, since these migrate into the global scope, we must
-	 build them on the permanent obstack.  */
-
-      temp = allocation_temporary_p ();
-      if (temp)
-	end_temporary_allocation ();
-
-      if (code == ENUMERAL_TYPE)
-	{
-	  ref = make_node (ENUMERAL_TYPE);
-
-	  /* Give the type a default layout like unsigned int
-	     to avoid crashing if it does not get defined.  */
-	  TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
-	  TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
-	  TREE_UNSIGNED (ref) = 1;
-	  TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
-	  TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
-	  TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
-
-	  /* Enable us to recognize when a type is created in class context.
-	     To do nested classes correctly, this should probably be cleared
-	     out when we leave this classes scope.  Currently this in only
-	     done in `start_enum'.  */
-
-	  pushtag (name, ref);
-	  if (flag_cadillac)
-	    cadillac_start_enum (ref);
-	}
-      else if (tag_code == exception_type)
-	{
-	  ref = make_lang_type (code);
-	  /* Enable us to recognize when an exception type is created in
-	     class context.  To do nested classes correctly, this should
-	     probably be cleared out when we leave this class's scope.  */
-	  CLASSTYPE_DECLARED_EXCEPTION (ref) = 1;
-	  pushtag (name, ref);
-	  if (flag_cadillac)
-	    cadillac_start_struct (ref);
-	}
-      else
-	{
-	  extern tree pending_vtables;
-	  struct binding_level *old_b = class_binding_level;
-	  int needs_writing;
-
-	  ref = make_lang_type (code);
-
-	  /* Record how to set the visibility of this class's
-	     virtual functions.  If write_virtuals == 2 or 3, then
-	     inline virtuals are ``extern inline''.  */
-	  switch (write_virtuals)
-	    {
-	    case 0:
-	    case 1:
-	      needs_writing = 1;
-	      break;
-	    case 2:
-	      needs_writing = !! value_member (name, pending_vtables);
-	      break;
-	    case 3:
-	      needs_writing
-		= ! (CLASSTYPE_INTERFACE_ONLY (ref) || CLASSTYPE_INTERFACE_UNKNOWN (ref));
-	      break;
-	    default:
-	      needs_writing = 0;
-	    }
-
-	  CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = needs_writing;
-
-#ifdef NONNESTED_CLASSES
-	  /* Class types don't nest the way enums do.  */
-	  class_binding_level = (struct binding_level *)0;
-#endif
-	  pushtag (name, ref);
-	  class_binding_level = old_b;
-
-	  if (flag_cadillac)
-	    cadillac_start_struct (ref);
-	}
-    }
-  else
-    {
-      if (IS_AGGR_TYPE_CODE (code))
-	{
-	  if (IS_AGGR_TYPE (ref)
-	      && ((tag_code == exception_type)
-		  != (CLASSTYPE_DECLARED_EXCEPTION (ref) == 1)))
-	    {
-	      error ("type `%s' is both exception and aggregate type",
-		     IDENTIFIER_POINTER (name));
-	      CLASSTYPE_DECLARED_EXCEPTION (ref) = (tag_code == exception_type);
-	    }
-	}
-
-      /* If it no longer looks like a nested type, make sure it's
-	 in global scope.  */
-      if (b == global_binding_level && !class_binding_level
-	  && IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
-	IDENTIFIER_GLOBAL_VALUE (name) = TYPE_NAME (ref);
-
-      if (binfo)
-	{
-	  tree tt1 = binfo;
-	  tree tt2 = TYPE_BINFO_BASETYPES (ref);
-
-	  if (TYPE_BINFO_BASETYPES (ref))
-	    for (i = 0; tt1; i++, tt1 = TREE_CHAIN (tt1))
-	      if (TREE_VALUE (tt1) != TYPE_IDENTIFIER (BINFO_TYPE (TREE_VEC_ELT (tt2, i))))
-		{
-		  error ("redeclaration of derivation chain of type `%s'",
-			 IDENTIFIER_POINTER (name));
-		  break;
-		}
-
-	  if (tt1 == NULL_TREE)
-	    /* The user told us something we already knew.  */
-	    goto just_return;
-
-	  /* In C++, since these migrate into the global scope, we must
-	     build them on the permanent obstack.  */
-	  end_temporary_allocation ();
-	}
-    }
-
-  if (binfo)
-    {
-      /* In the declaration `A : X, Y, ... Z' we mark all the types
-	 (A, X, Y, ..., Z) so we can check for duplicates.  */
-      tree binfos;
-
-      SET_CLASSTYPE_MARKED (ref);
-      BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
-
-      for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
-	{
-	  /* The base of a derived struct is public.  */
-	  int via_public = (tag_code != class_type
-			    || TREE_PURPOSE (binfo) == (tree)visibility_public
-			    || TREE_PURPOSE (binfo) == (tree)visibility_public_virtual);
-	  int via_protected = TREE_PURPOSE (binfo) == (tree)visibility_protected;
-	  int via_virtual = (TREE_PURPOSE (binfo) == (tree)visibility_private_virtual
-			     || TREE_PURPOSE (binfo) == (tree)visibility_public_virtual
-			     || TREE_PURPOSE (binfo) == (tree)visibility_default_virtual);
-	  tree basetype = TREE_TYPE (TREE_VALUE (binfo));
-	  tree base_binfo;
-
-	  GNU_xref_hier (IDENTIFIER_POINTER (name),
-			 IDENTIFIER_POINTER (TREE_VALUE (binfo)),
-			 via_public, via_virtual, 0);
-
-	  if (basetype && TREE_CODE (basetype) == TYPE_DECL)
-	    basetype = TREE_TYPE (basetype);
-	  if (!basetype || TREE_CODE (basetype) != RECORD_TYPE)
-	    {
-	      error ("base type `%s' fails to be a struct or class type",
-		     IDENTIFIER_POINTER (TREE_VALUE (binfo)));
-	      continue;
-	    }
-#if 1
-	  /* This code replaces similar code in layout_basetypes.  */
-	  else if (TYPE_SIZE (basetype) == NULL_TREE)
-	    {
-	      error_with_aggr_type (basetype, "base class `%s' has incomplete type");
-	      continue;
-	    }
-#endif
-	  else
-	    {
-	      if (CLASSTYPE_MARKED (basetype))
-		{
-		  if (basetype == ref)
-		    error_with_aggr_type (basetype, "recursive type `%s' undefined");
-		  else
-		    error_with_aggr_type (basetype, "duplicate base type `%s' invalid");
-		  continue;
-		}
-
- 	      /* Note that the BINFO records which describe individual
- 		 inheritances are *not* shared in the lattice!  They
- 		 cannot be shared because a given baseclass may be
- 		 inherited with different `accessibility' by different
- 		 derived classes.  (Each BINFO record describing an
- 		 individual inheritance contains flags which say what
- 		 the `accessibility' of that particular inheritance is.)  */
-  
-	      base_binfo = make_binfo (integer_zero_node, basetype,
-				  TYPE_BINFO_VTABLE (basetype),
- 				  TYPE_BINFO_VIRTUALS (basetype), 0);
- 
-	      TREE_VEC_ELT (binfos, i) = base_binfo;
-	      TREE_VIA_PUBLIC (base_binfo) = via_public;
- 	      TREE_VIA_PROTECTED (base_binfo) = via_protected;
-	      TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
-
-	      SET_CLASSTYPE_MARKED (basetype);
-#if 0
-/* XYZZY TEST VIRTUAL BASECLASSES */
-if (CLASSTYPE_N_BASECLASSES (basetype) == NULL_TREE
-    && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype)
-    && via_virtual == 0)
-  {
-    warning ("making type `%s' a virtual baseclass",
-	     TYPE_NAME_STRING (basetype));
-    via_virtual = 1;
-  }
-#endif
-	      /* We are free to modify these bits because they are meaningless
-		 at top level, and BASETYPE is a top-level type.  */
-	      if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
-		{
-		  TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
-		  TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
-		}
-
-	      TYPE_GETS_ASSIGNMENT (ref) |= TYPE_GETS_ASSIGNMENT (basetype);
-	      TYPE_OVERLOADS_METHOD_CALL_EXPR (ref) |= TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype);
-	      TREE_GETS_NEW (ref) |= TREE_GETS_NEW (basetype);
-	      TREE_GETS_DELETE (ref) |= TREE_GETS_DELETE (basetype);
-	      CLASSTYPE_LOCAL_TYPEDECLS (ref) |= CLASSTYPE_LOCAL_TYPEDECLS (basetype);
-	      i += 1;
-	    }
-	}
-      if (i)
-	TREE_VEC_LENGTH (binfos) = i;
-      else
-	BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
-
-      if (i > 1)
-	TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
-      else if (i == 1)
-	TYPE_USES_MULTIPLE_INHERITANCE (ref)
-	  = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos, 0)));
-      if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
-	TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
-
-      /* Unmark all the types.  */
-      while (--i >= 0)
-	CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
-      CLEAR_CLASSTYPE_MARKED (ref);
-    }
-
- just_return:
-
-  /* Until the type is defined, tentatively accept whatever
-     structure tag the user hands us.  */
-  if (TYPE_SIZE (ref) == NULL_TREE
-      && ref != current_class_type
-      /* Have to check this, in case we have contradictory tag info.  */
-      && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
-    {
-      if (tag_code == class_type)
-	CLASSTYPE_DECLARED_CLASS (ref) = 1;
-      else if (tag_code == record_type)
-	CLASSTYPE_DECLARED_CLASS (ref) = 0;
-    }
-
-  pop_obstacks ();
-
-  return ref;
-}
-
-static tree current_local_enum = NULL_TREE;
-
-/* Begin compiling the definition of an enumeration type.
-   NAME is its name (or null if anonymous).
-   Returns the type object, as yet incomplete.
-   Also records info about it so that build_enumerator
-   may be used to declare the individual values as they are read.  */
-
-tree
-start_enum (name)
-     tree name;
-{
-  register tree enumtype = NULL_TREE;
-  struct binding_level *b
-    = (class_binding_level ? class_binding_level : current_binding_level);
-
-  /* If this is the real definition for a previous forward reference,
-     fill in the contents in the same object that used to be the
-     forward reference.  */
-
-  if (name != NULL_TREE)
-    enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
-
-  if (enumtype == NULL_TREE || TREE_CODE (enumtype) != ENUMERAL_TYPE)
-    {
-      enumtype = make_node (ENUMERAL_TYPE);
-      pushtag (name, enumtype);
-    }
-
-  if (current_class_type)
-    TREE_ADDRESSABLE (b->tags) = 1;
-  current_local_enum = NULL_TREE;
-
-  if (TYPE_VALUES (enumtype) != NULL_TREE)
-    {
-      /* This enum is a named one that has been declared already.  */
-      error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
-
-      /* Completely replace its old definition.
-	 The old enumerators remain defined, however.  */
-      TYPE_VALUES (enumtype) = NULL_TREE;
-    }
-
-  /* Initially, set up this enum as like `int'
-     so that we can create the enumerators' declarations and values.
-     Later on, the precision of the type may be changed and
-     it may be laid out again.  */
-
-  TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
-  TYPE_SIZE (enumtype) = NULL_TREE;
-  fixup_unsigned_type (enumtype);
-
-  /* We copy this value because enumerated type constants
-     are really of the type of the enumerator, not integer_type_node.  */
-  enum_next_value = copy_node (integer_zero_node);
-
-  GNU_xref_decl (current_function_decl, enumtype);
-  return enumtype;
-}
-
-/* After processing and defining all the values of an enumeration type,
-   install their decls in the enumeration type and finish it off.
-   ENUMTYPE is the type object and VALUES a list of name-value pairs.
-   Returns ENUMTYPE.  */
-
-tree
-finish_enum (enumtype, values)
-     register tree enumtype, values;
-{
-  register tree pair;
-  register HOST_WIDE_INT maxvalue = 0;
-  register HOST_WIDE_INT minvalue = 0;
-  register HOST_WIDE_INT i;
-
-  TYPE_VALUES (enumtype) = values;
-
-  /* Calculate the maximum value of any enumerator in this type.  */
-
-  if (values)
-    {
-      /* Speed up the main loop by performing some precalculations */
-
-      HOST_WIDE_INT value = TREE_INT_CST_LOW (TREE_VALUE (values));
-      TREE_TYPE (TREE_VALUE (values)) = enumtype;
-      minvalue = maxvalue = value;
-      
-      for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
-	{
-	  value = TREE_INT_CST_LOW (TREE_VALUE (pair));
-	  if (value > maxvalue)
-	    maxvalue = value;
-	  else if (value < minvalue)
-	    minvalue = value;
-	  TREE_TYPE (TREE_VALUE (pair)) = enumtype;
-	}
-    }
-
-  if (flag_short_enums)
-    {
-      /* Determine the precision this type needs, lay it out, and define it.  */
-
-      for (i = maxvalue; i; i >>= 1)
-	TYPE_PRECISION (enumtype)++;
-
-      if (!TYPE_PRECISION (enumtype))
-	TYPE_PRECISION (enumtype) = 1;
-
-      /* Cancel the laying out previously done for the enum type,
-	 so that fixup_unsigned_type will do it over.  */
-      TYPE_SIZE (enumtype) = NULL_TREE;
-
-      fixup_unsigned_type (enumtype);
-    }
-
-  TREE_INT_CST_LOW (TYPE_MAX_VALUE (enumtype)) = maxvalue;
-
-  /* An enum can have some negative values; then it is signed.  */
-  if (minvalue < 0)
-    {
-      TREE_INT_CST_LOW (TYPE_MIN_VALUE (enumtype)) = minvalue;
-      TREE_INT_CST_HIGH (TYPE_MIN_VALUE (enumtype)) = -1;
-      TREE_UNSIGNED (enumtype) = 0;
-    }
-  if (flag_cadillac)
-    cadillac_finish_enum (enumtype);
-
-  /* Finish debugging output for this type.  */
-#if 0
-  /* @@ Do we ever generate generate ENUMERAL_TYPE nodes for which debugging
-     information should *not* be generated?  I think not.  */
-  if (! DECL_IGNORED_P (TYPE_NAME (enumtype)))
-#endif
-    rest_of_type_compilation (enumtype, global_bindings_p ());
-
-  return enumtype;
-}
-
-/* Build and install a CONST_DECL for one value of the
-   current enumeration type (one that was begun with start_enum).
-   Return a tree-list containing the name and its value.
-   Assignment of sequential values by default is handled here.  */
-
-tree
-build_enumerator (name, value)
-     tree name, value;
-{
-  tree decl, result;
-  /* Change this to zero if we find VALUE is not shareable.  */
-  int shareable = 1;
-
-  /* Remove no-op casts from the value.  */
-  if (value)
-    STRIP_TYPE_NOPS (value);
-
-  /* Validate and default VALUE.  */
-  if (value != NULL_TREE)
-    {
-      if (TREE_READONLY_DECL_P (value))
-	{
-	  value = decl_constant_value (value);
-	  shareable = 0;
-	}
-
-      if (TREE_CODE (value) != INTEGER_CST)
-	{
-	  error ("enumerator value for `%s' not integer constant",
-		 IDENTIFIER_POINTER (name));
-	  value = NULL_TREE;
-	}
-    }
-  /* The order of things is reversed here so that we
-     can check for possible sharing of enum values,
-     to keep that from happening.  */
-  /* Default based on previous value.  */
-  if (value == NULL_TREE)
-    value = enum_next_value;
-
-  /* Remove no-op casts from the value.  */
-  if (value)
-    STRIP_TYPE_NOPS (value);
-
-  /* Make up for hacks in cp-lex.c.  */
-  if (value == integer_zero_node)
-    value = build_int_2 (0, 0);
-  else if (value == integer_one_node)
-    value = build_int_2 (1, 0);
-  else if (TREE_CODE (value) == INTEGER_CST
-	   && (shareable == 0
-	       || TREE_CODE (TREE_TYPE (value)) == ENUMERAL_TYPE))
-    {
-      value = copy_node (value);
-      TREE_TYPE (value) = integer_type_node;
-    }
-
-  result = saveable_tree_cons (name, value, NULL_TREE);
-
-  /* C++ associates enums with global, function, or class declarations.  */
-  if (current_class_type == NULL_TREE || current_function_decl != NULL_TREE)
-    {
-      /* Create a declaration for the enum value name.  */
-
-      decl = build_decl (CONST_DECL, name, integer_type_node);
-      DECL_INITIAL (decl) = value;
-
-      pushdecl (decl);
-      GNU_xref_decl (current_function_decl, decl);
-    }
-
-  if (current_class_type)
-    {
-      /* class-local enum declaration */
-      decl = build_lang_field_decl (CONST_DECL, name, integer_type_node);
-      DECL_INITIAL (decl) = value;
-      TREE_READONLY (decl) = 1;
-      pushdecl_class_level (decl);
-      TREE_CHAIN (decl) = current_local_enum;
-      current_local_enum = decl;
-    }
-
-  /* Set basis for default for next value.  */
-  enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
-					       integer_one_node, PLUS_EXPR);
-  if (enum_next_value == integer_one_node)
-    enum_next_value = copy_node (enum_next_value);
-
-  return result;
-}
-
-tree
-grok_enum_decls (type, decl)
-     tree type, decl;
-{
-  tree d = current_local_enum;
-  
-  if (d == NULL_TREE)
-    return decl;
-  
-  while (1)
-    {
-      TREE_TYPE (d) = type;
-      if (TREE_CHAIN (d) == NULL_TREE)
-	{
-	  TREE_CHAIN (d) = decl;
-	  break;
-	}
-      d = TREE_CHAIN (d);
-    }
-
-  decl = current_local_enum;
-  current_local_enum = NULL_TREE;
-  
-  return decl;
-}
-
-/* Create the FUNCTION_DECL for a function definition.
-   DECLSPECS and DECLARATOR are the parts of the declaration;
-   they describe the function's name and the type it returns,
-   but twisted together in a fashion that parallels the syntax of C.
-
-   This function creates a binding context for the function body
-   as well as setting up the FUNCTION_DECL in current_function_decl.
-
-   Returns 1 on success.  If the DECLARATOR is not suitable for a function
-   (it defines a datum instead), we return 0, which tells
-   yyparse to report a parse error.
-
-   For C++, we must first check whether that datum makes any sense.
-   For example, "class A local_a(1,2);" means that variable local_a
-   is an aggregate of type A, which should have a constructor
-   applied to it with the argument list [1, 2].
-
-   @@ There is currently no way to retrieve the storage
-   @@ allocated to FUNCTION (or all of its parms) if we return
-   @@ something we had previously.  */
-
-int
-start_function (declspecs, declarator, raises, pre_parsed_p)
-     tree declarator, declspecs, raises;
-     int pre_parsed_p;
-{
-  extern tree EHS_decl;
-  tree decl1, olddecl;
-  tree ctype = NULL_TREE;
-  tree fntype;
-  tree restype;
-  extern int have_extern_spec;
-  extern int used_extern_spec;
-  int doing_friend = 0;
-
-  if (flag_handle_exceptions && EHS_decl == NULL_TREE)
-    init_exception_processing_1 ();
-
-  /* Sanity check.  */
-  my_friendly_assert (TREE_VALUE (void_list_node) == void_type_node, 160);
-  my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
-
-  /* Assume, until we see it does. */
-  current_function_returns_value = 0;
-  current_function_returns_null = 0;
-  warn_about_return_type = 0;
-  current_extern_inline = 0;
-  current_function_assigns_this = 0;
-  current_function_just_assigned_this = 0;
-  current_function_parms_stored = 0;
-  original_result_rtx = NULL_RTX;
-  current_function_obstack_index = 0;
-  current_function_obstack_usage = 0;
-
-  clear_temp_name ();
-
-  /* This should only be done once on the top most decl. */
-  if (have_extern_spec && !used_extern_spec)
-    {
-      declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
-      used_extern_spec = 1;
-    }
-
-  if (pre_parsed_p)
-    {
-      decl1 = declarator;
-      last_function_parms = DECL_ARGUMENTS (decl1);
-      last_function_parm_tags = NULL_TREE;
-      fntype = TREE_TYPE (decl1);
-      if (TREE_CODE (fntype) == METHOD_TYPE)
-	ctype = TYPE_METHOD_BASETYPE (fntype);
-
-      /* ANSI C++ June 5 1992 WP 11.4.5.  A friend function defined in a
-	 class is in the (lexical) scope of the class in which it is
-	 defined.  */
-      if (!ctype && DECL_FRIEND_P (decl1))
-	{
-	  ctype = TREE_TYPE (TREE_CHAIN (decl1));
-
-	  /* CTYPE could be null here if we're dealing with a template;
-	     for example, `inline friend float foo()' inside a template
-	     will have no CTYPE set.  */
-	  if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
-	    ctype = NULL_TREE;
-	  else
-	    doing_friend = 1;
-	}
-
-      if ( !(DECL_VINDEX (decl1)
-	     && write_virtuals >= 2
-	     && CLASSTYPE_VTABLE_NEEDS_WRITING (ctype)))
-	current_extern_inline = TREE_PUBLIC (decl1) && DECL_INLINE (decl1);
-
-      raises = TYPE_RAISES_EXCEPTIONS (fntype);
-
-      /* In a fcn definition, arg types must be complete.  */
-      require_complete_types_for_parms (last_function_parms);
-    }
-  else
-    {
-      decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, raises);
-      /* If the declarator is not suitable for a function definition,
-	 cause a syntax error.  */
-      if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
-
-      fntype = TREE_TYPE (decl1);
-
-      restype = TREE_TYPE (fntype);
-      if (IS_AGGR_TYPE (restype)
-	  && ! CLASSTYPE_GOT_SEMICOLON (restype))
-	{
-	  error_with_aggr_type (restype, "semicolon missing after declaration of `%s'");
-	  shadow_tag (build_tree_list (NULL_TREE, restype));
-	  CLASSTYPE_GOT_SEMICOLON (restype) = 1;
-	  if (TREE_CODE (fntype) == FUNCTION_TYPE)
-	    fntype = build_function_type (integer_type_node,
-					  TYPE_ARG_TYPES (fntype));
-	  else
-	    fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
-					      integer_type_node,
-					      TYPE_ARG_TYPES (fntype));
-	  TREE_TYPE (decl1) = fntype;
-	}
-
-      if (TREE_CODE (fntype) == METHOD_TYPE)
-	ctype = TYPE_METHOD_BASETYPE (fntype);
-      else if (IDENTIFIER_LENGTH (DECL_NAME (decl1)) == 4
-	       && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (decl1)), "main")
-	       && DECL_CONTEXT (decl1) == NULL_TREE)
-	{
-	  /* If this doesn't return integer_type, complain.  */
-	  if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
-	    {
-	      warning ("return type for `main' changed to integer type");
-	      TREE_TYPE (decl1) = fntype = default_function_type;
-	    }
-	  warn_about_return_type = 0;
-	}
-    }
-
-  /* Warn if function was previously implicitly declared
-     (but not if we warned then).  */
-  if (! warn_implicit
-      && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
-    warning_with_decl (IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)),
-		       "`%s' implicitly declared before its definition");
-
-  current_function_decl = decl1;
-
-  if (flag_cadillac)
-    cadillac_start_function (decl1);
-  else
-    announce_function (decl1);
-
-  if (TYPE_SIZE (TREE_TYPE (fntype)) == NULL_TREE)
-    {
-      if (IS_AGGR_TYPE (TREE_TYPE (fntype)))
-	error_with_aggr_type (TREE_TYPE (fntype),
-			      "return-type `%s' is an incomplete type");
-      else
-	error ("return-type is an incomplete type");
-
-      /* Make it return void instead, but don't change the
-	 type of the DECL_RESULT, in case we have a named return value.  */
-      if (ctype)
-	TREE_TYPE (decl1)
-	  = build_cplus_method_type (build_type_variant (ctype,
-							 TREE_READONLY (decl1),
-							 TREE_SIDE_EFFECTS (decl1)),
-				     void_type_node,
-				     FUNCTION_ARG_CHAIN (decl1));
-      else
-	TREE_TYPE (decl1)
-	  = build_function_type (void_type_node,
-				 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
-      DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, TREE_TYPE (fntype));
-    }
-
-  if (warn_about_return_type)
-    warning ("return-type defaults to `int'");
-
-  /* Make the init_value nonzero so pushdecl knows this is not tentative.
-     error_mark_node is replaced below (in poplevel) with the BLOCK.  */
-  DECL_INITIAL (decl1) = error_mark_node;
-
-  /* Didn't get anything from C.  */
-  olddecl = NULL_TREE;
-
-  /* This function exists in static storage.
-     (This does not mean `static' in the C sense!)  */
-  TREE_STATIC (decl1) = 1;
-
-  /* If this function belongs to an interface, it is public.
-     If it belongs to someone else's interface, it is also external.
-     It doesn't matter whether it's inline or not.  */
-  if (interface_unknown == 0)
-    {
-      TREE_PUBLIC (decl1) = 1;
-      DECL_EXTERNAL (decl1) = (interface_only
-			       || (DECL_INLINE (decl1)
-				   && ! flag_implement_inlines));
-    }
-  else
-    /* This is a definition, not a reference.
-       So normally clear DECL_EXTERNAL.
-       However, `extern inline' acts like a declaration except for
-       defining how to inline.  So set DECL_EXTERNAL in that case.  */
-    DECL_EXTERNAL (decl1) = current_extern_inline;
-
-  /* Now see if this is the implementation of a function
-     declared with "C" linkage.  */
-  if (ctype == NULL_TREE && current_lang_name == lang_name_cplusplus
-      && !DECL_CONTEXT (decl1))
-    {
-      olddecl = lookup_name_current_level (DECL_NAME (decl1));
-      if (olddecl && TREE_CODE (olddecl) != FUNCTION_DECL)
-	olddecl = NULL_TREE;
-      if (olddecl && DECL_NAME (decl1) != DECL_NAME (olddecl))
-	{
-	  /* Collision between user and internal naming scheme.  */
-	  olddecl = lookup_name_current_level (DECL_ASSEMBLER_NAME (decl1));
-	  if (olddecl == NULL_TREE)
-	    olddecl = decl1;
-	}
-      if (olddecl && olddecl != decl1
-	  && DECL_NAME (decl1) == DECL_NAME (olddecl))
-	{
-	  if (TREE_CODE (olddecl) == FUNCTION_DECL
-	      && decls_match (decl1, olddecl))
-	    {
-	      olddecl = DECL_MAIN_VARIANT (olddecl);
-	      /* The following copy is needed to handle forcing a function's
-		 linkage to obey the linkage of the original decl.  */
-	      DECL_ASSEMBLER_NAME (decl1) = DECL_ASSEMBLER_NAME (olddecl);
-	      DECL_OVERLOADED (decl1) = DECL_OVERLOADED (olddecl);
-	      if (DECL_INITIAL (olddecl))
-		redeclaration_error_message (decl1, olddecl);
-	      if (! duplicate_decls (decl1, olddecl))
-		my_friendly_abort (19);
-	      decl1 = olddecl;
-	    }
-	  else
-	    olddecl = NULL_TREE;
-	}
-    }
-
-  /* Record the decl so that the function name is defined.
-     If we already have a decl for this name, and it is a FUNCTION_DECL,
-     use the old decl.  */
-
-  if (olddecl)
-    current_function_decl = olddecl;
-  else if (pre_parsed_p == 0)
-    {
-      current_function_decl = pushdecl (decl1);
-      if (TREE_CODE (current_function_decl) == TREE_LIST)
-	{
-	  /* @@ revert to modified original declaration.  */
-	  decl1 = DECL_MAIN_VARIANT (decl1);
-	  current_function_decl = decl1;
-	}
-      else
-	{
-	  decl1 = current_function_decl;
-	  DECL_MAIN_VARIANT (decl1) = decl1;
-	}
-      fntype = TREE_TYPE (decl1);
-    }
-  else
-    current_function_decl = decl1;
-
-  if (DECL_OVERLOADED (decl1))
-    decl1 = push_overloaded_decl (decl1, 1);
-
-  if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
-    {
-      if (TREE_CODE (fntype) == METHOD_TYPE)
-	TREE_TYPE (decl1) = fntype
-	  = build_function_type (TREE_TYPE (fntype),
-				 TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
-      last_function_parms = TREE_CHAIN (last_function_parms);
-      DECL_ARGUMENTS (decl1) = last_function_parms;
-      ctype = NULL_TREE;
-    }
-  restype = TREE_TYPE (fntype);
-
-  pushlevel (0);
-  current_binding_level->parm_flag = 1;
-
-  /* Save the parm names or decls from this function's declarator
-     where store_parm_decls will find them.  */
-  current_function_parms = last_function_parms;
-  current_function_parm_tags = last_function_parm_tags;
-
-  GNU_xref_function (decl1, current_function_parms);
-
-  make_function_rtl (decl1);
-
-  if (ctype)
-    {
-      pushclass (ctype, 1);
-
-      /* If we're compiling a friend function, neither of the variables
-	 current_class_decl nor current_class_type will have values.  */
-      if (! doing_friend)
-	{
-	  /* We know that this was set up by `grokclassfn'.
-	     We do not wait until `store_parm_decls', since evil
-	     parse errors may never get us to that point.  Here
-	     we keep the consistency between `current_class_type'
-	     and `current_class_decl'.  */
-	  current_class_decl = last_function_parms;
-	  my_friendly_assert (current_class_decl != NULL_TREE
-		  && TREE_CODE (current_class_decl) == PARM_DECL, 162);
-	  if (TREE_CODE (TREE_TYPE (current_class_decl)) == POINTER_TYPE)
-	    {
-	      tree variant = TREE_TYPE (TREE_TYPE (current_class_decl));
-	      if (CLASSTYPE_INST_VAR (ctype) == NULL_TREE)
-		{
-		  /* Can't call build_indirect_ref here, because it has special
-		     logic to return C_C_D given this argument.  */
-		  C_C_D = build1 (INDIRECT_REF, current_class_type, current_class_decl);
-		  CLASSTYPE_INST_VAR (ctype) = C_C_D;
-		}
-	      else
-		{
-		  C_C_D = CLASSTYPE_INST_VAR (ctype);
-		  /* `current_class_decl' is different for every
-		     function we compile.  */
-		  TREE_OPERAND (C_C_D, 0) = current_class_decl;
-		}
-	      TREE_READONLY (C_C_D) = TYPE_READONLY (variant);
-	      TREE_SIDE_EFFECTS (C_C_D) = TYPE_VOLATILE (variant);
-	      TREE_THIS_VOLATILE (C_C_D) = TYPE_VOLATILE (variant);
-	    }
-	  else
-	    C_C_D = current_class_decl;
-	}
-    }
-  else
-    {
-      if (DECL_STATIC_FUNCTION_P (decl1))
-	pushclass (DECL_CONTEXT (decl1), 2);
-      else
-	push_memoized_context (0, 1);
-    }
-
-  /* Allocate further tree nodes temporarily during compilation
-     of this function only.  Tiemann moved up here from bottom of fn.  */
-  temporary_allocation ();
-
-  /* Promote the value to int before returning it.  */
-  if (C_PROMOTING_INTEGER_TYPE_P (restype))
-    {
-      /* It retains unsignedness if traditional or if it isn't
-	 really getting wider.  */
-      if (TREE_UNSIGNED (restype)
-	  && (flag_traditional
-	      || TYPE_PRECISION (restype)
-		   == TYPE_PRECISION (integer_type_node)))
-	restype = unsigned_type_node;
-      else
-	restype = integer_type_node;
-    }
-  if (DECL_RESULT (decl1) == NULL_TREE)
-    DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, restype);
-
-  if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1)))
-    {
-      dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
-      ctor_label = NULL_TREE;
-    }
-  else
-    {
-      dtor_label = NULL_TREE;
-      if (DECL_CONSTRUCTOR_P (decl1))
-	ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
-    }
-
-  /* If this fcn was already referenced via a block-scope `extern' decl
-     (or an implicit decl), propagate certain information about the usage.  */
-  if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
-    TREE_ADDRESSABLE (decl1) = 1;
-
-  return 1;
-}
-
-/* Store the parameter declarations into the current function declaration.
-   This is called after parsing the parameter declarations, before
-   digesting the body of the function.
-
-   Also install to binding contour return value identifier, if any.  */
-
-void
-store_parm_decls ()
-{
-  register tree fndecl = current_function_decl;
-  register tree parm;
-  int parms_have_cleanups = 0;
-  tree eh_decl;
-
-  /* This is either a chain of PARM_DECLs (when a prototype is used).  */
-  tree specparms = current_function_parms;
-
-  /* This is a list of types declared among parms in a prototype.  */
-  tree parmtags = current_function_parm_tags;
-
-  /* This is a chain of any other decls that came in among the parm
-     declarations.  If a parm is declared with  enum {foo, bar} x;
-     then CONST_DECLs for foo and bar are put here.  */
-  tree nonparms = NULL_TREE;
-
-  if (current_binding_level == global_binding_level)
-    fatal ("parse errors have confused me too much");
-
-  /* Initialize RTL machinery.  */
-  init_function_start (fndecl, input_filename, lineno);
-
-  /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
-  declare_function_name ();
-
-  /* Create a binding level for the parms.  */
-  expand_start_bindings (0);
-
-  /* Prepare to catch raises, if appropriate.  */
-  if (flag_handle_exceptions)
-    {
-      /* Get this cleanup to be run last, since it
-	 is a call to `longjmp'.  */
-      setup_exception_throw_decl ();
-      eh_decl = current_binding_level->names;
-      current_binding_level->names = TREE_CHAIN (current_binding_level->names);
-    }
-  if (flag_handle_exceptions)
-    expand_start_try (integer_one_node, 0, 1);
-
-  if (specparms != NULL_TREE)
-    {
-      /* This case is when the function was defined with an ANSI prototype.
-	 The parms already have decls, so we need not do anything here
-	 except record them as in effect
-	 and complain if any redundant old-style parm decls were written.  */
-
-      register tree next;
-
-      /* Must clear this because it might contain TYPE_DECLs declared
-	 at class level.  */
-      storedecls (NULL_TREE);
-      for (parm = nreverse (specparms); parm; parm = next)
-	{
-	  next = TREE_CHAIN (parm);
-	  if (TREE_CODE (parm) == PARM_DECL)
-	    {
-	      tree cleanup = maybe_build_cleanup (parm);
-	      if (DECL_NAME (parm) == NULL_TREE)
-		{
-#if 0
-		  error_with_decl (parm, "parameter name omitted");
-#else
-		  /* for C++, this is not an error.  */
-		  pushdecl (parm);
-#endif
-		}
-	      else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
-		error_with_decl (parm, "parameter `%s' declared void");
-	      else
-		{
-		  /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
-		     A parameter is assumed not to have any side effects.
-		     If this should change for any reason, then this
-		     will have to wrap the bashed reference type in a save_expr.
-		     
-		     Also, if the parameter type is declared to be an X
-		     and there is an X(X&) constructor, we cannot lay it
-		     into the stack (any more), so we make this parameter
-		     look like it is really of reference type.  Functions
-		     which pass parameters to this function will know to
-		     create a temporary in their frame, and pass a reference
-		     to that.  */
-
-		  if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
-		      && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))))
-		    SET_DECL_REFERENCE_SLOT (parm, convert_from_reference (parm));
-
-		  pushdecl (parm);
-		}
-	      if (cleanup)
-		{
-		  expand_decl (parm);
-		  expand_decl_cleanup (parm, cleanup);
-		  parms_have_cleanups = 1;
-		}
-	    }
-	  else
-	    {
-	      /* If we find an enum constant or a type tag,
-		 put it aside for the moment.  */
-	      TREE_CHAIN (parm) = NULL_TREE;
-	      nonparms = chainon (nonparms, parm);
-	    }
-	}
-
-      /* Get the decls in their original chain order
-	 and record in the function.  This is all and only the
-	 PARM_DECLs that were pushed into scope by the loop above.  */
-      DECL_ARGUMENTS (fndecl) = getdecls ();
-
-      storetags (chainon (parmtags, gettags ()));
-    }
-  else
-    DECL_ARGUMENTS (fndecl) = NULL_TREE;
-
-  /* Now store the final chain of decls for the arguments
-     as the decl-chain of the current lexical scope.
-     Put the enumerators in as well, at the front so that
-     DECL_ARGUMENTS is not modified.  */
-
-  storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
-
-  /* Initialize the RTL code for the function.  */
-  DECL_SAVED_INSNS (fndecl) = NULL_RTX;
-  expand_function_start (fndecl, parms_have_cleanups);
-
-  if (flag_handle_exceptions)
-    {
-      /* Make the throw decl visible at this level, just
-	 not in the way of the parameters.  */
-      pushdecl (eh_decl);
-      expand_decl_init (eh_decl);
-    }
-
-  /* Create a binding contour which can be used to catch
-     cleanup-generated temporaries.  Also, if the return value needs or
-     has initialization, deal with that now.  */
-  if (parms_have_cleanups)
-    {
-      pushlevel (0);
-      expand_start_bindings (0);
-    }
-
-  current_function_parms_stored = 1;
-
-  if (flag_gc)
-    {
-      maybe_gc_cleanup = build_tree_list (NULL_TREE, error_mark_node);
-      expand_decl_cleanup (NULL_TREE, maybe_gc_cleanup);
-    }
-
-  /* If this function is `main', emit a call to `__main'
-     to run global initializers, etc.  */
-  if (DECL_NAME (fndecl)
-      && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
-      && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
-      && DECL_CONTEXT (fndecl) == NULL_TREE)
-    {
-      expand_main_function ();
-
-      if (flag_gc)
-	expand_expr (build_function_call (lookup_name (get_identifier ("__gc_main"), 0), NULL_TREE),
-		     0, VOIDmode, 0);
-
-      if (flag_dossier)
-	output_builtin_tdesc_entries ();
-    }
-}
-
-/* Bind a name and initialization to the return value of
-   the current function.  */
-void
-store_return_init (return_id, init)
-     tree return_id, init;
-{
-  tree decl = DECL_RESULT (current_function_decl);
-
-  if (pedantic)
-    /* Give this error as many times as there are occurrences,
-       so that users can use Emacs compilation buffers to find
-       and fix all such places.  */
-    error ("ANSI C++ does not permit named return values");
-
-  if (return_id != NULL_TREE)
-    {
-      if (DECL_NAME (decl) == NULL_TREE)
-	{
-	  DECL_NAME (decl) = return_id;
-	  DECL_ASSEMBLER_NAME (decl) = return_id;
-	}
-      else
-	error ("return identifier `%s' already in place",
-	       IDENTIFIER_POINTER (DECL_NAME (decl)));
-    }
-
-  /* Can't let this happen for constructors.  */
-  if (DECL_CONSTRUCTOR_P (current_function_decl))
-    {
-      error ("can't redefine default return value for constructors");
-      return;
-    }
-
-  /* If we have a named return value, put that in our scope as well.  */
-  if (DECL_NAME (decl) != NULL_TREE)
-    {
-      /* If this named return value comes in a register,
-	 put it in a pseudo-register.  */
-      if (DECL_REGISTER (decl))
-	{
-	  original_result_rtx = DECL_RTL (decl);
-	  DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
-	}
-
-      /* Let `finish_decl' know that this initializer is ok.  */
-      DECL_INITIAL (decl) = init;
-      pushdecl (decl);
-      finish_decl (decl, init, 0, 0);
-    }
-}
-
-/* Generate code for default X(X&) constructor.  */
-static void
-build_default_constructor (fndecl)
-     tree fndecl;
-{
-  int i = CLASSTYPE_N_BASECLASSES (current_class_type);
-  tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
-  tree fields = TYPE_FIELDS (current_class_type);
-  tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
-
-  if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
-    parm = TREE_CHAIN (parm);
-  parm = DECL_REFERENCE_SLOT (parm);
-
-  while (--i >= 0)
-    {
-      tree basetype = TREE_VEC_ELT (binfos, i);
-      if (TYPE_GETS_INIT_REF (basetype))
-	{
-	  tree name = TYPE_NAME (basetype);
-	  if (TREE_CODE (name) == TYPE_DECL)
-	    name = DECL_NAME (name);
-	  current_base_init_list = tree_cons (name, parm, current_base_init_list);
-	}
-    }
-  for (; fields; fields = TREE_CHAIN (fields))
-    {
-      tree name, init;
-      if (TREE_STATIC (fields))
-	continue;
-      if (TREE_CODE (fields) != FIELD_DECL)
-	continue;
-      if (DECL_NAME (fields))
-	{
-	  if (VFIELD_NAME_P (DECL_NAME (fields)))
-	    continue;
-	  if (VBASE_NAME_P (DECL_NAME (fields)))
-	    continue;
-
-	  /* True for duplicate members.  */
-	  if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields)
-	    continue;
-	}
-
-      init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields);
-
-      if (TREE_ANON_UNION_ELEM (fields))
-	name = build (COMPONENT_REF, TREE_TYPE (fields), C_C_D, fields);
-      else
-	{
-	  name = DECL_NAME (fields);
-	  init = build_tree_list (NULL_TREE, init);
-	}
-
-      current_member_init_list
-	= tree_cons (name, init, current_member_init_list);
-    }
-}
-
-
-/* Finish up a function declaration and compile that function
-   all the way to assembler language output.  The free the storage
-   for the function definition.
-
-   This is called after parsing the body of the function definition.
-   LINENO is the current line number.
-
-   C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
-   (and expand_end_bindings) must be made to take care of the binding
-   contour for the base initializers.  This is only relevant for
-   constructors.  */
-
-void
-finish_function (lineno, call_poplevel)
-     int lineno;
-     int call_poplevel;
-{
-  register tree fndecl = current_function_decl;
-  tree fntype, ctype = NULL_TREE;
-  rtx head, last_parm_insn, mark;
-  extern int sets_exception_throw_decl;
-  /* Label to use if this function is supposed to return a value.  */
-  tree no_return_label = NULL_TREE;
-
-  /* When we get some parse errors, we can end up without a
-     current_function_decl, so cope.  */
-  if (fndecl == NULL_TREE)
-    return;
-
-  fntype = TREE_TYPE (fndecl);
-
-/*  TREE_READONLY (fndecl) = 1;
-    This caused &foo to be of type ptr-to-const-function
-    which then got a warning when stored in a ptr-to-function variable.  */
-
-  /* This happens on strange parse errors.  */
-  if (! current_function_parms_stored)
-    {
-      call_poplevel = 0;
-      store_parm_decls ();
-    }
-
-  if (write_symbols != NO_DEBUG && TREE_CODE (fntype) != METHOD_TYPE)
-    {
-      tree ttype = target_type (fntype);
-      tree parmdecl;
-
-      if (IS_AGGR_TYPE (ttype))
-	/* Let debugger know it should output info for this type.  */
-	note_debug_info_needed (ttype);
-
-      for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
-	{
-	  ttype = target_type (TREE_TYPE (parmdecl));
-	  if (IS_AGGR_TYPE (ttype))
-	    /* Let debugger know it should output info for this type.  */
-	    note_debug_info_needed (ttype);
-	}
-    }
-
-  /* Clean house because we will need to reorder insns here.  */
-  do_pending_stack_adjust ();
-
-  if (dtor_label)
-    {
-      tree binfo = TYPE_BINFO (current_class_type);
-      tree cond = integer_one_node;
-      tree exprstmt, vfields;
-      tree in_charge_node = lookup_name (in_charge_identifier, 0);
-      tree virtual_size;
-      int ok_to_optimize_dtor = 0;
-
-      if (current_function_assigns_this)
-	cond = build (NE_EXPR, integer_type_node,
-		      current_class_decl, integer_zero_node);
-      else
-	{
-	  int n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
-
-	  /* If this destructor is empty, then we don't need to check
-	     whether `this' is NULL in some cases.  */
-	  mark = get_last_insn ();
-	  last_parm_insn = get_first_nonparm_insn ();
-
-	  if ((flag_this_is_variable & 1) == 0)
-	    ok_to_optimize_dtor = 1;
-	  else if (mark == last_parm_insn)
-	    ok_to_optimize_dtor
-	      = (n_baseclasses == 0
-		 || (n_baseclasses == 1
-		     && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type, 0))));
-	}
-
-      /* These initializations might go inline.  Protect
-	 the binding level of the parms.  */
-      pushlevel (0);
-
-      if (current_function_assigns_this)
-	{
-	  current_function_assigns_this = 0;
-	  current_function_just_assigned_this = 0;
-	}
-
-      /* Generate the code to call destructor on base class.
-	 If this destructor belongs to a class with virtual
-	 functions, then set the virtual function table
-	 pointer to represent the type of our base class.  */
-
-      /* This side-effect makes call to `build_delete' generate the
-	 code we have to have at the end of this destructor.  */
-      TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
-
-      /* These are two cases where we cannot delegate deletion.  */
-      if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
-	  || TREE_GETS_DELETE (current_class_type))
-	exprstmt = build_delete (current_class_type, C_C_D, integer_zero_node,
-				 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0, 0);
-      else
-	exprstmt = build_delete (current_class_type, C_C_D, in_charge_node,
-				 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0, 0);
-
-      /* If we did not assign to this, then `this' is non-zero at
-	 the end of a destructor.  As a special optimization, don't
-	 emit test if this is an empty destructor.  If it does nothing,
-	 it does nothing.  If it calls a base destructor, the base
-	 destructor will perform the test.  */
-
-      if (exprstmt != error_mark_node
-	  && (TREE_CODE (exprstmt) != NOP_EXPR
-	      || TREE_OPERAND (exprstmt, 0) != integer_zero_node
-	      || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
-	{
-	  expand_label (dtor_label);
-	  if (cond != integer_one_node)
-	    expand_start_cond (cond, 0);
-	  if (exprstmt != void_zero_node)
-	    /* Don't call `expand_expr_stmt' if we're not going to do
-	       anything, since -Wall will give a diagnostic.  */
-	    expand_expr_stmt (exprstmt);
-
-	  /* Run destructor on all virtual baseclasses.  */
-	  if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
-	    {
-	      tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
-	      expand_start_cond (build (BIT_AND_EXPR, integer_type_node,
-					in_charge_node, integer_two_node), 0);
-	      while (vbases)
-		{
-		  if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
-		    {
-		      tree ptr = convert_pointer_to_vbase (vbases, current_class_decl);
-		      expand_expr_stmt (build_delete (TYPE_POINTER_TO (BINFO_TYPE (vbases)),
-						      ptr, integer_zero_node,
-						      LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_HAS_IN_CHARGE, 0, 0));
-		    }
-		  vbases = TREE_CHAIN (vbases);
-		}
-	      expand_end_cond ();
-	    }
-
-	  do_pending_stack_adjust ();
-	  if (cond != integer_one_node)
-	    expand_end_cond ();
-	}
-
-      TYPE_HAS_DESTRUCTOR (current_class_type) = 1;
-
-      virtual_size = c_sizeof (current_class_type);
-
-      /* At the end, call delete if that's what's requested.  */
-      if (TREE_GETS_DELETE (current_class_type))
-	/* This NOP_EXPR means we are in a static call context.  */
-	exprstmt =
-	  build_method_call
-	    (build1 (NOP_EXPR,
-		     TYPE_POINTER_TO (current_class_type), error_mark_node),
-	     ansi_opname[(int) DELETE_EXPR],
-	     tree_cons (NULL_TREE, current_class_decl,
-			build_tree_list (NULL_TREE, virtual_size)),
-	     NULL_TREE, LOOKUP_NORMAL);
-      else if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
-	exprstmt = build_x_delete (ptr_type_node, current_class_decl, 0,
-				   virtual_size);
-      else
-	exprstmt = NULL_TREE;
-
-      if (exprstmt)
-	{
-	  cond = build (BIT_AND_EXPR, integer_type_node,
-			in_charge_node, integer_one_node);
-	  expand_start_cond (cond, 0);
-	  expand_expr_stmt (exprstmt);
-	  expand_end_cond ();
-	}
-
-      /* End of destructor.  */
-      poplevel (2, 0, 0);
-
-      /* Back to the top of destructor.  */
-      /* Dont execute destructor code if `this' is NULL.  */
-      mark = get_last_insn ();
-      last_parm_insn = get_first_nonparm_insn ();
-      if (last_parm_insn == NULL_RTX)
-	last_parm_insn = mark;
-      else
-	last_parm_insn = previous_insn (last_parm_insn);
-
-      /* Make all virtual function table pointers point to CURRENT_CLASS_TYPE's
-	 virtual function tables.  */
-      if (CLASSTYPE_VFIELDS (current_class_type))
-	{
-	  for (vfields = CLASSTYPE_VFIELDS (current_class_type);
-	       TREE_CHAIN (vfields);
-	       vfields = TREE_CHAIN (vfields))
-	    {
-	      tree vf_decl = current_class_decl;
-	      /* ??? This may need to be a loop if there are multiple
-		 levels of replication.  */
-	      if (VF_BINFO_VALUE (vfields))
-		vf_decl = convert_pointer_to (VF_BINFO_VALUE (vfields), vf_decl);
-	      if (vf_decl != error_mark_node)
-		{
-		  /* It is one of these two, or a combination...  */
-		  /* basically speaking, I want to get down to the right
-		     VF_BASETYPE_VALUE (vfields) */
-#if 0
-		  if (VF_NORMAL_VALUE (vfields) != VF_DERIVED_VALUE (vfields))
-		    warning ("hum, wonder if I am doing the right thing");
-#endif
-		  expand_expr_stmt (build_virtual_init (binfo,
-							get_binfo (VF_BASETYPE_VALUE (vfields),
-								   get_binfo (VF_DERIVED_VALUE (vfields), binfo, 0), 0),
-							vf_decl));
-		}
-	    }
-	  expand_expr_stmt (build_virtual_init (binfo, binfo,
-						current_class_decl));
-	}
-      if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
-	expand_expr_stmt (build_vbase_vtables_init (binfo, binfo,
-						    C_C_D, current_class_decl, 0));
-      if (! ok_to_optimize_dtor)
-	{
-	  cond = build_binary_op (NE_EXPR,
-				  current_class_decl, integer_zero_node, 1);
-	  expand_start_cond (cond, 0);
-	}
-      if (mark != get_last_insn ())
-	reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
-      if (! ok_to_optimize_dtor)
-	expand_end_cond ();
-    }
-  else if (current_function_assigns_this)
-    {
-      /* Does not need to call emit_base_init, because
-	 that is done (if needed) just after assignment to this
-	 is seen.  */
-
-      if (DECL_CONSTRUCTOR_P (current_function_decl))
-	{
-	  expand_label (ctor_label);
-	  ctor_label = NULL_TREE;
-
-	  if (call_poplevel)
-	    {
-	      tree decls = getdecls ();
-	      if (flag_handle_exceptions == 2)
-		deactivate_exception_cleanups ();
-	      expand_end_bindings (decls, decls != NULL_TREE, 0);
-	      poplevel (decls != NULL_TREE, 0, 0);
-	    }
-	  c_expand_return (current_class_decl);
-	}
-      else if (TYPE_MAIN_VARIANT (TREE_TYPE (
-			DECL_RESULT (current_function_decl))) != void_type_node
-	       && return_label != NULL_RTX)
-	no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
-
-      current_function_assigns_this = 0;
-      current_function_just_assigned_this = 0;
-      base_init_insns = NULL_RTX;
-    }
-  else if (DECL_CONSTRUCTOR_P (fndecl))
-    {
-      tree allocated_this;
-      tree cond, thenclause;
-      /* Allow constructor for a type to get a new instance of the object
-	 using `build_new'.  */
-      tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
-      CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = NULL_TREE;
-
-      DECL_RETURNS_FIRST_ARG (fndecl) = 1;
-
-      if (flag_this_is_variable > 0)
-	{
-	  cond = build_binary_op (EQ_EXPR,
-				  current_class_decl, integer_zero_node, 1);
-	  thenclause = build_modify_expr (current_class_decl, NOP_EXPR,
-					  build_new (NULL_TREE, current_class_type, void_type_node, 0));
-	  if (flag_handle_exceptions == 2)
-	    {
-	      tree cleanup, cleanup_deallocate;
-	      tree virtual_size;
-
-	      /* This is the size of the virtual object pointed to by
-		 allocated_this.  In this case, it is simple.  */
-	      virtual_size = c_sizeof (current_class_type);
-
-	      allocated_this = build_decl (VAR_DECL, NULL_TREE, ptr_type_node);
-	      DECL_REGISTER (allocated_this) = 1;
-	      DECL_INITIAL (allocated_this) = error_mark_node;
-	      expand_decl (allocated_this);
-	      expand_decl_init (allocated_this);
-	      /* How we cleanup `this' if an exception was raised before
-		 we are ready to bail out.  */
-	      cleanup = TREE_GETS_DELETE (current_class_type)
-		? build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, allocated_this, virtual_size, NULL_TREE)
-		  /* The size of allocated_this is wrong, and hence the
-		     second argument to operator delete will be wrong. */
-		  : build_delete (TREE_TYPE (allocated_this), allocated_this,
-				  integer_three_node,
-				  LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE, 1, 0);
-	      cleanup_deallocate
-		= build_modify_expr (current_class_decl, NOP_EXPR, integer_zero_node);
-	      cleanup = tree_cons (NULL_TREE, cleanup,
-				   build_tree_list (NULL_TREE, cleanup_deallocate));
-
-	      expand_decl_cleanup (allocated_this,
-				   build (COND_EXPR, integer_type_node,
-					  build (NE_EXPR, integer_type_node,
-						 allocated_this, integer_zero_node),
-					  build_compound_expr (cleanup),
-					  integer_zero_node));
-	    }
-	}
-      else if (TREE_GETS_NEW (current_class_type))
-	/* Just check visibility here.  */
-	build_method_call (build1 (NOP_EXPR, TYPE_POINTER_TO (current_class_type), error_mark_node),
-			   ansi_opname[(int) NEW_EXPR],
-			   build_tree_list (NULL_TREE, integer_zero_node),
-			   NULL_TREE, LOOKUP_NORMAL);
-
-      CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = abstract_virtuals;
-
-      /* must keep the first insn safe.  */
-      head = get_insns ();
-
-      /* this note will come up to the top with us.  */
-      mark = get_last_insn ();
-
-      if (flag_this_is_variable > 0)
-	{
-	  expand_start_cond (cond, 0);
-	  expand_expr_stmt (thenclause);
-	  if (flag_handle_exceptions == 2)
-	    expand_assignment (allocated_this, current_class_decl, 0, 0);
-	  expand_end_cond ();
-	}
-
-      if (DECL_NAME (fndecl) == NULL_TREE
-	  && TREE_CHAIN (DECL_ARGUMENTS (fndecl)) != NULL_TREE)
-	build_default_constructor (fndecl);
-
-      /* Emit insns from `emit_base_init' which sets up virtual
-	 function table pointer(s).  */
-      emit_insns (base_init_insns);
-      base_init_insns = NULL_RTX;
-
-      /* This is where the body of the constructor begins.
-	 If there were no insns in this function body, then the
-	 last_parm_insn is also the last insn.
-
-	 If optimization is enabled, last_parm_insn may move, so
-	 we don't hold on to it (across emit_base_init).  */
-      last_parm_insn = get_first_nonparm_insn ();
-      if (last_parm_insn == NULL_RTX) last_parm_insn = mark;
-      else last_parm_insn = previous_insn (last_parm_insn);
-
-      if (mark != get_last_insn ())
-	reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
-
-      /* This is where the body of the constructor ends.  */
-      expand_label (ctor_label);
-      ctor_label = NULL_TREE;
-      if (flag_handle_exceptions == 2)
-	{
-	  expand_assignment (allocated_this, integer_zero_node, 0, 0);
-	  if (call_poplevel)
-	    deactivate_exception_cleanups ();
-	}
-
-      pop_implicit_try_blocks (NULL_TREE);
-
-      if (call_poplevel)
-	{
-	  expand_end_bindings (getdecls (), 1, 0);
-	  poplevel (1, 1, 0);
-	}
-
-      c_expand_return (current_class_decl);
-
-      current_function_assigns_this = 0;
-      current_function_just_assigned_this = 0;
-    }
-  else if (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
-	   && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main")
-	   && DECL_CONTEXT (fndecl) == NULL_TREE)
-    {
-      /* Make it so that `main' always returns 0 by default.  */
-#ifdef VMS
-      c_expand_return (integer_one_node);
-#else
-      c_expand_return (integer_zero_node);
-#endif
-    }
-  else if (return_label != NULL_RTX
-	   && current_function_return_value == NULL_TREE
-	   && ! DECL_NAME (DECL_RESULT (current_function_decl)))
-    no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
-
-  if (flag_gc)
-    expand_gc_prologue_and_epilogue ();
-
-  /* That's the end of the vtable decl's life.  Need to mark it such
-     if doing stupid register allocation.
-
-     Note that current_vtable_decl is really an INDIRECT_REF
-     on top of a VAR_DECL here.  */
-  if (obey_regdecls && current_vtable_decl)
-    use_variable (DECL_RTL (TREE_OPERAND (current_vtable_decl, 0)));
-
-  /* If this function is supposed to return a value, ensure that
-     we do not fall into the cleanups by mistake.  The end of our
-     function will look like this:
-
-	user code (may have return stmt somewhere)
-	goto no_return_label
-	cleanup_label:
-	cleanups
-	goto return_label
-	no_return_label:
-	NOTE_INSN_FUNCTION_END
-	return_label:
-	things for return
-
-     If the user omits a return stmt in the USER CODE section, we
-     will have a control path which reaches NOTE_INSN_FUNCTION_END.
-     Otherwise, we won't.  */
-  if (no_return_label)
-    {
-      DECL_CONTEXT (no_return_label) = fndecl;
-      DECL_INITIAL (no_return_label) = error_mark_node;
-      DECL_SOURCE_FILE (no_return_label) = input_filename;
-      DECL_SOURCE_LINE (no_return_label) = lineno;
-      expand_goto (no_return_label);
-    }
-
-  if (cleanup_label)
-    {
-      /* remove the binding contour which is used
-	 to catch cleanup-generated temporaries.  */
-      expand_end_bindings (0, 0, 0);
-      poplevel (0, 0, 0);
-    }
-
-  if (cleanup_label)
-    /* Emit label at beginning of cleanup code for parameters.  */
-    emit_label (cleanup_label);
-
-#if 1
-  /* Cheap hack to get better code from GNU C++.  Remove when cse is fixed.  */
-  if (exception_throw_decl && sets_exception_throw_decl == 0)
-    expand_assignment (exception_throw_decl, integer_zero_node, 0, 0);
-#endif
-
-  if (flag_handle_exceptions)
-    {
-      expand_end_try ();
-      expand_start_except (0, 0);
-      expand_end_except ();
-    }
-  expand_end_bindings (0, 0, 0);
-
-  /* Get return value into register if that's where it's supposed to be.  */
-  if (original_result_rtx)
-    fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
-
-  /* Finish building code that will trigger warnings if users forget
-     to make their functions return values.  */
-  if (no_return_label || cleanup_label)
-    emit_jump (return_label);
-  if (no_return_label)
-    {
-      /* We don't need to call `expand_*_return' here because we
-	 don't need any cleanups here--this path of code is only
-	 for error checking purposes.  */
-      expand_label (no_return_label);
-    }
-
-  /* reset scope for C++: if we were in the scope of a class,
-     then when we finish this function, we are not longer so.
-     This cannot be done until we know for sure that no more
-     class members will ever be referenced in this function
-     (i.e., calls to destructors).  */
-  if (current_class_name)
-    {
-      ctype = current_class_type;
-      popclass (1);
-    }
-  else
-    pop_memoized_context (1);
-
-  /* Forget about all overloaded functions defined in
-     this scope which go away.  */
-  while (overloads_to_forget)
-    {
-      IDENTIFIER_GLOBAL_VALUE (TREE_PURPOSE (overloads_to_forget))
-	= TREE_VALUE (overloads_to_forget);
-      overloads_to_forget = TREE_CHAIN (overloads_to_forget);
-    }
-
-  /* Generate rtl for function exit.  */
-  expand_function_end (input_filename, lineno);
-
-  /* This must come after expand_function_end because cleanups might
-     have declarations (from inline functions) that need to go into
-     this function's blocks.  */
-  if (current_binding_level->parm_flag != 1)
-    my_friendly_abort (122);
-  poplevel (1, 0, 1);
-
-  /* Must mark the RESULT_DECL as being in this function.  */
-  DECL_CONTEXT (DECL_RESULT (fndecl)) = DECL_INITIAL (fndecl);
-
-  /* Obey `register' declarations if `setjmp' is called in this fn.  */
-  if (flag_traditional && current_function_calls_setjmp)
-    setjmp_protect (DECL_INITIAL (fndecl));
-
-  /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
-     to the FUNCTION_DECL node itself.  */
-  BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
-
-  /* So we can tell if jump_optimize sets it to 1.  */
-  can_reach_end = 0;
-
-  /* ??? Compensate for Sun brain damage in dealing with data segments
-     of PIC code.  */
-  if (flag_pic
-      && (DECL_CONSTRUCTOR_P (fndecl)
-	  || DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
-      && CLASSTYPE_NEEDS_VIRTUAL_REINIT (TYPE_METHOD_BASETYPE (fntype)))
-    DECL_INLINE (fndecl) = 0;
-
-  if (DECL_EXTERNAL (fndecl)
-      /* This function is just along for the ride.  If we can make
-	 it inline, that's great.  Otherwise, just punt it.  */
-      && (DECL_INLINE (fndecl) == 0
-	  || flag_no_inline
-	  || function_cannot_inline_p (fndecl)))
-    {
-      extern int rtl_dump_and_exit;
-      int old_rtl_dump_and_exit = rtl_dump_and_exit;
-      int inline_spec = DECL_INLINE (fndecl);
-
-      /* This throws away the code for FNDECL.  */
-      rtl_dump_and_exit = 1;
-      /* This throws away the memory of the code for FNDECL.  */
-      if (flag_no_inline)
-	DECL_INLINE (fndecl) = 0;
-      rest_of_compilation (fndecl);
-      rtl_dump_and_exit = old_rtl_dump_and_exit;
-      DECL_INLINE (fndecl) = inline_spec;
-    }
-  else
-    {
-      /* Run the optimizers and output the assembler code for this function.  */
-      rest_of_compilation (fndecl);
-    }
-
-  if (ctype && TREE_ASM_WRITTEN (fndecl))
-    note_debug_info_needed (ctype);
-
-  current_function_returns_null |= can_reach_end;
-
-  /* Since we don't normally go through c_expand_return for constructors,
-     this normally gets the wrong value.
-     Also, named return values have their return codes emitted after
-     NOTE_INSN_FUNCTION_END, confusing jump.c.  */
-  if (DECL_CONSTRUCTOR_P (fndecl)
-      || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
-    current_function_returns_null = 0;
-
-  if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
-    warning ("`volatile' function does return");
-  else if (warn_return_type && current_function_returns_null
-	   && TYPE_MAIN_VARIANT (TREE_TYPE (fntype)) != void_type_node)
-    {
-      /* If this function returns non-void and control can drop through,
-	 complain.  */
-      pedwarn ("control reaches end of non-void function");
-    }
-  /* With just -W, complain only if function returns both with
-     and without a value.  */
-  else if (extra_warnings
-	   && current_function_returns_value && current_function_returns_null)
-    warning ("this function may return with or without a value");
-
-  /* Free all the tree nodes making up this function.  */
-  /* Switch back to allocating nodes permanently
-     until we start another function.  */
-  permanent_allocation ();
-
-  if (flag_cadillac)
-    cadillac_finish_function (fndecl);
-
-  if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
-    {
-      /* Stop pointing to the local nodes about to be freed.  */
-      /* But DECL_INITIAL must remain nonzero so we know this
-	 was an actual function definition.  */
-      DECL_INITIAL (fndecl) = error_mark_node;
-      if (! DECL_CONSTRUCTOR_P (fndecl)
-	  || !TYPE_USES_VIRTUAL_BASECLASSES (TYPE_METHOD_BASETYPE (fntype)))
-	DECL_ARGUMENTS (fndecl) = NULL_TREE;
-    }
-
-  /* Let the error reporting routines know that we're outside a function.  */
-  current_function_decl = NULL_TREE;
-  named_label_uses = NULL_TREE;
-  clear_anon_parm_name ();
-}
-
-/* Create the FUNCTION_DECL for a function definition.
-   LINE1 is the line number that the definition absolutely begins on.
-   LINE2 is the line number that the name of the function appears on.
-   DECLSPECS and DECLARATOR are the parts of the declaration;
-   they describe the function's name and the type it returns,
-   but twisted together in a fashion that parallels the syntax of C.
-
-   This function creates a binding context for the function body
-   as well as setting up the FUNCTION_DECL in current_function_decl.
-
-   Returns a FUNCTION_DECL on success.
-
-   If the DECLARATOR is not suitable for a function (it defines a datum
-   instead), we return 0, which tells yyparse to report a parse error.
-
-   May return void_type_node indicating that this method is actually
-   a friend.  See grokfield for more details.
-
-   Came here with a `.pushlevel' .
-
-   DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
-   CHANGES TO CODE IN `grokfield'.  */
-tree
-start_method (declspecs, declarator, raises)
-     tree declarator, declspecs, raises;
-{
-  tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0, raises);
-
-  /* Something too ugly to handle.  */
-  if (fndecl == NULL_TREE)
-    return NULL_TREE;
-
-  /* Pass friends other than inline friend functions back.  */
-  if (TYPE_MAIN_VARIANT (fndecl) == void_type_node)
-    return fndecl;
-
-  if (TREE_CODE (fndecl) != FUNCTION_DECL)
-    /* Not a function, tell parser to report parse error.  */
-    return NULL_TREE;
-
-  if (DECL_IN_AGGR_P (fndecl))
-    {
-      if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
-	{
-	  if (DECL_CONTEXT (fndecl))
-	    error_with_decl (fndecl, "`%s' is already defined in class %s",
-			     TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
-	}
-      return void_type_node;
-    }
-
-  /* If we're expanding a template, a function must be explicitly declared
-     inline if we're to compile it now.  If it isn't, we have to wait to see
-     whether it's needed, and whether an override exists.  */
-  if (flag_default_inline && !processing_template_defn)
-    DECL_INLINE (fndecl) = 1;
-
-  /* We read in the parameters on the maybepermanent_obstack,
-     but we won't be getting back to them until after we
-     may have clobbered them.  So the call to preserve_data
-     will keep them safe.  */
-  preserve_data ();
-
-  if (! DECL_FRIEND_P (fndecl))
-    {
-      if (DECL_CHAIN (fndecl) != NULL_TREE)
-	{
-	  /* Need a fresh node here so that we don't get circularity
-	     when we link these together.  If FNDECL was a friend, then
-	     `pushdecl' does the right thing, which is nothing wrt its
-	     current value of DECL_CHAIN.  */
-	  fndecl = copy_node (fndecl);
-	}
-      if (TREE_CHAIN (fndecl))
-	{
-	  fndecl = copy_node (fndecl);
-	  TREE_CHAIN (fndecl) = NULL_TREE;
-	}
-
-      if (DECL_CONSTRUCTOR_P (fndecl))
-	grok_ctor_properties (current_class_type, fndecl);
-      else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
-	grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl));
-    }
-
-  finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
-
-  /* Make a place for the parms */
-  pushlevel (0);
-  current_binding_level->parm_flag = 1;
-  
-  DECL_IN_AGGR_P (fndecl) = 1;
-  return fndecl;
-}
-
-/* Go through the motions of finishing a function definition.
-   We don't compile this method until after the whole class has
-   been processed.
-
-   FINISH_METHOD must return something that looks as though it
-   came from GROKFIELD (since we are defining a method, after all).
-
-   This is called after parsing the body of the function definition.
-   STMTS is the chain of statements that makes up the function body.
-
-   DECL is the ..._DECL that `start_method' provided.  */
-
-tree
-finish_method (decl)
-     tree decl;
-{
-  register tree fndecl = decl;
-  tree old_initial;
-  tree context = DECL_CONTEXT (fndecl);
-
-  register tree link;
-
-  if (TYPE_MAIN_VARIANT (decl) == void_type_node)
-    return decl;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "finish_method");
-  debug_bindings_indentation += 4;
-#endif
-
-  old_initial = DECL_INITIAL (fndecl);
-
-  /* Undo the level for the parms (from start_method).
-     This is like poplevel, but it causes nothing to be
-     saved.  Saving information here confuses symbol-table
-     output routines.  Besides, this information will
-     be correctly output when this method is actually
-     compiled.  */
-
-  /* Clear out the meanings of the local variables of this level;
-     also record in each decl which block it belongs to.  */
-
-  for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
-    {
-      if (DECL_NAME (link) != NULL_TREE)
-	IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
-      my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
-      DECL_CONTEXT (link) = NULL_TREE;
-    }
-
-  /* Restore all name-meanings of the outer levels
-     that were shadowed by this level.  */
-
-  for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
-      IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
-  for (link = current_binding_level->class_shadowed;
-       link; link = TREE_CHAIN (link))
-    IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
-  for (link = current_binding_level->type_shadowed;
-       link; link = TREE_CHAIN (link))
-    IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
-
-  GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
-		      (HOST_WIDE_INT) current_binding_level->level_chain,
-		      current_binding_level->parm_flag,
-		      current_binding_level->keep,
-		      current_binding_level->tag_transparent);
-
-  pop_binding_level ();
-
-  DECL_INITIAL (fndecl) = old_initial;
-#if 0
-  /* tiemann would like this, but is causes String.cc to not compile. */
-  if (DECL_FRIEND_P (fndecl) || DECL_CONTEXT (fndecl) != current_class_type)
-#else
-  if (DECL_FRIEND_P (fndecl))
-#endif
-    {
-      CLASSTYPE_INLINE_FRIENDS (current_class_type)
-	= tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
-      decl = void_type_node;
-    }
-#if 0
-  /* Work in progress, 9/17/92. */
-  else if (context != current_class_type
-	   && TREE_CHAIN (context) != NULL_TREE
-	   && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)))
-    {
-      /* Don't allow them to declare a function like this:
-       class A {
-       public:
-         class B {
-         public:
-           int f();
-         };
-         int B::f() {}
-       };
-
-       Note we can get in here if it's a friend (in which case we'll
-       avoid lots of nasty cruft), or it's a destructor.  Compensate.
-      */
-      tree tmp = DECL_ARGUMENTS (TREE_CHAIN (context));
-      if (tmp
-	  && TREE_CODE (tmp) == IDENTIFIER_NODE
-	  && TREE_CHAIN (IDENTIFIER_GLOBAL_VALUE (tmp))
-	  && TREE_CODE (TREE_CHAIN (IDENTIFIER_GLOBAL_VALUE (tmp))) == TYPE_DECL)
-	{
-	  error_with_decl (decl,
-			   "qualified name used in declaration of `%s'");
-	  /* Make this node virtually unusable in the end.  */
-	  TREE_CHAIN (decl) = NULL_TREE;
-	}
-    }
-#endif
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-
-  return decl;
-}
-
-/* Called when a new struct TYPE is defined.
-   If this structure or union completes the type of any previous
-   variable declaration, lay it out and output its rtl.  */
-
-void
-hack_incomplete_structures (type)
-     tree type;
-{
-  tree decl;
-
-  if (current_binding_level->n_incomplete == 0)
-    return;
-
-  if (!type) /* Don't do this for class templates.  */
-    return;
-
-  for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
-    if (TREE_TYPE (decl) == type
-	|| (TREE_TYPE (decl)
-	    && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
-	    && TREE_TYPE (TREE_TYPE (decl)) == type))
-      {
-	if (TREE_CODE (decl) == TYPE_DECL)
-	  layout_type (TREE_TYPE (decl));
-	else
-	  {
-	    int toplevel = global_binding_level == current_binding_level;
-	    if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
-		&& TREE_TYPE (TREE_TYPE (decl)) == type)
-	      layout_type (TREE_TYPE (decl));
-	    layout_decl (decl, 0);
-	    rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
-	    if (! toplevel)
-	      {
-		expand_decl (decl);
-		expand_decl_cleanup (decl, maybe_build_cleanup (decl));
-		expand_decl_init (decl);
-	      }
-	  }
-	my_friendly_assert (current_binding_level->n_incomplete > 0, 164);
-	--current_binding_level->n_incomplete;
-      }
-}
-
-/* Nonzero if presently building a cleanup.  Needed because
-   SAVE_EXPRs are not the right things to use inside of cleanups.
-   They are only ever evaluated once, where the cleanup
-   might be evaluated several times.  In this case, a later evaluation
-   of the cleanup might fill in the SAVE_EXPR_RTL, and it will
-   not be valid for an earlier cleanup.  */
-
-int building_cleanup;
-
-/* If DECL is of a type which needs a cleanup, build that cleanup here.
-   We don't build cleanups if just going for syntax checking, since
-   fixup_cleanups does not know how to not handle them.
-
-   Don't build these on the momentary obstack; they must live
-   the life of the binding contour.  */
-tree
-maybe_build_cleanup (decl)
-     tree decl;
-{
-  tree type = TREE_TYPE (decl);
-  if (TYPE_NEEDS_DESTRUCTOR (type))
-    {
-      int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
-      tree rval;
-      int old_building_cleanup = building_cleanup;
-      building_cleanup = 1;
-
-      if (TREE_CODE (decl) != PARM_DECL)
-	temp = suspend_momentary ();
-
-      if (TREE_CODE (type) == ARRAY_TYPE)
-	rval = decl;
-      else
-	{
-	  mark_addressable (decl);
-	  rval = build_unary_op (ADDR_EXPR, decl, 0);
-	}
-
-      /* Optimize for space over speed here.  */
-      if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
-	  || flag_expensive_optimizations)
-	flags |= LOOKUP_NONVIRTUAL;
-
-      /* Use TYPE_MAIN_VARIANT so we don't get a warning about
-	 calling delete on a `const' variable.  */
-      if (TYPE_READONLY (TREE_TYPE (TREE_TYPE (rval))))
-	rval = build1 (NOP_EXPR, TYPE_POINTER_TO (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (rval)))), rval);
-
-      rval = build_delete (TREE_TYPE (rval), rval, integer_two_node, flags, 0, 0);
-
-      if (TYPE_USES_VIRTUAL_BASECLASSES (type)
-	  && ! TYPE_HAS_DESTRUCTOR (type))
-	rval = build_compound_expr (tree_cons (NULL_TREE, rval,
-					       build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
-
-      current_binding_level->have_cleanups = 1;
-      current_binding_level->more_exceptions_ok = 0;
-
-      if (TREE_CODE (decl) != PARM_DECL)
-	resume_momentary (temp);
-
-      building_cleanup = old_building_cleanup;
-
-      return rval;
-    }
-  return 0;
-}
-
-/* Expand a C++ expression at the statement level.
-   This is needed to ferret out nodes which have UNKNOWN_TYPE.
-   The C++ type checker should get all of these out when
-   expressions are combined with other, type-providing, expressions,
-   leaving only orphan expressions, such as:
-
-   &class::bar;		/ / takes its address, but does nothing with it.
-
-   */
-void
-cplus_expand_expr_stmt (exp)
-     tree exp;
-{
-  if (TREE_TYPE (exp) == unknown_type_node)
-    {
-      if (TREE_CODE (exp) == ADDR_EXPR || TREE_CODE (exp) == TREE_LIST)
-	error ("address of overloaded function with no contextual type information");
-      else if (TREE_CODE (exp) == COMPONENT_REF)
-	warning ("useless reference to a member function name, did you forget the ()?");
-    }
-  else
-    {
-      int remove_implicit_immediately = 0;
-
-      if (TREE_CODE (exp) == FUNCTION_DECL)
-	{
-	  warning_with_decl (exp, "reference, not call, to function `%s'");
-	  warning ("at this point in file");
-	}
-      if (TREE_RAISES (exp))
-	{
-	  my_friendly_assert (flag_handle_exceptions, 165);
-	  if (flag_handle_exceptions == 2)
-	    {
-	      if (! current_binding_level->more_exceptions_ok)
-		{
-		  extern struct nesting *nesting_stack, *block_stack;
-
-		  remove_implicit_immediately
-		    = (nesting_stack != block_stack);
-		  cplus_expand_start_try (1);
-		}
-	      current_binding_level->have_exceptions = 1;
-	    }
-	}
-
-      expand_expr_stmt (break_out_cleanups (exp));
-
-      if (remove_implicit_immediately)
-	pop_implicit_try_blocks (NULL_TREE);
-    }
-
-  /* Clean up any pending cleanups.  This happens when a function call
-     returns a cleanup-needing value that nobody uses.  */
-  expand_cleanups_to (NULL_TREE);
-}
-
-/* When a stmt has been parsed, this function is called.
-
-   Currently, this function only does something within a
-   constructor's scope: if a stmt has just assigned to this,
-   and we are in a derived class, we call `emit_base_init'.  */
-
-void
-finish_stmt ()
-{
-  extern struct nesting *cond_stack, *loop_stack, *case_stack;
-
-  
-  if (current_function_assigns_this
-      || ! current_function_just_assigned_this)
-    return;
-  if (DECL_CONSTRUCTOR_P (current_function_decl))
-    {
-      /* Constructors must wait until we are out of control
-	 zones before calling base constructors.  */
-      if (cond_stack || loop_stack || case_stack)
-	return;
-      emit_insns (base_init_insns);
-      check_base_init (current_class_type);
-    }
-  current_function_assigns_this = 1;
-
-  if (flag_cadillac)
-    cadillac_finish_stmt ();
-}
-
-void
-pop_implicit_try_blocks (decl)
-     tree decl;
-{
-  if (decl)
-    {
-      my_friendly_assert (current_binding_level->parm_flag == 3, 166);
-      current_binding_level->names = TREE_CHAIN (decl);
-    }
-
-  while (current_binding_level->parm_flag == 3)
-    {
-      tree name = get_identifier ("(compiler error)");
-      tree orig_ex_type = current_exception_type;
-      tree orig_ex_decl = current_exception_decl;
-      tree orig_ex_obj = current_exception_object;
-      tree decl = cplus_expand_end_try (2);
-
-      /* @@ It would be nice to make all these point
-	 to exactly the same handler.  */
-      /* Start hidden EXCEPT.  */
-      cplus_expand_start_except (name, decl);
-      /* reraise ALL.  */
-      cplus_expand_reraise (NULL_TREE);
-      current_exception_type = orig_ex_type;
-      current_exception_decl = orig_ex_decl;
-      current_exception_object = orig_ex_obj;
-      /* This will reraise for us.  */
-      cplus_expand_end_except (error_mark_node);
-    }
-
-  if (decl)
-    {
-      TREE_CHAIN (decl) = current_binding_level->names;
-      current_binding_level->names = decl;
-    }
-}
-
-/* Push a cleanup onto the current binding contour that will cause
-   ADDR to be cleaned up, in the case that an exception propagates
-   through its binding contour.  */
-
-void
-push_exception_cleanup (addr)
-     tree addr;
-{
-  tree decl = build_decl (VAR_DECL, get_identifier (EXCEPTION_CLEANUP_NAME), ptr_type_node);
-  tree cleanup;
-
-  decl = pushdecl (decl);
-  DECL_REGISTER (decl) = 1;
-  store_init_value (decl, addr);
-  expand_decl (decl);
-  expand_decl_init (decl);
-
-  cleanup = build (COND_EXPR, integer_type_node,
-		   build (NE_EXPR, integer_type_node,
-			  decl, integer_zero_node),
-		   build_delete (TREE_TYPE (addr), decl,
-				 lookup_name (in_charge_identifier, 0),
-				 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0, 0),
-		   integer_zero_node);
-  expand_decl_cleanup (decl, cleanup);
-}
-
-/* For each binding contour, emit code that deactivates the
-   exception cleanups.  All other cleanups are left as they were.  */
-
-static void
-deactivate_exception_cleanups ()
-{
-  struct binding_level *b = current_binding_level;
-  tree xyzzy = get_identifier (EXCEPTION_CLEANUP_NAME);
-  while (b != class_binding_level)
-    {
-      if (b->parm_flag == 3)
-	{
-	  tree decls = b->names;
-	  while (decls)
-	    {
-	      if (DECL_NAME (decls) == xyzzy)
-		expand_assignment (decls, integer_zero_node, 0, 0);
-	      decls = TREE_CHAIN (decls);
-	    }
-	}
-      b = b->level_chain;
-    }
-}
-
-/* Change a static member function definition into a FUNCTION_TYPE, instead
-   of the METHOD_TYPE that we create when it's originally parsed.  */
-void
-revert_static_member_fn (fn, decl, argtypes)
-     tree *fn, *decl, *argtypes;
-{
-  tree tmp, function = *fn;
-
-  *argtypes = TREE_CHAIN (*argtypes);
-  tmp = build_function_type (TREE_TYPE (function), *argtypes);
-  tmp = build_type_variant (tmp, TYPE_READONLY (function),
-			    TYPE_VOLATILE (function));
-  tmp = build_exception_variant (TYPE_METHOD_BASETYPE (function), tmp,
-				 TYPE_RAISES_EXCEPTIONS (function));
-  TREE_TYPE (*decl) = tmp;
-  *fn = tmp;
-  DECL_STATIC_FUNCTION_P (*decl) = 1;
-}
diff --git a/gnu/gcc2/cc1plus/cp-decl.h b/gnu/gcc2/cc1plus/cp-decl.h
deleted file mode 100644
index aabfa2fb9264..000000000000
--- a/gnu/gcc2/cc1plus/cp-decl.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Variables and structures for declaration processing.
-   Copyright (C) 1993 Free Software Foundation, Inc.
-
-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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* In grokdeclarator, distinguish syntactic contexts of declarators.  */
-enum decl_context
-{ NORMAL,			/* Ordinary declaration */
-  FUNCDEF,			/* Function definition */
-  PARM,				/* Declaration of parm before function body */
-  FIELD,			/* Declaration inside struct or union */
-  BITFIELD,			/* Likewise but with specified width */
-  TYPENAME,			/* Typename (inside cast or sizeof)  */
-  MEMFUNCDEF			/* Member function definition */
-};
-
-/* C++: Keep these around to reduce calls to `get_identifier'.
-   Identifiers for `this' in member functions and the auto-delete
-   parameter for destructors.  */
-extern tree this_identifier, in_charge_identifier;
-
-/* Parsing a function declarator leaves a list of parameter names
-   or a chain or parameter decls here.  */
-extern tree last_function_parms;
-
-/* A list of static class variables.  This is needed, because a
-   static class variable can be declared inside the class without
-   an initializer, and then initialized, staticly, outside the class.  */
-extern tree pending_statics;
-
-/* 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.  */
-extern tree static_aggregates;
-
-/* A list of functions which were declared inline, but later had their
-   address taken.  Used only for non-virtual member functions, since we can
-   find other functions easily enough.  */
-extern tree pending_addressable_inlines;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-/* Purely for debugging purposes.  */
-extern int debug_bindings_indentation;
-#endif
diff --git a/gnu/gcc2/cc1plus/cp-decl2.c b/gnu/gcc2/cc1plus/cp-decl2.c
deleted file mode 100644
index bb1a9cd7b828..000000000000
--- a/gnu/gcc2/cc1plus/cp-decl2.c
+++ /dev/null
@@ -1,2451 +0,0 @@
-/* Process declarations and variables for C compiler.
-   Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, 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 <stdio.h>
-#include "tree.h"
-#include "rtl.h"
-#include "flags.h"
-#include "cp-tree.h"
-#include "cp-decl.h"
-#include "cp-lex.h"
-
-extern tree grokdeclarator ();
-static void grok_function_init ();
-
-/* A list of virtual function tables we must make sure to write out.  */
-tree pending_vtables;
-
-/* A list of static class variables.  This is needed, because a
-   static class variable can be declared inside the class without
-   an initializer, and then initialized, staticly, outside the class.  */
-tree pending_statics;
-
-extern tree pending_addressable_inlines;
-
-/* Used to help generate temporary names which are unique within
-   a function.  Reset to 0 by start_function.  */
-
-static int temp_name_counter;
-
-/* Same, but not reset.  Local temp variables and global temp variables
-   can have the same name.  */
-static int global_temp_name_counter;
-
-/* The (assembler) name of the first globally-visible object output.  */
-extern char * first_global_object_name;
-
-/* Flag used when debugging cp-spew.c */
-
-extern int spew_debug;
-
-/* C (and C++) language-specific option variables.  */
-
-/* Nonzero means allow type mismatches in conditional expressions;
-   just make their values `void'.   */
-
-int flag_cond_mismatch;
-
-/* Nonzero means give `double' the same size as `float'.  */
-
-int flag_short_double;
-
-/* Nonzero means don't recognize the keyword `asm'.  */
-
-int flag_no_asm;
-
-/* Nonzero means don't recognize the non-ANSI builtin functions.  */
-
-int flag_no_builtin;
-
-/* Nonzero means do some things the same way PCC does.  */
-
-int flag_traditional;
-
-/* Nonzero means to treat bitfields as unsigned unless they say `signed'.  */
-
-int flag_signed_bitfields = 1;
-
-/* Nonzero means handle `#ident' directives.  0 means ignore them.  */
-
-int flag_no_ident = 0;
-
-/* Nonzero means handle things in ANSI, instead of GNU fashion.  This
-   flag should be tested for language behavior that's different between
-   ANSI and GNU, but not so horrible as to merit a PEDANTIC label.  */
-
-int flag_ansi = 0;
-
-/* Nonzero means do emit exported implementations of functions even if
-   they can be inlined.  */
-
-int flag_implement_inlines = 1;
-
-/* Nonzero means warn about implicit declarations.  */
-
-int warn_implicit = 1;
-
-/* Like `warn_return_type', but this is set by users, whereas
-   `warn_return_type' is set by the compiler.  */
-
-int explicit_warn_return_type;
-
-/* Nonzero means give string constants the type `const char *'
-   to get extra warnings from them.  These warnings will be too numerous
-   to be useful, except in thoroughly ANSIfied programs.  */
-
-int warn_write_strings;
-
-/* Nonzero means warn about pointer casts that can drop a type qualifier
-   from the pointer target type.  */
-
-int warn_cast_qual;
-
-/* Nonzero means warn that dbx info for template class methods isn't fully
-   supported yet.  */
-
-int warn_template_debugging;
-
-/* Warn about traditional constructs whose meanings changed in ANSI C.  */
-
-int warn_traditional;
-
-/* Nonzero means warn about sizeof(function) or addition/subtraction
-   of function pointers.  */
-
-int warn_pointer_arith;
-
-/* Nonzero means warn for non-prototype function decls
-   or non-prototyped defs without previous prototype.  */
-
-int warn_strict_prototypes;
-
-/* Nonzero means warn for any function def without prototype decl.  */
-
-int warn_missing_prototypes;
-
-/* Nonzero means warn about multiple (redundant) decls for the same single
-   variable or function.  */
-
-int warn_redundant_decls;
-
-/* Warn about *printf or *scanf format/argument anomalies. */
-
-int warn_format;
-
-/* Warn about a subscript that has type char.  */
-
-int warn_char_subscripts = 0;
-
-/* Warn if a type conversion is done that might have confusing results.  */
-
-int warn_conversion;
-
-/* Warn if adding () is suggested.  */
-
-int warn_parentheses = 1;
-
-/* Non-zero means warn in function declared in derived class has the
-   same name as a virtual in the base class, but fails to match the
-   type signature of any virtual function in the base class.  */
-int warn_overloaded_virtual;
-
-/* Non-zero means warn when converting between different enumeral types.  */
-int warn_enum_clash;
-
-/* Non-zero means warn when declaring a class that has a non virtual
-   destructor, when it really ought to have a virtual one. */
-int warn_nonvdtor = 1;
-
-/* Nonzero means `$' can be in an identifier.
-   See cccp.c for reasons why this breaks some obscure ANSI C programs.  */
-
-#ifndef DOLLARS_IN_IDENTIFIERS
-#define DOLLARS_IN_IDENTIFIERS 1
-#endif
-int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
-
-/* Nonzero for -no-strict-prototype switch: do not consider empty
-   argument prototype to mean function takes no arguments.  */
-
-int strict_prototype = 1;
-int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus = 1;
-
-/* Nonzero means that labels can be used as first-class objects */
-
-int flag_labels_ok;
-
-/* Non-zero means to collect statistics which might be expensive
-   and to print them when we are done.  */
-int flag_detailed_statistics;
-
-/* C++ specific flags.  */   
-/* Nonzero for -fall-virtual: make every member function (except
-   constructors) lay down in the virtual function table.  Calls
-   can then either go through the virtual function table or not,
-   depending.  */
-
-int flag_all_virtual;
-
-/* Zero means that `this' is a *const.  This gives nice behavior in the
-   2.0 world.  1 gives 1.2-compatible behavior.  2 gives Spring behavior.
-   -2 means we're constructing an object and it has fixed type.  */
-
-int flag_this_is_variable;
-
-/* Nonzero means memoize our member lookups.  */
-
-int flag_memoize_lookups; int flag_save_memoized_contexts;
-
-/* 3 means write out only virtuals function tables `defined'
-   in this implementation file.
-   2 means write out only specific virtual function tables
-   and give them (C) public visibility.
-   1 means write out virtual function tables and give them
-   (C) public visibility.
-   0 means write out virtual function tables and give them
-   (C) static visibility (default).
-   -1 means declare virtual function tables extern.  */
-
-int write_virtuals;
-
-/* Nonzero means we should attempt to elide constructors when possible.  */
-
-int flag_elide_constructors;
-
-/* Same, but for inline functions: nonzero means write out debug info
-   for inlines.  Zero means do not.  */
-
-int flag_inline_debug;
-
-/* Nonzero means recognize and handle exception handling constructs.
-   2 means handle exceptions the way Spring wants them handled.  */
-
-int flag_handle_exceptions;
-
-/* Nonzero means recognize and handle exception handling constructs.
-   Use ansi syntax and semantics.  WORK IN PROGRESS!
-   2 means handle exceptions the way Spring wants them handled.  */
-
-int flag_ansi_exceptions;
-
-/* Nonzero means that member functions defined in class scope are
-   inline by default.  */
-
-int flag_default_inline = 1;
-
-/* Controls whether enums and ints freely convert.
-   1 means with complete freedom.
-   0 means enums can convert to ints, but not vice-versa.  */
-int flag_int_enum_equivalence;
-
-/* Controls whether compiler is operating under LUCID's Cadillac
-   system.  1 means yes, 0 means no.  */
-int flag_cadillac;
-
-/* Controls whether compiler generates code to build objects
-   that can be collected when they become garbage.  */
-int flag_gc;
-
-/* Controls whether compiler generates 'dossiers' that give
-   run-time type information.  */
-int flag_dossier;
-
-/* Nonzero if we wish to output cross-referencing information
-   for the GNU class browser.  */
-extern int flag_gnu_xref;
-
-/* Nonzero if compiler can make `reasonable' assumptions about
-   references and objects.  For example, the compiler must be
-   conservative about the following and not assume that `a' is nonnull:
-
-   obj &a = g ();
-   a.f (2);
-
-   In general, it is `reasonable' to assume that for many programs,
-   and better code can be generated in that case.  */
-
-int flag_assume_nonnull_objects;
-
-/* Table of language-dependent -f options.
-   STRING is the option name.  VARIABLE is the address of the variable.
-   ON_VALUE is the value to store in VARIABLE
-    if `-fSTRING' is seen as an option.
-   (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
-
-static struct { char *string; int *variable; int on_value;} lang_f_options[] =
-{
-  {"signed-char", &flag_signed_char, 1},
-  {"unsigned-char", &flag_signed_char, 0},
-  {"signed-bitfields", &flag_signed_bitfields, 1},
-  {"unsigned-bitfields", &flag_signed_bitfields, 0},
-  {"short-enums", &flag_short_enums, 1},
-  {"short-double", &flag_short_double, 1},
-  {"cond-mismatch", &flag_cond_mismatch, 1},
-  {"asm", &flag_no_asm, 0},
-  {"builtin", &flag_no_builtin, 0},
-  {"ident", &flag_no_ident, 0},
-  {"labels-ok", &flag_labels_ok, 1},
-  {"stats", &flag_detailed_statistics, 1},
-  {"this-is-variable", &flag_this_is_variable, 1},
-  {"strict-prototype", &strict_prototypes_lang_cplusplus, 1},
-  {"all-virtual", &flag_all_virtual, 1},
-  {"memoize-lookups", &flag_memoize_lookups, 1},
-  {"elide-constructors", &flag_elide_constructors, 1},
-  {"inline-debug", &flag_inline_debug, 0},
-  {"handle-exceptions", &flag_handle_exceptions, 1},
-  {"ansi-exceptions", &flag_ansi_exceptions, 1},
-  {"spring-exceptions", &flag_handle_exceptions, 2},
-  {"default-inline", &flag_default_inline, 1},
-  {"dollars-in-identifiers", &dollars_in_ident, 1},
-  {"enum-int-equiv", &flag_int_enum_equivalence, 1},
-  {"gc", &flag_gc, 1},
-  {"dossier", &flag_dossier, 1},
-  {"xref", &flag_gnu_xref, 1},
-  {"nonnull-objects", &flag_assume_nonnull_objects, 1},
-  {"implement-inlines", &flag_implement_inlines, 1},
-};
-
-/* Decode the string P as a language-specific option.
-   Return 1 if it is recognized (and handle it);
-   return 0 if not recognized.  */
-
-int   
-lang_decode_option (p)
-     char *p;
-{
-  if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
-    flag_traditional = 1, dollars_in_ident = 1, flag_writable_strings = 1,
-    flag_this_is_variable = 1;
-  /* The +e options are for cfront compatibility.  They come in as
-     `-+eN', to kludge around gcc.c's argument handling.  */
-  else if (p[0] == '-' && p[1] == '+' && p[2] == 'e')
-    {
-      int old_write_virtuals = write_virtuals;
-      if (p[3] == '1')
-	write_virtuals = 1;
-      else if (p[3] == '0')
-	write_virtuals = -1;
-      else if (p[3] == '2')
-	write_virtuals = 2;
-      else error ("invalid +e option");
-      if (old_write_virtuals != 0
-	  && write_virtuals != old_write_virtuals)
-	error ("conflicting +e options given");
-    }
-  else if (p[0] == '-' && p[1] == 'f')
-    {
-      /* Some kind of -f option.
-	 P's value is the option sans `-f'.
-	 Search for it in the table of options.  */
-      int found = 0, j;
-
-      p += 2;
-      /* Try special -f options.  */
-
-      if (!strcmp (p, "save-memoized"))
-	{
-	  flag_memoize_lookups = 1;
-	  flag_save_memoized_contexts = 1;
-	  found = 1;
-	}
-      if (!strcmp (p, "no-save-memoized"))
-	{
-	  flag_memoize_lookups = 0;
-	  flag_save_memoized_contexts = 0;
-	  found = 1;
-	}
-      else if (! strncmp (p, "cadillac", 8))
-	{
-	  flag_cadillac = atoi (p+9);
-	  found = 1;
-	}
-      else if (! strncmp (p, "no-cadillac", 11))
-	{
-	  flag_cadillac = 0;
-	  found = 1;
-	}
-      else if (! strcmp (p, "gc"))
-	{
-	  flag_gc = 1;
-	  /* This must come along for the ride.  */
-	  flag_dossier = 1;
-	  found = 1;
-	}
-      else if (! strcmp (p, "no-gc"))
-	{
-	  flag_gc = 0;
-	  /* This must come along for the ride.  */
-	  flag_dossier = 0;
-	  found = 1;
-	}
-      else for (j = 0;
-		!found && j < sizeof (lang_f_options) / sizeof (lang_f_options[0]);
-		j++)
-	{
-	  if (!strcmp (p, lang_f_options[j].string))
-	    {
-	      *lang_f_options[j].variable = lang_f_options[j].on_value;
-	      /* A goto here would be cleaner,
-		 but breaks the vax pcc.  */
-	      found = 1;
-	    }
-	  if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
-	      && ! strcmp (p+3, lang_f_options[j].string))
-	    {
-	      *lang_f_options[j].variable = ! lang_f_options[j].on_value;
-	      found = 1;
-	    }
-	}
-      return found;
-    }
-  else if (p[0] == '-' && p[1] == 'W')
-    {
-      int setting = 1;
-
-      /* The -W options control the warning behavior of the compiler.  */
-      p += 2;
-
-      if (p[0] == 'n' && p[1] == 'o' && p[2] == '-')
-	setting = 0, p += 3;
-
-      if (!strcmp (p, "implicit"))
-	warn_implicit = setting;
-      else if (!strcmp (p, "return-type"))
-	explicit_warn_return_type = setting;
-      else if (!strcmp (p, "write-strings"))
-	warn_write_strings = setting;
-      else if (!strcmp (p, "cast-qual"))
-	warn_cast_qual = setting;
-      else if (!strcmp (p, "traditional"))
-	warn_traditional = setting;
-      else if (!strcmp (p, "char-subscripts"))
-	warn_char_subscripts = setting;
-      else if (!strcmp (p, "pointer-arith"))
-	warn_pointer_arith = setting;
-      else if (!strcmp (p, "strict-prototypes"))
-	warn_strict_prototypes = setting;
-      else if (!strcmp (p, "missing-prototypes"))
-	warn_missing_prototypes = setting;
-      else if (!strcmp (p, "redundant-decls"))
-	warn_redundant_decls = setting;
-      else if (!strcmp (p, "format"))
-	warn_format = setting;
-      else if (!strcmp (p, "conversion"))
-	warn_conversion = setting;
-      else if (!strcmp (p, "parentheses"))
-	warn_parentheses = setting;
-      else if (!strcmp (p, "comment"))
-	;			/* cpp handles this one.  */
-      else if (!strcmp (p, "comments"))
-	;			/* cpp handles this one.  */
-      else if (!strcmp (p, "trigraphs"))
-	;			/* cpp handles this one.  */
-      else if (!strcmp (p, "import"))
-	;			/* cpp handles this one.  */
-      else if (!strcmp (p, "all"))
-	{
-	  extra_warnings = setting;
-	  explicit_warn_return_type = setting;
-	  warn_unused = setting;
-	  warn_implicit = setting;
-	  warn_switch = setting;
-	  /* We save the value of warn_uninitialized, since if they put
-	     -Wuninitialized on the command line, we need to generate a
-	     warning about not using it without also specifying -O.  */
-	  if (warn_uninitialized != 1)
-	    warn_uninitialized = (setting ? 2 : 0);
-	  warn_template_debugging = setting;
-#if 0
-	  warn_enum_clash = setting;
-#endif
-	}
-
-      else if (!strcmp (p, "overloaded-virtual"))
-	warn_overloaded_virtual = setting;
-      else if (!strcmp (p, "enum-clash"))
-	warn_enum_clash = setting;
-      else return 0;
-    }
-  else if (!strcmp (p, "-ansi"))
-    flag_no_asm = 1, dollars_in_ident = 0, flag_ansi = 1;
-#ifdef SPEW_DEBUG
-  /* Undocumented, only ever used when you're invoking cc1plus by hand, since
-     it's probably safe to assume no sane person would ever want to use this
-     under normal circumstances.  */
-  else if (!strcmp (p, "-spew-debug"))
-    spew_debug = 1;
-#endif
-  else
-    return 0;
-
-  return 1;
-}
-
-/* Incorporate `const' and `volatile' qualifiers for member functions.
-   FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
-   QUALS is a list of qualifiers.  */
-tree
-grok_method_quals (ctype, function, quals)
-     tree ctype, function, quals;
-{
-  tree fntype = TREE_TYPE (function);
-  tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
-
-  do
-    {
-      extern tree ridpointers[];
-
-      if (TREE_VALUE (quals) == ridpointers[(int)RID_CONST])
-	{
-	  if (TYPE_READONLY (ctype))
-	    error ("duplicate `%s' %s",
-		   IDENTIFIER_POINTER (TREE_VALUE (quals)),
-		   (TREE_CODE (function) == FUNCTION_DECL
-		    ? "for member function" : "in type declaration"));
-	  ctype = build_type_variant (ctype, 1, TYPE_VOLATILE (ctype));
-	  build_pointer_type (ctype);
-	}
-      else if (TREE_VALUE (quals) == ridpointers[(int)RID_VOLATILE])
-	{
-	  if (TYPE_VOLATILE (ctype))
-	    error ("duplicate `%s' %s",
-		   IDENTIFIER_POINTER (TREE_VALUE (quals)),
-		   (TREE_CODE (function) == FUNCTION_DECL
-		    ? "for member function" : "in type declaration"));
-	  ctype = build_type_variant (ctype, TYPE_READONLY (ctype), 1);
-	  build_pointer_type (ctype);
-	}
-      else
-	my_friendly_abort (20);
-      quals = TREE_CHAIN (quals);
-    }
-  while (quals);
-  fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype),
-				    (TREE_CODE (fntype) == METHOD_TYPE
-				     ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
-				     : TYPE_ARG_TYPES (fntype)));
-  if (raises)
-    fntype = build_exception_variant (ctype, fntype, raises);
-
-  TREE_TYPE (function) = fntype;
-  return ctype;
-}
-
-/* This routine replaces cryptic DECL_NAMEs with readable DECL_NAMEs.
-   It leaves DECL_ASSEMBLER_NAMEs with the correct value.  */
-/* This does not yet work with user defined conversion operators
-   It should.  */
-static void
-substitute_nice_name (decl)
-     tree decl;
-{
-  if (DECL_NAME (decl) && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE)
-    {
-      char *n = decl_as_string (DECL_NAME (decl));
-      if (n[strlen (n) - 1] == ' ')
-	n[strlen (n) - 1] = 0;
-      DECL_NAME (decl) = get_identifier (n);
-    }
-}
-
-/* Classes overload their constituent function names automatically.
-   When a function name is declared in a record structure,
-   its name is changed to it overloaded name.  Since names for
-   constructors and destructors can conflict, we place a leading
-   '$' for destructors.
-
-   CNAME is the name of the class we are grokking for.
-
-   FUNCTION is a FUNCTION_DECL.  It was created by `grokdeclarator'.
-
-   FLAGS contains bits saying what's special about today's
-   arguments.  1 == DESTRUCTOR.  2 == OPERATOR.
-
-   If FUNCTION is a destructor, then we must add the `auto-delete' field
-   as a second parameter.  There is some hair associated with the fact
-   that we must "declare" this variable in the manner consistent with the
-   way the rest of the arguments were declared.
-
-   QUALS are the qualifiers for the this pointer.  */
-
-void
-grokclassfn (ctype, cname, function, flags, quals)
-     tree ctype, cname, function;
-     enum overload_flags flags;
-     tree quals;
-{
-  tree fn_name = DECL_NAME (function);
-  tree arg_types;
-  tree parm;
-
-  if (fn_name == NULL_TREE)
-    {
-      error ("name missing for member function");
-      fn_name = get_identifier ("<anonymous>");
-      DECL_NAME (function) = fn_name;
-    }
-
-  if (quals)
-    ctype = grok_method_quals (ctype, function, quals);
-
-  arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
-  if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
-    {
-      /* Must add the class instance variable up front.  */
-      /* Right now we just make this a pointer.  But later
-	 we may wish to make it special.  */
-      tree type = TREE_VALUE (arg_types);
-
-      if (flags == DTOR_FLAG)
-	type = TYPE_MAIN_VARIANT (type);
-      else if (DECL_CONSTRUCTOR_P (function))
-	{
-	  if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
-	    {
-	      DECL_CONSTRUCTOR_FOR_VBASE_P (function) = 1;
-	      /* In this case we need "in-charge" flag saying whether
-		 this constructor is responsible for initialization
-		 of virtual baseclasses or not.  */
-	      parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node);
-	      DECL_ARG_TYPE (parm) = integer_type_node;
-	      DECL_REGISTER (parm) = 1;
-	      TREE_CHAIN (parm) = last_function_parms;
-	      last_function_parms = parm;
-	    }
-	}
-
-      parm = build_decl (PARM_DECL, this_identifier, type);
-      /* Mark the artificial `this' parameter as "artificial".  */
-      DECL_SOURCE_LINE (parm) = 0;
-      DECL_ARG_TYPE (parm) = type;
-      /* We can make this a register, so long as we don't
-	 accidentally complain if someone tries to take its address.  */
-      DECL_REGISTER (parm) = 1;
-#if 0
-      /* it is wrong to flag the object as readonly, when
-	 flag_this_is_variable is 0. */
-      if (flags != DTOR_FLAG
-	  && (flag_this_is_variable <= 0 || TYPE_READONLY (type)))
-#else
-      if (flags != DTOR_FLAG && TYPE_READONLY (type))
-#endif
-	TREE_READONLY (parm) = 1;
-      TREE_CHAIN (parm) = last_function_parms;
-      last_function_parms = parm;
-    }
-
-  if (flags == DTOR_FLAG)
-    {
-      char *buf, *dbuf;
-      tree const_integer_type = build_type_variant (integer_type_node, 1, 0);
-      int len = sizeof (DESTRUCTOR_DECL_PREFIX)-1;
-
-      arg_types = hash_tree_chain (const_integer_type, void_list_node);
-      /* Build the overload name.  It will look like e.g. 7Example.  */
-      if (IDENTIFIER_TYPE_VALUE (cname))
-	dbuf = build_overload_name (IDENTIFIER_TYPE_VALUE (cname), 1, 1);
-      else if (IDENTIFIER_LOCAL_VALUE (cname))
-	dbuf = build_overload_name (TREE_TYPE (IDENTIFIER_LOCAL_VALUE (cname)), 1, 1);
-      else
-#if 0
-	my_friendly_abort (346);
-#else
-      /* Using ctype fixes the `X::Y::~Y()' crash.  The cname has no type when
-	 it's defined out of the class definition, since poplevel_class wipes
-	 it out.  */
-	dbuf = build_overload_name (ctype, 1, 1);
-#endif
-      buf = (char *)alloca (strlen (dbuf) + sizeof (DESTRUCTOR_DECL_PREFIX));
-      bcopy (DESTRUCTOR_DECL_PREFIX, buf, len);
-      buf[len] = '\0';
-      strcat (buf, dbuf);
-      DECL_ASSEMBLER_NAME (function) = get_identifier (buf);
-      parm = build_decl (PARM_DECL, in_charge_identifier, const_integer_type);
-      TREE_USED (parm) = 1;
-      TREE_READONLY (parm) = 1;
-      DECL_ARG_TYPE (parm) = const_integer_type;
-      /* This is the same chain as DECL_ARGUMENTS (...).  */
-      TREE_CHAIN (last_function_parms) = parm;
-
-      TREE_TYPE (function) = build_cplus_method_type (ctype, void_type_node, arg_types);
-      TYPE_HAS_DESTRUCTOR (ctype) = 1;
-    }
-  else
-    {
-      tree these_arg_types;
-
-      if (DECL_CONSTRUCTOR_FOR_VBASE_P (function))
-	{
-	  arg_types = hash_tree_chain (integer_type_node, TREE_CHAIN (arg_types));
-	  TREE_TYPE (function)
-	    = build_cplus_method_type (ctype, TREE_TYPE (TREE_TYPE (function)), arg_types);
-	  arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
-	}
-
-      these_arg_types = arg_types;
-
-      if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
-	/* Only true for static member functions.  */
-	these_arg_types = hash_tree_chain (TYPE_POINTER_TO (ctype), arg_types);
-
-      DECL_ASSEMBLER_NAME (function)
-	= build_decl_overload (fn_name, these_arg_types,
-			       1 + DECL_CONSTRUCTOR_P (function));
-
-#if 0
-      /* This code is going into the compiler, but currently, it makes
-	 libg++/src/Interger.cc not compile.  The problem is that the nice name
-	 winds up going into the symbol table, and conversion operations look
-	 for the manged name.  */
-      substitute_nice_name (function);
-#endif
-
-#if 0
-      if (flags == TYPENAME_FLAG)
-	/* Not exactly an IDENTIFIER_TYPE_VALUE.  */
-	TREE_TYPE (DECL_ASSEMBLER_NAME (function)) = TREE_TYPE (fn_name);
-#endif
-    }
-
-  DECL_ARGUMENTS (function) = last_function_parms;
-  /* First approximations.  */
-  DECL_CONTEXT (function) = ctype;
-  DECL_CLASS_CONTEXT (function) = ctype;
-}
-
-/* Generate errors possibly applicable for a given set of specifiers.  */
-void
-bad_specifiers (object, virtualp, quals, friendp, raises)
-     char *object;
-     int virtualp, quals, friendp, raises;
-{
-  if (virtualp)
-    error ("%s declared `virtual'", object);
-  if (quals)
-    error ("`const' and `volatile' function specifiers invalid in %s declaration");
-  if (friendp)
-    error ("invalid friend declaration");
-  if (raises)
-    error ("invalid raises declaration");
-}
-
-/* Sanity check: report error if this function FUNCTION is not
-   really a member of the class (CTYPE) it is supposed to belong to.
-   CNAME and FLAGS are the same here as they are for grokclassfn above.  */
-
-void
-check_classfn (ctype, cname, function)
-     tree ctype, cname, function;
-{
-  tree fn_name = DECL_NAME (function);
-  tree fndecl;
-  int need_quotes = 0;
-  char *err_name;
-  tree method_vec = CLASSTYPE_METHOD_VEC (ctype);
-  tree *methods = 0;
-  tree *end = 0;
-
-  if (method_vec != 0)
-    {
-      methods = &TREE_VEC_ELT (method_vec, 0);
-      end = TREE_VEC_END (method_vec);
-
-      /* First suss out ctors and dtors.  */
-      if (*methods && fn_name == cname)
-	goto got_it;
-
-      while (++methods != end)
-	{
-	  if (fn_name == DECL_NAME (*methods))
-	    {
-	    got_it:
-	      fndecl = *methods;
-	      while (fndecl)
-		{
-		  if (DECL_ASSEMBLER_NAME (function) == DECL_ASSEMBLER_NAME (fndecl))
-		    return;
-		  fndecl = DECL_CHAIN (fndecl);
-		}
-	      break;		/* loser */
-	    }
-	}
-    }
-
-  if (fn_name == ansi_opname[(int) TYPE_EXPR])
-    {
-      if (TYPE_HAS_CONVERSION (ctype))
-	err_name = "such type conversion operator";
-    }
-  else if (IDENTIFIER_OPNAME_P (fn_name))
-    {
-      err_name = (char *)alloca (1024);
-      sprintf (err_name, "`operator %s'", operator_name_string (fn_name));
-    }
-  else
-    {
-      err_name = IDENTIFIER_POINTER (fn_name);
-      need_quotes = 1;
-    }
-
-  if (methods != end)
-    if (need_quotes)
-      error ("argument list for `%s' does not match any in class `%s'",
-	     err_name, IDENTIFIER_POINTER (cname));
-    else
-      error ("argument list for %s does not match any in class `%s'",
-	     err_name, IDENTIFIER_POINTER (cname));
-  else
-    {
-      methods = 0;
-      if (need_quotes)
-	error ("no `%s' member function declared in class `%s'",
-	       err_name, IDENTIFIER_POINTER (cname));
-      else
-	error ("no %s declared in class `%s'",
-	       err_name, IDENTIFIER_POINTER (cname));
-    }
-
-  /* If we did not find the method in the class, add it to
-     avoid spurious errors.  */
-  add_method (ctype, methods, function);
-}
-
-/* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
-   of a structure component, returning a FIELD_DECL node.
-   QUALS is a list of type qualifiers for this decl (such as for declaring
-   const member functions).
-
-   This is done during the parsing of the struct declaration.
-   The FIELD_DECL nodes are chained together and the lot of them
-   are ultimately passed to `build_struct' to make the RECORD_TYPE node.
-
-   C++:
-
-   If class A defines that certain functions in class B are friends, then
-   the way I have set things up, it is B who is interested in permission
-   granted by A.  However, it is in A's context that these declarations
-   are parsed.  By returning a void_type_node, class A does not attempt
-   to incorporate the declarations of the friends within its structure.
-
-   DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
-   CHANGES TO CODE IN `start_method'.  */
-
-tree
-grokfield (declarator, declspecs, raises, init, asmspec_tree)
-     tree declarator, declspecs, raises, init, asmspec_tree;
-{
-  register tree value;
-  char *asmspec = 0;
-
-  /* Convert () initializers to = initializers.  */
-  if (init == NULL_TREE && declarator != NULL_TREE
-      && TREE_CODE (declarator) == CALL_EXPR
-      && TREE_OPERAND (declarator, 0)
-      && (TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE
-	  || TREE_CODE (TREE_OPERAND (declarator, 0)) == SCOPE_REF)
-      && parmlist_is_exprlist (TREE_OPERAND (declarator, 1)))
-    {
-      init = TREE_OPERAND (declarator, 1);
-      declarator = TREE_OPERAND (declarator, 0);
-    }
-
-  if (init
-      && TREE_CODE (init) == TREE_LIST
-      && TREE_VALUE (init) == error_mark_node
-      && TREE_CHAIN (init) == NULL_TREE)
-	init = NULL_TREE;
-
-  value = grokdeclarator (declarator, declspecs, FIELD, init != 0, raises);
-  if (! value)
-    return NULL_TREE; /* friends went bad.  */
-
-  /* Pass friendly classes back.  */
-  if (TREE_CODE (value) == VOID_TYPE)
-    return void_type_node;
-
-  if (DECL_NAME (value) != NULL_TREE
-      && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
-      && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
-    error_with_decl (value, "member `%s' conflicts with virtual function table field name");
-
-  /* Stash away type declarations.  */
-  if (TREE_CODE (value) == TYPE_DECL)
-    {
-      DECL_NONLOCAL (value) = 1;
-      CLASSTYPE_LOCAL_TYPEDECLS (current_class_type) = 1;
-      set_identifier_type_value (DECL_NAME (value), TREE_TYPE (value));
-      pushdecl_class_level (value);
-      return value;
-    }
-
-  if (DECL_IN_AGGR_P (value))
-    {
-      error_with_decl (value, "`%s' is already defined in the class %s",
-		       TYPE_NAME_STRING (DECL_CONTEXT (value)));
-      return void_type_node;
-    }
-
-  if (flag_cadillac)
-    cadillac_start_decl (value);
-
-  if (asmspec_tree)
-    asmspec = TREE_STRING_POINTER (asmspec_tree);
-
-  if (init != 0)
-    {
-      if (TREE_CODE (value) == FUNCTION_DECL)
-	{
-	  grok_function_init (value, init);
-	  init = NULL_TREE;
-	}
-      else if (pedantic)
-	{
-	  error ("fields cannot have initializers");
-	  init = NULL_TREE;
-	}
-      else
-	{
-	  /* We allow initializers to become parameters to base initializers.  */
-	  if (TREE_CODE (init) == TREE_LIST)
-	    {
-	      if (TREE_CHAIN (init) == NULL_TREE)
-		init = TREE_VALUE (init);
-	      else
-		init = digest_init (TREE_TYPE (value), init, (tree *)0);
-	    }
-
-	  if (TREE_CODE (init) == CONST_DECL)
-	    init = DECL_INITIAL (init);
-	  else if (TREE_READONLY_DECL_P (init))
-	    init = decl_constant_value (init);
-	  else if (TREE_CODE (init) == CONSTRUCTOR)
-	    init = digest_init (TREE_TYPE (value), init, (tree *)0);
-	  my_friendly_assert (TREE_PERMANENT (init), 192);
-	  if (init == error_mark_node)
-	    /* We must make this look different than `error_mark_node'
-	       because `decl_const_value' would mis-interpret it
-	       as only meaning that this VAR_DECL is defined.  */
-	    init = build1 (NOP_EXPR, TREE_TYPE (value), init);
-	  else if (! TREE_CONSTANT (init))
-	    {
-	      /* We can allow references to things that are effectively
-		 static, since references are initialized with the address.  */
-	      if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
-		  || (TREE_STATIC (init) == 0
-		      && (TREE_CODE_CLASS (TREE_CODE (init)) != 'd'
-			  || DECL_EXTERNAL (init) == 0)))
-		{
-		  error ("field initializer is not constant");
-		  init = error_mark_node;
-		}
-	    }
-	}
-    }
-
-  /* The corresponding pop_obstacks is in finish_decl.  */
-  push_obstacks_nochange ();
-
-  if (TREE_CODE (value) == VAR_DECL)
-    {
-      /* We cannot call pushdecl here, because that would
-	 fill in the value of our TREE_CHAIN.  Instead, we
-	 modify finish_decl to do the right thing, namely, to
-	 put this decl out straight away.  */
-      if (TREE_STATIC (value))
-	{
-	  /* current_class_type can be NULL_TREE in case of error.  */
-	  if (asmspec == 0 && current_class_type)
-	    {
-	      tree name;
-	      char *buf, *buf2;
-
-	      buf2 = build_overload_name (current_class_type, 1, 1);
-	      buf = (char *)alloca (IDENTIFIER_LENGTH (DECL_NAME (value))
-				    + sizeof (STATIC_NAME_FORMAT)
-				    + strlen (buf2));
-	      sprintf (buf, STATIC_NAME_FORMAT, buf2,
-		       IDENTIFIER_POINTER (DECL_NAME (value)));
-	      name = get_identifier (buf);
-	      TREE_PUBLIC (value) = 1;
-	      DECL_INITIAL (value) = error_mark_node;
-	      DECL_ASSEMBLER_NAME (value) = name;
-	    }
-	  pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics);
-
-	  /* Static consts need not be initialized in the class definition.  */
-	  if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (value)))
-	    {
-	      static int explanation = 0;
-
-	      error ("initializer invalid for static member with constructor");
-	      if (explanation++ == 0)
-		error ("(you really want to initialize it separately)");
-	      init = 0;
-	    }
-	  /* Force the compiler to know when an uninitialized static
-	     const member is being used.  */
-	  if (TYPE_READONLY (value) && init == 0)
-	    TREE_USED (value) = 1;
-	}
-      DECL_INITIAL (value) = init;
-      DECL_IN_AGGR_P (value) = 1;
-
-      finish_decl (value, init, asmspec_tree, 1);
-      pushdecl_class_level (value);
-      return value;
-    }
-  if (TREE_CODE (value) == FIELD_DECL)
-    {
-      if (asmspec)
-	DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
-      if (DECL_INITIAL (value) == error_mark_node)
-	init = error_mark_node;
-      finish_decl (value, init, asmspec_tree, 1);
-      DECL_INITIAL (value) = init;
-      DECL_IN_AGGR_P (value) = 1;
-      return value;
-    }
-  if (TREE_CODE (value) == FUNCTION_DECL)
-    {
-      /* grokdeclarator defers setting this.  */
-      TREE_PUBLIC (value) = 1;
-      if (DECL_CHAIN (value) != NULL_TREE)
-	{
-	  /* Need a fresh node here so that we don't get circularity
-	     when we link these together.  */
-	  value = copy_node (value);
-	  /* When does this happen?  */
-	  my_friendly_assert (init == NULL_TREE, 193);
-	}
-      finish_decl (value, init, asmspec_tree, 1);
-
-      /* Pass friends back this way.  */
-      if (DECL_FRIEND_P (value))
-	return void_type_node;
-
-      DECL_IN_AGGR_P (value) = 1;
-      return value;
-    }
-  my_friendly_abort (21);
-  /* NOTREACHED */
-  return NULL_TREE;
-}
-
-/* Like `grokfield', but for bitfields.
-   WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.  */
-
-tree
-grokbitfield (declarator, declspecs, width)
-     tree declarator, declspecs, width;
-{
-  register tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL_TREE);
-
-  if (! value) return NULL_TREE; /* friends went bad.  */
-
-  /* Pass friendly classes back.  */
-  if (TREE_CODE (value) == VOID_TYPE)
-    return void_type_node;
-
-  if (TREE_CODE (value) == TYPE_DECL)
-    {
-      error_with_decl (value, "cannot declare `%s' to be a bitfield type");
-      return NULL_TREE;
-    }
-
-  if (DECL_IN_AGGR_P (value))
-    {
-      error_with_decl (value, "`%s' is already defined in the class %s",
-		       TYPE_NAME_STRING (DECL_CONTEXT (value)));
-      return void_type_node;
-    }
-
-  GNU_xref_member (current_class_name, value);
-
-  if (TREE_STATIC (value))
-    {
-      error_with_decl (value, "static member `%s' cannot be a bitfield");
-      return NULL_TREE;
-    }
-  finish_decl (value, NULL_TREE, NULL_TREE, 0);
-
-  if (width != error_mark_node)
-    {
-      /* detect invalid field size.  */
-      if (TREE_CODE (width) == CONST_DECL)
-	width = DECL_INITIAL (width);
-      else if (TREE_READONLY_DECL_P (width))
-	width = decl_constant_value (width);
-      if (TREE_CODE (width) != INTEGER_CST)
-	{
-	  error_with_decl (value, "structure field `%s' width not an integer constant");
-	  DECL_INITIAL (value) = NULL_TREE;
-	}
-      else
-	{
-	  DECL_INITIAL (value) = width;
-	  DECL_BIT_FIELD (value) = 1;
-	}
-    }
-
-  DECL_IN_AGGR_P (value) = 1;
-  return value;
-}
-
-/* Like GROKFIELD, except that the declarator has been
-   buried in DECLSPECS.  Find the declarator, and
-   return something that looks like it came from
-   GROKFIELD.  */
-tree
-groktypefield (declspecs, parmlist)
-     tree declspecs;
-     tree parmlist;
-{
-  tree spec = declspecs;
-  tree prev = NULL_TREE;
-
-  tree type_id = NULL_TREE;
-  tree quals = NULL_TREE;
-  tree lengths = NULL_TREE;
-  tree decl = NULL_TREE;
-
-  while (spec)
-    {
-      register tree id = TREE_VALUE (spec);
-
-      if (TREE_CODE (spec) != TREE_LIST)
-	/* Certain parse errors slip through.  For example,
-	   `int class ();' is not caught by the parser. Try
-	   weakly to recover here.  */
-	return NULL_TREE;
-
-      if (TREE_CODE (id) == TYPE_DECL
-	  || (TREE_CODE (id) == IDENTIFIER_NODE && TREE_TYPE (id)))
-	{
-	  /* We have a constructor/destructor or
-	     conversion operator.  Use it.  */
-	  if (prev)
-	    TREE_CHAIN (prev) = TREE_CHAIN (spec);
-	  else
-	    declspecs = TREE_CHAIN (spec);
-
-	  type_id = id;
-	  goto found;
-	}
-      prev = spec;
-      spec = TREE_CHAIN (spec);
-    }
-
-  /* Nope, we have a conversion operator to a scalar type or something
-     else, that includes things like constructor declarations for
-     templates.  */
-  spec = declspecs;
-  while (spec)
-    {
-      tree id = TREE_VALUE (spec);
-
-      if (TREE_CODE (id) == IDENTIFIER_NODE)
-	{
-	  if (id == ridpointers[(int)RID_INT]
-	      || id == ridpointers[(int)RID_DOUBLE]
-	      || id == ridpointers[(int)RID_FLOAT]
-	      || id == ridpointers[(int)RID_WCHAR])
-	    {
-	      if (type_id)
-		error ("extra `%s' ignored",
-		       IDENTIFIER_POINTER (id));
-	      else
-		type_id = id;
-	    }
-	  else if (id == ridpointers[(int)RID_LONG]
-		   || id == ridpointers[(int)RID_SHORT]
-		   || id == ridpointers[(int)RID_CHAR])
-	    {
-	      lengths = tree_cons (NULL_TREE, id, lengths);
-	    }
-	  else if (id == ridpointers[(int)RID_VOID])
-	    {
-	      if (type_id)
-		error ("spurious `void' type ignored");
-	      else
-		error ("conversion to `void' type invalid");
-	    }
-	  else if (id == ridpointers[(int)RID_AUTO]
-		   || id == ridpointers[(int)RID_REGISTER]
-		   || id == ridpointers[(int)RID_TYPEDEF]
-		   || id == ridpointers[(int)RID_CONST]
-		   || id == ridpointers[(int)RID_VOLATILE])
-	    {
-	      error ("type specifier `%s' used invalidly",
-		     IDENTIFIER_POINTER (id));
-	    }
-	  else if (id == ridpointers[(int)RID_FRIEND]
-		   || id == ridpointers[(int)RID_VIRTUAL]
-		   || id == ridpointers[(int)RID_INLINE]
-		   || id == ridpointers[(int)RID_UNSIGNED]
-		   || id == ridpointers[(int)RID_SIGNED]
-		   || id == ridpointers[(int)RID_STATIC]
-		   || id == ridpointers[(int)RID_EXTERN])
-	    {
-	      quals = tree_cons (NULL_TREE, id, quals);
-	    }
-	  else
-	    {
-	      /* Happens when we have a global typedef
-		 and a class-local member function with
-		 the same name.  */
-	      type_id = id;
-	      goto found;
-	    }
-	}
-      else if (TREE_CODE (id) == RECORD_TYPE)
-	{
-	  type_id = TYPE_NAME (id);
-	  if (TREE_CODE (type_id) == TYPE_DECL)
-	    type_id = DECL_NAME (type_id);
-	  if (type_id == NULL_TREE)
-	    error ("identifier for aggregate type conversion omitted");
-	}
-      else if (TREE_CODE_CLASS (TREE_CODE (id)) == 't')
-	error ("`operator' missing on conversion operator or tag missing from type");
-      else
-	my_friendly_abort (194);
-      spec = TREE_CHAIN (spec);
-    }
-
-  if (type_id)
-    declspecs = chainon (lengths, quals);
-  else if (lengths)
-    {
-      if (TREE_CHAIN (lengths))
-	error ("multiple length specifiers");
-      type_id = ridpointers[(int)RID_INT];
-      declspecs = chainon (lengths, quals);
-    }
-  else if (quals)
-    {
-      error ("no type given, defaulting to `operator int ...'");
-      type_id = ridpointers[(int)RID_INT];
-      declspecs = quals;
-    }
-  else
-    return NULL_TREE;
-
- found:
-  decl = grokdeclarator (build_parse_node (CALL_EXPR, type_id, parmlist, NULL_TREE),
-			 declspecs, FIELD, 0, NULL_TREE);
-  if (decl == NULL_TREE)
-    return NULL_TREE;
-
-  if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CHAIN (decl) != NULL_TREE)
-    {
-      /* Need a fresh node here so that we don't get circularity
-	 when we link these together.  */
-      decl = copy_node (decl);
-    }
-
-  if (decl == void_type_node
-      || (TREE_CODE (decl) == FUNCTION_DECL
-	  && TREE_CODE (TREE_TYPE (decl)) != METHOD_TYPE))
-    /* bunch of friends.  */
-    return decl;
-
-  if (DECL_IN_AGGR_P (decl))
-    {
-      error_with_decl (decl, "`%s' already defined in the class ");
-      return void_type_node;
-    }
-
-  finish_decl (decl, NULL_TREE, NULL_TREE, 0);
-
-  /* If this declaration is common to another declaration
-     complain about such redundancy, and return NULL_TREE
-     so that we don't build a circular list.  */
-  if (DECL_CHAIN (decl))
-    {
-      error_with_decl (decl, "function `%s' declared twice in class %s",
-		       TYPE_NAME_STRING (DECL_CONTEXT (decl)));
-      return NULL_TREE;
-    }
-  DECL_IN_AGGR_P (decl) = 1;
-  return decl;
-}
-
-/* The precedence rules of this grammar (or any other deterministic LALR
-   grammar, for that matter), place the CALL_EXPR somewhere where we
-   may not want it.  The solution is to grab the first CALL_EXPR we see,
-   pretend that that is the one that belongs to the parameter list of
-   the type conversion function, and leave everything else alone.
-   We pull it out in place.
-
-   CALL_REQUIRED is non-zero if we should complain if a CALL_EXPR
-   does not appear in DECL.  */
-tree
-grokoptypename (decl, call_required)
-     tree decl;
-     int call_required;
-{
-  tree tmp, last;
-
-  my_friendly_assert (TREE_CODE (decl) == TYPE_EXPR, 195);
-
-  tmp = TREE_OPERAND (decl, 0);
-  last = NULL_TREE;
-
-  while (tmp)
-    {
-      switch (TREE_CODE (tmp))
-	{
-	case CALL_EXPR:
-	  {
-	    tree parms = TREE_OPERAND (tmp, 1);
-
-	    if (last)
-	      TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
-	    else
-	      TREE_OPERAND (decl, 0) = TREE_OPERAND (tmp, 0);
-	    if (parms
-		&& TREE_CODE (TREE_VALUE (parms)) == TREE_LIST)
-	      TREE_VALUE (parms)
-		= grokdeclarator (TREE_VALUE (TREE_VALUE (parms)),
-				  TREE_PURPOSE (TREE_VALUE (parms)),
-				  TYPENAME, 0, NULL_TREE);
-	    if (parms)
-	      {
-		if (TREE_VALUE (parms) != void_type_node)
-		  error ("operator <typename> requires empty parameter list");
-		else
-		  /* Canonicalize parameter lists.  */
-		  TREE_OPERAND (tmp, 1) = void_list_node;
-	      }
-
-	    last = grokdeclarator (TREE_OPERAND (decl, 0),
-				   TREE_TYPE (decl),
-				   TYPENAME, 0, NULL_TREE);
-	    TREE_OPERAND (tmp, 0) = build_typename_overload (last);
-	    TREE_TYPE (TREE_OPERAND (tmp, 0)) = last;
-	    return tmp;
-	  }
-
-	case INDIRECT_REF:
-	case ADDR_EXPR:
-	case ARRAY_REF:
-	  break;
-
-	case SCOPE_REF:
-	  /* This is legal when declaring a conversion to
-	     something of type pointer-to-member.  */
-	  if (TREE_CODE (TREE_OPERAND (tmp, 1)) == INDIRECT_REF)
-	    {
-	      tmp = TREE_OPERAND (tmp, 1);
-	    }
-	  else
-	    {
-#if 0
-	      /* We may need to do this if grokdeclarator cannot handle this.  */
-	      error ("type `member of class %s' invalid return type",
-		     TYPE_NAME_STRING (TREE_OPERAND (tmp, 0)));
-	      TREE_OPERAND (tmp, 1) = build_parse_node (INDIRECT_REF, TREE_OPERAND (tmp, 1));
-#endif
-	      tmp = TREE_OPERAND (tmp, 1);
-	    }
-	  break;
-
-	default:
-	  my_friendly_abort (196);
-	}
-      last = tmp;
-      tmp = TREE_OPERAND (tmp, 0);
-    }
-
-  if (call_required)
-    error ("operator <typename> construct requires parameter list");
-
-  last = grokdeclarator (TREE_OPERAND (decl, 0),
-			 TREE_TYPE (decl),
-			 TYPENAME, 0, NULL_TREE);
-  tmp = build_parse_node (CALL_EXPR, build_typename_overload (last),
-			  void_list_node, NULL_TREE);
-  TREE_TYPE (TREE_OPERAND (tmp, 0)) = last;
-  return tmp;
-}
-
-/* When a function is declared with an initializer,
-   do the right thing.  Currently, there are two possibilities:
-
-   class B
-   {
-    public:
-     // initialization possibility #1.
-     virtual void f () = 0;
-     int g ();
-   };
-   
-   class D1 : B
-   {
-    public:
-     int d1;
-     // error, no f ();
-   };
-   
-   class D2 : B
-   {
-    public:
-     int d2;
-     void f ();
-   };
-   
-   class D3 : B
-   {
-    public:
-     int d3;
-     // initialization possibility #2
-     void f () = B::f;
-   };
-
-*/
-
-static void
-grok_function_init (decl, init)
-     tree decl;
-     tree init;
-{
-  /* An initializer for a function tells how this function should
-     be inherited.  */
-  tree type = TREE_TYPE (decl);
-  extern tree abort_fndecl;
-
-  if (TREE_CODE (type) == FUNCTION_TYPE)
-    error_with_decl (decl, "initializer specified for non-member function `%s'");
-  else if (DECL_VINDEX (decl) == NULL_TREE)
-    error_with_decl (decl, "initializer specified for non-virtual method `%s'");
-  else if (integer_zerop (init))
-    {
-      /* Mark this function as being "defined".  */
-      DECL_INITIAL (decl) = error_mark_node;
-      /* pure virtual destructors must be defined. */
-      if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)))
-	{
-	  /* Give this node rtl from `abort'.  */
-	  DECL_RTL (decl) = DECL_RTL (abort_fndecl);
-	}
-      DECL_ABSTRACT_VIRTUAL_P (decl) = 1;
-    }
-  else if (TREE_CODE (init) == OFFSET_REF
-	   && TREE_OPERAND (init, 0) == NULL_TREE
-	   && TREE_CODE (TREE_TYPE (init)) == METHOD_TYPE)
-    {
-      tree basetype = DECL_CLASS_CONTEXT (init);
-      tree basefn = TREE_OPERAND (init, 1);
-      if (TREE_CODE (basefn) != FUNCTION_DECL)
-	error_with_decl (decl, "non-method initializer invalid for method `%s'");
-      else if (! BINFO_OFFSET_ZEROP (TYPE_BINFO (DECL_CLASS_CONTEXT (basefn))))
-	sorry ("base member function from other than first base class");
-      else
-	{
-	  tree binfo = get_binfo (basetype, TYPE_METHOD_BASETYPE (type), 1);
-	  if (binfo == error_mark_node)
-	    ;
-	  else if (binfo == 0)
-	    error_not_base_type (TYPE_METHOD_BASETYPE (TREE_TYPE (init)),
-				 TYPE_METHOD_BASETYPE (type));
-	  else
-	    {
-	      /* Mark this function as being defined,
-		 and give it new rtl.  */
-	      DECL_INITIAL (decl) = error_mark_node;
-	      DECL_RTL (decl) = DECL_RTL (basefn);
-	    }
-	}
-    }
-  else
-    error_with_decl (decl, "invalid initializer for virtual method `%s'");
-}
-
-/* When we get a declaration of the form
-
-   type cname::fname ...
-
-   the node for `cname::fname' gets built here in a special way.
-   Namely, we push into `cname's scope.  When this declaration is
-   processed, we pop back out.  */
-tree
-build_push_scope (cname, name)
-     tree cname;
-     tree name;
-{
-  extern int current_class_depth;
-  tree ctype, rval;
-
-  if (cname == error_mark_node)
-    return error_mark_node;
-
-  ctype = IDENTIFIER_TYPE_VALUE (cname);
-
-  if (ctype == NULL_TREE || ! IS_AGGR_TYPE (ctype))
-    {
-      error ("`%s' not defined as aggregate type", IDENTIFIER_POINTER (cname));
-      return name;
-    }
-
-  rval = build_parse_node (SCOPE_REF, cname, name);
-
-  /* Don't need to push the scope here, but we do need to return
-     a SCOPE_REF for something like
-
-     class foo { typedef int bar (foo::*foo_fn)(void); };  */
-  if (ctype == current_class_type)
-    return rval;
-
-  pushclass (ctype, 3);
-  TREE_COMPLEXITY (rval) = current_class_depth;
-  return rval;
-}
-
-void cplus_decl_attributes (decl, attributes)
-     tree decl, attributes;
-{
-  if (decl)
-    decl_attributes (decl, attributes);
-}
-
-/* CONSTRUCTOR_NAME:
-   Return the name for the constructor (or destructor) for the specified
-   class.  Argument can be RECORD_TYPE, TYPE_DECL, or IDENTIFIER_NODE.  */
-tree
-constructor_name (thing)
-     tree thing;
-{
-  tree t;
-  if (TREE_CODE (thing) == UNINSTANTIATED_P_TYPE)
-    return DECL_NAME (UPT_TEMPLATE (thing));
-  if (TREE_CODE (thing) == RECORD_TYPE || TREE_CODE (thing) == UNION_TYPE)
-    thing = TYPE_NAME (thing);
-  if (TREE_CODE (thing) == TYPE_DECL
-      || (TREE_CODE (thing) == TEMPLATE_DECL
-	  && DECL_TEMPLATE_IS_CLASS (thing)))
-    thing = DECL_NAME (thing);
-  my_friendly_assert (TREE_CODE (thing) == IDENTIFIER_NODE, 197);
-  t = IDENTIFIER_TEMPLATE (thing);
-  if (!t)
-    return thing;
-  t = TREE_PURPOSE (t);
-  return DECL_NAME (t);
-}
-
-/* Cache the value of this class's main virtual function table pointer
-   in a register variable.  This will save one indirection if a
-   more than one virtual function call is made this function.  */
-void
-setup_vtbl_ptr ()
-{
-  extern rtx base_init_insns;
-
-  if (base_init_insns == 0
-      && DECL_CONSTRUCTOR_P (current_function_decl))
-    emit_base_init (current_class_type, 0);
-
-#if 0
-  /* This has something a little wrong with it.
-
-     On a sun4, code like:
-
-        be L6
-        ld [%i0],%o1
-
-     is generated, when the below is used when -O4 is given.  The delay
-     slot it filled with an instruction that is safe, when this isn't
-     used, like in:
-
-        be L6
-        sethi %hi(LC1),%o0
-        ld [%i0],%o1
-
-     on code like:
-
-        struct A {
-          virtual void print() { printf("xxx"); }
-          void f();
-        };
-
-        void A::f() {
-          if (this) {
-            print();
-          } else {
-            printf("0");
-          }
-        }
-
-     And that is why this is disabled for now. (mrs)
-  */
-
-  if ((flag_this_is_variable & 1) == 0
-      && optimize
-      && current_class_type
-      && CLASSTYPE_VSIZE (current_class_type)
-      && ! DECL_STATIC_FUNCTION_P (current_function_decl))
-    {
-      tree vfield = build_vfield_ref (C_C_D, current_class_type);
-      current_vtable_decl = CLASSTYPE_VTBL_PTR (current_class_type);
-      DECL_RTL (current_vtable_decl) = 0;
-      DECL_INITIAL (current_vtable_decl) = error_mark_node;
-      /* Have to cast the initializer, since it may have come from a
-	 more base class then we ascribe CURRENT_VTABLE_DECL to be.  */
-      finish_decl (current_vtable_decl, convert_force (TREE_TYPE (current_vtable_decl), vfield), 0, 0);
-      current_vtable_decl = build_indirect_ref (current_vtable_decl, 0);
-    }
-  else
-#endif
-    current_vtable_decl = NULL_TREE;
-}
-
-/* Record the existence of an addressable inline function.  */
-void
-mark_inline_for_output (decl)
-     tree decl;
-{
-  if (DECL_PENDING_INLINE_INFO (decl) != 0
-      && ! DECL_PENDING_INLINE_INFO (decl)->deja_vu)
-    {
-      struct pending_inline *t = pending_inlines;
-      my_friendly_assert (DECL_SAVED_INSNS (decl) == 0, 198);
-      while (t)
-	{
-	  if (t == DECL_PENDING_INLINE_INFO (decl))
-	    break;
-	  t = t->next;
-	}
-      if (t == 0)
-	{
-	  t = DECL_PENDING_INLINE_INFO (decl);
-	  t->next = pending_inlines;
-	  pending_inlines = t;
-	}
-      DECL_PENDING_INLINE_INFO (decl) = 0;
-    }
-  pending_addressable_inlines = perm_tree_cons (NULL_TREE, decl,
-						pending_addressable_inlines);
-}
-
-void
-clear_temp_name ()
-{
-  temp_name_counter = 0;
-}
-
-/* Hand off a unique name which can be used for variable we don't really
-   want to know about anyway, for example, the anonymous variables which
-   are needed to make references work.  Declare this thing so we can use it.
-   The variable created will be of type TYPE.
-
-   STATICP is nonzero if this variable should be static.  */
-
-tree
-get_temp_name (type, staticp)
-     tree type;
-     int staticp;
-{
-  char buf[sizeof (AUTO_TEMP_FORMAT) + 20];
-  tree decl;
-  int toplev = global_bindings_p ();
-
-  push_obstacks_nochange ();
-  if (toplev || staticp)
-    {
-      end_temporary_allocation ();
-      sprintf (buf, AUTO_TEMP_FORMAT, global_temp_name_counter++);
-      decl = pushdecl_top_level (build_decl (VAR_DECL, get_identifier (buf), type));
-    }
-  else
-    {
-      sprintf (buf, AUTO_TEMP_FORMAT, temp_name_counter++);
-      decl = pushdecl (build_decl (VAR_DECL, get_identifier (buf), type));
-    }
-  TREE_USED (decl) = 1;
-  TREE_STATIC (decl) = staticp;
-
-  /* If this is a local variable, then lay out its rtl now.
-     Otherwise, callers of this function are responsible for dealing
-     with this variable's rtl.  */
-  if (! toplev)
-    {
-      expand_decl (decl);
-      expand_decl_init (decl);
-    }
-  pop_obstacks ();
-
-  return decl;
-}
-
-/* Get a variable which we can use for multiple assignments.
-   It is not entered into current_binding_level, because
-   that breaks things when it comes time to do final cleanups
-   (which take place "outside" the binding contour of the function).  */
-tree
-get_temp_regvar (type, init)
-     tree type, init;
-{
-  static char buf[sizeof (AUTO_TEMP_FORMAT) + 20] = { '_' };
-  tree decl;
-
-  sprintf (buf+1, AUTO_TEMP_FORMAT, temp_name_counter++);
-  decl = build_decl (VAR_DECL, get_identifier (buf), type);
-  TREE_USED (decl) = 1;
-  DECL_REGISTER (decl) = 1;
-
-  if (init)
-    store_init_value (decl, init);
-
-  /* We can expand these without fear, since they cannot need
-     constructors or destructors.  */
-  expand_decl (decl);
-  expand_decl_init (decl);
-
-  if (type_needs_gc_entry (type))
-    DECL_GC_OFFSET (decl) = size_int (++current_function_obstack_index);
-
-  return decl;
-}
-
-/* Make the macro TEMP_NAME_P available to units which do not
-   include c-tree.h.  */
-int
-temp_name_p (decl)
-     tree decl;
-{
-  return TEMP_NAME_P (decl);
-}
-
-/* Finish off the processing of a UNION_TYPE structure.
-   If there are static members, then all members are
-   static, and must be laid out together.  If the
-   union is an anonymous union, we arrange for that
-   as well.  PUBLIC_P is nonzero if this union is
-   not declared static.  */
-void
-finish_anon_union (anon_union_decl)
-     tree anon_union_decl;
-{
-  tree type = TREE_TYPE (anon_union_decl);
-  tree field, main_decl = NULL_TREE;
-  tree elems = NULL_TREE;
-  int public_p = TREE_PUBLIC (anon_union_decl);
-  int static_p = TREE_STATIC (anon_union_decl);
-  int external_p = DECL_EXTERNAL (anon_union_decl);
-
-  if ((field = TYPE_FIELDS (type)) == NULL_TREE)
-    return;
-
-  if (public_p && (static_p || external_p))
-    error ("optimizer cannot handle global anonymous unions");
-
-  while (field)
-    {
-      tree decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
-      /* tell `pushdecl' that this is not tentative.  */
-      DECL_INITIAL (decl) = error_mark_node;
-      TREE_PUBLIC (decl) = public_p;
-      TREE_STATIC (decl) = static_p;
-      DECL_EXTERNAL (decl) = external_p;
-      decl = pushdecl (decl);
-
-      /* Only write out one anon union element--choose the one that
-	 can hold them all.  */
-      if (main_decl == NULL_TREE
-	  && DECL_SIZE (decl) == DECL_SIZE (anon_union_decl))
-	{
-	  main_decl = decl;
-	}
-      else
-	{
-	  /* ??? This causes there to be no debug info written out
-	     about this decl.  */
-	  TREE_ASM_WRITTEN (decl) = 1;
-	}
-
-      DECL_INITIAL (decl) = NULL_TREE;
-      /* If there's a cleanup to do, it belongs in the
-	 TREE_PURPOSE of the following TREE_LIST.  */
-      elems = tree_cons (NULL_TREE, decl, elems);
-      TREE_TYPE (elems) = type;
-      field = TREE_CHAIN (field);
-    }
-  if (static_p)
-    {
-      make_decl_rtl (main_decl, 0, global_bindings_p ());
-      DECL_RTL (anon_union_decl) = DECL_RTL (main_decl);
-    }
-
-  /* The following call assumes that there are never any cleanups
-     for anonymous unions--a reasonable assumption.  */
-  expand_anon_union_decl (anon_union_decl, NULL_TREE, elems);
-
-  if (flag_cadillac)
-    cadillac_finish_anon_union (anon_union_decl);
-}
-
-/* Finish and output a table which is generated by the compiler.
-   NAME is the name to give the table.
-   TYPE is the type of the table entry.
-   INIT is all the elements in the table.
-   PUBLICP is non-zero if this table should be given external visibility.  */
-tree
-finish_table (name, type, init, publicp)
-     tree name, type, init;
-     int publicp;
-{
-  tree itype, atype, decl;
-  static tree empty_table;
-  int is_empty = 0;
-  tree asmspec;
-
-  itype = build_index_type (size_int (list_length (init) - 1));
-  atype = build_cplus_array_type (type, itype);
-  layout_type (atype);
-
-  if (TREE_VALUE (init) == integer_zero_node
-      && TREE_CHAIN (init) == NULL_TREE)
-    {
-      if (empty_table == NULL_TREE)
-	{
-	  empty_table = get_temp_name (atype, 1);
-	  init = build (CONSTRUCTOR, atype, NULL_TREE, init);
-	  TREE_CONSTANT (init) = 1;
-	  TREE_STATIC (init) = 1;
-	  DECL_INITIAL (empty_table) = init;
-	  asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
-				  IDENTIFIER_POINTER (DECL_NAME (empty_table)));
-	  finish_decl (empty_table, init, asmspec, 0);
-	}
-      is_empty = 1;
-    }
-
-  if (name == NULL_TREE)
-    {
-      if (is_empty)
-	return empty_table;
-      decl = get_temp_name (atype, 1);
-    }
-  else
-    {
-      decl = build_decl (VAR_DECL, name, atype);
-      decl = pushdecl (decl);
-      TREE_STATIC (decl) = 1;
-    }
-
-  if (is_empty == 0)
-    {
-      TREE_PUBLIC (decl) = publicp;
-      init = build (CONSTRUCTOR, atype, NULL_TREE, init);
-      TREE_CONSTANT (init) = 1;
-      TREE_STATIC (init) = 1;
-      DECL_INITIAL (decl) = init;
-      asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (decl)),
-			      IDENTIFIER_POINTER (DECL_NAME (decl)));
-    }
-  else
-    {
-      /* This will cause DECL to point to EMPTY_TABLE in rtl-land.  */
-      DECL_EXTERNAL (decl) = 1;
-      TREE_STATIC (decl) = 0;
-      init = 0;
-      asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
-			      IDENTIFIER_POINTER (DECL_NAME (empty_table)));
-    }
-
-  finish_decl (decl, init, asmspec, 0);
-  return decl;
-}
-
-/* Finish processing a builtin type TYPE.  It's name is NAME,
-   its fields are in the array FIELDS.  LEN is the number of elements
-   in FIELDS.
-
-   It is given the same alignment as ALIGN_TYPE.  */
-void
-finish_builtin_type (type, name, fields, len, align_type)
-     tree type;
-     char *name;
-     tree fields[];
-     int len;
-     tree align_type;
-{
-  register int i;
-
-  TYPE_FIELDS (type) = fields[0];
-  for (i = 0; i < len; i++)
-    {
-      layout_type (TREE_TYPE (fields[i]));
-      DECL_FIELD_CONTEXT (fields[i]) = type;
-      TREE_CHAIN (fields[i]) = fields[i+1];
-    }
-  DECL_FIELD_CONTEXT (fields[i]) = type;
-  DECL_CLASS_CONTEXT (fields[i]) = type;
-  TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
-  layout_type (type);
-#if 0 /* not yet, should get fixed properly later */
-  TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
-#else
-  TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
-#endif
-  layout_decl (TYPE_NAME (type), 0);
-}
-
-/* Auxiliary functions to make type signatures for
-   `operator new' and `operator delete' correspond to
-   what compiler will be expecting.  */
-
-extern tree sizetype;
-
-tree
-coerce_new_type (type)
-     tree type;
-{
-  int e1 = 0, e2 = 0;
-
-  if (TREE_CODE (type) == METHOD_TYPE)
-    type = build_function_type (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type)));
-  if (TREE_TYPE (type) != ptr_type_node)
-    e1 = 1, error ("`operator new' must return type `void *'");
-
-  /* Technically the type must be `size_t', but we may not know
-     what that is.  */
-  if (TYPE_ARG_TYPES (type) == NULL_TREE)
-    e1 = 1, error ("`operator new' takes type `size_t' parameter");
-  else if (TREE_CODE (TREE_VALUE (TYPE_ARG_TYPES (type))) != INTEGER_TYPE
-	   || TYPE_PRECISION (TREE_VALUE (TYPE_ARG_TYPES (type))) != TYPE_PRECISION (sizetype))
-    e2 = 1, error ("`operator new' takes type `size_t' as first parameter");
-  if (e2)
-    type = build_function_type (ptr_type_node, tree_cons (NULL_TREE, sizetype, TREE_CHAIN (TYPE_ARG_TYPES (type))));
-  else if (e1)
-    type = build_function_type (ptr_type_node, TYPE_ARG_TYPES (type));
-  return type;
-}
-
-tree
-coerce_delete_type (type)
-     tree type;
-{
-  int e1 = 0, e2 = 0, e3 = 0;
-  tree arg_types = TYPE_ARG_TYPES (type);
-
-  if (TREE_CODE (type) == METHOD_TYPE)
-    {
-      type = build_function_type (TREE_TYPE (type), TREE_CHAIN (arg_types));
-      arg_types = TREE_CHAIN (arg_types);
-    }
-  if (TREE_TYPE (type) != void_type_node)
-    e1 = 1, error ("`operator delete' must return type `void'");
-  if (arg_types == NULL_TREE
-      || TREE_VALUE (arg_types) != ptr_type_node)
-    e2 = 1, error ("`operator delete' takes type `void *' as first parameter");
-
-  if (arg_types
-      && TREE_CHAIN (arg_types)
-      && TREE_CHAIN (arg_types) != void_list_node)
-    {
-      /* Again, technically this argument must be `size_t', but again
-	 we may not know what that is.  */
-      tree t2 = TREE_VALUE (TREE_CHAIN (arg_types));
-      if (TREE_CODE (t2) != INTEGER_TYPE
-	  || TYPE_PRECISION (t2) != TYPE_PRECISION (sizetype))
-	e3 = 1, error ("second argument to `operator delete' must be of type `size_t'");
-      else if (TREE_CHAIN (TREE_CHAIN (arg_types)) != void_list_node)
-	{
-	  e3 = 1;
-	  if (TREE_CHAIN (TREE_CHAIN (arg_types)))
-	    error ("too many arguments in declaration of `operator delete'");
-	  else
-	    error ("`...' invalid in specification of `operator delete'");
-	}
-    }
-  if (e3)
-    arg_types = tree_cons (NULL_TREE, ptr_type_node, build_tree_list (NULL_TREE, sizetype));
-  else if (e3 |= e2)
-    {
-      if (arg_types == NULL_TREE)
-	arg_types = void_list_node;
-      else
-	arg_types = tree_cons (NULL_TREE, ptr_type_node, TREE_CHAIN (arg_types));
-    }
-  else e3 |= e1;
-
-  if (e3)
-    type = build_function_type (void_type_node, arg_types);
-
-  return type;
-}
-
-static void
-write_vtable_entries (decl)
-     tree decl;
-{
-  tree entries = TREE_CHAIN (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)));
-
-  if (flag_dossier)
-    entries = TREE_CHAIN (entries);
-
-  for (; entries; entries = TREE_CHAIN (entries))
-    {
-      tree fnaddr = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries));
-      tree fn = TREE_OPERAND (fnaddr, 0);
-      if (! DECL_EXTERNAL (fn) && ! TREE_ASM_WRITTEN (fn)
-	  && DECL_SAVED_INSNS (fn))
-	{
-	  if (TREE_PUBLIC (DECL_CLASS_CONTEXT (fn)))
-	    TREE_PUBLIC (fn) = 1;
-	  TREE_ADDRESSABLE (fn) = 1;
-	  output_inline_function (fn);
-	}
-      else
-	assemble_external (fn);
-    }
-}
-
-/* Note even though prev is never used in here, walk_vtables
-   expects this to have two arguments, so concede.  */
-static void
-finish_vtable_typedecl (prev, vars)
-     tree prev, vars;
-{
-  tree decl = TYPE_BINFO_VTABLE (TREE_TYPE (vars));
-
-  /* If we are controlled by `+e2', obey.  */
-  if (write_virtuals == 2)
-    {
-      tree binfo = value_member (DECL_NAME (vars), pending_vtables);
-      if (binfo)
-	TREE_PURPOSE (binfo) = void_type_node;
-      else
-	decl = NULL_TREE;
-    }
-  /* If this type has inline virtual functions, then
-     write those functions out now.  */
-  if (decl && write_virtuals >= 0
-      && ! DECL_EXTERNAL (decl) && (TREE_PUBLIC (decl) || TREE_USED (decl)))
-    write_vtable_entries (decl);
-}
-
-static void
-finish_vtable_vardecl (prev, vars)
-     tree prev, vars;
-{
-  if (write_virtuals >= 0
-      && ! DECL_EXTERNAL (vars) && (TREE_PUBLIC (vars) || TREE_USED (vars)))
-    {
-      extern tree the_null_vtable_entry;
-
-      /* Stuff this virtual function table's size into
-	 `pfn' slot of `the_null_vtable_entry'.  */
-      tree nelts = array_type_nelts (TREE_TYPE (vars));
-      SET_FNADDR_FROM_VTABLE_ENTRY (the_null_vtable_entry, nelts);
-      /* Kick out the dossier before writing out the vtable.  */
-      if (flag_dossier)
-	rest_of_decl_compilation (TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (TREE_CHAIN (CONSTRUCTOR_ELTS (DECL_INITIAL (vars))))), 0), 0, 1, 1);
-
-      /* Write it out.  */
-      write_vtable_entries (vars);
-      if (TREE_TYPE (DECL_INITIAL (vars)) == 0)
-	store_init_value (vars, DECL_INITIAL (vars));
-      rest_of_decl_compilation (vars, 0, 1, 1);
-    }
-  /* We know that PREV must be non-zero here.  */
-  TREE_CHAIN (prev) = TREE_CHAIN (vars);
-}
-
-void
-walk_vtables (typedecl_fn, vardecl_fn)
-     register void (*typedecl_fn)();
-     register void (*vardecl_fn)();
-{
-  tree prev, vars;
-
-  for (prev = 0, vars = getdecls (); vars; vars = TREE_CHAIN (vars))
-    {
-      if (TREE_CODE (vars) == TYPE_DECL
-	  && TYPE_LANG_SPECIFIC (TREE_TYPE (vars))
-	  && CLASSTYPE_VSIZE (TREE_TYPE (vars)))
-	{
-	  if (typedecl_fn) (*typedecl_fn) (prev, vars);
-	}
-      else if (TREE_CODE (vars) == VAR_DECL && DECL_VIRTUAL_P (vars))
-	{
-	  if (vardecl_fn) (*vardecl_fn) (prev, vars);
-	}
-      else
-	prev = vars;
-    }
-}
-
-extern int parse_time, varconst_time;
-
-#define TIMEVAR(VAR, BODY)    \
-do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
-
-/* This routine is called from the last rule in yyparse ().
-   Its job is to create all the code needed to initialize and
-   destroy the global aggregates.  We do the destruction
-   first, since that way we only need to reverse the decls once.  */
-
-void
-finish_file ()
-{
-  extern int lineno;
-  int start_time, this_time;
-
-  char *buf;
-  char *p;
-  tree fnname;
-  tree vars = static_aggregates;
-  int needs_cleaning = 0, needs_messing_up = 0;
-
-  if (main_input_filename == 0)
-    main_input_filename = input_filename;
-  if (!first_global_object_name)
-    first_global_object_name = main_input_filename;
-
-  buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT)
-			 + strlen (first_global_object_name));
-
-  if (flag_detailed_statistics)
-    dump_tree_statistics ();
-
-  /* Bad parse errors.  Just forget about it.  */
-  if (! global_bindings_p () || current_class_type)
-    return;
-
-  start_time = get_run_time ();
-
-  /* Push into C language context, because that's all
-     we'll need here.  */
-  push_lang_context (lang_name_c);
-
-  /* Set up the name of the file-level functions we may need.  */
-  /* Use a global object (which is already required to be unique over
-     the program) rather than the file name (which imposes extra
-     constraints).  -- Raeburn@MIT.EDU, 10 Jan 1990.  */
-  sprintf (buf, FILE_FUNCTION_FORMAT, first_global_object_name);
-
-  /* Don't need to pull wierd characters out of global names.  */
-  if (first_global_object_name == main_input_filename)
-    {
-      for (p = buf+11; *p; p++)
-	if (! ((*p >= '0' && *p <= '9')
-#if 0 /* we always want labels, which are valid C++ identifiers (+ `$') */
-#ifndef ASM_IDENTIFY_GCC	/* this is required if `.' is invalid -- k. raeburn */
-	       || *p == '.'
-#endif
-#endif
-#ifndef NO_DOLLAR_IN_LABEL	/* this for `$'; unlikely, but... -- kr */
-	       || *p == '$'
-#endif
-#ifndef NO_DOT_IN_LABEL		/* this for `.'; unlikely, but... */
-	       || *p == '.'
-#endif
-	       || (*p >= 'A' && *p <= 'Z')
-	       || (*p >= 'a' && *p <= 'z')))
-	  *p = '_';
-    }
-
-  /* See if we really need the hassle.  */
-  while (vars && needs_cleaning == 0)
-    {
-      tree decl = TREE_VALUE (vars);
-      tree type = TREE_TYPE (decl);
-      if (TYPE_NEEDS_DESTRUCTOR (type))
-	{
-	  needs_cleaning = 1;
-	  needs_messing_up = 1;
-	  break;
-	}
-      else
-	needs_messing_up |= TYPE_NEEDS_CONSTRUCTING (type);
-      vars = TREE_CHAIN (vars);
-    }
-  if (needs_cleaning == 0)
-    goto mess_up;
-
-  /* Otherwise, GDB can get confused, because in only knows
-     about source for LINENO-1 lines.  */
-  lineno -= 1;
-
-  fnname = get_identifier (buf);
-  start_function (void_list_node, build_parse_node (CALL_EXPR, fnname, void_list_node, NULL_TREE), 0, 0);
-  fnname = DECL_ASSEMBLER_NAME (current_function_decl);
-  store_parm_decls ();
-
-  pushlevel (0);
-  clear_last_expr ();
-  push_momentary ();
-  expand_start_bindings (0);
-
-  /* These must be done in backward order to destroy,
-     in which they happen to be!  */
-  while (vars)
-    {
-      tree decl = TREE_VALUE (vars);
-      tree type = TREE_TYPE (decl);
-      tree temp = TREE_PURPOSE (vars);
-
-      if (TYPE_NEEDS_DESTRUCTOR (type))
-	{
-	  if (TREE_STATIC (vars))
-	    expand_start_cond (build_binary_op (NE_EXPR, temp, integer_zero_node, 1), 0);
-	  if (TREE_CODE (type) == ARRAY_TYPE)
-	    temp = decl;
-	  else
-	    {
-	      mark_addressable (decl);
-	      temp = build1 (ADDR_EXPR, TYPE_POINTER_TO (type), decl);
-	    }
-	  temp = build_delete (TREE_TYPE (temp), temp,
-			       integer_two_node, LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0, 0);
-	  expand_expr_stmt (temp);
-
-	  if (TREE_STATIC (vars))
-	    expand_end_cond ();
-	}
-      vars = TREE_CHAIN (vars);
-    }
-
-  expand_end_bindings (getdecls (), 1, 0);
-  poplevel (1, 0, 0);
-  pop_momentary ();
-
-  finish_function (lineno, 0);
-
-  assemble_destructor (IDENTIFIER_POINTER (fnname));
-
-  /* if it needed cleaning, then it will need messing up: drop through  */
-
- mess_up:
-  /* Must do this while we think we are at the top level.  */
-  vars = nreverse (static_aggregates);
-  if (vars != NULL_TREE)
-    {
-      buf[FILE_FUNCTION_PREFIX_LEN] = 'I';
-
-      fnname = get_identifier (buf);
-      start_function (void_list_node, build_parse_node (CALL_EXPR, fnname, void_list_node, NULL_TREE), 0, 0);
-      fnname = DECL_ASSEMBLER_NAME (current_function_decl);
-      store_parm_decls ();
-
-      pushlevel (0);
-      clear_last_expr ();
-      push_momentary ();
-      expand_start_bindings (0);
-
-      while (vars)
-	{
-	  tree decl = TREE_VALUE (vars);
-	  tree init = TREE_PURPOSE (vars);
-
-	  /* If this was a static attribute within some function's scope,
-	     then don't initialize it here.  Also, don't bother
-	     with initializers that contain errors.  */
-	  if (TREE_STATIC (vars)
-	      || (init && TREE_CODE (init) == TREE_LIST
-		  && value_member (error_mark_node, init)))
-	    {
-	      vars = TREE_CHAIN (vars);
-	      continue;
-	    }
-
-	  if (TREE_CODE (decl) == VAR_DECL)
-	    {
-	      /* Set these global variables so that GDB at least puts
-		 us near the declaration which required the initialization.  */
-	      input_filename = DECL_SOURCE_FILE (decl);
-	      lineno = DECL_SOURCE_LINE (decl);
-	      emit_note (input_filename, lineno);
-
-	      if (init)
-		{
-		  if (TREE_CODE (init) == VAR_DECL)
-		    {
-		      /* This behavior results when there are
-			 multiple declarations of an aggregate,
-			 the last of which defines it.  */
-		      if (DECL_RTL (init) == DECL_RTL (decl))
-			{
-			  my_friendly_assert (DECL_INITIAL (decl) == error_mark_node
-				  || (TREE_CODE (DECL_INITIAL (decl)) == CONSTRUCTOR
-				      && CONSTRUCTOR_ELTS (DECL_INITIAL (decl)) == NULL_TREE),
-					      199);
-			  init = DECL_INITIAL (init);
-			  if (TREE_CODE (init) == CONSTRUCTOR
-			      && CONSTRUCTOR_ELTS (init) == NULL_TREE)
-			    init = NULL_TREE;
-			}
-#if 0
-		      else if (TREE_TYPE (decl) == TREE_TYPE (init))
-			{
-#if 1
-			  my_friendly_abort (200);
-#else
-			  /* point to real decl's rtl anyway.  */
-			  DECL_RTL (init) = DECL_RTL (decl);
-			  my_friendly_assert (DECL_INITIAL (decl) == error_mark_node,
-					      201);
-			  init = DECL_INITIAL (init);
-#endif				/* 1 */
-			}
-#endif				/* 0 */
-		    }
-		}
-	      if (IS_AGGR_TYPE (TREE_TYPE (decl))
-		  || init == 0
-		  || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
-		{
-		  /* Set this up so is_friend() works properly on _GLOBAL_ fns.  */
-		  tree old_dcc = DECL_CLASS_CONTEXT (current_function_decl);
-		  if (old_dcc == NULL_TREE)
-		    DECL_CLASS_CONTEXT (current_function_decl) = TREE_TYPE (decl);
-		  expand_aggr_init (decl, init, 0);
-		  DECL_CLASS_CONTEXT (current_function_decl) = old_dcc;
-		}
-	      else if (TREE_CODE (init) == TREE_VEC)
-		{
-		  expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0),
-						TREE_VEC_ELT (init, 1),
-						TREE_VEC_ELT (init, 2), 0),
-			       const0_rtx, VOIDmode, 0);
-		  free_temp_slots ();
-		}
-	      else
-		expand_assignment (decl, init, 0, 0);
-	    }
-	  else if (TREE_CODE (decl) == SAVE_EXPR)
-	    {
-	      if (! PARM_DECL_EXPR (decl))
-		{
-		  /* a `new' expression at top level.  */
-		  expand_expr (decl, const0_rtx, VOIDmode, 0);
-		  free_temp_slots ();
-		  expand_aggr_init (build_indirect_ref (decl, 0), init, 0);
-		}
-	    }
-	  else if (decl == error_mark_node)
-	    ;
-	  else my_friendly_abort (22);
-	  vars = TREE_CHAIN (vars);
-	}
-
-      expand_end_bindings (getdecls (), 1, 0);
-      poplevel (1, 0, 0);
-      pop_momentary ();
-
-      finish_function (lineno, 0);
-      assemble_constructor (IDENTIFIER_POINTER (fnname));
-    }
-
-  /* Done with C language context needs.  */
-  pop_lang_context ();
-
-  /* Now write out any static class variables (which may have since
-     learned how to be initialized).  */
-  while (pending_statics)
-    {
-      tree decl = TREE_VALUE (pending_statics);
-      if (TREE_USED (decl) == 1
-	  || TREE_READONLY (decl) == 0
-	  || DECL_INITIAL (decl) == 0)
-	rest_of_decl_compilation (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1, 1);
-      pending_statics = TREE_CHAIN (pending_statics);
-    }
-
-  this_time = get_run_time ();
-  parse_time -= this_time - start_time;
-  varconst_time += this_time - start_time;
-
-  /* Now write out inline functions which had their addresses taken
-     and which were not declared virtual and which were not declared
-     `extern inline'.  */
-  while (pending_addressable_inlines)
-    {
-      tree decl = TREE_VALUE (pending_addressable_inlines);
-      if (! TREE_ASM_WRITTEN (decl)
-	  && ! DECL_EXTERNAL (decl)
-	  && DECL_SAVED_INSNS (decl))
-	output_inline_function (decl);
-      pending_addressable_inlines = TREE_CHAIN (pending_addressable_inlines);
-    }
-
-  start_time = get_run_time ();
-
-  /* Now delete from the chain of variables all virtual function tables.
-     We output them all ourselves, because each will be treated specially.  */
-
-#if 1
-  /* The reason for pushing garbage onto the global_binding_level is to
-     ensure that we can slice out _DECLs which pertain to virtual function
-     tables.  If the last thing pushed onto the global_binding_level was a
-     virtual function table, then slicing it out would slice away all the
-     decls (i.e., we lose the head of the chain).
-
-     There are several ways of getting the same effect, from changing the
-     way that iterators over the chain treat the elements that pertain to
-     virtual function tables, moving the implementation of this code to
-     cp-decl.c (where we can manipulate global_binding_level directly),
-     popping the garbage after pushing it and slicing away the vtable
-     stuff, or just leaving it alone. */
-
-  /* Make last thing in global scope not be a virtual function table.  */
-#if 0 /* not yet, should get fixed properly later */
-  vars = make_type_decl (get_identifier (" @%$#@!"), integer_type_node);
-#else
-  vars = build_decl (TYPE_DECL, get_identifier (" @%$#@!"), integer_type_node);
-#endif
-  DECL_IGNORED_P (vars) = 1;
-  DECL_SOURCE_LINE (vars) = 0;
-  pushdecl (vars);
-#endif
-
-  walk_vtables (finish_vtable_typedecl, finish_vtable_vardecl);
-
-  if (write_virtuals == 2)
-    {
-      /* Now complain about an virtual function tables promised
-	 but not delivered.  */
-      while (pending_vtables)
-	{
-	  if (TREE_PURPOSE (pending_vtables) == NULL_TREE)
-	    error ("virtual function table for `%s' not defined",
-		   IDENTIFIER_POINTER (TREE_VALUE (pending_vtables)));
-	  pending_vtables = TREE_CHAIN (pending_vtables);
-	}
-    }
-
-  permanent_allocation ();
-  this_time = get_run_time ();
-  parse_time -= this_time - start_time;
-  varconst_time += this_time - start_time;
-
-  if (flag_detailed_statistics)
-    dump_time_statistics ();
-}
diff --git a/gnu/gcc2/cc1plus/cp-edsel.c b/gnu/gcc2/cc1plus/cp-edsel.c
deleted file mode 100644
index 78b2637f78d2..000000000000
--- a/gnu/gcc2/cc1plus/cp-edsel.c
+++ /dev/null
@@ -1,927 +0,0 @@
-/* Interface to LUCID Cadillac system for GNU compiler.
-   Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
-
-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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-#include "config.h"
-
-#include "tree.h"
-#include "flags.h"
-#include <stdio.h>
-#include "cp-tree.h"
-#include "obstack.h"
-
-#ifdef CADILLAC
-#include <compilerreq.h>
-#include <compilerconn.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <errno.h>
-#include <sys/file.h>
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-void init_cadillac ();
-
-extern char *input_filename;
-extern int lineno;
-
-/* Put random information we might want to get back from
-   Cadillac here.  */
-typedef struct
-{
-  /* The connection to the Cadillac kernel.  */
-  Connection *conn;
-
-  /* Input and output file descriptors for Cadillac.  */
-  short fd_input, fd_output;
-
-  /* #include nesting of current file.  */
-  short depth;
-
-  /* State variables for the connection.  */
-  char messages;
-  char conversion;
-  char emission;
-  char process_until;
-
-  /* #if level of current file.  */
-  int iflevel;
-
-  /* Line number that starts current source file.  */
-  int lineno;
-
-  /* Name of current file.  */
-  char *filename;
-
-  /* Where to stop processing (if process_until is set).  */
-  char *end_filename;
-  int end_position;
-
-} cadillac_struct;
-static cadillac_struct cadillacObj;
-
-/* Nonzero if in the process of exiting.  */
-static int exiting;
-
-void cadillac_note_source ();
-static void CWriteLanguageDecl ();
-static void CWriteLanguageType ();
-static void CWriteTopLevel ();
-static void cadillac_note_filepos ();
-static void cadillac_process_request (), cadillac_process_requests ();
-static void cadillac_switch_source ();
-static void exit_cadillac ();
-
-/* Blocking test.  */
-static int
-readable_p (fd)
-     int fd;
-{
-  fd_set f;
-
-  FD_ZERO (&f);
-  FD_SET (fd, &f);
-
-  return select (32, &f, NULL, NULL, 0) == 1;
-}
-
-static CObjectType *tree_to_cadillac_map;
-struct obstack cadillac_obstack;
-
-
-#include "stack.h"
-
-struct context_level
-{
-  struct stack_level base;
-
-  tree context;
-};
-
-/* Stack for maintaining contexts (in case functions or types are nested).
-   When defining a struct type, the `context' field is the RECORD_TYPE.
-   When defining a function, the `context' field is the FUNCTION_DECL.  */
-
-static struct context_level *context_stack;
-
-static struct context_level *
-push_context_level (stack, obstack)
-     struct stack_level *stack;
-     struct obstack *obstack;
-{
-  struct context_level tem;
-
-  tem.base.prev = stack;
-  return (struct context_level *)push_stack_level (obstack, &tem, sizeof (tem));
-}
-
-/* Discard a level of search allocation.  */
-
-static struct context_level *
-pop_context_level (stack)
-     struct context_level *stack;
-{
-  stack = (struct context_level *)pop_stack_level (stack);
-  return stack;
-}
-
-void
-init_cadillac ()
-{
-  extern FILE *finput;
-  extern int errno;
-  CCompilerMessage* req;
-  cadillac_struct *cp = &cadillacObj;
-  int i;
-
-  if (! flag_cadillac)
-    return;
-
-  tree_to_cadillac_map = (CObjectType*) xmalloc (sizeof (CObjectType) * LAST_CPLUS_TREE_CODE);
-  for (i = 0; i < LAST_CPLUS_TREE_CODE; i++)
-    tree_to_cadillac_map[i] = MiscOType;
-  tree_to_cadillac_map[RECORD_TYPE] = StructOType;
-  tree_to_cadillac_map[UNION_TYPE] = UnionOType;
-  tree_to_cadillac_map[ENUMERAL_TYPE] = EnumTypeOType;
-  tree_to_cadillac_map[TYPE_DECL] = TypedefOType;
-  tree_to_cadillac_map[VAR_DECL] = VariableOType;
-  tree_to_cadillac_map[CONST_DECL] = EnumConstantOType;
-  tree_to_cadillac_map[FUNCTION_DECL] = FunctionOType;
-  tree_to_cadillac_map[FIELD_DECL] = FieldOType;
-
-#ifdef sun
-  on_exit (&exit_cadillac, 0);
-#endif
-
-  gcc_obstack_init (&cadillac_obstack);
-
-  /* Yow!  This is the way Cadillac was designed to deal with
-     Oregon C++ compiler!  */
-  cp->fd_input = flag_cadillac;
-  cp->fd_output = flag_cadillac;
-
-  /* Start in "turned-on" state.  */
-  cp->messages = 1;
-  cp->conversion = 1;
-  cp->emission = 1;
-
-  /* Establish a connection with Cadillac here.  */
-  cp->conn = NewConnection (cp, cp->fd_input, cp->fd_output);
-
-  CWriteHeader (cp->conn, WaitingMType, 0);
-  CWriteRequestBuffer (cp->conn);
-
-  if (!readable_p (cp->fd_input))
-    ;
-
-  req = CReadCompilerMessage (cp->conn);
-
-  if (!req)
-    switch (errno)
-      {
-      case EWOULDBLOCK:
-	sleep (5);
-	return;
-      
-      case 0:
-	fatal ("init_cadillac: EOF on connection to kernel, exiting\n");
-	break;
-
-      default:
-	perror ("Editor to kernel connection");
-	exit (0);
-      }
-}
-
-static void
-cadillac_process_requests (conn)
-     Connection *conn;
-{
-  CCompilerMessage *req;
-  while (req = (CCompilerMessage*) CPeekNextRequest (conn))
-    {
-      req = CReadCompilerMessage (conn);
-      cadillac_process_request (&cadillacObj, req);
-    }
-}
-
-static void
-cadillac_process_request (cp, req)
-     cadillac_struct *cp;
-     CCompilerMessage *req;
-{
-  if (! req)
-    return;
-
-  switch (req->reqType)
-    {
-    case ProcessUntilMType:
-      if (cp->process_until)
-	my_friendly_abort (23);
-      cp->process_until = 1;
-      /* This is not really right.  */
-      cp->end_position = ((CCompilerCommand*)req)->processuntil.position;
-#if 0
-      cp->end_filename = req->processuntil.filename;
-#endif
-      break;
-
-    case CommandMType:
-      switch (req->header.data)
-	{
-	case MessagesOnCType:
-	  cp->messages = 1;
-	  break;
-	case MessagesOffCType:
-	  cp->messages = 0;
-	  break;
-	case ConversionOnCType:
-	  cp->conversion = 1;
-	  break;
-	case ConversionOffCType:
-	  cp->conversion = 0;
-	  break;
-	case EmissionOnCType:
-	  cp->emission = 1;
-	  break;
-	case EmissionOffCType:
-	  cp->emission = 0;
-	  break;
-
-	case FinishAnalysisCType:
-	  return;
-
-	case PuntAnalysisCType:
-	case ContinueAnalysisCType:
-	case GotoFileposCType:
-	case OpenSucceededCType:
-	case OpenFailedCType:
-	  fprintf (stderr, "request type %d not implemented\n", req->reqType);
-	  return;
-
-	case DieCType:
-	  if (! exiting)
-	    my_friendly_abort (24);
-	  return;
-
-	}
-      break;
-
-    default:
-      fatal ("unknown request type %d", req->reqType);
-    }
-}
-
-void
-cadillac_start ()
-{
-  Connection *conn = cadillacObj.conn;
-  CCompilerMessage *req;
-
-  /* Let Cadillac know that we start in C++ language scope.  */
-  CWriteHeader (conn, ForeignLinkageMType, LinkCPlus);
-  CWriteLength (conn);
-  CWriteRequestBuffer (conn);
-
-  cadillac_process_requests (conn);
-}
-
-static void
-cadillac_printf (msg, name)
-{
-  if (cadillacObj.messages)
-    printf ("[%s,%4d] %s `%s'\n", input_filename, lineno, msg, name);
-}
-
-void
-cadillac_start_decl (decl)
-     tree decl;
-{
-  Connection *conn = cadillacObj.conn;
-  CObjectType object_type = tree_to_cadillac_map [TREE_CODE (decl)];
-
-  if (context_stack)
-    switch (TREE_CODE (context_stack->context))
-      {
-      case FUNCTION_DECL:
-	/* Currently, cadillac only implements top-level forms.  */
-	return;
-      case RECORD_TYPE:
-      case UNION_TYPE:
-	cadillac_printf ("start class-level decl", IDENTIFIER_POINTER (DECL_NAME (decl)));
-	break;
-      default:
-	my_friendly_abort (25);
-      }
-  else
-    {
-      cadillac_printf ("start top-level decl", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
-      CWriteTopLevel (conn, StartMType);
-    }
-
-  CWriteLanguageDecl (conn, decl, tree_to_cadillac_map[TREE_CODE (decl)]);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_finish_decl (decl)
-     tree decl;
-{
-  Connection *conn = cadillacObj.conn;
-
-  if (context_stack)
-    switch (TREE_CODE (context_stack->context))
-      {
-      case FUNCTION_DECL:
-	return;
-      case RECORD_TYPE:
-      case UNION_TYPE:
-	cadillac_printf ("end class-level decl", IDENTIFIER_POINTER (DECL_NAME (decl)));
-	CWriteHeader (conn, EndDefMType, 0);
-	CWriteLength (conn);
-	break;
-      default:
-	my_friendly_abort (26);
-      }
-  else
-    {
-      cadillac_printf ("end top-level decl", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
-      CWriteHeader (conn, EndDefMType, 0);
-      CWriteLength (conn);
-      CWriteTopLevel (conn, StopMType);
-    }
-
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_start_function (fndecl)
-     tree fndecl;
-{
-  Connection *conn = cadillacObj.conn;
-
-  if (context_stack)
-    /* nested functions not yet handled.  */
-    my_friendly_abort (27);
-
-  cadillac_printf ("start top-level function", lang_printable_name (fndecl));
-  context_stack = push_context_level (context_stack, &cadillac_obstack);
-  context_stack->context = fndecl;
-
-  CWriteTopLevel (conn, StartMType);
-  my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 202);
-  CWriteLanguageDecl (conn, fndecl,
-		      (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE
-		       ? MemberFnOType : FunctionOType));
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_finish_function (fndecl)
-     tree fndecl;
-{
-  Connection *conn = cadillacObj.conn;
-
-  cadillac_printf ("end top-level function", lang_printable_name (fndecl));
-  context_stack = pop_context_level (context_stack);
-
-  if (context_stack)
-    /* nested functions not yet implemented.  */
-    my_friendly_abort (28);
-
-  CWriteHeader (conn, EndDefMType, 0);
-  CWriteLength (conn);
-  CWriteTopLevel (conn, StopMType);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_finish_anon_union (decl)
-     tree decl;
-{
-  Connection *conn = cadillacObj.conn;
-
-  if (! global_bindings_p ())
-    return;
-  cadillac_printf ("finish top-level anon union", "");
-  CWriteHeader (conn, EndDefMType, 0);
-  CWriteLength (conn);
-  CWriteTopLevel (conn, StopMType);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_start_enum (type)
-     tree type;
-{
-  Connection *conn = cadillacObj.conn;
-
-  tree name = TYPE_NAME (type);
-
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-
-  if (context_stack)
-    switch (TREE_CODE (context_stack->context))
-      {
-      case FUNCTION_DECL:
-	return;
-      case RECORD_TYPE:
-      case UNION_TYPE:
-	break;
-      default:
-	my_friendly_abort (29);
-      }
-  else
-    {
-      cadillac_printf ("start top-level enum", IDENTIFIER_POINTER (name));
-      CWriteTopLevel (conn, StartMType);
-    }
-
-  CWriteLanguageType (conn, type, tree_to_cadillac_map[ENUMERAL_TYPE]);
-}
-
-void
-cadillac_finish_enum (type)
-     tree type;
-{
-  Connection *conn = cadillacObj.conn;
-  tree name = TYPE_NAME (type);
-
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-
-  if (context_stack)
-    switch (TREE_CODE (context_stack->context))
-      {
-      case FUNCTION_DECL:
-	return;
-      case RECORD_TYPE:
-      case UNION_TYPE:
-	CWriteHeader (conn, EndDefMType, 0);
-	CWriteLength (conn);
-	break;
-      default:
-	my_friendly_abort (30);
-      }
-  else
-    {
-      CWriteHeader (conn, EndDefMType, 0);
-      CWriteLength (conn);
-      cadillac_printf ("finish top-level enum", IDENTIFIER_POINTER (name));
-      CWriteTopLevel (conn, StopMType);
-    }
-
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_start_struct (type)
-     tree type;
-{
-  Connection *conn = cadillacObj.conn;
-  tree name = TYPE_NAME (type);
-
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-
-  if (context_stack)
-    switch (TREE_CODE (context_stack->context))
-      {
-      case FUNCTION_DECL:
-	return;
-      case RECORD_TYPE:
-      case UNION_TYPE:
-	return;
-      default:
-	my_friendly_abort (31);
-      }
-  else
-    {
-      cadillac_printf ("start struct", IDENTIFIER_POINTER (name));
-      CWriteTopLevel (conn, StartMType);
-    }
-
-  context_stack = push_context_level (context_stack, &cadillac_obstack);
-  context_stack->context = type;
-
-  CWriteLanguageType (conn, type,
-		      TYPE_LANG_SPECIFIC (type) && CLASSTYPE_DECLARED_CLASS (type) ? ClassOType : tree_to_cadillac_map[TREE_CODE (type)]);
-}
-
-void
-cadillac_finish_struct (type)
-     tree type;
-{
-  Connection *conn = cadillacObj.conn;
-  tree name = TYPE_NAME (type);
-
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-
-  context_stack = pop_context_level (context_stack);
-  if (context_stack)
-    return;
-
-  cadillac_printf ("finish struct", IDENTIFIER_POINTER (name));
-  CWriteHeader (conn, EndDefMType, 0);
-  CWriteLength (conn);
-  CWriteTopLevel (conn, StopMType);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_finish_exception (type)
-     tree type;
-{
-  Connection *conn = cadillacObj.conn;
-
-  fatal ("cadillac_finish_exception");
-  CWriteHeader (conn, EndDefMType, 0);
-  CWriteLength (conn);
-  CWriteTopLevel (conn, StopMType);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_push_class (type)
-     tree type;
-{
-}
-
-void
-cadillac_pop_class ()
-{
-}
-
-void
-cadillac_push_lang (name)
-     tree name;
-{
-  Connection *conn = cadillacObj.conn;
-  CLinkLanguageType m;
-
-  if (name == lang_name_cplusplus)
-    m = LinkCPlus;
-  else if (name == lang_name_c)
-    m = LinkC;
-  else
-    my_friendly_abort (32);
-  CWriteHeader (conn, ForeignLinkageMType, m);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_pop_lang ()
-{
-  Connection *conn = cadillacObj.conn;
-
-  CWriteHeader (conn, ForeignLinkageMType, LinkPop);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_finish_stmt ()
-{
-}
-
-void
-cadillac_note_source ()
-{
-  cadillacObj.lineno = lineno;
-  cadillacObj.filename = input_filename;
-}
-
-static void
-CWriteTopLevel (conn, m)
-     Connection *conn;
-     CMessageSubType m;
-{
-  static context_id = 0;
-  CWriteHeader (conn, TopLevelFormMType, m);
-  cadillac_note_filepos ();
-
-  /* Eventually, this will point somewhere into the digest file.  */
-  context_id += 1;
-  CWriteSomething (conn, &context_id, sizeof (BITS32));
-
-  CWriteSomething (conn, &cadillacObj.iflevel, sizeof (BITS32));
-  CWriteLength (conn);
-}
-
-static void
-cadillac_note_filepos ()
-{
-  extern FILE *finput;
-  int pos = ftell (finput);
-  CWriteSomething (cadillacObj.conn, &pos, sizeof (BITS32));
-}
-
-void
-cadillac_switch_source (startflag)
-     int startflag;
-{
-  Connection *conn = cadillacObj.conn;
-  /* Send out the name of the source file being compiled.  */
-
-  CWriteHeader (conn, SourceFileMType, startflag ? StartMType : StopMType);
-  CWriteSomething (conn, &cadillacObj.depth, sizeof (BITS16));
-  CWriteVstring0 (conn, input_filename);
-  CWriteLength (conn);
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-void
-cadillac_push_source ()
-{
-  cadillacObj.depth += 1;
-  cadillac_switch_source (1);
-}
-
-void
-cadillac_pop_source ()
-{
-  cadillacObj.depth -= 1;
-  cadillac_switch_source (0);
-}
-
-struct cadillac_mdep
-{
-  short object_type;
-  char linkage;
-  char access;
-  short length;
-};
-
-static void
-CWriteLanguageElem (conn, p, name)
-     Connection *conn;
-     struct cadillac_mdep *p;
-     char *name;
-{
-  CWriteSomething (conn, &p->object_type, sizeof (BITS16));
-  CWriteSomething (conn, &p->linkage, sizeof (BITS8));
-  CWriteSomething (conn, &p->access, sizeof (BITS8));
-  CWriteSomething (conn, &p->length, sizeof (BITS16));
-  CWriteVstring0 (conn, name);
-
-#if 0
-  /* Don't write date_type.  */
-  CWriteVstring0 (conn, "");
-#endif
-  CWriteLength (conn);
-}
-
-static void
-CWriteLanguageDecl (conn, decl, object_type)
-     Connection *conn;
-     tree decl;
-     CObjectType object_type;
-{
-  struct cadillac_mdep foo;
-  tree name;
-
-  CWriteHeader (conn, LanguageElementMType, StartDefineMType);
-  foo.object_type = object_type;
-  if (decl_type_context (decl))
-    {
-      foo.linkage = ParentLinkage;
-      if (TREE_PRIVATE (decl))
-	foo.access = PrivateAccess;
-      else if (TREE_PROTECTED (decl))
-	foo.access = ProtectedAccess;
-      else
-	foo.access = PublicAccess;
-    }
-  else
-    {
-      if (TREE_PUBLIC (decl))
-	foo.linkage = GlobalLinkage;
-      else
-	foo.linkage = FileLinkage;
-      foo.access = PublicAccess;
-    }
-  name = DECL_NAME (decl);
-  foo.length = IDENTIFIER_LENGTH (name);
-
-  CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-static void
-CWriteLanguageType (conn, type, object_type)
-     Connection *conn;
-     tree type;
-     CObjectType object_type;
-{
-  struct cadillac_mdep foo;
-  tree name = TYPE_NAME (type);
-
-  CWriteHeader (conn, LanguageElementMType, StartDefineMType);
-  foo.object_type = object_type;
-  if (current_class_type)
-    {
-      foo.linkage = ParentLinkage;
-      if (TREE_PRIVATE (type))
-	foo.access = PrivateAccess;
-      else if (TREE_PROTECTED (type))
-	foo.access = ProtectedAccess;
-      else
-	foo.access = PublicAccess;
-    }
-  else
-    {
-      foo.linkage = NoLinkage;
-      foo.access = PublicAccess;
-    }
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-
-  foo.length = IDENTIFIER_LENGTH (name);
-
-  CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-static void
-CWriteUseObject (conn, type, object_type, use)
-     Connection *conn;
-     tree type;
-     CObjectType object_type;
-     CMessageSubType use;
-{
-  struct cadillac_mdep foo;
-  tree name = NULL_TREE;
-
-  CWriteHeader (conn, LanguageElementMType, use);
-  foo.object_type = object_type;
-  if (current_class_type)
-    {
-      foo.linkage = ParentLinkage;
-      if (TREE_PRIVATE (type))
-	foo.access = PrivateAccess;
-      else if (TREE_PROTECTED (type))
-	foo.access = ProtectedAccess;
-      else
-	foo.access = PublicAccess;
-    }
-  else
-    {
-      foo.linkage = NoLinkage;
-      foo.access = PublicAccess;
-    }
-  switch (TREE_CODE (type))
-    {
-    case VAR_DECL:
-    case FIELD_DECL:
-    case TYPE_DECL:
-    case CONST_DECL:
-    case FUNCTION_DECL:
-      name = DECL_NAME (type);
-      break;
-
-    default:
-      my_friendly_abort (33);
-  }
-
-  foo.length = IDENTIFIER_LENGTH (name);
-
-  CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
-  CWriteRequestBuffer (conn);
-  cadillac_process_requests (conn);
-}
-
-/* Here's how we exit under cadillac.  */
-
-static void
-exit_cadillac ()
-{
-  extern int errorcount;
-
-  Connection *conn = cadillacObj.conn;
-
-  if (flag_cadillac)
-    {
-      CCompilerMessage *req;
-
-      CWriteHeader (conn, FinishedMType,
-		    errorcount ? 0 : CsObjectWritten | CsComplete);
-      /* Bye, bye!  */
-      CWriteRequestBuffer (conn);
-
-      /* Block on read.  */
-      while (! readable_p (cadillacObj.fd_input))
-	{
-	  if (exiting)
-	    my_friendly_abort (34);
-	  exiting = 1;
-	}
-      exiting = 1;
-
-      req = CReadCompilerMessage (conn);
-      cadillac_process_request (&cadillacObj, req);
-    }
-}
-
-#else
-/* Stubs.  */
-void init_cadillac () {}
-void cadillac_start () {}
-void cadillac_start_decl (decl)
-     tree decl;
-{}
-void
-cadillac_finish_decl (decl)
-     tree decl;
-{}
-void
-cadillac_start_function (fndecl)
-     tree fndecl;
-{}
-void
-cadillac_finish_function (fndecl)
-     tree fndecl;
-{}
-void
-cadillac_finish_anon_union (decl)
-     tree decl;
-{}
-void
-cadillac_start_enum (type)
-     tree type;
-{}
-void
-cadillac_finish_enum (type)
-     tree type;
-{}
-void
-cadillac_start_struct (type)
-     tree type;
-{}
-void
-cadillac_finish_struct (type)
-     tree type;
-{}
-void
-cadillac_finish_exception (type)
-     tree type;
-{}
-void
-cadillac_push_class (type)
-     tree type;
-{}
-void
-cadillac_pop_class ()
-{}
-void
-cadillac_push_lang (name)
-     tree name;
-{}
-void
-cadillac_pop_lang ()
-{}
-void
-cadillac_note_source ()
-{}
-void
-cadillac_finish_stmt ()
-{}
-void
-cadillac_switch_source ()
-{}
-void
-cadillac_push_source ()
-{}
-void
-cadillac_pop_source ()
-{}
-#endif
diff --git a/gnu/gcc2/cc1plus/cp-except.c b/gnu/gcc2/cc1plus/cp-except.c
deleted file mode 100644
index 6f5dc3b09796..000000000000
--- a/gnu/gcc2/cc1plus/cp-except.c
+++ /dev/null
@@ -1,1221 +0,0 @@
-/* Handle exceptional things in C++.
-   Copyright (C) 1989, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* High-level class interface. */
-
-#include "config.h"
-#include "tree.h"
-#include "rtl.h"
-#include "cp-tree.h"
-#include "flags.h"
-/* On Suns this can get you to the right definition if you
-   set the right value for TARGET.  */
-#include <setjmp.h>
-#ifdef sequent
-/* Can you believe they forgot this?  */
-#define _JBLEN 11
-#endif
-
-#ifndef _JBLEN
-#define _JBLEN (sizeof(jmp_buf)/sizeof(int))
-#endif
-
-#undef NULL
-#define NULL (char *)0
-
-/* This should be part of `ansi_opname', or at least be defined by the std.  */
-#define EXCEPTION_NAME_PREFIX "__ex"
-#define EXCEPTION_NAME_LENGTH 4
-
-void init_exception_processing ();
-void init_exception_processing_1 ();
-
-/* If non-zero, a VAR_DECL whose cleanup will cause a throw to the
-   next exception handler.  Its value says whether to throw or not.
-   In the case of functions which do not issue a RAISE, it should be
-   possible to optimize away this VAR_DECL (and overhead associated
-   with it).  */
-tree exception_throw_decl;
-/* Use this to know that we did not set `exception_throw_decl',
-   until GCC optimizer is smart enough to figure it out for itself.  */
-int sets_exception_throw_decl;
-
-/* The exception `type' currently in scope, or NULL_TREE if none.  */
-tree current_exception_type;
-
-/* The exception handler object for the given scope.  */
-tree current_exception_decl;
-rtx current_exception_name_as_rtx;
-rtx current_exception_parms_as_rtx;
-
-/* The ``object'' view of the current exception parameters.
-   We cast up from the `parms' field to `current_exception_type'.  */
-tree current_exception_object;
-
-/* Cache `setjmp', `longjmp', `raise_exception', and `unhandled_exception'
-   after default conversion.  Maybe later they will get built-in.  */
-static tree BISJ, BILJ, BIR, BIUE;
-
-/* Local variables which give the appearance that exception
-   handling is part of the language and the execution model.  */
-
-/* The type of the exception handler stack.  */
-static tree EHS_type;
-
-/* The global handler stack.  */
-tree EHS_decl;
-
-/* Cached component refs to fields of `EHS_decl'.  */
-static tree EHS_prev, EHS_handler, EHS_parms, EHS_name;
-static rtx EHS_parms_as_rtx, EHS_name_as_rtx;
-
-/* The parameter names of this exception type.  */
-
-static tree last_exception_fields;
-static tree last_exception_field_types;
-
-/* When ID is VOID_TYPE_NODE, it means ``raise all''.
-   Cannot be inline, since it uses `alloca', and that
-   breaks code which pushes the result of this function
-   on the stack.  */
-static tree
-exception_object_name (prefix, id)
-     tree prefix;
-     tree id;
-{
-  /* First, cons up the `name' of this exception.  */
-  char *name;
-  int length = (id == void_type_node ? 3 : IDENTIFIER_LENGTH (id)) + EXCEPTION_NAME_LENGTH;
-
-  if (prefix)
-    length += IDENTIFIER_LENGTH (prefix) + 2;
-
-  name = (char *)alloca (length);
-  strcpy (name, EXCEPTION_NAME_PREFIX);
-  length = EXCEPTION_NAME_LENGTH;
-  if (prefix)
-    {
-      strcpy (name + length, IDENTIFIER_POINTER (prefix));
-#ifdef JOINER
-      name[length + IDENTIFIER_LENGTH (prefix)] = JOINER;
-#else
-      name[length + IDENTIFIER_LENGTH (prefix)] = '_';
-#endif
-      length += IDENTIFIER_LENGTH (prefix) + 1;
-    }
-  if (id == void_type_node)
-    strcpy (name + length, "all");
-  else
-    strcpy (name + length, IDENTIFIER_POINTER (id));
-  return get_identifier (name);
-}
-
-tree
-lookup_exception_cname (ctype, cname, raise_id)
-     tree ctype, cname;
-     tree raise_id;
-{
-  tree this_cname = TREE_PURPOSE (raise_id);
-  if (this_cname == NULL_TREE)
-    {
-      if (cname)
-	{
-	  tree name = TREE_VALUE (raise_id);
-	  if (purpose_member (name, CLASSTYPE_TAGS (ctype)))
-	    this_cname = cname;
-	}
-    }
-  else if (this_cname == void_type_node)
-    this_cname = NULL_TREE;
-  else if (TREE_CODE (this_cname) != IDENTIFIER_NODE)
-    {
-      sorry ("multiple scope refs in `cplus_expand_raise_stmt'");
-      this_cname = error_mark_node;
-    }
-  return this_cname;
-}
-
-tree
-lookup_exception_tname (oname)
-     tree oname;
-{
-  return get_identifier (IDENTIFIER_POINTER (oname) + EXCEPTION_NAME_LENGTH);
-}
-
-tree
-lookup_exception_object (cname, name, complain)
-     tree cname, name;
-     int complain;
-{
-  tree oname;
-  tree decl;
-
-  if (cname == void_type_node)
-    cname = NULL_TREE;
-  else if (cname && TREE_CODE (cname) != IDENTIFIER_NODE)
-    {
-      sorry ("multiple scope refs in `lookup_exception_object'");
-      cname = NULL_TREE;
-    }
-  oname = exception_object_name (cname, name);
-  decl = IDENTIFIER_GLOBAL_VALUE (oname);
-  if (decl == NULL_TREE || TREE_CODE (decl) != VAR_DECL)
-    {
-      if (complain)
-	{
-	  push_obstacks_nochange ();
-
-	  if (cname)
-	    error ("no exception name object for name `%s::%s'",
-		   IDENTIFIER_POINTER (cname),
-		   IDENTIFIER_POINTER (name));
-	  else
-	    error ("no exception name object for name `%s'",
-		   IDENTIFIER_POINTER (name));
-	  end_temporary_allocation ();
-	  /* Avoid further error messages.  */
-	  pushdecl_top_level (build_lang_field_decl (VAR_DECL,
-						     exception_object_name (cname, name),
-						     error_mark_node));
-	  pop_obstacks ();
-	}
-      return NULL_TREE;
-    }
-  return decl;
-}
-
-tree
-lookup_exception_type (ctype, cname, raise_id)
-     tree ctype, cname;
-     tree raise_id;
-{
-  tree name = TREE_VALUE (raise_id);
-  tree purpose = TREE_PURPOSE (raise_id);
-
-  if (cname && purpose == NULL_TREE)
-    purpose = cname;
-
-  if (purpose && purpose != void_type_node)
-    {
-      tree link = NULL_TREE;
-
-      if (TREE_CODE (purpose) != IDENTIFIER_NODE)
-	{
-	  sorry ("multiple scope refs in `lookup_exception_type'");
-	  TREE_PURPOSE (raise_id) = NULL_TREE;
-	  return NULL_TREE;
-	}
-      if (! is_aggr_typedef (purpose, 1))
-	return NULL_TREE;
-      ctype = IDENTIFIER_TYPE_VALUE (purpose);
-      link = purpose_member (name, CLASSTYPE_TAGS (ctype));
-      if (link)
-	return TREE_VALUE (link);
-    }
-
-  ctype = lookup_name (name, 1);
-  if (ctype && TREE_CODE (ctype) == TYPE_DECL)
-    ctype = TREE_TYPE (ctype);
-  if (ctype && TREE_CODE (ctype) == RECORD_TYPE
-      && CLASSTYPE_DECLARED_EXCEPTION (ctype))
-    return ctype;
-  return NULL_TREE;
-}
-
-tree
-finish_exception (e, list_of_fieldlists)
-     tree e;
-     tree list_of_fieldlists;
-{
-  tree parmtypes = NULL_TREE, name_field;
-  tree cname = TYPE_NAME (e);
-
-  if (TREE_CODE (cname) == TYPE_DECL)
-    cname = DECL_NAME (cname);
-
-  if (last_exception_fields)
-    error ("cannot declare exceptions within exceptions");
-  if (list_of_fieldlists && ! ANON_AGGRNAME_P (cname))
-    error_with_aggr_type (e, "exception name `%s' must follow body declaration");
-  if (list_of_fieldlists)
-    {
-      tree prev, field;
-
-      /* Note: no public, private, or protected allowed.  */
-      if (TREE_CHAIN (list_of_fieldlists))
-	error ("visibility declarations invalid in exception declaration");
-      else if (TREE_PURPOSE (list_of_fieldlists) != (tree)visibility_default)
-	error ("visibility declarations invalid in exception declaration");
-      TREE_PURPOSE (list_of_fieldlists) = (tree)visibility_default;
-
-      /* Note also: no member function declarations allowed.  */
-      for (prev = 0, field = TREE_VALUE (list_of_fieldlists);
-	   field; prev = field, field = TREE_CHAIN (field))
-	{
-	  switch (TREE_CODE (field))
-	    {
-	    case FIELD_DECL:
-	      /* ok.  */
-	      parmtypes = tree_cons (NULL_TREE, TREE_TYPE (field), parmtypes);
-	      continue;
-	    case FUNCTION_DECL:
-	      error_with_decl (field, "declaration of function `%s' in exception invalid");
-	      break;
-	    case VAR_DECL:
-	      if (TREE_STATIC (field))
-		error_with_decl (field, "declaration of static variable `%s' in exception invalid");
-	      else
-		error_with_decl (field, "declaration of constant field `%s' in exception invalid");
-	      break;
-	    case CONST_DECL:
-	      error_with_decl (field, "declaration of enum value `%s' in exception invalid");
-	      break;
-	    case SCOPE_REF:
-	      error ("use of `::' in exception context invalid");
-	      break;
-	    }
-	  if (prev)
-	    TREE_CHAIN (prev) = TREE_CHAIN (field);
-	  else
-	    TREE_VALUE (list_of_fieldlists) = TREE_CHAIN (field);
-	}
-    }
-
-  /* Now that we've cleaned up the fields, add a name identifier at front.  */
-  name_field = build_lang_field_decl (FIELD_DECL, get_identifier ("__name"),
-				      ptr_type_node);
-  if (list_of_fieldlists)
-    {
-      TREE_CHAIN (name_field) = TREE_VALUE (list_of_fieldlists);
-      TREE_VALUE (list_of_fieldlists) = name_field;
-    }
-  else
-    list_of_fieldlists = build_tree_list (NULL_TREE, name_field);
-
-  last_exception_fields = TREE_VALUE (list_of_fieldlists);
-  if (parmtypes)
-    {
-      last_exception_field_types = nreverse (parmtypes);
-      /* Set the TREE_CHAIN of what is now at the end of the
-	 list to `void_list_node'.  */
-      TREE_CHAIN (parmtypes) = void_list_node;
-    }
-  else
-    last_exception_field_types = void_list_node;
-
-  popclass (0);
-
-#if 0
-  /* Remove aggregate types from the list of tags,
-     since these appear at global scope.  */
-  while (x && IS_AGGR_TYPE (TREE_VALUE (x)))
-    x = TREE_CHAIN (x);
-  CLASSTYPE_TAGS (t) = x;
-  y = x;
-  while (x)
-    {
-      if (IS_AGGR_TYPE (TREE_VALUE (x)))
-	TREE_CHAIN (y) = TREE_CHAIN (x);
-      x = TREE_CHAIN (x);
-    }
-#endif
-
-  if (flag_cadillac)
-    cadillac_finish_exception (e);
-
-  return e;
-}
-
-void
-finish_exception_decl (cname, decl)
-     tree cname, decl;
-{
-  /* In cp-decl.h.  */
-  extern tree last_function_parms;
-
-  /* An exception declaration.  */
-  tree t, ctor;
-  tree parmdecls = NULL_TREE, fields;
-  tree list_of_fieldlists = temp_tree_cons (NULL_TREE,
-					    copy_list (last_exception_fields),
-					    NULL_TREE);
-  tree edecl = build_lang_field_decl (VAR_DECL,
-				      exception_object_name (cname, DECL_NAME (decl)),
-				      ptr_type_node);
-
-  DECL_LANGUAGE (edecl) = lang_c;
-  TREE_STATIC (edecl) = 1;
-  TREE_PUBLIC (edecl) = 1;
-  finish_decl (pushdecl (edecl), NULL_TREE, NULL_TREE, 0);
-
-  /* Now instantiate the exception decl.  */
-  t = xref_tag (exception_type_node, DECL_NAME (decl), NULL_TREE);
-
-  /* finish_struct will pop this.  */
-  pushclass (t, 0);
-
-  /* Now add a constructor which takes as parameters all the types we
-     just defined.  */
-  ctor = build_lang_decl (FUNCTION_DECL, DECL_NAME (decl),
-			  build_cplus_method_type (t, TYPE_POINTER_TO (t),
-						   last_exception_field_types));
-  /* Don't take `name'.  The constructor handles that.  */
-  fields = TREE_CHAIN (TREE_VALUE (list_of_fieldlists));
-  while (fields)
-    {
-      tree parm = build_decl (PARM_DECL, DECL_NAME (fields), TREE_TYPE (fields));
-      /* Since there is a prototype, args are passed in their own types.  */
-      DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
-#ifdef PROMOTE_PROTOTYPES
-      if (TREE_CODE (TREE_TYPE (fields)) == INTEGER_TYPE
-	  && TYPE_PRECISION (TREE_TYPE (fields)) < TYPE_PRECISION (integer_type_node))
-	DECL_ARG_TYPE (parm) = integer_type_node;
-#endif
-      TREE_CHAIN (parm) = parmdecls;
-      parmdecls = parm;
-      fields = TREE_CHAIN (fields);
-    }
-  fields = TREE_VALUE (list_of_fieldlists);
-  last_function_parms = nreverse (parmdecls);
-
-  DECL_CONSTRUCTOR_P (ctor) = 1;
-  TYPE_HAS_CONSTRUCTOR (t) = 1;
-  grokclassfn (t, DECL_NAME (decl), ctor, NO_SPECIAL, NULL_TREE);
-  DECL_EXTERNAL (ctor) = 1;
-  TREE_STATIC (ctor) = 1;
-  TREE_PUBLIC (ctor) = 0;
-  DECL_INLINE (ctor) = 1;
-  make_decl_rtl (ctor, NULL_PTR, 1);
-  finish_decl (ctor, NULL_TREE, NULL_TREE, 0);
-  TREE_CHAIN (ctor) = TREE_VALUE (list_of_fieldlists);
-  TREE_VALUE (list_of_fieldlists) = ctor;
-
-  finish_struct (t, list_of_fieldlists, 0);
-
-  if (current_function_decl)
-    error ("cannot define exception inside function scope");
-  else
-    {
-      enum debug_info_type old_write_symbols = write_symbols;
-      write_symbols = NO_DEBUG;
-
-      /* Now build the constructor for this exception.  */
-      parmdecls = DECL_ARGUMENTS (ctor);
-      start_function (NULL_TREE, ctor, 0, 1);
-      store_parm_decls ();
-      pushlevel (0);
-      clear_last_expr ();
-      push_momentary ();
-      expand_start_bindings (0);
-
-      /* Move all the parameters to the fields, skipping `this'.  */
-      parmdecls = TREE_CHAIN (parmdecls);
-      /* Install `name' of this exception handler.  */
-      DECL_INITIAL (fields) = build_unary_op (ADDR_EXPR, edecl, 0);
-      fields = TREE_CHAIN (fields);
-      /* Install all the values.  */
-      while (fields)
-	{
-	  /* Set up the initialization for this field.  */
-	  DECL_INITIAL (fields) = parmdecls;
-	  fields = TREE_CHAIN (fields);
-	  parmdecls = TREE_CHAIN (parmdecls);
-	}
-      emit_base_init (t, 0);
-
-      finish_function (DECL_SOURCE_LINE (ctor), 1);
-      write_symbols = old_write_symbols;
-    }
-}
-
-void
-end_exception_decls ()
-{
-  last_exception_field_types = NULL_TREE;
-  last_exception_fields = NULL_TREE;
-}
-
-/* Statement-level exception semantics.  */
-
-void
-cplus_expand_start_try (implicit)
-     int implicit;
-{
-  tree call_to_setjmp;
-  tree handler, ref;
-
-  /* Start a new block enclosing the whole handler.  */
-  if (implicit)
-    {
-      pushlevel_temporary (1);
-    }
-  else
-    {
-      pushlevel (0);
-      clear_last_expr ();
-      push_momentary ();
-
-      /* Encompass whole exception handler in one big binding contour.
-	 If RAISE should throw out of the whole TRY/EXCEPT block, call
-	 `expand_start_bindings' with argument of 1.  */
-      expand_start_bindings (0);
-    }
-
-  /* Allocate handler in that block.  It's real name will come later.
-     Note that it will be the first name in this binding contour.  */
-  handler = get_temp_name (EHS_type, 0);
-  DECL_INITIAL (handler) = error_mark_node;
-  finish_decl (handler, NULL_TREE, NULL_TREE, 0);
-
-  /* Must come after call to `finish_decl', else the cleanup for the temp
-     for the handler will cause the contour we just created to be popped.  */
-  if (implicit)
-    declare_implicit_exception ();
-
-  /* Catch via `setjmp'.  */
-  ref = build_component_ref (handler, get_identifier ("handler"), NULL_TREE, 0);
-  call_to_setjmp = build_function_call (BISJ, build_tree_list (NULL_TREE, ref));
-
-  /* RAISE throws to EXCEPT part.  */
-  expand_start_try (build_binary_op (EQ_EXPR, call_to_setjmp, integer_zero_node, 1), 0, 1);
-}
-
-/* If KEEP is 1, then declarations in the TRY statement are worth keeping.
-   If KEEP is 2, then the TRY statement was generated by the compiler.
-   If KEEP is 0, the declarations in the TRY statement contain errors.  */
-
-tree
-cplus_expand_end_try (keep)
-     int keep;
-{
-  tree decls, decl, block;
-
-  if (keep < 2)
-    pop_implicit_try_blocks (NULL_TREE);
-
-  decls = getdecls ();
-
-  /* Emit code to avoid falling through into a default
-     handler that might come later.  */
-  expand_end_try ();
-
-  /* Pops binding contour local to TRY, and get the exception handler
-     object built by `...start_try'.  */
-  switch (keep)
-    {
-    case 0:
-      expand_end_bindings (decls, 0, 1);
-      block = poplevel (0, 0, 0);
-      pop_momentary (); 
-      decl = getdecls ();
-      break;
-
-    case 1:
-      expand_end_bindings (decls, 1, 1);
-      block = poplevel (1, 1, 0);
-      pop_momentary ();
-      decl = getdecls ();
-      break;
-
-    default:
-      decl = tree_last (decls);
-      block = NULL_TREE;
-      break;
-    }
-
-  my_friendly_assert (TREE_CODE (decl) == VAR_DECL
-		      && TREE_TYPE (decl) == EHS_type, 203);
-  if (block)
-    {
-      BLOCK_HANDLER_BLOCK (block) = 1;
-      TREE_USED (block) = 1;
-    }
-
-  /* Pass it back so that its rtl can be bound to its name
-     (or vice versa).  */
-  return decl;
-}
-
-void
-cplus_expand_start_except (name, decl)
-     tree name, decl;
-{
-  int yes;
-  tree tmp, init;
-
-  expand_start_except (0, 1);
-
-  /* This is internal `eh'.  */
-  current_exception_decl = decl;
-  current_exception_name_as_rtx
-    = expand_expr (build (COMPONENT_REF, ptr_type_node,
-			  current_exception_decl, TREE_OPERAND (EHS_name, 1)),
-		   0, 0, 0);
-  init = build (COMPONENT_REF, ptr_type_node, decl, TREE_OPERAND (EHS_parms, 1));
-  current_exception_parms_as_rtx = expand_expr (init, 0, 0, 0);
-
-  if (name)
-    {
-      /* Get the exception object into scope (user declared `ex').  */
-      tmp = pushdecl (build_decl (VAR_DECL, name, ptr_type_node));
-      DECL_INITIAL (tmp) = error_mark_node;
-      finish_decl (tmp, init, 0, 0);
-    }
-  current_exception_type = NULL_TREE;
-  yes = suspend_momentary ();
-  if (name)
-    {
-      /* From now on, send the user to our faked-up object.  */
-      current_exception_object = build1 (INDIRECT_REF, void_type_node, tmp);
-      IDENTIFIER_LOCAL_VALUE (name) = current_exception_object;
-    }
-  resume_momentary (yes);
-
-  /* Pop exception handler stack.  */
-  expand_assignment (EHS_decl, EHS_prev, 0, 0);
-}
-
-/* Generate the call to `unhandled_exception' that is appropriate
-   for this particular unhandled exception.  */
-static tree
-call_to_unhandled_exception ()
-{
-  extern int lineno;
-  extern tree combine_strings ();
-  tree parms = tree_cons (NULL_TREE,
-			  combine_strings (build_string (strlen (input_filename + 1), input_filename)),
-			  build_tree_list (NULL_TREE, build_int_2 (lineno, 0)));
-  return build_function_call (BIUE, parms);
-}
-
-/* Note that this must be mirror image of `...start_try'.
-   DFAULT is the default clause, if there was one.
-   DFAULT is ERROR_MARK_NODE when this ends an implicit handler.  */
-void
-cplus_expand_end_except (dfault)
-     tree dfault;
-{
-  extern tree expand_end_except (); /* stmt.c.  */
-  tree decls, raised;
-
-  if (dfault == NULL_TREE)
-    {
-      /* Uncaught exception at outermost level.  If raised locally,
-	 reraise the exception.  Otherwise, generate code to call `abort'.  */
-      if (in_try_block (1) == 0)
-	{
-	  expand_start_cond (build (EQ_EXPR, integer_type_node,
-				    exception_throw_decl, integer_zero_node), 0);
-	  expand_expr (call_to_unhandled_exception (), 0, VOIDmode, 0);
-	  expand_end_cond ();
-	}
-      /* Try the next handler.  */
-      if (! expand_escape_except ())
-	compiler_error ("except nesting botch");
-    }
-
-  raised = expand_end_except ();
-
-  decls = getdecls ();
-  expand_end_bindings (decls, decls != 0, 1);
-  poplevel (decls != 0, 1, 0);
-
-  /* Implicit handlers do not use the momentary obstack.  */
-  if (dfault != error_mark_node)
-    pop_momentary ();
-
-  if (! in_try_block (1))
-    {
-      /* Check that this function is not raising exceptions
-	 it is not supposed to.  */
-      while (raised)
-	{
-	  error_with_decl (TREE_VALUE (raised), "exception `%s' raised but not declared raisable");
-	  raised = TREE_CHAIN (raised);
-	}
-    }
-  else if (dfault == NULL_TREE || dfault == error_mark_node)
-    {
-      expand_start_cond (build (NE_EXPR, integer_type_node,
-				exception_throw_decl,
-				integer_zero_node), 0);
-      /* We fell off the end of this try block.  Try going to the next.
-	 The escape_label will be the beginning of the next try block.  */
-      if (! expand_escape_except ())
-	compiler_error ("except nesting botch");
-      expand_end_cond ();
-    }
-}
-
-/* Generate code to raise exception RAISE_ID.
-   If EXP is NULL_TREE, then PARMS is the list of parameters to use
-   for constructing this exception.
-   If EXP is non-NULL, then it is an already constructed object
-   of the kind that we want.
-
-   FOR_RERAISE is non-zero if this raise is called by reraise.  In
-   this case we do not need to emit extra gotos to avoid warning messages;
-   the caller will do that once after all the exceptions it reraises
-   are handled and raised.  */
-void
-cplus_expand_raise (raise_id, parms, exp, for_reraise)
-     tree raise_id;
-     tree parms;
-     tree exp;
-     int for_reraise;
-{
-  /* Allocate new exception of appropriate type, passing
-     PARMS to its constructor.  */
-  tree cname, name;
-  tree decl;
-  tree xexp = exp;
-
-  cname = lookup_exception_cname (current_class_type, current_class_name, raise_id);
-  if (cname == error_mark_node)
-    return;
-  name = TREE_VALUE (raise_id);
-
-  decl = lookup_exception_object (cname, name, 1);
-  if (decl == NULL_TREE)
-    return;
-
-  if (exp == NULL_TREE)
-    {
-      exp = build_method_call (NULL_TREE, name, parms, NULL_TREE, LOOKUP_COMPLAIN);
-      if (exp == error_mark_node)
-	return;
-    }
-
-  if (in_try_block (1))
-    {
-      expand_raise (decl);
-    }
-  else if (! current_function_decl)
-    {
-      if (xexp == NULL_TREE)
-	error_with_decl (decl, "invalid raise of `%s' outside of functions");
-      else
-	error_with_decl (decl, "invalid reraise of `%s' outside of functions");
-    }
-  else
-    {
-      /* Test this raise against what this function permits.  */
-      tree names = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl));
-      while (names)
-	{
-	  if (decl == TREE_TYPE (names))
-	    break;
-	  names = TREE_CHAIN (names);
-	}
-      if (names == NULL_TREE)
-	{
-	  error ("current function not declared to raise exception `%s'",
-		 IDENTIFIER_POINTER (name));
-	  return;
-	}
-    }
-
-  store_expr (exp, EHS_parms_as_rtx, 0);
-
-  /* Set the global exception handler stack's NAME field
-     to the `name' of this exception.  The global exception
-     handler stack is the container for the exception object
-     we just built.
-
-     We go through a function call to make life easier when debugging.  */
-#if 0
-  expand_assignment (EHS_name, build_unary_op (ADDR_EXPR, decl, 0), 0, 0);
-#else
-  parms = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, EHS_name, 0),
-		     build_tree_list (NULL_TREE,
-				      build_unary_op (ADDR_EXPR, decl, 0)));
-  expand_expr (build_function_call (BIR, parms), 0, 0, 0);
-#endif
-
-  /* Activate thrower.  If we are inside a TRY statement,
-     we can cheat and not do this, saving a longjmp.  */
-  if (in_try_block (1) == 0)
-    {
-      sets_exception_throw_decl = 1;
-      emit_move_insn (DECL_RTL (exception_throw_decl), const1_rtx);
-    }
-
-  if (xexp == NULL_TREE)
-    {    
-      /* Invoke destructors for current procedure or handler.  */
-      if (! expand_escape_except ())
-	compiler_error ("except nesting botch");
-      /* Throw via `longjmp'... Done as side-effect of goto.  */
-    }
-  /* To avoid spurious warning messages, we add a goto to the end
-     of the function.  This code is dead, and the compiler should
-     know how to delete it, but for now, we are stuck with it.  */
-  if (! for_reraise
-      && TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
-    expand_null_return ();
-}
-
-extern tree cplus_exception_name ();
-
-tree
-ansi_exception_object_lookup (type)
-     tree type;
-{
-  tree raise_id = cplus_exception_name (type);
-  tree decl;
-
-  decl = IDENTIFIER_GLOBAL_VALUE (raise_id);
-  if (decl == NULL_TREE || TREE_CODE (decl) != VAR_DECL)
-    {
-      push_obstacks_nochange ();
-      end_temporary_allocation ();
-      decl = build_decl (VAR_DECL, raise_id, ptr_type_node);
-      TREE_PUBLIC (decl) = 1;
-      TREE_STATIC (decl) = 1;
-      pushdecl_top_level (decl);
-      make_decl_rtl (decl, (char*)0, 1);
-      pop_obstacks ();
-    }
-  return decl;
-}
-
-/* Generate code to throw an exception using EXP.
-   Usng ANSI syntax and semantics.
-   If EXP is NULL_TREE< re-raise instead. */
-
-void
-cplus_expand_throw (exp)
-     tree exp;
-{
-  tree parms;
-  int for_reraise;
-  /* Allocate new exception of appropriate type, passing
-     PARMS to its constructor.  */
-  tree decl = ansi_exception_object_lookup (TREE_TYPE (exp));
-  tree xexp = exp;
-
-  if (in_try_block (1))
-    {
-#if 1
-      my_friendly_abort (35);
-#else
-      expand_raise (decl);
-#endif
-    }
-  else if (! current_function_decl)
-    error ("invalid throw outside of functions");
-  else
-    {
-#if 0
-      /* Test this raise against what this function permits.  */
-      tree names = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl));
-      while (names)
-	{
-	  if (decl == TREE_TYPE (names))
-	    break;
-	  names = TREE_CHAIN (names);
-	}
-      if (names == NULL_TREE)
-	{
-	  error ("current function not declared to raise exception `%s'",
-		 IDENTIFIER_POINTER (name));
-	  return;
-	}
-#endif
-    }
-
-  store_expr (exp, EHS_parms_as_rtx, 0);
-
-  /* Set the global exception handler stack's NAME field
-     to the `name' of this exception.  The global exception
-     handler stack is the container for the exception object
-     we just built.
-
-     We go through a function call to make life easier when debugging.  */
-#if 0
-  expand_assignment (EHS_name, build_unary_op (ADDR_EXPR, decl, 0), 0, 0);
-#else
-  parms = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, EHS_name, 0),
-		     build_tree_list (NULL_TREE,
-				      build_unary_op (ADDR_EXPR, decl, 0)));
-  expand_expr (build_function_call (BIR, parms), 0, 0, 0);
-#endif
-
-  /* Activate thrower.  If we are inside a TRY statement,
-     we can cheat and not do this, saving a longjmp.  */
-  if (in_try_block (1) == 0)
-    {
-      sets_exception_throw_decl = 1;
-      emit_move_insn (DECL_RTL (exception_throw_decl), const1_rtx);
-    }
-
-  if (xexp == NULL_TREE)
-    {    
-      /* Invoke destructors for current procedure or handler.  */
-      if (! expand_escape_except ())
-	compiler_error ("except nesting botch");
-      /* Throw via `longjmp'... Done as side-effect of goto.  */
-    }
-
-  /* XXX: for_reraise is never set above here.  */
-  /* To avoid spurious warning messages, we add a goto to the end
-     of the function.  This code is dead, and the compiler should
-     know how to delete it, but for now, we are stuck with it.  */
-  if (! for_reraise
-      && TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
-    expand_null_return ();
-}
-
-tree
-cplus_expand_start_catch (raise_id)
-     tree raise_id;
-{
-  tree cname = lookup_exception_cname (current_class_type, current_class_name, raise_id);
-  tree decl;
-  tree cond;
-
-  if (cname == error_mark_node)
-    {
-      decl = error_mark_node;
-      cond = error_mark_node;
-    }
-  else
-    {
-      decl = lookup_exception_object (cname, TREE_VALUE (raise_id), 1);
-      if (decl == NULL_TREE)
-	cond = error_mark_node;
-      else
-	cond = build_binary_op (EQ_EXPR, build_unary_op (ADDR_EXPR, decl, 0),
-				build (COMPONENT_REF, ptr_type_node,
-				       current_exception_decl,
-				       TREE_OPERAND (EHS_name, 1)),
-				1);
-    }
-  expand_start_cond (cond, 0);
-
-  /* Does nothing right now.  */
-  expand_catch (decl);
-  if (current_exception_type
-      && TYPE_NEEDS_DESTRUCTOR (current_exception_type))
-    {
-      /* Make a cleanup for the name-specific exception object now in scope.  */
-      tree cleanup = maybe_build_cleanup (current_exception_object);
-      expand_start_bindings (0);
-      expand_decl_cleanup (NULL_TREE, cleanup);
-    }
-  return decl;
-}
-tree
-ansi_expand_start_catch (raise_type)
-     tree raise_type;
-{
-  tree decl = ansi_exception_object_lookup (raise_type);
-  tree cond;
-
-  if (decl == NULL_TREE)
-      cond = error_mark_node;
-  else
-      cond = build_binary_op (EQ_EXPR, build_unary_op (ADDR_EXPR, decl, 0),
-			      build (COMPONENT_REF, ptr_type_node,
-				     current_exception_decl,
-				     TREE_OPERAND (EHS_name, 1)),
-			      1);
-  expand_start_cond (cond, 0);
-
-  /* Does nothing right now.  */
-  expand_catch (decl);
-  return decl;
-}
-
-void
-cplus_expand_end_catch (for_reraise)
-     int for_reraise;
-{
-  if (current_exception_type
-      && TYPE_NEEDS_DESTRUCTOR (current_exception_type))
-    {
-      /* Destroy the specific exception object now in scope.  */
-      expand_end_bindings (getdecls (), 0, 1);
-    }
-  if (for_reraise)
-    {
-      if (! expand_escape_except ())
-	my_friendly_abort (36);
-    }
-  else
-    {
-      if (! expand_end_catch ())
-	my_friendly_abort (37);
-    }
-  expand_end_cond ();
-}
-
-/* Reraise an exception.
-   If EXCEPTIONS is NULL_TREE, it means reraise whatever exception was caught.
-   If EXCEPTIONS is an IDENTIFIER_NODE, it means reraise the exception
-   object named by EXCEPTIONS.  This must be a variable declared in
-   an `except' clause.
-   If EXCEPTIONS is a TREE_LIST, it is the list of exceptions we are
-   willing to reraise.  */
-
-void
-cplus_expand_reraise (exceptions)
-     tree exceptions;
-{
-  tree ex_ptr;
-  tree ex_object = current_exception_object;
-  rtx ex_ptr_as_rtx;
-
-  if (exceptions && TREE_CODE (exceptions) == IDENTIFIER_NODE)
-    {
-      /* Don't get tripped up if its TREE_TYPE is `error_mark_node'.  */
-      ex_object = IDENTIFIER_LOCAL_VALUE (exceptions);
-      if (ex_object == NULL_TREE || TREE_CODE (ex_object) != INDIRECT_REF)
-	{
-	  error ("`%s' is not an exception decl", IDENTIFIER_POINTER (exceptions));
-	  return;
-	}
-      my_friendly_assert (TREE_CODE (TREE_OPERAND (ex_object, 0)) == VAR_DECL,
-			  204);
-      exceptions = NULL_TREE;
-    }
-
-  ex_ptr = build1 (NOP_EXPR, ptr_type_node, TREE_OPERAND (ex_object, 0));
-  ex_ptr_as_rtx = expand_expr (ex_ptr, 0, 0, 0);
-
-  /* reraise ALL, used by compiler.  */
-  if (exceptions == NULL_TREE)
-    {
-      /* Now treat reraise like catch/raise.  */
-      expand_catch (error_mark_node);
-      expand_raise (error_mark_node);
-      emit_move_insn (EHS_name_as_rtx, current_exception_name_as_rtx);
-      store_expr ((tree) EHS_parms_as_rtx, current_exception_parms_as_rtx, 0);
-      if (in_try_block (1) == 0)
-	{
-	  sets_exception_throw_decl = 1;
-	  emit_move_insn (DECL_RTL (exception_throw_decl), const1_rtx);
-	}
-      /* Set to zero so that destructor will not be called.  */
-      emit_move_insn (ex_ptr_as_rtx, const0_rtx);
-      if (! expand_escape_except ())
-	my_friendly_abort (38);
-
-      /* To avoid spurious warning messages, we add a goto to the end
-	 of the function.  This code is dead, and the compiler should
-	 know how to delete it, but for now, we are stuck with it.  */
-      if (TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
-	expand_null_return ();
-
-      return;
-    }
-
-  /* reraise from a list of exceptions.  */
-  while (exceptions)
-    {
-      tree type = lookup_exception_type (current_class_type, current_class_name,
-					 exceptions);
-      if (type == NULL_TREE)
-	{
-	  error ("`%s' is not an exception type",
-		 IDENTIFIER_POINTER (TREE_VALUE (exceptions)));
-	  current_exception_type = NULL_TREE;
-	  TREE_TYPE (ex_object) = error_mark_node;
-	  TREE_TYPE (ex_ptr) = error_mark_node;
-	}
-      else
-	{
-	  current_exception_type = type;
-	  /* In-place union.  */
-	  TREE_TYPE (ex_object) = type;
-	  TREE_TYPE (ex_ptr) = TYPE_POINTER_TO (type);
-	}
-
-      /* Now treat reraise like catch/raise.  */
-      cplus_expand_start_catch (exceptions);
-      cplus_expand_raise (exceptions, NULL_TREE, ex_ptr, 1);
-      /* Set to zero so that destructor will not be called.  */
-      if (TREE_TYPE (ex_ptr) != error_mark_node)
-	emit_move_insn (ex_ptr_as_rtx, const0_rtx);
-      cplus_expand_end_catch (1);
-      exceptions = TREE_CHAIN (exceptions);
-    }
-  /* Don't propagate any unhandled exceptions.  */
-  expand_expr (call_to_unhandled_exception (), 0, VOIDmode, 0);
-
-  /* To avoid spurious warning messages, we add a goto to the end
-     of the function.  This code is dead, and the compiler should
-     know how to delete it, but for now, we are stuck with it.  */
-  if (TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
-    expand_null_return ();
-}
-
-void
-setup_exception_throw_decl ()
-{
-  tree call_to_longjmp, parms;
-
-  int old = suspend_momentary ();
-
-  exception_throw_decl = build_decl (VAR_DECL, get_identifier (THROW_NAME), integer_type_node);
-  pushdecl (exception_throw_decl);
-  parms = tree_cons (NULL_TREE, EHS_handler,
-		     build_tree_list (0, integer_one_node));
-  call_to_longjmp = build_function_call (BILJ, parms);
-
-  expand_decl (exception_throw_decl);
-  expand_decl_cleanup (exception_throw_decl,
-		       build (COND_EXPR, void_type_node,
-			      exception_throw_decl,
-			      call_to_longjmp, integer_zero_node));
-  DECL_INITIAL (exception_throw_decl) = integer_zero_node;
-  sets_exception_throw_decl = 0;
-  resume_momentary (old);
-
-  /* Cache these, since they won't change throughout the function.  */
-  EHS_parms_as_rtx = expand_expr (EHS_parms, 0, 0, 0);
-  EHS_name_as_rtx = expand_expr (EHS_name, 0, 0, 0);
-}
-
-void
-init_exception_processing ()
-{
-  extern tree build_function_type (), define_function ();
-  extern tree unhandled_exception_fndecl;
-  tree cname = get_identifier ("ExceptionHandler");
-  tree field, chain;
-  tree ctor, dtor;
-  tree jmp_buf_type = build_array_type (integer_type_node,
-					build_index_type (build_int_2 (_JBLEN-1, 0)));
-  tree jmp_buf_arg_type = build_pointer_type (integer_type_node);
-
-  tree parmtypes = hash_tree_chain (jmp_buf_arg_type, void_list_node);
-  tree setjmp_fndecl, longjmp_fndecl, raise_fndecl;
-
-  int old_interface_only = interface_only;
-  int old_interface_unknown = interface_unknown;
-  interface_only = 1;
-  interface_unknown = 0;
-  EHS_type = xref_tag (record_type_node, cname, NULL_TREE);
-  push_lang_context (lang_name_c);
-  setjmp_fndecl = define_function ("setjmp",
-				   build_function_type (integer_type_node,
-							parmtypes),
-				   NOT_BUILT_IN, pushdecl, 0);
-  BISJ = default_conversion (setjmp_fndecl);
-  parmtypes = hash_tree_chain (jmp_buf_arg_type,
-			       hash_tree_chain (integer_type_node, void_list_node));
-  longjmp_fndecl = define_function ("longjmp",
-				    build_function_type (void_type_node, parmtypes),
-				    NOT_BUILT_IN, pushdecl, 0);
-  raise_fndecl = define_function ("__raise_exception",
-				  build_function_type (void_type_node,
-						       hash_tree_chain (ptr_type_node,
-									hash_tree_chain (build_pointer_type (ptr_type_node), void_list_node))),
-				  NOT_BUILT_IN, pushdecl, 0);
-  BILJ = default_conversion (longjmp_fndecl);
-  BIR = default_conversion (raise_fndecl);
-  BIUE = default_conversion (unhandled_exception_fndecl);
-
-  pop_lang_context ();
-
-  /* finish_struct will pop this.  */
-  pushclass (EHS_type, 0);
-  field = build_lang_field_decl (FIELD_DECL, get_identifier ("parms"), ptr_type_node);
-  chain = field;
-  field = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
-				 build_pointer_type (default_function_type));
-  TREE_CHAIN (field) = chain;
-  chain = field;
-  field = build_lang_field_decl (FIELD_DECL, get_identifier ("handler"), jmp_buf_type);
-  TREE_CHAIN (field) = chain;
-  chain = field;
-  field = build_lang_field_decl (FIELD_DECL, get_identifier ("prev"),
-				 TYPE_POINTER_TO (EHS_type));
-  TREE_CHAIN (field) = chain;
-  chain = field;
-
-  ctor = build_lang_decl (FUNCTION_DECL, cname,
-			  build_cplus_method_type (EHS_type, TYPE_POINTER_TO (EHS_type), void_list_node));
-  DECL_CONSTRUCTOR_P (ctor) = 1;
-  TREE_STATIC (ctor) = 1;
-  TREE_PUBLIC (ctor) = 1;
-  DECL_EXTERNAL (ctor) = 1;
-  grokclassfn (EHS_type, cname, ctor, NO_SPECIAL, 0);
-  grok_ctor_properties (EHS_type, ctor);
-  finish_decl (pushdecl (ctor), NULL_TREE, NULL_TREE, 0);
-  /* Must copy the node here because the FUNCTION_DECL
-     used inside the struct ain't the same as the
-     FUNCTION_DECL we stick into the global binding
-     contour.  */
-  ctor = copy_node (ctor);
-  TREE_CHAIN (ctor) = chain;
-  chain = ctor;
-  dtor = build_lang_decl (FUNCTION_DECL, cname,
-			  build_cplus_method_type (EHS_type, TYPE_POINTER_TO (EHS_type), void_list_node));
-  TREE_STATIC (dtor) = 1;
-  TREE_PUBLIC (dtor) = 1;
-  DECL_EXTERNAL (dtor) = 1;
-  grokclassfn (EHS_type, cname, dtor, DTOR_FLAG, 0);
-  finish_decl (pushdecl (dtor), NULL_TREE, NULL_TREE, 0);
-  /* Copy for the same reason as copying ctor.  */
-  dtor = copy_node (dtor);
-  TREE_CHAIN (dtor) = chain;
-  chain = dtor;
-  TYPE_HAS_CONSTRUCTOR (EHS_type) = 1;
-  TYPE_HAS_DESTRUCTOR (EHS_type) = 1;
-  finish_struct (EHS_type, temp_tree_cons (NULL_TREE, chain, NULL_TREE), 0);
-  interface_only = old_interface_only;
-  interface_unknown = old_interface_unknown;
-}
-
-void
-init_exception_processing_1 ()
-{
-  register tree EHS_id = get_identifier ("exceptionHandlerStack");
-
-  EHS_decl = IDENTIFIER_GLOBAL_VALUE (EHS_id);
-
-  /* If we have no other definition, default to library implementation.  */
-  if (EHS_decl == NULL_TREE)
-    {
-      EHS_decl = build_decl (VAR_DECL, EHS_id, TYPE_POINTER_TO (EHS_type));
-      /* If we don't push this, its definition, should it be encountered,
-	 will not be seen.  */
-      EHS_decl = pushdecl (EHS_decl);
-      DECL_EXTERNAL (EHS_decl) = 1;
-      TREE_STATIC (EHS_decl) = 1;
-      TREE_PUBLIC (EHS_decl) = 1;
-      finish_decl (EHS_decl, NULL_TREE, NULL_TREE, 0);
-    }
-  else if (TREE_CODE (EHS_decl) != VAR_DECL
-	   || TREE_TYPE (EHS_decl) != TYPE_POINTER_TO (EHS_type))
-    fatal ("exception handling declarations conflict with compiler's internal model");
-
-  if (EHS_prev == NULL_TREE)
-    {
-      register tree EHS_DECL = build1 (INDIRECT_REF, EHS_type, EHS_decl);
-      EHS_prev = build_component_ref (EHS_DECL, get_identifier ("prev"), 0, 0);
-      EHS_handler = build_component_ref (EHS_DECL, get_identifier ("handler"), 0, 0);
-      EHS_parms = build_component_ref (EHS_DECL, get_identifier ("parms"), 0, 0);
-      EHS_name = build_component_ref (EHS_DECL, get_identifier ("name"), 0, 0);
-    }
-}
diff --git a/gnu/gcc2/cc1plus/cp-expr.c b/gnu/gcc2/cc1plus/cp-expr.c
deleted file mode 100644
index 77c0ab5e1623..000000000000
--- a/gnu/gcc2/cc1plus/cp-expr.c
+++ /dev/null
@@ -1,222 +0,0 @@
-/* Convert language-specific tree expression to rtl instructions,
-   for GNU compiler.
-   Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
-
-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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-#include "config.h"
-#include "rtl.h"
-#include "tree.h"
-#include "flags.h"
-#include "expr.h"
-#include "cp-tree.h"
-
-#undef NULL
-#define NULL 0
-
-/* Hook used by expand_expr to expand language-specific tree codes.  */
-
-rtx
-cplus_expand_expr (exp, target, tmode, modifier)
-     tree exp;
-     rtx target;
-     enum machine_mode tmode;
-     enum expand_modifier modifier;
-{
-  tree type = TREE_TYPE (exp);
-  register enum machine_mode mode = TYPE_MODE (type);
-  register enum tree_code code = TREE_CODE (exp);
-  rtx original_target = target;
-  int ignore = target == const0_rtx;
-
-  if (ignore) target = 0, original_target = 0;
-
-  /* No sense saving up arithmetic to be done
-     if it's all in the wrong mode to form part of an address.
-     And force_operand won't know whether to sign-extend or zero-extend.  */
-
-  if (mode != Pmode && modifier == EXPAND_SUM)
-    modifier = EXPAND_NORMAL;
-
-  switch (code)
-    {
-    case NEW_EXPR:
-      {
-	/* Something needs to be initialized, but we didn't know
-	   where that thing was when building the tree.  For example,
-	   it could be the return value of a function, or a parameter
-	   to a function which lays down in the stack, or a temporary
-	   variable which must be passed by reference.
-
-	   Cleanups are handled in a language-specific way: they
-	   might be run by the called function (true in GNU C++
-	   for parameters with cleanups), or they might be
-	   run by the caller, after the call (true in GNU C++
-	   for other cleanup needs).  */
-
-	tree func = TREE_OPERAND (exp, 0);
-	tree args = TREE_OPERAND (exp, 1);
-	tree type = TREE_TYPE (exp), slot;
-	tree fn_type = TREE_TYPE (TREE_TYPE (func));
-	tree return_type = TREE_TYPE (fn_type);
-	rtx call_target, return_target;
-
-	/* The expression `init' wants to initialize what
-	   `target' represents.  SLOT holds the slot for TARGET.  */
-	slot = TREE_OPERAND (exp, 2);
-
-	if (target == 0)
-	  {
-	    /* Should always be called with a target in BLKmode case.  */
-	    my_friendly_assert (mode != BLKmode, 205);
-	    my_friendly_assert (DECL_RTL (slot) != 0, 206);
-
-	    target = gen_reg_rtx (mode);
-	  }
-
-	/* The target the initializer will initialize (CALL_TARGET)
-	   must now be directed to initialize the target we are
-	   supposed to initialize (TARGET).  The semantics for
-	   choosing what CALL_TARGET is is language-specific,
-	   as is building the call which will perform the
-	   initialization.  It is left here to show the choices that
-	   exist for C++.  */
-	   
-	if (TREE_CODE (func) == ADDR_EXPR
-	    && TREE_CODE (TREE_OPERAND (func, 0)) == FUNCTION_DECL
-	    && DECL_CONSTRUCTOR_P (TREE_OPERAND (func, 0)))
-	  {
-	    type = TYPE_POINTER_TO (type);
-	    /* Don't clobber a value that might be part of a default
-	       parameter value.  */
-	    if (TREE_PERMANENT (args))
-	      args = tree_cons (0, build1 (ADDR_EXPR, type, slot),
-				TREE_CHAIN (args));
-	    else
-	      TREE_VALUE (args) = build1 (ADDR_EXPR, type, slot);
-	    call_target = 0;
-	  }
-	else if (TREE_CODE (return_type) == REFERENCE_TYPE)
-	  {
-	    type = return_type;
-	    call_target = 0;
-	  }
-	else
-	  {
-	    call_target = target;
-	  }
-	if (call_target)
-	  preserve_temp_slots (call_target);
-	preserve_temp_slots (DECL_RTL (slot));
-	return_target = expand_expr (build (CALL_EXPR, type, func, args, 0), call_target, mode, 0);
-	free_temp_slots ();
-	if (call_target == 0)
-	  call_target = return_target;
-	else if (call_target != return_target)
-	  {
-	    if (GET_MODE (return_target) == BLKmode)
-	      emit_block_move (call_target, return_target, expr_size (exp),
-			       TYPE_ALIGN (type) / BITS_PER_UNIT);
-	    else
-	      emit_move_insn (call_target, return_target);
-	  }
-
-	if (TREE_CODE (return_type) == REFERENCE_TYPE)
-	  {
-	    tree init;
-
-	    if (GET_CODE (call_target) == REG
-		&& REGNO (call_target) < FIRST_PSEUDO_REGISTER)
-	      my_friendly_abort (39);
-
-	    type = TREE_TYPE (exp);
-
-	    init = build (RTL_EXPR, return_type, 0, call_target);
-	    /* We got back a reference to the type we want.  Now initialize
-	       target with that.  */
-	    expand_aggr_init (slot, init, 0);
-	  }
-
-	if (DECL_RTL (slot) != target)
-	  emit_move_insn (DECL_RTL (slot), target);
-	return DECL_RTL (slot);
-      }
-
-    case OFFSET_REF:
-      {
-	tree base = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 0), 0);
-	tree offset = build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 1), 0);
-	return expand_expr (build (PLUS_EXPR, TREE_TYPE (exp), base, offset),
-			    target, tmode, EXPAND_NORMAL);
-      }
-
-    default:
-      break;
-    }
-  my_friendly_abort (40);
-  /* NOTREACHED */
-  return NULL;
-}
-
-void
-init_cplus_expand ()
-{
-  lang_expand_expr = cplus_expand_expr;
-}
-
-/* If DECL had its rtl moved from where callers expect it
-   to be, fix it up.  RESULT is the nominal rtl for the RESULT_DECL,
-   which may be a pseudo instead of a hard register.  */
-
-void
-fixup_result_decl (decl, result)
-     tree decl;
-     rtx result;
-{
-  if (REG_P (result))
-    {
-      if (REGNO (result) >= FIRST_PSEUDO_REGISTER)
-	{
-	  rtx real_decl_result;
-
-#ifdef FUNCTION_OUTGOING_VALUE
-	  real_decl_result
-	    = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl), current_function_decl);
-#else
-	  real_decl_result
-	    = FUNCTION_VALUE (TREE_TYPE (decl), current_function_decl);
-#endif
-	  REG_FUNCTION_VALUE_P (real_decl_result) = 1;
-	  result = real_decl_result;
-	}
-      emit_move_insn (result, DECL_RTL (decl));
-      emit_insn (gen_rtx (USE, VOIDmode, result));
-    }
-}
-
-/* Return nonzero iff DECL is memory-based.  The DECL_RTL of
-   certain const variables might be a CONST_INT, or a REG
-   in some cases.  We cannot use `memory_operand' as a test
-   here because on most RISC machines, a variable's address
-   is not, by itself, a legitimate address.  */
-int
-decl_in_memory_p (decl)
-     tree decl;
-{
-  return DECL_RTL (decl) != 0 && GET_CODE (DECL_RTL (decl)) == MEM;
-}
diff --git a/gnu/gcc2/cc1plus/cp-gc.c b/gnu/gcc2/cc1plus/cp-gc.c
deleted file mode 100644
index f62832458390..000000000000
--- a/gnu/gcc2/cc1plus/cp-gc.c
+++ /dev/null
@@ -1,793 +0,0 @@
-/* Garbage collection primitives for GNU C++.
-   Copyright (C) 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-#include "config.h"
-#include "tree.h"
-#include "cp-tree.h"
-#include "flags.h"
-
-#undef NULL
-#define NULL 0
-
-extern tree define_function ();
-extern tree build_t_desc_overload ();
-
-/* This is the function decl for the (pseudo-builtin) __gc_protect
-   function.  Args are (class *value, int index); Returns value.  */
-tree gc_protect_fndecl;
-
-/* This is the function decl for the (pseudo-builtin) __gc_unprotect
-   function.  Args are (int index); void return.  */
-tree gc_unprotect_fndecl;
-
-/* This is the function decl for the (pseudo-builtin) __gc_push
-   function.  Args are (int length); void return.  */
-tree gc_push_fndecl;
-
-/* This is the function decl for the (pseudo-builtin) __gc_pop
-   function.  Args are void; void return.  */
-tree gc_pop_fndecl;
-
-/* Special integers that are used to represent bits in gc-safe objects.  */
-tree gc_nonobject;
-tree gc_visible;
-tree gc_white;
-tree gc_offwhite;
-tree gc_grey;
-tree gc_black;
-
-/* in c-common.c */
-extern tree combine_strings PROTO((tree));
-
-/* Predicate that returns non-zero if TYPE needs some kind of
-   entry for the GC.  Returns zero otherwise.  */
-int
-type_needs_gc_entry (type)
-     tree type;
-{
-  tree ttype = type;
-
-  if (! flag_gc || type == error_mark_node)
-    return 0;
-
-  /* Aggregate types need gc entries if any of their members
-     need gc entries.  */
-  if (IS_AGGR_TYPE (type))
-    {
-      tree binfos;
-      tree fields = TYPE_FIELDS (type);
-      int i;
-
-      /* We don't care about certain pointers.  Pointers
-	 to virtual baseclasses are always up front.  We also
-	 cull out virtual function table pointers because it's
-	 easy, and it simplifies the logic.*/
-      while (fields
-	     && (DECL_NAME (fields) == NULL_TREE
-		 || VFIELD_NAME_P (DECL_NAME (fields))
-		 || VBASE_NAME_P (DECL_NAME (fields))
-		 || !strcmp (IDENTIFIER_POINTER (DECL_NAME (fields)), "__bits")))
-	fields = TREE_CHAIN (fields);
-
-      while (fields)
-	{
-	  if (type_needs_gc_entry (TREE_TYPE (fields)))
-	    return 1;
-	  fields = TREE_CHAIN (fields);
-	}
-
-      binfos = TYPE_BINFO_BASETYPES (type);
-      if (binfos)
-	for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
-	  if (type_needs_gc_entry (BINFO_TYPE (TREE_VEC_ELT (binfos, i))))
-	    return 1;
-
-      return 0;
-    }
-
-  while (TREE_CODE (ttype) == ARRAY_TYPE
-	 && TREE_CODE (TREE_TYPE (ttype)) == ARRAY_TYPE)
-    ttype = TREE_TYPE (ttype);
-  if ((TREE_CODE (ttype) == POINTER_TYPE
-       || TREE_CODE (ttype) == ARRAY_TYPE
-       || TREE_CODE (ttype) == REFERENCE_TYPE)
-      && IS_AGGR_TYPE (TREE_TYPE (ttype))
-      && CLASSTYPE_DOSSIER (TREE_TYPE (ttype)))
-    return 1;
-
-  return 0;
-}
-
-/* Predicate that returns non-zero iff FROM is safe from the GC.
-   
-   If TO is nonzero, it means we know that FROM is being stored
-   in TO, which make make it safe.  */
-int
-value_safe_from_gc (to, from)
-     tree to, from;
-{
-  /* First, return non-zero for easy cases: parameters,
-     static variables.  */
-  if (TREE_CODE (from) == PARM_DECL
-      || (TREE_CODE (from) == VAR_DECL
-	  && TREE_STATIC (from)))
-    return 1;
-
-  /* If something has its address taken, it cannot be
-     in the heap, so it doesn't need to be protected.  */
-  if (TREE_CODE (from) == ADDR_EXPR || TREE_REFERENCE_EXPR (from))
-    return 1;
-
-  /* If we are storing into a static variable, then what
-     we store will be safe from the gc.  */
-  if (to && TREE_CODE (to) == VAR_DECL
-      && TREE_STATIC (to))
-    return 1;
-
-  /* Now recurse on structure of FROM.  */
-  switch (TREE_CODE (from))
-    {
-    case COMPONENT_REF:
-      /* These guys are special, and safe.  */
-      if (TREE_CODE (TREE_OPERAND (from, 1)) == FIELD_DECL
-	  && (VFIELD_NAME_P (DECL_NAME (TREE_OPERAND (from, 1)))
-	      || VBASE_NAME_P (DECL_NAME (TREE_OPERAND (from, 1)))))
-	return 1;
-      /* fall through...  */
-    case NOP_EXPR:
-    case CONVERT_EXPR:
-    case NON_LVALUE_EXPR:
-    case WITH_CLEANUP_EXPR:
-    case SAVE_EXPR:
-    case PREDECREMENT_EXPR:
-    case PREINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-      if (value_safe_from_gc (to, TREE_OPERAND (from, 0)))
-	return 1;
-      break;
-
-    case VAR_DECL:
-    case PARM_DECL:
-      /* We can safely pass these things as parameters to functions.  */
-      if (to == 0)
-	return 1;
-
-    case ARRAY_REF:
-    case INDIRECT_REF:
-    case RESULT_DECL:
-    case OFFSET_REF:
-    case CALL_EXPR:
-    case METHOD_CALL_EXPR:
-      break;
-
-    case COMPOUND_EXPR:
-    case TARGET_EXPR:
-      if (value_safe_from_gc (to, TREE_OPERAND (from, 1)))
-	return 1;
-      break;
-
-    case COND_EXPR:
-      if (value_safe_from_gc (to, TREE_OPERAND (from, 1))
-	  && value_safe_from_gc (to, TREE_OPERAND (from, 2)))
-	return 1;
-      break;
-
-    case PLUS_EXPR:
-    case MINUS_EXPR:
-      if ((type_needs_gc_entry (TREE_TYPE (TREE_OPERAND (from, 0)))
-	   || value_safe_from_gc (to, TREE_OPERAND (from, 0)))
-	  && (type_needs_gc_entry (TREE_TYPE (TREE_OPERAND (from, 1))) == 0
-	      || value_safe_from_gc (to, TREE_OPERAND (from, 1))))
-	return 1;
-      break;
-
-    case RTL_EXPR:
-      /* Every time we build an RTL_EXPR in the front-end, we must
-	 ensure that everything in it is safe from the garbage collector.
-	 ??? This has only been done for `build_new'.  */
-      return 1;
-
-    default:
-      my_friendly_abort (41);
-    }
-
-  if (to == 0)
-    return 0;
-
-  /* FROM wasn't safe.  But other properties of TO might make it safe.  */
-  switch (TREE_CODE (to))
-    {
-    case VAR_DECL:
-    case PARM_DECL:
-      /* We already culled out static VAR_DECLs above.  */
-      return 0;
-
-    case COMPONENT_REF:
-      /* These guys are special, and safe.  */
-      if (TREE_CODE (TREE_OPERAND (to, 1)) == FIELD_DECL
-	  && (VFIELD_NAME_P (DECL_NAME (TREE_OPERAND (to, 1)))
-	      || VBASE_NAME_P (DECL_NAME (TREE_OPERAND (to, 1)))))
-	return 1;
-      /* fall through...  */
-
-    case NOP_EXPR:
-    case NON_LVALUE_EXPR:
-    case WITH_CLEANUP_EXPR:
-    case SAVE_EXPR:
-    case PREDECREMENT_EXPR:
-    case PREINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-      return value_safe_from_gc (TREE_OPERAND (to, 0), from);
-
-    case COMPOUND_EXPR:
-    case TARGET_EXPR:
-      return value_safe_from_gc (TREE_OPERAND (to, 1), from);
-
-    case COND_EXPR:
-      return (value_safe_from_gc (TREE_OPERAND (to, 1), from)
-	      && value_safe_from_gc (TREE_OPERAND (to, 2), from));
-
-    case INDIRECT_REF:
-    case ARRAY_REF:
-      /* This used to be 0, but our current restricted model
-	 allows this to be 1.  We'll never get arrays this way.  */
-      return 1;
-
-    default:
-      my_friendly_abort (42);
-    }
-
-  /* Catch-all case is that TO/FROM is not safe.  */
-  return 0;
-}
-
-/* Function to build a static GC entry for DECL.  TYPE is DECL's type.
-
-   For objects of type `class *', this is just an entry in the
-   static vector __PTR_LIST__.
-
-   For objects of type `class[]', this requires building an entry
-   in the static vector __ARR_LIST__.
-
-   For aggregates, this records all fields of type `class *'
-   and `class[]' in the respective lists above.  */
-void
-build_static_gc_entry (decl, type)
-     tree decl;
-     tree type;
-{
-  /* Now, figure out what sort of entry to build.  */
-  if (TREE_CODE (type) == POINTER_TYPE
-      || TREE_CODE (type) == REFERENCE_TYPE)
-    assemble_gc_entry (IDENTIFIER_POINTER (DECL_NAME (decl)));
-  else if (TREE_CODE (type) == RECORD_TYPE)
-    {
-      tree ref = get_temp_name (build_reference_type (type), 1);
-      DECL_INITIAL (ref) = build1 (ADDR_EXPR, TREE_TYPE (ref), decl);
-      TREE_CONSTANT (DECL_INITIAL (ref)) = 1;
-      finish_decl (ref, DECL_INITIAL (ref), 0, 0);
-    }
-  else
-    {
-      /* Not yet implemented.
-	 
-	 Cons up a static variable that holds address and length info
-	 and add that to ___ARR_LIST__.  */
-      my_friendly_abort (43);
-    }
-}
-
-/* Protect FROM from the GC, assuming FROM is going to be
-   stored into TO.  We handle three cases for TO here:
-
-   case 1: TO is a stack variable.
-   case 2: TO is zero (which means it is a parameter).
-   case 3: TO is a return value.  */
-
-tree
-protect_value_from_gc (to, from)
-     tree to, from;
-{
-  if (to == 0)
-    {
-      tree cleanup;
-
-      to = get_temp_regvar (TREE_TYPE (from), from);
-
-      /* Convert from integer to list form since we'll use it twice.  */
-      DECL_GC_OFFSET (to) = build_tree_list (NULL_TREE, DECL_GC_OFFSET (to));
-      cleanup = build_function_call (gc_unprotect_fndecl,
-				     DECL_GC_OFFSET (to));
-
-      if (! expand_decl_cleanup (to, cleanup))
-	{
-	  compiler_error ("cannot unprotect parameter in this scope");
-	  return error_mark_node;
-	}
-    }
-
-  /* Should never need to protect a value that's headed for static storage.  */
-  if (TREE_STATIC (to))
-    my_friendly_abort (44);
-
-  switch (TREE_CODE (to))
-    {
-    case COMPONENT_REF:
-    case INDIRECT_REF:
-      return protect_value_from_gc (TREE_OPERAND (to, 0), from);
-
-    case VAR_DECL:
-    case PARM_DECL:
-      {
-	tree rval;
-	if (DECL_GC_OFFSET (to) == NULL_TREE)
-	  {
-	    /* Because of a cast or a conversion, we might stick
-	       a value into a variable that would not normally
-	       have a GC entry.  */
-	    DECL_GC_OFFSET (to) = size_int (++current_function_obstack_index);
-	  }
-
-	if (TREE_CODE (DECL_GC_OFFSET (to)) != TREE_LIST)
-	  {
-	    DECL_GC_OFFSET (to)
-	      = build_tree_list (NULL_TREE, DECL_GC_OFFSET (to));
-	  }
-
-	current_function_obstack_usage = 1;
-	rval = build_function_call (gc_protect_fndecl,
-				    tree_cons (NULL_TREE, from,
-					       DECL_GC_OFFSET (to)));
-	TREE_TYPE (rval) = TREE_TYPE (from);
-	return rval;
-      }
-    }
-
-  /* If we fall through the switch, assume we lost.  */
-  my_friendly_abort (45);
-  /* NOTREACHED */
-  return NULL_TREE;
-}
-
-/* Given the expression EXP of type `class *', return the head
-   of the object pointed to by EXP.  */
-tree
-build_headof (exp)
-     tree exp;
-{
-  tree type = TREE_TYPE (exp);
-  tree vptr, offset;
-
-  if (TREE_CODE (type) != POINTER_TYPE)
-    {
-      error ("`headof' applied to non-pointer type");
-      return error_mark_node;
-    }
-
-  vptr = build1 (INDIRECT_REF, TYPE_POINTER_TO (vtable_entry_type), exp);
-  offset = build_component_ref (build_array_ref (vptr, integer_one_node),
-				get_identifier (VTABLE_DELTA_NAME),
-				NULL_TREE, 0);
-  return build (PLUS_EXPR, class_star_type_node, exp,
-		convert (integer_type_node, offset));
-}
-
-/* Given the expression EXP of type `class *', return the
-   type descriptor for the object pointed to by EXP.  */
-tree
-build_classof (exp)
-     tree exp;
-{
-  tree type = TREE_TYPE (exp);
-  tree vptr;
-  tree t_desc_entry;
-
-  if (TREE_CODE (type) != POINTER_TYPE)
-    {
-      error ("`classof' applied to non-pointer type");
-      return error_mark_node;
-    }
-
-  vptr = build1 (INDIRECT_REF, TYPE_POINTER_TO (vtable_entry_type), exp);
-  t_desc_entry = build_component_ref (build_array_ref (vptr, integer_one_node),
-				      get_identifier (VTABLE_PFN_NAME),
-				      NULL_TREE, 0);
-  TREE_TYPE (t_desc_entry) = TYPE_POINTER_TO (__t_desc_type_node);
-  return t_desc_entry;
-}
-
-/* Build and initialize various sorts of descriptors.  Every descriptor
-   node has a name associated with it (the name created by mangling).
-   For this reason, we use the identifier as our access to the __*_desc
-   nodes, instead of sticking them directly in the types.  Otherwise we
-   would burden all built-in types (and pointer types) with slots that
-   we don't necessarily want to use.
-
-   For each descriptor we build, we build a variable that contains
-   the descriptor's information.  When we need this info at runtime,
-   all we need is access to these variables.
-
-   Note: these constructors always return the address of the descriptor
-   info, since that is simplest for their mutual interaction.  */
-
-static tree
-build_generic_desc (decl, elems)
-     tree decl;
-     tree elems;
-{
-  tree init = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE, elems);
-  TREE_CONSTANT (init) = 1;
-  TREE_STATIC (init) = 1;
-  TREE_READONLY (init) = 1;
-
-  DECL_INITIAL (decl) = init;
-  TREE_STATIC (decl) = 1;
-  layout_decl (decl, 0);
-  finish_decl (decl, init, 0, 0);
-
-  return IDENTIFIER_AS_DESC (DECL_NAME (decl));
-}
-
-/* Build an initializer for a __t_desc node.  So that we can take advantage
-   of recursion, we accept NULL for TYPE.
-   DEFINITION is greater than zero iff we must define the type descriptor
-   (as opposed to merely referencing it).  1 means treat according to
-   #pragma interface/#pragma implementation rules.  2 means define as
-   global and public, no matter what.  */
-tree
-build_t_desc (type, definition)
-     tree type;
-     int definition;
-{
-  tree tdecl;
-  tree tname, name_string;
-  tree elems, fields;
-  tree parents, vbases, offsets, ivars, methods, target_type;
-  int method_count = 0, field_count = 0;
-
-  if (type == NULL_TREE)
-    return NULL_TREE;
-
-  tname = build_t_desc_overload (type);
-  if (IDENTIFIER_AS_DESC (tname)
-      && (!definition || TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname))))
-    return IDENTIFIER_AS_DESC (tname);
-
-  tdecl = lookup_name (tname, 0);
-  if (tdecl == NULL_TREE)
-    {
-      tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node);
-      DECL_EXTERNAL (tdecl) = 1;
-      TREE_PUBLIC (tdecl) = 1;
-      tdecl = pushdecl_top_level (tdecl);
-    }
-  /* If we previously defined it, return the defined result.  */
-  else if (definition && DECL_INITIAL (tdecl))
-    return IDENTIFIER_AS_DESC (tname);
-
-  if (definition)
-    {
-      tree taggr = type;
-      /* Let T* and T& be written only when T is written (if T is an aggr).
-         We do this for const, but not for volatile, since volatile
-	 is rare and const is not.  */
-      if (!TYPE_VOLATILE (taggr)
-	  && (TREE_CODE (taggr) == POINTER_TYPE
-	      || TREE_CODE (taggr) == REFERENCE_TYPE)
-	  && IS_AGGR_TYPE (TREE_TYPE (taggr)))
-	taggr = TREE_TYPE (taggr);
-
-      /* If we know that we don't need to write out this type's
-	 vtable, then don't write out it's dossier.  Somebody
-	 else will take care of that.  */
-      if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr))
-	{
-	  if (CLASSTYPE_VTABLE_NEEDS_WRITING (taggr))
-	    {
-	      TREE_PUBLIC (tdecl) = !(CLASSTYPE_INTERFACE_ONLY (taggr)
-				      || CLASSTYPE_INTERFACE_UNKNOWN (taggr));
-	      TREE_STATIC (tdecl) = 1;
-	      DECL_EXTERNAL (tdecl) = 0;
-	    }
-	  else
-	    {
-	      if (write_virtuals != 0)
-		TREE_PUBLIC (tdecl) = 1;
-	    }
-	}
-      else
-	{
-	  DECL_EXTERNAL (tdecl) = 0;
-	  TREE_STATIC (tdecl) = 1;
-	  TREE_PUBLIC (tdecl) = (definition > 1);
-	}
-    }
-  SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0));
-  if (!definition || DECL_EXTERNAL (tdecl))
-    {
-      /* That's it!  */
-      finish_decl (tdecl, 0, 0, 0);
-      return IDENTIFIER_AS_DESC (tname);
-    }
-
-  /* Show that we are defining the t_desc for this type.  */
-  DECL_INITIAL (tdecl) = error_mark_node;
-
-  parents = build_tree_list (NULL_TREE, integer_zero_node);
-  vbases = build_tree_list (NULL_TREE, integer_zero_node);
-  offsets = build_tree_list (NULL_TREE, integer_zero_node);
-  methods = NULL_TREE;
-  ivars = NULL_TREE;
-
-  if (TYPE_LANG_SPECIFIC (type))
-    {
-      int i = CLASSTYPE_N_BASECLASSES (type);
-      tree method_vec = CLASSTYPE_METHOD_VEC (type);
-      tree *meth, *end;
-      tree binfos = TYPE_BINFO_BASETYPES (type);
-      tree vb = CLASSTYPE_VBASECLASSES (type);
-
-      while (--i >= 0)
-	parents = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (TREE_VEC_ELT (binfos, i)), 0), parents);
-
-      while (vb)
-	{
-	  vbases = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (vb), 0), vbases);
-	  offsets = tree_cons (NULL_TREE, BINFO_OFFSET (vb), offsets);
-	  vb = TREE_CHAIN (vb);
-	}
-
-      if (method_vec)
-	for (meth = TREE_VEC_END (method_vec),
-	     end = &TREE_VEC_ELT (method_vec, 0); meth-- != end; )
-	  if (*meth)
-	    {
-	      methods = tree_cons (NULL_TREE, build_m_desc (*meth), methods);
-	      method_count++;
-	    }
-    }
-
-  if (IS_AGGR_TYPE (type))
-    {
-      for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
-	if (TREE_CODE (fields) == FIELD_DECL
-	    || TREE_CODE (fields) == VAR_DECL)
-	  {
-	    ivars = tree_cons (NULL_TREE, build_i_desc (fields), ivars);
-	    field_count++;
-	  }
-      ivars = nreverse (ivars);
-    }
-
-  parents = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node), parents, 0);
-  vbases = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node), vbases, 0);
-  offsets = finish_table (0, integer_type_node, offsets, 0);
-  methods = finish_table (0, __m_desc_type_node, methods, 0);
-  ivars = finish_table (0, __i_desc_type_node, ivars, 0);
-  if (TREE_TYPE (type))
-    target_type = build_t_desc (TREE_TYPE (type), definition);
-  else
-    target_type = integer_zero_node;
-
-  name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
-
-  elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
-	   tree_cons (NULL_TREE,
-		      TYPE_SIZE(type)? size_in_bytes(type) : integer_zero_node,
-	     /* really should use bitfield initialization here.  */
-	     tree_cons (NULL_TREE, integer_zero_node,
-	      tree_cons (NULL_TREE, target_type,
-	       tree_cons (NULL_TREE, build_int_2 (field_count, 2),
-		tree_cons (NULL_TREE, build_int_2 (method_count, 2),
-		 tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, ivars, 0),
-		  tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, methods, 0),
-		   tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, parents, 0),
-		    tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, vbases, 0),
-		     build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, offsets, 0))))))))))));
-  return build_generic_desc (tdecl, elems);
-}
-
-/* Build an initializer for a __i_desc node.  */
-tree
-build_i_desc (decl)
-     tree decl;
-{
-  tree elems, name_string;
-  tree taggr;
-
-  name_string = DECL_NAME (decl);
-  name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
-
-  /* Now decide whether this ivar should cause it's type to get
-     def'd or ref'd in this file.  If the type we are looking at
-     has a proxy definition, we look at the proxy (i.e., a
-     `foo *' is equivalent to a `foo').  */
-  taggr = TREE_TYPE (decl);
-
-  if ((TREE_CODE (taggr) == POINTER_TYPE
-       || TREE_CODE (taggr) == REFERENCE_TYPE)
-      && TYPE_VOLATILE (taggr) == 0)
-    taggr = TREE_TYPE (taggr);
-
-  elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
-	     tree_cons (NULL_TREE, DECL_FIELD_BITPOS (decl),
-		build_tree_list (NULL_TREE, build_t_desc (TREE_TYPE (decl),
-							  ! IS_AGGR_TYPE (taggr)))));
-  taggr = build (CONSTRUCTOR, __i_desc_type_node, NULL_TREE, elems);
-  TREE_CONSTANT (taggr) = 1;
-  TREE_STATIC (taggr) = 1;
-  TREE_READONLY (taggr) = 1;
-  return taggr;
-}
-
-/* Build an initializer for a __m_desc node.  */
-tree
-build_m_desc (decl)
-     tree decl;
-{
-  tree taggr, elems, name_string;
-  tree parm_count, req_count, vindex, vcontext;
-  tree parms;
-  int p_count, r_count;
-  tree parm_types = NULL_TREE;
-
-  for (parms = TYPE_ARG_TYPES (TREE_TYPE (decl)), p_count = 0, r_count = 0;
-       parms != NULL_TREE; parms = TREE_CHAIN (parms), p_count++)
-    {
-      taggr = TREE_VALUE (parms);
-      if ((TREE_CODE (taggr) == POINTER_TYPE
-	   || TREE_CODE (taggr) == REFERENCE_TYPE)
-	  && TYPE_VOLATILE (taggr) == 0)
-	taggr = TREE_TYPE (taggr);
-
-      parm_types = tree_cons (NULL_TREE, build_t_desc (TREE_VALUE (parms),
-						       ! IS_AGGR_TYPE (taggr)),
-			      parm_types);
-      if (TREE_PURPOSE (parms) == NULL_TREE)
-	r_count++;
-    }
-
-  parm_types = finish_table (0, TYPE_POINTER_TO (__t_desc_type_node),
-			     nreverse (parm_types), 0);
-  parm_count = build_int_2 (p_count, 0);
-  req_count = build_int_2 (r_count, 0);
-
-  if (DECL_VINDEX (decl))
-    vindex = DECL_VINDEX (decl);
-  else
-    vindex = integer_zero_node;
-  if (DECL_CONTEXT (decl)
-      && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
-    vcontext = build_t_desc (DECL_CONTEXT (decl), 0);
-  else
-    vcontext = integer_zero_node;
-  name_string = DECL_NAME (decl);
-  if (name_string == NULL)
-      name_string = DECL_ASSEMBLER_NAME (decl);
-  name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
-
-  /* Now decide whether the return type of this mvar
-     should cause it's type to get def'd or ref'd in this file.
-     If the type we are looking at has a proxy definition,
-     we look at the proxy (i.e., a `foo *' is equivalent to a `foo').  */
-  taggr = TREE_TYPE (TREE_TYPE (decl));
-
-  if ((TREE_CODE (taggr) == POINTER_TYPE
-       || TREE_CODE (taggr) == REFERENCE_TYPE)
-      && TYPE_VOLATILE (taggr) == 0)
-    taggr = TREE_TYPE (taggr);
-
-  elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
-	     tree_cons (NULL_TREE, vindex,
-		tree_cons (NULL_TREE, vcontext,
-		   tree_cons (NULL_TREE, build_t_desc (TREE_TYPE (TREE_TYPE (decl)),
-						       ! IS_AGGR_TYPE (taggr)),
-		      tree_cons (NULL_TREE, build_c_cast (TYPE_POINTER_TO (default_function_type), build_unary_op (ADDR_EXPR, decl, 0)),
-			 tree_cons (NULL_TREE, parm_count,
-			    tree_cons (NULL_TREE, req_count,
-			       build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, parm_types, 0)))))))));
-
-  taggr = build (CONSTRUCTOR, __m_desc_type_node, NULL_TREE, elems);
-  TREE_CONSTANT (taggr) = 1;
-  TREE_STATIC (taggr) = 1;
-  TREE_READONLY (taggr) = 1;
-  return taggr;
-}
-
-/* Conditionally emit code to set up an unwind-protect for the
-   garbage collector.  If this function doesn't do anything that involves
-   the garbage collector, then do nothing.  Otherwise, call __gc_push
-   at the beginning and __gc_pop at the end.
-
-   NOTE!  The __gc_pop function must operate transparently, since
-   it comes where the logical return label lies.  This means that
-   at runtime *it* must preserve any return value registers.  */
-
-void
-expand_gc_prologue_and_epilogue ()
-{
-  extern tree maybe_gc_cleanup;
-  struct rtx_def *last_parm_insn, *mark;
-  extern struct rtx_def *get_last_insn ();
-  extern struct rtx_def *get_first_nonparm_insn ();
-  extern struct rtx_def *previous_insn ();
-  tree action;
-
-  /* If we didn't need the obstack, don't cons any space.  */
-  if (current_function_obstack_index == 0
-      || current_function_obstack_usage == 0)
-    return;
-
-  mark = get_last_insn ();
-  last_parm_insn = get_first_nonparm_insn ();
-  if (last_parm_insn == 0) last_parm_insn = mark;
-  else last_parm_insn = previous_insn (last_parm_insn);
-
-  action = build_function_call (gc_push_fndecl,
-				build_tree_list (NULL_TREE, size_int (++current_function_obstack_index)));
-  expand_expr_stmt (action);
-
-  reorder_insns (next_insn (mark), get_last_insn (), last_parm_insn);
-
-  /* This will be expanded as a cleanup.  */
-  TREE_VALUE (maybe_gc_cleanup)
-    = build_function_call (gc_pop_fndecl, NULL_TREE);
-}
-
-/* Some day we'll use this function as a call-back and clean
-   up all the unnecessary gc dribble that we otherwise create.  */
-void
-lang_expand_end_bindings (first, last)
-     struct rtx_def *first, *last;
-{
-}
-
-void
-init_gc_processing ()
-{
-  tree parmtypes = hash_tree_chain (class_star_type_node,
-				    hash_tree_chain (integer_type_node, NULL_TREE));
-  gc_protect_fndecl = define_function ("__gc_protect",
-				       build_function_type (class_star_type_node, parmtypes),
-				       NOT_BUILT_IN, 0, 0);
-
-  parmtypes = hash_tree_chain (integer_type_node, NULL_TREE);
-  gc_unprotect_fndecl = define_function ("__gc_unprotect",
-					 build_function_type (void_type_node, parmtypes),
-					 NOT_BUILT_IN, 0, 0);
-
-  gc_push_fndecl = define_function ("__gc_push",
-				    TREE_TYPE (gc_unprotect_fndecl),
-				    NOT_BUILT_IN, 0, 0);
-
-  gc_pop_fndecl = define_function ("__gc_pop",
-				   build_function_type (void_type_node,
-							void_list_node),
-				   NOT_BUILT_IN, 0, 0);
-  gc_nonobject = build_int_2 (0x80000000, 0);
-  gc_visible = build_int_2 (0x40000000, 0);
-  gc_white = integer_zero_node;
-  gc_offwhite = build_int_2 (0x10000000, 0);
-  gc_grey = build_int_2 (0x20000000, 0);
-  gc_black = build_int_2 (0x30000000, 0);
-}
diff --git a/gnu/gcc2/cc1plus/cp-hash.h b/gnu/gcc2/cc1plus/cp-hash.h
deleted file mode 100644
index 04d03accb9d6..000000000000
--- a/gnu/gcc2/cc1plus/cp-hash.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/* C code produced by gperf version 2.5 (GNU C++ version) */
-/* Command-line: gperf -p -j1 -g -o -t -N is_reserved_word -k1,4,$,7 gplus.gperf  */
-/* Command-line: gperf -p -j1 -g -o -t -N is_reserved_word -k1,4,$,7 gplus.gperf  */
-struct resword { char *name; short token; enum rid rid;};
-
-#define TOTAL_KEYWORDS 82
-#define MIN_WORD_LENGTH 2
-#define MAX_WORD_LENGTH 13
-#define MIN_HASH_VALUE 4
-#define MAX_HASH_VALUE 140
-/* maximum key range = 137, duplicates = 0 */
-
-#ifdef __GNUC__
-inline
-#endif
-static unsigned int
-hash (str, len)
-     register char *str;
-     register int unsigned len;
-{
-  static unsigned char asso_values[] =
-    {
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
-     141, 141, 141, 141, 141,   0, 141,  49,   3,  28,
-      28,   0,   5,  11,  32,  37, 141,   2,  24,  35,
-      51,   0,  19, 141,  23,   0,   8,  48,   0,  36,
-       0,  11, 141, 141, 141, 141, 141, 141,
-    };
-  register int hval = len;
-
-  switch (hval)
-    {
-      default:
-      case 7:
-        hval += asso_values[str[6]];
-      case 6:
-      case 5:
-      case 4:
-        hval += asso_values[str[3]];
-      case 3:
-      case 2:
-      case 1:
-        hval += asso_values[str[0]];
-    }
-  return hval + asso_values[str[len - 1]];
-}
-
-#ifdef __GNUC__
-inline
-#endif
-struct resword *
-is_reserved_word (str, len)
-     register char *str;
-     register unsigned int len;
-{
-  static struct resword wordlist[] =
-    {
-      {"",}, {"",}, {"",}, {"",}, 
-      {"else",  ELSE, NORID,},
-      {"",}, {"",}, 
-      {"__asm__",  GCC_ASM_KEYWORD, NORID},
-      {"",}, {"",}, 
-      {"__headof__",  HEADOF, NORID},
-      {"sizeof",  SIZEOF, NORID,},
-      {"this",  THIS, NORID,},
-      {"__headof",  HEADOF, NORID},
-      {"except",  EXCEPT, NORID		/* Extension */,},
-      {"goto",  GOTO, NORID,},
-      {"",}, 
-      {"__const__",  TYPE_QUAL, RID_CONST},
-      {"__volatile",  TYPE_QUAL, RID_VOLATILE},
-      {"typeof",  TYPEOF, NORID,},
-      {"__volatile__",  TYPE_QUAL, RID_VOLATILE},
-      {"__typeof__",  TYPEOF, NORID},
-      {"try",  TRY, NORID			/* Extension */,},
-      {"__const",  TYPE_QUAL, RID_CONST},
-      {"__typeof",  TYPEOF, NORID},
-      {"typedef",  SCSPEC, RID_TYPEDEF,},
-      {"private",  VISSPEC, RID_PRIVATE,},
-      {"",}, 
-      {"raise",  RAISE, NORID		/* Extension */,},
-      {"raises",  RAISES, NORID		/* Extension */,},
-      {"do",  DO, NORID,},
-      {"for",  FOR, NORID,},
-      {"case",  CASE, NORID,},
-      {"class",  AGGR, RID_CLASS,},
-      {"delete",  DELETE, NORID,},
-      {"__classof__",  CLASSOF, NORID},
-      {"short",  TYPESPEC, RID_SHORT,},
-      {"double",  TYPESPEC, RID_DOUBLE,},
-      {"__classof",  CLASSOF, NORID},
-      {"friend",  SCSPEC, RID_FRIEND,},
-      {"__asm",  GCC_ASM_KEYWORD, NORID},
-      {"const",  TYPE_QUAL, RID_CONST,},
-      {"static",  SCSPEC, RID_STATIC,},
-      {"template",  TEMPLATE, NORID,},
-      {"if",  IF, NORID,},
-      {"classof",  CLASSOF, NORID,},
-      {"switch",  SWITCH, NORID,},
-      {"__signed__",  TYPESPEC, RID_SIGNED},
-      {"int",  TYPESPEC, RID_INT,},
-      {"throw",  THROW, NORID		/* Extension */,},
-      {"long",  TYPESPEC, RID_LONG,},
-      {"",}, {"",}, 
-      {"auto",  SCSPEC, RID_AUTO,},
-      {"operator",  OPERATOR, NORID,},
-      {"",}, 
-      {"__attribute",  ATTRIBUTE, NORID},
-      {"extern",  SCSPEC, RID_EXTERN,},
-      {"__attribute__",  ATTRIBUTE, NORID},
-      {"break",  BREAK, NORID,},
-      {"void",  TYPESPEC, RID_VOID,},
-      {"",}, 
-      {"struct",  AGGR, RID_RECORD,},
-      {"virtual",  SCSPEC, RID_VIRTUAL,},
-      {"__extension__",  EXTENSION, NORID},
-      {"while",  WHILE, NORID,},
-      {"",}, 
-      {"float",  TYPESPEC, RID_FLOAT,},
-      {"__wchar_t",  TYPESPEC, RID_WCHAR  /* Unique to ANSI C++ */,},
-      {"",}, {"",}, 
-      {"headof",  HEADOF, NORID,},
-      {"protected",  VISSPEC, RID_PROTECTED,},
-      {"__signed",  TYPESPEC, RID_SIGNED},
-      {"enum",  ENUM, NORID,},
-      {"",}, 
-      {"all",  ALL, NORID			/* Extension */,},
-      {"public",  VISSPEC, RID_PUBLIC,},
-      {"char",  TYPESPEC, RID_CHAR,},
-      {"reraise",  RERAISE, NORID		/* Extension */,},
-      {"inline",  SCSPEC, RID_INLINE,},
-      {"volatile",  TYPE_QUAL, RID_VOLATILE,},
-      {"__label__",  LABEL, NORID},
-      {"",}, {"",}, 
-      {"signed",  TYPESPEC, RID_SIGNED,},
-      {"__alignof__",  ALIGNOF, NORID},
-      {"asm",  ASM_KEYWORD, NORID,},
-      {"",}, 
-      {"__alignof",  ALIGNOF, NORID},
-      {"new",  NEW, NORID,},
-      {"register",  SCSPEC, RID_REGISTER,},
-      {"continue",  CONTINUE, NORID,},
-      {"catch",  CATCH, NORID,},
-      {"",}, {"",}, {"",}, 
-      {"exception",  AGGR, RID_EXCEPTION	/* Extension */,},
-      {"",}, {"",}, 
-      {"default",  DEFAULT, NORID,},
-      {"",}, {"",}, {"",}, 
-      {"union",  AGGR, RID_UNION,},
-      {"",}, {"",}, {"",}, 
-      {"overload",  OVERLOAD, NORID,},
-      {"",}, 
-      {"__inline",  SCSPEC, RID_INLINE},
-      {"",}, 
-      {"__inline__",  SCSPEC, RID_INLINE},
-      {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
-      {"unsigned",  TYPESPEC, RID_UNSIGNED,},
-      {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
-      {"return",  RETURN, NORID,},
-      {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
-      {"",}, {"",}, 
-      {"dynamic",  DYNAMIC, NORID,},
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      register int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= 0)
-        {
-          register char *s = wordlist[key].name;
-
-          if (*s == *str && !strcmp (str + 1, s + 1))
-            return &wordlist[key];
-        }
-    }
-  return 0;
-}
diff --git a/gnu/gcc2/cc1plus/cp-init.c b/gnu/gcc2/cc1plus/cp-init.c
deleted file mode 100644
index 38082e5689aa..000000000000
--- a/gnu/gcc2/cc1plus/cp-init.c
+++ /dev/null
@@ -1,4008 +0,0 @@
-/* Handle initialization things in C++.
-   Copyright (C) 1987, 1989, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* High-level class interface. */
-
-#include "config.h"
-#include "tree.h"
-#include "rtl.h"
-#include "cp-tree.h"
-#include "flags.h"
-
-#undef NULL
-#define NULL 0
-
-/* In C++, structures with well-defined constructors are initialized by
-   those constructors, unasked.  CURRENT_BASE_INIT_LIST
-   holds a list of stmts for a BASE_INIT term in the grammar.
-   This list has one element for each base class which must be
-   initialized.  The list elements are [basename, init], with
-   type basetype.  This allows the possibly anachronistic form
-   (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
-   where each successive term can be handed down the constructor
-   line.  Perhaps this was not intended.  */
-tree current_base_init_list, current_member_init_list;
-
-void emit_base_init ();
-void check_base_init ();
-static void expand_aggr_vbase_init ();
-void expand_member_init ();
-void expand_aggr_init ();
-
-static void expand_aggr_init_1 ();
-static void expand_recursive_init_1 ();
-static void expand_recursive_init ();
-tree expand_vec_init ();
-tree build_vec_delete ();
-
-static void add_friend (), add_friends ();
-
-/* Cache _builtin_new and _builtin_delete exprs.  */
-static tree BIN, BID;
-
-static tree minus_one;
-
-/* Set up local variable for this file.  MUST BE CALLED AFTER
-   INIT_DECL_PROCESSING.  */
-
-tree BI_header_type, BI_header_size;
-
-void init_init_processing ()
-{
-  tree op_id;
-  tree fields[2];
-
-  /* Define implicit `operator new' and `operator delete' functions.  */
-  BIN = default_conversion (TREE_VALUE (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) NEW_EXPR])));
-  TREE_USED (TREE_OPERAND (BIN, 0)) = 0;
-  BID = default_conversion (TREE_VALUE (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) DELETE_EXPR])));
-  TREE_USED (TREE_OPERAND (BID, 0)) = 0;
-  minus_one = build_int_2 (-1, -1);
-
-  op_id = ansi_opname[(int) NEW_EXPR];
-  IDENTIFIER_GLOBAL_VALUE (op_id) = BIN;
-  op_id = ansi_opname[(int) DELETE_EXPR];
-  IDENTIFIER_GLOBAL_VALUE (op_id) = BID;
-
-  /* Define the structure that holds header information for
-     arrays allocated via operator new.  */
-  BI_header_type = make_lang_type (RECORD_TYPE);
-  fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("nelts"),
-				     sizetype);
-  fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("ptr_2comp"),
-				     ptr_type_node);
-  finish_builtin_type (BI_header_type, "__new_cookie", fields, 1, double_type_node);
-  BI_header_size = size_in_bytes (BI_header_type);
-}
-
-/* Recursive subroutine of emit_base_init.  For main type T,
-   recursively initialize the vfields of the base type PARENT.
-   RECURSE is non-zero when this function is being called
-   recursively.  */
-
-static void
-init_vfields (t, parent, recurse)
-     tree t, parent;
-     int recurse;
-{
-  tree vfields;
-
-  /* Initialize all the virtual function table fields that
-     do not come from virtual base classes.  */
-  vfields = CLASSTYPE_VFIELDS (parent);
-  while (vfields)
-    {
-      tree basetype = VF_DERIVED_VALUE (vfields)
-	? TYPE_MAIN_VARIANT (VF_DERIVED_VALUE (vfields))
-	  : VF_BASETYPE_VALUE (vfields);
-
-      /* If the vtable installed by the constructor was not
-	 the right one, fix that here.  */
-      if (TREE_ADDRESSABLE (vfields)
-	  && CLASSTYPE_NEEDS_VIRTUAL_REINIT (basetype)
-	  && (recurse > 0
-	      || TYPE_HAS_CONSTRUCTOR (basetype)
-	      /* BASE_INIT_LIST has already initialized the immediate basetypes.  */
-	      || get_base_distance (basetype, t, 0, (tree *) 0) > 1))
-	{
-	  tree binfo = binfo_value (basetype, t);
-	  if ((recurse != 0 && (binfo != binfo_value (basetype, parent)))
-	      || (recurse == 0
-		  && BINFO_VTABLE (binfo) != TYPE_BINFO_VTABLE (basetype)))
-	    {
-	      tree ptr = convert_pointer_to (binfo, current_class_decl);
-	      expand_expr_stmt (build_virtual_init (TYPE_BINFO (t), binfo, ptr));
-	    }
-	  init_vfields (t, basetype, recurse+1);
-	}
-      vfields = TREE_CHAIN (vfields);
-    }
-}
-
-/* Perform whatever initialization have yet to be done on the
-   base class of the class variable.  These actions are in
-   the global variable CURRENT_BASE_INIT_LIST.  Such an
-   action could be NULL_TREE, meaning that the user has explicitly
-   called the base class constructor with no arguments.
-
-   If there is a need for a call to a constructor, we
-   must surround that call with a pushlevel/poplevel pair,
-   since we are technically at the PARM level of scope.
-
-   Argument IMMEDIATELY, if zero, forces a new sequence to be generated
-   to contain these new insns, so it can be emitted later.  This sequence
-   is saved in the global variable BASE_INIT_INSNS.  Otherwise, the insns
-   are emitted into the current sequence.
-
-   Note that emit_base_init does *not* initialize virtual
-   base classes.  That is done specially, elsewhere.  */
-   
-void
-emit_base_init (t, immediately)
-     tree t;
-     int immediately;
-{
-  extern tree in_charge_identifier;
-
-  tree member, decl, vbases;
-  tree init_list;
-  int pass, start;
-  tree t_binfo = TYPE_BINFO (t);
-  tree binfos = BINFO_BASETYPES (t_binfo);
-  int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-  tree fields_to_unmark = NULL_TREE;
-
-  if (! immediately)
-    {
-      do_pending_stack_adjust ();
-      start_sequence ();
-    }
-
-  if (write_symbols == NO_DEBUG)
-    /* As a matter of principle, `start_sequence' should do this.  */
-    emit_note (0, -1);
-  else
-    /* Always emit a line number note so we can step into constructors.  */
-    emit_line_note_force (DECL_SOURCE_FILE (current_function_decl),
-			  DECL_SOURCE_LINE (current_function_decl));
-
-  /* In this case, we always need IN_CHARGE_NODE, because we have
-     to know whether to deallocate or not before exiting.  */
-  if (flag_handle_exceptions == 2
-      && lookup_name (in_charge_identifier, 0) == NULL_TREE)
-    {
-      tree in_charge_node = pushdecl (build_decl (VAR_DECL, in_charge_identifier,
-						  integer_type_node));
-      store_init_value (in_charge_node, build (EQ_EXPR, integer_type_node,
-					       current_class_decl,
-					       integer_zero_node));
-      expand_decl (in_charge_node);
-      expand_decl_init (in_charge_node);
-    }
-
-  start = ! TYPE_USES_VIRTUAL_BASECLASSES (t);
-  for (pass = start; pass < 2; pass++)
-    {
-      tree vbase_init_list = NULL_TREE;
-
-      for (init_list = current_base_init_list; init_list;
-	   init_list = TREE_CHAIN (init_list))
-	{
-	  tree basename = TREE_PURPOSE (init_list);
-	  tree binfo;
-	  tree init = TREE_VALUE (init_list);
-
-	  if (basename == NULL_TREE)
-	    {
-	      /* Initializer for single base class.  Must not
-		 use multiple inheritance or this is ambiguous.  */
-	      switch (n_baseclasses)
-		{
-		case 0:
-		  error ("type `%s' does not have a base class to initialize",
-			 IDENTIFIER_POINTER (current_class_name));
-		  return;
-		case 1:
-		  break;
-		default:
-		  error ("unnamed initializer ambiguous for type `%s' which uses multiple inheritance", IDENTIFIER_POINTER (current_class_name));
-		  return;
-		}
-	      binfo = TREE_VEC_ELT (binfos, 0);
-	    }
-	  else if (is_aggr_typedef (basename, 1))
-	    {
-	      binfo = binfo_or_else (IDENTIFIER_TYPE_VALUE (basename), t);
-	      if (binfo == NULL_TREE)
-		continue;
-
-	      /* Virtual base classes are special cases.  Their initializers
-		 are recorded with this constructor, and they are used when
-		 this constructor is the top-level constructor called.  */
-	      if (! TREE_VIA_VIRTUAL (binfo))
-		{
-		  /* Otherwise, if it is not an immediate base class, complain.  */
-		  for (i = n_baseclasses-1; i >= 0; i--)
-		    if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i)))
-		      break;
-		  if (i < 0)
-		    {
-		      error ("type `%s' is not an immediate base class of type `%s'",
-			     IDENTIFIER_POINTER (basename),
-			     IDENTIFIER_POINTER (current_class_name));
-		      continue;
-		    }
-		}
-	    }
-	  else
-	    continue;
-
-	  /* The base initialization list goes up to the first
-	     base class which can actually use it.  */
-
-	  if (pass == start)
-	    {
-	      char *msgp = (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo)))
-		? "cannot pass initialization up to class `%s'" : 0;
-
-	      while (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo))
-		     && BINFO_BASETYPES (binfo) != NULL_TREE
-		     && TREE_VEC_LENGTH (BINFO_BASETYPES (binfo)) == 1)
-		{
-		  /* ?? This should be fixed in RENO by forcing
-		     default constructors to exist.  */
-		  SET_BINFO_BASEINIT_MARKED (binfo);
-		  binfo = BINFO_BASETYPE (binfo, 0);
-		}
-
-	      if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo)))
-		{
-		  if (msgp)
-		    {
-		      if (pedantic)
-			error_with_aggr_type (binfo, msgp);
-		      else
-			msgp = 0;
-		    }
-		}
-	      else
-		{
-		  msgp = "no constructor found for initialization of `%s'";
-		  error (msgp, IDENTIFIER_POINTER (basename));
-		}
-
-	      if (BINFO_BASEINIT_MARKED (binfo))
-		{
-		  msgp = "class `%s' initializer already specified";
-		  error (msgp, IDENTIFIER_POINTER (basename));
-		}
-	      if (msgp)
-		continue;
-
-	      SET_BINFO_BASEINIT_MARKED (binfo);
-	      if (TREE_VIA_VIRTUAL (binfo))
-		{
-		  vbase_init_list = tree_cons (init, BINFO_TYPE (binfo),
-					       vbase_init_list);
-		  continue;
-		}
-	      if (pass == 0)
-		continue;
-	    }
-	  else if (TREE_VIA_VIRTUAL (binfo))
-	    continue;
-
-	  member = convert_pointer_to (binfo, current_class_decl);
-	  expand_aggr_init_1 (t_binfo, 0,
-			      build_indirect_ref (member, 0), init,
-			      BINFO_OFFSET_ZEROP (binfo),
-			      LOOKUP_PROTECTED_OK|LOOKUP_COMPLAIN);
-	  if (flag_handle_exceptions == 2 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (binfo)))
-	    {
-	      cplus_expand_start_try (1);
-	      push_exception_cleanup (member);
-	    }
-	}
-
-      if (pass == 0)
-	{
-	  tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
-	  tree vbases;
-
-	  if (DECL_NAME (current_function_decl) == NULL_TREE
-	      && TREE_CHAIN (first_arg) != NULL_TREE)
-	    {
-	      /* If there are virtual baseclasses without initialization
-		 specified, and this is a default X(X&) constructor,
-		 build the initialization list so that each virtual baseclass
-		 of the new object is initialized from the virtual baseclass
-		 of the incoming arg.  */
-	      tree init_arg = build_unary_op (ADDR_EXPR, TREE_CHAIN (first_arg), 0);
-	      for (vbases = CLASSTYPE_VBASECLASSES (t);
-		   vbases; vbases = TREE_CHAIN (vbases))
-		{
-		  if (BINFO_BASEINIT_MARKED (vbases) == 0)
-		    {
-		      member = convert_pointer_to (vbases, init_arg);
-		      if (member == init_arg)
-			member = TREE_CHAIN (first_arg);
-		      else
-			TREE_TYPE (member) = build_reference_type (BINFO_TYPE (vbases));
-		      vbase_init_list = tree_cons (convert_from_reference (member),
-						   vbases, vbase_init_list);
-		      SET_BINFO_BASEINIT_MARKED (vbases);
-		    }
-		}
-	    }
-	  expand_start_cond (first_arg, 0);
-	  expand_aggr_vbase_init (t_binfo, C_C_D, current_class_decl,
-				  vbase_init_list);
-	  expand_expr_stmt (build_vbase_vtables_init (t_binfo, t_binfo,
-						      C_C_D, current_class_decl, 1));
-	  expand_end_cond ();
-	}
-    }
-  current_base_init_list = NULL_TREE;
-
-  /* Now, perform default initialization of all base classes which
-     have not yet been initialized, and unmark baseclasses which
-     have been initialized.  */
-  for (i = 0; i < n_baseclasses; i++)
-    {
-      tree base = current_class_decl;
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-      if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo)))
-	{
-	  if (! TREE_VIA_VIRTUAL (base_binfo)
-	      && ! BINFO_BASEINIT_MARKED (base_binfo))
-	    {
-	      tree ref;
-
-	      if (BINFO_OFFSET_ZEROP (base_binfo))
-		base = build1 (NOP_EXPR,
-			       TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
-			       current_class_decl);
-	      else
-		base = build (PLUS_EXPR,
-			      TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
-			      current_class_decl, BINFO_OFFSET (base_binfo));
-
-	      ref = build_indirect_ref (base, 0);
-	      expand_aggr_init_1 (t_binfo, 0, ref, NULL_TREE,
-				  BINFO_OFFSET_ZEROP (base_binfo),
-				  LOOKUP_PROTECTED_OK|LOOKUP_COMPLAIN);
-	      if (flag_handle_exceptions == 2
-		  && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
-		{
-		  cplus_expand_start_try (1);
-		  push_exception_cleanup (base);
-		}
-	    }
-	}
-      CLEAR_BINFO_BASEINIT_MARKED (base_binfo);
-    }
-  for (vbases = CLASSTYPE_VBASECLASSES (t); vbases; vbases = TREE_CHAIN (vbases))
-    CLEAR_BINFO_BASEINIT_MARKED (vbases);
-
-  /* Initialize all the virtual function table fields that
-     do not come from virtual base classes.  */
-  init_vfields (t, t, 0);
-
-  if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (t))
-    expand_expr_stmt (build_virtual_init (TYPE_BINFO (t), t,
-					  current_class_decl));
-
-  /* Members we through expand_member_init.  We initialize all the members
-     needing initialization that did not get it so far.  */
-  for (; current_member_init_list;
-       current_member_init_list = TREE_CHAIN (current_member_init_list))
-    {
-      tree name = TREE_PURPOSE (current_member_init_list);
-      tree init = TREE_VALUE (current_member_init_list);
-      tree field = (TREE_CODE (name) == COMPONENT_REF
-		    ? TREE_OPERAND (name, 1) : IDENTIFIER_CLASS_VALUE (name));
-      tree type;
-      
-      /* If one member shadows another, get the outermost one.  */
-      if (TREE_CODE (field) == TREE_LIST)
-	{
-	  field = TREE_VALUE (field);
-	  if (decl_type_context (field) != current_class_type)
-	    error ("field `%s' not in immediate context");
-	}
-
-      type = TREE_TYPE (field);
-
-      if (TREE_STATIC (field))
-	{
-	  error_with_aggr_type (DECL_FIELD_CONTEXT (field),
-				"field `%s::%s' is static; only point of initialization is its declaration", IDENTIFIER_POINTER (name));
-	  continue;
-	}
-
-      if (DECL_NAME (field))
-	{
-	  if (TREE_HAS_CONSTRUCTOR (field))
-	    error ("multiple initializations given for member `%s'",
-		   IDENTIFIER_POINTER (DECL_NAME (field)));
-	}
-
-      /* Mark this node as having been initialized.  */
-      TREE_HAS_CONSTRUCTOR (field) = 1;
-      if (DECL_FIELD_CONTEXT (field) != t)
-	fields_to_unmark = tree_cons (NULL_TREE, field, fields_to_unmark);
-
-      if (TREE_CODE (name) == COMPONENT_REF)
-	{
-	  /* Initialization of anonymous union.  */
-	  expand_assignment (name, init, 0, 0);
-	  continue;
-	}
-      decl = build_component_ref (C_C_D, name, 0, 1);
-
-      if (TYPE_NEEDS_CONSTRUCTING (type))
-	{
-	  if (TREE_CODE (type) == ARRAY_TYPE
-	      && init != NULL_TREE
-	      && TREE_CHAIN (init) == NULL_TREE
-	      && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
-	    {
-	      /* Initialization of one array from another.  */
-	      expand_vec_init (TREE_OPERAND (decl, 1), decl,
-			       array_type_nelts (type), TREE_VALUE (init), 1);
-	    }
-	  else
-	    expand_aggr_init (decl, init, 0);
-	}
-      else
-	{
-	  if (init == NULL_TREE)
-	    {
-	      error ("types without constructors must have complete initializers");
-	      init = error_mark_node;
-	    }
-	  else if (TREE_CHAIN (init))
-	    {
-	      warning ("initializer list treated as compound expression");
-	      init = build_compound_expr (init);
-	    }
-	  else
-	    init = TREE_VALUE (init);
-
-	  expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
-	}
-      if (flag_handle_exceptions == 2 && TYPE_NEEDS_DESTRUCTOR (type))
-	{
-	  cplus_expand_start_try (1);
-	  push_exception_cleanup (build_unary_op (ADDR_EXPR, decl, 0));
-	}
-    }
-
-  for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
-    {
-      /* All we care about is this unique member.  It contains
-	 all the information we need to know, and that right early.  */
-      tree type = TREE_TYPE (member);
-      tree init = TREE_HAS_CONSTRUCTOR (member)
-	? error_mark_node : DECL_INITIAL (member);
-
-      /* Unmark this field.  If it is from an anonymous union,
-         then unmark the field recursively.  */
-      TREE_HAS_CONSTRUCTOR (member) = 0;
-      if (TREE_ANON_UNION_ELEM (member))
-	emit_base_init (TREE_TYPE (member), 1);
-
-      /* Member had explicit initializer.  */
-      if (init == error_mark_node)
-	continue;
-
-      if (TREE_CODE (member) != FIELD_DECL)
-	continue;
-
-      if (type == error_mark_node)
-	continue;
-
-      if (TYPE_NEEDS_CONSTRUCTING (type))
-	{
-	  if (init)
-	    init = build_tree_list (NULL_TREE, init);
-	  decl = build_component_ref (C_C_D, DECL_NAME (member), 0, 0);
-	  expand_aggr_init (decl, init, 0);
-	}
-      else
-	{
-	  if (init)
-	    {
-	      decl = build_component_ref (C_C_D, DECL_NAME (member), 0, 0);
-	      expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
-	    }
-	  else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE)
-	    warning ("uninitialized reference member `%s'",
-		     IDENTIFIER_POINTER (DECL_NAME (member)));
-	}
-      if (flag_handle_exceptions == 2 && TYPE_NEEDS_DESTRUCTOR (type))
-	{
-	  cplus_expand_start_try (1);
-	  push_exception_cleanup (build_unary_op (ADDR_EXPR, decl, 0));
-	}
-    }
-  /* Unmark fields which are initialized for the base class.  */
-  while (fields_to_unmark)
-    {
-      TREE_HAS_CONSTRUCTOR (TREE_VALUE (fields_to_unmark)) = 0;
-      fields_to_unmark = TREE_CHAIN (fields_to_unmark);
-    }
-
-  /* It is possible for the initializers to need cleanups.
-     Expand those cleanups now that all the initialization
-     has been done.  */
-  expand_cleanups_to (NULL_TREE);
-
-  if (! immediately)
-    {
-      extern rtx base_init_insns;
-
-      do_pending_stack_adjust ();
-      my_friendly_assert (base_init_insns == 0, 207);
-      base_init_insns = get_insns ();
-      end_sequence ();
-    }
-
-  /* All the implicit try blocks we built up will be zapped
-     when we come to a real binding contour boundary.  */
-}
-
-/* Check that all fields are properly initialized after
-   an assignment to `this'.  */
-void
-check_base_init (t)
-     tree t;
-{
-  tree member;
-  for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
-    if (DECL_NAME (member) && TREE_USED (member))
-      error ("field `%s' used before initialized (after assignment to `this')",
-	     IDENTIFIER_POINTER (DECL_NAME (member)));
-}
-
-/* This code sets up the virtual function tables appropriate for
-   the pointer DECL.  It is a one-ply initialization.
-
-   BINFO is the exact type that DECL is supposed to be.  In
-   multiple inheritance, this might mean "C's A" if C : A, B.  */
-tree
-build_virtual_init (main_binfo, binfo, decl)
-     tree main_binfo, binfo;
-     tree decl;
-{
-  tree type;
-  tree vtbl, vtbl_ptr;
-  tree vtype;
-
-  if (TREE_CODE (binfo) == TREE_VEC)
-    type = BINFO_TYPE (binfo);
-  else if (TREE_CODE (binfo) == RECORD_TYPE)
-    {
-      type = binfo;
-      binfo = TYPE_BINFO (type);
-    }
-  else
-    my_friendly_abort (46);
-
-  vtype = DECL_CONTEXT (CLASSTYPE_VFIELD (type));
-#if 0
-  /* This code suggests that it's time to rewrite how we handle
-     replicated baseclasses in G++.  */
-  if (get_base_distance (vtype, TREE_TYPE (TREE_TYPE (decl)),
-			 0, (tree *) 0) == -2)
-    {
-      tree binfos = TYPE_BINFO_BASETYPES (TREE_TYPE (TREE_TYPE (decl)));
-      int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-      tree result = NULL_TREE;
-
-      for (i = n_baselinks-1; i >= 0; i--)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-	  tree this_decl;
-
-	  if (get_base_distance (vtype, BINFO_TYPE (base_binfo), 0, 0) == -1)
-	    continue;
-
-	  if (TREE_VIA_VIRTUAL (base_binfo))
-	    this_decl = build_vbase_pointer (build_indirect_ref (decl), BINFO_TYPE (base_binfo));
-	  else if (BINFO_OFFSET_ZEROP (base_binfo))
-	    this_decl = build1 (NOP_EXPR, TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
-				decl);
-	  else
-	    this_decl = build (PLUS_EXPR, TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
-			       decl, BINFO_OFFSET (base_binfo));
-	  result = tree_cons (NULL_TREE, build_virtual_init (main_binfo, base_binfo, this_decl), result);
-	}
-      return build_compound_expr (result);
-    }
-#endif
-
-    {
-#if 1
-#if 1
-      vtbl = BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type)), binfo));
-#else
-      /* The below does not work when we have to step through the
-	 vfield, on our way down to the most base class for the
-	 vfield. */
-      vtbl = BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type)),
-					BINFO_TYPE (main_binfo)));
-#endif
-#else
-      my_friendly_assert (BINFO_TYPE (main_binfo) == BINFO_TYPE (binfo), 208);
-      vtbl = BINFO_VTABLE (main_binfo);
-#endif /* 1 */
-      assemble_external (vtbl);
-      TREE_USED (vtbl) = 1;
-      vtbl = build1 (ADDR_EXPR, TYPE_POINTER_TO (TREE_TYPE (vtbl)), vtbl);
-    }
-  decl = convert_pointer_to (vtype, decl);
-  vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, 0), vtype);
-  if (vtbl_ptr == error_mark_node)
-    return error_mark_node;
-
-  /* Have to convert VTBL since array sizes may be different.  */
-  return build_modify_expr (vtbl_ptr, NOP_EXPR,
-			    convert (TREE_TYPE (vtbl_ptr), vtbl));
-}
-
-/* Subroutine of `expand_aggr_vbase_init'.
-   BINFO is the binfo of the type that is being initialized.
-   INIT_LIST is the list of initializers for the virtual baseclass.  */
-static void
-expand_aggr_vbase_init_1 (binfo, exp, addr, init_list)
-     tree binfo, exp, addr, init_list;
-{
-  tree init = value_member (BINFO_TYPE (binfo), init_list);
-  tree ref = build_indirect_ref (addr, 0);
-  if (init)
-    init = TREE_PURPOSE (init);
-  /* Call constructors, but don't set up vtables.  */
-  expand_aggr_init_1 (binfo, exp, ref, init, 0,
-		      LOOKUP_PROTECTED_OK|LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY);
-  CLEAR_BINFO_VBASE_INIT_MARKED (binfo);
-}
-
-/* Initialize this object's virtual base class pointers.  This must be
-   done only at the top-level of the object being constructed.
-
-   INIT_LIST is list of initialization for constructor to perform.  */
-static void
-expand_aggr_vbase_init (binfo, exp, addr, init_list)
-     tree binfo;
-     tree exp;
-     tree addr;
-     tree init_list;
-{
-  tree type = BINFO_TYPE (binfo);
-
-  if (TYPE_USES_VIRTUAL_BASECLASSES (type))
-    {
-      tree result = init_vbase_pointers (type, addr);
-      tree vbases;
-
-      if (result)
-	expand_expr_stmt (build_compound_expr (result));
-
-      /* Mark everything as having an initializer
-	 (either explicit or default).  */
-      for (vbases = CLASSTYPE_VBASECLASSES (type);
-	   vbases; vbases = TREE_CHAIN (vbases))
-	SET_BINFO_VBASE_INIT_MARKED (vbases);
-
-      /* First, initialize baseclasses which could be baseclasses
-	 for other virtual baseclasses.  */
-      for (vbases = CLASSTYPE_VBASECLASSES (type);
-	   vbases; vbases = TREE_CHAIN (vbases))
-	/* Don't initialize twice.  */
-	if (BINFO_VBASE_INIT_MARKED (vbases))
-	  {
-	    tree tmp = result;
-
-	    while (BINFO_TYPE (vbases) != BINFO_TYPE (TREE_PURPOSE (tmp)))
-	      tmp = TREE_CHAIN (tmp);
-	    expand_aggr_vbase_init_1 (vbases, exp,
-				      TREE_OPERAND (TREE_VALUE (tmp), 0),
-				      init_list);
-	  }
-
-      /* Now initialize the baseclasses which don't have virtual baseclasses.  */
-      for (; result; result = TREE_CHAIN (result))
-	/* Don't initialize twice.  */
-	if (BINFO_VBASE_INIT_MARKED (TREE_PURPOSE (result)))
-	  {
-	    my_friendly_abort (47);
-	    expand_aggr_vbase_init_1 (TREE_PURPOSE (result), exp,
-				      TREE_OPERAND (TREE_VALUE (result), 0),
-				      init_list);
-	  }
-    }
-}
-
-/* Subroutine to perform parser actions for member initialization.
-   S_ID is the scoped identifier.
-   NAME is the name of the member.
-   INIT is the initializer, or `void_type_node' if none.  */
-void
-do_member_init (s_id, name, init)
-     tree s_id, name, init;
-{
-  tree binfo, base;
-
-  if (current_class_type == NULL_TREE
-      || ! is_aggr_typedef (s_id, 1))
-    return;
-  binfo = get_binfo (IDENTIFIER_TYPE_VALUE (s_id),
-			  current_class_type, 1);
-  if (binfo == error_mark_node)
-    return;
-  if (binfo == 0)
-    {
-      error_not_base_type (IDENTIFIER_TYPE_VALUE (s_id), current_class_type);
-      return;
-    }
-
-  base = convert_pointer_to (binfo, current_class_decl);
-  expand_member_init (build_indirect_ref (base, NULL_PTR), name, init);
-}
-
-/* Function to give error message if member initialization specification
-   is erroneous.  FIELD is the member we decided to initialize.
-   TYPE is the type for which the initialization is being performed.
-   FIELD must be a member of TYPE, or the base type from which FIELD
-   comes must not need a constructor.
-   
-   MEMBER_NAME is the name of the member.  */
-
-static int
-member_init_ok_or_else (field, type, member_name)
-     tree field;
-     tree type;
-     char *member_name;
-{
-  if (field == error_mark_node) return 0;
-  if (field == NULL_TREE)
-    {
-      error_with_aggr_type (type, "class `%s' does not have any field named `%s'",
-			    member_name);
-      return 0;
-    }
-  if (DECL_CONTEXT (field) != type
-      && TYPE_NEEDS_CONSTRUCTOR (DECL_CONTEXT (field)))
-    {
-      error ("member `%s' comes from base class needing constructor", member_name);
-      return 0;
-    }
-  return 1;
-}
-
-/* If NAME is a viable field name for the aggregate DECL,
-   and PARMS is a viable parameter list, then expand an _EXPR
-   which describes this initialization.
-
-   Note that we do not need to chase through the class's base classes
-   to look for NAME, because if it's in that list, it will be handled
-   by the constructor for that base class.
-
-   We do not yet have a fixed-point finder to instantiate types
-   being fed to overloaded constructors.  If there is a unique
-   constructor, then argument types can be got from that one.
-
-   If INIT is non-NULL, then it the initialization should
-   be placed in `current_base_init_list', where it will be processed
-   by `emit_base_init'.  */
-void
-expand_member_init (exp, name, init)
-     tree exp, name, init;
-{
-  extern tree ptr_type_node;	/* should be in tree.h */
-
-  tree basetype = NULL_TREE, field;
-  tree parm;
-  tree rval, type;
-  tree actual_name;
-
-  if (exp == NULL_TREE)
-    return;			/* complain about this later */
-
-  type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
-
-  if (name == NULL_TREE && IS_AGGR_TYPE (type))
-    switch (CLASSTYPE_N_BASECLASSES (type))
-      {
-      case 0:
-	error ("base class initializer specified, but no base class to initialize");
-	return;
-      case 1:
-	basetype = TYPE_BINFO_BASETYPE (type, 0);
-	break;
-      default:
-	error ("initializer for unnamed base class ambiguous");
-	error_with_aggr_type (type, "(type `%s' uses multiple inheritance)");
-	return;
-      }
-
-  if (init)
-    {
-      /* The grammar should not allow fields which have names
-	 that are TYPENAMEs.  Therefore, if the field has
-	 a non-NULL TREE_TYPE, we may assume that this is an
-	 attempt to initialize a base class member of the current
-	 type.  Otherwise, it is an attempt to initialize a
-	 member field.  */
-
-      if (init == void_type_node)
-	init = NULL_TREE;
-
-      if (name == NULL_TREE || IDENTIFIER_HAS_TYPE_VALUE (name))
-	{
-	  tree base_init;
-
-	  if (name == NULL_TREE)
-	    if (basetype)
-	      name = TYPE_IDENTIFIER (basetype);
-	    else
-	      {
-		error ("no base class to initialize");
-		return;
-	      }
-	  else
-	    {
-	      basetype = IDENTIFIER_TYPE_VALUE (name);
-	      if (basetype != type
-		  && ! binfo_member (basetype, TYPE_BINFO (type))
-		  && ! binfo_member (basetype, CLASSTYPE_VBASECLASSES (type)))
-		{
-		  if (IDENTIFIER_CLASS_VALUE (name))
-		    goto try_member;
-		  if (TYPE_USES_VIRTUAL_BASECLASSES (type))
-		    error ("type `%s' is not an immediate or virtual basetype for `%s'",
-			   IDENTIFIER_POINTER (name),
-			   TYPE_NAME_STRING (type));
-		  else
-		    error ("type `%s' is not an immediate basetype for `%s'",
-			   IDENTIFIER_POINTER (name),
-			   TYPE_NAME_STRING (type));
-		  return;
-		}
-	    }
-
-	  if (purpose_member (name, current_base_init_list))
-	    {
-	      error ("base class `%s' already initialized",
-		     IDENTIFIER_POINTER (name));
-	      return;
-	    }
-
-	  base_init = build_tree_list (name, init);
-	  TREE_TYPE (base_init) = basetype;
-	  current_base_init_list = chainon (current_base_init_list, base_init);
-	}
-      else
-	{
-	  tree member_init;
-
-	try_member:
-	  field = lookup_field (type, name, 1, 0);
-
-	  if (! member_init_ok_or_else (field, type, IDENTIFIER_POINTER (name)))
-	    return;
-
-	  if (purpose_member (name, current_member_init_list))
-	    {
-	      error ("field `%s' already initialized", IDENTIFIER_POINTER (name));
-	      return;
-	    }
-
-	  member_init = build_tree_list (name, init);
-	  TREE_TYPE (member_init) = TREE_TYPE (field);
-	  current_member_init_list = chainon (current_member_init_list, member_init);
-	}
-      return;
-    }
-  else if (name == NULL_TREE)
-    {
-      compiler_error ("expand_member_init: name == NULL_TREE");
-      return;
-    }
-
-  basetype = type;
-  field = lookup_field (basetype, name, 0, 0);
-
-  if (! member_init_ok_or_else (field, basetype, IDENTIFIER_POINTER (name)))
-    return;
-
-  /* now see if there is a constructor for this type
-     which will take these args. */
-
-  if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (field)))
-    {
-      tree parmtypes, fndecl;
-
-      if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
-	{
-	  /* just know that we've seen something for this node */
-	  DECL_INITIAL (exp) = error_mark_node;
-	  TREE_USED (exp) = 1;
-	}
-      type = TYPE_MAIN_VARIANT (TREE_TYPE (field));
-      actual_name = TYPE_IDENTIFIER (type);
-      parm = build_component_ref (exp, name, 0, 0);
-
-      /* Now get to the constructor.  */
-      fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0);
-      /* Get past destructor, if any.  */
-      if (TYPE_HAS_DESTRUCTOR (type))
-	fndecl = DECL_CHAIN (fndecl);
-
-      if (fndecl)
-	my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 209);
-
-      /* If the field is unique, we can use the parameter
-	 types to guide possible type instantiation.  */
-      if (DECL_CHAIN (fndecl) == NULL_TREE)
-	{
-	  /* There was a confusion here between
-	     FIELD and FNDECL.  The following code
-	     should be correct, but abort is here
-	     to make sure.  */
-	  my_friendly_abort (48);
-	  parmtypes = FUNCTION_ARG_CHAIN (fndecl);
-	}
-      else
-	{
-	  parmtypes = NULL_TREE;
-	  fndecl = NULL_TREE;
-	}
-
-      init = convert_arguments (parm, parmtypes, NULL_TREE, fndecl, LOOKUP_NORMAL);
-      if (init == NULL_TREE || TREE_TYPE (init) != error_mark_node)
-	rval = build_method_call (NULL_TREE, actual_name, init, NULL_TREE, LOOKUP_NORMAL);
-      else
-	return;
-
-      if (rval != error_mark_node)
-	{
-	  /* Now, fill in the first parm with our guy */
-	  TREE_VALUE (TREE_OPERAND (rval, 1))
-	    = build_unary_op (ADDR_EXPR, parm, 0);
-	  TREE_TYPE (rval) = ptr_type_node;
-	  TREE_SIDE_EFFECTS (rval) = 1;
-	}
-    }
-  else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
-    {
-      parm = build_component_ref (exp, name, 0, 0);
-      expand_aggr_init (parm, NULL_TREE, 0);
-      rval = error_mark_node;
-    }
-
-  /* Now initialize the member.  It does not have to
-     be of aggregate type to receive initialization.  */
-  if (rval != error_mark_node)
-    expand_expr_stmt (rval);
-}
-
-/* This is like `expand_member_init', only it stores one aggregate
-   value into another.
-
-   INIT comes in two flavors: it is either a value which
-   is to be stored in EXP, or it is a parameter list
-   to go to a constructor, which will operate on EXP.
-   If `init' is a CONSTRUCTOR, then we emit a warning message,
-   explaining that such initializations are illegal.
-
-   ALIAS_THIS is nonzero iff we are initializing something which is
-   essentially an alias for C_C_D.  In this case, the base constructor
-   may move it on us, and we must keep track of such deviations.
-
-   If INIT resolves to a CALL_EXPR which happens to return
-   something of the type we are looking for, then we know
-   that we can safely use that call to perform the
-   initialization.
-
-   The virtual function table pointer cannot be set up here, because
-   we do not really know its type.
-
-   Virtual baseclass pointers are also set up here.
-
-   This never calls operator=().
-
-   When initializing, nothing is CONST.
-
-   A default copy constructor may have to be used to perform the
-   initialization.
-
-   A constructor or a conversion operator may have to be used to
-   perform the initialization, but not both, as it would be ambiguous.
-   */
-
-void
-expand_aggr_init (exp, init, alias_this)
-     tree exp, init;
-     int alias_this;
-{
-  tree type = TREE_TYPE (exp);
-  int was_const = TREE_READONLY (exp);
-
-  if (init == error_mark_node)
-    return;
-
-  TREE_READONLY (exp) = 0;
-
-  if (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      /* Must arrange to initialize each element of EXP
-	 from elements of INIT.  */
-      int was_const_elts = TYPE_READONLY (TREE_TYPE (type));
-      tree itype = init ? TREE_TYPE (init) : NULL_TREE;
-      if (was_const_elts)
-	{
-	  tree atype = build_cplus_array_type (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
-					       TYPE_DOMAIN (type));
-	  if (init && (TREE_TYPE (exp) == TREE_TYPE (init)))
-	    TREE_TYPE (init) = atype;
-	  TREE_TYPE (exp) = atype;
-	}
-      expand_vec_init (exp, exp, array_type_nelts (type), init,
-		       init && comptypes (TREE_TYPE (init), TREE_TYPE (exp), 1));
-      TREE_READONLY (exp) = was_const;
-      TREE_TYPE (exp) = type;
-      if (init) TREE_TYPE (init) = itype;
-      return;
-    }
-
-  if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
-    /* just know that we've seen something for this node */
-    TREE_USED (exp) = 1;
-
-  /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
-     constructor as parameters to an implicit GNU C++ constructor.  */
-  if (init && TREE_CODE (init) == CONSTRUCTOR
-      && TYPE_HAS_CONSTRUCTOR (type)
-      && TREE_TYPE (init) == type)
-    init = CONSTRUCTOR_ELTS (init);
-  expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
-		      init, alias_this, LOOKUP_NORMAL);
-  TREE_READONLY (exp) = was_const;
-}
-
-static void
-expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags)
-     tree binfo;
-     tree true_exp, exp;
-     tree type;
-     tree init;
-     int alias_this;
-     int flags;
-{
-  /* It fails because there may not be a constructor which takes
-     its own type as the first (or only parameter), but which does
-     take other types via a conversion.  So, if the thing initializing
-     the expression is a unit element of type X, first try X(X&),
-     followed by initialization by X.  If neither of these work
-     out, then look hard.  */
-  tree rval;
-  tree parms;
-  int xxref_init_possible;
-
-  if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
-    {
-      parms = init;
-      if (parms) init = TREE_VALUE (parms);
-    }
-  else if (TREE_CODE (init) == INDIRECT_REF && TREE_HAS_CONSTRUCTOR (init))
-    {
-      rval = convert_for_initialization (exp, type, init, 0, 0, 0, 0);
-      expand_expr_stmt (rval);
-      return;
-    }
-  else parms = build_tree_list (NULL_TREE, init);
-
-  if (TYPE_HAS_INIT_REF (type)
-      || init == NULL_TREE
-      || TREE_CHAIN (parms) != NULL_TREE)
-    xxref_init_possible = 0;
-  else
-    {
-      xxref_init_possible = LOOKUP_SPECULATIVELY;
-      flags &= ~LOOKUP_COMPLAIN;
-    }
-
-  if (TYPE_USES_VIRTUAL_BASECLASSES (type))
-    {
-      if (true_exp == exp)
-	parms = tree_cons (NULL_TREE, integer_one_node, parms);
-      else
-	parms = tree_cons (NULL_TREE, integer_zero_node, parms);
-      flags |= LOOKUP_HAS_IN_CHARGE;
-    }
-
-  rval = build_method_call (exp, constructor_name (type),
-			    parms, binfo, flags|xxref_init_possible);
-  if (rval == NULL_TREE && xxref_init_possible)
-    {
-      /* It is an error to implement a default copy constructor if
-	 (see ARM 12.8 for details) ... one case being if another
-	 copy constructor already exists. */
-      tree init_type = TREE_TYPE (init);
-      if (TREE_CODE (init_type) == REFERENCE_TYPE)
-	init_type = TREE_TYPE (init_type);
-      if (TYPE_MAIN_VARIANT (init_type) == TYPE_MAIN_VARIANT (type)
-	  || (IS_AGGR_TYPE (init_type)
-	      && UNIQUELY_DERIVED_FROM_P (type, init_type)))
-	{
-	  if (type == BINFO_TYPE (binfo)
-	      && TYPE_USES_VIRTUAL_BASECLASSES (type))
-	    {
-	      tree addr = build_unary_op (ADDR_EXPR, exp, 0);
-	      expand_aggr_vbase_init (binfo, exp, addr, NULL_TREE);
-
-	      expand_expr_stmt (build_vbase_vtables_init (binfo, binfo,
-							  exp, addr, 1));
-	    }
-	  expand_expr_stmt (build_modify_expr (exp, INIT_EXPR, init));
-	  return;
-	}
-      else
-	rval = build_method_call (exp, constructor_name (type), parms,
-				  binfo, flags);
-    }
-
-  /* Private, protected, or otherwise unavailable.  */
-  if (rval == error_mark_node && (flags&LOOKUP_COMPLAIN))
-    error_with_aggr_type (binfo, "in base initialization for class `%s'");
-  /* A valid initialization using constructor.  */
-  else if (rval != error_mark_node && rval != NULL_TREE)
-    {
-      /* p. 222: if the base class assigns to `this', then that
-	 value is used in the derived class.  */
-      if ((flag_this_is_variable & 1) && alias_this)
-	{
-	  TREE_TYPE (rval) = TREE_TYPE (current_class_decl);
-	  expand_assignment (current_class_decl, rval, 0, 0);
-	}
-      else
-	expand_expr_stmt (rval);
-    }
-  else if (parms && TREE_CHAIN (parms) == NULL_TREE)
-    {
-      /* If we are initializing one aggregate value
-	 from another, and though there are constructors,
-	 and none accept the initializer, just do a bitwise
-	 copy.
-
-	 The above sounds wrong, ``If a class has any copy
-	 constructor defined, the default copy constructor will
-	 not be generated.'' 12.8 Copying Class Objects  (mrs)
-
-	 @@ This should reject initializer which a constructor
-	 @@ rejected on visibility gounds, but there is
-	 @@ no way right now to recognize that case with
-	 @@ just `error_mark_node'.  */
-      tree itype;
-      init = TREE_VALUE (parms);
-      itype = TREE_TYPE (init);
-      if (TREE_CODE (itype) == REFERENCE_TYPE)
-	{
-	  init = convert_from_reference (init);
-	  itype = TREE_TYPE (init);
-	}
-      itype = TYPE_MAIN_VARIANT (itype);
-
-      /* This is currently how the default X(X&) constructor
-	 is implemented.  */
-      if (comptypes (TYPE_MAIN_VARIANT (type), itype, 0))
-	{
-#if 0
-	  warning ("bitwise copy in initialization of type `%s'",
-		   TYPE_NAME_STRING (type));
-#endif
-	  rval = build (INIT_EXPR, type, exp, init);
-	  expand_expr_stmt (rval);
-	}
-      else
-	{
-	  error_with_aggr_type (binfo, "in base initialization for class `%s',");
-	  error_with_aggr_type (type, "invalid initializer to constructor for type `%s'");
-	  return;
-	}
-    }
-  else
-    {
-      if (init == NULL_TREE)
-	my_friendly_assert (parms == NULL_TREE, 210);
-      if (parms == NULL_TREE && TREE_VIA_VIRTUAL (binfo))
-	error_with_aggr_type (binfo, "virtual baseclass `%s' does not have default initializer");
-      else
-	{
-	  error_with_aggr_type (binfo, "in base initialization for class `%s',");
-	  /* This will make an error message for us.  */
-	  build_method_call (exp, constructor_name (type), parms, binfo,
-			     (TYPE_USES_VIRTUAL_BASECLASSES (type)
-			      ? LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE
-			      : LOOKUP_NORMAL));
-	}
-      return;
-    }
-  /* Constructor has been called, but vtables may be for TYPE
-     rather than for FOR_TYPE.  */
-}
-
-/* This function is responsible for initializing EXP with INIT
-   (if any).
-
-   BINFO is the binfo of the type for who we are performing the
-   initialization.  For example, if W is a virtual base class of A and B,
-   and C : A, B.
-   If we are initializing B, then W must contain B's W vtable, whereas
-   were we initializing C, W must contain C's W vtable.
-
-   TRUE_EXP is nonzero if it is the true expression being initialized.
-   In this case, it may be EXP, or may just contain EXP.  The reason we
-   need this is because if EXP is a base element of TRUE_EXP, we
-   don't necessarily know by looking at EXP where its virtual
-   baseclass fields should really be pointing.  But we do know
-   from TRUE_EXP.  In constructors, we don't know anything about
-   the value being initialized.
-
-   ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
-
-   FLAGS is just passes to `build_method_call'.  See that function for
-   its description.  */
-
-static void
-expand_aggr_init_1 (binfo, true_exp, exp, init, alias_this, flags)
-     tree binfo;
-     tree true_exp, exp;
-     tree init;
-     int alias_this;
-     int flags;
-{
-  tree type = TREE_TYPE (exp);
-  tree init_type = NULL_TREE;
-  tree rval;
-
-  my_friendly_assert (init != error_mark_node && type != error_mark_node, 211);
-
-  /* Use a function returning the desired type to initialize EXP for us.
-     If the function is a constructor, and its first argument is
-     NULL_TREE, know that it was meant for us--just slide exp on
-     in and expand the constructor.  Constructors now come
-     as TARGET_EXPRs.  */
-  if (init)
-    {
-      tree init_list = NULL_TREE;
-
-      if (TREE_CODE (init) == TREE_LIST)
-	{
-	  init_list = init;
-	  if (TREE_CHAIN (init) == NULL_TREE)
-	    init = TREE_VALUE (init);
-	}
-
-      init_type = TREE_TYPE (init);
-
-      if (TREE_CODE (init) != TREE_LIST)
-	{
-	  if (TREE_CODE (init_type) == ERROR_MARK)
-	    return;
-
-#if 0
-	  /* These lines are found troublesome 5/11/89.  */
-	  if (TREE_CODE (init_type) == REFERENCE_TYPE)
-	    init_type = TREE_TYPE (init_type);
-#endif
-
-	  /* This happens when we use C++'s functional cast notation.
-	     If the types match, then just use the TARGET_EXPR
-	     directly.  Otherwise, we need to create the initializer
-	     separately from the object being initialized.  */
-	  if (TREE_CODE (init) == TARGET_EXPR)
-	    {
-	      if (init_type == type)
-		{
-		  if (TREE_CODE (exp) == VAR_DECL
-		      || TREE_CODE (exp) == RESULT_DECL)
-		    /* Unify the initialization targets.  */
-		    DECL_RTL (TREE_OPERAND (init, 0)) = DECL_RTL (exp);
-		  else
-		    DECL_RTL (TREE_OPERAND (init, 0)) = expand_expr (exp, NULL_RTX, 0, 0);
-
-		  expand_expr_stmt (init);
-		  return;
-		}
-	      else
-		{
-		  init = TREE_OPERAND (init, 1);
-		  init = build (CALL_EXPR, init_type,
-				TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), 0);
-		  TREE_SIDE_EFFECTS (init) = 1;
-#if 0
-		  TREE_RAISES (init) = ??
-#endif
-		    if (init_list)
-		      TREE_VALUE (init_list) = init;
-		}
-	    }
-
-	  if (init_type == type && TREE_CODE (init) == CALL_EXPR
-#if 0
-	      /* It is legal to directly initialize from a CALL_EXPR
-		 without going through X(X&), apparently.  */
-	      && ! TYPE_GETS_INIT_REF (type)
-#endif
-	      )
-	    {
-	      /* A CALL_EXPR is a legitimate form of initialization, so
-		 we should not print this warning message.  */
-#if 0
-	      /* Should have gone away due to 5/11/89 change.  */
-	      if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
-		init = convert_from_reference (init);
-#endif
-	      expand_assignment (exp, init, 0, 0);
-	      if (exp == DECL_RESULT (current_function_decl))
-		{
-		  /* Failing this assertion means that the return value
-		     from receives multiple initializations.  */
-		  my_friendly_assert (DECL_INITIAL (exp) == NULL_TREE
-				      || DECL_INITIAL (exp) == error_mark_node,
-				      212);
-		  DECL_INITIAL (exp) = init;
-		}
-	      return;
-	    }
-	  else if (init_type == type
-		   && TREE_CODE (init) == COND_EXPR)
-	    {
-	      /* Push value to be initialized into the cond, where possible.
-	         Avoid spurious warning messages when initializing the
-		 result of this function.  */
-	      TREE_OPERAND (init, 1)
-		= build_modify_expr (exp, INIT_EXPR, TREE_OPERAND (init, 1));
-	      if (exp == DECL_RESULT (current_function_decl))
-		DECL_INITIAL (exp) = NULL_TREE;
-	      TREE_OPERAND (init, 2)
-		= build_modify_expr (exp, INIT_EXPR, TREE_OPERAND (init, 2));
-	      if (exp == DECL_RESULT (current_function_decl))
-		DECL_INITIAL (exp) = init;
-	      expand_expr (init, const0_rtx, VOIDmode, 0);
-	      free_temp_slots ();
-	      return;
-	    }
-	}
-
-      /* We did not know what we were initializing before.  Now we do.  */
-      if (TREE_CODE (init) == TARGET_EXPR)
-	{
-	  tree tmp = TREE_OPERAND (TREE_OPERAND (init, 1), 1);
-
-	  if (TREE_CODE (TREE_VALUE (tmp)) == NOP_EXPR
-	      && TREE_OPERAND (TREE_VALUE (tmp), 0) == integer_zero_node)
-	    {
-	      /* In order for this to work for RESULT_DECLs, if their
-		 type has a constructor, then they must be BLKmode
-		 so that they will be meaningfully addressable.  */
-	      tree arg = build_unary_op (ADDR_EXPR, exp, 0);
-	      init = TREE_OPERAND (init, 1);
-	      init = build (CALL_EXPR, build_pointer_type (TREE_TYPE (init)),
-			    TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), 0);
-	      TREE_SIDE_EFFECTS (init) = 1;
-#if 0
-	      TREE_RAISES (init) = ??
-#endif
-	      TREE_VALUE (TREE_OPERAND (init, 1))
-		= convert_pointer_to (TREE_TYPE (TREE_TYPE (TREE_VALUE (tmp))), arg);
-
-	      if (alias_this)
-		{
-		  expand_assignment (current_function_decl, init, 0, 0);
-		  return;
-		}
-	      if (exp == DECL_RESULT (current_function_decl))
-		{
-		  if (DECL_INITIAL (DECL_RESULT (current_function_decl)))
-		    fatal ("return value from function receives multiple initializations");
-		  DECL_INITIAL (exp) = init;
-		}
-	      expand_expr_stmt (init);
-	      return;
-	    }
-	}
-
-      /* Handle this case: when calling a constructor: xyzzy foo(bar);
-	 which really means:  xyzzy foo = bar; Ugh!
-
-	 We can also be called with an initializer for an object
-	 which has virtual functions, but no constructors.  In that
-	 case, we perform the assignment first, then initialize
-	 the virtual function table pointer fields.  */
-
-      if (! TYPE_NEEDS_CONSTRUCTING (type))
-	{
-	  if (init_list && TREE_CHAIN (init_list))
-	    {
-	      warning ("initializer list being treated as compound expression");
-	      init = convert (TREE_TYPE (exp), build_compound_expr (init_list));
-	      if (init == error_mark_node)
-		return;
-	    }
-	  if (TREE_CODE (exp) == VAR_DECL
-	      && TREE_CODE (init) == CONSTRUCTOR
-	      && TREE_HAS_CONSTRUCTOR (init)
-	      && flag_pic == 0)
-	    store_init_value (exp, init);
-	  else
-	    expand_assignment (exp, init, 0, 0);
-
-	  if (TYPE_VIRTUAL_P (type))
-	    expand_recursive_init (binfo, true_exp, exp, init, CLASSTYPE_BASE_INIT_LIST (type), alias_this);
-	  return;
-	}
-
-      /* See whether we can go through a type conversion operator.
-	 This wins over going through a non-existent constructor.  If
-	 there is a constructor, it is ambiguous.  */
-      if (TREE_CODE (init) != TREE_LIST)
-	{
-	  tree ttype = TREE_CODE (init_type) == REFERENCE_TYPE
-	    ? TREE_TYPE (init_type) : init_type;
-
-	  if (ttype != type && IS_AGGR_TYPE (ttype))
-	    {
-	      tree rval = build_type_conversion (CONVERT_EXPR, type, init, 0);
-
-	      if (rval)
-		{
-		  /* See if there is a constructor for``type'' that takes a
-		     ``ttype''-typed object. */
-		  tree parms = build_tree_list (NULL_TREE, init);
-		  tree as_cons = NULL_TREE;
-		  if (TYPE_HAS_CONSTRUCTOR (type))
-		    as_cons = build_method_call (exp, constructor_name (type),
-						 parms, binfo,
-						 LOOKUP_SPECULATIVELY|LOOKUP_NO_CONVERSION);
-		  if (as_cons != NULL_TREE && as_cons != error_mark_node)
-		    {
-		      tree name = TYPE_NAME (type);
-		      if (TREE_CODE (name) == TYPE_DECL)
-			name = DECL_NAME (name);
-		      /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
-		      error ("ambiguity between conversion to `%s' and constructor",
-			     IDENTIFIER_POINTER (name));
-		    }
-		  else
-		    expand_assignment (exp, rval, 0, 0);
-		  return;
-		}
-	    }
-	}
-    }
-
-  /* Handle default copy constructors here, does not matter if there is
-     a constructor or not.  */
-  if (type == init_type && IS_AGGR_TYPE (type)
-      && init && TREE_CODE (init) != TREE_LIST)
-    expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags);
-  /* Not sure why this is here... */
-  else if (TYPE_HAS_CONSTRUCTOR (type))
-    expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags);
-  else if (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
-	expand_vec_init (exp, exp, array_type_nelts (type), init, 0);
-      else if (TYPE_VIRTUAL_P (TREE_TYPE (type)))
-	sorry ("arrays of objects with virtual functions but no constructors");
-    }
-  else
-    expand_recursive_init (binfo, true_exp, exp, init,
-			   CLASSTYPE_BASE_INIT_LIST (type), alias_this);
-}
-
-/* A pointer which holds the initializer.  First call to
-   expand_aggr_init gets this value pointed to, and sets it to init_null.  */
-static tree *init_ptr, init_null;
-
-/* Subroutine of expand_recursive_init:
-
-   ADDR is the address of the expression being initialized.
-   INIT_LIST is the cons-list of initializations to be performed.
-   ALIAS_THIS is its same, lovable self.  */
-static void
-expand_recursive_init_1 (binfo, true_exp, addr, init_list, alias_this)
-     tree binfo, true_exp, addr;
-     tree init_list;
-     int alias_this;
-{
-  while (init_list)
-    {
-      if (TREE_PURPOSE (init_list))
-	{
-	  if (TREE_CODE (TREE_PURPOSE (init_list)) == FIELD_DECL)
-	    {
-	      tree member = TREE_PURPOSE (init_list);
-	      tree subexp = build_indirect_ref (convert_pointer_to (TREE_VALUE (init_list), addr), 0);
-	      tree member_base = build (COMPONENT_REF, TREE_TYPE (member), subexp, member);
-	      if (IS_AGGR_TYPE (TREE_TYPE (member)))
-		expand_aggr_init (member_base, DECL_INITIAL (member), 0);
-	      else if (TREE_CODE (TREE_TYPE (member)) == ARRAY_TYPE
-		       && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (member)))
-		{
-		  member_base = save_expr (default_conversion (member_base));
-		  expand_vec_init (member, member_base,
-				   array_type_nelts (TREE_TYPE (member)),
-				   DECL_INITIAL (member), 0);
-		}
-	      else expand_expr_stmt (build_modify_expr (member_base, INIT_EXPR, DECL_INITIAL (member)));
-	    }
-	  else if (TREE_CODE (TREE_PURPOSE (init_list)) == TREE_LIST)
-	    {
-	      expand_recursive_init_1 (binfo, true_exp, addr, TREE_PURPOSE (init_list), alias_this);
-	      expand_recursive_init_1 (binfo, true_exp, addr, TREE_VALUE (init_list), alias_this);
-	    }
-	  else if (TREE_CODE (TREE_PURPOSE (init_list)) == ERROR_MARK)
-	    {
-	      /* Only initialize the virtual function tables if we
-		 are initializing the ultimate users of those vtables.  */
-	      if (TREE_VALUE (init_list))
-		{
-		  /* We have to ensure that the second argment to
-		     build_virtual_init is in binfo's hierarchy.  */
-		  expand_expr_stmt (build_virtual_init (binfo,
-							get_binfo (TREE_VALUE (init_list), binfo, 0),
-							addr));
-		  if (TREE_VALUE (init_list) == binfo
-		      && TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
-		    expand_expr_stmt (build_vbase_vtables_init (binfo, binfo, true_exp, addr, 1));
-		}
-	    }
-	  else my_friendly_abort (49);
-	}
-      else if (TREE_VALUE (init_list)
-	       && TREE_CODE (TREE_VALUE (init_list)) == TREE_VEC)
-	{
-	  tree subexp = build_indirect_ref (convert_pointer_to (TREE_VALUE (init_list), addr), 0);
-	  expand_aggr_init_1 (binfo, true_exp, subexp, *init_ptr,
-			      alias_this && BINFO_OFFSET_ZEROP (TREE_VALUE (init_list)),
-			      LOOKUP_PROTECTED_OK|LOOKUP_COMPLAIN);
-
-	  /* INIT_PTR is used up.  */
-	  init_ptr = &init_null;
-	}
-      else
-	my_friendly_abort (50);
-      init_list = TREE_CHAIN (init_list);
-    }
-}
-
-/* Initialize EXP with INIT.  Type EXP does not have a constructor,
-   but it has a baseclass with a constructor or a virtual function
-   table which needs initializing.
-
-   INIT_LIST is a cons-list describing what parts of EXP actually
-   need to be initialized.  INIT is given to the *unique*, first
-   constructor within INIT_LIST.  If there are multiple first
-   constructors, such as with multiple inheritance, INIT must
-   be zero or an ambiguity error is reported.
-
-   ALIAS_THIS is passed from `expand_aggr_init'.  See comments
-   there.  */
-
-static void
-expand_recursive_init (binfo, true_exp, exp, init, init_list, alias_this)
-     tree binfo, true_exp, exp, init;
-     tree init_list;
-     int alias_this;
-{
-  tree *old_init_ptr = init_ptr;
-  tree addr = build_unary_op (ADDR_EXPR, exp, 0);
-  init_ptr = &init;
-
-  if (true_exp == exp && TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
-    {
-      expand_aggr_vbase_init (binfo, exp, addr, init_list);
-      expand_expr_stmt (build_vbase_vtables_init (binfo, binfo, true_exp, addr, 1));
-    }
-  expand_recursive_init_1 (binfo, true_exp, addr, init_list, alias_this);
-
-  if (*init_ptr)
-    {
-      tree type = TREE_TYPE (exp);
-
-      if (TREE_CODE (type) == REFERENCE_TYPE)
-	type = TREE_TYPE (type);
-      if (IS_AGGR_TYPE (type))
-	error_with_aggr_type (type, "unexpected argument to constructor `%s'");
-      else
-	error ("unexpected argument to constructor");
-    }
-  init_ptr = old_init_ptr;
-}
-
-/* Report an error if NAME is not the name of a user-defined,
-   aggregate type.  If OR_ELSE is nonzero, give an error message.  */
-int
-is_aggr_typedef (name, or_else)
-     tree name;
-     int or_else;
-{
-  tree type;
-
-  if (name == error_mark_node)
-    return 0;
-
-  if (! IDENTIFIER_HAS_TYPE_VALUE (name))
-    {
-      if (or_else)
-	error ("`%s' fails to be an aggregate typedef",
-	       IDENTIFIER_POINTER (name));
-      return 0;
-    }
-  type = IDENTIFIER_TYPE_VALUE (name);
-  if (! IS_AGGR_TYPE (type))
-    {
-      if (or_else)
-	error ("type `%s' is of non-aggregate type",
-	       IDENTIFIER_POINTER (name));
-      return 0;
-    }
-  return 1;
-}
-
-/* This code could just as well go in `cp-class.c', but is placed here for
-   modularity.  */
-
-/* For an expression of the form CNAME :: NAME (PARMLIST), build
-   the appropriate function call.  */
-tree
-build_member_call (cname, name, parmlist)
-     tree cname, name, parmlist;
-{
-  tree type, t;
-  tree method_name = name;
-  int dtor = 0;
-  int dont_use_this = 0;
-  tree basetype_path, decl;
-
-  if (TREE_CODE (method_name) == BIT_NOT_EXPR)
-    {
-      method_name = TREE_OPERAND (method_name, 0);
-      dtor = 1;
-    }
-
-  if (TREE_CODE (cname) == SCOPE_REF)
-    cname = resolve_scope_to_name (NULL_TREE, cname);
-
-  if (cname == NULL_TREE || ! is_aggr_typedef (cname, 1))
-    return error_mark_node;
-
-  /* An operator we did not like.  */
-  if (name == NULL_TREE)
-    return error_mark_node;
-
-  if (dtor)
-    {
-      if (! TYPE_HAS_DESTRUCTOR (IDENTIFIER_TYPE_VALUE (cname)))
-	error ("type `%s' does not have a destructor",
-	       IDENTIFIER_POINTER (cname));
-      else
-	error ("destructor specification error");
-      return error_mark_node;
-    }
-
-  type = IDENTIFIER_TYPE_VALUE (cname);
-
-  /* No object?  Then just fake one up, and let build_method_call
-     figure out what to do.  */
-  if (current_class_type == 0
-      || get_base_distance (type, current_class_type, 0, &basetype_path) == -1)
-    dont_use_this = 1;
-
-  if (dont_use_this)
-    {
-      basetype_path = NULL_TREE;
-      decl = build1 (NOP_EXPR, TYPE_POINTER_TO (type), error_mark_node);
-    }
-  else if (current_class_decl == 0)
-    {
-      dont_use_this = 1;
-      decl = build1 (NOP_EXPR, TYPE_POINTER_TO (type), error_mark_node);
-    }
-  else
-    {
-      decl = current_class_decl;
-      if (TREE_TYPE (decl) != type)
-	decl = convert (TYPE_POINTER_TO (type), decl);
-    }
-
-  if (t = lookup_fnfields (TYPE_BINFO (type), method_name, 0))
-    return build_method_call (decl, method_name, parmlist, basetype_path,
-			      LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
-  if (TREE_CODE (name) == IDENTIFIER_NODE
-      && (t = lookup_field (TYPE_BINFO (type), name, 1, 0)))
-    {
-      if (t == error_mark_node)
-	return error_mark_node;
-      if (TREE_CODE (t) == FIELD_DECL)
-	{
-	  if (dont_use_this)
-	    {
-	      error ("invalid use of non-static field `%s'",
-		     IDENTIFIER_POINTER (name));
-	      return error_mark_node;
-	    }
-	  decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t);
-	}
-      else if (TREE_CODE (t) == VAR_DECL)
-	decl = t;
-      else
-	{
-	  error ("invalid use of member `%s::%s'",
-		 IDENTIFIER_POINTER (cname), name);
-	  return error_mark_node;
-	}
-      if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl))
-	  && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (decl)))
-	return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl, parmlist, NULL_TREE);
-      return build_function_call (decl, parmlist);
-    }
-  else
-    {
-      char *err_name;
-      if (TREE_CODE (name) == IDENTIFIER_NODE)
-	{
-	  if (IDENTIFIER_OPNAME_P (name))
-	    {
-	      char *op_name = operator_name_string (method_name);
-	      err_name = (char *)alloca (13 + strlen (op_name));
-	      sprintf (err_name, "operator %s", op_name);
-	    }
-	  else
-	    err_name = IDENTIFIER_POINTER (name);
-	}
-      else
-	my_friendly_abort (51);
-
-      error ("no method `%s::%s'", IDENTIFIER_POINTER (cname), err_name);
-      return error_mark_node;
-    }
-}
-
-/* Build a reference to a member of an aggregate.  This is not a
-   C++ `&', but really something which can have its address taken,
-   and then act as a pointer to member, for example CNAME :: FIELD
-   can have its address taken by saying & CNAME :: FIELD.
-
-   @@ Prints out lousy diagnostics for operator <typename>
-   @@ fields.
-
-   @@ This function should be rewritten and placed in cp-search.c.  */
-tree
-build_offset_ref (cname, name)
-     tree cname, name;
-{
-  tree decl, type, fnfields, fields, t = error_mark_node;
-  tree basetypes = NULL_TREE;
-  int dtor = 0;
-
-  if (TREE_CODE (cname) == SCOPE_REF)
-    cname = resolve_scope_to_name (NULL_TREE, cname);
-
-  if (cname == NULL_TREE || ! is_aggr_typedef (cname, 1))
-    return error_mark_node;
-
-  type = IDENTIFIER_TYPE_VALUE (cname);
-
-  if (TREE_CODE (name) == BIT_NOT_EXPR)
-    {
-      dtor = 1;
-      name = TREE_OPERAND (name, 0);
-    }
-
-  if (TYPE_SIZE (type) == 0)
-    {
-      t = IDENTIFIER_CLASS_VALUE (name);
-      if (t == 0)
-	{
-	  error_with_aggr_type (type, "incomplete type `%s' does not have member `%s'", IDENTIFIER_POINTER (name));
-	  return error_mark_node;
-	}
-      if (TREE_CODE (t) == TYPE_DECL)
-	{
-	  error_with_decl (t, "member `%s' is just a type declaration");
-	  return error_mark_node;
-	}
-      if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL)
-	{
-	  TREE_USED (t) = 1;
-	  return t;
-	}
-      if (TREE_CODE (t) == FIELD_DECL)
-	sorry ("use of member in incomplete aggregate type");
-      else if (TREE_CODE (t) == FUNCTION_DECL)
-	sorry ("use of member function in incomplete aggregate type");
-      else
-	my_friendly_abort (52);
-      return error_mark_node;
-    }
-
-  if (TREE_CODE (name) == TYPE_EXPR)
-    /* Pass a TYPE_DECL to build_component_type_expr.  */
-    return build_component_type_expr (TYPE_NAME (TREE_TYPE (cname)),
-				      name, NULL_TREE, 1);
-
-  fnfields = lookup_fnfields (TYPE_BINFO (type), name, 1);
-  fields = lookup_field (type, name, 0, 0);
-
-  if (fields == error_mark_node || fnfields == error_mark_node)
-    return error_mark_node;
-
-  if (current_class_type == 0
-      || get_base_distance (type, current_class_type, 0, &basetypes) == -1)
-    {
-      basetypes = TYPE_BINFO (type);
-      decl = build1 (NOP_EXPR,
-		     IDENTIFIER_TYPE_VALUE (cname),
-		     error_mark_node);
-    }
-  else if (current_class_decl == 0)
-    decl = build1 (NOP_EXPR, IDENTIFIER_TYPE_VALUE (cname),
-		   error_mark_node);
-  else decl = C_C_D;
-
-  /* A lot of this logic is now handled in lookup_field and
-     lookup_fnfield. */
-  if (fnfields)
-    {
-      basetypes = TREE_PURPOSE (fnfields);
-
-      /* Go from the TREE_BASELINK to the member function info.  */
-      t = TREE_VALUE (fnfields);
-
-      if (fields)
-	{
-	  if (DECL_FIELD_CONTEXT (fields) == DECL_FIELD_CONTEXT (t))
-	    {
-	      error ("ambiguous member reference: member `%s' defined as both field and function",
-		     IDENTIFIER_POINTER (name));
-	      return error_mark_node;
-	    }
-	  if (UNIQUELY_DERIVED_FROM_P (DECL_FIELD_CONTEXT (fields), DECL_FIELD_CONTEXT (t)))
-	    ;
-	  else if (UNIQUELY_DERIVED_FROM_P (DECL_FIELD_CONTEXT (t), DECL_FIELD_CONTEXT (fields)))
-	    t = fields;
-	  else
-	    {
-	      error ("ambiguous member reference: member `%s' derives from distinct classes in multiple inheritance lattice");
-	      return error_mark_node;
-	    }
-	}
-
-      if (t == TREE_VALUE (fnfields))
-	{
-	  extern int flag_save_memoized_contexts;
-
-	  /* This does not handle visibility checking yet.  */
-	  if (DECL_CHAIN (t) == NULL_TREE || dtor)
-	    {
-	      enum visibility_type visibility;
-
-	      /* unique functions are handled easily.  */
-	    unique:
-	      visibility = compute_visibility (basetypes, t);
-	      if (visibility == visibility_protected)
-		{
-		  error_with_decl (t, "member function `%s' is protected");
-		  error ("in this context");
-		  return error_mark_node;
-		}
-	      if (visibility == visibility_private)
-		{
-		  error_with_decl (t, "member function `%s' is private");
-		  error ("in this context");
-		  return error_mark_node;
-		}
-	      assemble_external (t);
-	      return build (OFFSET_REF, TREE_TYPE (t), decl, t);
-	    }
-
-	  /* overloaded functions may need more work.  */
-	  if (cname == name)
-	    {
-	      if (TYPE_HAS_DESTRUCTOR (type)
-		  && DECL_CHAIN (DECL_CHAIN (t)) == NULL_TREE)
-		{
-		  t = DECL_CHAIN (t);
-		  goto unique;
-		}
-	    }
-	  /* FNFIELDS is most likely allocated on the search_obstack,
-	     which will go away after this class scope.  If we need
-	     to save this value for later (either for memoization
-	     or for use as an initializer for a static variable), then
-	     do so here.
-
-	     ??? The smart thing to do for the case of saving initializers
-	     is to resolve them before we're done with this scope.  */
-	  if (!TREE_PERMANENT (fnfields)
-	      && ((flag_save_memoized_contexts && global_bindings_p ())
-		  || ! allocation_temporary_p ()))
-	    fnfields = copy_list (fnfields);
-	  t = build_tree_list (error_mark_node, fnfields);
-	  TREE_TYPE (t) = build_offset_type (type, unknown_type_node);
-	  return t;
-	}
-    }
-
-  /* Now that we know we are looking for a field, see if we
-     have access to that field.  Lookup_field will give us the
-     error message.  */
-
-  t = lookup_field (basetypes, name, 1, 0);
-
-  if (t == error_mark_node)
-    return error_mark_node;
-
-  if (t == NULL_TREE)
-    {
-      char *print_name, *non_operator = "<";
-
-      if (name == ansi_opname[(int) TYPE_EXPR])
-	{
-	  error ("type conversion operator not a member of type `%s'",
-		 IDENTIFIER_POINTER (cname));
-	  return error_mark_node;
-	}
-
-      if ((IDENTIFIER_POINTER (name))[0] == '_'
-	  && (IDENTIFIER_POINTER (name))[1] == '_')
-	print_name = operator_name_string (name);
-      else
-	print_name = non_operator;
-
-      /* First character of "<invalid operator>".  */
-      if (print_name[0] == '<')
-	error ("field `%s' is not a member of type `%s'",
-	       IDENTIFIER_POINTER (name),
-	       IDENTIFIER_POINTER (cname));
-      else
-	error ("operator `%s' is not a member of type `%s'",
-	       print_name, IDENTIFIER_POINTER (cname));
-      return error_mark_node;
-    }
-
-  if (TREE_CODE (t) == TYPE_DECL)
-    {
-      error_with_decl (t, "member `%s' is just a type declaration");
-      return error_mark_node;
-    }
-  /* static class members and class-specific enum
-     values can be returned without further ado.  */
-  if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL)
-    {
-      assemble_external (t);
-      TREE_USED (t) = 1;
-      return t;
-    }
-
-  /* static class functions too.  */
-  if (TREE_CODE (t) == FUNCTION_DECL && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
-    my_friendly_abort (53);
-
-  /* In member functions, the form `cname::name' is no longer
-     equivalent to `this->cname::name'.  */
-  return build (OFFSET_REF, build_offset_type (type, TREE_TYPE (t)), decl, t);
-}
-
-/* Given an object EXP and a member function reference MEMBER,
-   return the address of the actual member function.  */
-tree
-get_member_function (exp_addr_ptr, exp, member)
-     tree *exp_addr_ptr;
-     tree exp, member;
-{
-  tree ctype = TREE_TYPE (exp);
-  tree function = save_expr (build_unary_op (ADDR_EXPR, member, 0));
-
-  if (TYPE_VIRTUAL_P (ctype)
-      || (flag_all_virtual == 1 && TYPE_OVERLOADS_METHOD_CALL_EXPR (ctype)))
-    {
-      tree e0, e1, e3;
-      tree exp_addr;
-
-      /* Save away the unadulterated `this' pointer.  */
-      exp_addr = save_expr (*exp_addr_ptr);
-
-      /* Cast function to signed integer.  */
-      e0 = build1 (NOP_EXPR, integer_type_node, function);
-
-#ifdef VTABLE_USES_MASK
-      /* If we are willing to limit the number of
-	 virtual functions a class may have to some
-	 *small* number, then if, for a function address,
-	 we are passed some small number, we know that
-	 it is a virtual function index, and work from there.  */
-      e1 = build (BIT_AND_EXPR, integer_type_node, e0, vtbl_mask);
-#else
-      /* There is a hack here that takes advantage of
-	 twos complement arithmetic, and the fact that
-	 there are more than one UNITS to the WORD.
-	 If the high bit is set for the `function',
-	 then we pretend it is a virtual function,
-	 and the array indexing will knock this bit
-	 out the top, leaving a valid index.  */
-      if (UNITS_PER_WORD <= 1)
-	my_friendly_abort (54);
-
-      e1 = build (GT_EXPR, integer_type_node, e0, integer_zero_node);
-      e1 = build_compound_expr (tree_cons (NULL_TREE, exp_addr,
-					   build_tree_list (NULL_TREE, e1)));
-      e1 = save_expr (e1);
-#endif
-
-      if (TREE_SIDE_EFFECTS (*exp_addr_ptr))
-	{
-	  exp = build_indirect_ref (exp_addr, 0);
-	  *exp_addr_ptr = exp_addr;
-	}
-
-      /* This is really hairy: if the function pointer is a pointer
-	 to a non-virtual member function, then we can't go mucking
-	 with the `this' pointer (any more than we already have to
-	 this point).  If it is a pointer to a virtual member function,
-	 then we have to adjust the `this' pointer according to
-	 what the virtual function table tells us.  */
-
-      e3 = build_vfn_ref (exp_addr_ptr, exp, e0);
-      my_friendly_assert (e3 != error_mark_node, 213);
-
-      /* Change this pointer type from `void *' to the
-	 type it is really supposed to be.  */
-      TREE_TYPE (e3) = TREE_TYPE (function);
-
-      /* If non-virtual, use what we had originally.  Otherwise,
-	 use the value we get from the virtual function table.  */
-      *exp_addr_ptr = build_conditional_expr (e1, exp_addr, *exp_addr_ptr);
-
-      function = build_conditional_expr (e1, function, e3);
-    }
-  return build_indirect_ref (function, 0);
-}
-
-/* If a OFFSET_REF made it through to here, then it did
-   not have its address taken.  */
-
-tree
-resolve_offset_ref (exp)
-     tree exp;
-{
-  tree type = TREE_TYPE (exp);
-  tree base = NULL_TREE;
-  tree member;
-  tree basetype, addr;
-
-  if (TREE_CODE (exp) == TREE_LIST)
-    return build_unary_op (ADDR_EXPR, exp, 0);
-
-  if (TREE_CODE (exp) != OFFSET_REF)
-    {
-      my_friendly_assert (TREE_CODE (type) == OFFSET_TYPE, 214);
-      if (TYPE_OFFSET_BASETYPE (type) != current_class_type)
-	{
-	  error ("object missing in use of pointer-to-member construct");
-	  return error_mark_node;
-	}
-      member = exp;
-      type = TREE_TYPE (type);
-      base = C_C_D;
-    }
-  else
-    {
-      member = TREE_OPERAND (exp, 1);
-      base = TREE_OPERAND (exp, 0);
-    }
-
-  if (TREE_CODE (member) == VAR_DECL
-      || TREE_CODE (TREE_TYPE (member)) == FUNCTION_TYPE)
-    {
-      /* These were static members.  */
-      if (mark_addressable (member) == 0)
-	return error_mark_node;
-      return member;
-    }
-
-  /* Syntax error can cause a member which should
-     have been seen as static to be grok'd as non-static.  */
-  if (TREE_CODE (member) == FIELD_DECL && C_C_D == NULL_TREE)
-    {
-      if (TREE_ADDRESSABLE (member) == 0)
-	{
-	  error_with_decl (member, "member `%s' is non-static in static member function context");
-	  error ("at this point in file");
-	  TREE_ADDRESSABLE (member) = 1;
-	}
-      return error_mark_node;
-    }
-
-  /* The first case is really just a reference to a member of `this'.  */
-  if (TREE_CODE (member) == FIELD_DECL
-      && (base == C_C_D
-	  || (TREE_CODE (base) == NOP_EXPR
-	      && TREE_OPERAND (base, 0) == error_mark_node)))
-    {
-      tree basetype_path;
-      enum visibility_type visibility;
-
-      basetype = DECL_CONTEXT (member);
-      if (get_base_distance (basetype, current_class_type, 0, &basetype_path) < 0)
-	{
-	  error_not_base_type (basetype, current_class_type);
-	  return error_mark_node;
-	}
-      addr = convert_pointer_to (basetype, current_class_decl);
-      visibility = compute_visibility (basetype_path, member);
-      if (visibility == visibility_public)
-	return build (COMPONENT_REF, TREE_TYPE (member),
-		      build_indirect_ref (addr, 0), member);
-      if (visibility == visibility_protected)
-	{
-	  error_with_decl (member, "member `%s' is protected");
-	  error ("in this context");
-	  return error_mark_node;
-	}
-      if (visibility == visibility_private)
-	{
-	  error_with_decl (member, "member `%s' is private");
-	  error ("in this context");
-	  return error_mark_node;
-	}
-      my_friendly_abort (55);
-    }
-
-  /* If this is a reference to a member function, then return
-     the address of the member function (which may involve going
-     through the object's vtable), otherwise, return an expression
-     for the dereferenced pointer-to-member construct.  */
-  addr = build_unary_op (ADDR_EXPR, base, 0);
-
-  if (TREE_CODE (TREE_TYPE (member)) == METHOD_TYPE)
-    {
-      basetype = DECL_CLASS_CONTEXT (member);
-      addr = convert_pointer_to (basetype, addr);
-      return build_unary_op (ADDR_EXPR, get_member_function (&addr, build_indirect_ref (addr, 0), member), 0);
-    }
-  else if (TREE_CODE (TREE_TYPE (member)) == OFFSET_TYPE)
-    {
-      basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (member));
-      addr = convert_pointer_to (basetype, addr);
-      member = convert (ptr_type_node, build_unary_op (ADDR_EXPR, member, 0));
-      return build1 (INDIRECT_REF, type,
-		     build (PLUS_EXPR, ptr_type_node, addr, member));
-    }
-  my_friendly_abort (56);
-  /* NOTREACHED */
-  return NULL_TREE;
-}
-
-/* Return either DECL or its known constant value (if it has one).  */
-
-tree
-decl_constant_value (decl)
-     tree decl;
-{
-  if (! TREE_THIS_VOLATILE (decl)
-#if 0
-      /* These may be necessary for C, but they break C++.  */
-      ! TREE_PUBLIC (decl)
-      /* Don't change a variable array bound or initial value to a constant
-	 in a place where a variable is invalid.  */
-      && ! pedantic
-#endif /* 0 */
-      && DECL_INITIAL (decl) != 0
-      && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
-      /* This is invalid if initial value is not constant.
-	 If it has either a function call, a memory reference,
-	 or a variable, then re-evaluating it could give different results.  */
-      && TREE_CONSTANT (DECL_INITIAL (decl))
-      /* Check for cases where this is sub-optimal, even though valid.  */
-      && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
-#if 0
-      /* We must allow this to work outside of functions so that
-	 static constants can be used for array sizes.  */
-      && current_function_decl != 0
-      && DECL_MODE (decl) != BLKmode
-#endif
-      )
-    return DECL_INITIAL (decl);
-  return decl;
-}
-
-/* Friend handling routines.  */
-/* Friend data structures:
-
-   Friend lists come from TYPE_DECL nodes.  Since all aggregate
-   types are automatically typedef'd, these node are guaranteed
-   to exist.
-
-   The TREE_PURPOSE of a friend list is the name of the friend,
-   and its TREE_VALUE is another list.
-
-   The TREE_PURPOSE of that list is a type, which allows
-   all functions of a given type to be friends.
-   The TREE_VALUE of that list is an individual function
-   which is a friend.
-
-   Non-member friends will match only by their DECL.  Their
-   member type is NULL_TREE, while the type of the inner
-   list will either be of aggregate type or error_mark_node.  */
-
-/* Tell if this function specified by DECL
-   can be a friend of type TYPE.
-   Return nonzero if friend, zero otherwise.
-
-   DECL can be zero if we are calling a constructor or accessing a
-   member in global scope.  */
-int
-is_friend (type, decl)
-     tree type, decl;
-{
-  tree typedecl = TYPE_NAME (type);
-  tree ctype;
-  tree list;
-  tree name;
-
-  if (decl == NULL_TREE)
-    return 0;
-
-  ctype = DECL_CLASS_CONTEXT (decl);
-  if (ctype)
-    {
-      list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (typedecl));
-      while (list)
-	{
-	  if (ctype == TREE_VALUE (list))
-	    return 1;
-	  list = TREE_CHAIN (list);
-	}
-    }
-
-  list = DECL_FRIENDLIST (typedecl);
-  name = DECL_NAME (decl);
-  while (list)
-    {
-      if (name == TREE_PURPOSE (list))
-	{
-	  tree friends = TREE_VALUE (list);
-	  name = DECL_ASSEMBLER_NAME (decl);
-	  while (friends)
-	    {
-	      if (ctype == TREE_PURPOSE (friends))
-		return 1;
-	      if (name == DECL_ASSEMBLER_NAME (TREE_VALUE (friends)))
-		return 1;
-	      friends = TREE_CHAIN (friends);
-	    }
-	  return 0;
-	}
-      list = TREE_CHAIN (list);
-    }
-  return 0;
-}
-
-/* Add a new friend to the friends of the aggregate type TYPE.
-   DECL is the FUNCTION_DECL of the friend being added.  */
-static void
-add_friend (type, decl)
-     tree type, decl;
-{
-  tree typedecl = TYPE_NAME (type);
-  tree list = DECL_FRIENDLIST (typedecl);
-  tree name = DECL_NAME (decl);
-  tree ctype = TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
-    ? DECL_CLASS_CONTEXT (decl) : error_mark_node;
-
-  while (list)
-    {
-      if (name == TREE_PURPOSE (list))
-	{
-	  tree friends = TREE_VALUE (list);
-	  while (friends)
-	    {
-	      if (decl == TREE_VALUE (friends))
-		{
-		  warning_with_decl (decl, "`%s' is already a friend of class `%s'", IDENTIFIER_POINTER (DECL_NAME (typedecl)));
-		  return;
-		}
-	      friends = TREE_CHAIN (friends);
-	    }
-	  TREE_VALUE (list) = tree_cons (ctype, decl, TREE_VALUE (list));
-	  return;
-	}
-      list = TREE_CHAIN (list);
-    }
-  DECL_FRIENDLIST (typedecl)
-    = tree_cons (DECL_NAME (decl), build_tree_list (error_mark_node, decl),
-		 DECL_FRIENDLIST (typedecl));
-  if (DECL_NAME (decl) == ansi_opname[(int) MODIFY_EXPR])
-    {
-      tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
-      TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
-      TYPE_GETS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
-      if (parmtypes && TREE_CHAIN (parmtypes))
-	{
-	  tree parmtype = TREE_VALUE (TREE_CHAIN (parmtypes));
-	  if (TREE_CODE (parmtype) == REFERENCE_TYPE
-	      && TREE_TYPE (parmtypes) == TREE_TYPE (typedecl))
-	    {
-	      TYPE_HAS_ASSIGN_REF (TREE_TYPE (typedecl)) = 1;
-	      TYPE_GETS_ASSIGN_REF (TREE_TYPE (typedecl)) = 1;
-	    }
-	}
-    }
-}
-
-/* Declare that every member function NAME in FRIEND_TYPE
-   (which may be NULL_TREE) is a friend of type TYPE.  */
-static void
-add_friends (type, name, friend_type)
-     tree type, name, friend_type;
-{
-  tree typedecl = TYPE_NAME (type);
-  tree list = DECL_FRIENDLIST (typedecl);
-
-  while (list)
-    {
-      if (name == TREE_PURPOSE (list))
-	{
-	  tree friends = TREE_VALUE (list);
-	  while (friends && TREE_PURPOSE (friends) != friend_type)
-	    friends = TREE_CHAIN (friends);
-	  if (friends)
-	    if (friend_type)
-	      warning ("method `%s::%s' is already a friend of class",
-		       TYPE_NAME_STRING (friend_type),
-		       IDENTIFIER_POINTER (name));
-	    else
-	      warning ("function `%s' is already a friend of class `%s'",
-		       IDENTIFIER_POINTER (name),
-		       IDENTIFIER_POINTER (DECL_NAME (typedecl)));
-	  else
-	    TREE_VALUE (list) = tree_cons (friend_type, NULL_TREE,
-					   TREE_VALUE (list));
-	  return;
-	}
-      list = TREE_CHAIN (list);
-    }
-  DECL_FRIENDLIST (typedecl) =
-    tree_cons (name,
-	       build_tree_list (friend_type, NULL_TREE),
-	       DECL_FRIENDLIST (typedecl));
-  if (! strncmp (IDENTIFIER_POINTER (name),
-		 IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR]),
-		 strlen (IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR]))))
-    {
-      TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
-      TYPE_GETS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
-      sorry ("declaring \"friend operator =\" will not find \"operator = (X&)\" if it exists");
-    }
-}
-
-/* Set up a cross reference so that type TYPE will
-   make member function CTYPE::DECL a friend when CTYPE
-   is finally defined.  */
-void
-xref_friend (type, decl, ctype)
-     tree type, decl, ctype;
-{
-  tree typedecl = TYPE_NAME (type);
-  tree friend_decl = TYPE_NAME (ctype);
-  tree t = tree_cons (NULL_TREE, ctype, DECL_UNDEFINED_FRIENDS (typedecl));
-
-  DECL_UNDEFINED_FRIENDS (typedecl) = t;
-  SET_DECL_WAITING_FRIENDS (friend_decl, tree_cons (type, t, DECL_WAITING_FRIENDS (friend_decl)));
-  TREE_TYPE (DECL_WAITING_FRIENDS (friend_decl)) = decl;
-}
-
-/* Set up a cross reference so that functions with name NAME and
-   type CTYPE know that they are friends of TYPE.  */
-void
-xref_friends (type, name, ctype)
-     tree type, name, ctype;
-{
-  tree typedecl = TYPE_NAME (type);
-  tree friend_decl = TYPE_NAME (ctype);
-  tree t = tree_cons (NULL_TREE, ctype,
-		      DECL_UNDEFINED_FRIENDS (typedecl));
-
-  DECL_UNDEFINED_FRIENDS (typedecl) = t;
-  SET_DECL_WAITING_FRIENDS (friend_decl, tree_cons (type, t, DECL_WAITING_FRIENDS (friend_decl)));
-  TREE_TYPE (DECL_WAITING_FRIENDS (friend_decl)) = name;
-}
-
-/* Make FRIEND_TYPE a friend class to TYPE.  If FRIEND_TYPE has already
-   been defined, we make all of its member functions friends of
-   TYPE.  If not, we make it a pending friend, which can later be added
-   when its definition is seen.  If a type is defined, then its TYPE_DECL's
-   DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
-   classes that are not defined.  If a type has not yet been defined,
-   then the DECL_WAITING_FRIENDS contains a list of types
-   waiting to make it their friend.  Note that these two can both
-   be in use at the same time!  */
-void
-make_friend_class (type, friend_type)
-     tree type, friend_type;
-{
-  tree classes;
-
-  if (type == friend_type)
-    {
-      warning ("class `%s' is implicitly friends with itself",
-	       TYPE_NAME_STRING (type));
-      return;
-    }
-
-  GNU_xref_hier (TYPE_NAME_STRING (type),
-		 TYPE_NAME_STRING (friend_type), 0, 0, 1);
-
-  classes = CLASSTYPE_FRIEND_CLASSES (type);
-  while (classes && TREE_VALUE (classes) != friend_type)
-    classes = TREE_CHAIN (classes);
-  if (classes)
-    warning ("class `%s' is already friends with class `%s'",
-	     TYPE_NAME_STRING (TREE_VALUE (classes)), TYPE_NAME_STRING (type));
-  else
-    {
-      CLASSTYPE_FRIEND_CLASSES (type)
-	= tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
-    }
-}
-
-/* Main friend processor.  This is large, and for modularity purposes,
-   has been removed from grokdeclarator.  It returns `void_type_node'
-   to indicate that something happened, though a FIELD_DECL is
-   not returned.
-
-   CTYPE is the class this friend belongs to.
-
-   DECLARATOR is the name of the friend.
-
-   DECL is the FUNCTION_DECL that the friend is.
-
-   In case we are parsing a friend which is part of an inline
-   definition, we will need to store PARM_DECL chain that comes
-   with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
-
-   FLAGS is just used for `grokclassfn'.
-
-   QUALS say what special qualifies should apply to the object
-   pointed to by `this'.  */
-tree
-do_friend (ctype, declarator, decl, parmdecls, flags, quals)
-     tree ctype, declarator, decl, parmdecls;
-     enum overload_flags flags;
-     tree quals;
-{
-  /* first, lets find out if what we are making a friend needs overloading */
-  tree previous_decl;
-  int was_c_linkage = 0;
-  /* if we find something in scope, let see if it has extern "C" linkage */
-  /* This code is pretty general and should be ripped out and reused
-     as a separate function. */
-  if (DECL_NAME (decl))
-    {
-      previous_decl=lookup_name (DECL_NAME (decl), 0);
-      if (previous_decl && TREE_CODE (previous_decl) == TREE_LIST)
-	{
-	  do
-	    {
-	      if (TREE_TYPE (TREE_VALUE (previous_decl)) == TREE_TYPE (decl))
-		{
-		  previous_decl = TREE_VALUE (previous_decl);
-		  break;
-		}
-	      previous_decl = TREE_CHAIN (previous_decl);
-	    }
-	  while (previous_decl);
-	}
-      if (previous_decl && TREE_CODE (previous_decl) == FUNCTION_DECL)
-	if (TREE_TYPE (decl) == TREE_TYPE (previous_decl))
-	    if (DECL_LANGUAGE (previous_decl) == lang_c)
-	    {
-	      /* it did, so lets not overload this */
-	      was_c_linkage = 1;
-	    }
-    }
-	  
-  if (ctype)
-    {
-      tree cname = TYPE_NAME (ctype);
-      if (TREE_CODE (cname) == TYPE_DECL)
-	cname = DECL_NAME (cname);
-
-      /* A method friend.  */
-      if (TREE_CODE (decl) == FUNCTION_DECL)
-	{
-	  if (flags == NO_SPECIAL && ctype && declarator == cname)
-	    DECL_CONSTRUCTOR_P (decl) = 1;
-
-	  /* This will set up DECL_ARGUMENTS for us.  */
-	  grokclassfn (ctype, cname, decl, flags, quals);
-	  if (TYPE_SIZE (ctype) != 0)
-	    check_classfn (ctype, cname, decl);
-
-	  if (TREE_TYPE (decl) != error_mark_node)
-	    {
-	      if (TYPE_SIZE (ctype))
-		{
-		  /* We don't call pushdecl here yet, or ever on this
-		     actual FUNCTION_DECL.  We must preserve its TREE_CHAIN
-		     until the end.  */
-		  make_decl_rtl (decl, NULL_PTR, 1);
-		  add_friend (current_class_type, decl);
-		}
-	      else
-		xref_friend (current_class_type, decl, ctype);
-	      DECL_FRIEND_P (decl) = 1;
-	    }
-	}
-      else
-	{
-	  /* Possibly a bunch of method friends.  */
-
-	  /* Get the class they belong to.  */
-	  tree ctype = IDENTIFIER_TYPE_VALUE (cname);
-
-	  /* This class is defined, use its methods now.  */
-	  if (TYPE_SIZE (ctype))
-	    {
-	      tree fields = lookup_fnfields (TYPE_BINFO (ctype), declarator, 0);
-	      if (fields)
-		add_friends (current_class_type, declarator, ctype);
-	      else
-		error ("method `%s' is not a member of class `%s'",
-		       IDENTIFIER_POINTER (declarator),
-		       IDENTIFIER_POINTER (cname));
-	    }
-	  else
-	    xref_friends (current_class_type, declarator, ctype);
-	  decl = void_type_node;
-	}
-    }
-  /* never overload C functions */
-  else if (TREE_CODE (decl) == FUNCTION_DECL
-	   && ((IDENTIFIER_LENGTH (declarator) == 4
-		&& IDENTIFIER_POINTER (declarator)[0] == 'm'
-		&& ! strcmp (IDENTIFIER_POINTER (declarator), "main"))
-	       || (IDENTIFIER_LENGTH (declarator) > 10
-		   && IDENTIFIER_POINTER (declarator)[0] == '_'
-		   && IDENTIFIER_POINTER (declarator)[1] == '_'
-		   && strncmp (IDENTIFIER_POINTER (declarator)+2,
-			       "builtin_", 8) == 0)
-	       || was_c_linkage))
-    {
-      /* raw "main", and builtin functions never gets overloaded,
-	 but they can become friends.  */
-      TREE_PUBLIC (decl) = 1;
-      add_friend (current_class_type, decl);
-      DECL_FRIEND_P (decl) = 1;
-      if (IDENTIFIER_POINTER (declarator)[0] == '_')
-	{
-	  if (! strcmp (IDENTIFIER_POINTER (declarator)+10, "new"))
-	    TREE_GETS_NEW (current_class_type) = 0;
-	  else if (! strcmp (IDENTIFIER_POINTER (declarator)+10, "delete"))
-	    TREE_GETS_DELETE (current_class_type) = 0;
-	}
-      decl = void_type_node;
-    }
-  /* A global friend.
-     @@ or possibly a friend from a base class ?!?  */
-  else if (TREE_CODE (decl) == FUNCTION_DECL)
-    {
-      /* Friends must all go through the overload machinery,
-	 even though they may not technically be overloaded.
-
-	 Note that because classes all wind up being top-level
-	 in their scope, their friend wind up in top-level scope as well.  */
-      DECL_ASSEMBLER_NAME (decl)
-	= build_decl_overload (declarator, TYPE_ARG_TYPES (TREE_TYPE (decl)),
-			       TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
-      DECL_ARGUMENTS (decl) = parmdecls;
-
-      /* We can call pushdecl here, because the TREE_CHAIN of this
-	 FUNCTION_DECL is not needed for other purposes.  */
-      decl = pushdecl_top_level (decl);
-
-      make_decl_rtl (decl, NULL_PTR, 1);
-      add_friend (current_class_type, decl);
-
-      if (! TREE_OVERLOADED (declarator)
-	  && IDENTIFIER_GLOBAL_VALUE (declarator)
-	  && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (declarator)) == FUNCTION_DECL)
-	{
-	  error ("friend `%s' implicitly overloaded",
-		 IDENTIFIER_POINTER (declarator));
-	  error_with_decl (IDENTIFIER_GLOBAL_VALUE (declarator),
-			   "after declaration of non-overloaded `%s'");
-	}
-      DECL_FRIEND_P (decl) = 1;
-      DECL_OVERLOADED (decl) = 1;
-      TREE_OVERLOADED (declarator) = 1;
-      decl = push_overloaded_decl (decl, 1);
-    }
-  else
-    {
-      /* @@ Should be able to ingest later definitions of this function
-	 before use.  */
-      tree decl = IDENTIFIER_GLOBAL_VALUE (declarator);
-      if (decl == NULL_TREE)
-	{
-	  warning ("implicitly declaring `%s' as struct",
-		   IDENTIFIER_POINTER (declarator));
-	  decl = xref_tag (record_type_node, declarator, NULL_TREE);
-	  decl = TYPE_NAME (decl);
-	}
-
-      /* Allow abbreviated declarations of overloaded functions,
-	 but not if those functions are really class names.  */
-      if (TREE_CODE (decl) == TREE_LIST && TREE_TYPE (TREE_PURPOSE (decl)))
-	{
-	  warning ("`friend %s' archaic, use `friend class %s' instead",
-		   IDENTIFIER_POINTER (declarator),
-		   IDENTIFIER_POINTER (declarator));
-	  decl = TREE_TYPE (TREE_PURPOSE (decl));
-	}
-
-      if (TREE_CODE (decl) == TREE_LIST)
-	add_friends (current_class_type, TREE_PURPOSE (decl), NULL_TREE);
-      else
-	make_friend_class (current_class_type, TREE_TYPE (decl));
-      decl = void_type_node;
-    }
-  return decl;
-}
-
-/* TYPE has now been defined.  It may, however, have a number of things
-   waiting make make it their friend.  We resolve these references
-   here.  */
-void
-embrace_waiting_friends (type)
-     tree type;
-{
-  tree decl = TYPE_NAME (type);
-  tree waiters;
-
-  if (TREE_CODE (decl) != TYPE_DECL)
-    return;
-
-  for (waiters = DECL_WAITING_FRIENDS (decl); waiters;
-       waiters = TREE_CHAIN (waiters))
-    {
-      tree waiter = TREE_PURPOSE (waiters);
-      tree waiter_prev = TREE_VALUE (waiters);
-      tree decl = TREE_TYPE (waiters);
-      tree name = decl ? (TREE_CODE (decl) == IDENTIFIER_NODE
-			  ? decl : DECL_NAME (decl)) : NULL_TREE;
-      if (name)
-	{
-	  /* @@ There may be work to be done since we have not verified
-	     @@ consistency between original and friend declarations
-	     @@ of the functions waiting to become friends.  */
-	  tree field = lookup_fnfields (TYPE_BINFO (type), name, 0);
-	  if (field)
-	    if (decl == name)
-	      add_friends (waiter, name, type);
-	    else
-	      add_friend (waiter, decl);
-	  else
-	    error_with_file_and_line (DECL_SOURCE_FILE (TYPE_NAME (waiter)),
-				      DECL_SOURCE_LINE (TYPE_NAME (waiter)),
-				      "no method `%s' defined in class `%s' to be friend",
-				      IDENTIFIER_POINTER (DECL_NAME (TREE_TYPE (waiters))),
-				      TYPE_NAME_STRING (type));
-	}
-      else
-	make_friend_class (type, waiter);
-
-      if (TREE_CHAIN (waiter_prev))
-	TREE_CHAIN (waiter_prev) = TREE_CHAIN (TREE_CHAIN (waiter_prev));
-      else
-	DECL_UNDEFINED_FRIENDS (TYPE_NAME (waiter)) = NULL_TREE;
-    }
-}
-
-/* Common subroutines of build_new and build_vec_delete.  */
-
-/* Common interface for calling "builtin" functions that are not
-   really builtin.  */
-
-tree
-build_builtin_call (type, node, arglist)
-     tree type;
-     tree node;
-     tree arglist;
-{
-  tree rval = build (CALL_EXPR, type, node, arglist, 0);
-  TREE_SIDE_EFFECTS (rval) = 1;
-  assemble_external (TREE_OPERAND (node, 0));
-  TREE_USED (TREE_OPERAND (node, 0)) = 1;
-  return rval;
-}
-
-/* Generate a C++ "new" expression. DECL is either a TREE_LIST
-   (which needs to go through some sort of groktypename) or it
-   is the name of the class we are newing. INIT is an initialization value.
-   It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
-   If INIT is void_type_node, it means do *not* call a constructor
-   for this instance.
-
-   For types with constructors, the data returned is initialized
-   by the appropriate constructor.
-
-   Whether the type has a constructor or not, if it has a pointer
-   to a virtual function table, then that pointer is set up
-   here.
-
-   Unless I am mistaken, a call to new () will return initialized
-   data regardless of whether the constructor itself is private or
-   not.
-
-   Note that build_new does nothing to assure that any special
-   alignment requirements of the type are met.  Rather, it leaves
-   it up to malloc to do the right thing.  Otherwise, folding to
-   the right alignment cal cause problems if the user tries to later
-   free the memory returned by `new'.
-
-   PLACEMENT is the `placement' list for user-defined operator new ().  */
-
-tree
-build_new (placement, decl, init, use_global_new)
-     tree placement;
-     tree decl, init;
-     int use_global_new;
-{
-  tree type, true_type, size, rval;
-  tree init1 = NULL_TREE, nelts;
-  int has_call = 0, has_array = 0;
-
-  tree pending_sizes = NULL_TREE;
-
-  if (decl == error_mark_node)
-    return error_mark_node;
-
-  if (TREE_CODE (decl) == TREE_LIST)
-    {
-      tree absdcl = TREE_VALUE (decl);
-      tree last_absdcl = NULL_TREE;
-      int old_immediate_size_expand;
-
-      if (current_function_decl
-	  && DECL_CONSTRUCTOR_P (current_function_decl))
-	{
-	  old_immediate_size_expand = immediate_size_expand;
-	  immediate_size_expand = 0;
-	}
-
-      nelts = integer_one_node;
-
-      if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
-	{
-	  /* probably meant to be a call */
-	  has_call = 1;
-	  init1 = TREE_OPERAND (absdcl, 1);
-	  absdcl = TREE_OPERAND (absdcl, 0);
-	  TREE_VALUE (decl) = absdcl;
-	}
-      while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF)
-	{
-	  last_absdcl = absdcl;
-	  absdcl = TREE_OPERAND (absdcl, 0);
-	}
-
-      if (absdcl && TREE_CODE (absdcl) == ARRAY_REF)
-	{
-	  /* probably meant to be a vec new */
-	  tree this_nelts;
-
-	  has_array = 1;
-	  this_nelts = TREE_OPERAND (absdcl, 1);
-	  if (this_nelts != error_mark_node)
-	    {
-	      if (this_nelts == NULL_TREE)
-		error ("new of array type fails to specify size");
-	      else
-		{
-		  this_nelts = save_expr (this_nelts);
-		  absdcl = TREE_OPERAND (absdcl, 0);
-	          if (this_nelts == integer_zero_node)
-		    {
-		      warning ("zero size array reserves no space");
-		      nelts = integer_zero_node;
-		    }
-		  else
-		    nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1);
-		}
-	    }
-	  else
-	    nelts = integer_zero_node;
-	}
-
-      if (last_absdcl)
-	TREE_OPERAND (last_absdcl, 0) = absdcl;
-      else
-	TREE_VALUE (decl) = absdcl;
-
-      type = true_type = groktypename (decl);
-      if (! type || type == error_mark_node
-	  || true_type == error_mark_node)
-	return error_mark_node;
-
-      /* ``A reference cannot be created by the new operator.  A reference
-	 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
-	 returned by new.'' ARM 5.3.3 */
-      if (TREE_CODE (type) == REFERENCE_TYPE)
-	error ("new cannot be applied to a reference type");
-
-      type = TYPE_MAIN_VARIANT (type);
-      if (type == void_type_node)
-	{
-	  error ("invalid type: `void []'");
-	  return error_mark_node;
-	}
-      if (current_function_decl
-	  && DECL_CONSTRUCTOR_P (current_function_decl))
-	{
-	  pending_sizes = get_pending_sizes ();
-	  immediate_size_expand = old_immediate_size_expand;
-	}
-    }
-  else if (TREE_CODE (decl) == IDENTIFIER_NODE)
-    {
-      if (IDENTIFIER_HAS_TYPE_VALUE (decl))
-	{
-	  /* An aggregate type.  */
-	  type = IDENTIFIER_TYPE_VALUE (decl);
-	  decl = TYPE_NAME (type);
-	}
-      else
-	{
-	  /* A builtin type.  */
-	  decl = lookup_name (decl, 1);
-	  my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 215);
-	  type = TREE_TYPE (decl);
-	}
-      true_type = type;
-    }
-  else if (TREE_CODE (decl) == TYPE_DECL)
-    {
-      type = TREE_TYPE (decl);
-      true_type = type;
-    }
-  else
-    {
-      type = decl;
-      true_type = type;
-      decl = TYPE_NAME (type);
-    }
-
-  if (TYPE_SIZE (type) == 0)
-    {
-      if (type == void_type_node)
-	error ("invalid type for new: `void'");
-      else
-	incomplete_type_error (0, type);
-      return error_mark_node;
-    }
-
-  if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_ABSTRACT_VIRTUALS (type))
-    {
-      abstract_virtuals_error (NULL_TREE, type);
-      return error_mark_node;
-    }
-
-  /* If our base type is an array, then make sure we know how many elements
-     it has.  */
-  while (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      tree this_nelts = array_type_nelts_top (type);
-      if (nelts == integer_one_node)
-	{
-	  has_array = 1;
-	  nelts = this_nelts;
-	}
-      else
-	{
-	  my_friendly_assert (has_array != 0, 216);
-	  nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1);
-	}
-      type = TREE_TYPE (type);
-    }
-  if (has_array)
-    size = fold (build_binary_op (MULT_EXPR, size_in_bytes (type), nelts, 1));
-  else
-    size = size_in_bytes (type);
-
-  if (has_call)
-    init = init1;
-
-  /* Get to the target type of TRUE_TYPE, so we can decide whether
-     any constructors need to be called or not.  */
-  type = true_type;
-  while (TREE_CODE (type) == ARRAY_TYPE)
-    type = TREE_TYPE (type);
-
-  /* Get a little extra space to store a couple of things before the new'ed
-     array. */
-  if (has_array && TYPE_NEEDS_DESTRUCTOR (true_type))
-    {
-      tree extra = BI_header_size;
-
-      size = size_binop (PLUS_EXPR, size, extra);
-    }
-
-  /* Allocate the object. */
-  if (TYPE_LANG_SPECIFIC (true_type)
-      && (TREE_GETS_NEW (true_type) && !use_global_new))
-    rval = build_opfncall (NEW_EXPR, LOOKUP_NORMAL,
-			   TYPE_POINTER_TO (true_type), size, placement);
-  else if (placement)
-    {
-      rval = build_opfncall (NEW_EXPR, LOOKUP_GLOBAL|LOOKUP_COMPLAIN,
-			     ptr_type_node, size, placement);
-      rval = convert (TYPE_POINTER_TO (true_type), rval);
-    }
-  else if (flag_this_is_variable > 0
-	   && TYPE_HAS_CONSTRUCTOR (true_type) && init != void_type_node)
-    {
-      if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
-	rval = NULL_TREE;
-      else
-	{
-	  error ("constructors take parameter lists");
-	  return error_mark_node;
-	}
-    }
-  else
-    {
-      rval = build_builtin_call (build_pointer_type (true_type),
-				 BIN, build_tree_list (NULL_TREE, size));
-#if 0
-      /* See comment above as to why this is disabled.  */
-      if (alignment)
-	{
-	  rval = build (PLUS_EXPR, TYPE_POINTER_TO (true_type), rval,
-			alignment);
-	  rval = build (BIT_AND_EXPR, TYPE_POINTER_TO (true_type),
-			rval, build1 (BIT_NOT_EXPR, integer_type_node,
-				      alignment));
-	}
-#endif
-      TREE_CALLS_NEW (rval) = 1;
-      TREE_SIDE_EFFECTS (rval) = 1;
-    }
-
-  /* if rval is NULL_TREE I don't have to allocate it, but are we totally
-     sure we have some extra bytes in that case for the BI_header_size
-     cookies? And how does that interact with the code below? (mrs) */
-  /* Finish up some magic for new'ed arrays */
-  if (has_array && TYPE_NEEDS_DESTRUCTOR (true_type) && rval != NULL_TREE)
-    {
-      tree extra = BI_header_size;
-      tree cookie, exp1, exp2;
-      rval = convert (ptr_type_node, rval);    /* convert to void * first */
-      rval = convert (string_type_node, rval); /* lets not add void* and ints */
-      rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra, 1));
-      /* Store header info.  */
-      cookie = build_indirect_ref (build (MINUS_EXPR, TYPE_POINTER_TO (BI_header_type),
-					  rval, extra), 0);
-      exp1 = build (MODIFY_EXPR, void_type_node,
-		    build_component_ref (cookie, get_identifier ("nelts"), 0, 0),
-		    nelts);
-      TREE_SIDE_EFFECTS (exp1) = 1;
-      exp2 = build (MODIFY_EXPR, void_type_node,
-		    build_component_ref (cookie, get_identifier ("ptr_2comp"), 0, 0),
-		    build (MINUS_EXPR, ptr_type_node, integer_zero_node, rval));
-      TREE_SIDE_EFFECTS (exp2) = 1;
-      rval = convert (build_pointer_type (true_type), rval);
-      TREE_CALLS_NEW (rval) = 1;
-      TREE_SIDE_EFFECTS (rval) = 1;
-      rval = build_compound_expr (tree_cons (NULL_TREE, exp1,
-					     tree_cons (NULL_TREE, exp2,
-							build_tree_list (NULL_TREE, rval))));
-    }
-
-  /* We've figured out where the allocation is to go.
-     If we're not eliding constructors, then if a constructor
-     is defined, we must go through it.  */
-  if (!has_array && (rval == NULL_TREE || !flag_elide_constructors)
-      && TYPE_HAS_CONSTRUCTOR (true_type) && init != void_type_node)
-    {
-      tree newrval;
-      /* Constructors are never virtual.  */
-      int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL;
-      /* If a copy constructor might work, set things up so that we can
-	 try that after this. */
-      if (rval != NULL_TREE)
-	flags = ~LOOKUP_COMPLAIN & (flags|LOOKUP_SPECULATIVELY);
-      
-      if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
-	{
-	  init = tree_cons (NULL_TREE, integer_one_node, init);
-	  flags |= LOOKUP_HAS_IN_CHARGE;
-	}
-      newrval = build_method_call (rval, constructor_name (true_type),
-				init, NULL_TREE, flags);
-      if (newrval)
-	{
-	  rval = newrval;
-	  TREE_HAS_CONSTRUCTOR (rval) = 1;
-	  goto done;
-	}
-      /* Didn't find the constructor, maybe it is a call to a copy constructor
-	 that we should implement. */
-    }
-
-  if (rval == error_mark_node)
-    return error_mark_node;
-  rval = save_expr (rval);
-  TREE_HAS_CONSTRUCTOR (rval) = 1;
-
-  /* Don't call any constructors or do any initialization.  */
-  if (init == void_type_node)
-    goto done;
-
-  if (TYPE_NEEDS_CONSTRUCTING (type)
-      || (has_call || init))
-    {
-      extern tree static_aggregates;
-
-      if (current_function_decl == NULL_TREE)
-	{
-	  /* In case of static initialization, SAVE_EXPR is good enough.  */
-	  init = copy_to_permanent (init);
-	  rval = copy_to_permanent (rval);
-	  static_aggregates = perm_tree_cons (init, rval, static_aggregates);
-	}
-      else
-	{
-	  /* Have to wrap this in RTL_EXPR for two cases:
-	     in base or member initialization and if we
-	     are a branch of a ?: operator.  Since we
-	     can't easily know the latter, just do it always.  */
-	  tree xval = make_node (RTL_EXPR);
-
-	  TREE_TYPE (xval) = TREE_TYPE (rval);
-	  do_pending_stack_adjust ();
-	  start_sequence ();
-
-	  /* As a matter of principle, `start_sequence' should do this.  */
-	  emit_note (0, -1);
-
-	  if (has_array)
-	    rval = expand_vec_init (decl, rval,
-				    build_binary_op (MINUS_EXPR, nelts, integer_one_node, 1),
-				    init, 0);
-	  else
-	    expand_aggr_init (build_indirect_ref (rval, 0), init, 0);
-
-	  do_pending_stack_adjust ();
-
-	  TREE_SIDE_EFFECTS (xval) = 1;
-	  TREE_CALLS_NEW (xval) = 1;
-	  RTL_EXPR_SEQUENCE (xval) = get_insns ();
-	  end_sequence ();
-
-	  if (TREE_CODE (rval) == SAVE_EXPR)
-	    {
-	      /* Errors may cause this to not get evaluated.  */
-	      if (SAVE_EXPR_RTL (rval) == 0)
-		SAVE_EXPR_RTL (rval) = const0_rtx;
-	      RTL_EXPR_RTL (xval) = SAVE_EXPR_RTL (rval);
-	    }
-	  else
-	    {
-	      my_friendly_assert (TREE_CODE (rval) == VAR_DECL, 217);
-	      RTL_EXPR_RTL (xval) = DECL_RTL (rval);
-	    }
-	  rval = xval;
-	}
-    }
-#if 0
-  /* It would seem that the above code handles this better than the code
-     below. (mrs) */
-  else if (has_call || init)
-    {
-      if (IS_AGGR_TYPE (type))
-	{
-	  /*  default copy constructor may be missing from the below. (mrs) */
-	  error_with_aggr_type (type, "no constructor for type `%s'");
-	  rval = error_mark_node;
-	}
-      else
-	{
-	  /* New 2.0 interpretation: `new int (10)' means
-	     allocate an int, and initialize it with 10.  */
-
-	  init = build_c_cast (type, init);
-	  rval = build (COMPOUND_EXPR, TREE_TYPE (rval),
-			build_modify_expr (build_indirect_ref (rval, 0),
-					   NOP_EXPR, init),
-			rval);
-	  TREE_SIDE_EFFECTS (rval) = 1;
-	}
-    }
-#endif
- done:
-  if (pending_sizes)
-    rval = build_compound_expr (chainon (pending_sizes,
-					 build_tree_list (NULL_TREE, rval)));
-
-  if (flag_gc)
-    {
-      extern tree gc_visible;
-      tree objbits;
-      tree update_expr;
-
-      rval = save_expr (rval);
-      /* We don't need a `headof' operation to do this because
-	 we know where the object starts.  */
-      objbits = build1 (INDIRECT_REF, unsigned_type_node,
-			build (MINUS_EXPR, ptr_type_node,
-			       rval, c_sizeof_nowarn (unsigned_type_node)));
-      update_expr = build_modify_expr (objbits, BIT_IOR_EXPR, gc_visible);
-      rval = build_compound_expr (tree_cons (NULL_TREE, rval,
-					     tree_cons (NULL_TREE, update_expr,
-							build_tree_list (NULL_TREE, rval))));
-    }
-
-  return save_expr (rval);
-}
-
-/* `expand_vec_init' performs initialization of a vector of aggregate
-   types.
-
-   DECL is passed only for error reporting, and provides line number
-   and source file name information.
-   BASE is the space where the vector will be.
-   MAXINDEX is the maximum index of the array (one less than the
-	    number of elements).
-   INIT is the (possibly NULL) initializer.
-
-   FROM_ARRAY is 0 if we should init everything with INIT
-   (i.e., every element initialized from INIT).
-   FROM_ARRAY is 1 if we should index into INIT in parallel
-   with initialization of DECL.
-   FROM_ARRAY is 2 if we should index into INIT in parallel,
-   but use assignment instead of initialization.  */
-
-tree
-expand_vec_init (decl, base, maxindex, init, from_array)
-     tree decl, base, maxindex, init;
-     int from_array;
-{
-  tree rval;
-  tree iterator, base2 = NULL_TREE;
-  tree type = TREE_TYPE (TREE_TYPE (base));
-  tree size;
-
-  maxindex = convert (integer_type_node, maxindex);
-  if (maxindex == error_mark_node)
-    return error_mark_node;
-
-  if (current_function_decl == NULL_TREE)
-    {
-      rval = make_tree_vec (3);
-      TREE_VEC_ELT (rval, 0) = base;
-      TREE_VEC_ELT (rval, 1) = maxindex;
-      TREE_VEC_ELT (rval, 2) = init;
-      return rval;
-    }
-
-  size = size_in_bytes (type);
-
-  /* Set to zero in case size is <= 0.  Optimizer will delete this if
-     it is not needed.  */
-  rval = get_temp_regvar (TYPE_POINTER_TO (type), convert (TYPE_POINTER_TO (type),
-							   null_pointer_node));
-  base = default_conversion (base);
-  base = convert (TYPE_POINTER_TO (type), base);
-  expand_assignment (rval, base, 0, 0);
-  base = get_temp_regvar (TYPE_POINTER_TO (type), base);
-
-  if (init != NULL_TREE
-      && TREE_CODE (init) == CONSTRUCTOR
-      && TREE_TYPE (init) == TREE_TYPE (decl))
-    {
-      /* Initialization of array from {...}.  */
-      tree elts = CONSTRUCTOR_ELTS (init);
-      tree baseref = build1 (INDIRECT_REF, type, base);
-      tree baseinc = build (PLUS_EXPR, TYPE_POINTER_TO (type), base, size);
-      int host_i = TREE_INT_CST_LOW (maxindex);
-
-      if (IS_AGGR_TYPE (type))
-	{
-	  while (elts)
-	    {
-	      host_i -= 1;
-	      expand_aggr_init (baseref, TREE_VALUE (elts), 0);
-
-	      expand_assignment (base, baseinc, 0, 0);
-	      elts = TREE_CHAIN (elts);
-	    }
-	  /* Initialize any elements by default if possible.  */
-	  if (host_i >= 0)
-	    {
-	      if (TYPE_NEEDS_CONSTRUCTING (type) == 0)
-		{
-		  if (obey_regdecls)
-		    use_variable (DECL_RTL (base));
-		  goto done_init;
-		}
-
-	      iterator = get_temp_regvar (integer_type_node,
-					  build_int_2 (host_i, 0));
-	      init = NULL_TREE;
-	      goto init_by_default;
-	    }
-	}
-      else
-	while (elts)
-	  {
-	    expand_assignment (baseref, TREE_VALUE (elts), 0, 0);
-
-	    expand_assignment (base, baseinc, 0, 0);
-	    elts = TREE_CHAIN (elts);
-	  }
-
-      if (obey_regdecls)
-	use_variable (DECL_RTL (base));
-    }
-  else
-    {
-      iterator = get_temp_regvar (integer_type_node, maxindex);
-
-    init_by_default:
-
-      /* If initializing one array from another,
-	 initialize element by element.  */
-      if (from_array)
-	{
-	  if (decl == NULL_TREE
-	      || (init && !comptypes (TREE_TYPE (init), TREE_TYPE (decl), 1)))
-	    {
-	      sorry ("initialization of array from dissimilar array type");
-	      return error_mark_node;
-	    }
-	  if (init)
-	    {
-	      base2 = default_conversion (init);
-	      base2 = get_temp_regvar (TYPE_POINTER_TO (type), base2);
-	    }
-	  else if (TYPE_LANG_SPECIFIC (type)
-		   && TYPE_NEEDS_CONSTRUCTING (type)
-		   && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
-	    {
-	      error ("initializer ends prematurely");
-	      return error_mark_node;
-	    }
-	}
-
-      expand_start_cond (build (GE_EXPR, integer_type_node,
-				iterator, integer_zero_node), 0);
-      expand_start_loop_continue_elsewhere (1);
-
-      if (from_array)
-	{
-	  tree to = build1 (INDIRECT_REF, type, base);
-	  tree from;
-
-	  if (base2)
-	    from = build1 (INDIRECT_REF, type, base2);
-	  else
-	    from = NULL_TREE;
-
-	  if (from_array == 2)
-	    expand_expr_stmt (build_modify_expr (to, NOP_EXPR, from));
-	  else if (TYPE_NEEDS_CONSTRUCTING (type))
-	    expand_aggr_init (to, from, 0);
-	  else if (from)
-	    expand_assignment (to, from, 0, 0);
-	  else my_friendly_abort (57);
-	}
-      else if (TREE_CODE (type) == ARRAY_TYPE)
-	{
-	  if (init != 0)
-	    sorry ("cannot initialize multi-dimensional array with initializer");
-	  expand_vec_init (decl, build1 (NOP_EXPR, TYPE_POINTER_TO (TREE_TYPE (type)), base),
-			   array_type_nelts (type), 0, 0);
-	}
-      else
-	expand_aggr_init (build1 (INDIRECT_REF, type, base), init, 0);
-
-      expand_assignment (base,
-			 build (PLUS_EXPR, TYPE_POINTER_TO (type), base, size),
-			 0, 0);
-      if (base2)
-	expand_assignment (base2,
-			   build (PLUS_EXPR, TYPE_POINTER_TO (type), base2, size), 0, 0);
-      expand_loop_continue_here ();
-      expand_exit_loop_if_false (0, build (NE_EXPR, integer_type_node,
-					   build (PREDECREMENT_EXPR, integer_type_node, iterator, integer_one_node), minus_one));
-
-      if (obey_regdecls)
-	{
-	  use_variable (DECL_RTL (base));
-	  if (base2)
-	    use_variable (DECL_RTL (base2));
-	}
-      expand_end_loop ();
-      expand_end_cond ();
-      if (obey_regdecls)
-	use_variable (DECL_RTL (iterator));
-    }
- done_init:
-
-  if (obey_regdecls)
-    use_variable (DECL_RTL (rval));
-  return rval;
-}
-
-/* Free up storage of type TYPE, at address ADDR.
-
-   TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
-   of pointer.
-
-   VIRTUAL_SIZE is the ammount of storage that was allocated, and is
-   used as the second argument to operator delete.  It can include
-   things like padding and magic size cookies.  It has virtual in it,
-   because if you have a base pointer and you delete through a virtual
-   destructor, it should be the size of the dynamic object, not the
-   static object, see Free Store 12.5 ANSI C++ WP.
-
-   This does not call any destructors.  */
-tree
-build_x_delete (type, addr, use_global_delete, virtual_size)
-     tree type, addr;
-     int use_global_delete;
-     tree virtual_size;
-{
-  tree rval;
-
-  if (!use_global_delete
-      && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
-      && TREE_GETS_DELETE (TREE_TYPE (type)))
-    rval = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr, virtual_size, NULL_TREE);
-  else
-    rval = build_builtin_call (void_type_node, BID,
-			       tree_cons (NULL_TREE, addr,
-					  build_tree_list (NULL_TREE,
-							   virtual_size)));
-  return rval;
-}
-
-/* Objects returned by `build_new' may point to just what the user
-   requested (in the case of `new X'), or they may have a cookie
-   consisting of a special value (the two's complement of the pointer
-   address) and the number of elements allocated (in the case of
-   `new X[N]'.  In the latter case, we need to adjust the pointer
-   that's passed back to the storage allocator.  */
-
-static tree
-maybe_adjust_addr_for_delete (addr)
-     tree addr;
-{
-  tree cookie_addr;
-  tree cookie;
-  tree adjusted_addr, ptr_2comp;
-
-  if (TREE_SIDE_EFFECTS (addr))
-    addr = save_expr (addr);
-
-  cookie_addr = build (MINUS_EXPR, TYPE_POINTER_TO (BI_header_type),
-		       addr, BI_header_size);
-  cookie = build_indirect_ref (cookie_addr, 0);
-
-  ptr_2comp = build_component_ref (cookie, get_identifier ("ptr_2comp"), 0, 0);
-  adjusted_addr = save_expr (build (MINUS_EXPR, TREE_TYPE (addr), addr, BI_header_size));
-
-  /* We must zero out the storage here because if the memory is freed,
-     then later reallocated, we might get a false positive when the
-     address is reused.  */
-  adjusted_addr = build_compound_expr (tree_cons (NULL_TREE,
-						  build_modify_expr (ptr_2comp, NOP_EXPR, null_pointer_node),
-						  build_tree_list (NULL_TREE, adjusted_addr)));
-
-  addr = build (COND_EXPR, TREE_TYPE (addr),
-		build (TRUTH_ORIF_EXPR, integer_type_node,
-		       build (EQ_EXPR, integer_type_node,
-			      addr, integer_zero_node),
-		       build (PLUS_EXPR, integer_type_node,
-			      convert (ptr_type_node, addr), ptr_2comp)),
-		addr,
-		adjusted_addr);
-  return addr;
-}
-
-/* Generate a call to a destructor. TYPE is the type to cast ADDR to.
-   ADDR is an expression which yields the store to be destroyed.
-   AUTO_DELETE is nonzero if a call to DELETE should be made or not.
-   If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
-   virtual baseclasses.
-   If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
-
-   FLAGS is the logical disjunction of zero or more LOOKUP_
-   flags.  See cp-tree.h for more info.
-
-   MAYBE_ADJUST is nonzero iff we may need to adjust the address
-   of the object being deleted before calling `operator delete'.
-   This can happen when a user allocates an array with `operator new'
-   and simply calls delete.  Ideally this is unnecessary, but there
-   is much code that does `p = new char[n]; ... delete p;' and this code
-   would crash otherwise.
-
-   This function does not delete an object's virtual base classes.  */
-tree
-build_delete (type, addr, auto_delete, flags, use_global_delete, maybe_adjust)
-     tree type, addr;
-     tree auto_delete;
-     int flags;
-     int use_global_delete;
-     int maybe_adjust;
-{
-  tree function, parms;
-  tree member;
-  tree expr;
-  tree ref;
-  int ptr;
-
-  if (addr == error_mark_node)
-    return error_mark_node;
-
-  /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
-     set to `error_mark_node' before it gets properly cleaned up.  */
-  if (type == error_mark_node)
-    return error_mark_node;
-
-  type = TYPE_MAIN_VARIANT (type);
-
-  if (TREE_CODE (type) == POINTER_TYPE)
-    {
-      type = TREE_TYPE (type);
-      if (TYPE_SIZE (type) == 0)
-	{
-	  incomplete_type_error (0, type);
-	  return error_mark_node;
-	}
-      if (TREE_CODE (type) == ARRAY_TYPE)
-	goto handle_array;
-      if (! IS_AGGR_TYPE (type))
-	{
-	  tree virtual_size;
-
-	  /* This is probably wrong. It should be the size of the virtual
-	     object being deleted.  */
-	  virtual_size = c_sizeof_nowarn (type);
-
-	  if (maybe_adjust)
-	    addr = maybe_adjust_addr_for_delete (addr);
-	  return build_builtin_call (void_type_node, BID,
-				     tree_cons (NULL_TREE, addr,
-						build_tree_list (NULL_TREE, virtual_size)));
-	}
-      if (TREE_SIDE_EFFECTS (addr))
-	addr = save_expr (addr);
-      ref = build_indirect_ref (addr, 0);
-      ptr = 1;
-    }
-  else if (TREE_CODE (type) == ARRAY_TYPE)
-    {
-    handle_array:
-      if (TREE_SIDE_EFFECTS (addr))
-	addr = save_expr (addr);
-      return build_vec_delete (addr, array_type_nelts (type),
-			       c_sizeof_nowarn (TREE_TYPE (type)),
-			       NULL_TREE, auto_delete, integer_two_node);
-    }
-  else
-    {
-      /* Don't check PROTECT here; leave that decision to the
-	 destructor.  If the destructor is visible, call it,
-	 else report error.  */
-      addr = build_unary_op (ADDR_EXPR, addr, 0);
-      if (TREE_SIDE_EFFECTS (addr))
-	addr = save_expr (addr);
-
-      if (TREE_CONSTANT (addr))
-	addr = convert_pointer_to (type, addr);
-      else
-	addr = convert_force (build_pointer_type (type), addr);
-
-      if (TREE_CODE (addr) == NOP_EXPR
-	  && TREE_OPERAND (addr, 0) == current_class_decl)
-	ref = C_C_D;
-      else
-	ref = build_indirect_ref (addr, 0);
-      ptr = 0;
-    }
-
-  my_friendly_assert (IS_AGGR_TYPE (type), 220);
-
-  if (! TYPE_NEEDS_DESTRUCTOR (type))
-    {
-      tree virtual_size;
-
-      /* This is probably wrong. It should be the size of the virtual object
-	 being deleted.  */
-      virtual_size = c_sizeof_nowarn (type);
-
-      if (auto_delete == integer_zero_node)
-	return void_zero_node;
-      if (maybe_adjust && addr != current_class_decl)
-	addr = maybe_adjust_addr_for_delete (addr);
-      if (TREE_GETS_DELETE (type) && !use_global_delete)
-	return build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr, virtual_size, NULL_TREE);
-      return build_builtin_call (void_type_node, BID,
-				 tree_cons (NULL_TREE, addr,
-					    build_tree_list (NULL_TREE, virtual_size)));
-    }
-  parms = build_tree_list (NULL_TREE, addr);
-
-  /* Below, we will reverse the order in which these calls are made.
-     If we have a destructor, then that destructor will take care
-     of the base classes; otherwise, we must do that here.  */
-  if (TYPE_HAS_DESTRUCTOR (type))
-    {
-      tree dtor = DECL_MAIN_VARIANT (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0));
-      tree basetypes = TYPE_BINFO (type);
-
-      if (flags & LOOKUP_PROTECT)
-	{
-	  enum visibility_type visibility = compute_visibility (basetypes, dtor);
-
-	  if (visibility == visibility_private)
-	    {
-	      if (flags & LOOKUP_COMPLAIN)
-		error_with_aggr_type (type, "destructor for type `%s' is private in this scope");
-	      return error_mark_node;
-	    }
-	  else if (visibility == visibility_protected
-		   && (flags & LOOKUP_PROTECTED_OK) == 0)
-	    {
-	      if (flags & LOOKUP_COMPLAIN)
-		error_with_aggr_type (type, "destructor for type `%s' is protected in this scope");
-	      return error_mark_node;
-	    }
-	}
-
-      /* Once we are in a destructor, try not going through
-	 the virtual function table to find the next destructor.  */
-      if (DECL_VINDEX (dtor)
-	  && ! (flags & LOOKUP_NONVIRTUAL)
-	  && TREE_CODE (auto_delete) != PARM_DECL
-	  && (ptr == 1 || ! resolves_to_fixed_type_p (ref, 0)))
-	{
-	  /* This destructor must be called via virtual function table.  */
-	  dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (DECL_CONTEXT (dtor)), 0);
-	  expr = convert_pointer_to (DECL_CLASS_CONTEXT (dtor), TREE_VALUE (parms));
-	  if (expr != TREE_VALUE (parms))
-	    {
-	      expr = fold (expr);
-	      ref = build_indirect_ref (expr, 0);
-	      TREE_VALUE (parms) = expr;
-	    }
-	  function = build_vfn_ref (&TREE_VALUE (parms), ref, DECL_VINDEX (dtor));
-	  if (function == error_mark_node)
-	    return error_mark_node;
-	  TREE_TYPE (function) = build_pointer_type (TREE_TYPE (dtor));
-	  TREE_CHAIN (parms) = build_tree_list (NULL_TREE, auto_delete);
-	  expr = build_function_call (function, parms);
-	  if (ptr && (flags & LOOKUP_DESTRUCTOR) == 0)
-	    {
-	      /* Handle the case where a virtual destructor is
-		 being called on an item that is 0.
-
-		 @@ Does this really need to be done?  */
-	      tree ifexp = build_binary_op(NE_EXPR, addr, integer_zero_node,1);
-#if 0
-	      if (TREE_CODE (ref) == VAR_DECL
-		  || TREE_CODE (ref) == COMPONENT_REF)
-		warning ("losing in build_delete");
-#endif
-	      expr = build (COND_EXPR, void_type_node,
-			    ifexp, expr, void_zero_node);
-	    }
-	}
-      else
-	{
-	  tree ifexp;
-
-	  if ((flags & LOOKUP_DESTRUCTOR)
-	      || TREE_CODE (ref) == VAR_DECL
-	      || TREE_CODE (ref) == PARM_DECL
-	      || TREE_CODE (ref) == COMPONENT_REF
-	      || TREE_CODE (ref) == ARRAY_REF)
-	    /* These can't be 0.  */
-	    ifexp = integer_one_node;
-	  else
-	    /* Handle the case where a non-virtual destructor is
-	       being called on an item that is 0.  */
-	    ifexp = build_binary_op (NE_EXPR, addr, integer_zero_node, 1);
-
-	  /* Used to mean that this destructor was known to be empty,
-	     but that's now obsolete.  */
-	  my_friendly_assert (DECL_INITIAL (dtor) != void_type_node, 221);
-
-	  TREE_CHAIN (parms) = build_tree_list (NULL_TREE, auto_delete);
-	  expr = build_function_call (dtor, parms);
-
-	  if (ifexp != integer_one_node)
-	    expr = build (COND_EXPR, void_type_node,
-			  ifexp, expr, void_zero_node);
-	}
-      return expr;
-    }
-  else
-    {
-      /* This can get visibilities wrong.  */
-      tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
-      int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-      tree base_binfo = n_baseclasses > 0 ? TREE_VEC_ELT (binfos, 0) : NULL_TREE;
-      tree exprstmt = NULL_TREE;
-      tree parent_auto_delete = auto_delete;
-      tree cond;
-
-      /* If this type does not have a destructor, but does have
-	 operator delete, call the parent parent destructor (if any),
-	 but let this node do the deleting.  Otherwise, it is ok
-	 to let the parent destructor do the deleting.  */
-      if (TREE_GETS_DELETE (type) && !use_global_delete)
-	{
-	  parent_auto_delete = integer_zero_node;
-	  if (auto_delete == integer_zero_node)
-	    cond = NULL_TREE;
-	  else
-	    {
-	      tree virtual_size;
-
-	        /* This is probably wrong. It should be the size of the
-		   virtual object being deleted.  */
-	      virtual_size = c_sizeof_nowarn (type);
-
-	      expr = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr,
-				     virtual_size, NULL_TREE);
-	      if (expr == error_mark_node)
-		return error_mark_node;
-	      if (auto_delete != integer_one_node)
-		cond = build (COND_EXPR, void_type_node,
-			      build (BIT_AND_EXPR, integer_type_node,
-				     auto_delete, integer_one_node),
-			      expr, void_zero_node);
-	      else cond = expr;
-	    }
-	}
-      else if (base_binfo == NULL_TREE
-	       || (TREE_VIA_VIRTUAL (base_binfo) == 0
-		   && ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))))
-	{
-	  tree virtual_size;
-
-	  /* This is probably wrong. It should be the size of the virtual
-	     object being deleted.  */
-	  virtual_size = c_sizeof_nowarn (type);
-
-	  cond = build (COND_EXPR, void_type_node,
-			build (BIT_AND_EXPR, integer_type_node, auto_delete, integer_one_node),
-			build_builtin_call (void_type_node, BID,
-					    tree_cons (NULL_TREE, addr,
-						       build_tree_list (NULL_TREE, virtual_size))),
-			void_zero_node);
-	}
-      else cond = NULL_TREE;
-
-      if (cond)
-	exprstmt = build_tree_list (NULL_TREE, cond);
-
-      if (base_binfo
-	  && ! TREE_VIA_VIRTUAL (base_binfo)
-	  && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
-	{
-	  tree this_auto_delete;
-
-	  if (BINFO_OFFSET_ZEROP (base_binfo))
-	    this_auto_delete = parent_auto_delete;
-	  else
-	    this_auto_delete = integer_zero_node;
-
-	  expr = build_delete (TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), addr,
-			       this_auto_delete, flags|LOOKUP_PROTECTED_OK, 0, 0);
-	  exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
-	}
-
-      /* Take care of the remaining baseclasses.  */
-      for (i = 1; i < n_baseclasses; i++)
-	{
-	  base_binfo = TREE_VEC_ELT (binfos, i);
-	  if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))
-	      || TREE_VIA_VIRTUAL (base_binfo))
-	    continue;
-
-	  /* May be zero offset if other baseclasses are virtual.  */
-	  expr = fold (build (PLUS_EXPR, TYPE_POINTER_TO (BINFO_TYPE (base_binfo)),
-			      addr, BINFO_OFFSET (base_binfo)));
-
-	  expr = build_delete (TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), expr,
-			       integer_zero_node,
-			       flags|LOOKUP_PROTECTED_OK, 0, 0);
-
-	  exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
-	}
-
-      for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
-	{
-	  if (TREE_CODE (member) != FIELD_DECL)
-	    continue;
-	  if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member)))
-	    {
-	      tree this_member = build_component_ref (ref, DECL_NAME (member), 0, 0);
-	      tree this_type = TREE_TYPE (member);
-	      expr = build_delete (this_type, this_member, integer_two_node, flags, 0, 0);
-	      exprstmt = tree_cons (NULL_TREE, expr, exprstmt);
-	    }
-	}
-
-      if (exprstmt)
-	return build_compound_expr (exprstmt);
-      /* Virtual base classes make this function do nothing.  */
-      return void_zero_node;
-    }
-}
-
-/* For type TYPE, delete the virtual baseclass objects of DECL.  */
-
-tree
-build_vbase_delete (type, decl)
-     tree type, decl;
-{
-  tree vbases = CLASSTYPE_VBASECLASSES (type);
-  tree result = NULL_TREE;
-  tree addr = build_unary_op (ADDR_EXPR, decl, 0);
-  my_friendly_assert (addr != error_mark_node, 222);
-  while (vbases)
-    {
-      tree this_addr = convert_force (TYPE_POINTER_TO (BINFO_TYPE (vbases)), addr);
-      result = tree_cons (NULL_TREE,
-			  build_delete (TREE_TYPE (this_addr), this_addr,
-					integer_zero_node,
-					LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0, 0),
-			  result);
-      vbases = TREE_CHAIN (vbases);
-    }
-  return build_compound_expr (nreverse (result));
-}
-
-/* Build a C++ vector delete expression.
-   MAXINDEX is the number of elements to be deleted.
-   ELT_SIZE is the nominal size of each element in the vector.
-   BASE is the expression that should yield the store to be deleted.
-   DTOR_DUMMY is a placeholder for a destructor.  The library function
-   __builtin_vec_delete has a pointer to function in this position.
-   This function expands (or synthesizes) these calls itself.
-   AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
-   AUTO_DELETE say whether each item in the container should be deallocated.
-
-   This also calls delete for virtual baseclasses of elements of the vector.
-
-   Update: MAXINDEX is no longer needed.  The size can be extracted from the
-   start of the vector for pointers, and from the type for arrays.  We still
-   use MAXINDEX for arrays because it happens to already have one of the
-   values we'd have to extract.  (We could use MAXINDEX with pointers to
-   confirm the size, and trap if the numbers differ; not clear that it'd
-   be worth bothering.)  */
-tree
-build_vec_delete (base, maxindex, elt_size, dtor_dummy, auto_delete_vec, auto_delete)
-     tree base, maxindex, elt_size;
-     tree dtor_dummy;
-     tree auto_delete_vec, auto_delete;
-{
-  tree ptype = TREE_TYPE (base);
-  tree type;
-  tree virtual_size;
-  /* Temporary variables used by the loop.  */
-  tree tbase, size_exp, tbase_init;
-
-  /* This is the body of the loop that implements the deletion of a
-     single element, and moves temp variables to next elements.  */
-  tree body;
-
-  /* This is the LOOP_EXPR that governs the deletion of the elements.  */
-  tree loop;
-
-  /* This is the thing that governs what to do after the loop has run.  */
-  tree deallocate_expr = 0;
-
-  /* This is the BIND_EXPR which holds the outermost iterator of the
-     loop.  It is convenient to set this variable up and test it before
-     executing any other code in the loop.
-     This is also the containing expression returned by this function.  */
-  tree controller = NULL_TREE;
-
-  /* This is the BLOCK to record the symbol binding for debugging.  */
-  tree block;
-
-  base = stabilize_reference (base);
-
-  /* Since we can use base many times, save_epr it. */
-  if (TREE_SIDE_EFFECTS (base))
-    base = save_expr (base);
-
-  if (TREE_CODE (ptype) == POINTER_TYPE)
-    {
-      /* Step back one from start of vector, and read dimension.  */
-      tree cookie_addr = build (MINUS_EXPR, TYPE_POINTER_TO (BI_header_type),
-				base, BI_header_size);
-      tree cookie = build_indirect_ref (cookie_addr, 0);
-      maxindex = build_component_ref (cookie, get_identifier ("nelts"), 0, 0);
-      do
-	ptype = TREE_TYPE (ptype);
-      while (TREE_CODE (ptype) == ARRAY_TYPE);
-    }
-  else if (TREE_CODE (ptype) == ARRAY_TYPE)
-    {
-      /* get the total number of things in the array, maxindex is a bad name */
-      maxindex = array_type_nelts_total (ptype);
-      while (TREE_CODE (ptype) == ARRAY_TYPE)
-	ptype = TREE_TYPE (ptype);
-      base = build_unary_op (ADDR_EXPR, base, 1);
-    }
-  else
-    {
-      error ("type to vector delete is neither pointer or array type");
-      return error_mark_node;
-    }
-  type = ptype;
-  ptype = TYPE_POINTER_TO (type);
-
-  size_exp = size_in_bytes (type);
-
-  if (! IS_AGGR_TYPE (type) || ! TYPE_NEEDS_DESTRUCTOR (type))
-    {
-      loop = integer_zero_node;
-      goto no_destructor;
-    }
-
-  /* The below is short by BI_header_size */
-  virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
-
-  tbase = build_decl (VAR_DECL, NULL_TREE, ptype);
-  tbase_init = build_modify_expr (tbase, NOP_EXPR,
-				  fold (build (PLUS_EXPR, ptype,
-					       base,
-					       virtual_size)));
-  DECL_REGISTER (tbase) = 1;
-  controller = build (BIND_EXPR, void_type_node, tbase, 0, 0);
-  TREE_SIDE_EFFECTS (controller) = 1;
-  block = build_block (tbase, 0, 0, 0, 0);
-  add_block_current_level (block);
-
-  if (auto_delete != integer_zero_node
-      && auto_delete != integer_two_node)
-    {
-      tree base_tbd = convert (ptype,
-			       build_binary_op (MINUS_EXPR,
-						convert (ptr_type_node, base),
-						BI_header_size,
-						1));
-      /* This is the real size */
-      virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
-      body = build_tree_list (NULL_TREE,
-			      build_x_delete (ptr_type_node, base_tbd, 0,
-					      virtual_size));
-      body = build (COND_EXPR, void_type_node,
-		    build (BIT_AND_EXPR, integer_type_node,
-			   auto_delete, integer_one_node),
-		    body, integer_zero_node);
-    }
-  else
-    body = NULL_TREE;
-
-  body = tree_cons (NULL_TREE,
-		    build_delete (ptype, tbase, auto_delete,
-				  LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0, 0),
-		    body);
-
-  body = tree_cons (NULL_TREE,
-		    build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
-		    body);
-
-  body = tree_cons (NULL_TREE,
-		    build (EXIT_EXPR, void_type_node,
-			   build (EQ_EXPR, integer_type_node, base, tbase)),
-		    body);
-
-  loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
-
-  loop = tree_cons (NULL_TREE, tbase_init,
-		    tree_cons (NULL_TREE, loop, NULL_TREE));
-  loop = build_compound_expr (loop);
-
- no_destructor:
-  /* If the delete flag is one, or anything else with the low bit set,
-     delete the storage.  */
-  if (auto_delete_vec == integer_zero_node
-      || auto_delete_vec == integer_two_node)
-    deallocate_expr = integer_zero_node;
-  else
-    {
-      tree base_tbd;
-
-      /* The below is short by BI_header_size */
-      virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
-
-      if (loop == integer_zero_node)
-	/* no header */
-	base_tbd = base;
-      else
-	{
-	  base_tbd = convert (ptype,
-			      build_binary_op (MINUS_EXPR,
-					       convert (string_type_node, base),
-					       BI_header_size,
-					       1));
-	  /* True size with header. */
-	  virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
-	}
-      deallocate_expr = build_x_delete (ptr_type_node, base_tbd, 1,
-					virtual_size);
-      if (auto_delete_vec != integer_one_node)
-	deallocate_expr = build (COND_EXPR, void_type_node,
-				 build (BIT_AND_EXPR, integer_type_node,
-					auto_delete_vec, integer_one_node),
-				 deallocate_expr, integer_zero_node);
-    }
-
-  if (loop && deallocate_expr != integer_zero_node)
-    {
-      body = tree_cons (NULL_TREE, loop,
-			tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
-      body = build_compound_expr (body);
-    }
-  else
-    body = loop;
-
-  /* Outermost wrapper: If pointer is null, punt.  */
-  body = build (COND_EXPR, void_type_node,
-		build (NE_EXPR, integer_type_node, base, integer_zero_node),
-		body, integer_zero_node);
-
-  if (controller)
-    {
-      TREE_OPERAND (controller, 1) = body;
-      return controller;
-    }
-  else
-    return convert (void_type_node, body);
-}
diff --git a/gnu/gcc2/cc1plus/cp-input.c b/gnu/gcc2/cc1plus/cp-input.c
deleted file mode 100644
index 1252aed187a8..000000000000
--- a/gnu/gcc2/cc1plus/cp-input.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/* Input handling for G++.
-   Copyright (C) 1992, 1993 Free Software Foundation, Inc.
-   Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
-
-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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* G++ needs to do enough saving and re-parsing of text that it is
-   necessary to abandon the simple FILE* model and use a mechanism where
-   we can pre-empt one input stream with another derived from saved text;
-   we may need to do this arbitrarily often, and cannot depend on having
-   the GNU library available, so FILE objects just don't cut it.
-
-   This file is written as a separate module, but can be included by
-   cp-lex.c for very minor efficiency gains (primarily in function
-   inlining).  */
-
-#include <stdio.h>
-#include "obstack.h"
-
-extern FILE *finput;
-
-struct pending_input *save_pending_input ();
-void restore_pending_input ();
-
-struct input_source {
-  /* saved string */
-  char *str;
-  int length;
-  /* current position, when reading as input */
-  int offset;
-  /* obstack to free this input string from when finished, if any */
-  struct obstack *obstack;
-  /* linked list maintenance */
-  struct input_source *next;
-  /* values to restore after reading all of current string */
-  char *filename;
-  int lineno;
-  struct pending_input *input;
-  int putback_char;
-};
-
-static struct input_source *input, *free_inputs;
-
-extern char *input_filename;
-extern int lineno;
-
-#ifdef __GNUC__
-#define inline __inline__
-#else
-#define inline
-#endif
-
-static inline struct input_source *
-allocate_input ()
-{
-  struct input_source *inp;
-  if (free_inputs)
-    {
-      inp = free_inputs;
-      free_inputs = inp->next;
-      inp->next = 0;
-      return inp;
-    }
-  inp = (struct input_source *) xmalloc (sizeof (struct input_source));
-  inp->next = 0;
-  inp->obstack = 0;
-  return inp;
-}
-
-static inline void
-free_input (inp)
-     struct input_source *inp;
-{
-  if (inp->obstack)
-    obstack_free (inp->obstack, inp->str);
-  inp->obstack = 0;
-  inp->str = 0;
-  inp->length = 0;
-  inp->next = free_inputs;
-  free_inputs = inp;
-}
-
-static int putback_char = -1;
-
-/* Some of these external functions are declared inline in case this file
-   is included in cp-lex.c.  */
-
-inline
-void
-feed_input (str, len, delete)
-     char *str;
-     int len;
-     struct obstack *delete;
-{
-  struct input_source *inp = allocate_input ();
-
-  /* This shouldn't be necessary.  */
-  while (len && !str[len-1])
-    len--;
-
-  inp->str = str;
-  inp->length = len;
-  inp->obstack = delete;
-  inp->offset = 0;
-  inp->next = input;
-  inp->filename = input_filename;
-  inp->lineno = lineno;
-  inp->input = save_pending_input ();
-  inp->putback_char = putback_char;
-  putback_char = -1;
-  input = inp;
-}
-
-struct pending_input *to_be_restored; /* XXX */
-extern int end_of_file;
-
-int
-getch ()
-{
-  if (putback_char != -1)
-    {
-      int ch = putback_char;
-      putback_char = -1;
-      return ch;
-    }
-  if (input)
-    {
-      if (input->offset == input->length)
-	{
-	  struct input_source *inp = input;
-	  my_friendly_assert (putback_char == -1, 223);
-	  to_be_restored = inp->input;
-	  input->offset++;
-	  return EOF;
-	}
-      else if (input->offset > input->length)
-	{
-	  struct input_source *inp = input;
-
-	  end_of_file = 0;
-	  input = inp->next;
-	  input_filename = inp->filename;
-	  lineno = inp->lineno;
-	  /* Get interface/implementation back in sync. */
-	  extract_interface_info ();
-	  putback_char = inp->putback_char;
-	  free_input (inp);
-	  return getch ();
-	}
-      if (input)
-	return input->str[input->offset++];
-    }
-  return getc (finput);
-}
-
-inline
-void
-put_back (ch)
-     int ch;
-{
-  my_friendly_assert (putback_char == -1, 224);
-  putback_char = ch;
-}
-
-inline
-int
-input_redirected ()
-{
-  return input != 0;
-}
diff --git a/gnu/gcc2/cc1plus/cp-lex.c b/gnu/gcc2/cc1plus/cp-lex.c
deleted file mode 100644
index 81e9047d0150..000000000000
--- a/gnu/gcc2/cc1plus/cp-lex.c
+++ /dev/null
@@ -1,4232 +0,0 @@
-/* Separate lexical analyzer for GNU C++.
-   Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* This file is the lexical analyzer for GNU C++.  */
-
-#if defined(GATHER_STATISTICS) || defined(SPEW_DEBUG)
-#undef YYDEBUG
-#define YYDEBUG 1
-#endif
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <errno.h>
-#include <setjmp.h>
-#include "config.h"
-#include "input.h"
-#include "tree.h"
-#include "cp-lex.h"
-#include "cp-parse.h"
-#include "cp-tree.h"
-#include "flags.h"
-#include "obstack.h"
-
-#ifdef MULTIBYTE_CHARS
-#include <stdlib.h>
-#include <locale.h>
-#endif
-
-#ifndef errno
-extern int errno;		/* needed for VAX.  */
-#endif
-extern jmp_buf toplevel;
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-extern struct obstack *expression_obstack, permanent_obstack;
-extern struct obstack *current_obstack, *saveable_obstack;
-
-extern double atof ();
-
-extern char *get_directive_line ();	/* In c-common.c */
-
-/* Given a file name X, return the nondirectory portion.
-   Keep in mind that X can be computed more than once.  */
-#ifndef FILE_NAME_NONDIRECTORY
-#define FILE_NAME_NONDIRECTORY(X)		\
- (rindex (X, '/') != 0 ? rindex (X, '/') + 1 : X)
-#endif
-
-extern char *index ();
-extern char *rindex ();
-
-void extract_interface_info ();
-void yyerror ();
-
-/* This obstack is needed to hold text.  It is not safe to use
-   TOKEN_BUFFER because `check_newline' calls `yylex'.  */
-static struct obstack inline_text_obstack;
-static char *inline_text_firstobj;
-
-int end_of_file;
-
-extern int first_token;
-extern struct obstack token_obstack;
-
-/* ??? Don't really know where this goes yet.  */
-#if 1
-#include "cp-input.c"
-#else
-extern void put_back (/* int */);
-extern int input_redirected ();
-extern void feed_input (/* char *, int, struct obstack * */);
-#endif
-
-/* Holds translations from TREE_CODEs to operator name strings,
-   i.e., opname_tab[PLUS_EXPR] == "+".  */
-char **opname_tab;
-char **assignop_tab;
-
-extern int yychar;		/*  the lookahead symbol		*/
-extern YYSTYPE yylval;		/*  the semantic value of the		*/
-				/*  lookahead symbol			*/
-
-#if 0
-YYLTYPE yylloc;			/*  location data for the lookahead	*/
-				/*  symbol				*/
-#endif
-
-
-/* the declaration found for the last IDENTIFIER token read in.
-   yylex must look this up to detect typedefs, which get token type TYPENAME,
-   so it is left around in case the identifier is not a typedef but is
-   used in a context which makes it a reference to a variable.  */
-tree lastiddecl;
-
-/* The elements of `ridpointers' are identifier nodes
-   for the reserved type names and storage classes.
-   It is indexed by a RID_... value.  */
-tree ridpointers[(int) RID_MAX];
-
-/* We may keep statistics about how long which files took to compile.  */
-static int header_time, body_time;
-static tree get_time_identifier ();
-static tree filename_times;
-static tree this_filename_time;
-
-/* For implementing #pragma unit.  */
-tree current_unit_name;
-tree current_unit_language;
-
-/* Array for holding counts of the numbers of tokens seen.  */
-extern int *token_count;
-
-/* Textual definition used for default functions.  */
-static char default_def[] = "{}";
-
-/* Return something to represent absolute declarators containing a *.
-   TARGET is the absolute declarator that the * contains.
-   TYPE_QUALS is a list of modifiers such as const or volatile
-   to apply to the pointer type, represented as identifiers.
-
-   We return an INDIRECT_REF whose "contents" are TARGET
-   and whose type is the modifier list.  */
-
-tree
-make_pointer_declarator (type_quals, target)
-     tree type_quals, target;
-{
-  if (target && TREE_CODE (target) == IDENTIFIER_NODE
-      && ANON_AGGRNAME_P (target))
-    error ("type name expected before `*'");
-  target = build_parse_node (INDIRECT_REF, target);
-  TREE_TYPE (target) = type_quals;
-  return target;
-}
-
-/* Return something to represent absolute declarators containing a &.
-   TARGET is the absolute declarator that the & contains.
-   TYPE_QUALS is a list of modifiers such as const or volatile
-   to apply to the reference type, represented as identifiers.
-
-   We return an ADDR_EXPR whose "contents" are TARGET
-   and whose type is the modifier list.  */
-   
-tree
-make_reference_declarator (type_quals, target)
-     tree type_quals, target;
-{
-  if (target)
-    {
-      if (TREE_CODE (target) == ADDR_EXPR)
-	{
-	  error ("cannot declare references to references");
-	  return target;
-	}
-      if (TREE_CODE (target) == INDIRECT_REF)
-	{
-	  error ("cannot declare pointers to references");
-	  return target;
-	}
-      if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
-	  error ("type name expected before `&'");
-    }
-  target = build_parse_node (ADDR_EXPR, target);
-  TREE_TYPE (target) = type_quals;
-  return target;
-}
-
-/* Build names and nodes for overloaded operators.  */
-
-tree ansi_opname[LAST_CPLUS_TREE_CODE];
-tree ansi_assopname[LAST_CPLUS_TREE_CODE];
-
-char *
-operator_name_string (name)
-     tree name;
-{
-  char *opname = IDENTIFIER_POINTER (name) + 2;
-  tree *opname_table;
-  int i, assign;
-
-  /* Works for builtin and user defined types.  */
-  if (IDENTIFIER_GLOBAL_VALUE (name)
-      && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
-    return IDENTIFIER_POINTER (name);
-
-  if (opname[0] == 'a' && opname[2] != '\0')
-    {
-      opname += 1;
-      assign = 1;
-      opname_table = ansi_assopname;
-    }
-  else
-    {
-      assign = 0;
-      opname_table = ansi_opname;
-    }
-
-  for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
-    {
-      if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
-	  && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
-	break;
-    }
-
-  if (i == LAST_CPLUS_TREE_CODE)
-    return "<invalid operator>";
-
-  if (assign)
-    return assignop_tab[i];
-  else
-    return opname_tab[i];
-}
-
-int interface_only;		/* whether or not current file is only for
-				   interface definitions.  */
-int interface_unknown;		/* whether or not we know this class
-				   to behave according to #pragma interface.  */
-
-/* lexical analyzer */
-
-/* File used for outputting assembler code.  */
-extern FILE *asm_out_file;
-
-#ifndef WCHAR_TYPE_SIZE
-#ifdef INT_TYPE_SIZE
-#define WCHAR_TYPE_SIZE INT_TYPE_SIZE
-#else
-#define WCHAR_TYPE_SIZE	BITS_PER_WORD
-#endif
-#endif
-
-/* Number of bytes in a wide character.  */
-#define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
-
-static int maxtoken;		/* Current nominal length of token buffer.  */
-char *token_buffer;		/* Pointer to token buffer.
-				   Actual allocated length is maxtoken + 2.  */
-
-#include "cp-hash.h"
-
-int check_newline ();
-
-/* Nonzero tells yylex to ignore \ in string constants.  */
-static int ignore_escape_flag = 0;
-
-static int skip_white_space ();
-
-static tree
-get_time_identifier (name)
-     char *name;
-{
-  tree time_identifier;
-  int len = strlen (name);
-  char *buf = (char *)alloca (len + 6);
-  strcpy (buf, "file ");
-  bcopy (name, buf+5, len);
-  buf[len+5] = '\0';
-  time_identifier = get_identifier (buf);
-  if (IDENTIFIER_LOCAL_VALUE (time_identifier) == NULL_TREE)
-    {
-      push_obstacks_nochange ();
-      end_temporary_allocation ();
-      IDENTIFIER_LOCAL_VALUE (time_identifier) = build_int_2 (0, 0);
-      IDENTIFIER_CLASS_VALUE (time_identifier) = build_int_2 (0, 1);
-      IDENTIFIER_GLOBAL_VALUE (time_identifier) = filename_times;
-      filename_times = time_identifier;
-      pop_obstacks ();
-    }
-  return time_identifier;
-}
-
-#ifdef __GNUC__
-__inline
-#endif
-static int
-my_get_run_time ()
-{
-  int old_quiet_flag = quiet_flag;
-  int this_time;
-  quiet_flag = 0;
-  this_time = get_run_time ();
-  quiet_flag = old_quiet_flag;
-  return this_time;
-}
-
-/* Table indexed by tree code giving a string containing a character
-   classifying the tree code.  Possibilities are
-   t, d, s, c, r, <, 1 and 2.  See cp-tree.def for details.  */
-
-#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
-
-char *cplus_tree_code_type[] = {
-  "x",
-#include "cp-tree.def"
-};
-#undef DEFTREECODE
-
-/* Table indexed by tree code giving number of expression
-   operands beyond the fixed part of the node structure.
-   Not used for types or decls.  */
-
-#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
-
-int cplus_tree_code_length[] = {
-  0,
-#include "cp-tree.def"
-};
-#undef DEFTREECODE
-
-/* Names of tree components.
-   Used for printing out the tree and error messages.  */
-#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
-
-char *cplus_tree_code_name[] = {
-  "@@dummy",
-#include "cp-tree.def"
-};
-#undef DEFTREECODE
-
-/* toplev.c needs to call these.  */
-
-void
-lang_init ()
-{
-  /* the beginning of the file is a new line; check for # */
-  /* With luck, we discover the real source file's name from that
-     and put it in input_filename.  */
-  put_back (check_newline ());
-
-  if (flag_cadillac)
-    cadillac_start ();
-  if (flag_gnu_xref) GNU_xref_begin (input_filename);
-}
-
-void
-lang_finish ()
-{
-  extern int errorcount, sorrycount;
-  if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
-}
-
-char *
-lang_identify ()
-{
-  return "cplusplus";
-}
-
-void
-init_filename_times ()
-{
-  this_filename_time = get_time_identifier ("<top level>");
-  if (flag_detailed_statistics)
-    {
-      header_time = 0;
-      body_time = my_get_run_time ();
-      TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time)) = body_time;
-    }
-}
-
-/* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
-   Stuck this hack in to get the files open correctly; this is called
-   in place of init_lex if we are an unexec'd binary.    */
-void
-reinit_lang_specific ()
-{
-  init_filename_times ();
-  reinit_search_statistics ();
-}
-
-void
-init_lex ()
-{
-  extern char *(*decl_printable_name) ();
-
-  int i;
-
-  /* Initialize the lookahead machinery.  */
-  init_spew ();
-
-  /* Make identifier nodes long enough for the language-specific slots.  */
-  set_identifier_size (sizeof (struct lang_identifier));
-  decl_printable_name = lang_printable_name;
-
-  init_cplus_expand ();
-
-  tree_code_type
-    = (char **) realloc (tree_code_type,
-			 sizeof (char *) * LAST_CPLUS_TREE_CODE);
-  tree_code_length
-    = (int *) realloc (tree_code_length,
-		       sizeof (int) * LAST_CPLUS_TREE_CODE);
-  tree_code_name
-    = (char **) realloc (tree_code_name,
-			 sizeof (char *) * LAST_CPLUS_TREE_CODE);
-  bcopy ((char *)cplus_tree_code_type,
-	 (char *)(tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE),
-	 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
-  bcopy ((char *)cplus_tree_code_length,
-	 (char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
-	 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
-  bcopy ((char *)cplus_tree_code_name,
-	 (char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
-	 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
-
-  opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
-  bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
-  assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
-  bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
-
-  ansi_opname[0] = get_identifier ("<invalid operator>");
-  for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
-    {
-      ansi_opname[i] = ansi_opname[0];
-      ansi_assopname[i] = ansi_opname[0];
-    }
-
-  ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
-  ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
-  ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
-  ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
-  ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
-  ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
-  ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
-  ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
-  ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
-  ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
-  ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
-  ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
-  ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
-  ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
-  ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
-  ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
-  ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
-  ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
-  ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
-  ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
-  ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
-  ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
-  ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
-  ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
-  ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
-  ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
-  ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
-  ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
-  ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
-  ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
-  ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
-  ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
-  ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
-  ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
-  ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
-  ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
-  ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
-  ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
-  ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
-  ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
-  ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
-  ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
-  ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
-  ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
-  ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
-  ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
-  ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
-  ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
-  ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
-  ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
-  ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
-  ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
-  IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
-  ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
-  ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
-  ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
-  ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
-  ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
-  ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
-  ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
-  ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
-  ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
-  ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
-  ansi_opname[(int) TYPE_EXPR] = get_identifier ("__op");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
-
-  /* This is not true: these operators are not defined in ANSI,
-     but we need them anyway.  */
-  ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
-  ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
-  ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
-  ansi_opname[(int) METHOD_CALL_EXPR] = get_identifier ("__wr");
-  IDENTIFIER_OPNAME_P (ansi_opname[(int) METHOD_CALL_EXPR]) = 1;
-
-  init_method ();
-  gcc_obstack_init (&inline_text_obstack);
-  inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
-
-  /* Start it at 0, because check_newline is called at the very beginning
-     and will increment it to 1.  */
-  lineno = 0;
-  current_function_decl = NULL;
-
-  maxtoken = 40;
-  token_buffer = (char *) xmalloc (maxtoken + 2);
-
-  ridpointers[(int) RID_INT] = get_identifier ("int");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INT],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]));
-  ridpointers[(int) RID_CHAR] = get_identifier ("char");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CHAR],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]));
-  ridpointers[(int) RID_VOID] = get_identifier ("void");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOID],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]));
-  ridpointers[(int) RID_FLOAT] = get_identifier ("float");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FLOAT],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_FLOAT]));
-  ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_DOUBLE],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_DOUBLE]));
-  ridpointers[(int) RID_SHORT] = get_identifier ("short");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SHORT],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_SHORT]));
-  ridpointers[(int) RID_LONG] = get_identifier ("long");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_LONG],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]));
-  ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_UNSIGNED],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]));
-  ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SIGNED],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_SIGNED]));
-  ridpointers[(int) RID_INLINE] = get_identifier ("inline");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INLINE],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_INLINE]));
-  ridpointers[(int) RID_CONST] = get_identifier ("const");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CONST],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]));
-  ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOLATILE],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_VOLATILE]));
-  ridpointers[(int) RID_AUTO] = get_identifier ("auto");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_AUTO],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_AUTO]));
-  ridpointers[(int) RID_STATIC] = get_identifier ("static");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_STATIC],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]));
-  ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXTERN],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]));
-  ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TYPEDEF],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_TYPEDEF]));
-  ridpointers[(int) RID_REGISTER] = get_identifier ("register");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_REGISTER],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_REGISTER]));
-
-  /* C++ extensions. These are probably not correctly named. */
-  ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_WCHAR],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_WCHAR]));
-  class_type_node = build_int_2 (class_type, 0);
-  TREE_TYPE (class_type_node) = class_type_node;
-  ridpointers[(int) RID_CLASS] = class_type_node;
-
-  record_type_node = build_int_2 (record_type, 0);
-  TREE_TYPE (record_type_node) = record_type_node;
-  ridpointers[(int) RID_RECORD] = record_type_node;
-
-  union_type_node = build_int_2 (union_type, 0);
-  TREE_TYPE (union_type_node) = union_type_node;
-  ridpointers[(int) RID_UNION] = union_type_node;
-
-  enum_type_node = build_int_2 (enum_type, 0);
-  TREE_TYPE (enum_type_node) = enum_type_node;
-  ridpointers[(int) RID_ENUM] = enum_type_node;
-
-  ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
-  ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
-
-  ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PUBLIC],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_PUBLIC]));
-  ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PRIVATE],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_PRIVATE]));
-  ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
-  SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PROTECTED],
-			  build_tree_list (NULL_TREE, ridpointers[(int) RID_PROTECTED]));
-
-  /* Exception handling extensions.  */
-  exception_type_node = build_int_2 (exception_type, 0);
-  TREE_TYPE (exception_type_node) = exception_type_node;
-  ridpointers[(int) RID_EXCEPTION] = exception_type_node;
-
-  opname_tab[(int) COMPONENT_REF] = "->";
-  opname_tab[(int) MEMBER_REF] = "->*";
-  opname_tab[(int) METHOD_CALL_EXPR] = "->()";
-  opname_tab[(int) INDIRECT_REF] = "(unary *)";
-  opname_tab[(int) ARRAY_REF] = "[]";
-  opname_tab[(int) MODIFY_EXPR] = "=";
-  opname_tab[(int) NEW_EXPR] = "new";
-  opname_tab[(int) DELETE_EXPR] = "delete";
-  opname_tab[(int) COND_EXPR] = "... ? ... : ...";
-  opname_tab[(int) CALL_EXPR] = "()";
-  opname_tab[(int) PLUS_EXPR] = "+";
-  opname_tab[(int) MINUS_EXPR] = "-";
-  opname_tab[(int) MULT_EXPR] = "*";
-  opname_tab[(int) TRUNC_DIV_EXPR] = "/";
-  opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
-  opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
-  opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
-  opname_tab[(int) TRUNC_MOD_EXPR] = "%";
-  opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
-  opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
-  opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
-  opname_tab[(int) NEGATE_EXPR] = "-";
-  opname_tab[(int) MIN_EXPR] = "<?";
-  opname_tab[(int) MAX_EXPR] = ">?";
-  opname_tab[(int) ABS_EXPR] = "abs";
-  opname_tab[(int) FFS_EXPR] = "ffs";
-  opname_tab[(int) LSHIFT_EXPR] = "<<";
-  opname_tab[(int) RSHIFT_EXPR] = ">>";
-  opname_tab[(int) BIT_IOR_EXPR] = "|";
-  opname_tab[(int) BIT_XOR_EXPR] = "^";
-  opname_tab[(int) BIT_AND_EXPR] = "&";
-  opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
-  opname_tab[(int) BIT_NOT_EXPR] = "~";
-  opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
-  opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
-  opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
-  opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
-  opname_tab[(int) TRUTH_NOT_EXPR] = "!";
-  opname_tab[(int) LT_EXPR] = "<";
-  opname_tab[(int) LE_EXPR] = "<=";
-  opname_tab[(int) GT_EXPR] = ">";
-  opname_tab[(int) GE_EXPR] = ">=";
-  opname_tab[(int) EQ_EXPR] = "==";
-  opname_tab[(int) NE_EXPR] = "!=";
-  opname_tab[(int) IN_EXPR] = "in";
-  opname_tab[(int) RANGE_EXPR] = "..";
-  opname_tab[(int) CONVERT_EXPR] = "(unary +)";
-  opname_tab[(int) ADDR_EXPR] = "(unary &)";
-  opname_tab[(int) PREDECREMENT_EXPR] = "--";
-  opname_tab[(int) PREINCREMENT_EXPR] = "++";
-  opname_tab[(int) POSTDECREMENT_EXPR] = "--";
-  opname_tab[(int) POSTINCREMENT_EXPR] = "++";
-  opname_tab[(int) COMPOUND_EXPR] = ",";
-
-  assignop_tab[(int) NOP_EXPR] = "=";
-  assignop_tab[(int) PLUS_EXPR] =  "+=";
-  assignop_tab[(int) CONVERT_EXPR] =  "+=";
-  assignop_tab[(int) MINUS_EXPR] = "-=";
-  assignop_tab[(int) NEGATE_EXPR] = "-=";
-  assignop_tab[(int) MULT_EXPR] = "*=";
-  assignop_tab[(int) INDIRECT_REF] = "*=";
-  assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
-  assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
-  assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
-  assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
-  assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
-  assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
-  assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
-  assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
-  assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
-  assignop_tab[(int) MIN_EXPR] = "<?=";
-  assignop_tab[(int) MAX_EXPR] = ">?=";
-  assignop_tab[(int) LSHIFT_EXPR] = "<<=";
-  assignop_tab[(int) RSHIFT_EXPR] = ">>=";
-  assignop_tab[(int) BIT_IOR_EXPR] = "|=";
-  assignop_tab[(int) BIT_XOR_EXPR] = "^=";
-  assignop_tab[(int) BIT_AND_EXPR] = "&=";
-  assignop_tab[(int) ADDR_EXPR] = "&=";
-
-  init_filename_times ();
-
-  /* Some options inhibit certain reserved words.
-     Clear those words out of the hash table so they won't be recognized.  */
-#define UNSET_RESERVED_WORD(STRING) \
-  do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
-       if (s) s->name = ""; } while (0)
-
-  if (flag_ansi_exceptions)
-      flag_handle_exceptions = 2;
-
-  if (!flag_ansi_exceptions)
-    {
-      UNSET_RESERVED_WORD ("catch");
-    }
-
-  if (! flag_handle_exceptions)
-    {
-      /* Easiest way to not recognize exception
-	 handling extensions...  */
-      UNSET_RESERVED_WORD ("all");
-      UNSET_RESERVED_WORD ("except");
-      UNSET_RESERVED_WORD ("exception");
-      UNSET_RESERVED_WORD ("raise");
-      UNSET_RESERVED_WORD ("raises");
-      UNSET_RESERVED_WORD ("reraise");
-      UNSET_RESERVED_WORD ("try");
-      UNSET_RESERVED_WORD ("throw");
-    }
-  else if (flag_ansi_exceptions)
-    {
-      /* Easiest way to not recognize exception
-	 handling extensions...  */
-      UNSET_RESERVED_WORD ("exception");
-      UNSET_RESERVED_WORD ("all");
-      UNSET_RESERVED_WORD ("except");
-      UNSET_RESERVED_WORD ("raise");
-      UNSET_RESERVED_WORD ("raises");
-      UNSET_RESERVED_WORD ("reraise");
-      is_reserved_word ("try", sizeof ("try") - 1)->token = ANSI_TRY;
-      is_reserved_word ("throw", sizeof ("throw") - 1)->token = ANSI_THROW;
-    }
-  if (! (flag_gc || flag_dossier))
-    {
-      UNSET_RESERVED_WORD ("classof");
-      UNSET_RESERVED_WORD ("headof");
-    }
-  if (flag_no_asm)
-    UNSET_RESERVED_WORD ("asm");
-  if (flag_no_asm || flag_traditional)
-    UNSET_RESERVED_WORD ("typeof");
-  UNSET_RESERVED_WORD ("dynamic");
-
-  token_count = init_parse ();
-  interface_unknown = 1;
-}
-
-void
-reinit_parse_for_function ()
-{
-  current_base_init_list = NULL_TREE;
-  current_member_init_list = NULL_TREE;
-}
-
-#ifdef __GNUC__
-__inline
-#endif
-void
-yyprint (file, yychar, yylval)
-     FILE *file;
-     int yychar;
-     YYSTYPE yylval;
-{
-  tree t;
-  switch (yychar)
-    {
-    case IDENTIFIER:
-    case TYPENAME:
-    case TYPESPEC:
-    case PTYPENAME:
-    case IDENTIFIER_DEFN:
-    case TYPENAME_DEFN:
-    case PTYPENAME_DEFN:
-    case TYPENAME_COLON:
-    case TYPENAME_ELLIPSIS:
-    case SCOPED_TYPENAME:
-    case SCSPEC:
-      t = yylval.ttype;
-    print_id:
-      my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
-      if (IDENTIFIER_POINTER (t))
-	  fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
-      break;
-    case AGGR:
-      if (yylval.ttype == class_type_node)
-	fprintf (file, " `class'");
-      else if (yylval.ttype == record_type_node)
-	fprintf (file, " `struct'");
-      else if (yylval.ttype == union_type_node)
-	fprintf (file, " `union'");
-      else if (yylval.ttype == enum_type_node)
-	fprintf (file, " `enum'");
-      else
-	my_friendly_abort (80);
-      break;
-    case PRE_PARSED_CLASS_DECL:
-      t = yylval.ttype;
-      my_friendly_assert (TREE_CODE (t) == TREE_LIST, 225);
-      t = TREE_VALUE (t);
-      goto print_id;
-    }
-}
-
-static int *reduce_count;
-int *token_count;
-
-#define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
-#define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
-
-int *
-init_parse ()
-{
-#ifdef GATHER_STATISTICS
-  reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
-  bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
-  reduce_count += 1;
-  token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
-  bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
-  token_count += 1;
-#endif
-  return token_count;
-}
-
-#ifdef GATHER_STATISTICS
-void
-yyhook (yyn)
-     int yyn;
-{
-  reduce_count[yyn] += 1;
-}
-#endif
-
-static int
-reduce_cmp (p, q)
-     int *p, *q;
-{
-  return reduce_count[*q] - reduce_count[*p];
-}
-
-static int
-token_cmp (p, q)
-     int *p, *q;
-{
-  return token_count[*q] - token_count[*p];
-}
-
-void
-print_parse_statistics ()
-{
-#ifdef GATHER_STATISTICS
-#if YYDEBUG != 0
-  int i;
-  int maxlen = REDUCE_LENGTH;
-  unsigned *sorted;
-  
-  if (reduce_count[-1] == 0)
-    return;
-
-  if (TOKEN_LENGTH > REDUCE_LENGTH)
-    maxlen = TOKEN_LENGTH;
-  sorted = (unsigned *) alloca (sizeof (int) * maxlen);
-
-  for (i = 0; i < TOKEN_LENGTH; i++)
-    sorted[i] = i;
-  qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
-  for (i = 0; i < TOKEN_LENGTH; i++)
-    {
-      int index = sorted[i];
-      if (token_count[index] == 0)
-	break;
-      if (token_count[index] < token_count[-1])
-	break;
-      fprintf (stderr, "token %d, `%s', count = %d\n",
-	       index, yytname[YYTRANSLATE (index)], token_count[index]);
-    }
-  fprintf (stderr, "\n");
-  for (i = 0; i < REDUCE_LENGTH; i++)
-    sorted[i] = i;
-  qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
-  for (i = 0; i < REDUCE_LENGTH; i++)
-    {
-      int index = sorted[i];
-      if (reduce_count[index] == 0)
-	break;
-      if (reduce_count[index] < reduce_count[-1])
-	break;
-      fprintf (stderr, "rule %d, line %d, count = %d\n",
-	       index, yyrline[index], reduce_count[index]);
-    }
-  fprintf (stderr, "\n");
-#endif
-#endif
-}
-
-/* Sets the value of the 'yydebug' variable to VALUE.
-   This is a function so we don't have to have YYDEBUG defined
-   in order to build the compiler.  */
-void
-set_yydebug (value)
-     int value;
-{
-#if YYDEBUG != 0
-  extern int yydebug;
-  yydebug = value;
-#else
-  warning ("YYDEBUG not defined.");
-#endif
-}
-
-#ifdef SPEW_DEBUG
-const char *
-debug_yytranslate (value)
-    int value;
-{
-  return yytname[YYTRANSLATE (value)];
-}
-
-#endif
-
-/* Functions and data structures for #pragma interface.
-
-   `#pragma implementation' means that the main file being compiled
-   is considered to implement (provide) the classes that appear in
-   its main body.  I.e., if this is file "foo.cc", and class `bar'
-   is defined in "foo.cc", then we say that "foo.cc implements bar".
-
-   All main input files "implement" themselves automagically.
-
-   `#pragma interface' means that unless this file (of the form "foo.h"
-   is not presently being included by file "foo.cc", the
-   CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
-   of the vtables nor any of the inline functions defined in foo.h
-   will ever be output.
-
-   There are cases when we want to link files such as "defs.h" and
-   "main.cc".  In this case, we give "defs.h" a `#pragma interface',
-   and "main.cc" has `#pragma implementation "defs.h"'.  */
-
-struct impl_files
-{
-  char *filename;
-  struct impl_files *next;
-};
-
-static struct impl_files *impl_file_chain;
-
-/* Helper function to load global variables with interface
-   information.  */
-void
-extract_interface_info ()
-{
-  tree fileinfo = get_time_identifier (input_filename);
-  fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
-  interface_only = TREE_INT_CST_LOW (fileinfo);
-  interface_unknown = TREE_INT_CST_HIGH (fileinfo);
-}
-
-/* Return nonzero if S and T are not considered part of an
-   INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
-static int
-interface_strcmp (s)
-     char *s;
-{
-  /* Set the interface/implementation bits for this scope.  */
-  struct impl_files *ifiles;
-  char *s1;
-
-  s = FILE_NAME_NONDIRECTORY (s);
-
-  for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
-    {
-      char *t1 = ifiles->filename;
-      s1 = s;
-
-      if (*s1 != *t1 || *s1 == 0)
-	continue;
-
-      while (*s1 == *t1 && *s1 != 0)
-	s1++, t1++;
-
-      /* A match.  */
-      if (*s1 == *t1)
-	return 0;
-
-      /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
-      if (index (s1, '.') || index (t1, '.'))
-	continue;
-
-      if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
-	continue;
-
-      /* A match.  */
-      return 0;
-    }
-
-  /* No matches.  */
-  return 1;
-}
-
-void
-set_typedecl_interface_info (prev, vars)
-     tree prev, vars;
-{
-  tree id = get_time_identifier (DECL_SOURCE_FILE (vars));
-  tree fileinfo = IDENTIFIER_CLASS_VALUE (id);
-  tree type = TREE_TYPE (vars);
-
-  CLASSTYPE_INTERFACE_ONLY (type) = TREE_INT_CST_LOW (fileinfo)
-    = interface_strcmp (DECL_SOURCE_FILE (vars));
-}
-
-void
-set_vardecl_interface_info (prev, vars)
-     tree prev, vars;
-{
-  tree type = DECL_CONTEXT (vars);
-
-  if (CLASSTYPE_INTERFACE_UNKNOWN (type) == 0)
-    {
-      if (CLASSTYPE_INTERFACE_ONLY (type))
-	set_typedecl_interface_info (prev, TYPE_NAME (type));
-      else
-	CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
-      DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
-      TREE_PUBLIC (vars) = 1;
-    }
-}
-
-/* Called from the top level: if there are any pending inlines to
-   do, set up to process them now.  */
-void
-do_pending_inlines ()
-{
-  struct pending_inline *prev = 0, *tail;
-  struct pending_inline *t;
-
-  /* Reverse the pending inline functions, since
-     they were cons'd instead of appended.  */
-  
-  for (t = pending_inlines; t; t = tail)
-    {
-      t->deja_vu = 1;
-      tail = t->next;
-      t->next = prev;
-      prev = t;
-    }
-  /* Reset to zero so that if the inline functions we are currently
-     processing define inline functions of their own, that is handled
-     correctly.  ??? This hasn't been checked in a while.  */
-  pending_inlines = 0;
-  
-  /* Now start processing the first inline function.  */
-  t = prev;
-  my_friendly_assert ((t->parm_vec == NULL_TREE) == (t->bindings == NULL_TREE),
-		      226);
-  if (t->parm_vec)
-    push_template_decls (t->parm_vec, t->bindings, 0);
-  if (t->len > 0)
-    {
-      feed_input (t->buf, t->len, t->can_free ? &inline_text_obstack : 0);
-      lineno = t->lineno;
-#if 0
-      if (input_filename != t->filename)
-	{
-	  input_filename = t->filename;
-	  /* Get interface/implementation back in sync.  */
-	  extract_interface_info ();
-	}
-#else
-      input_filename = t->filename;
-      interface_unknown = t->interface == 1;
-      interface_only = t->interface == 0;
-#endif
-      yychar = PRE_PARSED_FUNCTION_DECL;
-    }
-  /* Pass back a handle on the rest of the inline functions, so that they
-     can be processed later.  */
-  yylval.ttype = build_tree_list ((tree) t, t->fndecl);
-  if (flag_default_inline && t->fndecl
-      /* If we're working from a template, don't change
-	 the `inline' state.  */
-      && t->parm_vec == NULL_TREE)
-    DECL_INLINE (t->fndecl) = 1;
-  DECL_PENDING_INLINE_INFO (t->fndecl) = 0;
-}
-
-extern struct pending_input *to_be_restored;
-static int nextchar = -1;
-
-void
-process_next_inline (t)
-     tree t;
-{
-  struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
-  my_friendly_assert ((i->parm_vec == NULL_TREE) == (i->bindings == NULL_TREE),
-		      227);
-  if (i->parm_vec)
-    pop_template_decls (i->parm_vec, i->bindings, 0);
-  i = i->next;
-  if (yychar == YYEMPTY)
-    yychar = yylex ();
-  if (yychar != END_OF_SAVED_INPUT)
-    {
-      error ("parse error at end of saved function text");
-      /* restore_pending_input will abort unless yychar is either
-       * END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
-       * hosed, feed back YYEMPTY.
-       *  We also need to discard nextchar, since that may have gotten
-       * set as well.
-       */
-      nextchar = -1;
-    }
-  yychar = YYEMPTY;
-  if (to_be_restored == 0)
-    my_friendly_abort (123);
-  restore_pending_input (to_be_restored);
-  to_be_restored = 0;
-  if (i && i->fndecl != NULL_TREE)
-    {
-      my_friendly_assert ((i->parm_vec == NULL_TREE) == (i->bindings == NULL_TREE),
-			  228);
-      if (i->parm_vec)
-	push_template_decls (i->parm_vec, i->bindings, 0);
-      feed_input (i->buf, i->len, i->can_free ? &inline_text_obstack : 0);
-      lineno = i->lineno;
-      input_filename = i->filename;
-      yychar = PRE_PARSED_FUNCTION_DECL;
-      yylval.ttype = build_tree_list ((tree) i, i->fndecl);
-      if (flag_default_inline
-	  /* If we're working from a template, don't change
-	     the `inline' state.  */
-	  && i->parm_vec == NULL_TREE)
-	DECL_INLINE (i->fndecl) = 1;
-      DECL_PENDING_INLINE_INFO (i->fndecl) = 0;
-    }
-  if (i)
-    {
-      interface_unknown = i->interface == 1;
-      interface_only = i->interface == 0;
-    }
-  else
-    extract_interface_info ();
-}
-
-/* Since inline methods can refer to text which has not yet been seen,
-   we store the text of the method in a structure which is placed in the
-   DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
-   After parsing the body of the class definition, the FUNCTION_DECL's are
-   scanned to see which ones have this field set.  Those are then digested
-   one at a time.
-
-   This function's FUNCTION_DECL will have a bit set in its common so
-   that we know to watch out for it.  */
-
-void
-consume_string (this_obstack)
-     register struct obstack *this_obstack;
-{
-  register char c;
-  do
-    {
-      c = getch ();
-      if (c == '\\')
-	{
-	  obstack_1grow (this_obstack, c);
-	  c = getch ();
-	  obstack_1grow (this_obstack, c);
-	  continue;
-	}
-      if (c == '\n')
-	{
-	  if (pedantic)
-	    pedwarn ("ANSI C++ forbids newline in string constant");
-	  lineno++;
-	}
-      obstack_1grow (this_obstack, c);
-    }
-  while (c != '\"');
-}
-
-static int nextyychar = YYEMPTY;
-static YYSTYPE nextyylval;
-
-struct pending_input {
-  int nextchar, yychar, nextyychar, eof;
-  YYSTYPE yylval, nextyylval;
-  struct obstack token_obstack;
-  int first_token;
-};
-
-struct pending_input *
-save_pending_input ()
-{
-  struct pending_input *p;
-  p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
-  p->nextchar = nextchar;
-  p->yychar = yychar;
-  p->nextyychar = nextyychar;
-  p->yylval = yylval;
-  p->nextyylval = nextyylval;
-  p->eof = end_of_file;
-  yychar = nextyychar = YYEMPTY;
-  nextchar = -1;
-  p->first_token = first_token;
-  p->token_obstack = token_obstack;
-
-  first_token = 0;
-  gcc_obstack_init (&token_obstack);
-  end_of_file = 0;
-  return p;
-}
-
-void
-restore_pending_input (p)
-     struct pending_input *p;
-{
-  my_friendly_assert (nextchar == -1, 229);
-  nextchar = p->nextchar;
-  my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
-  yychar = p->yychar;
-  my_friendly_assert (nextyychar == YYEMPTY, 231);
-  nextyychar = p->nextyychar;
-  yylval = p->yylval;
-  nextyylval = p->nextyylval;
-  first_token = p->first_token;
-  obstack_free (&token_obstack, (char *) 0);
-  token_obstack = p->token_obstack;
-  end_of_file = p->eof;
-  free (p);
-}
-
-/* Return next non-whitespace input character, which may come
-   from `finput', or from `nextchar'.  */
-static int
-yynextch ()
-{
-  int c;
-
-  if (nextchar >= 0)
-    {
-      c = nextchar;
-      nextchar = -1;
-    }
-  else c = getch ();
-  return skip_white_space (c);
-}
-
-/* Unget character CH from the input stream.
-   If RESCAN is non-zero, then we want to `see' this
-   character as the next input token.  */
-void
-yyungetc (ch, rescan)
-     int ch;
-     int rescan;
-{
-  /* Unget a character from the input stream.  */
-  if (yychar == YYEMPTY || rescan == 0)
-    {
-      if (nextchar >= 0)
-	put_back (nextchar);
-      nextchar = ch;
-    }
-  else
-    {
-      my_friendly_assert (nextyychar == YYEMPTY, 232);
-      nextyychar = yychar;
-      nextyylval = yylval;
-      yychar = ch;
-    }
-}
-
-/* This function stores away the text for an inline function that should
-   be processed later.  It decides how much later, and may need to move
-   the info between obstacks; therefore, the caller should not refer to
-   the T parameter after calling this function.
-
-   This function also stores the list of template-parameter bindings that
-   will be needed for expanding the template, if any.  */
-
-static void
-store_pending_inline (decl, t)
-     tree decl;
-     struct pending_inline *t;
-{
-  extern int processing_template_defn;
-  int delay_to_eof = 0;
-  struct pending_inline **inlines;
-
-  t->fndecl = decl;
-  /* Default: compile right away, and no extra bindings are needed.  */
-  t->parm_vec = t->bindings = 0;
-  if (processing_template_defn)
-    {
-      tree type = current_class_type;
-      /* Assumption: In this (possibly) nested class sequence, only
-	 one name will have template parms.  */
-      while (type && TREE_CODE_CLASS (TREE_CODE (type)) == 't')
-	{
-	  tree decl = TYPE_NAME (type);
-	  tree tmpl = IDENTIFIER_TEMPLATE (DECL_NAME (decl));
-	  if (tmpl)
-	    {
-	      t->parm_vec = DECL_TEMPLATE_INFO (TREE_PURPOSE (tmpl))->parm_vec;
-	      t->bindings = TREE_VALUE (tmpl);
-	    }
-	  type = DECL_CONTEXT (decl);
-	}
-      if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
-	  || TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
-	{
-	  if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
-	    my_friendly_assert (TYPE_MAX_VALUE (TREE_TYPE (decl)) == current_class_type,
-				233);
-
-	  /* Inline functions can be compiled immediately.  Other functions
-	     will be output separately, so if we're in interface-only mode,
-	     punt them now, or output them now if we're doing implementations
-	     and we know no overrides will exist.  Otherwise, we delay until
-	     end-of-file, to see if the definition is really required.  */
-	  if (DECL_INLINE (decl))
-	    /* delay_to_eof == 0 */;
-	  else if (current_class_type && !interface_unknown)
-	    {
-	      if (interface_only)
-		{
-#if 0
-		  print_node_brief (stderr, "\ndiscarding text for ", decl, 0);
-#endif
-		  if (t->can_free)
-		    obstack_free (&inline_text_obstack, t->buf);
-		  DECL_PENDING_INLINE_INFO (decl) = 0;
-		  return;
-		}
-	    }
-	  /* Don't delay the processing of virtual functions.  */
-	  else if (DECL_VINDEX (decl) == NULL_TREE)
-	    delay_to_eof = 1;
-	}
-      else
-	my_friendly_abort (58);
-    }
-
-  if (delay_to_eof)
-    {
-      extern struct pending_inline *pending_template_expansions;
-
-      if (t->can_free)
-	{
-	  char *free_to = t->buf;
-	  t->buf = (char *) obstack_copy (&permanent_obstack, t->buf,
-					  t->len + 1);
-	  t = (struct pending_inline *) obstack_copy (&permanent_obstack, 
-						      (char *)t, sizeof (*t));
-	  obstack_free (&inline_text_obstack, free_to);
-	}
-      inlines = &pending_template_expansions;
-      t->can_free = 0;
-    }
-  else
-    {
-      inlines = &pending_inlines;
-      DECL_PENDING_INLINE_INFO (decl) = t;
-    }
-
-  /* Because we use obstacks, we must process these in precise order.  */
-  t->next = *inlines;
-  *inlines = t;
-}
-
-void reinit_parse_for_block ();
-
-void
-reinit_parse_for_method (yychar, decl)
-     int yychar;
-     tree decl;
-{
-  int len;
-  int starting_lineno = lineno;
-  char *starting_filename = input_filename;
-
-  reinit_parse_for_block (yychar, &inline_text_obstack, 0);
-
-  len = obstack_object_size (&inline_text_obstack);
-  current_base_init_list = NULL_TREE;
-  current_member_init_list = NULL_TREE;
-  if (decl == void_type_node
-      || (current_class_type && TYPE_REDEFINED (current_class_type)))
-    {
-      /* Happens when we get two declarations of the same
-	 function in the same scope.  */
-      char *buf = obstack_finish (&inline_text_obstack);
-      obstack_free (&inline_text_obstack, buf);
-      return;
-    }
-  else
-    {
-      struct pending_inline *t;
-      char *buf = obstack_finish (&inline_text_obstack);
-
-      t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
-						   sizeof (struct pending_inline));
-      t->buf = buf;
-      t->len = len;
-      t->lineno = starting_lineno;
-      t->filename = starting_filename;
-      t->token = YYEMPTY;
-      t->can_free = 1;
-      t->deja_vu = 0;
-      t->interface = ((interface_unknown || processing_template_defn)
-		      ? 1
-		      : (interface_only ? 0 : 2));
-      store_pending_inline (decl, t);
-    }
-}
-
-/* Consume a block -- actually, a method or template definition beginning
-   with `:' or `{' -- and save it away on the specified obstack.
-
-   Argument IS_TEMPLATE indicates which set of error messages should be
-   output if something goes wrong.  This should really be cleaned up somehow,
-   without loss of clarity.  */
-void
-reinit_parse_for_block (yychar, obstackp, is_template)
-     int yychar;
-     struct obstack *obstackp;
-     int is_template;
-{
-  register int c = 0;
-  int blev = 1;
-  int starting_lineno = lineno;
-  char *starting_filename = input_filename;
-  int len;
-  int look_for_semicolon = 0;
-
-  if (yychar == '{')
-    obstack_1grow (obstackp, '{');
-  else if (yychar == '=')
-    {
-      look_for_semicolon = 1;
-    }
-  else
-    {
-      if (yychar != ':' && (yychar != RETURN || is_template))
-	{
-	  yyerror (is_template
-		   ? "parse error in template specification"
-		   : "parse error in method specification");
-	  yychar = '{';
-	}
-      obstack_1grow (obstackp, yychar);
-      while (c >= 0)
-	{
-	  int this_lineno = lineno;
-
-	  c = yynextch ();
-
-	  /* Don't lose our cool if there are lots of comments.  */
-	  if (lineno == this_lineno)
-	    ;
-	  else if (lineno - this_lineno < 10 /* + strlen (input_filename) */)
-	    {
-	      int i;
-	      for (i = lineno - this_lineno; i > 0; i--)
-		obstack_1grow (obstackp, '\n');
-	    }
-	  else
-	    {
-	      char buf[16];
-	      sprintf (buf, "\n# %d \"", lineno);
-	      len = strlen (buf);
-	      obstack_grow (obstackp, buf, len);
-
-	      len = strlen (input_filename);
-	      obstack_grow (obstackp, input_filename, len);
-	      obstack_1grow (obstackp, '\"');
-	      obstack_1grow (obstackp, '\n');
-	    }
-
-	  /* strings must be read differently than text.  */
-	  if (c == '\"')
-	    {
-	      obstack_1grow (obstackp, c);
-	      consume_string (obstackp);
-	      c = yynextch ();
-	    }
-	  while (c > ' ')	/* ASCII dependent! */
-	    {
-	      obstack_1grow (obstackp, c);
-	      if (c == '{')
-		goto main_loop;
-	      if (c == '\"')
-		consume_string (obstackp);
-	      if (c == ';')
-		{
-		  error (is_template
-			 ? "template body missing"
-			 : "function body for constructor missing");
-		  obstack_1grow (obstackp, '{');
-		  obstack_1grow (obstackp, '}');
-		  len += 2;
-		  goto done;
-		}
-	      c = getch ();
-	    }
-	  if (c == '\n')
-	    lineno++;
-	  obstack_1grow (obstackp, c);
-	}
-      if (c == EOF)
-	error_with_file_and_line (starting_filename,
-				  starting_lineno,
-				  "end of file read inside definition");
-    }
-
- main_loop:
-  while (c >= 0)
-    {
-      int this_lineno = lineno;
-
-      c = skip_white_space (getch ());
-
-      /* Don't lose our cool if there are lots of comments.  */
-      if (lineno - this_lineno)
-	{
-	  if (lineno - this_lineno == 1)
-	    obstack_1grow (obstackp, '\n');
-	  else
-	    {
-	      char buf[16];
-	      sprintf (buf, "\n# %d \"", lineno);
-	      len = strlen (buf);
-	      obstack_grow (obstackp, buf, len);
-
-	      len = strlen (input_filename);
-	      obstack_grow (obstackp, input_filename, len);
-	      obstack_1grow (obstackp, '\"');
-	      obstack_1grow (obstackp, '\n');
-	    }
-	}
-
-      while (c > ' ')
-	{
-	  obstack_1grow (obstackp, c);
-	  if (c == '{') blev++;
-	  else if (c == '}')
-	    {
-	      blev--;
-	      if (blev == 0 && !look_for_semicolon)
-		goto done;
-	    }
-	  else if (c == '\"')
-	    consume_string (obstackp);
-	  else if (c == ';' && look_for_semicolon && blev == 0)
-	    goto done;
-	  c = getch ();
-	}
-      if (c == '\n')
-	lineno++;
-      obstack_1grow (obstackp, c);
-    }
- done:
-  obstack_1grow (obstackp, '\0');
-}
-
-/* Build a default function named NAME for type TYPE.
-   KIND says what to build.
-
-   When KIND == 0, build default destructor.
-   When KIND == 1, build virtual destructor.
-   When KIND == 2, build default constructor.
-   When KIND == 3, build default X(const X&) constructor.
-   When KIND == 4, build default X(X&) constructor.  */
-
-tree
-cons_up_default_function (type, name, kind)
-     tree type, name;
-     int kind;
-{
-  extern tree void_list_node;
-  int len;
-  tree declspecs = NULL_TREE;
-  tree fn, args;
-  tree argtype;
-
-  name = constructor_name (name);
-  switch (kind)
-    {
-      /* Destructors.  */
-    case 1:
-      declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
-      /* Fall through...  */
-    case 0:
-      name = build_parse_node (BIT_NOT_EXPR, name);
-      /* Fall through...  */
-    case 2:
-      /* Default constructor.  */
-      args = void_list_node;
-      break;
-
-    case 3:
-      type = build_type_variant (type, 1, 0);
-      /* Fall through...  */
-    case 4:
-      argtype = build_reference_type (type);
-      args = tree_cons (NULL_TREE,
-			build_tree_list (hash_tree_chain (argtype, NULL_TREE),
-					 get_identifier ("arg")),
-			void_list_node);
-      break;
-
-    default:
-      my_friendly_abort (59);
-    }
-
-  fn = start_method (declspecs,
-		     build_parse_node (CALL_EXPR, name, args, NULL_TREE),
-		     NULL_TREE);
-  if (fn == void_type_node)
-    return fn;
-
-  current_base_init_list = NULL_TREE;
-  current_member_init_list = NULL_TREE;
-
-  len = 3;
-
-  {
-    struct pending_inline *t;
-
-    t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
-						 sizeof (struct pending_inline));
-    t->buf = default_def;
-    t->len = len;
-    t->lineno = lineno;
-    t->filename = input_filename;
-    t->token = YYEMPTY;
-    t->can_free = 0;
-    t->deja_vu = 0;
-    t->interface = ((interface_unknown || processing_template_defn)
-		    ? 1
-		    : (interface_only ? 0 : 2));
-    store_pending_inline (fn, t);
-    /* We make this declaration private (static in the C sense).  */
-    TREE_PUBLIC (fn) = 0;
-  }
-  finish_method (fn);
-  DECL_CLASS_CONTEXT (fn) = type;
-  /* Show that this function was generated by the compiler.  */
-  DECL_SOURCE_LINE (fn) = 0;
-  return fn;
-}
-
-/* Heuristic to tell whether the user is missing a semicolon
-   after a struct or enum declaration.  Emit an error message
-   if we know the user has blown it.  */
-void
-check_for_missing_semicolon (type)
-     tree type;
-{
-  if (yychar < 0)
-    yychar = yylex ();
-
-  if (yychar > 255
-      && yychar != IDENTIFIER
-      && yychar != TYPENAME)
-    {
-      if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
-	error ("semicolon missing after %s declaration",
-	       TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
-      else
-	error ("semicolon missing after declaration of `%s'",
-	       TYPE_NAME_STRING (type));
-      shadow_tag (build_tree_list (0, type));
-    }
-  /* Could probably also hack cases where class { ... } f (); appears.  */
-  clear_anon_tags ();
-}
-
-void
-note_got_semicolon (type)
-     tree type;
-{
-  if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
-    my_friendly_abort (60);
-  if (IS_AGGR_TYPE (type))
-    CLASSTYPE_GOT_SEMICOLON (type) = 1;
-}
-
-void
-note_list_got_semicolon (declspecs)
-     tree declspecs;
-{
-  tree link;
-
-  for (link = declspecs; link; link = TREE_CHAIN (link))
-    {
-      tree type = TREE_VALUE (link);
-      if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
-	note_got_semicolon (type);
-    }
-  clear_anon_tags ();
-}
-
-/* If C is not whitespace, return C.
-   Otherwise skip whitespace and return first nonwhite char read.  */
-
-static int
-skip_white_space (c)
-     register int c;
-{
-  for (;;)
-    {
-      switch (c)
-	{
-	case '\n':
-	  c = check_newline ();
-	  break;
-
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\r':
-	case '\v':
-	case '\b':
-	  do
-	    c = getch ();
-	  while (c == ' ' || c == '\t');
-	  break;
-
-	case '\\':
-	  c = getch ();
-	  if (c == '\n')
-	    lineno++;
-	  else
-	    error ("stray '\\' in program");
-	  c = getch ();
-	  break;
-
-	default:
-	  return (c);
-	}
-    }
-}
-
-
-
-/* Make the token buffer longer, preserving the data in it.
-   P should point to just beyond the last valid character in the old buffer.
-   The value we return is a pointer to the new buffer
-   at a place corresponding to P.  */
-
-static char *
-extend_token_buffer (p)
-     char *p;
-{
-  int offset = p - token_buffer;
-
-  maxtoken = maxtoken * 2 + 10;
-  token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
-
-  return token_buffer + offset;
-}
-
-static int
-get_last_nonwhite_on_line ()
-{
-  register int c;
-
-  /* Is this the last nonwhite stuff on the line?  */
-  if (nextchar >= 0)
-    c = nextchar, nextchar = -1;
-  else
-    c = getch ();
-
-  while (c == ' ' || c == '\t')
-    c = getch ();
-  return c;
-}
-
-/* At the beginning of a line, increment the line number
-   and process any #-directive on this line.
-   If the line is a #-directive, read the entire line and return a newline.
-   Otherwise, return the line's first non-whitespace character.  */
-
-int
-check_newline ()
-{
-  register int c;
-  register int token;
-
-  lineno++;
-
-  /* Read first nonwhite char on the line.  */
-
-  do
-    c = getch ();
-  while (c == ' ' || c == '\t');
-
-  if (c != '#')
-    {
-      /* If not #, return it so caller will use it.  */
-      return c;
-    }
-
-  /* Read first nonwhite char after the `#'.  */
-
-  do
-    c = getch ();
-  while (c == ' ' || c == '\t');
-
-  /* If a letter follows, then if the word here is `line', skip
-     it and ignore it; otherwise, ignore the line, with an error
-     if the word isn't `pragma'.  */
-
-  if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
-    {
-      if (c == 'p')
-	{
-	  if (getch () == 'r'
-	      && getch () == 'a'
-	      && getch () == 'g'
-	      && getch () == 'm'
-	      && getch () == 'a')
-	    {
-	      /* Read first nonwhite char after the `#pragma'.  */
-
-	      do
-		c = getch ();
-	      while (c == ' ' || c == '\t');
-
-	      if (c == 'v'
-		  && getch () == 't'
-		  && getch () == 'a'
-		  && getch () == 'b'
-		  && getch () == 'l'
-		  && getch () == 'e'
-		  && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
-		{
-		  extern tree pending_vtables;
-
-		  /* More follows: it must be a string constant (class name).  */
-		  token = real_yylex ();
-		  if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
-		    {
-		      error ("invalid #pragma vtable");
-		      goto skipline;
-		    }
-		  if (write_virtuals != 2)
-		    {
-		      warning ("use `+e2' option to enable #pragma vtable");
-		      goto skipline;
-		    }
-		  pending_vtables = perm_tree_cons (NULL_TREE, get_identifier (TREE_STRING_POINTER (yylval.ttype)), pending_vtables);
-		  if (nextchar < 0)
-		    nextchar = getch ();
-		  c = nextchar;
-		  if (c != '\n')
-		    warning ("trailing characters ignored");
-		}
-	      else if (c == 'u'
-		       && getch () == 'n'
-		       && getch () == 'i'
-		       && getch () == 't'
-		       && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
-		{
-		  /* More follows: it must be a string constant (unit name).  */
-		  token = real_yylex ();
-		  if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
-		    {
-		      error ("invalid #pragma unit");
-		      goto skipline;
-		    }
-		  current_unit_name = get_identifier (TREE_STRING_POINTER (yylval.ttype));
-		  current_unit_language = current_lang_name;
-		  if (nextchar < 0)
-		    nextchar = getch ();
-		  c = nextchar;
-		  if (c != '\n')
-		    warning ("trailing characters ignored");
-		}
-	      else if (c == 'i')
-		{
-		  tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
-		  c = getch ();
-
-		  if (c == 'n'
-		      && getch () == 't'
-		      && getch () == 'e'
-		      && getch () == 'r'
-		      && getch () == 'f'
-		      && getch () == 'a'
-		      && getch () == 'c'
-		      && getch () == 'e'
-		      && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
-		    {
-		      /* read to newline.  */
-		      while (c != '\n')
-			c = getch ();
-
-		      write_virtuals = 3;
-
-		      if (impl_file_chain == 0)
-			{
-			  char *filename;
-			  tree fi;
-
-			  /* If this is zero at this point, then we are
-			     auto-implementing.  */
-			  if (main_input_filename == 0)
-			    main_input_filename = input_filename;
-
-			  filename = FILE_NAME_NONDIRECTORY (main_input_filename);
-			  fi = get_time_identifier (filename);
-			  fi = IDENTIFIER_CLASS_VALUE (fi);
-			  TREE_INT_CST_LOW (fi) = 0;
-			  TREE_INT_CST_HIGH (fi) = 1;
-			  /* Get default.  */
-			  impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
-			  impl_file_chain->filename = filename;
-			  impl_file_chain->next = 0;
-			}
-
-		      interface_only = interface_strcmp (input_filename);
-		      interface_unknown = 0;
-		      TREE_INT_CST_LOW (fileinfo) = interface_only;
-		      TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
-		    }
-		  else if (c == 'm'
-			   && getch () == 'p'
-			   && getch () == 'l'
-			   && getch () == 'e'
-			   && getch () == 'm'
-			   && getch () == 'e'
-			   && getch () == 'n'
-			   && getch () == 't'
-			   && getch () == 'a'
-			   && getch () == 't'
-			   && getch () == 'i'
-			   && getch () == 'o'
-			   && getch () == 'n'
-			   && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
-		    {
-		      char *main_filename = main_input_filename ? main_input_filename : input_filename;
-
-		      while (c == ' ' || c == '\t')
-			c = getch ();
-		      if (c != '\n')
-			{
-			  put_back (c);
-			  token = real_yylex ();
-			  if (token != STRING
-			      || TREE_CODE (yylval.ttype) != STRING_CST)
-			    {
-			      error ("invalid `#pragma implementation'");
-			      goto skipline;
-			    }
-			  main_filename = TREE_STRING_POINTER (yylval.ttype);
-			}
-		      main_filename = FILE_NAME_NONDIRECTORY (main_filename);
-
-		      /* read to newline.  */
-		      while (c != '\n')
-			c = getch ();
-
-		      if (write_virtuals == 3)
-			{
-			  struct impl_files *ifiles = impl_file_chain;
-			  while (ifiles)
-			    {
-			      if (! strcmp (ifiles->filename, main_filename))
-				break;
-			      ifiles = ifiles->next;
-			    }
-			  if (ifiles == 0)
-			    {
-			      ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
-			      ifiles->filename = main_filename;
-			      ifiles->next = impl_file_chain;
-			      impl_file_chain = ifiles;
-			    }
-			}
-		      else if ((main_input_filename != 0
-				&& ! strcmp (main_input_filename, input_filename))
-			       || ! strcmp (input_filename, main_filename))
-			{
-			  write_virtuals = 3;
-			  if (impl_file_chain == 0)
-			    {
-			      impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
-			      impl_file_chain->filename = main_filename;
-			      impl_file_chain->next = 0;
-			    }
-			}
-		      else
-			error ("`#pragma implementation' can only appear at top-level");
-		      interface_only = 0;
-		      /* We make this non-zero so that we infer decl linkage
-			 in the impl file only for variables first declared
-			 in the interface file.  */
-		      interface_unknown = 1;
-		      TREE_INT_CST_LOW (fileinfo) = interface_only;
-		      TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
-		    }
-		}
-	    }
-	  goto skipline;
-	}
-      else if (c == 'd')
-	{
-	  if (getch () == 'e'
-	      && getch () == 'f'
-	      && getch () == 'i'
-	      && getch () == 'n'
-	      && getch () == 'e'
-	      && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
-	    {
-#ifdef DWARF_DEBUGGING_INFO
-	      if ((debug_info_level == DINFO_LEVEL_VERBOSE)
-		  && (write_symbols == DWARF_DEBUG))
-	        dwarfout_define (lineno, get_directive_line (finput));
-#endif /* DWARF_DEBUGGING_INFO */
-	      goto skipline;
-	    }
-	}
-      else if (c == 'u')
-	{
-	  if (getch () == 'n'
-	      && getch () == 'd'
-	      && getch () == 'e'
-	      && getch () == 'f'
-	      && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
-	    {
-#ifdef DWARF_DEBUGGING_INFO
-	      if ((debug_info_level == DINFO_LEVEL_VERBOSE)
-		  && (write_symbols == DWARF_DEBUG))
-	        dwarfout_undef (lineno, get_directive_line (finput));
-#endif /* DWARF_DEBUGGING_INFO */
-	      goto skipline;
-	    }
-	}
-      else if (c == 'l')
-	{
-	  if (getch () == 'i'
-	      && getch () == 'n'
-	      && getch () == 'e'
-	      && ((c = getch ()) == ' ' || c == '\t'))
-	    goto linenum;
-	}
-      else if (c == 'i')
-	{
-	  if (getch () == 'd'
-	      && getch () == 'e'
-	      && getch () == 'n'
-	      && getch () == 't'
-	      && ((c = getch ()) == ' ' || c == '\t'))
-	    {
-#ifdef ASM_OUTPUT_IDENT
-              extern FILE *asm_out_file;
-#endif
-	      /* #ident.  The pedantic warning is now in cccp.c.  */
-
-	      /* Here we have just seen `#ident '.
-		 A string constant should follow.  */
-
-	      while (c == ' ' || c == '\t')
-		c = getch ();
-
-	      /* If no argument, ignore the line.  */
-	      if (c == '\n')
-		return c;
-
-	      put_back (c);
-	      token = real_yylex ();
-	      if (token != STRING
-		  || TREE_CODE (yylval.ttype) != STRING_CST)
-		{
-		  error ("invalid #ident");
-		  goto skipline;
-		}
-
-	      if (! flag_no_ident)
-		{
-#ifdef ASM_OUTPUT_IDENT
-		  ASM_OUTPUT_IDENT (asm_out_file,
-				    TREE_STRING_POINTER (yylval.ttype));
-#endif
-		}
-
-	      /* Skip the rest of this line.  */
-	      goto skipline;
-	    }
-	}
-      else if (c == 'n')
-	{
-	  if (getch () == 'e'
-	      && getch () == 'w'
-	      && getch () == 'w'
-	      && getch () == 'o'
-	      && getch () == 'r'
-	      && getch () == 'l'
-	      && getch () == 'd'
-	      && ((c = getch ()) == ' ' || c == '\t'))
-	    {
-	      /* Used to test incremental compilation.  */
-	      sorry ("#pragma newworld");
-	      goto skipline;
-	    }
-	}
-      error ("undefined or invalid # directive");
-      goto skipline;
-    }
-
-linenum:
-  /* Here we have either `#line' or `# <nonletter>'.
-     In either case, it should be a line number; a digit should follow.  */
-
-  while (c == ' ' || c == '\t')
-    c = getch ();
-
-  /* If the # is the only nonwhite char on the line,
-     just ignore it.  Check the new newline.  */
-  if (c == '\n')
-    return c;
-
-  /* Something follows the #; read a token.  */
-
-  put_back (c);
-  token = real_yylex ();
-
-  if (token == CONSTANT
-      && TREE_CODE (yylval.ttype) == INTEGER_CST)
-    {
-      int old_lineno = lineno;
-      int used_up = 0;
-      /* subtract one, because it is the following line that
-	 gets the specified number */
-
-      int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
-      c = get_last_nonwhite_on_line ();
-      if (c == '\n')
-	{
-	  /* No more: store the line number and check following line.  */
-	  lineno = l;
-	  return c;
-	}
-      put_back (c);
-
-      /* More follows: it must be a string constant (filename).  */
-
-      /* Read the string constant, but don't treat \ as special.  */
-      ignore_escape_flag = 1;
-      token = real_yylex ();
-      ignore_escape_flag = 0;
-
-      if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
-	{
-	  error ("invalid #line");
-	  goto skipline;
-	}
-
-      /* Changing files again.  This means currently collected time
-	 is charged against header time, and body time starts back
-	 at 0.  */
-      if (flag_detailed_statistics)
-	{
-	  int this_time = my_get_run_time ();
-	  tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
-	  header_time += this_time - body_time;
-	  TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
-	    += this_time - body_time;
-	  this_filename_time = time_identifier;
-	  body_time = this_time;
-	}
-
-      if (flag_cadillac)
-	cadillac_note_source ();
-
-      input_filename
-	= (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
-      strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
-      lineno = l;
-      GNU_xref_file (input_filename);
-
-      /* Each change of file name
-	 reinitializes whether we are now in a system header.  */
-      in_system_header = 0;
-
-      if (main_input_filename == 0)
-	{
-	  struct impl_files *ifiles = impl_file_chain;
-
-	  if (ifiles)
-	    {
-	      while (ifiles->next)
-		ifiles = ifiles->next;
-	      ifiles->filename = FILE_NAME_NONDIRECTORY (input_filename);
-	    }
-
-	  main_input_filename = input_filename;
-	  if (write_virtuals == 3)
-	    walk_vtables (set_typedecl_interface_info, set_vardecl_interface_info);
-	}
-
-      extract_interface_info ();
-
-      c = get_last_nonwhite_on_line ();
-      if (c == '\n')
-	{
-	  if (flag_cadillac)
-	    cadillac_switch_source (-1);
-	  return c;
-	}
-      put_back (c);
-
-      token = real_yylex ();
-      used_up = 0;
-
-      /* `1' after file name means entering new file.
-	 `2' after file name means just left a file.  */
-
-      if (token == CONSTANT
-	  && TREE_CODE (yylval.ttype) == INTEGER_CST)
-	{
-	  if (TREE_INT_CST_LOW (yylval.ttype) == 1)
-	    {
-	      /* Pushing to a new file.  */
-	      struct file_stack *p
-		= (struct file_stack *) xmalloc (sizeof (struct file_stack));
-	      input_file_stack->line = old_lineno;
-	      p->next = input_file_stack;
-	      p->name = input_filename;
-	      input_file_stack = p;
-	      input_file_stack_tick++;
-#ifdef DWARF_DEBUGGING_INFO
-	      if (debug_info_level == DINFO_LEVEL_VERBOSE
-		  && write_symbols == DWARF_DEBUG)
-		dwarfout_start_new_source_file (input_filename);
-#endif /* DWARF_DEBUGGING_INFO */
-
-	      used_up = 1;
-	      if (flag_cadillac)
-		cadillac_push_source ();
-	    }
-	  else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
-	    {
-	      /* Popping out of a file.  */
-	      if (input_file_stack->next)
-		{
-		  struct file_stack *p = input_file_stack;
-
-		  if (flag_cadillac)
-		    cadillac_pop_source ();
-
-		  input_file_stack = p->next;
-		  free (p);
-		  input_file_stack_tick++;
-#ifdef DWARF_DEBUGGING_INFO
-		  if (debug_info_level == DINFO_LEVEL_VERBOSE
-		      && write_symbols == DWARF_DEBUG)
-		    dwarfout_resume_previous_source_file (input_file_stack->line);
-#endif /* DWARF_DEBUGGING_INFO */
-		}
-	      else
-		error ("#-lines for entering and leaving files don't match");
-
-	      used_up = 1;
-	    }
-	}
-      else if (flag_cadillac)
-	cadillac_switch_source (-1);
-
-      /* If we have handled a `1' or a `2',
-	 see if there is another number to read.  */
-      if (used_up)
-	{
-	  c = get_last_nonwhite_on_line ();
-	  if (c == '\n')
-	    {
-	      if (flag_cadillac)
-		cadillac_switch_source (-1);
-	      return c;
-	    }
-	  put_back (c);
-
-	  token = real_yylex ();
-	  used_up = 0;
-	}
-
-      /* `3' after file name means this is a system header file.  */
-
-      if (token == CONSTANT
-	  && TREE_CODE (yylval.ttype) == INTEGER_CST
-	  && TREE_INT_CST_LOW (yylval.ttype) == 3)
-	in_system_header = 1;
-
-      /* If NEXTCHAR is not end of line, we don't care what it is.  */
-      if (nextchar == '\n')
-	return '\n';
-    }
-  else
-    error ("invalid #-line");
-
-  /* skip the rest of this line.  */
- skipline:
-  if (c == '\n')
-    return c;
-  while ((c = getch ()) != EOF && c != '\n');
-  return c;
-}
-
-#if 0
-#define isalnum(char) (char >= 'a' ? char <= 'z' : char >= '0' ? char <= '9' || (char >= 'A' && char <= 'Z') : 0)
-#define isdigit(char) (char >= '0' && char <= '9')
-#else
-#include <ctype.h>
-#endif
-
-#define ENDFILE -1  /* token that represents end-of-file */
-
-/* Read an escape sequence, returning its equivalent as a character,
-   or store 1 in *ignore_ptr if it is backslash-newline.  */
-
-static int
-readescape (ignore_ptr)
-     int *ignore_ptr;
-{
-  register int c = getch ();
-  register int code;
-  register unsigned count;
-  unsigned firstdig;
-  int nonnull;
-
-  switch (c)
-    {
-    case 'x':
-      if (warn_traditional)
-	warning ("the meaning of `\\x' varies with -traditional");
-
-      if (flag_traditional)
-	return c;
-
-      code = 0;
-      count = 0;
-      nonnull = 0;
-      while (1)
-	{
-	  c = getch ();
-	  if (! isxdigit (c))
-	    {
-	      put_back (c);
-	      break;
-	    }
-	  code *= 16;
-	  if (c >= 'a' && c <= 'f')
-	    code += c - 'a' + 10;
-	  if (c >= 'A' && c <= 'F')
-	    code += c - 'A' + 10;
-	  if (c >= '0' && c <= '9')
-	    code += c - '0';
-	  if (code != 0 || count != 0)
-	    {
-	      if (count == 0)
-		firstdig = code;
-	      count++;
-	    }
-	  nonnull = 1;
-	}
-      if (! nonnull)
-	error ("\\x used with no following hex digits");
-      else if (count == 0)
-	/* Digits are all 0's.  Ok.  */
-	;
-      else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
-	       || (count > 1
-		   && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
-		       <= firstdig)))
-	warning ("hex escape out of range");
-      return code;
-
-    case '0':  case '1':  case '2':  case '3':  case '4':
-    case '5':  case '6':  case '7':
-      code = 0;
-      count = 0;
-      while ((c <= '7') && (c >= '0') && (count++ < 3))
-	{
-	  code = (code * 8) + (c - '0');
-	  c = getch ();
-	}
-      put_back (c);
-      return code;
-
-    case '\\': case '\'': case '"':
-      return c;
-
-    case '\n':
-      lineno++;
-      *ignore_ptr = 1;
-      return 0;
-
-    case 'n':
-      return TARGET_NEWLINE;
-
-    case 't':
-      return TARGET_TAB;
-
-    case 'r':
-      return TARGET_CR;
-
-    case 'f':
-      return TARGET_FF;
-
-    case 'b':
-      return TARGET_BS;
-
-    case 'a':
-      if (warn_traditional)
-	warning ("the meaning of `\\a' varies with -traditional");
-
-      if (flag_traditional)
-	return c;
-      return TARGET_BELL;
-
-    case 'v':
-      return TARGET_VT;
-
-    case 'e':
-    case 'E':
-      if (pedantic)
-	pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
-      return 033;
-
-    case '?':
-      return c;
-
-      /* `\(', etc, are used at beginning of line to avoid confusing Emacs.  */
-    case '(':
-    case '{':
-    case '[':
-      if (pedantic)
-	pedwarn ("unknown escape sequence `\\%c'", c);
-      return c;
-    }
-  if (c >= 040 && c < 0177)
-    pedwarn ("unknown escape sequence `\\%c'", c);
-  else
-    pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
-  return c;
-}
-
-/* Value is 1 if we should try to make the next identifier look like a
-   typename (when it may be a local variable or a class variable).
-   Value is 0 if we treat this name in a default fashion.
-   Value is -1 if we must not see a type name.  */
-int looking_for_typename = 0;
-
-void
-dont_see_typename ()
-{
-  looking_for_typename = -1;
-  if (yychar == TYPENAME || yychar == PTYPENAME)
-    {
-      yychar = IDENTIFIER;
-      lastiddecl = 0;
-    }
-}
-
-#ifdef __GNUC__
-extern __inline int identifier_type ();
-__inline
-#endif
-int
-identifier_type (decl)
-     tree decl;
-{
-  if (TREE_CODE (decl) == TEMPLATE_DECL
-      && DECL_TEMPLATE_IS_CLASS (decl))
-    return PTYPENAME;
-  if (TREE_CODE (decl) != TYPE_DECL)
-    return IDENTIFIER;
-  return TYPENAME;
-}
-
-void
-see_typename ()
-{
-  looking_for_typename = 0;
-  if (yychar == IDENTIFIER)
-    {
-      lastiddecl = lookup_name (yylval.ttype, -1);
-      if (lastiddecl == 0)
-	{
-	  if (flag_labels_ok)
-	    lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
-	}
-      else
-	yychar = identifier_type (lastiddecl);
-    }
-}
-
-tree
-do_identifier (token)
-     register tree token;
-{
-  register tree id = lastiddecl;
-
-  if (yychar == YYEMPTY)
-    yychar = yylex ();
-  /* Scope class declarations before global
-     declarations.  */
-  if (id == IDENTIFIER_GLOBAL_VALUE (token)
-      && current_class_type != 0
-      && TYPE_SIZE (current_class_type) == 0
-      && TREE_CODE (current_class_type) != UNINSTANTIATED_P_TYPE)
-    {
-      /* Could be from one of the base classes.  */
-      tree field = lookup_field (current_class_type, token, 1, 0);
-      if (field == 0)
-	;
-      else if (field == error_mark_node)
-	/* We have already generated the error message.
-	   But we still want to return this value.  */
-	id = lookup_field (current_class_type, token, 0, 0);
-      else if (TREE_CODE (field) == VAR_DECL
-	       || TREE_CODE (field) == CONST_DECL)
-	id = field;
-      else if (TREE_CODE (field) != FIELD_DECL)
-	my_friendly_abort (61);
-      else
-	{
-	  error_with_decl (field, "invalid use of member `%s' from base class `%s'",
-			   TYPE_NAME_STRING (DECL_FIELD_CONTEXT (field)));
-	  id = error_mark_node;
-	  return id;
-	}
-    }
-
-  if (!id || id == error_mark_node)
-    {
-      if (id == error_mark_node && current_class_type != NULL_TREE)
-	{
-	  id = lookup_nested_field (token, 1);
-	  /* In lookup_nested_field(), we marked this so we can gracefully
-	     leave this whole mess.  */
-	  if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
-	    return id;
-	}
-      if (yychar == '(' || yychar == LEFT_RIGHT)
-	{
-	  id = implicitly_declare (token);
-	}
-      else if (current_function_decl == 0)
-	{
-	  error ("`%s' was not declared in this scope",
-		 IDENTIFIER_POINTER (token));
-	  id = error_mark_node;
-	}
-      else
-	{
-	  if (IDENTIFIER_GLOBAL_VALUE (token) != error_mark_node
-	      || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
-	    {
-	      static int undeclared_variable_notice;
-
-	      error ("`%s' undeclared (first use this function)",
-		     IDENTIFIER_POINTER (token));
-
-	      if (! undeclared_variable_notice)
-		{
-		  error ("(Each undeclared identifier is reported only once");
-		  error ("for each function it appears in.)");
-		  undeclared_variable_notice = 1;
-		}
-	    }
-	  id = error_mark_node;
-	  /* Prevent repeated error messages.  */
-	  IDENTIFIER_GLOBAL_VALUE (token) = error_mark_node;
-	  SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
-	}
-    }
-  /* TREE_USED is set in `hack_identifier'.  */
-  if (TREE_CODE (id) == CONST_DECL)
-    {
-      if (IDENTIFIER_CLASS_VALUE (token) == id)
-	{
-	  /* Check visibility.  */
-	  enum visibility_type visibility
-	    = compute_visibility (TYPE_BINFO (current_class_type), id);
-	  if (visibility == visibility_private)
-	    error_with_decl (id, "enum `%s' is private");
-	  /* protected is OK, since it's an enum of `this'.  */
-	}
-      id = DECL_INITIAL (id);
-    }
-  else
-    id = hack_identifier (id, token, yychar);
-  return id;
-}
-
-tree
-identifier_typedecl_value (node)
-     tree node;
-{
-  tree t, type;
-  type = IDENTIFIER_TYPE_VALUE (node);
-  if (type == NULL_TREE)
-    return NULL_TREE;
-#define do(X) \
-  { \
-    t = (X); \
-    if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
-      return t; \
-  }
-  do (IDENTIFIER_LOCAL_VALUE (node));
-  do (IDENTIFIER_CLASS_VALUE (node));
-  do (IDENTIFIER_GLOBAL_VALUE (node));
-#undef do
-  /* Will this one ever happen?  */
-  if (TYPE_NAME (type))
-    return TYPE_NAME (type);
-
-  /* We used to do an internal error of 62 here, but instead we will
-     handle the return of a null appropriately in the callers.  */
-  return NULL_TREE;
-}
-
-struct try_type
-{
-  tree *node_var;
-  char unsigned_flag;
-  char long_flag;
-  char long_long_flag;
-};
-
-struct try_type type_sequence[] = 
-{
-  { &integer_type_node, 0, 0, 0},
-  { &unsigned_type_node, 1, 0, 0},
-  { &long_integer_type_node, 0, 1, 0},
-  { &long_unsigned_type_node, 1, 1, 0},
-  { &long_long_integer_type_node, 0, 1, 1},
-  { &long_long_unsigned_type_node, 1, 1, 1}
-};
-
-int
-real_yylex ()
-{
-  tree tmp;
-  register int c;
-  register int value;
-  int wide_flag = 0;
-  int dollar_seen = 0;
-  int i;
-
-  if (nextchar >= 0)
-    c = nextchar, nextchar = -1;
-  else
-    c = getch ();
-
-  /* Effectively do c = skip_white_space (c)
-     but do it faster in the usual cases.  */
-  while (1)
-    switch (c)
-      {
-      case ' ':
-      case '\t':
-      case '\f':
-      case '\v':
-      case '\b':
-	c = getch ();
-	break;
-
-      case '\r':
-	/* Call skip_white_space so we can warn if appropriate.  */
-
-      case '\n':
-      case '/':
-      case '\\':
-	c = skip_white_space (c);
-      default:
-	goto found_nonwhite;
-      }
- found_nonwhite:
-
-  token_buffer[0] = c;
-  token_buffer[1] = 0;
-
-/*  yylloc.first_line = lineno; */
-
-  switch (c)
-    {
-    case EOF:
-      token_buffer[0] = '\0';
-      end_of_file = 1;
-      if (input_redirected ())
-	value = END_OF_SAVED_INPUT;
-      else if (do_pending_expansions ())
-	/* this will set yychar for us */
-	return yychar;
-      else
-	value = ENDFILE;
-      break;
-
-    case '$':
-      if (dollars_in_ident)
-	{
-	  dollar_seen = 1;
-	  goto letter;
-	}
-      value = '$';
-      goto done;
-
-    case 'L':
-      /* Capital L may start a wide-string or wide-character constant.  */
-      {
-	register int c = getch ();
-	if (c == '\'')
-	  {
-	    wide_flag = 1;
-	    goto char_constant;
-	  }
-	if (c == '"')
-	  {
-	    wide_flag = 1;
-	    goto string_constant;
-	  }
-	put_back (c);
-      }
-
-    case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
-    case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
-    case 'K':		  case 'M':  case 'N':  case 'O':
-    case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
-    case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
-    case 'Z':
-    case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
-    case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
-    case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
-    case 'p':  case 'q':  case 'r':  case 's':  case 't':
-    case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
-    case 'z':
-    case '_':
-    letter:
-      {
-	register char *p;
-
-	p = token_buffer;
-	if (input == 0)
-	  {
-	    /* We know that `token_buffer' can hold at least on char,
-	       so we install C immediately.
-	       We may have to read the value in `putback_char', so call
-	       `getch' once.  */
-	    *p++ = c;
-	    c = getch ();
-
-	    /* Make this run fast.  We know that we are reading straight
-	       from FINPUT in this case (since identifiers cannot straddle
-	       input sources.  */
-	    while (isalnum (c) || (c == '_') || c == '$')
-	      {
-		if (p >= token_buffer + maxtoken)
-		  p = extend_token_buffer (p);
-		if (c == '$' && ! dollars_in_ident)
-		  break;
-
-		*p++ = c;
-		c = getc (finput);
-	      }
-	  }
-	else
-	  {
-	    /* We know that `token_buffer' can hold at least on char,
-	       so we install C immediately.  */
-	    *p++ = c;
-	    c = getch ();
-
-	    while (isalnum (c) || (c == '_') || c == '$')
-	      {
-		if (p >= token_buffer + maxtoken)
-		  p = extend_token_buffer (p);
-		if (c == '$' && ! dollars_in_ident)
-		  break;
-
-		*p++ = c;
-		c = getch ();
-	      }
-	  }
-
-	*p = 0;
-	nextchar = c;
-
-	value = IDENTIFIER;
-	yylval.itype = 0;
-
-      /* Try to recognize a keyword.  Uses minimum-perfect hash function */
-
-	{
-	  register struct resword *ptr;
-
-	  if (ptr = is_reserved_word (token_buffer, p - token_buffer))
-	    {
-	      if (ptr->rid)
-		{
-		  tree old_ttype = ridpointers[(int) ptr->rid];
-
-		  /* If this provides a type for us, then revert lexical
-		     state to standard state.  */
-		  if (TREE_CODE (old_ttype) == IDENTIFIER_NODE
-		      && IDENTIFIER_GLOBAL_VALUE (old_ttype) != 0
-		      && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype)) == TYPE_DECL)
-		    looking_for_typename = 0;
-		  else if (ptr->token == AGGR || ptr->token == ENUM)
-		    looking_for_typename = 1;
-
-		  /* Check if this is a language-type declaration.
-		     Just glimpse the next non-white character.  */
-		  nextchar = skip_white_space (nextchar);
-		  if (nextchar == '"')
-		    {
-		      /* We are looking at a string.  Complain
-			 if the token before the string is no `extern'.
-			 
-			 Could cheat some memory by placing this string
-			 on the temporary_, instead of the saveable_
-			 obstack.  */
-
-		      if (ptr->rid != RID_EXTERN)
-			error ("invalid modifier `%s' for language string",
-			       ptr->name);
-		      real_yylex ();
-		      value = EXTERN_LANG_STRING;
-		      yylval.ttype = get_identifier (TREE_STRING_POINTER (yylval.ttype));
-		      break;
-		    }
-		  if (ptr->token == VISSPEC)
-		    {
-		      switch (ptr->rid)
-			{
-			case RID_PUBLIC:
-			  yylval.itype = visibility_public;
-			  break;
-			case RID_PRIVATE:
-			  yylval.itype = visibility_private;
-			  break;
-			case RID_PROTECTED:
-			  yylval.itype = visibility_protected;
-			  break;
-			default:
-			  my_friendly_abort (63);
-			}
-		    }
-		  else
-		    yylval.ttype = old_ttype;
-		}
-	      value = (int) ptr->token;
-	    }
-	}
-
-	/* If we did not find a keyword, look for an identifier
-	   (or a typename).  */
-
-	if (value == IDENTIFIER || value == TYPESPEC)
-	  GNU_xref_ref (current_function_decl, token_buffer);
-
-	if (value == IDENTIFIER)
-	  {
-	    tmp = get_identifier (token_buffer);
-
-#if !defined(VMS) && defined(JOINER)
-	    /* Make sure that user does not collide with our internal
-	       naming scheme.  */
-	    if (JOINER == '$'
-		&& dollar_seen
-		&& (THIS_NAME_P (tmp)
-		    || VPTR_NAME_P (tmp)
-		    || DESTRUCTOR_NAME_P (tmp)
-		    || VTABLE_NAME_P (tmp)
-		    || TEMP_NAME_P (tmp)
-		    || ANON_AGGRNAME_P (tmp)
-		    || ANON_PARMNAME_P (tmp)))
-	      warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
-		       token_buffer);
-#endif
-
-	    yylval.ttype = tmp;
-
-#if 0
-	    /* This can not be done this way in C++ because
-	       lookup_name can find ambiguous names, and yield an
-	       error.  Because this routine can be called at token
-	       scan time, this is unacceptable.  (mrs) */
-
-	    /* A user-invisible read-only initialized variable
-	       should be replaced by its value.  We only handle strings
-	       since that's the only case used in C (and C++).  */
-	    tmp = lookup_name (yylval.ttype, 0);
-	    if (tmp != NULL_TREE && TREE_CODE (tmp) == VAR_DECL
-		&& DECL_IGNORED_P (tmp)
-		&& TREE_READONLY (tmp)
-		&& DECL_INITIAL (tmp) != NULL_TREE
-		&& TREE_CODE (DECL_INITIAL (tmp)) == STRING_CST)
-	      {
-		yylval.ttype = DECL_INITIAL (tmp);
-		value = STRING;
-	      }
-#endif
-	  }
-	if (value == NEW && ! global_bindings_p ())
-	  {
-	    looking_for_typename = 1;
-	    value = NEW;
-	    goto done;
-	  }
-      }
-      break;
-
-    case '.':
-      {
-	register int c1 = getch ();
-	token_buffer[0] = c;
-	token_buffer[1] = c1;
-	if (c1 == '*')
-	  {
-	    value = DOT_STAR;
-	    token_buffer[2] = 0;
-	    goto done;
-	  }
-	if (c1 == '.')
-	  {
-	    c1 = getch ();
-	    if (c1 == '.')
-	      {
-		token_buffer[2] = c1;
-		token_buffer[3] = 0;
-		value = ELLIPSIS;
-		goto done;
-	      }
-	    nextchar = c1;
-	    token_buffer[2] = '\0';
-	    value = RANGE;
-	    goto done;
-	  }
-	if (isdigit (c1))
-	  {
-	    put_back (c1);
-	    goto resume_numerical_scan;
-	  }
-	nextchar = c1;
-	value = '.';
-	token_buffer[1] = 0;
-	goto done;
-      }
-    case '0':  case '1':
-	/* Optimize for most frequent case.  */
-      {
-	register int c1 = getch ();
-	if (! isalnum (c1) && c1 != '.')
-	  {
-	    /* Terminate string.  */
-	    token_buffer[0] = c;
-	    token_buffer[1] = 0;
-	    if (c == '0')
-	      yylval.ttype = integer_zero_node;
-	    else
-	      yylval.ttype = integer_one_node;
-	    nextchar = c1;
-	    value = CONSTANT;
-	    goto done;
-	  }
-	put_back (c1);
-      }
-      /* fall through... */
-			  case '2':  case '3':  case '4':
-    case '5':  case '6':  case '7':  case '8':  case '9':
-    resume_numerical_scan:
-      {
-	register char *p;
-	int base = 10;
-	int count = 0;
-	int largest_digit = 0;
-	int numdigits = 0;
-	/* for multi-precision arithmetic,
-	   we store only 8 live bits in each short.  */
-	short shorts[MAX_SHORTS];
-	int overflow = 0;
-
-	enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
-	  = NOT_FLOAT;
-
-	p = token_buffer;
-	*p++ = c;
-
-	for (count = 0; count < MAX_SHORTS; count++)
-	  shorts[count] = 0;
-
-	if (c == '0')
-	  {
-	    *p++ = (c = getch ());
-	    if ((c == 'x') || (c == 'X'))
-	      {
-		base = 16;
-		*p++ = (c = getch ());
-	      }
-	    /* Leading 0 forces octal unless the 0 is the only digit.  */
-	    else if (c >= '0' && c <= '9')
-	      {
-		base = 8;
-		numdigits++;
-	      }
-	    else
-	      numdigits++;
-	  }
-
-	/* Read all the digits-and-decimal-points.  */
-
-	while (c == '.'
-	       || (isalnum (c) && (c != 'l') && (c != 'L')
-		   && (c != 'u') && (c != 'U')
-		   && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
-	  {
-	    if (c == '.')
-	      {
-		if (base == 16)
-		  error ("floating constant may not be in radix 16");
-		if (floatflag == AFTER_POINT)
-		  {
-		    error ("malformed floating constant");
-		    floatflag = TOO_MANY_POINTS;
-		  }
-		else
-		  floatflag = AFTER_POINT;
-
-		base = 10;
-		*p++ = c = getch ();
-		/* Accept '.' as the start of a floating-point number
-		   only when it is followed by a digit.
-		   Otherwise, unread the following non-digit
-		   and use the '.' as a structural token.  */
-		if (p == token_buffer + 2 && !isdigit (c))
-		  {
-		    if (c == '.')
-		      {
-			c = getch ();
-			if (c == '.')
-			  {
-			    *p++ = '.';
-			    *p = '\0';
-			    value = ELLIPSIS;
-			    goto done;
-			  }
-			nextchar = c;
-			token_buffer[2] = '\0';
-			value = RANGE;
-			goto done;
-		      }
-		    nextchar = c;
-		    token_buffer[1] = '\0';
-		    value = '.';
-		    goto done;
-		  }
-	      }
-	    else
-	      {
-		/* It is not a decimal point.
-		   It should be a digit (perhaps a hex digit).  */
-
-		if (isdigit (c))
-		  {
-		    c = c - '0';
-		  }
-		else if (base <= 10)
-		  {
-		    if (c == 'e' || c == 'E')
-		      {
-			base = 10;
-			floatflag = AFTER_POINT;
-			break;   /* start of exponent */
-		      }
-		    error ("nondigits in number and not hexadecimal");
-		    c = 0;
-		  }
-		else if (c >= 'a')
-		  {
-		    c = c - 'a' + 10;
-		  }
-		else
-		  {
-		    c = c - 'A' + 10;
-		  }
-		if (c >= largest_digit)
-		  largest_digit = c;
-		numdigits++;
-
-		for (count = 0; count < MAX_SHORTS; count++)
-		  {
-		    shorts[count] *= base;
-		    if (count)
-		      {
-			shorts[count] += (shorts[count-1] >> 8);
-			shorts[count-1] &= (1<<8)-1;
-		      }
-		    else shorts[0] += c;
-		  }
-
-		if (shorts[MAX_SHORTS - 1] >= 1<<8
-		    || shorts[MAX_SHORTS - 1] < - (1 << 8))
-		  overflow = TRUE;
-
-		if (p >= token_buffer + maxtoken - 3)
-		  p = extend_token_buffer (p);
-		*p++ = (c = getch ());
-	      }
-	  }
-
-	if (numdigits == 0)
-	  error ("numeric constant with no digits");
-
-	if (largest_digit >= base)
-	  error ("numeric constant contains digits beyond the radix");
-
-	/* Remove terminating char from the token buffer and delimit the string */
-	*--p = 0;
-
-	if (floatflag != NOT_FLOAT)
-	  {
-	    tree type = double_type_node;
-	    char f_seen = 0;
-	    char l_seen = 0;
-	    int garbage_chars = 0, exceeds_double = 0;
-	    REAL_VALUE_TYPE value;
-	    jmp_buf handler;
-
-	    /* Read explicit exponent if any, and put it in tokenbuf.  */
-
-	    if ((c == 'e') || (c == 'E'))
-	      {
-		if (p >= token_buffer + maxtoken - 3)
-		  p = extend_token_buffer (p);
-		*p++ = c;
-		c = getch ();
-		if ((c == '+') || (c == '-'))
-		  {
-		    *p++ = c;
-		    c = getch ();
-		  }
-		if (! isdigit (c))
-		  error ("floating constant exponent has no digits");
-	        while (isdigit (c))
-		  {
-		    if (p >= token_buffer + maxtoken - 3)
-		      p = extend_token_buffer (p);
-		    *p++ = c;
-		    c = getch ();
-		  }
-	      }
-
-	    *p = 0;
-	    errno = 0;
-
-	    /* Convert string to a double, checking for overflow.  */
-	    if (setjmp (handler))
-	      {
-		error ("floating constant out of range");
-		value = dconst0;
-	      }
-	    else
-	      {
-		set_float_handler (handler);
-		/*  The second argument, machine_mode, of REAL_VALUE_ATOF
-		    tells the desired precision of the binary result of
-		    decimal-to-binary conversion. */
-
-		/* Read the suffixes to choose a data type.  */
-		switch (c)
-		  {
-		  case 'f': case 'F':
-		    type = float_type_node;
-		    value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
-		    if (REAL_VALUE_ISINF (value) && pedantic)
-		      pedwarn ("floating point number exceeds range of `float'");
-		    garbage_chars = -1;
-		    break;
-
-		  case 'l': case 'L':
-		    type = long_double_type_node;
-		    value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
-		    if (REAL_VALUE_ISINF (value) && pedantic)
-		      pedwarn (
-			       "floating point number exceeds range of `long double'");
-		    garbage_chars = -1;
-		    break;
-
-		  default:
-		    value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
-		    if (REAL_VALUE_ISINF (value) && pedantic)
-		      pedwarn ("floating point number exceeds range of `double'");
-		  }
-		set_float_handler (NULL);
-	      }
-#ifdef ERANGE
-	    if (errno == ERANGE && !flag_traditional && pedantic)
-	      {
-		char *p1 = token_buffer;
-		/* Check for "0.0" and variants;
-		   SunOS 4 spuriously returns ERANGE for them.  */
-		while (*p1 == '0') p1++;
-		if (*p1 == '.')
-  		  {
-		    p1++;
-		    while (*p1 == '0') p1++;
-  		  }
-		if (*p1 == 'e' || *p1 == 'E')
-		  {
-		    /* with significand==0, ignore the exponent */
-		    p1++;
-		    while (*p1 != 0) p1++;
-		  }
-  		/* ERANGE is also reported for underflow,
-  		   so test the value to distinguish overflow from that.  */
-		if (REAL_VALUES_LESS (dconst1, value)
-		    || REAL_VALUES_LESS (value, dconstm1))
-		  {
-		    pedwarn ("floating point number exceeds range of `double'");
-		    exceeds_double = 1;
-		  }
-	      }
-#endif
-	    /* Note: garbage_chars is -1 if first char is *not* garbage.  */
-	    while (isalnum (c))
-	      {
-		if (c == 'f' || c == 'F')
-		  {
-		    if (f_seen)
-		      error ("two `f's in floating constant");
-		    f_seen = 1;
-		  }
-		if (c == 'l' || c == 'L')
-		  {
-		    if (l_seen)
-		      error ("two `l's in floating constant");
-		    l_seen = 1;
-		  }
-		if (p >= token_buffer + maxtoken - 3)
-		  p = extend_token_buffer (p);
-		*p++ = c;
-		c = getch ();
-		garbage_chars++;
-	      }
-
-	    if (garbage_chars > 0)
-	      error ("garbage at end of number");
-
-	    /* Create a node with determined type and value.  */
-	    yylval.ttype = build_real (type, value);
-
-	    put_back (c);
-	    *p = 0;
-	  }
-	else
-	  {
-	    tree type;
-	    HOST_WIDE_INT high, low;
-	    int spec_unsigned = 0;
-	    int spec_long = 0;
-	    int spec_long_long = 0;
-
-	    while (1)
-	      {
-		if (c == 'u' || c == 'U')
-		  {
-		    if (spec_unsigned)
-		      error ("two `u's in integer constant");
-		    spec_unsigned = 1;
-		  }
-		else if (c == 'l' || c == 'L')
-		  {
-		    if (spec_long)
-		      {
-			if (spec_long_long)
-			  error ("three `l's in integer constant");
-			else if (pedantic)
-			  pedwarn ("ANSI C++ forbids long long integer constants");
-			spec_long_long = 1;
-		      }
-		    spec_long = 1;
-		  }
-		else
-		  {
-		    if (isalnum (c))
-		      {
-			error ("garbage at end of number");
-			while (isalnum (c))
-			  {
-			    if (p >= token_buffer + maxtoken - 3)
-			      p = extend_token_buffer (p);
-			    *p++ = c;
-			    c = getch ();
-			  }
-		      }
-		    break;
-		  }
-		if (p >= token_buffer + maxtoken - 3)
-		  p = extend_token_buffer (p);
-		*p++ = c;
-		c = getch ();
-	      }
-
-	    put_back (c);
-
-	    /* ??? This code assumes that everything but long long is 32-bits.
-	       Probably this code needs to be replaced with code similar
-	       to that in c-lex.c, but I don't want to do it. -- RK.  */
-
-	    if ((overflow || shorts[7] || shorts[6] || shorts[5] || shorts[4])
-		&& !spec_long_long)
-	      warning ("integer constant out of range");
-
-	    /* If it won't fit in a signed long long, make it unsigned.
-	       We can't distinguish based on the tree node because
-	       any integer constant fits any long long type.  */
-	    if (shorts[7] >= (1<<8))
-	      spec_unsigned = 1;
-
-	    /* This is simplified by the fact that our constant
-	       is always positive.  */
-	    high = low = 0;
-
-	    for (i = 0; i < MAX_SHORTS / 2; i++)
-	      {
-		high |= (HOST_WIDE_INT) shorts[i + MAX_SHORTS / 2] << (i * 8);
-		low |= (HOST_WIDE_INT) shorts[i] << (i * 8);
-	      }
-	    
-	    yylval.ttype = build_int_2 (low, high);
-
-#if 0
-	    /* Find the first allowable type that the value fits in.  */
-	    type = 0;
-	    for (i = 0; i < sizeof (type_sequence) / sizeof (type_sequence[0]);
-		 i++)
-	      if (!(spec_long && !type_sequence[i].long_flag)
-		  && !(spec_long_long && !type_sequence[i].long_long_flag)
-		  && !(spec_unsigned && !type_sequence[i].unsigned_flag)
-		  /* A hex or octal constant traditionally is unsigned.  */
-		  && !(base != 10 && flag_traditional
-		       && !type_sequence[i].unsigned_flag)
-		  /* A decimal constant can't be unsigned int
-		     unless explicitly specified.  */
-		  && !(base == 10 && !spec_unsigned
-		       && *type_sequence[i].node_var == unsigned_type_node))
-		if (int_fits_type_p (yylval.ttype, *type_sequence[i].node_var))
-		  {
-		    type = *type_sequence[i].node_var;
-		    break;
-		  }
-	    if (flag_traditional && type == long_unsigned_type_node
-		&& !spec_unsigned)
-	      type = long_integer_type_node;
-	      
-	    if (type == 0)
-	      {
-		type = long_long_integer_type_node;
-		warning ("integer constant out of range");
-	      }
-
-	    /* Warn about some cases where the type of a given constant
-	       changes from traditional C to ANSI C.  */
-	    if (warn_traditional)
-	      {
-		tree other_type = 0;
-
-		/* This computation is the same as the previous one
-		   except that flag_traditional is used backwards.  */
-		for (i = 0; i < sizeof (type_sequence) / sizeof (type_sequence[0]);
-		     i++)
-		  if (!(spec_long && !type_sequence[i].long_flag)
-		      && !(spec_long_long && !type_sequence[i].long_long_flag)
-		      && !(spec_unsigned && !type_sequence[i].unsigned_flag)
-		      /* A hex or octal constant traditionally is unsigned.  */
-		      && !(base != 10 && !flag_traditional
-			   && !type_sequence[i].unsigned_flag)
-		      /* A decimal constant can't be unsigned int
-			 unless explicitly specified.  */
-		      && !(base == 10 && !spec_unsigned
-			   && *type_sequence[i].node_var == unsigned_type_node))
-		    if (int_fits_type_p (yylval.ttype, *type_sequence[i].node_var))
-		      {
-			other_type = *type_sequence[i].node_var;
-			break;
-		      }
-		if (!flag_traditional && type == long_unsigned_type_node
-		    && !spec_unsigned)
-		  type = long_integer_type_node;
-	      
-		if (other_type != 0 && other_type != type)
-		  {
-		    if (flag_traditional)
-		      warning ("type of integer constant would be different without -traditional");
-		    else
-		      warning ("type of integer constant would be different with -traditional");
-		  }
-	      }
-
-#else /* 1 */
-	    if (!spec_long && !spec_unsigned
-		&& !(flag_traditional && base != 10)
-		&& int_fits_type_p (yylval.ttype, integer_type_node))
-	      {
-#if 0
-		if (warn_traditional && base != 10)
-		  warning ("small nondecimal constant becomes signed in ANSI C++");
-#endif
-		type = integer_type_node;
-	      }
-	    else if (!spec_long && (base != 10 || spec_unsigned)
-		     && int_fits_type_p (yylval.ttype, unsigned_type_node))
-	      {
-		/* Nondecimal constants try unsigned even in traditional C.  */
-		type = unsigned_type_node;
-	      }
-
-	    else if (!spec_unsigned && !spec_long_long
-		     && int_fits_type_p (yylval.ttype, long_integer_type_node))
-	      type = long_integer_type_node;
-
-	    else if (! spec_long_long
-		     && int_fits_type_p (yylval.ttype,
-					 long_unsigned_type_node))
-	      {
-#if 0
-		if (warn_traditional && !spec_unsigned)
-		  warning ("large integer constant becomes unsigned in ANSI C++");
-#endif
-		if (flag_traditional && !spec_unsigned)
-		  type = long_integer_type_node;
-		else
-		  type = long_unsigned_type_node;
-	      }
-
-	    else if (! spec_unsigned
-		     && int_fits_type_p (yylval.ttype,
-					 long_long_integer_type_node))
-	      type = long_long_integer_type_node;
-
-	    else if (int_fits_type_p (yylval.ttype,
-				      long_long_unsigned_type_node))
-	      {
-#if 0
-		if (warn_traditional && !spec_unsigned)
-		  warning ("large nondecimal constant is unsigned in ANSI C++");
-#endif
-
-		if (flag_traditional && !spec_unsigned)
-		  type = long_long_integer_type_node;
-		else
-		  type = long_long_unsigned_type_node;
-	      }
-
-	    else
-	      {
-		type = long_long_integer_type_node;
-		warning ("integer constant out of range");
-	      }
-#endif
-
-	    TREE_TYPE (yylval.ttype) = type;
-	    *p = 0;
-	  }
-
-	value = CONSTANT; break;
-      }
-
-    case '\'':
-    char_constant:
-      {
-	register int result = 0;
-	register int num_chars = 0;
-	unsigned width = TYPE_PRECISION (char_type_node);
-	int max_chars;
-
-	if (wide_flag)
-	  {
-	    width = WCHAR_TYPE_SIZE;
-#ifdef MULTIBYTE_CHARS
-	    max_chars = MB_CUR_MAX;
-#else
-	    max_chars = 1;
-#endif
-	  }
-	else
-	  max_chars = TYPE_PRECISION (integer_type_node) / width;
-
-	while (1)
-	  {
-	  tryagain:
-
-	    c = getch ();
-
-	    if (c == '\'' || c == EOF)
-	      break;
-
-	    if (c == '\\')
-	      {
-		int ignore = 0;
-		c = readescape (&ignore);
-		if (ignore)
-		  goto tryagain;
-		if (width < HOST_BITS_PER_INT
-		    && (unsigned) c >= (1 << width))
-		  pedwarn ("escape sequence out of range for character");
-#ifdef MAP_CHARACTER
-		if (isprint (c))
-		  c = MAP_CHARACTER (c);
-#endif
-	      }
-	    else if (c == '\n')
-	      {
-		if (pedantic)
-		  pedwarn ("ANSI C++ forbids newline in character constant");
-		lineno++;
-	      }
-#ifdef MAP_CHARACTER
-	    else
-	      c = MAP_CHARACTER (c);
-#endif
-
-	    num_chars++;
-	    if (num_chars > maxtoken - 4)
-	      extend_token_buffer (token_buffer);
-
-	    token_buffer[num_chars] = c;
-
-	    /* Merge character into result; ignore excess chars.  */
-	    if (num_chars < max_chars + 1)
-	      {
-		if (width < HOST_BITS_PER_INT)
-		  result = (result << width) | (c & ((1 << width) - 1));
-		else
-		  result = c;
-	      }
-	  }
-
-	token_buffer[num_chars + 1] = '\'';
-	token_buffer[num_chars + 2] = 0;
-
-	if (c != '\'')
-	  error ("malformatted character constant");
-	else if (num_chars == 0)
-	  error ("empty character constant");
-	else if (num_chars > max_chars)
-	  {
-	    num_chars = max_chars;
-	    error ("character constant too long");
-	  }
-	else if (num_chars != 1 && ! flag_traditional)
-	  warning ("multi-character character constant");
-
-	/* If char type is signed, sign-extend the constant.  */
-	if (! wide_flag)
-	  {
-	    int num_bits = num_chars * width;
-	    if (TREE_UNSIGNED (char_type_node)
-		|| ((result >> (num_bits - 1)) & 1) == 0)
-	      yylval.ttype
-		= build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
-					 >> (HOST_BITS_PER_INT - num_bits)),
-			       0);
-	    else
-	      yylval.ttype
-		= build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
-					  >> (HOST_BITS_PER_INT - num_bits)),
-			       -1);
-	    if (num_chars<=1)
-	      TREE_TYPE (yylval.ttype) = char_type_node;
-	    else
-	      TREE_TYPE (yylval.ttype) = integer_type_node;
-	  }
-	else
-	  {
-#ifdef MULTIBYTE_CHARS
-	    /* Set the initial shift state and convert the next sequence.  */
-	    result = 0;
-	    /* In all locales L'\0' is zero and mbtowc will return zero,
-	       so don't use it.  */
-	    if (num_chars > 1
-		|| (num_chars == 1 && token_buffer[1] != '\0'))
-	      {
-		wchar_t wc;
-		(void) mbtowc (NULL, NULL, 0);
-		if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
-		  result = wc;
-		else
-		  warning ("Ignoring invalid multibyte character");
-	      }
-#endif
-	    yylval.ttype = build_int_2 (result, 0);
-	    TREE_TYPE (yylval.ttype) = wchar_type_node;
-	  }
-
-	value = CONSTANT;
-	break;
-      }
-
-    case '"':
-    string_constant:
-      {
-	register char *p;
-
-	c = getch ();
-	p = token_buffer + 1;
-
-	while (c != '"' && c >= 0)
-	  {
-	    /* ignore_escape_flag is set for reading the filename in #line.  */
-	    if (!ignore_escape_flag && c == '\\')
-	      {
-		int ignore = 0;
-		c = readescape (&ignore);
-		if (ignore)
-		  goto skipnewline;
-		if (!wide_flag
-		    && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
-		    && c >= ((unsigned) 1 << TYPE_PRECISION (char_type_node)))
-		  pedwarn ("escape sequence out of range for character");
-	      }
-	    else if (c == '\n')
-	      {
-		if (pedantic)
-		  pedwarn ("ANSI C++ forbids newline in string constant");
-		lineno++;
-	      }
-
-	    if (p == token_buffer + maxtoken)
-	      p = extend_token_buffer (p);
-	    *p++ = c;
-
-	  skipnewline:
-	    c = getch ();
-	    if (c == EOF) {
-		error("Unterminated string");
-		break;
-	    }
-	  }
-	*p = 0;
-
-	/* We have read the entire constant.
-	   Construct a STRING_CST for the result.  */
-
-	if (wide_flag)
-	  {
-	    /* If this is a L"..." wide-string, convert the multibyte string
-	       to a wide character string.  */
-	    char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
-	    int len;
-
-#ifdef MULTIBYTE_CHARS
-	    len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
-	    if (len < 0 || len >= (p - token_buffer))
-	      {
-		warning ("Ignoring invalid multibyte string");
-		len = 0;
-	      }
-	    bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
-#else
-	    {
-	      union { long l; char c[sizeof (long)]; } u;
-	      int big_endian;
-	      char *wp, *cp;
-
-	      /* Determine whether host is little or big endian.  */
-	      u.l = 1;
-	      big_endian = u.c[sizeof (long) - 1];
-	      wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
-
-	      bzero (widep, (p - token_buffer) * WCHAR_BYTES);
-	      for (cp = token_buffer + 1; cp < p; cp++)
-		*wp = *cp, wp += WCHAR_BYTES;
-	      len = p - token_buffer - 1;
-	    }
-#endif
-	    yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
-	    TREE_TYPE (yylval.ttype) = wchar_array_type_node;
-	  }
-	else
-	  {
-	    yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
-	    TREE_TYPE (yylval.ttype) = char_array_type_node;
-	  }
-
-	*p++ = '"';
-	*p = 0;
-
-	value = STRING; break;
-      }
-
-    case '+':
-    case '-':
-    case '&':
-    case '|':
-    case '<':
-    case '>':
-    case '*':
-    case '/':
-    case '%':
-    case '^':
-    case '!':
-    case '=':
-      {
-	register int c1;
-
-      combine:
-
-	switch (c)
-	  {
-	  case '+':
-	    yylval.code = PLUS_EXPR; break;
-	  case '-':
-	    yylval.code = MINUS_EXPR; break;
-	  case '&':
-	    yylval.code = BIT_AND_EXPR; break;
-	  case '|':
-	    yylval.code = BIT_IOR_EXPR; break;
-	  case '*':
-	    yylval.code = MULT_EXPR; break;
-	  case '/':
-	    yylval.code = TRUNC_DIV_EXPR; break;
-	  case '%':
-	    yylval.code = TRUNC_MOD_EXPR; break;
-	  case '^':
-	    yylval.code = BIT_XOR_EXPR; break;
-	  case LSHIFT:
-	    yylval.code = LSHIFT_EXPR; break;
-	  case RSHIFT:
-	    yylval.code = RSHIFT_EXPR; break;
-	  case '<':
-	    yylval.code = LT_EXPR; break;
-	  case '>':
-	    yylval.code = GT_EXPR; break;
-	  }
-
-	token_buffer[1] = c1 = getch ();
-	token_buffer[2] = 0;
-
-	if (c1 == '=')
-	  {
-	    switch (c)
-	      {
-	      case '<':
-		value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
-	      case '>':
-		value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
-	      case '!':
-		value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
-	      case '=':
-		value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
-	      }
-	    value = ASSIGN; goto done;
-	  }
-	else if (c == c1)
-	  switch (c)
-	    {
-	    case '+':
-	      value = PLUSPLUS; goto done;
-	    case '-':
-	      value = MINUSMINUS; goto done;
-	    case '&':
-	      value = ANDAND; goto done;
-	    case '|':
-	      value = OROR; goto done;
-	    case '<':
-	      c = LSHIFT;
-	      goto combine;
-	    case '>':
-	      c = RSHIFT;
-	      goto combine;
-	    }
-	else if ((c == '-') && (c1 == '>'))
-	  {
-	    nextchar = skip_white_space (getch ());
-	    if (nextchar == '(')
-	      {
-		int next_c = skip_white_space (getch ());
-		if (next_c == ')')
-		  {
-		    nextchar = -1;
-		    value = POINTSAT_LEFT_RIGHT;
-		    goto done;
-		  }
-		put_back (next_c);
-	      }
-	    if (nextchar == '*')
-	      {
-		nextchar = -1;
-		value = POINTSAT_STAR;
-	      }
-	    else
-	      value = POINTSAT;
-	    goto done;
-	  }
-	else if (c1 == '?' && (c == '<' || c == '>'))
-	  {
-	    token_buffer[3] = 0;
-
-	    c1 = getch ();
-	    yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
-	    if (c1 == '=')
-	      {
-		/* <?= or >?= expression.  */
-		token_buffer[2] = c1;
-		value = ASSIGN;
-	      }
-	    else
-	      {
-		value = MIN_MAX;
-		nextchar = c1;
-	      }
-	    if (pedantic)
-	      error ("use of `operator %s' is not standard C++",
-		     token_buffer);
-	    goto done;
-	  }
-
-	nextchar = c1;
-	token_buffer[1] = 0;
-
-	value = c;
-	goto done;
-      }
-
-    case ':':
-      c = getch ();
-      if (c == ':')
-	{
-	  token_buffer[1] = ':';
-	  token_buffer[2] = '\0';
-	  value = SCOPE;
-	  yylval.itype = 1;
-	}
-      else
-	{
-	  nextchar = c;
-	  value = ':';
-	}
-      break;
-
-    case 0:
-      /* Don't make yyparse think this is eof.  */
-      value = 1;
-      break;
-
-    case '(':
-      /* try, weakly, to handle casts to pointers to functions.  */
-      nextchar = skip_white_space (getch ());
-      if (nextchar == '*')
-	{
-	  int next_c = skip_white_space (getch ());
-	  if (next_c == ')')
-	    {
-	      nextchar = -1;
-	      yylval.ttype = build1 (INDIRECT_REF, 0, 0);
-	      value = PAREN_STAR_PAREN;
-	    }
-	  else
-	    {
-	      put_back (next_c);
-	      value = c;
-	    }
-	}
-      else if (nextchar == ')')
-	{
-	  nextchar = -1;
-	  yylval.ttype = NULL_TREE;
-	  value = LEFT_RIGHT;
-	}
-      else value = c;
-      break;
-
-    default:
-      value = c;
-    }
-
-done:
-/*  yylloc.last_line = lineno; */
-#ifdef GATHER_STATISTICS
-  token_count[value] += 1;
-#endif
-
-  return value;
-}
-
-typedef enum
-{
-  d_kind, t_kind, s_kind, r_kind, e_kind, c_kind,
-  id_kind, op_id_kind, perm_list_kind, temp_list_kind,
-  vec_kind, x_kind, lang_decl, lang_type, all_kinds
-} tree_node_kind;
-extern int tree_node_counts[];
-extern int tree_node_sizes[];
-extern char *tree_node_kind_names[];
-
-/* Place to save freed lang_decls which were allocated on the
-   permanent_obstack.  @@ Not currently used.  */
-tree free_lang_decl_chain;
-
-tree
-build_lang_decl (code, name, type)
-     enum tree_code code;
-     tree name;
-     tree type;
-{
-  register tree t = build_decl (code, name, type);
-  struct obstack *obstack = current_obstack;
-  register int i = sizeof (struct lang_decl) / sizeof (int);
-  register int *pi;
-
-  if (! TREE_PERMANENT (t))
-    obstack = saveable_obstack;
-  else
-    /* Could be that saveable is permanent and current is not.  */
-    obstack = &permanent_obstack;
-
-  if (free_lang_decl_chain && obstack == &permanent_obstack)
-    {
-      pi = (int *)free_lang_decl_chain;
-      free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
-    }
-  else
-    pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
-
-  while (i > 0)
-    pi[--i] = 0;
-
-  DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
-  LANG_DECL_PERMANENT ((struct lang_decl *) pi)
-    = obstack == &permanent_obstack;
-  my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
-	  == TREE_PERMANENT  (t), 234);
-  DECL_MAIN_VARIANT (t) = t;
-  if (current_lang_name == lang_name_cplusplus)
-    {
-      DECL_LANGUAGE (t) = lang_cplusplus;
-#ifndef NO_AUTO_OVERLOAD
-      if (code == FUNCTION_DECL && name != 0
-	  && ! (IDENTIFIER_LENGTH (name) == 4
-		&& IDENTIFIER_POINTER (name)[0] == 'm'
-		&& strcmp (IDENTIFIER_POINTER (name), "main") == 0)
-	  && ! (IDENTIFIER_LENGTH (name) > 10
-		&& IDENTIFIER_POINTER (name)[0] == '_'
-		&& IDENTIFIER_POINTER (name)[1] == '_'
-		&& strncmp (IDENTIFIER_POINTER (name)+2, "builtin_", 8) == 0))
-	TREE_OVERLOADED (name) = 1;
-#endif
-    }
-  else if (current_lang_name == lang_name_c)
-    DECL_LANGUAGE (t) = lang_c;
-  else my_friendly_abort (64);
-
-#if 0 /* not yet, should get fixed properly later */
-  if (code == TYPE_DECL)
-    {
-      tree id;
-      id = get_identifier (build_overload_name (type, 1, 1));
-      DECL_ASSEMBLER_NAME (t) = id;
-    }
-
-#endif
-#ifdef GATHER_STATISTICS
-  tree_node_counts[(int)lang_decl] += 1;
-  tree_node_sizes[(int)lang_decl] += sizeof(struct lang_decl);
-#endif
-
-  return t;
-}
-
-tree
-build_lang_field_decl (code, name, type)
-     enum tree_code code;
-     tree name;
-     tree type;
-{
-  extern struct obstack *current_obstack, *saveable_obstack;
-  register tree t = build_decl (code, name, type);
-  struct obstack *obstack = current_obstack;
-  register int i = sizeof (struct lang_decl_flags) / sizeof (int);
-  register int *pi;
-#if 0 /* not yet, should get fixed properly later */
-
-  if (code == TYPE_DECL)
-    {
-      tree id;
-      id = get_identifier (build_overload_name (type, 1, 1));
-      DECL_ASSEMBLER_NAME (t) = id;
-    }
-#endif
-
-  if (! TREE_PERMANENT (t))
-    obstack = saveable_obstack;
-  else
-    my_friendly_assert (obstack == &permanent_obstack, 235);
-
-  pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
-  while (i > 0)
-    pi[--i] = 0;
-
-  DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
-  return t;
-}
-
-void
-copy_lang_decl (node)
-     tree node;
-{
-  int size;
-  int *pi;
-
-  if (TREE_CODE (node) == FIELD_DECL)
-    size = sizeof (struct lang_decl_flags);
-  else
-    size = sizeof (struct lang_decl);
-  pi = (int *)obstack_alloc (&permanent_obstack, size);
-  bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
-  DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
-}
-
-tree
-make_lang_type (code)
-     enum tree_code code;
-{
-  extern struct obstack *current_obstack, *saveable_obstack;
-  register tree t = make_node (code);
-  struct obstack *obstack = current_obstack;
-  register int i = sizeof (struct lang_type) / sizeof (int);
-  register int *pi;
-
-  /* Set up some flags that give proper default behavior.  */
-  IS_AGGR_TYPE (t) = 1;
-
-  if (! TREE_PERMANENT (t))
-    obstack = saveable_obstack;
-  else
-    my_friendly_assert (obstack == &permanent_obstack, 236);
-
-  pi = (int *) obstack_alloc (obstack, sizeof (struct lang_type));
-  while (i > 0)
-    pi[--i] = 0;
-
-  TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
-  CLASSTYPE_AS_LIST (t) = build_tree_list (NULL_TREE, t);
-  CLASSTYPE_INTERFACE_UNKNOWN (t) = interface_unknown;
-  CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
-  CLASSTYPE_VBASE_SIZE (t) = integer_zero_node;
-  TYPE_BINFO (t) = make_binfo (integer_zero_node, t, 0, 0, 0);
-  CLASSTYPE_BINFO_AS_LIST (t) = build_tree_list (NULL_TREE, TYPE_BINFO (t));
-
-  /* Make sure this is laid out, for ease of use later.
-     In the presence of parse errors, the normal was of assuring
-     this might not ever get executed, so we lay it out *immediately*.  */
-  build_pointer_type (t);
-
-#ifdef GATHER_STATISTICS
-  tree_node_counts[(int)lang_type] += 1;
-  tree_node_sizes[(int)lang_type] += sizeof(struct lang_type);
-#endif
-
-  return t;
-}
-
-void
-copy_decl_lang_specific (decl)
-     tree decl;
-{
-  extern struct obstack *current_obstack, *saveable_obstack;
-  register int *old = (int *)DECL_LANG_SPECIFIC (decl);
-  struct obstack *obstack = current_obstack;
-  register int i = sizeof (struct lang_decl) / sizeof (int);
-  register int *pi;
-
-  if (! TREE_PERMANENT (decl))
-    obstack = saveable_obstack;
-  else
-    my_friendly_assert (obstack == &permanent_obstack, 237);
-
-  pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
-  while (i-- > 0)
-    pi[i] = old[i];
-
-  DECL_LANG_SPECIFIC (decl) = (struct lang_decl *) pi;
-
-#ifdef GATHER_STATISTICS
-  tree_node_counts[(int)lang_decl] += 1;
-  tree_node_sizes[(int)lang_decl] += sizeof(struct lang_decl);
-#endif
-}
-
-void
-dump_time_statistics ()
-{
-  register tree prev = 0, decl, next;
-  int this_time = my_get_run_time ();
-  TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
-    += this_time - body_time;
-
-  fprintf (stderr, "\n******\n");
-  print_time ("header files (total)", header_time);
-  print_time ("main file (total)", this_time - body_time);
-  fprintf (stderr, "ratio = %g : 1\n",
-	   (double)header_time / (double)(this_time - body_time));
-  fprintf (stderr, "\n******\n");
-
-  for (decl = filename_times; decl; decl = next)
-    {
-      next = IDENTIFIER_GLOBAL_VALUE (decl);
-      IDENTIFIER_GLOBAL_VALUE (decl) = prev;
-      prev = decl;
-    }
-
-  for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
-    print_time (IDENTIFIER_POINTER (decl),
-		TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl)));
-}
-
-void
-compiler_error (s, v, v2)
-     char *s;
-     HOST_WIDE_INT v, v2;			/* @@also used as pointer */
-{
-  char buf[1024];
-  sprintf (buf, s, v, v2);
-  error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
-}
-
-void
-compiler_error_with_decl (decl, s)
-     tree decl;
-     char *s;
-{
-  char *name;
-  count_error (0);
-
-  report_error_function (0);
-
-  if (TREE_CODE (decl) == PARM_DECL)
-    fprintf (stderr, "%s:%d: ",
-	     DECL_SOURCE_FILE (DECL_CONTEXT (decl)),
-	     DECL_SOURCE_LINE (DECL_CONTEXT (decl)));
-  else
-    fprintf (stderr, "%s:%d: ",
-	     DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
-
-  name = lang_printable_name (decl);
-  if (name)
-    fprintf (stderr, s, name);
-  else
-    fprintf (stderr, s, "((anonymous))");
-  fprintf (stderr, " (compiler error)\n");
-}
-
-void
-yyerror (string)
-     char *string;
-{
-  extern int end_of_file;
-  char buf[200];
-
-  strcpy (buf, string);
-
-  /* We can't print string and character constants well
-     because the token_buffer contains the result of processing escapes.  */
-  if (end_of_file)
-    strcat (buf, input_redirected ()
-	    ? " at end of saved text"
-	    : " at end of input");
-  else if (token_buffer[0] == 0)
-    strcat (buf, " at null character");
-  else if (token_buffer[0] == '"')
-    strcat (buf, " before string constant");
-  else if (token_buffer[0] == '\'')
-    strcat (buf, " before character constant");
-  else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
-    sprintf (buf + strlen (buf), " before character 0%o",
-	     (unsigned char) token_buffer[0]);
-  else
-    strcat (buf, " before `%s'");
-
-  error (buf, token_buffer);
-}
diff --git a/gnu/gcc2/cc1plus/cp-lex.h b/gnu/gcc2/cc1plus/cp-lex.h
deleted file mode 100644
index 9df38e5ee403..000000000000
--- a/gnu/gcc2/cc1plus/cp-lex.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/* Define constants and variables for communication with cp-parse.y.
-   Copyright (C) 1987, 1992, 1993 Free Software Foundation, Inc.
-   Hacked by Michael Tiemann (tiemann@cygnus.com)
-   and by Brendan Kehoe (brendan@cygnus.com).
-
-This file is part of GNU CC.
-
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY.  No author or distributor
-accepts responsibility to anyone for the consequences of using it
-or for whether it serves any particular purpose or works at all,
-unless he says so in writing.  Refer to the GNU CC General Public
-License for full details.
-
-Everyone is granted permission to copy, modify and redistribute
-GNU CC, but only under the conditions described in the
-GNU CC General Public License.   A copy of this license is
-supposed to have been given to you along with GNU CC so you
-can know your rights and responsibilities.  It should be in a
-file named COPYING.  Among other things, the copyright notice
-and this notice must be preserved on all copies.  */
-
-
-
-enum rid
-{
-  RID_UNUSED,
-  RID_INT,
-  RID_CHAR,
-  RID_WCHAR,
-  RID_FLOAT,
-  RID_DOUBLE,
-  RID_VOID,
-
-  /* C++ extension */
-  RID_CLASS,
-  RID_RECORD,
-  RID_UNION,
-  RID_ENUM,
-  RID_LONGLONG,
-
-  /* This is where grokdeclarator starts its search when setting the specbits.
-     The first seven are in the order of most frequently used, as found
-     building libg++.  */
-
-  RID_EXTERN,
-  RID_CONST,
-  RID_LONG,
-  RID_TYPEDEF,
-  RID_UNSIGNED,
-  RID_SHORT,
-  RID_INLINE,
-
-  RID_STATIC,
-
-  RID_REGISTER,
-  RID_VOLATILE,
-  RID_FRIEND,
-  RID_VIRTUAL,
-  RID_PUBLIC,
-  RID_PRIVATE,
-  RID_PROTECTED,
-  RID_SIGNED,
-  RID_EXCEPTION,
-  RID_RAISES,
-  RID_AUTO,
-
-  /* Note this is 31, and is unusable in shifts where ints are 32 bits.
-     As soon as a new rid has to be added to this enum, you have to
-     stop and come up with a better way to do all of this than by
-     doing `specbits & (1 << (int) RID_FOO)', since you'll end up
-     with an integer overflow.  */
-  RID_UNUSED1,
-
-  RID_MAX
-};
-
-#define NORID RID_UNUSED
-
-#define RID_FIRST_MODIFIER RID_EXTERN
-
-/* The integral type that can represent all values of RIDBIT.  */
-typedef unsigned long RID_BIT_TYPE;
-
-/* A bit that represents the given RID_... value.  */
-#define RIDBIT(N)  ((RID_BIT_TYPE) 1 << (int) (N))
-
-/* The elements of `ridpointers' are identifier nodes
-   for the reserved type names and storage classes.
-   It is indexed by a RID_... value.  */
-extern tree ridpointers[(int) RID_MAX];
-
-/* the declaration found for the last IDENTIFIER token read in.
-   yylex must look this up to detect typedefs, which get token type TYPENAME,
-   so it is left around in case the identifier is not a typedef but is
-   used in a context which makes it a reference to a variable.  */
-extern tree lastiddecl;
-
-extern char *token_buffer;	/* Pointer to token buffer.  */
-
-/* Back-door communication channel to the lexer.  */
-extern int looking_for_typename;
-
-extern tree make_pointer_declarator (), make_reference_declarator ();
-extern void reinit_parse_for_function ();
-extern void reinit_parse_for_method ();
-extern int yylex ();
diff --git a/gnu/gcc2/cc1plus/cp-method.c b/gnu/gcc2/cc1plus/cp-method.c
deleted file mode 100644
index ab98812ef7d5..000000000000
--- a/gnu/gcc2/cc1plus/cp-method.c
+++ /dev/null
@@ -1,2679 +0,0 @@
-/* Handle the hair of processing (but not expanding) inline functions.
-   Also manage function and variable name overloading.
-   Copyright (C) 1987, 1989, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-#ifndef PARM_CAN_BE_ARRAY_TYPE
-#define PARM_CAN_BE_ARRAY_TYPE 1
-#endif
-
-/* Handle method declarations.  */
-#include <stdio.h>
-#include "config.h"
-#include "tree.h"
-#include "cp-tree.h"
-#include "obstack.h"
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-/* TREE_LIST of the current inline functions that need to be
-   processed.  */
-struct pending_inline *pending_inlines;
-
-/* Obstack where we build text strings for overloading, etc.  */
-static struct obstack scratch_obstack;
-static char *scratch_firstobj;
-
-# define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
-# define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
-# define OB_PUTC2(C1,C2)	\
-  (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2)))
-# define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1))
-# define OB_PUTID(ID)  \
-  (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID),	\
-		 IDENTIFIER_LENGTH (ID)))
-# define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
-# define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
-
-/* Counter to help build parameter names in case they were omitted.  */
-static int dummy_name;
-static int in_parmlist;
-
-/* This points to a safe place to resume processing in case an expression
-   generates an error while we're trying to format it.  */
-static int scratch_error_offset;
-
-static void dump_type (), dump_decl ();
-static void dump_init (), dump_unary_op (), dump_binary_op ();
-
-#ifdef NO_AUTO_OVERLOAD
-int is_overloaded ();
-#endif
-
-void
-init_method ()
-{
-  gcc_obstack_init (&scratch_obstack);
-  scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
-}
-
-tree
-make_anon_parm_name ()
-{
-  char buf[32];
-
-  sprintf (buf, ANON_PARMNAME_FORMAT, dummy_name++);
-  return get_identifier (buf);
-}
-
-void
-clear_anon_parm_name ()
-{
-  /* recycle these names.  */
-  dummy_name = 0;
-}
-
-static void
-dump_readonly_or_volatile (t)
-     tree t;
-{
-  if (TYPE_READONLY (t))
-    OB_PUTS ("const ");
-  if (TYPE_VOLATILE (t))
-    OB_PUTS ("volatile ");
-}
-
-static void
-dump_aggr_type (t)
-     tree t;
-{
-  tree name;
-  char *aggr_string;
-  char *context_string = 0;
-
-  if (TYPE_READONLY (t))
-    OB_PUTS ("const ");
-  if (TYPE_VOLATILE (t))
-    OB_PUTS ("volatile ");
-  if (TREE_CODE (t) == ENUMERAL_TYPE)
-    aggr_string = "enum";
-  else if (TREE_CODE (t) == UNION_TYPE)
-    aggr_string = "union";
-  else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
-    aggr_string = "class";
-  else
-    aggr_string = "struct";
-
-  name = TYPE_NAME (t);
-
-  if (TREE_CODE (name) == TYPE_DECL)
-    {
-#if 0 /* not yet, should get fixed properly later */
-      if (DECL_CONTEXT (name))
-	context_string = TYPE_NAME_STRING (DECL_CONTEXT (name));
-#else
-      if (DECL_LANG_SPECIFIC (name) && DECL_CLASS_CONTEXT (name))
-	context_string = TYPE_NAME_STRING (DECL_CLASS_CONTEXT (name));
-#endif
-      name = DECL_NAME (name);
-    }
-
-  obstack_grow (&scratch_obstack, aggr_string, strlen (aggr_string));
-  OB_PUTC (' ');
-  if (context_string)
-    {
-      obstack_grow (&scratch_obstack, context_string, strlen (context_string));
-      OB_PUTC2 (':', ':');
-    }
-  OB_PUTID (name);
-}
-
-/* This must be large enough to hold any anonymous parm name.  */
-static char anon_buffer[sizeof (ANON_PARMNAME_FORMAT) + 20];
-/* This must be large enough to hold any printed integer or floatingpoint value.  */
-static char digit_buffer[128];
-
-static void
-dump_type_prefix (t, p)
-     tree t;
-     int *p;
-{
-  int old_p = 0;
-
-  if (t == NULL_TREE)
-    return;
-
-  switch (TREE_CODE (t))
-    {
-    case ERROR_MARK:
-      sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
-      OB_PUTCP (anon_buffer);
-      break;
-
-    case UNKNOWN_TYPE:
-      OB_PUTS ("<unknown type>");
-      return;
-
-    case TREE_LIST:
-      dump_type (TREE_VALUE (t), &old_p);
-      if (TREE_CHAIN (t))
-	{
-	  if (TREE_CHAIN (t) != void_list_node)
-	    {
-	      OB_PUTC (',');
-	      dump_type (TREE_CHAIN (t), &old_p);
-	    }
-	}
-      else OB_PUTS ("...");
-      return;
-
-    case POINTER_TYPE:
-      *p += 1;
-      dump_type_prefix (TREE_TYPE (t), p);
-      while (*p)
-	{
-	  OB_PUTC ('*');
-	  *p -= 1;
-	}
-      if (TYPE_READONLY (t))
-	OB_PUTS ("const ");
-      if (TYPE_VOLATILE (t))
-	OB_PUTS ("volatile ");
-      return;
-
-    case OFFSET_TYPE:
-      {
-	tree type = TREE_TYPE (t);
-	if (TREE_CODE (type) == FUNCTION_TYPE)
-	  {
-	    type = TREE_TYPE (type);
-	    if (in_parmlist)
-	      OB_PUTS ("auto ");
-	  }
-
-	dump_type_prefix (type, &old_p);
-
-	OB_PUTC ('(');
-	dump_type (TYPE_OFFSET_BASETYPE (t), &old_p);
-	OB_PUTC2 (':', ':');
-	while (*p)
-	  {
-	    OB_PUTC ('*');
-	    *p -= 1;
-	  }
-	if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	  dump_readonly_or_volatile (t);
-	return;
-      }
-
-    case METHOD_TYPE:
-      {
-	tree type = TREE_TYPE (t);
-	if (in_parmlist)
-	  OB_PUTS ("auto ");
-
-	dump_type_prefix (type, &old_p);
-
-	OB_PUTC ('(');
-	dump_type (TYPE_METHOD_BASETYPE (t), &old_p);
-	OB_PUTC2 (':', ':');
-	while (*p)
-	  {
-	    OB_PUTC ('*');
-	    *p -= 1;
-	  }
-	if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	  dump_readonly_or_volatile (t);
-	return;
-      }
-
-    case REFERENCE_TYPE:
-      dump_type_prefix (TREE_TYPE (t), p);
-      OB_PUTC ('&');
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      return;
-
-    case ARRAY_TYPE:
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      dump_type_prefix (TREE_TYPE (t), p);
-      return;
-
-    case FUNCTION_TYPE:
-      if (in_parmlist)
-	OB_PUTS ("auto ");
-      dump_type_prefix (TREE_TYPE (t), &old_p);
-      OB_PUTC ('(');
-      while (*p)
-	{
-	  OB_PUTC ('*');
-	  *p -= 1;
-	}
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      return;
-
-    case IDENTIFIER_NODE:
-      OB_PUTID (t);
-      OB_PUTC (' ');
-      break;
-
-    case RECORD_TYPE:
-    case UNION_TYPE:
-    case ENUMERAL_TYPE:
-      dump_aggr_type (t);
-      break;
-
-    case TYPE_DECL:
-      if (TYPE_READONLY (t))
-	OB_PUTS ("const ");
-      if (TYPE_VOLATILE (t))
-	OB_PUTS ("volatile ");
-      OB_PUTID (DECL_NAME (t));
-      OB_PUTC (' ');
-      break;
-
-    case INTEGER_TYPE:
-#if 0
-      /* Normally, `unsigned' is part of the deal.  Not so if it comes
-	 with `const' or `volatile'.  */
-      if (TYPE_MAIN_VARIANT (t) == unsigned_type (TYPE_MAIN_VARIANT (t))
-	  && (TYPE_READONLY (t) || TYPE_VOLATILE (t)))
-	OB_PUTS ("unsigned ");
-#endif
-      /* fall through.  */
-    case REAL_TYPE:
-    case VOID_TYPE:
-      if (TYPE_READONLY (t))
-	OB_PUTS ("const ");
-      if (TYPE_VOLATILE (t))
-	OB_PUTS ("volatile ");
-      OB_PUTID (TYPE_IDENTIFIER (t));
-      OB_PUTC (' ');
-      break;
-
-    default:
-      my_friendly_abort (65);
-    }
-}
-
-static void
-dump_type_suffix (t, p)
-     tree t;
-     int *p;
-{
-  int old_p = 0;
-
-  if (t == NULL_TREE)
-    return;
-
-  switch (TREE_CODE (t))
-    {
-    case ERROR_MARK:
-      sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
-      OB_PUTCP (anon_buffer);
-      break;
-
-    case UNKNOWN_TYPE:
-      return;
-
-    case POINTER_TYPE:
-      dump_type_suffix (TREE_TYPE (t), p);
-      return;
-
-    case OFFSET_TYPE:
-      {
-	tree type = TREE_TYPE (t);
-
-	OB_PUTC (')');
-	if (TREE_CODE (type) == FUNCTION_TYPE)
-	  {
-#if 0
-	    tree next_arg = TREE_CHAIN (TYPE_ARG_TYPES (type));
-	    OB_PUTC ('(');
-	    if (next_arg)
-	      {
-		if (next_arg != void_list_node)
-		  {
-		    in_parmlist++;
-		    dump_type (next_arg, &old_p);
-		    in_parmlist--;
-		  }
-	      }
-	    else OB_PUTS ("...");
-	    OB_PUTC (')');
-	    dump_type_suffix (TREE_TYPE (type), p);
-#else
-	    my_friendly_abort (66);
-#endif
-	  }
-	return;
-      }
-
-    case METHOD_TYPE:
-      {
-	tree next_arg;
-	OB_PUTC (')');
-	next_arg = TREE_CHAIN (TYPE_ARG_TYPES (t));
-	OB_PUTC ('(');
-	if (next_arg)
-	  {
-	    if (next_arg != void_list_node)
-	      {
-		in_parmlist++;
-		dump_type (next_arg, &old_p);
-		in_parmlist--;
-	      }
-	  }
-	else OB_PUTS ("...");
-	OB_PUTC (')');
-	dump_readonly_or_volatile (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
-	dump_type_suffix (TREE_TYPE (t), p);
-	return;
-      }
-
-    case REFERENCE_TYPE:
-      dump_type_suffix (TREE_TYPE (t), p);
-      return;
-
-    case ARRAY_TYPE:
-      dump_type_suffix (TREE_TYPE (t), p);
-      OB_PUTC2 ('[', ']');
-      return;
-
-    case FUNCTION_TYPE:
-      OB_PUTC2 (')', '(');
-      if (TYPE_ARG_TYPES (t) && TYPE_ARG_TYPES (t) != void_list_node)
-	{
-	  in_parmlist++;
-	  dump_type (TYPE_ARG_TYPES (t), &old_p);
-	  in_parmlist--;
-	}
-      OB_PUTC (')');
-      dump_type_suffix (TREE_TYPE (t), p);
-      return;
-
-    case IDENTIFIER_NODE:
-    case RECORD_TYPE:
-    case UNION_TYPE:
-    case ENUMERAL_TYPE:
-    case TYPE_DECL:
-    case INTEGER_TYPE:
-    case REAL_TYPE:
-    case VOID_TYPE:
-      return;
-
-    default:
-      my_friendly_abort (67);
-    }
-}
-
-static void
-dump_type (t, p)
-     tree t;
-     int *p;
-{
-  int old_p = 0;
-
-  if (t == NULL_TREE)
-    return;
-
-  switch (TREE_CODE (t))
-    {
-    case ERROR_MARK:
-      sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
-      OB_PUTCP (anon_buffer);
-      break;
-
-    case UNKNOWN_TYPE:
-      OB_PUTS ("<unknown type>");
-      return;
-
-    case TREE_LIST:
-      dump_type (TREE_VALUE (t), &old_p);
-      if (TREE_CHAIN (t))
-	{
-	  if (TREE_CHAIN (t) != void_list_node)
-	    {
-	      OB_PUTC (',');
-	      dump_type (TREE_CHAIN (t), &old_p);
-	    }
-	}
-      else OB_PUTS ("...");
-      return;
-
-    case POINTER_TYPE:
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      *p += 1;
-      dump_type (TREE_TYPE (t), p);
-      while (*p)
-	{
-	  OB_PUTC ('*');
-	  *p -= 1;
-	}
-      return;
-
-    case REFERENCE_TYPE:
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      dump_type (TREE_TYPE (t), p);
-      OB_PUTC ('&');
-      return;
-
-    case ARRAY_TYPE:
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      dump_type (TREE_TYPE (t), p);
-      OB_PUTC2 ('[', ']');
-      return;
-
-    case OFFSET_TYPE:
-    case METHOD_TYPE:
-    case FUNCTION_TYPE:
-      dump_type_prefix (t, p);
-      dump_type_suffix (t, p);
-      return;
-
-    case IDENTIFIER_NODE:
-      OB_PUTID (t);
-      OB_PUTC (' ');
-      break;
-
-    case RECORD_TYPE:
-    case UNION_TYPE:
-    case ENUMERAL_TYPE:
-      dump_aggr_type (t);
-      break;
-
-    case TYPE_DECL:
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      OB_PUTID (DECL_NAME (t));
-      OB_PUTC (' ');
-      break;
-
-    case INTEGER_TYPE:
-      /* Normally, `unsigned' is part of the deal.  Not so if it comes
-	 with `const' or `volatile'.  */
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-#if 0
-      if (TYPE_MAIN_VARIANT (t) == unsigned_type (TYPE_MAIN_VARIANT (t))
-	  && (TYPE_READONLY (t) | TYPE_VOLATILE (t)))
-	OB_PUTS ("unsigned ");
-#endif
-      OB_PUTID (TYPE_IDENTIFIER (t));
-      OB_PUTC (' ');
-      break;
-
-    case REAL_TYPE:
-    case VOID_TYPE:
-      if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
-	dump_readonly_or_volatile (t);
-      OB_PUTID (TYPE_IDENTIFIER (t));
-      OB_PUTC (' ');
-      break;
-
-    case TEMPLATE_TYPE_PARM:
-      OB_PUTS ("<template type parm ");
-      OB_PUTID (TYPE_IDENTIFIER (t));
-      OB_PUTC ('>');
-      break;
-
-    case UNINSTANTIATED_P_TYPE:
-      OB_PUTID (DECL_NAME (UPT_TEMPLATE (t)));
-      OB_PUTS ("<...>");
-      break;
-
-    default:
-      my_friendly_abort (68);
-    }
-}
-
-static void
-dump_decl (t)
-     tree t;
-{
-  int p = 0;
-
-  if (t == NULL_TREE)
-    return;
-
-  switch (TREE_CODE (t))
-    {
-    case ERROR_MARK:
-      OB_PUTS (" /* decl error */ ");
-      break;
-
-    case PARM_DECL:
-      dump_type_prefix (TREE_TYPE (t), &p);
-      if (DECL_NAME (t))
-	dump_decl (DECL_NAME (t));
-      else
-	{
-	  sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
-	  OB_PUTCP (anon_buffer);
-	  break;
-	}
-      dump_type_suffix (TREE_TYPE (t), &p);
-      return;
-
-    case CALL_EXPR:
-      dump_decl (TREE_OPERAND (t, 0));
-      OB_PUTC ('(');
-      in_parmlist++;
-      dump_decl (TREE_OPERAND (t, 1));
-      in_parmlist--;
-      t = tree_last (TYPE_ARG_TYPES (TREE_TYPE (t)));
-      if (!t || t != void_list_node)
-	OB_PUTS ("...");
-      OB_PUTC (')');
-      return;
-
-    case ARRAY_REF:
-      dump_decl (TREE_OPERAND (t, 0));
-      OB_PUTC ('[');
-      dump_decl (TREE_OPERAND (t, 1));
-      OB_PUTC (']');
-      return;
-
-    case TYPE_DECL:
-      OB_PUTID (DECL_NAME (t));
-      OB_PUTC (' ');
-      break;
-
-    case TYPE_EXPR:
-      my_friendly_abort (69);
-      break;
-
-    case IDENTIFIER_NODE:
-      if (t == ansi_opname[(int) TYPE_EXPR])
-	{
-	  OB_PUTS ("operator ");
-	  /* Not exactly IDENTIFIER_TYPE_VALUE.  */
-	  dump_type (TREE_TYPE (t), &p);
-	  return;
-	}
-      else if (IDENTIFIER_OPNAME_P (t))
-	{
-	  char *name_string = operator_name_string (t);
-	  OB_PUTS ("operator ");
-	  OB_PUTCP (name_string);
-	  OB_PUTC (' ');
-	}
-      else
-	{
-	  OB_PUTID (t);
-	  OB_PUTC (' ');
-	}
-      break;
-
-    case BIT_NOT_EXPR:
-      OB_PUTC2 ('~', ' ');
-      dump_decl (TREE_OPERAND (t, 0));
-      return;
-
-    case SCOPE_REF:
-      OB_PUTID (TREE_OPERAND (t, 0));
-      OB_PUTC2 (':', ':');
-      dump_decl (TREE_OPERAND (t, 1));
-      return;
-
-    case INDIRECT_REF:
-      OB_PUTC ('*');
-      dump_decl (TREE_OPERAND (t, 0));
-      return;
-
-    case ADDR_EXPR:
-      OB_PUTC ('&');
-      dump_decl (TREE_OPERAND (t, 0));
-      return;
-
-    default:
-      my_friendly_abort (70);
-    }
-}
-
-static void
-dump_init_list (l)
-     tree l;
-{
-  while (l)
-    {
-      dump_init (TREE_VALUE (l));
-      if (TREE_CHAIN (l))
-	OB_PUTC (',');
-      l = TREE_CHAIN (l);
-    }
-}
-
-static void
-dump_init (t)
-     tree t;
-{
-  int dummy;
-
-  switch (TREE_CODE (t))
-    {
-    case VAR_DECL:
-    case PARM_DECL:
-      OB_PUTC (' ');
-      OB_PUTID (DECL_NAME (t));
-      OB_PUTC (' ');
-      break;
-
-    case FUNCTION_DECL:
-      {
-	tree name = DECL_ASSEMBLER_NAME (t);
-
-	if (DESTRUCTOR_NAME_P (name))
-	  {
-	    OB_PUTC2 (' ', '~');
-	    OB_PUTID (DECL_NAME (t));
-	  }
-	else if (IDENTIFIER_TYPENAME_P (name))
-	  {
-	    dummy = 0;
-	    OB_PUTS ("operator ");
-	    dump_type (TREE_TYPE (name), &dummy);
-	  }
-	else if (IDENTIFIER_OPNAME_P (name))
-	  {
-	    char *name_string = operator_name_string (name);
-	      OB_PUTS ("operator ");
-	    OB_PUTCP (name_string);
-	    OB_PUTC (' ');
-	  }
-	else
-	  {
-	    OB_PUTC (' ');
-	    OB_PUTID (DECL_NAME (t));
-	  }
-	OB_PUTC (' ');
-      }
-      break;
-
-    case CONST_DECL:
-      dummy = 0;
-      OB_PUTC2 ('(', '(');
-      dump_type (TREE_TYPE (t), &dummy);
-      OB_PUTC (')');
-      dump_init (DECL_INITIAL (t));
-      OB_PUTC (')');
-      return;
-
-    case INTEGER_CST:
-      /* If it's an enum, output its tag, rather than its value.  */
-      if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ENUMERAL_TYPE)
-	{
-	  char *p = enum_name_string (t, TREE_TYPE (t));
-	  OB_PUTC (' ');
-	  OB_PUTCP (p);
-	  OB_PUTC (' ');
-	}
-      else
-	sprintf (digit_buffer, " %d ", TREE_INT_CST_LOW (t));
-      OB_PUTCP (digit_buffer);
-      break;
-
-    case REAL_CST:
-      sprintf (digit_buffer, " %g ", TREE_REAL_CST (t));
-      OB_PUTCP (digit_buffer);
-      break;
-
-    case STRING_CST:
-      {
-	char *p = TREE_STRING_POINTER (t);
-	int len = TREE_STRING_LENGTH (t) - 1;
-	int i;
-
-	OB_PUTC ('\"');
-	for (i = 0; i < len; i++)
-	  {
-	    register char c = p[i];
-	    if (c == '\"' || c == '\\')
-	      OB_PUTC ('\\');
-	    if (c >= ' ' && c < 0177)
-	      OB_PUTC (c);
-	    else
-	      {
-		sprintf (digit_buffer, "\\%03o", c);
-		OB_PUTCP (digit_buffer);
-	      }
-	  }
-	OB_PUTC ('\"');
-      }
-      return;
-
-    case COMPOUND_EXPR:
-      dump_binary_op (",", t, 1);
-      break;
-
-    case COND_EXPR:
-      OB_PUTC ('(');
-      dump_init (TREE_OPERAND (t, 0));
-      OB_PUTS (" ? ");
-      dump_init (TREE_OPERAND (t, 1));
-      OB_PUTS (" : ");
-      dump_init (TREE_OPERAND (t, 2));
-      OB_PUTC (')');
-      return;
-
-    case SAVE_EXPR:
-      if (TREE_HAS_CONSTRUCTOR (t))
-	{
-	  dummy = 0;
-	  OB_PUTS ("new ");
-	  dump_type (TREE_TYPE (TREE_TYPE (t)), &dummy);
-	  PARM_DECL_EXPR (t) = 1;
-	}
-      else
-	{
-	  sorry ("operand of SAVE_EXPR not understood");
-	  scratch_obstack.next_free
-	    = obstack_base (&scratch_obstack) + scratch_error_offset;
-	}
-      return;
-
-    case NEW_EXPR:
-      OB_PUTID (TYPE_IDENTIFIER (TREE_TYPE (t)));
-      OB_PUTC ('(');
-      dump_init_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
-      OB_PUTC (')');
-      return;
-
-    case CALL_EXPR:
-      OB_PUTC ('(');
-      dump_init (TREE_OPERAND (t, 0));
-      dump_init_list (TREE_OPERAND (t, 1));
-      OB_PUTC (')');
-      return;
-
-    case WITH_CLEANUP_EXPR:
-      /* Note that this only works for G++ cleanups.  If somebody
-	 builds a general cleanup, there's no way to represent it.  */
-      dump_init (TREE_OPERAND (t, 0));
-      return;
-
-    case TARGET_EXPR:
-      /* Note that this only works for G++ target exprs.  If somebody
-	 builds a general TARGET_EXPR, there's no way to represent that
-	 it initializes anything other that the parameter slot for the
-	 default argument.  Note we may have cleared out the first
-	 operand in expand_expr, so don't go killing ourselves.  */
-      if (TREE_OPERAND (t, 1))
-	dump_init (TREE_OPERAND (t, 1));
-      return;
-
-    case MODIFY_EXPR:
-    case PLUS_EXPR:
-    case MINUS_EXPR:
-    case MULT_EXPR:
-    case TRUNC_DIV_EXPR:
-    case TRUNC_MOD_EXPR:
-    case MIN_EXPR:
-    case MAX_EXPR:
-    case LSHIFT_EXPR:
-    case RSHIFT_EXPR:
-    case BIT_IOR_EXPR:
-    case BIT_XOR_EXPR:
-    case BIT_AND_EXPR:
-    case BIT_ANDTC_EXPR:
-    case TRUTH_ANDIF_EXPR:
-    case TRUTH_ORIF_EXPR:
-    case LT_EXPR:
-    case LE_EXPR:
-    case GT_EXPR:
-    case GE_EXPR:
-    case EQ_EXPR:
-    case NE_EXPR:
-      dump_binary_op (opname_tab[(int) TREE_CODE (t)], t,
-		      strlen (opname_tab[(int) TREE_CODE (t)]));
-      return;
-
-    case CEIL_DIV_EXPR:
-    case FLOOR_DIV_EXPR:
-    case ROUND_DIV_EXPR:
-      dump_binary_op ("/", t, 1);
-      return;
-
-    case CEIL_MOD_EXPR:
-    case FLOOR_MOD_EXPR:
-    case ROUND_MOD_EXPR:
-      dump_binary_op ("%", t, 1);
-      return;
-
-    case COMPONENT_REF:
-      dump_binary_op (".", t, 1);
-      return;
-
-    case CONVERT_EXPR:
-      dump_unary_op ("+", t, 1);
-      return;
-
-    case ADDR_EXPR:
-      if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
-	  || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
-	dump_init (TREE_OPERAND (t, 0));
-      else
-	dump_unary_op ("&", t, 1);
-      return;
-
-    case INDIRECT_REF:
-      if (TREE_HAS_CONSTRUCTOR (t))
-	{
-	  t = TREE_OPERAND (t, 0);
-	  my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
-	  dump_init (TREE_OPERAND (t, 0));
-	  OB_PUTC ('(');
-	  dump_init_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
-	  OB_PUTC (')');
-	}
-      else
-	dump_unary_op ("*", t, 1);
-      return;
-
-    case NEGATE_EXPR:
-    case BIT_NOT_EXPR:
-    case TRUTH_NOT_EXPR:
-    case PREDECREMENT_EXPR:
-    case PREINCREMENT_EXPR:
-      dump_unary_op (opname_tab [(int)TREE_CODE (t)], t,
-		     strlen (opname_tab[(int) TREE_CODE (t)]));
-      return;
-
-    case POSTDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-      OB_PUTC ('(');
-      dump_init (TREE_OPERAND (t, 0));
-      OB_PUTCP (opname_tab[(int)TREE_CODE (t)]);
-      OB_PUTC (')');
-      return;
-
-    case NOP_EXPR:
-      dummy = 0;
-      OB_PUTC2 ('(', '(');
-      dump_type (TREE_TYPE (t), &dummy);
-      OB_PUTC (')');
-      dump_init (TREE_OPERAND (t, 0));
-      OB_PUTC (')');
-      return;
-
-    case CONSTRUCTOR:
-      OB_PUTC ('{');
-      dump_init_list (CONSTRUCTOR_ELTS (t));
-      OB_PUTC ('}');
-      return;
-
-      /*  This list is incomplete, but should suffice for now.
-	  It is very important that `sorry' does not call
-	  `report_error_function'.  That could cause an infinite loop.  */
-    default:
-      sorry ("`%s' not supported for default parameters",
-	     tree_code_name[(int) TREE_CODE (t)]);
-
-      /* fall through to ERROR_MARK...  */
-    case ERROR_MARK:
-      scratch_obstack.next_free
-	= obstack_base (&scratch_obstack) + scratch_error_offset;
-      return;
-    }
-}
-
-static void
-dump_binary_op (opstring, t, len)
-     char *opstring;
-     tree t;
-     int len;
-{
-  OB_PUTC ('(');
-  dump_init (TREE_OPERAND (t, 0));
-  OB_PUTC (' ');
-  OB_PUTCP (opstring);
-  OB_PUTC (' ');
-  dump_init (TREE_OPERAND (t, 1));
-  OB_PUTC (')');
-}
-
-static void
-dump_unary_op (opstring, t, len)
-     char *opstring;
-     tree t;
-     int len;
-{
-  OB_PUTC ('(');
-  OB_PUTC (' ');
-  OB_PUTCP (opstring);
-  OB_PUTC (' ');
-  dump_init (TREE_OPERAND (t, 0));
-  OB_PUTC (')');
-}
-
-/* Pretty printing for announce_function.  CNAME is the TYPE_DECL for
-   the class that FNDECL belongs to, if we could not figure that out
-   from FNDECL itself.  FNDECL is the declaration of the function we
-   are interested in seeing.  PRINT_RET_TYPE_P is non-zero if we
-   should print the type that this function returns.  */
-
-char *
-fndecl_as_string (cname, fndecl, print_ret_type_p)
-     tree cname, fndecl;
-     int print_ret_type_p;
-{
-  tree name = DECL_ASSEMBLER_NAME (fndecl);
-  tree fntype = TREE_TYPE (fndecl);
-  tree parmtypes = TYPE_ARG_TYPES (fntype);
-  int p = 0;
-  int spaces = 0;
-
-  OB_INIT ();
-
-  if (DECL_CLASS_CONTEXT (fndecl))
-    cname = TYPE_NAME (DECL_CLASS_CONTEXT (fndecl));
-
-  if (DECL_STATIC_FUNCTION_P (fndecl))
-      OB_PUTS ("static ");
-    
-  if (print_ret_type_p && ! IDENTIFIER_TYPENAME_P (name))
-    {
-      dump_type_prefix (TREE_TYPE (fntype), &p);
-      OB_PUTC (' ');
-    }
-
-  if (cname)
-    {
-      dump_type (cname, &p);
-      *((char *) obstack_next_free (&scratch_obstack) - 1) = ':';
-      OB_PUTC (':');
-      if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes)
-	parmtypes = TREE_CHAIN (parmtypes);
-      if (DECL_CONSTRUCTOR_FOR_VBASE_P (fndecl))
-	/* Skip past "in_charge" identifier.  */
-	parmtypes = TREE_CHAIN (parmtypes);
-    }
-
-  if (DESTRUCTOR_NAME_P (name))
-    {
-      OB_PUTC ('~');
-      parmtypes = TREE_CHAIN (parmtypes);
-      dump_decl (DECL_NAME (fndecl));
-    }
-  else if (IDENTIFIER_TYPENAME_P (name))
-    {
-      /* This cannot use the hack that the operator's return
-	 type is stashed off of its name because it may be
-	 used for error reporting.  In the case of conflicting
-	 declarations, both will have the same name, yet
-	 the types will be different, hence the TREE_TYPE field
-	 of the first name will be clobbered by the second.  */
-      OB_PUTS ("operator ");
-      dump_type (TREE_TYPE (TREE_TYPE (fndecl)), &p);
-    }
-  else if (IDENTIFIER_OPNAME_P (name))
-    {
-      char *name_string = operator_name_string (name);
-      OB_PUTS ("operator ");
-      OB_PUTCP (name_string);
-      OB_PUTC (' ');
-    }
-  else
-    dump_decl (DECL_NAME (fndecl));
-
-  OB_PUTC ('(');
-  if (parmtypes)
-    {
-      in_parmlist++;
-      if (parmtypes != void_list_node)
-	spaces = 2;
-      while (parmtypes && parmtypes != void_list_node)
-	{
-	  char *last_space;
-	  dump_type (TREE_VALUE (parmtypes), &p);
-	  last_space = (char *)obstack_next_free (&scratch_obstack);
-	  while (last_space[-1] == ' ')
-	    last_space--;
-	  scratch_obstack.next_free = last_space;
-	  if (TREE_PURPOSE (parmtypes))
-	    {
-	      scratch_error_offset = obstack_object_size (&scratch_obstack);
-	      OB_PUTS (" (= ");
-	      dump_init (TREE_PURPOSE (parmtypes));
-	      OB_PUTC (')');
-	    }
-	  OB_PUTC2 (',', ' ');
-	  parmtypes = TREE_CHAIN (parmtypes);
-	}
-      in_parmlist--;
-    }
-  
-  if (parmtypes)
-    {
-      if (spaces)
-	scratch_obstack.next_free = obstack_next_free (&scratch_obstack)-spaces;
-    }
-  else
-    OB_PUTS ("...");
-
-  OB_PUTC (')');
-
-  if (print_ret_type_p && ! IDENTIFIER_TYPENAME_P (name))
-    dump_type_suffix (TREE_TYPE (fntype), &p);
-
-  if (TREE_CODE (fntype) == METHOD_TYPE)
-    dump_readonly_or_volatile (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
-
-  OB_FINISH ();
-  
-  return (char *)obstack_base (&scratch_obstack);
-}
-
-/* Same, but handtype a _TYPE.  */
-char *
-type_as_string (typ)
-     tree typ;
-{
-  int p = 0;
-
-  OB_INIT ();
-
-  dump_type(typ,&p);
-
-  OB_FINISH ();
-
-  return (char *)obstack_base (&scratch_obstack);
-}
-
-/* A cross between type_as_string and fndecl_as_string.  */
-char *
-decl_as_string (decl)
-     tree decl;
-{
-  OB_INIT ();
-
-  dump_decl(decl);
-
-  OB_FINISH ();
-
-  return (char *)obstack_base (&scratch_obstack);
-}
-
-/* Move inline function definitions out of structure so that they
-   can be processed normally.  CNAME is the name of the class
-   we are working from, METHOD_LIST is the list of method lists
-   of the structure.  We delete friend methods here, after
-   saving away their inline function definitions (if any).  */
-
-void
-do_inline_function_hair (type, friend_list)
-     tree type, friend_list;
-{
-  tree method = TYPE_METHODS (type);
-
-  if (method && TREE_CODE (method) == TREE_VEC)
-    {
-      if (TREE_VEC_ELT (method, 0))
-	method = TREE_VEC_ELT (method, 0);
-      else
-	method = TREE_VEC_ELT (method, 1);
-    }
-
-  while (method)
-    {
-      /* Do inline member functions.  */
-      struct pending_inline *info = DECL_PENDING_INLINE_INFO (method);
-      if (info)
-	{
-	  tree args;
-
-	  my_friendly_assert (info->fndecl == method, 238);
-	  args = DECL_ARGUMENTS (method);
-	  while (args)
-	    {
-	      DECL_CONTEXT (args) = method;
-	      args = TREE_CHAIN (args);
-	    }
-
-	  /* Allow this decl to be seen in global scope */
-	  IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (method)) = method;
-	}
-      method = TREE_CHAIN (method);
-    }
-  while (friend_list)
-    {
-      tree fndecl = TREE_VALUE (friend_list);
-      struct pending_inline *info = DECL_PENDING_INLINE_INFO (fndecl);
-      if (info)
-	{
-	  tree args;
-
-	  my_friendly_assert (info->fndecl == fndecl, 239);
-	  args = DECL_ARGUMENTS (fndecl);
-	  while (args)
-	    {
-	      DECL_CONTEXT (args) = fndecl;
-	      args = TREE_CHAIN (args);
-	    }
-
-	  /* Allow this decl to be seen in global scope */
-	  IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (fndecl)) = fndecl;
-	}
-
-      friend_list = TREE_CHAIN (friend_list);
-    }
-}
-
-/* Report an argument type mismatch between the best declared function
-   we could find and the current argument list that we have.  */
-void
-report_type_mismatch (cp, parmtypes, name_kind, err_name)
-     struct candidate *cp;
-     tree parmtypes;
-     char *name_kind, *err_name;
-{
-  int i = cp->u.bad_arg;
-  tree ttf, tta;
-  char *tmp_firstobj;
-
-  switch (i)
-    {
-    case -4:
-      my_friendly_assert (TREE_CODE (cp->function) == TEMPLATE_DECL, 240);
-      error ("type unification failed for function template `%s'", err_name);
-      return;
-
-    case -3:
-      if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))))
-	error ("call to const %s `%s' with non-const object", name_kind, err_name);
-      else
-	error ("call to non-const %s `%s' with const object", name_kind, err_name);
-      return;
-    case -2:
-      error ("too few arguments for %s `%s'", name_kind, err_name);
-      return;
-    case -1:
-      error ("too many arguments for %s `%s'", name_kind, err_name);
-      return;
-    case 0:
-      if (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
-	{
-	  /* Happens when we have an ambiguous base class.  */
-	  my_friendly_assert (get_binfo (DECL_CLASS_CONTEXT (cp->function),
-			     TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))), 1) == error_mark_node,
-			      241);
-	  return;
-	}
-    }
-
-  ttf = TYPE_ARG_TYPES (TREE_TYPE (cp->function));
-  tta = parmtypes;
-
-  while (i-- > 0)
-    {
-      ttf = TREE_CHAIN (ttf);
-      tta = TREE_CHAIN (tta);
-    }
-
-  OB_INIT ();
-  OB_PUTS ("bad argument ");
-  sprintf (digit_buffer, "%d",
-	   cp->u.bad_arg - (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE) + 1);
-  OB_PUTCP (digit_buffer);
-  OB_PUTS (" for function `");
-
-  tmp_firstobj = scratch_firstobj;
-  scratch_firstobj = 0;
-  fndecl_as_string (0, cp->function, 0);
-  scratch_firstobj = tmp_firstobj;
-
-  /* We know that the last char written is next_free-1.  */
-  ((char *) obstack_next_free (&scratch_obstack))[-1] = '\'';
-  OB_PUTS (" (type was ");
-
-  /* Reset `i' so that type printing routines do the right thing.  */
-  if (tta)
-    {
-      enum tree_code code = TREE_CODE (TREE_TYPE (TREE_VALUE (tta)));
-      if (code == ERROR_MARK)
-	OB_PUTS ("(failed type instantiation)");
-      else
-	{
-	  i = (code == FUNCTION_TYPE || code == METHOD_TYPE);
-	  dump_type (TREE_TYPE (TREE_VALUE (tta)), &i);
-	}
-    }
-  else OB_PUTS ("void");
-  OB_PUTC (')');
-  OB_FINISH ();
-
-  tmp_firstobj = (char *)alloca (obstack_object_size (&scratch_obstack));
-  bcopy (obstack_base (&scratch_obstack), tmp_firstobj,
-	 obstack_object_size (&scratch_obstack));
-  error (tmp_firstobj);
-}
-
-/* Here is where overload code starts.  */
-
-/* Array of types seen so far in top-level call to `build_overload_name'.
-   Allocated and deallocated by caller.  */
-static tree *typevec;
-
-/* Number of types interned by `build_overload_name' so far.  */
-static int maxtype;
-
-/* Number of occurrences of last type seen.  */
-static int nrepeats;
-
-/* Nonzero if we should not try folding parameter types.  */
-static int nofold;
-
-#define ALLOCATE_TYPEVEC(PARMTYPES) \
-  do { maxtype = 0, nrepeats = 0; \
-       typevec = (tree *)alloca (list_length (PARMTYPES) * sizeof (tree)); } while (0)
-
-#define DEALLOCATE_TYPEVEC(PARMTYPES) \
-  do { tree t = (PARMTYPES); \
-       while (t) { TREE_USED (TREE_VALUE (t)) = 0; t = TREE_CHAIN (t); } \
-  } while (0)
-
-/* Code to concatenate an asciified integer to a string.  */
-static
-#ifdef __GNUC__
-__inline
-#endif
-void
-icat (i)
-     int i;
-{
-  /* Handle this case first, to go really quickly.  For many common values,
-     the result of i/10 below is 1.  */
-  if (i == 1)
-    {
-      OB_PUTC ('1');
-      return;
-    }
-
-  if (i < 0)
-    {
-      OB_PUTC ('m');
-      i = -i;
-    }
-  if (i < 10)
-    OB_PUTC ('0' + i);
-  else
-    {
-      icat (i / 10);
-      OB_PUTC ('0' + (i % 10));
-    }
-}
-
-static
-#ifdef __GNUC__
-__inline
-#endif
-void
-flush_repeats (type)
-     tree type;
-{
-  int tindex = 0;
-
-  while (typevec[tindex] != type)
-    tindex++;
-
-  if (nrepeats > 1)
-    {
-      OB_PUTC ('N');
-      icat (nrepeats);
-      if (nrepeats > 9)
-	OB_PUTC ('_');
-    }
-  else
-    OB_PUTC ('T');
-  nrepeats = 0;
-  icat (tindex);
-  if (tindex > 9)
-    OB_PUTC ('_');
-}
-
-static void build_overload_identifier ();
-
-static void
-build_overload_nested_name (context)
-     tree context;
-{
-  /* We use DECL_NAME here, because pushtag now sets the DECL_ASSEMBLER_NAME.  */
-  tree name = DECL_NAME (context);
-  if (DECL_CONTEXT (context))
-    {
-      context = DECL_CONTEXT (context);
-      if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
-	context = TYPE_NAME (context);
-      build_overload_nested_name (context);
-    }
-  build_overload_identifier (name);
-}
-
-static void
-build_overload_value (type, value)
-     tree type, value;
-{
-  while (TREE_CODE (value) == NON_LVALUE_EXPR)
-    value = TREE_OPERAND (value, 0);
-  my_friendly_assert (TREE_CODE (type) == PARM_DECL, 242);
-  type = TREE_TYPE (type);
-  switch (TREE_CODE (type))
-    {
-    case INTEGER_TYPE:
-    case ENUMERAL_TYPE:
-      {
-	my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
-	if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
-	  {
-	    if (tree_int_cst_lt (value, integer_zero_node))
-	      {
-		OB_PUTC ('m');
-		value = build_int_2 (~ TREE_INT_CST_LOW (value),
-				     - TREE_INT_CST_HIGH (value));
-	      }
-	    if (TREE_INT_CST_HIGH (value)
-		!= (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
-	      {
-		/* need to print a DImode value in decimal */
-		sorry ("conversion of long long as PT parameter");
-	      }
-	    /* else fall through to print in smaller mode */
-	  }
-	/* Wordsize or smaller */
-	icat (TREE_INT_CST_LOW (value));
-	return;
-      }
-#ifndef REAL_IS_NOT_DOUBLE
-    case REAL_TYPE:
-      {
-	REAL_VALUE_TYPE val;
-	char *bufp = digit_buffer;
-	extern char *index ();
-
-	my_friendly_assert (TREE_CODE (value) == REAL_CST, 244);
-	val = TREE_REAL_CST (value);
-	if (val < 0)
-	  {
-	    val = -val;
-	    *bufp++ = 'm';
-	  }
-	sprintf (bufp, "%e", val);
-	bufp = (char *) index (bufp, 'e');
-	if (!bufp)
-	  strcat (digit_buffer, "e0");
-	else
-	  {
-	    char *p;
-	    bufp++;
-	    if (*bufp == '-')
-	      {
-		*bufp++ = 'm';
-	      }
-	    p = bufp;
-	    if (*p == '+')
-	      p++;
-	    while (*p == '0')
-	      p++;
-	    if (*p == 0)
-	      {
-		*bufp++ = '0';
-		*bufp = 0;
-	      }
-	    else if (p != bufp)
-	      {
-		while (*p)
-		  *bufp++ = *p++;
-		*bufp = 0;
-	      }
-	  }
-	OB_PUTCP (digit_buffer);
-	return;
-      }
-#endif
-    case POINTER_TYPE:
-      value = TREE_OPERAND (value, 0);
-      if (TREE_CODE (value) == VAR_DECL)
-	{
-	  my_friendly_assert (DECL_NAME (value) != 0, 245);
-	  build_overload_identifier (DECL_NAME (value));
-	  return;
-	}
-      else if (TREE_CODE (value) == FUNCTION_DECL)
-	{
-	  my_friendly_assert (DECL_NAME (value) != 0, 246);
-	  build_overload_identifier (DECL_NAME (value));
-	  return;
-	}
-      else
-	my_friendly_abort (71);
-      break; /* not really needed */
-
-    default:
-      sorry ("conversion of %s as PT parameter",
-	     tree_code_name [(int) TREE_CODE (type)]);
-      my_friendly_abort (72);
-    }
-}
-
-static void
-build_overload_identifier (name)
-     tree name;
-{
-  if (IDENTIFIER_TEMPLATE (name))
-    {
-      tree template, parmlist, arglist, tname;
-      int i, nparms;
-      template = IDENTIFIER_TEMPLATE (name);
-      arglist = TREE_VALUE (template);
-      template = TREE_PURPOSE (template);
-      tname = DECL_NAME (template);
-      parmlist = DECL_ARGUMENTS (template);
-      nparms = TREE_VEC_LENGTH (parmlist);
-      OB_PUTC ('t');
-      icat (IDENTIFIER_LENGTH (tname));
-      OB_PUTID (tname);
-      icat (nparms);
-      for (i = 0; i < nparms; i++)
-	{
-	  tree parm = TREE_VEC_ELT (parmlist, i);
-	  tree arg = TREE_VEC_ELT (arglist, i);
-	  if (TREE_CODE (parm) == IDENTIFIER_NODE)
-	    {
-	      /* This parameter is a type.  */
-	      OB_PUTC ('Z');
-	      build_overload_name (arg, 0, 0);
-	    }
-	  else
-	    {
-	      /* It's a PARM_DECL.  */
-	      build_overload_name (TREE_TYPE (parm), 0, 0);
-	      build_overload_value (parm, arg);
-	    }
-	}
-    }
-  else
-    {
-      icat (IDENTIFIER_LENGTH (name));
-      OB_PUTID (name);
-    }
-}
-
-/* Given a list of parameters in PARMTYPES, create an unambiguous
-   overload string. Should distinguish any type that C (or C++) can
-   distinguish. I.e., pointers to functions are treated correctly.
-
-   Caller must deal with whether a final `e' goes on the end or not.
-
-   Any default conversions must take place before this function
-   is called.
-
-   BEGIN and END control initialization and finalization of the
-   obstack where we build the string.  */
-
-char *
-build_overload_name (parmtypes, begin, end)
-     tree parmtypes;
-     int begin, end;
-{
-  int just_one;
-  tree parmtype;
-
-  if (begin) OB_INIT ();
-
-  if (just_one = (TREE_CODE (parmtypes) != TREE_LIST))
-    {
-      parmtype = parmtypes;
-      goto only_one;
-    }
-
-  while (parmtypes)
-    {
-      parmtype = TREE_VALUE (parmtypes);
-
-    only_one:
-
-      if (! nofold)
-	{
-	  if (! just_one)
-	    /* Every argument gets counted.  */
-	    typevec[maxtype++] = parmtype;
-
-	  if (TREE_USED (parmtype))
-	    {
-	      if (! just_one && parmtype == typevec[maxtype-2])
-		nrepeats++;
-	      else
-		{
-		  if (nrepeats)
-		    flush_repeats (parmtype);
-		  if (! just_one && TREE_CHAIN (parmtypes)
-		      && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes)))
-		    nrepeats++;
-		  else
-		    {
-		      int tindex = 0;
-
-		      while (typevec[tindex] != parmtype)
-			tindex++;
-		      OB_PUTC ('T');
-		      icat (tindex);
-		      if (tindex > 9)
-			OB_PUTC ('_');
-		    }
-		}
-	      goto next;
-	    }
-	  if (nrepeats)
-	    flush_repeats (typevec[maxtype-2]);
-	  if (! just_one
-	      /* Only cache types which take more than one character.  */
-	      && (parmtype != TYPE_MAIN_VARIANT (parmtype)
-		  || (TREE_CODE (parmtype) != INTEGER_TYPE
-		      && TREE_CODE (parmtype) != REAL_TYPE)))
-	    TREE_USED (parmtype) = 1;
-	}
-
-      if (TREE_READONLY (parmtype))
-	OB_PUTC ('C');
-      if (TREE_CODE (parmtype) == INTEGER_TYPE
-	  && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
-	OB_PUTC ('U');
-      if (TYPE_VOLATILE (parmtype))
-	OB_PUTC ('V');
-
-      switch (TREE_CODE (parmtype))
-	{
-	case OFFSET_TYPE:
-	  OB_PUTC ('O');
-	  build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
-	  OB_PUTC ('_');
-	  build_overload_name (TREE_TYPE (parmtype), 0, 0);
-	  break;
-
-	case REFERENCE_TYPE:
-	  OB_PUTC ('R');
-	  goto more;
-
-	case ARRAY_TYPE:
-#if PARM_CAN_BE_ARRAY_TYPE
-	  {
-	    tree length;
-
-	    OB_PUTC ('A');
-	    if (TYPE_DOMAIN (parmtype) == NULL_TREE)
-	      {
-		error ("parameter type with unspecified array bounds invalid");
-		icat (1);
-	      }
-	    else
-	      {
-		length = array_type_nelts (parmtype);
-		if (TREE_CODE (length) == INTEGER_CST)
-		  icat (TREE_INT_CST_LOW (length) + 1);
-	      }
-	    OB_PUTC ('_');
-	    goto more;
-	  }
-#else
-	  OB_PUTC ('P');
-	  goto more;
-#endif
-
-	case POINTER_TYPE:
-	  OB_PUTC ('P');
-	more:
-	  build_overload_name (TREE_TYPE (parmtype), 0, 0);
-	  break;
-
-	case FUNCTION_TYPE:
-	case METHOD_TYPE:
-	  {
-	    tree firstarg = TYPE_ARG_TYPES (parmtype);
-	    /* Otherwise have to implement reentrant typevecs,
-	       unmark and remark types, etc.  */
-	    int old_nofold = nofold;
-	    nofold = 1;
-
-	    if (nrepeats)
-	      flush_repeats (typevec[maxtype-1]);
-
-	    /* @@ It may be possible to pass a function type in
-	       which is not preceded by a 'P'.  */
-	    if (TREE_CODE (parmtype) == FUNCTION_TYPE)
-	      {
-		OB_PUTC ('F');
-		if (firstarg == NULL_TREE)
-		  OB_PUTC ('e');
-		else if (firstarg == void_list_node)
-		  OB_PUTC ('v');
-		else
-		  build_overload_name (firstarg, 0, 0);
-	      }
-	    else
-	      {
-		int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
-		int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
-		OB_PUTC ('M');
-		firstarg = TREE_CHAIN (firstarg);
-
-		build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
-		if (constp)
-		  OB_PUTC ('C');
-		if (volatilep)
-		  OB_PUTC ('V');
-
-		/* For cfront 2.0 compatibility.  */
-		OB_PUTC ('F');
-
-		if (firstarg == NULL_TREE)
-		  OB_PUTC ('e');
-		else if (firstarg == void_list_node)
-		  OB_PUTC ('v');
-		else
-		  build_overload_name (firstarg, 0, 0);
-	      }
-
-	    /* Separate args from return type.  */
-	    OB_PUTC ('_');
-	    build_overload_name (TREE_TYPE (parmtype), 0, 0);
-	    nofold = old_nofold;
-	    break;
-	  }
-
-	case INTEGER_TYPE:
-	  parmtype = TYPE_MAIN_VARIANT (parmtype);
-	  if (parmtype == integer_type_node
-	      || parmtype == unsigned_type_node)
-	    OB_PUTC ('i');
-	  else if (parmtype == long_integer_type_node
-		   || parmtype == long_unsigned_type_node)
-	    OB_PUTC ('l');
-	  else if (parmtype == short_integer_type_node
-		   || parmtype == short_unsigned_type_node)
-	    OB_PUTC ('s');
-	  else if (parmtype == signed_char_type_node)
-	    {
-	      OB_PUTC ('S');
-	      OB_PUTC ('c');
-	    }
-	  else if (parmtype == char_type_node
-		   || parmtype == unsigned_char_type_node)
-	    OB_PUTC ('c');
-	  else if (parmtype == wchar_type_node)
-	    OB_PUTC ('w');
-	  else if (parmtype == long_long_integer_type_node
-	      || parmtype == long_long_unsigned_type_node)
-	    OB_PUTC ('x');
-#if 0
-	  /* it would seem there is no way to enter these in source code,
-	     yet.  (mrs) */
-	  else if (parmtype == long_long_long_integer_type_node
-	      || parmtype == long_long_long_unsigned_type_node)
-	    OB_PUTC ('q');
-#endif
-	  else
-	    my_friendly_abort (73);
-	  break;
-
-	case REAL_TYPE:
-	  parmtype = TYPE_MAIN_VARIANT (parmtype);
-	  if (parmtype == long_double_type_node)
-	    OB_PUTC ('r');
-	  else if (parmtype == double_type_node)
-	    OB_PUTC ('d');
-	  else if (parmtype == float_type_node)
-	    OB_PUTC ('f');
-	  else my_friendly_abort (74);
-	  break;
-
-	case VOID_TYPE:
-	  if (! just_one)
-	    {
-#if 0
-	      extern tree void_list_node;
-
-	      /* See if anybody is wasting memory.  */
-	      my_friendly_assert (parmtypes == void_list_node, 247);
-#endif
-	      /* This is the end of a parameter list.  */
-	      if (end) OB_FINISH ();
-	      return (char *)obstack_base (&scratch_obstack);
-	    }
-	  OB_PUTC ('v');
-	  break;
-
-	case ERROR_MARK:	/* not right, but nothing is anyway */
-	  break;
-
-	  /* have to do these */
-	case UNION_TYPE:
-	case RECORD_TYPE:
-	  if (! just_one)
-	    /* Make this type signature look incompatible
-	       with AT&T.  */
-	    OB_PUTC ('G');
-	  goto common;
-	case ENUMERAL_TYPE:
-	common:
-	  {
-	    tree name = TYPE_NAME (parmtype);
-	    int i = 1;
-
-	    if (TREE_CODE (name) == TYPE_DECL)
-	      {
-		tree context = name;
-		while (DECL_CONTEXT (context))
-		  {
-		    i += 1;
-		    context = DECL_CONTEXT (context);
-		    if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
-		      context = TYPE_NAME (context);
-		  }
-		name = DECL_NAME (name);
-	      }
-	    my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 248);
-	    if (i > 1)
-	      {
-		OB_PUTC ('Q');
-		icat (i);
-		build_overload_nested_name (TYPE_NAME (parmtype));
-	      }
-	    else
-	      build_overload_identifier (name);
-	    break;
-	  }
-
-	case UNKNOWN_TYPE:
-	  /* This will take some work.  */
-	  OB_PUTC ('?');
-	  break;
-
-	case TEMPLATE_TYPE_PARM:
-	case TEMPLATE_CONST_PARM:
-        case UNINSTANTIATED_P_TYPE:
-	  /* We don't ever want this output, but it's inconvenient not to
-	     be able to build the string.  This should cause assembler
-	     errors we'll notice.  */
-	  {
-	    static int n;
-	    sprintf (digit_buffer, " *%d", n++);
-	    OB_PUTCP (digit_buffer);
-	  }
-	  break;
-
-	default:
-	  my_friendly_abort (75);
-	}
-
-    next:
-      if (just_one) break;
-      parmtypes = TREE_CHAIN (parmtypes);
-    }
-  if (! just_one)
-    {
-      if (nrepeats)
-	flush_repeats (typevec[maxtype-1]);
-
-      /* To get here, parms must end with `...'. */
-      OB_PUTC ('e');
-    }
-
-  if (end) OB_FINISH ();
-  return (char *)obstack_base (&scratch_obstack);
-}
-
-/* Generate an identifier that encodes the (ANSI) exception TYPE. */
-
-/* This should be part of `ansi_opname', or at least be defined by the std.  */
-#define EXCEPTION_NAME_PREFIX "__ex"
-#define EXCEPTION_NAME_LENGTH 4
-
-tree
-cplus_exception_name (type)
-     tree type;
-{
-  OB_INIT ();
-  OB_PUTS (EXCEPTION_NAME_PREFIX);
-  return get_identifier (build_overload_name (type, 0, 1));
-}
-
-/* Change the name of a function definition so that it may be
-   overloaded. NAME is the name of the function to overload,
-   PARMS is the parameter list (which determines what name the
-   final function obtains).
-
-   FOR_METHOD is 1 if this overload is being performed
-   for a method, rather than a function type.  It is 2 if
-   this overload is being performed for a constructor.  */
-tree
-build_decl_overload (dname, parms, for_method)
-     tree dname;
-     tree parms;
-     int for_method;
-{
-  char *name = IDENTIFIER_POINTER (dname);
-
-  if (dname == ansi_opname[(int) NEW_EXPR]
-      && parms != NULL_TREE
-      && TREE_CODE (parms) == TREE_LIST
-      && TREE_VALUE (parms) == sizetype
-      && TREE_CHAIN (parms) == void_list_node)
-    return get_identifier ("__builtin_new");
-  else if (dname == ansi_opname[(int) DELETE_EXPR]
-	   && parms != NULL_TREE
-	   && TREE_CODE (parms) == TREE_LIST
-	   && TREE_VALUE (parms) == ptr_type_node
-	   && TREE_CHAIN (parms) == void_list_node)
-    return get_identifier ("__builtin_delete");
-  else if (dname == ansi_opname[(int) DELETE_EXPR]
-	   && parms != NULL_TREE
-	   && TREE_CODE (parms) == TREE_LIST
-	   && TREE_VALUE (parms) == ptr_type_node
-	   && TREE_CHAIN (parms) != NULL_TREE
-	   && TREE_CODE (TREE_CHAIN (parms)) == TREE_LIST
-	   && TREE_VALUE (TREE_CHAIN (parms)) == sizetype
-	   && TREE_CHAIN (TREE_CHAIN (parms)) == void_list_node)
-    return get_identifier ("__builtin_delete");
-
-  OB_INIT ();
-  if (for_method != 2)
-    OB_PUTCP (name);
-  /* Otherwise, we can divine that this is a constructor,
-     and figure out its name without any extra encoding.  */
-
-  OB_PUTC2 ('_', '_');
-  if (for_method)
-    {
-#if 0
-      /* We can get away without doing this.  */
-      OB_PUTC ('M');
-#endif
-      parms = temp_tree_cons (NULL_TREE, TREE_TYPE (TREE_VALUE (parms)), TREE_CHAIN (parms));
-    }
-  else
-    OB_PUTC ('F');
-
-  if (parms == NULL_TREE)
-    OB_PUTC2 ('e', '\0');
-  else if (parms == void_list_node)
-    OB_PUTC2 ('v', '\0');
-  else
-    {
-      ALLOCATE_TYPEVEC (parms);
-      nofold = 0;
-      if (for_method)
-	{
-	  build_overload_name (TREE_VALUE (parms), 0, 0);
-
-	  typevec[maxtype++] = TREE_VALUE (parms);
-	  TREE_USED (TREE_VALUE (parms)) = 1;
-
-	  if (TREE_CHAIN (parms))
-	    build_overload_name (TREE_CHAIN (parms), 0, 1);
-	  else
-	    OB_PUTC2 ('e', '\0');
-	}
-      else
-	build_overload_name (parms, 0, 1);
-      DEALLOCATE_TYPEVEC (parms);
-    }
-  return get_identifier (obstack_base (&scratch_obstack));
-}
-
-/* Build an overload name for the type expression TYPE.  */
-tree
-build_typename_overload (type)
-     tree type;
-{
-  tree id;
-
-  OB_INIT ();
-  OB_PUTID (ansi_opname[(int) TYPE_EXPR]);
-  nofold = 1;
-  build_overload_name (type, 0, 1);
-  id = get_identifier (obstack_base (&scratch_obstack));
-  IDENTIFIER_OPNAME_P (id) = 1;
-  return id;
-}
-
-#ifndef NO_DOLLAR_IN_LABEL
-#define T_DESC_FORMAT "TD$"
-#define I_DESC_FORMAT "ID$"
-#define M_DESC_FORMAT "MD$"
-#else
-#if !defined(NO_DOT_IN_LABEL)
-#define T_DESC_FORMAT "TD."
-#define I_DESC_FORMAT "ID."
-#define M_DESC_FORMAT "MD."
-#else
-#define T_DESC_FORMAT "__t_desc_"
-#define I_DESC_FORMAT "__i_desc_"
-#define M_DESC_FORMAT "__m_desc_"
-#endif
-#endif
-
-/* Build an overload name for the type expression TYPE.  */
-tree
-build_t_desc_overload (type)
-     tree type;
-{
-  OB_INIT ();
-  OB_PUTS (T_DESC_FORMAT);
-  nofold = 1;
-
-#if 0
-  /* Use a different format if the type isn't defined yet.  */
-  if (TYPE_SIZE (type) == NULL_TREE)
-    {
-      char *p;
-      int changed;
-
-      for (p = tname; *p; p++)
-	if (isupper (*p))
-	  {
-	    changed = 1;
-	    *p = tolower (*p);
-	  }
-      /* If there's no change, we have an inappropriate T_DESC_FORMAT.  */
-      my_friendly_assert (changed != 0, 249);
-    }
-#endif
-
-  build_overload_name (type, 0, 1);
-  return get_identifier (obstack_base (&scratch_obstack));
-}
-
-/* Top-level interface to explicit overload requests. Allow NAME
-   to be overloaded. Error if NAME is already declared for the current
-   scope. Warning if function is redundantly overloaded. */
-
-void
-declare_overloaded (name)
-     tree name;
-{
-#ifdef NO_AUTO_OVERLOAD
-  if (is_overloaded (name))
-    warning ("function `%s' already declared overloaded",
-	     IDENTIFIER_POINTER (name));
-  else if (IDENTIFIER_GLOBAL_VALUE (name))
-    error ("overloading function `%s' that is already defined",
-	   IDENTIFIER_POINTER (name));
-  else
-    {
-      TREE_OVERLOADED (name) = 1;
-      IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
-      TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
-    }
-#else
-  if (current_lang_name == lang_name_cplusplus)
-    {
-      if (0)
-	warning ("functions are implicitly overloaded in C++");
-    }
-  else if (current_lang_name == lang_name_c)
-    error ("overloading function `%s' cannot be done in C language context");
-  else
-    my_friendly_abort (76);
-#endif
-}
-
-#ifdef NO_AUTO_OVERLOAD
-/* Check to see if NAME is overloaded. For first approximation,
-   check to see if its TREE_OVERLOADED is set.  This is used on
-   IDENTIFIER nodes.  */
-int
-is_overloaded (name)
-     tree name;
-{
-  /* @@ */
-  return (TREE_OVERLOADED (name)
-	  && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
-	  && ! IDENTIFIER_LOCAL_VALUE (name));
-}
-#endif
-
-/* Given a tree_code CODE, and some arguments (at least one),
-   attempt to use an overloaded operator on the arguments.
-
-   For unary operators, only the first argument need be checked.
-   For binary operators, both arguments may need to be checked.
-
-   Member functions can convert class references to class pointers,
-   for one-level deep indirection.  More than that is not supported.
-   Operators [](), ()(), and ->() must be member functions.
-
-   We call function call building calls with nonzero complain if
-   they are our only hope.  This is true when we see a vanilla operator
-   applied to something of aggregate type.  If this fails, we are free to
-   return `error_mark_node', because we will have reported the error.
-
-   Operators NEW and DELETE overload in funny ways: operator new takes
-   a single `size' parameter, and operator delete takes a pointer to the
-   storage being deleted.  When overloading these operators, success is
-   assumed.  If there is a failure, report an error message and return
-   `error_mark_node'.  */
-
-/* NOSTRICT */
-tree
-build_opfncall (code, flags, xarg1, xarg2, arg3)
-     enum tree_code code;
-     int flags;
-     tree xarg1, xarg2, arg3;
-{
-  tree rval = 0;
-  tree arg1, arg2;
-  tree type1, type2, fnname;
-  tree fields1 = 0, parms = 0;
-  tree global_fn;
-  int try_second;
-  int binary_is_unary;
-
-  if (xarg1 == error_mark_node)
-    return error_mark_node;
-
-  if (code == COND_EXPR)
-    {
-      if (TREE_CODE (xarg2) == ERROR_MARK
-	  || TREE_CODE (arg3) == ERROR_MARK)
-	return error_mark_node;
-    }
-  if (code == COMPONENT_REF)
-    if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
-      return rval;
-
-  /* First, see if we can work with the first argument */
-  type1 = TREE_TYPE (xarg1);
-
-  /* Some tree codes have length > 1, but we really only want to
-     overload them if their first argument has a user defined type.  */
-  switch (code)
-    {
-    case PREINCREMENT_EXPR:
-    case PREDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-    case COMPONENT_REF:
-      binary_is_unary = 1;
-      try_second = 0;
-      break;
-
-      /* ARRAY_REFs and CALL_EXPRs must overload successfully.
-	 If they do not, return error_mark_node instead of NULL_TREE.  */
-    case ARRAY_REF:
-      if (xarg2 == error_mark_node)
-	return error_mark_node;
-    case CALL_EXPR:
-      rval = error_mark_node;
-      binary_is_unary = 0;
-      try_second = 0;
-      break;
-
-    case NEW_EXPR:
-      {
-	/* For operators `new' (`delete'), only check visibility
-	   if we are in a constructor (destructor), and we are
-	   allocating for that constructor's (destructor's) type.  */
-
-	fnname = ansi_opname[(int) NEW_EXPR];
-	if (flags & LOOKUP_GLOBAL)
-	  return build_overload_call (fnname, tree_cons (NULL_TREE, xarg2, arg3),
-				      flags & LOOKUP_COMPLAIN,
-				      (struct candidate *)0);
-
-	if (current_function_decl == NULL_TREE
-	    || !DECL_CONSTRUCTOR_P (current_function_decl)
-	    || current_class_type != TYPE_MAIN_VARIANT (type1))
-	  flags = LOOKUP_COMPLAIN;
-	rval = build_method_call (build1 (NOP_EXPR, xarg1, error_mark_node),
-				  fnname, tree_cons (NULL_TREE, xarg2, arg3),
-				  NULL_TREE, flags);
-	if (rval == error_mark_node)
-	  /* User might declare fancy operator new, but invoke it
-	     like standard one.  */
-	  return rval;
-
-	TREE_TYPE (rval) = xarg1;
-	TREE_CALLS_NEW (rval) = 1;
-	return rval;
-      }
-      break;
-
-    case DELETE_EXPR:
-      {
-	/* See comment above.  */
-
-	fnname = ansi_opname[(int) DELETE_EXPR];
-	if (flags & LOOKUP_GLOBAL)
-	  return build_overload_call (fnname,
-				      tree_cons (NULL_TREE, xarg1,
-						 build_tree_list (NULL_TREE, xarg2)),
-				      flags & LOOKUP_COMPLAIN,
-				      (struct candidate *)0);
-
-	if (current_function_decl == NULL_TREE
-	    || !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl))
-	    || current_class_type != TYPE_MAIN_VARIANT (type1))
-	  flags = LOOKUP_COMPLAIN;
-	rval = build_method_call (build1 (NOP_EXPR, TREE_TYPE (xarg1),
-					  error_mark_node),
-				  fnname, tree_cons (NULL_TREE, xarg1,
-						     build_tree_list (NULL_TREE, xarg2)),
-				  NULL_TREE, flags);
-	/* This happens when the user mis-declares `operator delete'.
-	   Should now be impossible.  */
-	my_friendly_assert (rval != error_mark_node, 250);
-	TREE_TYPE (rval) = void_type_node;
-	return rval;
-      }
-      break;
-
-    default:
-      binary_is_unary = 0;
-      try_second = tree_code_length [(int) code] == 2;
-      if (try_second && xarg2 == error_mark_node)
-	return error_mark_node;
-      break;
-    }
-
-  if (try_second && xarg2 == error_mark_node)
-    return error_mark_node;
-
-  /* What ever it was, we do not know how to deal with it.  */
-  if (type1 == NULL_TREE)
-    return rval;
-
-  if (TREE_CODE (type1) == OFFSET_TYPE)
-    type1 = TREE_TYPE (type1);
-
-  if (TREE_CODE (type1) == REFERENCE_TYPE)
-    {
-      arg1 = convert_from_reference (xarg1);
-      type1 = TREE_TYPE (arg1);
-    }
-  else
-    {
-      arg1 = xarg1;
-    }
-
-  if (!IS_AGGR_TYPE (type1))
-    {
-      /* Try to fail. First, fail if unary */
-      if (! try_second)
-	return rval;
-      /* Second, see if second argument is non-aggregate. */
-      type2 = TREE_TYPE (xarg2);
-      if (TREE_CODE (type2) == OFFSET_TYPE)
-	type2 = TREE_TYPE (type2);
-      if (TREE_CODE (type2) == REFERENCE_TYPE)
-	{
-	  arg2 = convert_from_reference (xarg2);
-	  type2 = TREE_TYPE (arg2);
-	}
-      else
-	{
-	  arg2 = xarg2;
-	}
-
-      if (!IS_AGGR_TYPE (type2))
-	return rval;
-      try_second = 0;
-    }
-
-  if (try_second)
-    {
-      /* First arg may succeed; see whether second should.  */
-      type2 = TREE_TYPE (xarg2);
-      if (TREE_CODE (type2) == OFFSET_TYPE)
-	type2 = TREE_TYPE (type2);
-      if (TREE_CODE (type2) == REFERENCE_TYPE)
-	{
-	  arg2 = convert_from_reference (xarg2);
-	  type2 = TREE_TYPE (arg2);
-	}
-      else
-	{
-	  arg2 = xarg2;
-	}
-
-      if (! IS_AGGR_TYPE (type2))
-	try_second = 0;
-    }
-
-  if (type1 == unknown_type_node
-      || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
-    {
-      /* This will not be implemented in the foreseeable future.  */
-      return rval;
-    }
-
-  if (code == MODIFY_EXPR)
-    fnname = ansi_assopname[(int) TREE_CODE (arg3)];
-  else
-    fnname = ansi_opname[(int) code];
-
-  global_fn = IDENTIFIER_GLOBAL_VALUE (fnname);
-
-  /* This is the last point where we will accept failure.  This
-     may be too eager if we wish an overloaded operator not to match,
-     but would rather a normal operator be called on a type-converted
-     argument.  */
-
-  if (IS_AGGR_TYPE (type1))
-    {
-      fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
-      /* ARM $13.4.7, prefix/postfix ++/--.  */
-      if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
-	{
-	  xarg2 = integer_zero_node;
-	  binary_is_unary = 0;
-
-	  if (fields1)
-	    {
-	      tree t, t2;
-	      int have_postfix = 0;
-
-	      /* Look for an `operator++ (int)'.  If they didn't have
-		 one, then we fall back to the old way of doing things.  */
-	      for (t = TREE_VALUE (fields1); t ; t = TREE_CHAIN (t))
-		{
-		  t2 = TYPE_ARG_TYPES (TREE_TYPE (t));
-		  if (TREE_CHAIN (t2) != NULL_TREE
-		      && TREE_VALUE (TREE_CHAIN (t2)) == integer_type_node)
-		    {
-		      have_postfix = 1;
-		      break;
-		    }
-		}
-
-	      if (! have_postfix)
-		{
-		  char *op = POSTINCREMENT_EXPR ? "++" : "--";
-
-		  /* There's probably a LOT of code in the world that
-		     relies upon this old behavior.  So we'll only give this
-		     warning when we've been given -pedantic.  A few
-		     releases after 2.4, we'll convert this to be a pedwarn
-		     or something else more appropriate.  */
-		  if (pedantic)
-		    warning ("no `operator%s (int)' declared for postfix `%s'",
-			     op, op);
-		  xarg2 = NULL_TREE;
-		  binary_is_unary = 1;
-		}
-	    }
-	}
-    }
-
-  if (fields1 == NULL_TREE && global_fn == NULL_TREE)
-    return rval;
-
-  /* If RVAL winds up being `error_mark_node', we will return
-     that... There is no way that normal semantics of these
-     operators will succeed.  */
-
-  /* This argument may be an uncommitted OFFSET_REF.  This is
-     the case for example when dealing with static class members
-     which are referenced from their class name rather than
-     from a class instance.  */
-  if (TREE_CODE (xarg1) == OFFSET_REF
-      && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
-    xarg1 = TREE_OPERAND (xarg1, 1);
-  if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
-      && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
-    xarg2 = TREE_OPERAND (xarg2, 1);
-
-  if (global_fn)
-    flags |= LOOKUP_GLOBAL;
-
-  if (code == CALL_EXPR)
-    {
-      /* This can only be a member function.  */
-      return build_method_call (xarg1, fnname, xarg2,
-				NULL_TREE, LOOKUP_NORMAL);
-    }
-  else if (tree_code_length[(int) code] == 1 || binary_is_unary)
-    {
-      parms = NULL_TREE;
-      rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
-    }
-  else if (code == COND_EXPR)
-    {
-      parms = tree_cons (0, xarg2, build_tree_list (NULL_TREE, arg3));
-      rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
-    }
-  else if (code == METHOD_CALL_EXPR)
-    {
-      /* must be a member function.  */
-      parms = tree_cons (NULL_TREE, xarg2, arg3);
-      return build_method_call (xarg1, fnname, parms, NULL_TREE, LOOKUP_NORMAL);
-    }
-  else if (fields1)
-    {
-      parms = build_tree_list (NULL_TREE, xarg2);
-      rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
-    }
-  else
-    {
-      parms = tree_cons (NULL_TREE, xarg1,
-			 build_tree_list (NULL_TREE, xarg2));
-      rval = build_overload_call (fnname, parms, flags & LOOKUP_COMPLAIN,
-				  (struct candidate *)0);
-    }
-
-  /* If we did not win, do not lose yet, since type conversion may work.  */
-  if (TREE_CODE (rval) == ERROR_MARK)
-    {
-      if (flags & LOOKUP_COMPLAIN)
-	return rval;
-      return 0;
-    }
-
-  return rval;
-}
-
-/* This function takes an identifier, ID, and attempts to figure out what
-   it means. There are a number of possible scenarios, presented in increasing
-   order of hair:
-
-   1) not in a class's scope
-   2) in class's scope, member name of the class's method
-   3) in class's scope, but not a member name of the class
-   4) in class's scope, member name of a class's variable
-
-   NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
-   VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
-   yychar is the pending input character (suitably encoded :-).
-
-   As a last ditch, try to look up the name as a label and return that
-   address.
-
-   Values which are declared as being of REFERENCE_TYPE are
-   automatically dereferenced here (as a hack to make the
-   compiler faster).  */
-
-tree
-hack_identifier (value, name, yychar)
-     tree value, name;
-     int yychar;
-{
-  tree type;
-
-  if (TREE_CODE (value) == ERROR_MARK)
-    {
-      if (current_class_name)
-	{
-	  tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 1);
-	  if (fields == error_mark_node)
-	    return error_mark_node;
-	  if (fields)
-	    {
-	      tree fndecl;
-
-	      fndecl = TREE_VALUE (fields);
-	      my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
-	      if (DECL_CHAIN (fndecl) == NULL_TREE)
-		{
-		  warning ("methods cannot be converted to function pointers");
-		  return fndecl;
-		}
-	      else
-		{
-		  error ("ambiguous request for method pointer `%s'",
-			 IDENTIFIER_POINTER (name));
-		  return error_mark_node;
-		}
-	    }
-	}
-      if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
-	{
-	  return IDENTIFIER_LABEL_VALUE (name);
-	}
-      return error_mark_node;
-    }
-
-  type = TREE_TYPE (value);
-  if (TREE_CODE (value) == FIELD_DECL)
-    {
-      if (current_class_decl == NULL_TREE)
-	{
-	  error ("request for member `%s' in static member function",
-		 IDENTIFIER_POINTER (DECL_NAME (value)));
-	  return error_mark_node;
-	}
-      TREE_USED (current_class_decl) = 1;
-      if (yychar == '(')
-	if (! ((TYPE_LANG_SPECIFIC (type)
-		&& TYPE_OVERLOADS_CALL_EXPR (type))
-	       || (TREE_CODE (type) == REFERENCE_TYPE
-		   && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
-		   && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type))))
-	    && TREE_CODE (type) != FUNCTION_TYPE
-	    && TREE_CODE (type) != METHOD_TYPE
-	    && (TREE_CODE (type) != POINTER_TYPE
-		|| (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
-		    && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)))
-	  {
-	    error ("component `%s' is not a method",
-		   IDENTIFIER_POINTER (name));
-	    return error_mark_node;
-	  }
-      /* Mark so that if we are in a constructor, and then find that
-	 this field was initialized by a base initializer,
-	 we can emit an error message.  */
-      TREE_USED (value) = 1;
-      return build_component_ref (C_C_D, name, 0, 1);
-    }
-
-  if (TREE_CODE (value) == TREE_LIST)
-    {
-      tree t = value;
-      while (t && TREE_CODE (t) == TREE_LIST)
-	{
-	  assemble_external (TREE_VALUE (t));
-	  TREE_USED (t) = 1;
-	  t = TREE_CHAIN (t);
-	}
-    }
-  else
-    {
-      assemble_external (value);
-      TREE_USED (value) = 1;
-    }
-
-  if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
-    {
-      if (DECL_CLASS_CONTEXT (value) != current_class_type)
-	{
-	  tree path;
-	  enum visibility_type visibility;
-	  register tree context
-	    = (TREE_CODE (value) == FUNCTION_DECL && DECL_VIRTUAL_P (value))
-	      ? DECL_CLASS_CONTEXT (value)
-	      : DECL_CONTEXT (value);
-
-	  get_base_distance (context, current_class_type, 0, &path);
-	  visibility = compute_visibility (path, value);
-	  if (visibility != visibility_public)
-	    {
-	      if (TREE_CODE (value) == VAR_DECL)
-		error ("static member `%s' is from private base class",
-		       IDENTIFIER_POINTER (name));
-	      else
-		error ("enum `%s' is from private base class",
-		       IDENTIFIER_POINTER (name));
-	      return error_mark_node;
-	    }
-	}
-      return value;
-    }
-  if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
-    {
-      if (type == 0)
-	{
-	  error ("request for member `%s' is ambiguous in multiple inheritance lattice",
-		 IDENTIFIER_POINTER (name));
-	  return error_mark_node;
-	}
-
-      return value;
-    }
-
-  if (TREE_CODE (type) == REFERENCE_TYPE)
-    {
-      my_friendly_assert (TREE_CODE (value) == VAR_DECL
-			  || TREE_CODE (value) == PARM_DECL
-			  || TREE_CODE (value) == RESULT_DECL, 252);
-      if (DECL_REFERENCE_SLOT (value))
-	return DECL_REFERENCE_SLOT (value);
-    }
-  return value;
-}
-
-
-/* Given an object OF, and a type conversion operator COMPONENT
-   build a call to the conversion operator, if a call is requested,
-   or return the address (as a pointer to member function) if one is not.
-
-   OF can be a TYPE_DECL or any kind of datum that would normally
-   be passed to `build_component_ref'.  It may also be NULL_TREE,
-   in which case `current_class_type' and `current_class_decl'
-   provide default values.
-
-   BASETYPE_PATH, if non-null, is the path of basetypes
-   to go through before we get the the instance of interest.
-
-   PROTECT says whether we apply C++ scoping rules or not.  */
-tree
-build_component_type_expr (of, component, basetype_path, protect)
-     tree of, component, basetype_path;
-     int protect;
-{
-  tree cname = NULL_TREE;
-  tree tmp, last;
-  tree name;
-  int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
-
-  if (of)
-    my_friendly_assert (IS_AGGR_TYPE (TREE_TYPE (of)), 253);
-  my_friendly_assert (TREE_CODE (component) == TYPE_EXPR, 254);
-
-  tmp = TREE_OPERAND (component, 0);
-  last = NULL_TREE;
-
-  while (tmp)
-    {
-      switch (TREE_CODE (tmp))
-	{
-	case CALL_EXPR:
-	  if (last)
-	    TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
-	  else
-	    TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
-	  if (TREE_OPERAND (tmp, 0)
-	      && TREE_OPERAND (tmp, 0) != void_list_node)
-	    {
-	      error ("operator <typename> requires empty parameter list");
-	      TREE_OPERAND (tmp, 0) = NULL_TREE;
-	    }
-	  last = groktypename (build_tree_list (TREE_TYPE (component),
-						TREE_OPERAND (component, 0)));
-	  name = build_typename_overload (last);
-	  TREE_TYPE (name) = last;
-
-	  if (of && TREE_CODE (of) != TYPE_DECL)
-	    return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
-	  else if (of)
-	    {
-	      tree this_this;
-
-	      if (current_class_decl == NULL_TREE)
-		{
-		  error ("object required for `operator <typename>' call");
-		  return error_mark_node;
-		}
-
-	      this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
-	      return build_method_call (this_this, name, NULL_TREE,
-					NULL_TREE, flags | LOOKUP_NONVIRTUAL);
-	    }
-	  else if (current_class_decl)
-	    return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
-
-	  error ("object required for `operator <typename>' call");
-	  return error_mark_node;
-
-	case INDIRECT_REF:
-	case ADDR_EXPR:
-	case ARRAY_REF:
-	  break;
-
-	case SCOPE_REF:
-	  my_friendly_assert (cname == 0, 255);
-	  cname = TREE_OPERAND (tmp, 0);
-	  tmp = TREE_OPERAND (tmp, 1);
-	  break;
-
-	default:
-	  my_friendly_abort (77);
-	}
-      last = tmp;
-      tmp = TREE_OPERAND (tmp, 0);
-    }
-
-  last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
-  name = build_typename_overload (last);
-  TREE_TYPE (name) = last;
-  if (of && TREE_CODE (of) == TYPE_DECL)
-    {
-      if (cname == NULL_TREE)
-	{
-	  cname = DECL_NAME (of);
-	  of = NULL_TREE;
-	}
-      else my_friendly_assert (cname == DECL_NAME (of), 256);
-    }
-
-  if (of)
-    {
-      tree this_this;
-
-      if (current_class_decl == NULL_TREE)
-	{
-	  error ("object required for `operator <typename>' call");
-	  return error_mark_node;
-	}
-
-      this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
-      return build_component_ref (this_this, name, 0, protect);
-    }
-  else if (cname)
-    return build_offset_ref (cname, name);
-  else if (current_class_name)
-    return build_offset_ref (current_class_name, name);
-
-  error ("object required for `operator <typename>' member reference");
-  return error_mark_node;
-}
diff --git a/gnu/gcc2/cc1plus/cp-parse.c b/gnu/gcc2/cc1plus/cp-parse.c
deleted file mode 100644
index 3356f1b2fcfe..000000000000
--- a/gnu/gcc2/cc1plus/cp-parse.c
+++ /dev/null
@@ -1,7295 +0,0 @@
-
-/*  A Bison parser, made from cp-parse.y  */
-
-#define YYBISON 1  /* Identify Bison output.  */
-
-#define	IDENTIFIER	258
-#define	TYPENAME	259
-#define	SCOPED_TYPENAME	260
-#define	SCSPEC	261
-#define	TYPESPEC	262
-#define	TYPE_QUAL	263
-#define	CONSTANT	264
-#define	STRING	265
-#define	ELLIPSIS	266
-#define	SIZEOF	267
-#define	ENUM	268
-#define	IF	269
-#define	ELSE	270
-#define	WHILE	271
-#define	DO	272
-#define	FOR	273
-#define	SWITCH	274
-#define	CASE	275
-#define	DEFAULT	276
-#define	BREAK	277
-#define	CONTINUE	278
-#define	RETURN	279
-#define	GOTO	280
-#define	ASM_KEYWORD	281
-#define	GCC_ASM_KEYWORD	282
-#define	TYPEOF	283
-#define	ALIGNOF	284
-#define	HEADOF	285
-#define	CLASSOF	286
-#define	ATTRIBUTE	287
-#define	EXTENSION	288
-#define	LABEL	289
-#define	AGGR	290
-#define	VISSPEC	291
-#define	DELETE	292
-#define	NEW	293
-#define	OVERLOAD	294
-#define	THIS	295
-#define	OPERATOR	296
-#define	DYNAMIC	297
-#define	POINTSAT_LEFT_RIGHT	298
-#define	LEFT_RIGHT	299
-#define	TEMPLATE	300
-#define	SCOPE	301
-#define	START_DECLARATOR	302
-#define	EMPTY	303
-#define	TYPENAME_COLON	304
-#define	ASSIGN	305
-#define	RANGE	306
-#define	OROR	307
-#define	ANDAND	308
-#define	MIN_MAX	309
-#define	EQCOMPARE	310
-#define	ARITHCOMPARE	311
-#define	LSHIFT	312
-#define	RSHIFT	313
-#define	UNARY	314
-#define	PLUSPLUS	315
-#define	MINUSMINUS	316
-#define	HYPERUNARY	317
-#define	PAREN_STAR_PAREN	318
-#define	POINTSAT	319
-#define	POINTSAT_STAR	320
-#define	DOT_STAR	321
-#define	RAISE	322
-#define	RAISES	323
-#define	RERAISE	324
-#define	TRY	325
-#define	EXCEPT	326
-#define	CATCH	327
-#define	THROW	328
-#define	ANSI_TRY	329
-#define	ANSI_THROW	330
-#define	TYPENAME_ELLIPSIS	331
-#define	PTYPENAME	332
-#define	PRE_PARSED_FUNCTION_DECL	333
-#define	EXTERN_LANG_STRING	334
-#define	ALL	335
-#define	PRE_PARSED_CLASS_DECL	336
-#define	TYPENAME_DEFN	337
-#define	IDENTIFIER_DEFN	338
-#define	PTYPENAME_DEFN	339
-#define	END_OF_SAVED_INPUT	340
-
-#line 42 "cp-parse.y"
-
-#if defined(GATHER_STATISTICS) || defined(SPEW_DEBUG)
-#undef YYDEBUG
-#define YYDEBUG 1
-#endif
-
-#include "config.h"
-
-#include <stdio.h>
-#include <errno.h>
-
-#include "tree.h"
-#include "input.h"
-#include "flags.h"
-#include "cp-lex.h"
-#include "cp-tree.h"
-
-/* Since parsers are distinct for each language, put the language string
-   definition here.  (fnf) */
-char *language_string = "GNU C++";
-
-extern tree void_list_node;
-extern struct obstack permanent_obstack;
-
-#ifndef errno
-extern int errno;
-#endif
-
-extern int end_of_file;
-
-void yyerror ();
-
-/* Like YYERROR but do call yyerror.  */
-#define YYERROR1 { yyerror ("syntax error"); YYERROR; }
-
-static void position_after_white_space ();
-
-/* Contains the statement keyword (if/while/do) to include in an
-   error message if the user supplies an empty conditional expression.  */
-static char *cond_stmt_keyword;
-
-/* Nonzero if we have an `extern "C"' acting as an extern specifier.  */
-int have_extern_spec;
-int used_extern_spec;
-
-void yyhook ();
-
-/* Cons up an empty parameter list.  */
-#ifdef __GNUC__
-__inline
-#endif
-static tree
-empty_parms ()
-{
-  tree parms;
-
-  if (strict_prototype)
-    parms = void_list_node;
-  else
-    parms = NULL_TREE;
-  return parms;
-}
-
-#line 108 "cp-parse.y"
-typedef union {long itype; tree ttype; char *strtype; enum tree_code code; } YYSTYPE;
-#line 267 "cp-parse.y"
-
-/* List of types and structure classes of the current declaration.  */
-static tree current_declspecs;
-
-/* When defining an aggregate, this is the most recent one being defined.  */
-static tree current_aggr;
-
-/* Tell yyparse how to print a token's value, if yydebug is set.  */
-
-#define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
-extern void yyprint ();
-extern tree combine_strings		PROTO((tree));
-extern tree truthvalue_conversion	PROTO((tree));
-
-#ifndef YYLTYPE
-typedef
-  struct yyltype
-    {
-      int timestamp;
-      int first_line;
-      int first_column;
-      int last_line;
-      int last_column;
-      char *text;
-   }
-  yyltype;
-
-#define YYLTYPE yyltype
-#endif
-
-#include <stdio.h>
-
-#ifndef __STDC__
-#define const
-#endif
-
-
-
-#define	YYFINAL		1276
-#define	YYFLAG		-32768
-#define	YYNTBASE	110
-
-#define YYTRANSLATE(x) ((unsigned)(x) <= 340 ? yytranslate[x] : 304)
-
-static const char yytranslate[] = {     0,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,   108,     2,     2,     2,    73,    61,     2,    83,
-   104,    71,    69,    51,    70,    81,    72,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,    55,   105,    65,
-    53,    66,    54,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-    84,     2,   109,    60,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,    50,    59,   106,   107,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
-     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
-    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-    26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-    36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
-    46,    47,    48,    49,    52,    56,    57,    58,    62,    63,
-    64,    67,    68,    74,    75,    76,    77,    78,    79,    80,
-    82,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-    94,    95,    96,    97,    98,    99,   100,   101,   102,   103
-};
-
-static const short yyprhs[] = {     0,
-     0,     1,     3,     4,     7,    10,    11,    12,    14,    16,
-    18,    20,    22,    24,    30,    35,    39,    44,    49,    51,
-    52,    58,    60,    64,    67,    72,    76,    78,    82,    84,
-    88,    89,    95,    96,   102,   103,   109,   110,   116,   120,
-   124,   131,   139,   144,   148,   152,   154,   156,   158,   160,
-   162,   165,   169,   173,   177,   181,   184,   187,   190,   193,
-   195,   199,   204,   208,   214,   219,   223,   227,   230,   234,
-   238,   241,   248,   255,   260,   265,   267,   274,   279,   283,
-   290,   295,   299,   302,   305,   307,   311,   316,   319,   323,
-   324,   325,   327,   331,   334,   338,   340,   345,   348,   353,
-   356,   361,   364,   370,   374,   376,   378,   380,   382,   384,
-   386,   388,   390,   392,   395,   397,   401,   406,   411,   413,
-   415,   416,   417,   419,   423,   425,   427,   428,   435,   436,
-   438,   439,   442,   444,   446,   448,   450,   452,   454,   456,
-   458,   462,   464,   468,   472,   474,   475,   479,   482,   485,
-   488,   491,   494,   497,   502,   505,   510,   514,   521,   528,
-   538,   543,   551,   557,   566,   576,   586,   593,   603,   610,
-   620,   624,   631,   634,   639,   645,   647,   652,   660,   665,
-   670,   675,   677,   681,   685,   689,   693,   697,   701,   705,
-   709,   713,   717,   721,   725,   729,   733,   737,   741,   745,
-   751,   755,   759,   763,   766,   768,   770,   772,   774,   778,
-   782,   783,   788,   789,   796,   799,   804,   807,   811,   814,
-   817,   819,   824,   829,   832,   838,   842,   845,   848,   851,
-   857,   861,   867,   871,   878,   883,   885,   890,   893,   899,
-   900,   902,   904,   907,   909,   912,   913,   916,   919,   922,
-   926,   930,   934,   938,   941,   944,   946,   948,   951,   954,
-   956,   959,   962,   966,   968,   970,   973,   976,   978,   980,
-   983,   986,   988,   991,   994,   998,  1000,  1003,  1005,  1007,
-  1009,  1011,  1016,  1021,  1023,  1025,  1027,  1029,  1031,  1035,
-  1037,  1041,  1042,  1047,  1048,  1056,  1061,  1062,  1070,  1075,
-  1076,  1084,  1089,  1090,  1097,  1099,  1103,  1105,  1110,  1119,
-  1121,  1125,  1127,  1130,  1134,  1139,  1141,  1143,  1147,  1152,
-  1159,  1163,  1169,  1170,  1178,  1183,  1184,  1191,  1195,  1198,
-  1203,  1205,  1206,  1208,  1209,  1211,  1213,  1216,  1222,  1225,
-  1228,  1231,  1234,  1237,  1240,  1243,  1247,  1251,  1254,  1255,
-  1259,  1260,  1264,  1267,  1269,  1271,  1272,  1274,  1277,  1279,
-  1283,  1285,  1287,  1290,  1293,  1296,  1300,  1302,  1304,  1306,
-  1309,  1312,  1314,  1315,  1317,  1322,  1326,  1328,  1331,  1334,
-  1338,  1344,  1350,  1354,  1358,  1362,  1366,  1370,  1376,  1382,
-  1386,  1390,  1394,  1398,  1400,  1403,  1406,  1410,  1414,  1415,
-  1417,  1421,  1426,  1433,  1438,  1442,  1445,  1450,  1457,  1462,
-  1466,  1469,  1471,  1475,  1477,  1481,  1484,  1487,  1488,  1490,
-  1493,  1495,  1498,  1499,  1502,  1503,  1506,  1512,  1518,  1522,
-  1528,  1533,  1537,  1541,  1547,  1549,  1551,  1557,  1561,  1565,
-  1567,  1573,  1579,  1583,  1589,  1594,  1598,  1602,  1604,  1606,
-  1610,  1614,  1620,  1626,  1630,  1636,  1640,  1644,  1648,  1653,
-  1657,  1659,  1661,  1664,  1667,  1670,  1674,  1678,  1686,  1694,
-  1700,  1708,  1712,  1720,  1728,  1734,  1742,  1746,  1748,  1751,
-  1754,  1756,  1759,  1763,  1767,  1770,  1772,  1776,  1780,  1783,
-  1789,  1793,  1798,  1802,  1807,  1810,  1814,  1817,  1821,  1826,
-  1830,  1835,  1841,  1847,  1849,  1851,  1854,  1857,  1860,  1861,
-  1862,  1864,  1866,  1869,  1873,  1875,  1878,  1881,  1887,  1893,
-  1894,  1895,  1901,  1903,  1906,  1908,  1910,  1912,  1915,  1916,
-  1921,  1923,  1924,  1925,  1931,  1932,  1933,  1941,  1942,  1943,
-  1944,  1954,  1955,  1956,  1957,  1967,  1968,  1975,  1976,  1982,
-  1983,  1991,  1992,  1997,  2000,  2003,  2006,  2010,  2017,  2026,
-  2037,  2050,  2055,  2059,  2062,  2065,  2067,  2070,  2074,  2081,
-  2086,  2093,  2098,  2102,  2103,  2111,  2114,  2115,  2121,  2125,
-  2127,  2130,  2134,  2138,  2141,  2144,  2146,  2147,  2152,  2155,
-  2159,  2163,  2164,  2165,  2170,  2171,  2172,  2177,  2178,  2183,
-  2184,  2186,  2187,  2188,  2197,  2201,  2206,  2211,  2215,  2220,
-  2227,  2234,  2235,  2237,  2238,  2240,  2242,  2243,  2245,  2247,
-  2251,  2256,  2258,  2262,  2263,  2265,  2269,  2272,  2274,  2276,
-  2279,  2282,  2284,  2288,  2292,  2298,  2302,  2308,  2312,  2316,
-  2318,  2320,  2323,  2325,  2326,  2328,  2329,  2332,  2337,  2339,
-  2341,  2343,  2346,  2349,  2352,  2354,  2356,  2358,  2362,  2364,
-  2368,  2371,  2374,  2377,  2380,  2383,  2386,  2389,  2392,  2395,
-  2398,  2401,  2404,  2407,  2410,  2413,  2416,  2419,  2422,  2425,
-  2428,  2431,  2434,  2437,  2441,  2444,  2447,  2450,  2454,  2457,
-  2461,  2464,  2467,  2471
-};
-
-static const short yyrhs[] = {    -1,
-   111,     0,     0,   112,   116,     0,   111,   116,     0,     0,
-     0,    26,     0,    27,     0,   131,     0,   130,     0,   124,
-     0,   122,     0,   115,    83,   167,   104,   105,     0,   117,
-    50,   111,   106,     0,   117,    50,   106,     0,   117,   113,
-   131,   114,     0,   117,   113,   130,   114,     0,    97,     0,
-     0,    45,    65,   119,   120,    66,     0,   121,     0,   120,
-    51,   121,     0,   200,   140,     0,   200,   141,    55,   212,
-     0,   200,    49,   212,     0,   293,     0,    39,   123,   105,
-     0,     3,     0,   123,    51,     3,     0,     0,   118,   201,
-    50,   125,   105,     0,     0,   118,   202,    50,   126,   105,
-     0,     0,   118,   201,    55,   127,   105,     0,     0,   118,
-   202,    55,   128,   105,     0,   118,   201,   105,     0,   118,
-   202,   105,     0,   118,   231,   298,   182,   189,   129,     0,
-   118,   173,   172,   298,   182,   189,   129,     0,   118,   175,
-   172,   129,     0,   118,     1,   106,     0,   118,     1,   105,
-     0,    50,     0,    55,     0,   105,     0,    53,     0,    24,
-     0,   181,   105,     0,   175,   181,   105,     0,   175,   172,
-   105,     0,   173,   180,   105,     0,   173,   172,   105,     0,
-   175,   105,     0,   173,   105,     0,     1,   105,     0,     1,
-   106,     0,   105,     0,   132,   136,   244,     0,   132,   135,
-   136,   244,     0,   132,   168,   244,     0,   132,   135,   105,
-   168,   244,     0,   132,   135,   168,   244,     0,   173,   172,
-     1,     0,   175,   231,     1,     0,   231,     1,     0,   173,
-   172,   298,     0,   175,   231,   298,     0,   231,   298,     0,
-     4,    83,   291,   104,   226,   298,     0,   234,    83,   291,
-   104,   226,   298,     0,     4,    44,   226,   298,     0,   234,
-    44,   226,   298,     0,    96,     0,   173,    83,   291,   104,
-   226,   298,     0,   173,    44,   226,   298,     0,   173,   172,
-   298,     0,   175,    83,   291,   104,   226,   298,     0,   175,
-    44,   226,   298,     0,   175,   172,   298,     0,   231,   298,
-     0,    24,     3,     0,   134,     0,   134,    53,   193,     0,
-   134,    83,   156,   104,     0,   134,    44,     0,    55,   137,
-   138,     0,     0,     0,   139,     0,   138,    51,   139,     0,
-   138,     1,     0,    83,   156,   104,     0,    44,     0,   140,
-    83,   156,   104,     0,   140,    44,     0,   144,    83,   156,
-   104,     0,   144,    44,     0,   234,    83,   156,   104,     0,
-   234,    44,     0,   232,   140,    83,   156,   104,     0,   232,
-   140,    44,     0,     3,     0,     4,     0,    95,     0,   101,
-     0,   100,     0,   102,     0,     3,     0,     4,     0,    95,
-     0,   107,   140,     0,   303,     0,   144,   145,   151,     0,
-    95,    65,   147,    66,     0,     4,    65,   147,    66,     0,
-    50,     0,    55,     0,     0,     0,   148,     0,   147,    51,
-   148,     0,   223,     0,   160,     0,     0,    99,   208,   150,
-   214,   215,   106,     0,     0,   149,     0,     0,   149,   152,
-     0,    70,     0,    69,     0,    75,     0,    76,     0,   108,
-     0,   156,     0,   160,     0,    44,     0,    83,   154,   104,
-     0,   160,     0,   156,    51,   160,     0,   156,    51,     1,
-     0,   161,     0,     0,    33,   158,   159,     0,    71,   159,
-     0,    61,   159,     0,   107,   159,     0,   153,   159,     0,
-    58,   140,     0,    12,   157,     0,    12,    83,   223,   104,
-     0,    29,   157,     0,    29,    83,   223,   104,     0,   165,
-   164,   223,     0,   165,   164,    83,   156,   104,   223,     0,
-   165,   164,   178,    83,   156,   104,     0,   165,   164,    83,
-   156,   104,   178,    83,   156,   104,     0,   165,   164,   178,
-    44,     0,   165,   164,    83,   156,   104,   178,    44,     0,
-   165,   164,   223,    53,   193,     0,   165,   164,    83,   156,
-   104,   223,    53,   193,     0,   165,   164,    83,   176,   224,
-   104,    84,   227,   109,     0,   165,   164,    83,   225,   224,
-   104,    84,   227,   109,     0,   165,   164,    83,   176,   224,
-   104,     0,   165,   164,    83,   156,   104,    83,   176,   224,
-   104,     0,   165,   164,    83,   225,   224,   104,     0,   165,
-   164,    83,   156,   104,    83,   225,   224,   104,     0,   165,
-   164,    49,     0,   165,   164,    83,   156,   104,    49,     0,
-   166,   159,     0,   166,    84,   109,   159,     0,   166,    84,
-   154,   109,   159,     0,   157,     0,    83,   223,   104,   160,
-     0,    83,   223,   104,    50,   194,   198,   106,     0,    30,
-    83,   154,   104,     0,    31,    83,   154,   104,     0,    31,
-    83,     4,   104,     0,   159,     0,   160,    69,   160,     0,
-   160,    70,   160,     0,   160,    71,   160,     0,   160,    72,
-   160,     0,   160,    73,   160,     0,   160,    67,   160,     0,
-   160,    68,   160,     0,   160,    64,   160,     0,   160,    65,
-   160,     0,   160,    66,   160,     0,   160,    63,   160,     0,
-   160,    62,   160,     0,   160,    61,   160,     0,   160,    59,
-   160,     0,   160,    60,   160,     0,   160,    58,   160,     0,
-   160,    57,   160,     0,   160,    54,   286,    55,   160,     0,
-   160,    53,   160,     0,   160,    52,   160,     0,   161,    82,
-   160,     0,   170,   160,     0,     3,     0,   303,     0,     9,
-     0,   167,     0,    83,   154,   104,     0,    83,     1,   104,
-     0,     0,    83,   162,   245,   104,     0,     0,   161,    83,
-   156,   104,   163,   152,     0,   161,    44,     0,   161,    84,
-   154,   109,     0,   169,   142,     0,   169,   232,   142,     0,
-   161,    75,     0,   161,    76,     0,    40,     0,     8,    83,
-   156,   104,     0,   178,    83,   156,   104,     0,   178,    44,
-     0,    46,   178,    83,   156,   104,     0,    46,   178,    44,
-     0,    46,     3,     0,    46,   303,     0,   232,   142,     0,
-   232,   142,    83,   156,   104,     0,   232,   142,    44,     0,
-   169,   142,    83,   156,   104,     0,   169,   142,    44,     0,
-   169,   232,   142,    83,   156,   104,     0,   169,   232,   142,
-    44,     0,    38,     0,    38,    50,   156,   106,     0,    38,
-    42,     0,    38,    42,    83,   167,   104,     0,     0,    46,
-     0,    37,     0,    46,   166,     0,    10,     0,   167,    10,
-     0,     0,   161,    81,     0,   161,    79,     0,   161,    80,
-     0,   173,   180,   105,     0,   173,   172,   105,     0,   175,
-   181,   105,     0,   175,   172,   105,     0,   173,   105,     0,
-   175,   105,     0,   229,     0,   231,     0,    47,   229,     0,
-    47,   231,     0,   178,     0,   175,   178,     0,   178,   174,
-     0,   175,   178,   174,     0,   179,     0,     6,     0,   174,
-   179,     0,   174,     6,     0,     8,     0,     6,     0,   175,
-     8,     0,   175,     6,     0,   178,     0,   225,   178,     0,
-   178,   177,     0,   225,   178,   177,     0,   179,     0,   177,
-   179,     0,   195,     0,     7,     0,     4,     0,   234,     0,
-    28,    83,   154,   104,     0,    28,    83,   223,   104,     0,
-   143,     0,     7,     0,     8,     0,   195,     0,   183,     0,
-   180,    51,   185,     0,   187,     0,   181,    51,   185,     0,
-     0,   115,    83,   167,   104,     0,     0,   172,   298,   182,
-   189,    53,   184,   193,     0,   172,   298,   182,   189,     0,
-     0,   172,   298,   182,   189,    53,   186,   193,     0,   172,
-   298,   182,   189,     0,     0,   231,   298,   182,   189,    53,
-   188,   193,     0,   231,   298,   182,   189,     0,     0,    32,
-    83,    83,   190,   104,   104,     0,   191,     0,   190,    51,
-   191,     0,     3,     0,     3,    83,     9,   104,     0,     3,
-    83,     3,    51,     9,    51,     9,   104,     0,   140,     0,
-   192,    51,   140,     0,   160,     0,    50,   106,     0,    50,
-   194,   106,     0,    50,   194,    51,   106,     0,     1,     0,
-   193,     0,   194,    51,   193,     0,    84,   160,   109,   193,
-     0,   194,    51,    20,   160,    55,   193,     0,   140,    55,
-   193,     0,   194,    51,   140,    55,   193,     0,     0,    13,
-   140,    50,   196,   221,   199,   106,     0,    13,   140,    50,
-   106,     0,     0,    13,    50,   197,   221,   199,   106,     0,
-    13,    50,   106,     0,    13,   140,     0,   207,   214,   215,
-   106,     0,   207,     0,     0,    51,     0,     0,    51,     0,
-    35,     0,    42,    35,     0,    42,    83,   167,   104,    35,
-     0,   200,     6,     0,   200,     7,     0,   200,     8,     0,
-   200,    35,     0,   200,   140,     0,   200,   144,     0,   200,
-    49,     0,   200,   144,    50,     0,   200,   144,    55,     0,
-   200,   141,     0,     0,   201,   204,   208,     0,     0,   202,
-   205,   208,     0,   200,    50,     0,   206,     0,   203,     0,
-     0,    55,     0,    55,   209,     0,   210,     0,   209,    51,
-   210,     0,   212,     0,   211,     0,   213,   212,     0,   213,
-   211,     0,   212,     5,     0,   144,   146,   151,     0,   140,
-     0,    36,     0,     6,     0,   213,    36,     0,   213,     6,
-     0,    50,     0,     0,   216,     0,   215,    36,    55,   216,
-     0,   215,    36,    55,     0,   217,     0,   216,   217,     0,
-   216,   105,     0,   173,   218,   105,     0,   173,    83,   291,
-   104,   105,     0,   173,    83,   291,   104,   106,     0,   173,
-    44,   105,     0,   173,    44,   106,     0,   175,   218,   105,
-     0,   175,   172,   105,     0,   175,   218,   106,     0,   175,
-    83,   291,   104,   105,     0,   175,    83,   291,   104,   106,
-     0,   175,    44,   105,     0,   175,    44,   106,     0,    55,
-   160,   105,     0,    55,   160,   106,     0,     1,     0,   133,
-    55,     0,   133,    50,     0,   231,   298,   105,     0,   231,
-   298,   106,     0,     0,   219,     0,   218,    51,   220,     0,
-   172,   298,   182,   189,     0,   172,   298,   182,   189,    53,
-   193,     0,     3,    55,   160,   189,     0,    49,   160,   189,
-     0,    55,   160,     0,   172,   298,   182,   189,     0,   172,
-   298,   182,   189,    53,   193,     0,     3,    55,   160,   189,
-     0,    49,   160,   189,     0,    55,   160,     0,   222,     0,
-   221,    51,   222,     0,   140,     0,   140,    53,   160,     0,
-   176,   224,     0,   225,   224,     0,     0,   235,     0,    47,
-   235,     0,     8,     0,   225,     8,     0,     0,   226,     8,
-     0,     0,   228,   154,     0,   229,    83,   156,   104,   226,
-     0,   229,    83,   291,   104,   226,     0,   229,    44,   226,
-     0,   229,    83,     1,   104,   226,     0,   229,    84,   227,
-   109,     0,   229,    84,   109,     0,    83,   230,   104,     0,
-    83,    71,   226,   229,   104,     0,    78,     0,   237,     0,
-    83,    61,   226,   229,   104,     0,    71,   226,   229,     0,
-    61,   226,   229,     0,     4,     0,   230,    83,   156,   104,
-   226,     0,   230,    83,   291,   104,   226,     0,   230,    44,
-   226,     0,   230,    83,     1,   104,   226,     0,   230,    84,
-   227,   109,     0,   230,    84,   109,     0,    83,   230,   104,
-     0,    78,     0,   237,     0,    71,   226,   229,     0,    61,
-   226,   229,     0,   231,    83,   156,   104,   226,     0,   231,
-    83,   291,   104,   226,     0,   231,    44,   226,     0,   231,
-    83,     1,   104,   226,     0,    83,   231,   104,     0,    71,
-   226,   231,     0,    61,   226,   231,     0,   231,    84,   227,
-   109,     0,   231,    84,   109,     0,     3,     0,   303,     0,
-   107,     4,     0,   107,     3,     0,   107,    95,     0,   232,
-   295,   231,     0,   232,   295,     4,     0,   232,   295,     4,
-    83,   156,   104,   226,     0,   232,   295,     4,    83,   291,
-   104,   226,     0,   232,   295,     4,    44,   226,     0,   232,
-   295,     4,    83,     1,   104,   226,     0,   232,   295,    95,
-     0,   232,   295,    95,    83,   156,   104,   226,     0,   232,
-   295,    95,    83,   291,   104,   226,     0,   232,   295,    95,
-    44,   226,     0,   232,   295,    95,    83,     1,   104,   226,
-     0,    46,   295,   231,     0,   233,     0,   143,    46,     0,
-     4,    46,     0,     5,     0,   143,     5,     0,    83,   235,
-   104,     0,    71,   226,   235,     0,    71,   226,     0,    78,
-     0,    83,   236,   104,     0,    61,   226,   235,     0,    61,
-   226,     0,   235,    83,   291,   104,   226,     0,   235,    44,
-   226,     0,   235,    84,   227,   109,     0,   235,    84,   109,
-     0,    83,   291,   104,   226,     0,    44,   226,     0,    84,
-   227,   109,     0,    84,   109,     0,   232,    71,   226,     0,
-   232,    71,   226,   235,     0,   232,    61,   226,     0,   232,
-    61,   226,   235,     0,   232,   295,    71,   226,   229,     0,
-   232,   295,    61,   226,   229,     0,   250,     0,   239,     0,
-   238,   250,     0,   238,   239,     0,     1,   105,     0,     0,
-     0,   242,     0,   243,     0,   242,   243,     0,    34,   192,
-   105,     0,   245,     0,     1,   245,     0,    50,   106,     0,
-    50,   240,   241,   238,   106,     0,    50,   240,   241,     1,
-   106,     0,     0,     0,    14,   247,   155,   248,   249,     0,
-   245,     0,   240,   251,     0,   245,     0,   251,     0,   171,
-     0,   154,   105,     0,     0,   246,    15,   252,   249,     0,
-   246,     0,     0,     0,    16,   253,   155,   254,   249,     0,
-     0,     0,    17,   255,   249,    16,   256,   155,   105,     0,
-     0,     0,     0,   283,   257,   286,   105,   258,   286,   104,
-   259,   249,     0,     0,     0,     0,   284,   260,   286,   105,
-   261,   286,   104,   262,   249,     0,     0,    19,    83,   154,
-   104,   263,   249,     0,     0,    20,   154,    55,   264,   250,
-     0,     0,    20,   154,    56,   154,    55,   265,   250,     0,
-     0,    21,    55,   266,   250,     0,    22,   105,     0,    23,
-   105,     0,    24,   105,     0,    24,   154,   105,     0,   115,
-   285,    83,   167,   104,   105,     0,   115,   285,    83,   167,
-    55,   287,   104,   105,     0,   115,   285,    83,   167,    55,
-   287,    55,   287,   104,   105,     0,   115,   285,    83,   167,
-    55,   287,    55,   287,    55,   290,   104,   105,     0,    25,
-    71,   154,   105,     0,    25,   140,   105,     0,   270,   250,
-     0,   270,   106,     0,   105,     0,    93,   105,     0,    93,
-   154,   105,     0,    91,   299,    83,   156,   104,   105,     0,
-    91,   299,    44,   105,     0,    85,   299,    83,   156,   104,
-   105,     0,    85,   299,    44,   105,     0,    85,   140,   105,
-     0,     0,   269,    89,   140,    50,   267,   277,   106,     0,
-   269,     1,     0,     0,   273,   274,   274,   268,   281,     0,
-   269,    87,   301,     0,   269,     0,   271,   106,     0,   271,
-   238,   106,     0,   271,     1,   106,     0,     3,    55,     0,
-    95,    55,     0,    49,     0,     0,    88,    50,   272,   240,
-     0,   275,   106,     0,   275,   238,   106,     0,   275,     1,
-   106,     0,     0,     0,    92,    50,   276,   240,     0,     0,
-     0,   277,   299,   278,   245,     0,     0,   277,    21,   279,
-   245,     0,     0,   140,     0,     0,     0,   281,    90,    83,
-   223,   280,   104,   282,   245,     0,    18,    83,   105,     0,
-    18,    83,   154,   105,     0,    18,    83,    50,   106,     0,
-    18,    83,   171,     0,    18,    83,     1,   105,     0,    18,
-    83,    50,   240,   238,   106,     0,    18,    83,    50,   240,
-     1,   106,     0,     0,     8,     0,     0,   154,     0,     1,
-     0,     0,   288,     0,   289,     0,   288,    51,   289,     0,
-    10,    83,   154,   104,     0,    10,     0,   290,    51,    10,
-     0,     0,   292,     0,   292,    51,    11,     0,   292,    11,
-     0,    11,     0,    94,     0,   292,    94,     0,   292,    55,
-     0,   293,     0,   293,    53,   193,     0,   292,    51,   293,
-     0,   292,    51,   293,    53,   193,     0,   292,    51,   297,
-     0,   292,    51,   297,    53,   193,     0,   173,   296,   294,
-     0,   175,   296,   294,     0,   224,     0,   231,     0,    47,
-   231,     0,   226,     0,     0,   294,     0,     0,    86,   301,
-     0,    93,    83,   302,   104,     0,    98,     0,     3,     0,
-     4,     0,    46,     3,     0,    46,     4,     0,   232,     3,
-     0,   234,     0,   223,     0,   299,     0,   301,    51,   299,
-     0,   300,     0,   302,    51,   300,     0,    41,    71,     0,
-    41,    72,     0,    41,    73,     0,    41,    69,     0,    41,
-    70,     0,    41,    61,     0,    41,    59,     0,    41,    60,
-     0,    41,   107,     0,    41,    51,     0,    41,    64,     0,
-    41,    65,     0,    41,    66,     0,    41,    63,     0,    41,
-    52,     0,    41,    53,     0,    41,    67,     0,    41,    68,
-     0,    41,    75,     0,    41,    76,     0,    41,    58,     0,
-    41,    57,     0,    41,   108,     0,    41,    54,    55,     0,
-    41,    62,     0,    41,    79,     0,    41,    80,     0,    41,
-    43,   226,     0,    41,    44,     0,    41,    84,   109,     0,
-    41,    38,     0,    41,    37,     0,    41,   176,   224,     0,
-    41,     1,     0
-};
-
-#if YYDEBUG != 0
-static const short yyrline[] = { 0,
-   283,   284,   292,   294,   295,   299,   304,   308,   311,   314,
-   317,   319,   321,   322,   325,   327,   329,   332,   337,   342,
-   345,   349,   352,   356,   369,   376,   383,   386,   391,   393,
-   397,   403,   403,   406,   406,   409,   409,   422,   422,   427,
-   432,   447,   470,   479,   480,   483,   484,   485,   486,   487,
-   490,   496,   499,   504,   510,   517,   519,   537,   538,   539,
-   542,   556,   569,   572,   575,   578,   580,   582,   586,   592,
-   597,   602,   607,   612,   617,   622,   628,   638,   647,   654,
-   663,   672,   679,   688,   696,   698,   700,   702,   706,   715,
-   738,   741,   743,   744,   747,   754,   761,   765,   767,   769,
-   771,   773,   775,   779,   785,   787,   788,   791,   793,   794,
-   797,   799,   800,   804,   805,   808,   837,   840,   844,   848,
-   849,   853,   858,   861,   865,   868,   871,   903,   922,   925,
-   929,   932,   936,   938,   940,   942,   944,   948,   951,   954,
-   959,   963,   966,   968,   972,   979,   982,   985,   987,   989,
-   991,   997,  1002,  1022,  1024,  1057,  1060,  1062,  1064,  1066,
-  1068,  1070,  1072,  1074,  1082,  1092,  1095,  1097,  1099,  1101,
-  1104,  1106,  1109,  1137,  1156,  1181,  1183,  1186,  1201,  1203,
-  1205,  1216,  1218,  1220,  1222,  1224,  1226,  1228,  1230,  1232,
-  1234,  1236,  1238,  1240,  1242,  1244,  1246,  1248,  1250,  1252,
-  1254,  1256,  1263,  1266,  1281,  1284,  1299,  1300,  1302,  1304,
-  1306,  1314,  1329,  1334,  1341,  1351,  1401,  1403,  1419,  1421,
-  1425,  1448,  1492,  1494,  1496,  1498,  1500,  1539,  1546,  1548,
-  1550,  1552,  1555,  1558,  1560,  1602,  1604,  1609,  1611,  1615,
-  1618,  1622,  1624,  1632,  1634,  1638,  1647,  1662,  1668,  1671,
-  1678,  1686,  1689,  1696,  1701,  1708,  1710,  1711,  1713,  1721,
-  1724,  1726,  1728,  1732,  1736,  1741,  1743,  1754,  1758,  1760,
-  1763,  1778,  1781,  1783,  1785,  1789,  1792,  1800,  1801,  1802,
-  1803,  1804,  1808,  1812,  1817,  1818,  1819,  1822,  1824,  1827,
-  1829,  1832,  1835,  1839,  1847,  1849,  1858,  1864,  1865,  1871,
-  1879,  1881,  1892,  1895,  1900,  1902,  1907,  1912,  1923,  1938,
-  1941,  1945,  1947,  1952,  1955,  1958,  1964,  1967,  1970,  1972,
-  1974,  1976,  1980,  1984,  1988,  1991,  1994,  1998,  2001,  2005,
-  2060,  2075,  2077,  2080,  2082,  2087,  2088,  2090,  2092,  2095,
-  2098,  2101,  2106,  2109,  2111,  2113,  2119,  2123,  2128,  2133,
-  2140,  2145,  2154,  2159,  2159,  2161,  2164,  2166,  2170,  2172,
-  2176,  2181,  2185,  2189,  2195,  2204,  2218,  2221,  2223,  2227,
-  2253,  2262,  2288,  2291,  2293,  2295,  2298,  2301,  2304,  2309,
-  2374,  2376,  2380,  2382,  2386,  2389,  2392,  2396,  2398,  2402,
-  2404,  2408,  2410,  2414,  2419,  2421,  2423,  2425,  2431,  2434,
-  2435,  2446,  2451,  2455,  2459,  2463,  2468,  2472,  2475,  2478,
-  2481,  2489,  2491,  2495,  2498,  2502,  2505,  2509,  2512,  2513,
-  2517,  2520,  2524,  2527,  2535,  2537,  2541,  2544,  2546,  2548,
-  2550,  2552,  2554,  2556,  2558,  2560,  2561,  2563,  2565,  2567,
-  2570,  2573,  2575,  2577,  2579,  2581,  2583,  2585,  2587,  2588,
-  2590,  2597,  2600,  2602,  2604,  2606,  2608,  2610,  2612,  2614,
-  2616,  2620,  2623,  2629,  2631,  2633,  2642,  2644,  2646,  2648,
-  2650,  2653,  2655,  2657,  2659,  2661,  2663,  2667,  2675,  2692,
-  2695,  2696,  2717,  2722,  2724,  2726,  2728,  2730,  2732,  2734,
-  2736,  2738,  2740,  2742,  2744,  2746,  2748,  2752,  2760,  2767,
-  2774,  2783,  2791,  2804,  2806,  2807,  2808,  2811,  2818,  2828,
-  2830,  2835,  2837,  2840,  2854,  2857,  2860,  2862,  2867,  2874,
-  2878,  2881,  2883,  2886,  2893,  2896,  2899,  2902,  2915,  2918,
-  2920,  2923,  2929,  2931,  2933,  2937,  2940,  2946,  2951,  2954,
-  2959,  2965,  2969,  2972,  2978,  2993,  3000,  3003,  3053,  3053,
-  3132,  3132,  3148,  3148,  3152,  3156,  3159,  3164,  3171,  3180,
-  3189,  3198,  3201,  3207,  3209,  3213,  3217,  3218,  3219,  3222,
-  3225,  3228,  3231,  3234,  3246,  3275,  3285,  3298,  3326,  3357,
-  3369,  3377,  3382,  3389,  3397,  3399,  3406,  3408,  3408,  3416,
-  3421,  3428,  3429,  3431,  3431,  3434,  3455,  3471,  3490,  3508,
-  3511,  3513,  3516,  3533,  3551,  3554,  3556,  3560,  3563,  3565,
-  3567,  3573,  3576,  3580,  3583,  3584,  3590,  3592,  3595,  3597,
-  3601,  3606,  3609,  3618,  3625,  3630,  3635,  3639,  3646,  3650,
-  3654,  3668,  3671,  3673,  3675,  3677,  3679,  3687,  3703,  3708,
-  3709,  3710,  3714,  3718,  3736,  3744,  3747,  3749,  3753,  3756,
-  3758,  3760,  3762,  3764,  3766,  3769,  3774,  3776,  3783,  3785,
-  3792,  3795,  3797,  3799,  3801,  3803,  3805,  3807,  3809,  3811,
-  3813,  3815,  3817,  3819,  3821,  3823,  3832,  3834,  3836,  3838,
-  3840,  3842,  3844,  3846,  3848,  3850,  3862,  3874,  3905,  3917,
-  3929,  3942,  3958,  3960
-};
-
-static const char * const yytname[] = {   "$","error","$illegal.","IDENTIFIER",
-"TYPENAME","SCOPED_TYPENAME","SCSPEC","TYPESPEC","TYPE_QUAL","CONSTANT","STRING",
-"ELLIPSIS","SIZEOF","ENUM","IF","ELSE","WHILE","DO","FOR","SWITCH","CASE","DEFAULT",
-"BREAK","CONTINUE","RETURN","GOTO","ASM_KEYWORD","GCC_ASM_KEYWORD","TYPEOF",
-"ALIGNOF","HEADOF","CLASSOF","ATTRIBUTE","EXTENSION","LABEL","AGGR","VISSPEC",
-"DELETE","NEW","OVERLOAD","THIS","OPERATOR","DYNAMIC","POINTSAT_LEFT_RIGHT",
-"LEFT_RIGHT","TEMPLATE","SCOPE","START_DECLARATOR","EMPTY","TYPENAME_COLON",
-"'{'","','","ASSIGN","'='","'?'","':'","RANGE","OROR","ANDAND","'|'","'^'","'&'",
-"MIN_MAX","EQCOMPARE","ARITHCOMPARE","'<'","'>'","LSHIFT","RSHIFT","'+'","'-'",
-"'*'","'/'","'%'","UNARY","PLUSPLUS","MINUSMINUS","HYPERUNARY","PAREN_STAR_PAREN",
-"POINTSAT","POINTSAT_STAR","'.'","DOT_STAR","'('","'['","RAISE","RAISES","RERAISE",
-"TRY","EXCEPT","CATCH","THROW","ANSI_TRY","ANSI_THROW","TYPENAME_ELLIPSIS","PTYPENAME",
-"PRE_PARSED_FUNCTION_DECL","EXTERN_LANG_STRING","ALL","PRE_PARSED_CLASS_DECL",
-"TYPENAME_DEFN","IDENTIFIER_DEFN","PTYPENAME_DEFN","END_OF_SAVED_INPUT","')'",
-"';'","'}'","'~'","'!'","']'","program","extdefs","@1",".hush_warning",".warning_ok",
-"asm_keyword","extdef","extern_lang_string","template_header","@2","template_parm_list",
-"template_parm","overloaddef","ov_identifiers","template_def","@3","@4","@5",
-"@6","fn_tmpl_end","datadef","fndef","fn.def1","fn.def2","return_id","return_init",
-"base_init",".set_base_init","member_init_list","member_init","identifier","identifier_defn",
-"identifier_or_opname","template_type","template_type_name","tmpl.1","tmpl.2",
-"template_arg_list","template_arg","template_instantiate_once","@7","template_instantiation",
-"template_instantiate_some","unop","expr","paren_expr_or_null","nonnull_exprlist",
-"unary_expr","@8","cast_expr","expr_no_commas","primary","@9","@10","new",".scope",
-"delete","string","nodecls","object","object_star","decl","declarator","typed_declspecs",
-"reserved_declspecs","declmods","typed_typespecs","reserved_typespecquals","typespec",
-"typespecqual_reserved","initdecls","notype_initdecls","maybeasm","initdcl0",
-"@11","initdcl","@12","notype_initdcl0","@13","maybe_attribute","attribute_list",
-"attrib","identifiers_or_typenames","init","initlist","structsp","@14","@15",
-"maybecomma","maybecomma_warn","aggr","named_class_head_sans_basetype","named_class_head_sans_basetype_defn",
-"named_class_head","@16","@17","unnamed_class_head","class_head","maybe_base_class_list",
-"base_class_list","base_class","scoped_base_class","base_class.1","base_class_visibility_list",
-"left_curly","opt.component_decl_list","component_decl_list","component_decl",
-"components","component_declarator0","component_declarator","enumlist","enumerator",
-"typename","absdcl","nonempty_type_quals","type_quals","nonmomentary_expr","@18",
-"after_type_declarator","after_type_declarator_no_typename","notype_declarator",
-"scoped_id","typename_scope","scoped_typename","absdcl1","abs_member_declarator",
-"after_type_member_declarator","stmts","errstmt",".pushlevel","maybe_label_decls",
-"label_decls","label_decl","compstmt_or_error","compstmt","simple_if","@19",
-"@20","implicitly_scoped_stmt","stmt","simple_stmt","@21","@22","@23","@24",
-"@25","@26","@27","@28","@29","@30","@31","@32","@33","@34","@35","@36","@37",
-"try","label_colon","try_head","@38","ansi_try","ansi_dummy","ansi_try_head",
-"@39","except_stmts","@40","@41","optional_identifier","ansi_except_stmts","@42",
-"forhead.1","forhead.2","maybe_type_qual","xexpr","asm_operands","nonnull_asm_operands",
-"asm_operand","asm_clobbers","parmlist","parms","parm","abs_or_notype_decl",
-"see_typename","dont_see_typename","bad_parm","maybe_raises","raise_identifier",
-"ansi_raise_identifier","raise_identifiers","ansi_raise_identifiers","operator_name",
-""
-};
-#endif
-
-static const short yyr1[] = {     0,
-   110,   110,   112,   111,   111,   113,   114,   115,   115,   116,
-   116,   116,   116,   116,   116,   116,   116,   116,   117,   119,
-   118,   120,   120,   121,   121,   121,   121,   122,   123,   123,
-   125,   124,   126,   124,   127,   124,   128,   124,   124,   124,
-   124,   124,   124,   124,   124,   129,   129,   129,   129,   129,
-   130,   130,   130,   130,   130,   130,   130,   130,   130,   130,
-   131,   131,   131,   131,   131,   131,   131,   131,   132,   132,
-   132,   132,   132,   132,   132,   132,   133,   133,   133,   133,
-   133,   133,   133,   134,   135,   135,   135,   135,   136,   137,
-   138,   138,   138,   138,   139,   139,   139,   139,   139,   139,
-   139,   139,   139,   139,   140,   140,   140,   141,   141,   141,
-   142,   142,   142,   142,   142,   143,   144,   144,   145,   145,
-   145,   146,   147,   147,   148,   148,   150,   149,   151,   151,
-   152,   152,   153,   153,   153,   153,   153,   154,   154,   155,
-   155,   156,   156,   156,   157,   158,   157,   157,   157,   157,
-   157,   157,   157,   157,   157,   157,   157,   157,   157,   157,
-   157,   157,   157,   157,   157,   157,   157,   157,   157,   157,
-   157,   157,   157,   157,   157,   159,   159,   159,   159,   159,
-   159,   160,   160,   160,   160,   160,   160,   160,   160,   160,
-   160,   160,   160,   160,   160,   160,   160,   160,   160,   160,
-   160,   160,   160,   160,   161,   161,   161,   161,   161,   161,
-   162,   161,   163,   161,   161,   161,   161,   161,   161,   161,
-   161,   161,   161,   161,   161,   161,   161,   161,   161,   161,
-   161,   161,   161,   161,   161,   164,   164,   164,   164,   165,
-   165,   166,   166,   167,   167,   168,   169,   169,   170,   171,
-   171,   171,   171,   171,   171,   172,   172,   172,   172,   173,
-   173,   173,   173,   174,   174,   174,   174,   175,   175,   175,
-   175,   176,   176,   176,   176,   177,   177,   178,   178,   178,
-   178,   178,   178,   178,   179,   179,   179,   180,   180,   181,
-   181,   182,   182,   184,   183,   183,   186,   185,   185,   188,
-   187,   187,   189,   189,   190,   190,   191,   191,   191,   192,
-   192,   193,   193,   193,   193,   193,   194,   194,   194,   194,
-   194,   194,   196,   195,   195,   197,   195,   195,   195,   195,
-   195,   198,   198,   199,   199,   200,   200,   200,   200,   200,
-   200,   200,   201,   201,   201,   201,   201,   202,   204,   203,
-   205,   203,   206,   207,   207,   208,   208,   208,   209,   209,
-   210,   210,   210,   210,   211,   212,   212,   213,   213,   213,
-   213,   214,   215,   215,   215,   215,   216,   216,   216,   217,
-   217,   217,   217,   217,   217,   217,   217,   217,   217,   217,
-   217,   217,   217,   217,   217,   217,   217,   217,   218,   218,
-   218,   219,   219,   219,   219,   219,   220,   220,   220,   220,
-   220,   221,   221,   222,   222,   223,   223,   224,   224,   224,
-   225,   225,   226,   226,   228,   227,   229,   229,   229,   229,
-   229,   229,   229,   229,   229,   229,   229,   229,   229,   229,
-   230,   230,   230,   230,   230,   230,   230,   230,   230,   230,
-   230,   231,   231,   231,   231,   231,   231,   231,   231,   231,
-   231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
-   231,   231,   231,   231,   231,   231,   231,   232,   232,   233,
-   234,   234,   235,   235,   235,   235,   235,   235,   235,   235,
-   235,   235,   235,   235,   235,   235,   235,   236,   236,   236,
-   236,   237,   237,   238,   238,   238,   238,   239,   240,   241,
-   241,   242,   242,   243,   244,   244,   245,   245,   245,   247,
-   248,   246,   249,   249,   250,   250,   251,   251,   252,   251,
-   251,   253,   254,   251,   255,   256,   251,   257,   258,   259,
-   251,   260,   261,   262,   251,   263,   251,   264,   251,   265,
-   251,   266,   251,   251,   251,   251,   251,   251,   251,   251,
-   251,   251,   251,   251,   251,   251,   251,   251,   251,   251,
-   251,   251,   251,   267,   251,   251,   268,   251,   251,   251,
-   269,   269,   269,   270,   270,   270,   272,   271,   273,   273,
-   273,   274,   276,   275,   277,   278,   277,   279,   277,   280,
-   280,   281,   282,   281,   283,   283,   283,   284,   284,   284,
-   284,   285,   285,   286,   286,   286,   287,   287,   288,   288,
-   289,   290,   290,   291,   291,   291,   291,   291,   291,   291,
-   291,   292,   292,   292,   292,   292,   292,   293,   293,   294,
-   294,   294,   295,   296,   297,   298,   298,   298,   299,   299,
-   299,   299,   299,   299,   299,   300,   301,   301,   302,   302,
-   303,   303,   303,   303,   303,   303,   303,   303,   303,   303,
-   303,   303,   303,   303,   303,   303,   303,   303,   303,   303,
-   303,   303,   303,   303,   303,   303,   303,   303,   303,   303,
-   303,   303,   303,   303
-};
-
-static const short yyr2[] = {     0,
-     0,     1,     0,     2,     2,     0,     0,     1,     1,     1,
-     1,     1,     1,     5,     4,     3,     4,     4,     1,     0,
-     5,     1,     3,     2,     4,     3,     1,     3,     1,     3,
-     0,     5,     0,     5,     0,     5,     0,     5,     3,     3,
-     6,     7,     4,     3,     3,     1,     1,     1,     1,     1,
-     2,     3,     3,     3,     3,     2,     2,     2,     2,     1,
-     3,     4,     3,     5,     4,     3,     3,     2,     3,     3,
-     2,     6,     6,     4,     4,     1,     6,     4,     3,     6,
-     4,     3,     2,     2,     1,     3,     4,     2,     3,     0,
-     0,     1,     3,     2,     3,     1,     4,     2,     4,     2,
-     4,     2,     5,     3,     1,     1,     1,     1,     1,     1,
-     1,     1,     1,     2,     1,     3,     4,     4,     1,     1,
-     0,     0,     1,     3,     1,     1,     0,     6,     0,     1,
-     0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
-     3,     1,     3,     3,     1,     0,     3,     2,     2,     2,
-     2,     2,     2,     4,     2,     4,     3,     6,     6,     9,
-     4,     7,     5,     8,     9,     9,     6,     9,     6,     9,
-     3,     6,     2,     4,     5,     1,     4,     7,     4,     4,
-     4,     1,     3,     3,     3,     3,     3,     3,     3,     3,
-     3,     3,     3,     3,     3,     3,     3,     3,     3,     5,
-     3,     3,     3,     2,     1,     1,     1,     1,     3,     3,
-     0,     4,     0,     6,     2,     4,     2,     3,     2,     2,
-     1,     4,     4,     2,     5,     3,     2,     2,     2,     5,
-     3,     5,     3,     6,     4,     1,     4,     2,     5,     0,
-     1,     1,     2,     1,     2,     0,     2,     2,     2,     3,
-     3,     3,     3,     2,     2,     1,     1,     2,     2,     1,
-     2,     2,     3,     1,     1,     2,     2,     1,     1,     2,
-     2,     1,     2,     2,     3,     1,     2,     1,     1,     1,
-     1,     4,     4,     1,     1,     1,     1,     1,     3,     1,
-     3,     0,     4,     0,     7,     4,     0,     7,     4,     0,
-     7,     4,     0,     6,     1,     3,     1,     4,     8,     1,
-     3,     1,     2,     3,     4,     1,     1,     3,     4,     6,
-     3,     5,     0,     7,     4,     0,     6,     3,     2,     4,
-     1,     0,     1,     0,     1,     1,     2,     5,     2,     2,
-     2,     2,     2,     2,     2,     3,     3,     2,     0,     3,
-     0,     3,     2,     1,     1,     0,     1,     2,     1,     3,
-     1,     1,     2,     2,     2,     3,     1,     1,     1,     2,
-     2,     1,     0,     1,     4,     3,     1,     2,     2,     3,
-     5,     5,     3,     3,     3,     3,     3,     5,     5,     3,
-     3,     3,     3,     1,     2,     2,     3,     3,     0,     1,
-     3,     4,     6,     4,     3,     2,     4,     6,     4,     3,
-     2,     1,     3,     1,     3,     2,     2,     0,     1,     2,
-     1,     2,     0,     2,     0,     2,     5,     5,     3,     5,
-     4,     3,     3,     5,     1,     1,     5,     3,     3,     1,
-     5,     5,     3,     5,     4,     3,     3,     1,     1,     3,
-     3,     5,     5,     3,     5,     3,     3,     3,     4,     3,
-     1,     1,     2,     2,     2,     3,     3,     7,     7,     5,
-     7,     3,     7,     7,     5,     7,     3,     1,     2,     2,
-     1,     2,     3,     3,     2,     1,     3,     3,     2,     5,
-     3,     4,     3,     4,     2,     3,     2,     3,     4,     3,
-     4,     5,     5,     1,     1,     2,     2,     2,     0,     0,
-     1,     1,     2,     3,     1,     2,     2,     5,     5,     0,
-     0,     5,     1,     2,     1,     1,     1,     2,     0,     4,
-     1,     0,     0,     5,     0,     0,     7,     0,     0,     0,
-     9,     0,     0,     0,     9,     0,     6,     0,     5,     0,
-     7,     0,     4,     2,     2,     2,     3,     6,     8,    10,
-    12,     4,     3,     2,     2,     1,     2,     3,     6,     4,
-     6,     4,     3,     0,     7,     2,     0,     5,     3,     1,
-     2,     3,     3,     2,     2,     1,     0,     4,     2,     3,
-     3,     0,     0,     4,     0,     0,     4,     0,     4,     0,
-     1,     0,     0,     8,     3,     4,     4,     3,     4,     6,
-     6,     0,     1,     0,     1,     1,     0,     1,     1,     3,
-     4,     1,     3,     0,     1,     3,     2,     1,     1,     2,
-     2,     1,     3,     3,     5,     3,     5,     3,     3,     1,
-     1,     2,     1,     0,     1,     0,     2,     4,     1,     1,
-     1,     2,     2,     2,     1,     1,     1,     3,     1,     3,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     3,     2,     2,     2,     3,     2,     3,
-     2,     2,     3,     2
-};
-
-static const short yydefact[] = {     3,
-     0,     0,     0,   461,   280,   481,   269,   279,   268,     0,
-     8,     9,     0,   336,     0,     0,     0,     0,   423,   423,
-   423,     0,     0,    76,    19,    60,     0,     0,     5,     6,
-     0,    13,    12,    11,    10,   246,   284,   121,     0,     0,
-   260,     0,   290,   278,     0,   349,   351,   355,   354,   331,
-     0,   423,   478,   281,   462,     4,    58,    59,   423,   480,
-   240,   624,   105,   106,   326,   107,   329,   240,    29,     0,
-   694,   280,   421,   692,   691,   423,   689,   670,   675,   676,
-     0,   682,   681,   667,   668,   666,   685,   674,   671,   672,
-   673,   677,   678,   664,   665,   661,   662,   663,   679,   680,
-   686,   687,     0,   669,   683,   284,   418,   272,     0,   281,
-   337,     0,    20,   643,     0,     0,     0,     0,     0,     0,
-   240,   464,   463,   465,     0,     3,     0,     0,   280,     0,
-     0,   349,   351,   646,     0,    90,    85,   246,     0,     0,
-   482,   479,   119,   120,   129,   440,     0,   423,   423,   435,
-     0,    57,     0,     0,   288,   256,   257,   423,   436,   280,
-   271,   270,    56,     0,   261,     0,     0,   265,   285,   286,
-   262,   264,   287,     0,    51,   106,   339,   340,   341,   342,
-   345,   353,   107,   109,   108,   110,   343,   348,   344,   356,
-   356,   372,     0,    68,   423,     0,   425,     0,     0,    71,
-     0,   423,   624,   646,   205,   421,   207,   244,   240,   240,
-     0,     0,   146,   242,   221,   241,     0,   240,   134,   133,
-   240,   135,   136,     0,   240,   137,     0,   123,   240,   176,
-   182,   126,   145,     0,   240,   208,     0,   240,   418,   272,
-   125,   418,     0,   206,   628,   629,   644,   644,     0,   625,
-   632,   328,     0,   323,     0,   138,   139,     0,     0,    28,
-   688,   684,   690,   423,     0,   423,   423,   486,   624,   425,
-   693,   419,   274,   276,   422,   273,     0,     0,   424,   477,
-   458,   457,   456,     0,     0,    16,     0,     7,     7,    45,
-    44,   646,     0,    31,    35,    39,    33,    37,    40,   292,
-    84,    91,    88,     0,   240,   246,     0,     0,     0,   509,
-    61,   515,    63,   356,   130,   116,   258,   259,     0,     0,
-   423,   423,   448,     0,     0,   449,    66,    55,    69,     0,
-    54,   423,     0,   425,     0,    53,   263,    52,    67,    70,
-   267,   266,   646,   291,   346,   347,   357,   350,   352,   394,
-   240,     0,   399,   399,     0,     0,   377,   646,   454,     0,
-   268,     0,   142,   260,     0,   460,     0,   240,   650,   651,
-     0,   649,     0,     0,   655,   657,   647,     0,     0,   303,
-   467,   472,   466,   646,     0,    74,   240,     0,     0,   153,
-   145,     0,     0,   155,   240,   240,   240,   227,     0,   243,
-     0,   228,   152,   149,   148,     0,     0,     0,     0,   150,
-   240,   118,   151,   240,   240,     0,   240,   240,   240,   240,
-   240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-   240,   240,   240,   215,   219,   220,   248,   249,   247,   240,
-   240,   240,   236,     0,   240,   173,   245,   111,   112,   113,
-     0,   217,     0,   115,   204,   416,   224,   240,   417,   112,
-   113,   229,   418,   418,   423,   627,   418,   631,   630,     0,
-   414,   334,   412,   325,     0,   282,     0,   283,    30,   495,
-   420,   489,   485,     0,     0,     0,     0,   497,     0,   423,
-   624,   425,   277,   275,     0,     0,    22,     0,    27,   117,
-     0,    15,    18,    17,   292,    50,    46,    49,    47,    48,
-    43,     0,     0,     0,     0,   303,   106,    96,   240,     0,
-    92,     0,   121,     0,     0,   316,     0,   312,    86,     0,
-     0,    62,    65,   516,   517,   510,   127,   439,   438,     0,
-     0,   423,   423,     0,   423,     0,   425,   433,   303,   289,
-   429,     0,     0,     0,   432,     0,   423,   423,   292,   369,
-   368,   367,   122,   358,   359,   362,   361,     0,     0,   396,
-   395,   461,   423,   240,   240,   624,   646,     0,   400,   423,
-   624,   646,     0,     0,   330,   379,   378,    83,   423,   423,
-   423,   459,   426,   652,   653,   654,     0,   656,   659,     0,
-     0,     0,   302,   423,     0,   423,     0,    75,   423,     0,
-     0,     0,     0,   280,     0,   147,   226,   240,   210,   209,
-     0,   240,   124,   202,   201,   616,   615,     0,   199,   198,
-   196,   197,   195,   194,   193,   190,   191,   192,   188,   189,
-   183,   184,   185,   186,   187,   203,     0,     0,   238,   240,
-   171,   240,   272,   157,   240,     0,   114,   233,   240,   218,
-     0,   231,   240,     0,   423,   423,   624,   640,   641,   638,
-   639,   646,   626,   634,   645,   636,   633,   240,   335,     0,
-   334,   144,   143,   488,   484,   423,   423,   483,   487,   423,
-   496,   491,     0,   493,     0,   338,     0,    21,   345,   343,
-   348,    14,   303,    32,    36,    34,    38,     0,     0,    94,
-     0,    98,   240,   100,   240,     0,   102,   240,   205,   280,
-   240,   313,     0,   317,     0,    87,    64,     0,     0,   511,
-   512,     0,     0,     0,     0,     0,   447,   443,     0,     0,
-     0,   446,     0,   296,   423,   423,   423,   431,     0,     0,
-   303,   129,     0,   365,   371,   370,   364,   363,   392,   393,
-   240,   383,   384,   646,   303,   406,     0,   292,     0,   380,
-   390,   391,   646,     0,   386,   292,   385,   387,     0,   397,
-   398,   455,   452,   453,   658,     0,   648,     0,     0,   300,
-   470,     0,     0,     0,   475,     0,     0,     0,   646,   222,
-   154,   156,   179,   181,   180,     0,   212,     0,   177,   240,
-   213,   216,     0,     0,     0,   418,   418,   161,   240,     0,
-   174,   240,     0,   235,   240,   223,     0,   642,   489,   485,
-   423,    72,     0,     0,   415,   413,   327,     0,   500,   498,
-   494,   423,   492,    23,    26,     0,     0,    41,    95,    93,
-     0,     0,   104,   240,     0,     0,     0,     0,   314,   310,
-     0,     0,   205,   520,   532,   535,     0,     0,   240,     0,
-     0,     0,   240,     0,   586,     0,     0,     0,     0,   240,
-     0,   566,   612,     0,   527,     0,     0,     0,   505,   525,
-   531,   504,   526,     0,   240,     0,   592,     0,   538,   542,
-   513,     0,   437,   434,   451,   450,   423,   423,   423,   445,
-   294,   430,   427,   428,   503,   502,   299,   366,   360,   303,
-    78,   405,   423,   303,   461,   240,   240,   646,   401,    81,
-   423,     0,   660,   293,     0,     0,   423,   423,   423,   423,
-   423,   423,    73,   225,   332,   200,   131,     0,   237,     0,
-     0,     0,     0,   163,   175,   232,     0,   230,   635,   637,
-   324,   501,   499,   490,    25,    42,    97,    99,     0,   101,
-     0,   321,   240,   315,     0,   318,     0,   514,   508,   519,
-   584,     0,     0,   509,     0,   240,     0,   552,   554,   555,
-   556,     0,   240,     0,   650,   651,     0,     0,   587,     0,
-   593,   567,     0,   585,   613,     0,   528,   254,   646,     0,
-   255,     0,     0,   646,     0,   518,   507,   506,   529,   576,
-     0,     0,   565,   564,     0,   581,     0,   592,     0,   589,
-     0,     0,     0,     0,   444,   441,   442,     0,   297,   404,
-   381,   382,   646,   402,   240,   303,   411,   292,   388,   389,
-   646,   307,     0,   305,   301,   471,   468,   469,   476,   473,
-   474,     0,     0,   131,   214,   239,   172,     0,   272,   158,
-   167,   169,   159,   234,   103,   319,     0,     0,   311,   140,
-   240,   521,   533,   240,   523,     0,     0,   509,   605,     0,
-   608,     0,   548,   240,   240,   557,     0,   563,   573,     0,
-   240,   509,     0,   240,   509,   568,     0,   251,   292,   250,
-   253,   252,   292,   509,   579,     0,   583,   582,   577,   591,
-   590,     0,     0,   128,   295,     0,    77,     0,   303,   410,
-   303,    80,     0,     0,     0,   178,   132,   418,   418,   162,
-   240,     0,   425,   425,     0,   322,     0,   509,   509,   524,
-   536,   609,   607,     0,   606,   546,   240,     0,   553,   562,
-   572,     0,   588,   570,     0,   594,     0,   530,   574,   602,
-   539,   543,   298,   403,   409,   407,     0,     0,   306,   304,
-     0,     0,     0,   164,     0,     0,   320,   141,   522,   534,
-     0,     0,     0,   509,   549,   550,     0,     0,   617,     0,
-   595,   578,     0,     0,     0,     0,   308,   168,   170,   160,
-   165,   166,     0,   611,   610,   547,   240,   571,   569,     0,
-     0,   618,   619,   558,     0,     0,     0,     0,   408,     0,
-   537,   551,   240,   617,     0,     0,   598,   575,   596,     0,
-   540,   544,     0,     0,     0,   559,   620,     0,     0,   600,
-   509,   509,     0,   621,     0,     0,   599,   597,   601,     0,
-   541,   545,   309,   622,     0,   560,   603,     0,     0,     0,
-   623,   561,   604,     0,     0,     0
-};
-
-static const short yydefgoto[] = {  1274,
-     1,     2,   127,   503,   883,    29,    30,    31,   278,   496,
-   497,    32,    70,    33,   512,   514,   513,   515,   511,    34,
-    35,    36,   352,   137,   138,   139,   302,   520,   521,   562,
-   188,   452,    37,    38,   145,   752,   227,   228,   315,   732,
-   316,  1065,   229,   884,  1082,   256,   230,   397,   231,   257,
-   233,   408,   947,   444,   234,   235,   236,   140,   237,   238,
-   885,   343,   247,   171,   248,   239,   273,   392,   274,   154,
-    42,   380,   155,  1038,   344,  1126,    43,   936,   603,  1053,
-  1054,   861,   724,   725,    44,   475,   253,  1063,   680,    45,
-    46,    47,    48,   190,   191,    49,    50,   348,   564,   565,
-   566,   567,   568,   193,   355,   356,   357,   578,   579,   929,
-   472,   473,   241,   668,   242,   114,   367,   368,   156,   325,
-   157,   243,    53,   110,   272,   486,   159,   888,   889,  1084,
-   729,   730,   731,   311,   890,   891,   982,  1148,  1086,   892,
-   893,  1114,   983,  1149,   984,  1191,  1032,  1203,  1251,  1033,
-  1204,  1252,  1194,  1157,  1217,  1095,  1201,  1170,   894,   895,
-   896,  1102,   897,  1028,   898,  1105,  1225,  1249,  1248,  1260,
-  1202,  1270,   899,   900,  1006,   628,  1221,  1222,  1223,  1265,
-   487,   250,   251,   670,   201,   463,   676,   200,   376,   599,
-   377,   600,   244
-};
-
-static const short yypact[] = {    85,
-  1781,  1492,   152,-32768,   749,-32768,-32768,-32768,-32768,   321,
--32768,-32768,    16,-32768,   116,  2019,    74,    82,-32768,-32768,
--32768,  1140,   151,-32768,-32768,-32768,    84,   177,-32768,   285,
-   559,-32768,-32768,-32768,-32768,    62,   108,   182,   723,   839,
-   997,    92,-32768,-32768,  1078,-32768,-32768,-32768,-32768,   301,
-  1615,-32768,-32768,    39,-32768,-32768,-32768,-32768,-32768,-32768,
-  5696,  5379,-32768,-32768,   202,-32768,   310,  5696,-32768,   189,
--32768,   312,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-   325,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,   316,-32768,-32768,   389,  1204,  1494,  1248,-32768,
--32768,   427,-32768,   510,  1140,   500,   500,    51,   523,    49,
-  5696,-32768,-32768,-32768,   427,   450,  4946,   437,    51,  2378,
-  1433,    60,   194,   651,   574,-32768,   536,   160,   411,   411,
--32768,-32768,-32768,-32768,   503,    51,  2063,-32768,-32768,-32768,
-  3444,-32768,  1265,   212,-32768,   675,   677,-32768,-32768,  2129,
--32768,-32768,-32768,   508,   997,   238,  1746,-32768,-32768,-32768,
-  1665,-32768,-32768,  2378,-32768,   312,-32768,-32768,-32768,-32768,
--32768,-32768,   151,-32768,-32768,-32768,-32768,-32768,   473,   566,
-   566,-32768,  4861,-32768,-32768,  3380,   506,   103,   540,   494,
-  2391,-32768,  5379,   240,-32768,   543,-32768,-32768,  5902,  5979,
-   562,   600,-32768,-32768,-32768,  5413,   123,  5777,-32768,-32768,
-  5777,-32768,-32768,  4331,  5777,-32768,   195,-32768,  5777,-32768,
--32768,  6505,  1349,   605,  5369,   683,   266,  5777,  1204,   546,
--32768,  6305,   272,-32768,-32768,-32768,-32768,  3429,   606,   303,
-   660,-32768,   123,   611,   627,   653,  6439,   637,   742,-32768,
-   510,-32768,-32768,-32768,   887,-32768,-32768,-32768,  6261,   641,
--32768,   695,  1494,-32768,-32768,  1494,    48,  3537,-32768,-32768,
-   677,   677,-32768,   354,    64,-32768,  1886,-32768,-32768,-32768,
--32768,   341,    70,-32768,-32768,-32768,-32768,-32768,-32768,   591,
--32768,   179,-32768,  4412,  5777,-32768,   411,   411,   704,   681,
--32768,-32768,-32768,   566,-32768,-32768,   675,   677,  1539,  1539,
--32768,-32768,-32768,  3552,   318,-32768,-32768,-32768,   494,  2378,
--32768,-32768,  3488,   657,  3660,-32768,  1665,-32768,-32768,   494,
--32768,-32768,   341,-32768,-32768,-32768,   338,-32768,-32768,-32768,
-  5777,   548,  1894,  6023,    42,  1648,-32768,   651,   510,   692,
-   543,   175,  6483,   967,   708,-32768,   690,  5777,-32768,    51,
-   644,-32768,   108,   805,-32768,-32768,   772,  2568,   748,   809,
-    51,   151,-32768,   240,   735,-32768,  5777,   543,  4331,-32768,
-  1530,   190,  4331,-32768,  5777,  5858,  5777,-32768,    54,-32768,
-   409,-32768,-32768,-32768,-32768,   745,   747,   704,   759,-32768,
-  5696,-32768,-32768,  5777,  5777,  4493,  5777,  5777,  5777,  5777,
-  5777,  5777,  5777,  5777,  5777,  5777,  5777,  5777,  5777,  5777,
-  5777,  5777,  5777,-32768,-32768,-32768,-32768,-32768,-32768,  5777,
-  5777,  5777,   465,  1367,  4817,-32768,-32768,-32768,    51,   151,
-   123,   541,   272,-32768,-32768,-32768,-32768,  5777,-32768,-32768,
--32768,   646,   702,   702,-32768,-32768,  6085,-32768,-32768,  4412,
-   830,   843,-32768,-32768,   123,-32768,  4736,-32768,-32768,   510,
-   695,  1298,  1298,    50,   355,   792,   799,-32768,   810,-32768,
-  5379,   816,-32768,  1494,   874,   446,-32768,  1102,-32768,-32768,
-   824,-32768,-32768,-32768,   591,-32768,-32768,-32768,-32768,-32768,
--32768,   834,   840,   842,   849,   809,    51,-32768,  5777,   448,
--32768,   679,   806,   123,   684,-32768,  3920,  6483,-32768,   178,
-   411,-32768,-32768,-32768,-32768,   880,-32768,   675,   675,  1539,
-  1539,-32768,-32768,   362,-32768,  3596,   855,-32768,   809,-32768,
-   510,   868,   216,   872,-32768,   875,-32768,-32768,   591,-32768,
--32768,-32768,-32768,   926,-32768,-32768,   976,   383,  6366,-32768,
--32768,   931,   602,  5777,  5777,  6192,   341,   258,-32768,   619,
-  6192,   731,    -1,   932,-32768,-32768,-32768,   669,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,   103,-32768,-32768,   314,
-   427,   906,   939,-32768,  3704,-32768,  3812,-32768,-32768,   317,
-   890,   891,   892,    33,   893,-32768,-32768,  5777,-32768,-32768,
-   902,  5453,-32768,  6483,  6483,-32768,-32768,   952,  6541,  6556,
-  3766,  3333,  3872,  1802,  1790,  1891,  1891,  1891,  1118,  1118,
-   800,   800,-32768,-32768,-32768,-32768,   353,   907,   940,  5777,
--32768,  5696,  1089,   962,  5777,   913,-32768,-32768,  5777,   698,
-   356,-32768,  5777,  2362,-32768,-32768,  6130,-32768,   677,-32768,
--32768,   240,-32768,   971,-32768,   972,-32768,  5777,   123,   921,
-   843,-32768,  6483,   695,   695,-32768,-32768,-32768,-32768,-32768,
--32768,   510,   927,-32768,   924,-32768,  3537,-32768,   947,   468,
-   980,-32768,   809,-32768,-32768,-32768,-32768,    70,   372,-32768,
-   179,-32768,  5777,-32768,  5777,   709,-32768,  5777,   989,   814,
-  5777,-32768,   993,-32768,    89,-32768,-32768,   123,  3164,   880,
--32768,   301,   492,   592,  1539,  1539,-32768,   510,   950,   375,
-   956,-32768,   942,  1003,-32768,-32768,-32768,-32768,  1539,  1539,
-   809,   503,   338,-32768,-32768,-32768,-32768,   976,-32768,-32768,
-  5777,-32768,-32768,   240,  6416,  6483,   957,   807,  1122,-32768,
--32768,-32768,   240,   960,-32768,   964,-32768,-32768,  4930,-32768,
--32768,   510,   510,   510,-32768,  2568,-32768,    65,   982,-32768,
-   510,   965,   418,   968,   510,   970,   431,   973,   240,-32768,
--32768,-32768,-32768,-32768,-32768,   478,-32768,  4247,-32768,  5777,
--32768,-32768,   427,    99,   482,  1204,  6305,-32768,  5777,  4412,
--32768,  5777,   487,-32768,  5777,-32768,   489,   677,  2208,  2208,
-    50,-32768,  4412,  4412,  6483,-32768,-32768,   974,  1298,  1298,
-   510,-32768,-32768,-32768,-32768,   252,    70,-32768,-32768,-32768,
-   555,   560,-32768,  5777,   563,  6344,  4412,  4004,-32768,-32768,
-   283,   697,  1011,-32768,-32768,-32768,   996,  1000,  5777,  1034,
-   985,   986,  5534,   281,-32768,   300,  1043,   103,  1044,  5615,
-   284,-32768,  1087,   994,-32768,  2397,  6236,  2516,-32768,-32768,
-  1085,-32768,-32768,  2322,  5051,  2624,-32768,  2732,-32768,-32768,
--32768,  4861,-32768,-32768,   675,   675,-32768,-32768,-32768,-32768,
--32768,   510,   510,   510,   675,   675,  1054,-32768,-32768,  6416,
--32768,-32768,   787,   809,  1056,  5777,  5777,   341,-32768,-32768,
-   822,  2195,-32768,-32768,  1111,  4412,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,  1064,  6525,   503,    67,-32768,  3324,
-  1015,  1018,   577,-32768,-32768,-32768,   580,-32768,-32768,-32768,
--32768,   695,   695,   510,-32768,-32768,-32768,-32768,   581,-32768,
-  4412,-32768,  5777,-32768,  1075,-32768,   123,-32768,-32768,-32768,
--32768,   721,   721,   704,  4085,  5777,   856,-32768,-32768,-32768,
--32768,  1029,  5777,  1030,  1031,    24,  1033,   727,-32768,   744,
--32768,-32768,  1035,-32768,-32768,  1058,-32768,-32768,   782,   286,
--32768,  1042,   324,   388,  1045,-32768,-32768,-32768,-32768,-32768,
-   103,   123,-32768,-32768,   827,-32768,  2840,-32768,   831,-32768,
-  2948,  4574,  4574,   124,   510,   510,   510,  4412,-32768,-32768,
--32768,-32768,   240,  1095,  5777,  6416,  6483,   591,-32768,-32768,
-   240,  1066,   588,-32768,-32768,   510,   510,   510,   510,   510,
-   510,  4166,  1047,   503,-32768,-32768,-32768,  2568,  1407,  1101,
-  1071,  1074,-32768,-32768,-32768,-32768,  6461,  4412,-32768,-32768,
-  5777,-32768,-32768,  5263,-32768,  1143,  1059,  1055,-32768,  1060,
--32768,  1063,-32768,  5777,  5157,-32768,  1065,-32768,-32768,  1070,
-  5777,-32768,  1079,  5777,-32768,-32768,   427,-32768,   591,-32768,
--32768,-32768,   591,   704,   772,  1126,-32768,-32768,-32768,-32768,
--32768,  1090,  1093,-32768,-32768,  4412,-32768,  4412,  6416,-32768,
-   809,-32768,   502,  1111,  1103,-32768,-32768,  1204,  6305,-32768,
-  5777,  4412,-32768,-32768,  4412,-32768,  1104,   704,   704,-32768,
--32768,-32768,-32768,  3272,-32768,-32768,  5157,  1139,-32768,-32768,
--32768,   590,-32768,-32768,   598,-32768,    47,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,  1153,  1158,  1106,-32768,-32768,
-  1110,  1112,   636,-32768,  1113,  1115,-32768,-32768,-32768,-32768,
-   721,   846,  3056,   704,-32768,-32768,  1114,  1120,  1216,  1123,
--32768,  1137,  4655,  4655,  4412,  1221,-32768,-32768,-32768,-32768,
--32768,-32768,  1128,-32768,-32768,-32768,  5157,-32768,-32768,  1148,
-   360,  1183,-32768,-32768,   527,  1154,  1132,  1138,-32768,  1198,
--32768,-32768,  5777,  1216,  1145,  1216,-32768,-32768,-32768,  2568,
--32768,-32768,  1249,  1156,   380,-32768,-32768,   704,   704,   123,
-   704,   704,  1159,-32768,  1247,  1157,-32768,-32768,-32768,  1160,
--32768,-32768,-32768,-32768,   652,-32768,-32768,  1257,  1164,   704,
--32768,-32768,-32768,  1277,  1279,-32768
-};
-
-static const short yypgoto[] = {-32768,
-  1146,-32768,-32768,   991,    53,  1284,-32768,-32768,-32768,-32768,
-   584,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  -662,  1166,
-  1169,-32768,-32768,-32768,-32768,  1161,-32768,-32768,   587,   -10,
-   802,  -220,   535,   -31,-32768,-32768,  1180,   894,  -900,-32768,
-   550,   243,-32768,    35,  -955,  -163,   752,-32768,  -145,   908,
-  -169,-32768,-32768,-32768,-32768,  -177,   -99,   -93,-32768,-32768,
-   323,    56,    28,  1144,    61,   -15,  1037,     3,    -9,   424,
-   -29,  -293,-32768,-32768,   981,-32768,-32768,-32768,  -468,-32768,
-   180,-32768,  -160,   509,   -26,-32768,-32768,-32768,   643,  -261,
-  1313,  1314,-32768,-32768,-32768,-32768,-32768,  -140,-32768,   593,
-   779,  -496,-32768,   618,   451,   575,  -340,  1001,-32768,-32768,
-   881,   678,   -66,  -101,    -6,  1574,  -267,-32768,   -78,  1036,
-  1272,   171,-32768,    19,  -151,-32768,  -133,  -854,  -864,  -283,
--32768,-32768,   631,  -118,  -131,-32768,-32768,-32768, -1013,  -827,
-   289,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,   339,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,  -995,   134,-32768,   141,-32768,
-   -37,-32768,  -247,  -336,    34,  1131,-32768,    27,  -585,   604,
-   363,-32768,  1361
-};
-
-
-#define	YYLAST		6629
-
-
-static const short yytable[] = {    67,
-   107,   258,   489,    41,    41,   271,   516,   312,   312,   109,
-   166,   785,   277,   189,   173,   587,   498,   326,   108,    54,
-    54,   313,   462,  1017,   249,   285,   536,  1083,    39,    39,
-   499,   172,   362,    41,   187,   549,  1122,  1123,   400,   391,
-   391,  1027,   165,  1031,   308,   848,  1064,   708,   391,   769,
-   349,   391,   115,    28,    28,   391,   447,   447,   130,   391,
-  1018,    40,    40,   240,    41,   391,   556,  1024,   317,    60,
-   240,   758,   404,   447,   447,   405,   447,   584,    60,   410,
-   744,   173,   202,   413,    -1,   135,   122,   123,    61,   446,
-   214,   131,   195,   506,   153,   164,    60,    61,    68,   399,
-  1168,  1199,   255,   777,   778,   369,   370,     6,   111,   294,
-   686,   276,   141,   481,   295,    61,   136,   485,    69,   507,
-   687,   203,   508,   240,   509,    63,    64,   671,  -106,    41,
-   675,   196,   197,   165,  1189,  1190,   804,   456,   173,   858,
-   459,   530,   174,   529,   173,    54,   113,   585,   371,   477,
-  1200,   495,   283,   142,    39,   172,   112,   409,   365,   584,
-   300,   342,  1017,  1064,   296,   385,  1017,   501,   934,   553,
-  1066,    52,    52,   537,   510,   312,   312,   534,   124,   329,
-  1216,    63,   517,     6,   966,   292,   293,    40,   532,   533,
-   326,   335,    52,   340,   859,    41,   175,    23,   364,  1018,
-   372,    52,   845,  1018,   949,    41,   403,  1227,  1228,   158,
-   158,   703,   531,   173,   136,   121,   375,    66,   401,   674,
-   353,   400,   518,   610,   695,   477,   240,   391,   477,  1124,
-   386,   143,   660,   457,   847,  1213,   144,  1261,  1262,   259,
-   538,   539,   471,   297,   276,   411,   173,   279,   298,   173,
-   165,   616,   379,   354,    63,   176,    57,    58,   407,   125,
-   412,   519,   330,   493,   306,   751,   477,  1159,   448,   449,
-   523,    41,   458,   183,   448,   460,   621,   647,   590,   743,
-    41,   726,   917,    63,    64,    52,    52,    52,   174,    41,
-   998,   522,  1000,   260,   661,   554,   922,    52,   299,  1193,
-   158,   158,   995,   996,     6,    54,    16,   252,   769,   677,
-   173,   598,    16,   466,    39,   563,   331,   158,   505,   746,
-   525,   158,   611,    63,    64,   198,   612,   342,  1017,  1195,
-   684,   685,   199,   977,   126,   364,   330,   173,  1004,    28,
-    63,   176,   338,   560,   158,   371,   183,    40,   121,   965,
-   192,   993,   379,   467,   172,   709,   165,   468,    41,   254,
-   450,   545,   770,    52,   786,  1018,   461,   477,   374,   559,
-    65,    52,   451,   561,   174,    66,    61,   654,   451,   262,
-   108,   379,   740,   353,   588,    63,   176,   978,   755,  1232,
-  1110,   240,   379,   141,   183,   240,   469,   372,   490,   312,
-   546,   547,   593,   477,   411,   545,   477,   453,   577,   582,
-   608,   309,   727,   240,  1234,    66,   354,   787,   756,   500,
-   800,   548,   477,   407,   263,   477,   198,   407,  1112,   613,
-   615,   195,   183,   199,  1255,   498,   208,   491,   492,   484,
-   657,   793,   326,   797,   546,   547,   653,   326,   710,   499,
-   627,  1040,   617,   693,   806,  1044,   811,    52,   688,   826,
-   310,   733,   734,  1235,   471,   737,   189,   173,   477,    41,
-   196,   197,   524,   198,   924,   849,   648,   183,   908,   656,
-   199,   477,   924,  1256,   493,   391,   814,   700,   815,   158,
-   158,   618,  -257,    41,   158,   823,   697,   -89,   711,   827,
-   158,   788,     4,   118,  1177,    52,   649,   279,   741,   821,
-  1178,   698,   481,   716,   650,   485,   723,   279,   -24,    11,
-    12,   938,   345,   158,   158,  -292,    52,   346,   477,   369,
-   370,     6,   477,   -24,   941,   332,   563,   477,   767,   477,
-    16,   290,   291,   774,  -292,    19,  -292,  1237,   364,   851,
-   106,   852,   169,   170,   855,   286,   119,   379,    10,   128,
-    20,     4,   129,     6,     7,     8,     9,   794,   142,   798,
-    21,    10,   371,   119,   333,   334,   301,  1130,    41,   303,
-    14,   944,    22,    41,   658,   950,    13,    17,   304,   457,
-   956,   587,   958,    14,    23,   903,   106,   570,  -292,    16,
-    17,   314,   571,   768,    19,   477,    27,   364,   776,   364,
-   477,   379,   336,   477,   366,   375,    11,    12,   305,    20,
-   347,    23,   378,   659,   372,   387,   173,   477,   458,    21,
-   477,   477,  1238,    52,    52,   332,   816,    52,  1134,  1239,
-   477,    22,   443,   106,   395,   817,   594,   595,   477,   119,
-   119,   119,   391,    23,   240,   953,   905,   906,   967,   954,
-  1175,   957,  1176,   968,   119,    27,   970,   563,   471,    41,
-   915,   916,   959,   960,   333,   334,   955,   684,   685,   523,
-  1073,   119,   396,  1074,  1075,   119,   477,   962,   963,   662,
-   969,  1135,   447,  1197,   195,   904,   972,   976,   832,    41,
-   522,  1198,  1268,   477,     4,   118,   762,   763,   119,   465,
-   158,   158,   470,   948,   951,   952,   474,   860,   332,   598,
-   195,   563,   712,   771,   772,     4,   146,   717,   663,   525,
-   476,   364,   373,   196,   197,   119,   198,   106,   490,  1210,
-   478,   824,    16,   199,   479,   264,   158,    19,   664,   488,
-   106,   158,   853,   310,  1131,  1269,   886,   333,   334,   196,
-   197,   713,   665,    16,  1080,   555,   718,   374,    19,   147,
-  1100,   119,   666,   780,   781,  1055,   106,   491,   492,   268,
-   825,    41,   106,   148,   667,   270,   535,  1103,   108,   887,
-   921,   854,    59,   149,    60,   589,    23,   723,   592,   930,
-   150,   979,   980,  1081,  1154,   151,   353,   596,    27,  1101,
-  1076,   591,   106,    61,   563,   549,   198,    23,  1163,   276,
-   379,  1166,   597,   199,   928,   943,  1104,   152,   379,    27,
-   601,    62,    11,    12,    52,   775,   373,   831,   609,   354,
-   602,     4,   160,     6,   161,     8,   162,   975,   619,   714,
-   620,    10,  1085,   119,   119,   143,   -79,  1013,   119,    60,
-   144,   -79,   622,   994,   119,   997,    13,   198,  -106,   119,
-   431,   432,   433,    14,   199,  1185,  1186,  1125,    61,    16,
-    17,   524,   678,  1070,    19,   147,  1108,   119,   715,   165,
-   364,  1041,  1042,   679,   375,   689,   375,   364,   364,   148,
-   364,   976,   690,   987,    41,   158,   158,   992,   696,   149,
-  1093,  1094,   106,   728,  1003,   886,   150,  1146,   691,   158,
-   158,   151,   886,   886,   694,   886,  1049,  1050,   702,   353,
-   264,   979,  1117,    23,    41,   979,  1120,  1162,   704,   158,
-  1165,  1009,  1012,   163,   705,    27,   706,   266,   887,    52,
-   979,  1214,  1069,   707,  1048,   887,   887,   267,   887,   353,
-   390,   394,   354,   742,   268,  1173,  1079,  1174,   232,   269,
-   270,   745,   168,   169,   170,   747,   753,  1183,   106,    10,
-   754,  1184,  1085,   748,  1187,   761,   779,   364,   789,    11,
-    12,   790,   354,   801,   802,   803,   805,   119,   119,    52,
-    52,    14,   168,   169,   170,   807,   810,  1167,    17,    10,
-   457,  1116,   886,   -82,   820,   812,  1085,  1085,   -82,  1090,
-  1092,   822,   813,   833,   834,   106,   837,  1097,   232,   364,
-   842,    14,   843,   364,   846,  1109,  1181,  1182,    17,   375,
-  1113,   183,   173,  -105,  1229,   887,   374,   857,   374,   458,
-   910,   975,  1138,   907,   886,   911,   158,   158,   886,   909,
-   923,  1139,  1085,   931,   935,   981,   627,   627,   937,  1127,
-   108,   939,    52,   940,   119,   119,   942,  1132,   985,   961,
-    63,   176,   986,   177,   178,   179,   364,   887,   988,   989,
-   990,   887,   999,  1001,  1005,   169,   170,   364,  1007,  1019,
-   379,    10,    52,   363,    63,   176,  1039,   177,   178,   179,
-  1045,   886,   180,  1052,  1062,  1147,  1257,  1258,  1071,  1085,
-  1085,  1072,   886,    14,   925,   146,   181,   182,  1158,  1078,
-    17,   373,   818,  1096,  1098,  -105,   180,  1099,  1273,  1106,
-  1107,   276,     4,   118,   887,   455,  1111,  1128,  1133,   979,
-   699,   182,  1136,  1142,  1143,   887,   364,  1144,  1151,   364,
-  1153,   379,    16,  1152,  1155,   379,  1156,    19,   147,  1160,
-   926,   819,   183,  1250,  1161,  1169,   927,   184,   185,   186,
-    16,   886,   148,  1164,   886,    19,   429,   430,   431,   432,
-   433,   374,   149,  1196,  1171,   364,   183,  1172,   119,   150,
-    20,   184,   185,   186,   151,  1205,  1180,  1188,  1206,  1207,
-    21,   528,   363,  1208,   887,  1209,    23,   887,  1218,   364,
-   886,  1211,    22,  1212,  1219,  1220,  1226,  1224,    27,  1230,
-  1233,   106,  1231,  1236,    23,  1241,  1240,   627,   627,  1259,
-   363,  1242,   108,   375,   886,   373,    27,   264,  1243,  1246,
-   265,    72,     6,   887,     8,   275,  1264,  1253,   569,  1254,
-    10,  1266,  1263,  1267,   266,   327,  1271,  1244,  1272,   119,
-   119,   287,    51,    51,   267,    13,  1275,   887,  1276,   504,
-   844,   268,    14,   119,   119,    56,   269,   270,  -646,    17,
-  -646,  -646,   288,   120,   363,   289,  -646,   850,   307,   701,
-   284,   918,   134,   119,   623,   279,  1137,  1091,   337,  1010,
-   550,   167,   494,  1179,  -646,  -646,   945,  -646,   232,  -646,
-   106,   624,   625,   838,   629,   630,   631,   632,   633,   634,
-   635,   636,   637,   638,   639,   640,   641,   642,   643,   644,
-   645,   264,    23,   132,   133,   919,   757,   646,   363,   902,
-   198,   106,  1034,   932,   583,   681,   836,   199,   266,   544,
-   901,    55,    55,   119,   119,   363,  1119,  1245,   267,   328,
-    72,     6,  1150,     8,    73,   268,  1247,   528,   464,    10,
-   269,   270,    55,  1115,   683,     0,   280,   281,   282,   933,
-     0,    55,   434,     0,    13,   374,     0,     0,    51,    55,
-    55,    14,     0,     0,     0,     0,     0,     0,    17,     0,
-   373,     0,   373,   169,   170,   651,     0,     0,   318,    10,
-   119,     0,   120,   435,   436,     0,   363,   437,   438,   439,
-   440,   441,   442,     0,   528,     4,   160,     6,   161,     8,
-   162,    14,     0,     0,     0,    10,     0,     0,    17,   652,
-  1140,     0,     0,   363,     0,     0,     0,     0,     0,     0,
-    13,    23,     0,     0,   358,     0,     0,    14,     0,     0,
-     0,     0,   383,    16,    17,    55,    55,    55,    19,   147,
-     0,   765,   766,     0,   106,     0,     0,    55,     0,  1141,
-    55,    55,     3,   148,     4,     5,     6,     7,     8,     9,
-   169,   170,     0,   149,    10,     0,    10,    55,     0,     0,
-   150,    55,   363,     0,   363,   151,     0,    11,    12,    13,
-     0,     0,     0,     0,     0,   363,    14,    23,    14,   809,
-    15,     0,    16,    17,    55,    17,    18,    19,     0,    27,
-     0,     4,   146,     0,     0,     0,   279,     0,     0,     0,
-     0,     0,    20,    55,     0,   373,     0,   363,    51,   363,
-     0,    55,    21,     0,     0,     0,   363,     0,     0,     0,
-   363,     0,     0,   434,    22,     0,   402,     0,     0,    16,
-     0,     0,     0,     0,    19,   835,    23,    24,    25,     0,
-   281,   282,     0,   116,   117,   120,    26,   454,    27,   148,
-     0,     0,   106,   454,   435,   436,   383,     0,   437,   149,
-   439,     0,   441,   442,     0,   194,   150,     0,     0,     0,
-   363,   151,   363,     0,     0,   363,     0,   358,   856,     0,
-     0,     0,   204,    23,     0,     0,     0,     0,  -646,     0,
-  -646,  -646,     0,     0,     0,    27,  -646,    55,   350,   261,
-     4,   129,     6,     7,     8,     9,     0,     0,   195,     0,
-    10,     0,     0,     0,  -646,  -646,     0,  -646,   920,  -646,
-   341,   169,   170,   106,     0,    13,     0,    10,     0,    55,
-    55,     0,    14,  -374,    55,     0,     0,     0,    16,    17,
-    55,     0,     0,    19,     0,    55,     0,   196,   197,    14,
-   198,     0,   351,     0,     0,     0,    17,   199,    20,     0,
-     0,     0,     0,    55,    55,   528,    55,   946,    21,  -646,
-     0,   319,   320,     0,     0,     0,   363,   528,     0,     0,
-    22,     0,   363,     0,   669,   669,     0,     0,   669,     0,
-   528,   528,    23,     0,     0,     0,   339,     0,     0,     0,
-     0,     0,   586,  -374,    27,     0,     0,     0,     0,   373,
-     0,   363,     0,     0,   528,   528,     0,     0,   359,  -646,
-     0,  -646,  -646,     0,   106,   384,     0,  -646,     0,     0,
-    -2,     3,     0,     4,     5,     6,     7,     8,     9,   195,
-     0,     0,     0,    10,     0,  -646,  -646,     0,  -646,     0,
-  -646,     0,     0,     0,     0,     0,    11,    12,    13,     0,
-     0,   281,   282,   454,     0,    14,     0,     0,     0,    15,
-     0,    16,    17,    55,    55,    18,    19,    55,   196,   197,
-     0,   198,     0,  1046,  1047,     0,     0,   480,   199,   482,
-   483,    20,     0,   528,     0,     0,     0,   120,     0,     0,
-  -257,    21,   120,   424,   425,   426,   427,   428,   429,   430,
-   431,   432,   433,    22,   423,   424,   425,   426,   427,   428,
-   429,   430,   431,   432,   433,    23,    24,    25,   528,     0,
-  1077,     0,     0,     0,     0,    26,     3,    27,     4,     5,
-     6,     7,     8,     9,   540,   541,   572,   146,    10,     0,
-    55,    55,     0,     0,     0,   551,     0,     0,     0,     0,
-     0,    11,    12,    13,     0,     0,     0,     0,     0,     0,
-    14,     0,     0,     0,    15,     0,    16,    17,     0,     0,
-    18,    19,     0,     0,    16,   828,    55,   573,   120,    19,
-   147,    55,   574,     0,     0,   528,    20,     0,   575,     0,
-     0,     0,  1129,     0,   148,     0,    21,   427,   428,   429,
-   430,   431,   432,   433,   149,     0,     0,     0,    22,   528,
-     0,   150,     0,     0,     0,     0,   576,     0,     0,     0,
-    23,    24,    25,     0,     0,   528,     0,     0,    23,     0,
-    26,   502,    27,     0,     0,     0,     0,     0,     0,     0,
-    27,     0,     0,     0,     0,     0,   281,   282,   363,     0,
-     0,   363,     0,     0,     0,     0,     0,     0,     0,    71,
-   281,   282,    72,     6,    55,     8,    73,    55,     0,     0,
-     0,    10,     0,   528,     0,   528,     0,     0,   672,     0,
-     0,     0,     0,     0,     0,     0,    13,     0,   363,   528,
-   358,     0,   528,    14,     0,    74,    75,     0,     0,     0,
-    17,    76,    77,   692,     0,     4,   146,     0,     0,    78,
-    79,    80,    81,     0,     0,    82,    83,    84,    85,    86,
-    87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-    97,    98,     0,    99,   100,    55,    55,   101,   102,     0,
-   281,   282,   103,    16,     0,     0,     0,     0,    19,    55,
-    55,     0,   528,    23,     0,   735,   736,     0,   738,     0,
-     0,     0,     0,   148,     0,   104,   105,     0,     0,    55,
-   749,   750,     0,   149,     0,     0,     0,     0,     0,    55,
-   150,     0,     0,     0,     0,   151,   764,     0,     0,     0,
-     0,     0,  -440,   773,  -440,  -440,     0,    23,  1014,     0,
-  -440,     0,   782,   783,   784,     0,     0,     0,     0,    27,
-     0,     0,     0,   358,    60,     0,     0,   791,  -440,   795,
-     0,  -440,   799,     0,     0,     0,     0,     0,     0,    55,
-    55,     0,     0,    61,     0,   350,     0,     4,   129,     6,
-     7,     8,     9,   358,     0,     0,     0,    10,     0,     0,
-     4,   118,  -440,     0,  -440,   279,     0,     0,     0,     0,
-     0,  -440,    13,     0,     0,     0,     0,     0,     0,    14,
-  -375,     0,     0,     0,  -440,    16,    17,     0,   829,   830,
-    19,     0,     0,     0,     0,     0,    55,    55,    16,   351,
-     0,   264,     0,    19,     0,    20,     0,     0,     0,   839,
-   840,     0,    55,   841,     0,    21,     0,     0,   665,     0,
-     0,     0,     0,     0,     0,     0,     0,    22,   666,     0,
-     0,     0,     0,     0,     0,   268,     0,     0,     0,    23,
-   667,   270,    55,     0,     0,     0,     0,     0,     0,   586,
-  -375,    27,    23,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,    27,     0,     0,     0,   912,   913,
-   914,     0,  1020,     0,  -580,  -580,  -580,  -580,  -580,  -580,
-  -580,  -580,     0,  -580,  -580,  -580,  -580,  -580,  -580,  -580,
-  -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,
-  -580,  -580,  -580,     0,  -580,     0,  -580,     0,  -580,  -580,
-     0,  -580,  -580,  -580,     4,   118,     0,  -580,     0,     0,
-  -580,  -580,     0,     0,     0,     0,     0,     0,     0,  -580,
-     4,   146,  -580,     0,     0,     0,     0,     0,     0,     0,
-  -580,  -580,  -580,     4,   381,     0,  -580,  -580,     0,     4,
-   146,     0,    16,     0,  -580,   264,  -580,    19,  1021,  -580,
-  1022,     0,  -580,  -580,  -580,   964,  -580,     0,    16,     0,
-     0,     0,   665,    19,   147,     0,  -580,  -580,  -580,  -580,
-     0,    16,   666,     0,     0,     0,    19,    16,   148,   268,
-     0,     0,    19,   147,   667,   270,     0,     0,   149,     0,
-     0,    20,     0,     0,     0,   150,    23,   148,     0,     0,
-   151,    21,     0,     0,     0,     0,     0,   149,    27,     0,
-     0,     0,    23,    22,   150,     0,     0,     0,     0,   151,
-  1035,  1036,  1037,     0,    27,   382,     0,     0,     0,     0,
-     0,    23,     0,     0,     0,     0,  1043,    27,     0,     0,
-     0,  1008,     0,    27,  1051,     0,     0,     0,     0,     0,
-  1056,  1057,  1058,  1059,  1060,  1061,  1015,     0,   863,   129,
-     6,     7,     8,   361,   207,   208,     0,   209,    10,   864,
-     0,   865,   866,   867,   868,   869,   870,   871,   872,   873,
-   874,    11,    12,    13,   210,   211,   212,     0,   213,     0,
-    14,     0,   214,  -240,     0,   215,    16,    17,     0,     0,
-     0,   216,     0,     0,   875,   310,     0,     0,     0,     0,
-     0,    72,     6,   217,     8,    73,   218,     0,     0,     0,
-    10,     0,     0,     0,   219,   220,   221,     0,     0,     0,
-   222,   223,     0,     0,     0,    13,     0,     0,   224,     0,
-   876,     0,    14,   877,     0,     0,   878,   879,   880,    17,
-   881,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-   882,  1016,   225,   226,  1025,     0,   863,   129,     6,     7,
-     8,   361,   207,   208,     0,   209,    10,   864,     0,   865,
-   866,   867,   868,   869,   870,   871,   872,   873,   874,    11,
-    12,    13,   210,   211,   212,     0,   213,     0,    14,     0,
-   214,  -240,    23,   215,    16,    17,     0,     0,     0,   216,
-     0,     0,   875,   310,     0,     0,     0,     0,     0,     0,
-     0,   217,     0,     0,   218,     0,     0,     0,     0,     0,
-     0,     0,   219,   220,   221,     0,     0,     0,   222,   223,
-     0,     0,     0,     0,     0,     0,   224,     0,   876,     0,
-     0,   877,     0,     0,   878,   879,   880,     0,   881,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,   882,  1026,
-   225,   226,  1029,     0,   863,   129,     6,     7,     8,   361,
-   207,   208,     0,   209,    10,   864,     0,   865,   866,   867,
-   868,   869,   870,   871,   872,   873,   874,    11,    12,    13,
-   210,   211,   212,     0,   213,     0,    14,     0,   214,  -240,
-     0,   215,    16,    17,     0,     0,     0,   216,     0,     0,
-   875,   310,     0,     0,     0,     0,     0,     0,     0,   217,
-     0,     0,   218,     0,     0,     0,     0,     0,     0,     0,
-   219,   220,   221,     0,     0,     0,   222,   223,     0,     0,
-     0,     0,     0,     0,   224,     0,   876,     0,     0,   877,
-     0,     0,   878,   879,   880,     0,   881,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,   882,  1030,   225,   226,
-  1015,     0,   863,   129,     6,     7,     8,   361,   207,   208,
-     0,   209,    10,   864,     0,   865,   866,   867,   868,   869,
-   870,   871,   872,   873,   874,    11,    12,    13,   210,   211,
-   212,     0,   213,     0,    14,     0,   214,  -240,     0,   215,
-    16,    17,     0,     0,     0,   216,     0,     0,   875,   310,
-     0,     0,     0,     0,     0,     0,     0,   217,     0,     0,
-   218,     0,     0,     0,     0,     0,     0,     0,   219,   220,
-   221,     0,     0,     0,   222,   223,     0,     0,     0,     0,
-     0,     0,   224,     0,   876,     0,     0,   877,     0,     0,
-   878,   879,   880,     0,   881,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,   882,  1118,   225,   226,  1015,     0,
-   863,   129,     6,     7,     8,   361,   207,   208,     0,   209,
-    10,   864,     0,   865,   866,   867,   868,   869,   870,   871,
-   872,   873,   874,    11,    12,    13,   210,   211,   212,     0,
-   213,     0,    14,     0,   214,  -240,     0,   215,    16,    17,
-     0,     0,     0,   216,     0,     0,   875,   310,     0,     0,
-     0,     0,     0,     0,     0,   217,     0,     0,   218,     0,
-     0,     0,     0,     0,     0,     0,   219,   220,   221,     0,
-     0,     0,   222,   223,     0,     0,     0,     0,     0,     0,
-   224,     0,   876,     0,     0,   877,     0,     0,   878,   879,
-   880,     0,   881,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   882,  1121,   225,   226,  1015,     0,   863,   129,
-     6,     7,     8,   361,   207,   208,     0,   209,    10,   864,
-     0,   865,   866,   867,   868,   869,   870,   871,   872,   873,
-   874,    11,    12,    13,   210,   211,   212,     0,   213,     0,
-    14,     0,   214,  -240,     0,   215,    16,    17,     0,     0,
-     0,   216,     0,     0,   875,   310,     0,     0,     0,     0,
-     0,     0,     0,   217,     0,     0,   218,     0,     0,     0,
-     0,     0,     0,     0,   219,   220,   221,     0,     0,     0,
-   222,   223,     0,     0,     0,     0,     0,     0,   224,     0,
-   876,     0,     0,   877,     0,     0,   878,   879,   880,     0,
-   881,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-   882,  1215,   225,   226,   862,     0,   863,   129,     6,     7,
-     8,   361,   207,   208,     0,   209,    10,   864,     0,   865,
-   866,   867,   868,   869,   870,   871,   872,   873,   874,    11,
-    12,    13,   210,   211,   212,     0,   213,     0,    14,     0,
-   214,  -240,     0,   215,    16,    17,     0,     0,     0,   216,
-     0,     0,   875,   310,     0,     0,     0,     0,     0,     0,
-     0,   217,     0,     0,   218,     0,     0,     0,     0,     0,
-     0,     0,   219,   220,   221,     0,     0,     0,   222,   223,
-     0,     0,     0,     0,     0,     0,   224,     0,   876,     0,
-     0,   877,     0,     0,   878,   879,   880,     0,   881,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,   882,     0,
-   225,   226,  1192,     0,   863,   129,     6,     7,     8,   361,
-   207,   208,     0,   209,    10,   864,     0,   865,   866,   867,
-   868,   869,   870,   871,   872,   873,   874,    11,    12,    13,
-   210,   211,   212,     0,   213,     0,    14,     0,   214,  -240,
-     0,   215,    16,    17,     0,     0,     0,   216,     0,     0,
-   875,   310,     0,     0,     0,     0,     0,    72,     6,   217,
-     8,    73,   218,     0,     0,     0,    10,     0,     0,     0,
-   219,   220,   221,     0,     0,     0,   222,   223,     0,     0,
-     0,    13,     0,     0,   224,     0,   876,     0,    14,   877,
-     0,     0,   878,   879,   880,    17,   881,     0,     0,     0,
-     0,     0,  1067,     0,     0,     0,   882,     0,   225,   226,
-   360,     0,   205,   129,     6,     7,     8,   361,   207,   208,
-   245,   209,    10,   421,   422,   423,   424,   425,   426,   427,
-   428,   429,   430,   431,   432,   433,  1068,    13,   210,   211,
-   212,     0,   213,     0,    14,     0,   214,  -240,    23,   215,
-    16,    17,     0,     0,     0,   216,     0,     0,     0,     0,
-     0,     0,    72,     6,   161,     8,   162,   217,     0,     0,
-   218,    10,     0,     0,     0,     0,     4,   118,   219,   220,
-   221,     0,     0,     0,   222,   223,    13,     0,     0,     0,
-     0,     0,   224,    14,     0,     0,     0,     0,     0,     0,
-    17,     0,     0,   246,    23,     0,     0,     0,     0,     0,
-     0,     0,     0,  -624,    16,     0,   225,   226,   552,    19,
-   205,   129,     6,     7,     8,   361,   207,   208,   245,   209,
-    10,     0,     0,     0,   321,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,   322,    13,   210,   211,   212,     0,
-   213,   323,    14,    23,   214,  -240,   324,   215,    16,    17,
-     0,     0,     0,   216,     0,     0,     0,     0,    23,     0,
-    72,     6,     7,     8,     9,   217,     0,     0,   218,    10,
-    27,     0,     0,     0,     4,   118,   219,   220,   221,     0,
-     0,     0,   222,   223,    13,     0,     0,     0,     0,     0,
-   224,    14,     0,     0,     0,     0,     0,     0,    17,     0,
-     0,   246,    23,     0,     0,     0,     0,     0,     0,     0,
-     0,  -624,    16,     0,   225,   226,   739,    19,   205,   129,
-     6,     7,     8,   361,   207,   208,   245,   209,    10,     0,
-     0,     0,   542,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   543,    13,   210,   211,   212,     0,   213,   323,
-    14,    23,   214,  -240,   324,   215,    16,    17,     0,     0,
-     0,   216,     0,     0,     0,     0,    23,     0,     0,     0,
-     0,     0,     0,   217,     0,     0,   218,     0,    27,     0,
-     0,     0,     4,   381,   219,   220,   221,     0,     0,     0,
-   222,   223,     0,     0,     0,     0,     0,     0,   224,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,   246,
-    23,     0,     0,     0,     0,     0,     0,     0,     0,  -624,
-    16,     0,   225,   226,   792,    19,   205,   129,     6,     7,
-     8,   361,   207,   208,   245,   209,    10,     0,     0,     0,
-   557,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-   558,    13,   210,   211,   212,     0,   213,     0,    14,     0,
-   214,  -240,    22,   215,    16,    17,     0,     0,     0,   216,
-     0,     0,     0,     0,   382,     0,     0,     0,     0,     0,
-     0,   217,     0,     0,   218,     0,    27,     0,     0,     0,
-     0,     0,   219,   220,   221,     0,     0,     0,   222,   223,
-     0,     0,     0,     0,     0,     0,   224,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,   246,    23,     0,
-     0,     0,     0,     0,     0,     0,     0,  -624,     0,     0,
-   225,   226,   796,     0,   205,   129,     6,     7,     8,   361,
-   207,   208,   245,   209,    10,   420,   421,   422,   423,   424,
-   425,   426,   427,   428,   429,   430,   431,   432,   433,    13,
-   210,   211,   212,     0,   213,     0,    14,     0,   214,  -240,
-     0,   215,    16,    17,     0,     0,     0,   216,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,   217,
-     0,     0,   218,     0,     0,     0,     0,     0,     0,     0,
-   219,   220,   221,     0,     0,     0,   222,   223,     0,     0,
-     0,     0,     0,     0,   224,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,   246,    23,     0,     0,     0,
-     0,     0,     0,     0,     0,  -624,     0,     0,   225,   226,
-   526,     0,   719,   720,     6,     0,     8,   388,   207,   208,
-     0,   209,    10,   422,   423,   424,   425,   426,   427,   428,
-   429,   430,   431,   432,   433,     0,     0,    13,   210,   211,
-   212,     0,   213,     0,    14,     0,   214,  -240,     0,   215,
-    16,    17,     0,     0,     0,   216,     0,     0,     0,   527,
-     0,     0,     0,     0,     0,     0,     0,   217,     0,     0,
-   218,     0,     0,     0,     0,     0,     0,     0,   219,   220,
-   221,     0,     0,     0,   222,   223,     0,     0,     0,     0,
-     0,     0,   224,   721,   526,     0,   719,   720,     6,     0,
-     8,   388,   207,   208,   183,   209,    10,     0,     0,     0,
-     0,     0,     0,   973,     0,   722,   225,   226,     0,     0,
-     0,    13,   210,   211,   212,     0,   213,     0,    14,     0,
-   214,  -240,     0,   215,    16,    17,     0,     0,     0,   216,
-     0,     0,     0,   527,     0,     0,     0,     0,     0,     0,
-     0,   217,     0,     0,   218,     0,     0,     0,     0,     0,
-     0,     0,   219,   220,   221,     0,     0,     0,   222,   223,
-     0,     0,     0,     0,     0,  1087,   224,   205,   129,     6,
-     7,     8,   361,   207,   208,     0,   209,    10,   183,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,   974,
-   225,   226,    13,   210,   211,   212,     0,   213,     0,    14,
-     0,   214,  -240,     0,   215,    16,    17,     0,     0,     0,
-   216,     0,     0,     0,  1088,     0,     0,     0,     0,     0,
-     0,     0,   217,     0,     0,   218,     0,     0,     0,     0,
-     0,     0,     0,   219,   220,   221,     0,     0,     0,   222,
-   223,     0,     0,     0,     0,     0,   526,   224,   719,   720,
-     6,     0,     8,   388,   207,   208,     0,   209,    10,    23,
-     0,     0,     0,     0,     0,   973,     0,     0,     0,  1089,
-     0,   225,   226,    13,   210,   211,   212,     0,   213,     0,
-    14,     0,   214,  -240,     0,   215,    16,    17,     0,     0,
-     0,   216,     0,     0,     0,   527,     0,     0,     0,     0,
-     0,     0,     0,   217,     0,     0,   218,     0,     0,     0,
-     0,     0,     0,     0,   219,   220,   221,     0,     0,     0,
-   222,   223,     0,     0,     0,     0,     0,   526,   224,   719,
-   720,     6,     0,     8,   388,   207,   208,     0,   209,    10,
-   183,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,  -333,   225,   226,    13,   210,   211,   212,     0,   213,
-     0,    14,     0,   214,  -240,     0,   215,    16,    17,     0,
-     0,     0,   216,     0,     0,     0,   527,     0,     0,     0,
-     0,     0,     0,     0,   217,     0,     0,   218,     0,     0,
-     0,     0,     0,     0,     0,   219,   220,   221,     0,     0,
-     0,   222,   223,     0,     0,     0,     0,     0,     0,   224,
-   721,   406,     0,   205,   129,     6,     0,     8,   206,   207,
-   208,   183,   209,    10,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,   225,   226,     0,     0,     0,    13,   210,
-   211,   212,     0,   213,     0,    14,     0,   214,  -240,     0,
-   215,    16,    17,     0,     0,     0,   216,     0,     0,     0,
-  -211,     0,     0,     0,     0,     0,     0,     0,   217,     0,
-     0,   218,     0,     0,     0,     0,     0,     0,     0,   219,
-   220,   221,     0,     0,     0,   222,   223,     0,     0,     0,
-     0,     0,   526,   224,   205,   129,     6,     0,     8,   388,
-   207,   208,     0,   209,    10,    23,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,   225,   226,    13,
-   210,   211,   212,     0,   213,     0,    14,     0,   214,  -240,
-     0,   215,    16,    17,     0,     0,     0,   216,     0,     0,
-     0,   527,     0,     0,     0,     0,     0,     0,     0,   217,
-     0,     0,   218,     0,     0,     0,     0,     0,     0,     0,
-   219,   220,   221,     0,     0,     0,   222,   223,     0,     0,
-     0,     0,     0,   626,   224,   205,   129,     6,     0,     8,
-   388,   207,   208,     0,   209,    10,    23,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,   225,   226,
-    13,   210,   211,   212,     0,   213,     0,    14,     0,   214,
-  -240,     0,   215,    16,    17,     0,     0,     0,   216,     0,
-     0,     0,     0,     0,     0,     0,     0,  -614,     0,     0,
-   217,     0,     0,   218,     0,     0,     0,     0,     0,     0,
-     0,   219,   220,   221,     0,     0,     0,   222,   223,     0,
-     0,     0,     0,     0,   626,   224,   205,   129,     6,     0,
-     8,   388,   207,   208,     0,   209,    10,    23,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,   225,
-   226,    13,   210,   211,   212,     0,   213,     0,    14,     0,
-   214,  -240,     0,   215,    16,    17,     0,     0,     0,   216,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,   217,     0,     0,   218,     0,     0,     0,     0,     0,
-     0,     0,   219,   220,   221,     0,     0,     0,   222,   223,
-     0,     0,     0,     0,     0,   626,   224,   205,   129,     6,
-     0,     8,   388,   207,   208,     0,   209,    10,    23,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,  -614,     0,
-   225,   226,    13,   210,   211,   212,     0,   213,     0,    14,
-     0,   214,  -240,     0,   215,    16,    17,     0,     0,     0,
-   216,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   217,     0,     0,   218,     0,     0,     0,     0,
-     0,     0,     0,   219,   220,   221,     0,     0,     0,   222,
-   223,     0,     0,     0,     0,     0,   682,   224,   205,   129,
-     6,     0,     8,   388,   207,   208,     0,   209,    10,    23,
-     0,     0,     0,     0,     0,     0,     0,     0,  -614,     0,
-     0,   225,   226,    13,   210,   211,   212,     0,   213,     0,
-    14,     0,   214,  -240,     0,   215,    16,    17,     0,     0,
-     0,   216,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,   217,     0,     0,   218,     0,     0,     0,
-     0,     0,     0,     0,   219,   220,   221,     0,     0,     0,
-   222,   223,     0,     0,     0,     0,     0,     0,   224,   205,
-   129,     6,     0,     8,   388,   207,   208,     0,   209,    10,
-    23,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   225,   226,    13,   210,   211,   212,     0,   213,
-     0,    14,     0,   214,     0,     0,   215,    16,    17,     0,
-     0,   350,   216,     4,   129,     6,     7,     8,     9,     0,
-     0,     0,     0,    10,   217,     0,     0,   218,     0,     0,
-     0,     0,     0,     0,     0,   219,   220,   221,    13,     0,
-     0,   222,   223,     0,     0,    14,  -373,     0,     0,   224,
-     0,    16,    17,     0,     0,     0,    19,     0,     0,     0,
-     0,    23,     0,     0,     0,   351,     0,     0,     0,     0,
-     0,    20,     0,   225,   226,   655,     0,     0,     0,     0,
-   350,    21,     4,   129,     6,     7,     8,     9,     0,     0,
-     0,     0,    10,    22,     0,     0,     3,     0,     4,     5,
-     6,     7,     8,     9,     0,    23,     0,    13,    10,     0,
-     0,     0,     0,     0,    14,  -376,  -373,    27,     0,     0,
-    16,    17,     0,    13,     0,    19,     0,     0,     0,     0,
-    14,     0,     0,     0,   351,     0,    16,    17,     0,     0,
-    20,    19,     0,     0,     0,     0,     0,     0,     0,     0,
-    21,     0,     0,     0,     0,     0,    20,     0,     0,     0,
-     0,     0,    22,     0,     0,     0,    21,     0,     0,     0,
-     0,     0,     0,     0,    23,     0,     0,     0,    22,     0,
-     0,     0,     0,     0,     0,  -376,    27,     0,     0,     0,
-    23,    24,     0,     0,     0,     0,     0,     0,     0,     0,
-    26,     0,    27,   863,   129,     6,     7,     8,   361,   207,
-   208,     0,   209,    10,   864,     0,   865,   866,   867,   868,
-   869,   870,   871,   872,   873,   874,    11,    12,    13,   210,
-   211,   212,     0,   213,     0,    14,     0,   214,     0,     0,
-   215,    16,    17,     0,     0,     0,   216,     0,     0,   875,
-   310,     0,     0,     0,     0,     0,     0,     0,   217,     0,
-     0,   218,     0,     0,     0,     0,     0,     0,     0,   219,
-   220,   221,     0,     0,     0,   222,   223,     0,     0,     0,
-     0,     0,     0,   224,     0,   876,     0,     0,   877,     0,
-     0,   878,   879,   880,     0,   881,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,   882,  1023,   225,   226,   863,
-   129,     6,     7,     8,   361,   207,   208,     0,   209,    10,
-   864,     0,   865,   866,   867,   868,   869,   870,   871,   872,
-   873,   874,    11,    12,    13,   210,   211,   212,     0,   213,
-     0,    14,     0,   214,     0,     0,   215,    16,    17,     0,
-     0,     0,   216,     0,     0,   875,   310,     0,     0,     0,
-     0,     0,     0,     0,   217,     0,     0,   218,     0,     0,
-     0,     0,     0,     0,     0,   219,   220,   221,     0,     0,
-     0,   222,   223,     0,     0,     0,     0,     0,     0,   224,
-     0,   876,     0,     0,   877,     0,     0,   878,   879,   880,
-     0,   881,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,   882,     0,   225,   226,   863,   129,     6,     7,     8,
-   361,   207,   208,     0,   209,    10,   864,     0,   865,   866,
-   867,   868,   869,   870,   871,   872,   873,   874,    11,    12,
-    13,   210,   211,   212,     0,   213,     0,    14,     0,   214,
-     0,     0,   215,    16,    17,     0,     0,     0,   216,     0,
-     0,   875,     0,     0,     0,     0,     0,     0,     0,     0,
-   217,     0,     0,   218,     0,     0,     0,     0,     0,     0,
-     0,   219,   220,   221,     0,     0,     0,   222,   223,     0,
-     0,     0,     0,     0,     0,   224,     0,   876,     0,     0,
-   877,     0,     0,   878,   879,   880,     0,   881,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,   882,     0,   225,
-   226,   205,   129,     6,     0,     8,   388,   207,   208,     0,
-   209,    10,    72,     6,     7,     8,     9,     0,     0,   245,
-     0,    10,     0,     0,     0,     0,    13,   210,   211,   212,
-     0,   213,     0,    14,     0,   214,    13,     0,   215,    16,
-    17,     0,     0,    14,   216,   398,    72,     6,     0,     8,
-    17,     0,     0,     0,     0,    10,   217,     0,     0,   218,
-     0,     0,     0,     0,     0,     0,     0,   219,   220,   221,
-    13,     0,     0,   222,   223,     0,     0,    14,     0,   214,
-     0,   224,   445,    16,    17,   205,   129,     6,   399,     8,
-   388,   207,   208,    23,   209,    10,     0,     0,     0,     0,
-     0,     0,   246,    23,     0,   225,   226,     0,     0,     0,
-    13,   210,   211,   212,     0,   213,     0,    14,     0,   214,
-     0,     0,   215,    16,    17,     0,     0,     0,   216,     0,
-     0,     0,   808,     0,     0,     0,     0,    23,     0,     0,
-   217,     0,     0,   218,     0,     0,     0,     0,     0,     0,
-     0,   219,   220,   221,     0,     0,     0,   222,   223,     0,
-     0,     0,     0,     0,     0,   224,   205,   129,     6,     0,
-     8,   388,   207,   208,     0,   209,    10,    23,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,   225,
-   226,    13,   210,   211,   212,     0,   213,     0,    14,     0,
-   214,     0,     0,   215,    16,    17,     0,     0,     0,   216,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,   217,     0,     0,   218,     0,     0,     0,     0,     0,
-     0,     0,   219,   220,   221,     0,     0,     0,   222,   223,
-     0,     0,     0,     0,     0,     0,   224,   205,   129,     6,
-     0,     8,   388,   207,   208,     0,   209,    10,    23,     0,
-     0,     0,     0,     0,     0,     0,     0,     0,   991,     0,
-   225,   226,    13,   210,   211,   212,     0,   213,     0,    14,
-     0,   214,     0,     0,   215,    16,    17,     0,     0,     0,
-   216,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   217,     0,     0,   218,     0,     0,     0,     0,
-     0,     0,     0,   219,   220,   221,     0,     0,     0,   222,
-   223,     0,     0,     0,     0,     0,     0,   224,   205,   129,
-     6,     0,     8,   206,   207,   208,     0,   209,    10,    23,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,  1002,
-     0,   225,   226,    13,   210,   211,   212,     0,   213,     0,
-    14,     0,   214,     0,     0,   215,    16,    17,     0,     0,
-     0,   216,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,   217,     0,     0,   218,     0,     0,     0,
-     0,     0,     0,     0,   219,   220,   221,     0,     0,     0,
-   222,   223,     0,     0,     0,     0,     0,     0,   224,   205,
-   129,     6,     0,     8,   388,   207,   208,     0,   209,    10,
-    23,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   225,   226,    13,   210,   211,   212,     0,   213,
-     0,    14,     0,   214,     0,     0,   215,    16,    17,     0,
-     0,     0,   216,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,   217,     0,     0,   218,     0,     0,
-     0,     0,     0,     0,     0,   219,   220,   221,     0,     0,
-     0,   222,   223,     0,     0,     0,     0,     0,     0,   224,
-   205,   614,     6,     0,     8,   388,   207,   208,     0,   209,
-    10,    23,     0,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,   225,   226,    13,   210,   211,   212,     0,
-   213,     0,    14,     0,   214,     0,     0,   215,    16,    17,
-     0,     0,     0,   216,   205,   129,     6,     0,     8,   388,
-   207,   208,     0,   209,    10,   217,     0,     0,   218,     0,
-     0,     0,     0,     0,     0,     0,   219,   220,   221,    13,
-   210,     0,   222,   223,   213,     0,    14,     0,   214,     0,
-   224,   215,    16,    17,     0,     0,     0,   216,     0,     0,
-     0,     0,    23,     0,     0,     0,     0,     0,     0,   217,
-     0,     0,   218,     0,   225,   226,     0,     0,     0,     0,
-   219,   220,   221,     0,     0,     0,   222,   223,     0,     0,
-     0,   205,   129,     6,   389,     8,   388,   207,   208,     0,
-   209,    10,     0,     0,     0,     0,    23,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,    13,   210,   225,   226,
-     0,   213,     0,    14,     0,   214,     0,     0,   215,    16,
-    17,     0,     0,     0,   216,   572,   160,     6,   161,     8,
-   162,     0,     0,     0,     0,    10,   217,     0,     0,   218,
-     0,     0,     0,     0,     0,     0,     0,   219,   220,   221,
-    13,     0,     0,   222,   223,     0,     0,    14,     0,     0,
-     0,   393,     0,    16,    17,     0,   580,     0,    19,   147,
-     0,   574,     0,    23,     0,     0,     0,   575,     0,     0,
-     0,     0,     0,   148,     0,   225,   226,     4,   129,     6,
-     7,     8,     9,   149,     0,   673,     0,    10,     0,     0,
-   150,     0,     0,     0,     0,   581,     0,     0,     0,     0,
-     0,     0,    13,     0,     0,     0,     0,    23,     0,    14,
-     0,     0,     0,     0,     0,    16,    17,     0,   264,    27,
-    19,   664,     4,   129,     6,     7,     8,     9,     0,     0,
-   245,     0,    10,     0,     0,   665,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,   666,     0,    13,     0,     0,
-     0,     0,   268,     0,    14,     0,     0,   667,   270,     0,
-    16,    17,     0,   264,     0,    19,     0,     0,     0,    23,
-     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-   665,    27,     0,     0,     4,   129,     6,     7,     8,     9,
-   666,     0,   245,     0,    10,     0,     0,   268,     0,     0,
-     0,     0,   667,   270,     0,     0,     0,     0,     0,    13,
-     0,     0,     0,   246,    23,     0,    14,     0,     0,     0,
-     0,     0,    16,    17,     0,     0,    27,    19,     4,   160,
-     6,   161,     8,   162,     0,     0,     0,     0,    10,     0,
-     0,     0,   321,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,   322,    13,   129,     6,     7,     8,     9,   323,
-    14,   245,     0,    10,   324,     0,    16,    17,     0,     0,
-     0,    19,   147,     0,     0,   246,    23,     0,    13,     0,
-     0,     0,     0,     0,     0,    14,   148,     0,    27,     0,
-     0,     0,    17,     0,   264,     0,   149,     0,    72,     6,
-     0,     8,   275,   150,     0,     0,     0,    10,   151,     0,
-     0,   266,     0,     0,     0,     0,     0,     0,     0,     0,
-    23,   267,    13,     0,     0,     0,     0,     0,   268,    14,
-  1011,     0,    27,   269,   270,     0,    17,     0,   264,     0,
-     0,   265,     0,     0,   246,    23,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,   266,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,   267,     0,     0,     0,     0,
-     0,     0,   268,     0,     0,     0,     0,   269,   270,     0,
-     0,     0,     0,     0,     0,   414,   415,   416,     0,    23,
-   417,   418,   419,   420,   421,   422,   423,   424,   425,   426,
-   427,   428,   429,   430,   431,   432,   433,   414,   415,   416,
-     0,     0,   417,   418,   419,   420,   421,   422,   423,   424,
-   425,   426,   427,   428,   429,   430,   431,   432,   433,     0,
-     0,     0,     0,     0,     0,     0,     0,   602,     0,     0,
-     0,     0,   971,     0,     0,     0,     0,     0,     0,     0,
-     0,     0,     0,     0,     0,     0,     0,   414,   415,   416,
-   759,   760,   417,   418,   419,   420,   421,   422,   423,   424,
-   425,   426,   427,   428,   429,   430,   431,   432,   433,  -142,
-   414,   415,   416,     0,     0,   417,   418,   419,   420,   421,
-   422,   423,   424,   425,   426,   427,   428,   429,   430,   431,
-   432,   433,   414,   415,   416,  1145,     0,   417,   418,   419,
-   420,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-   430,   431,   432,   433,   414,   415,   416,     0,     0,   417,
-   418,   419,   420,   421,   422,   423,   424,   425,   426,   427,
-   428,   429,   430,   431,   432,   433,   414,   415,   416,     0,
-     0,   417,   418,   419,   420,   421,   422,   423,   424,   425,
-     0,   427,   428,   429,   430,   431,   432,   433,   416,     0,
-     0,   417,   418,   419,   420,   421,   422,   423,   424,   425,
-   426,   427,   428,   429,   430,   431,   432,   433,   418,   419,
-   420,   421,   422,   423,   424,   425,   426,   427,   428,   429,
-   430,   431,   432,   433,   419,   420,   421,   422,   423,   424,
-   425,   426,   427,   428,   429,   430,   431,   432,   433
-};
-
-static const short yycheck[] = {    10,
-    16,    68,   270,     1,     2,   107,   300,   139,   140,    16,
-    40,   597,   112,    45,    41,   356,   278,   151,    16,     1,
-     2,   140,   243,   888,    62,   125,   310,   983,     1,     2,
-   278,    41,   196,    31,    45,   329,  1032,  1033,   216,   209,
-   210,   896,    40,   898,   138,   708,   947,   516,   218,    51,
-   191,   221,    19,     1,     2,   225,    10,    10,    31,   229,
-   888,     1,     2,    61,    62,   235,   334,   895,   147,    46,
-    68,   568,   218,    10,    10,   221,    10,    36,    46,   225,
-   549,   108,    44,   229,     0,    24,     3,     4,    65,   235,
-    37,    31,    44,    24,    39,    40,    46,    65,    83,    46,
-  1114,    55,    68,   105,   106,     3,     4,     5,    35,    50,
-    61,   109,     5,   265,    55,    65,    55,   269,     3,    50,
-    71,    83,    53,   121,    55,     3,     4,   464,   105,   127,
-   467,    83,    84,   131,  1148,  1149,   104,   239,   165,    51,
-   242,   305,    51,   304,   171,   127,    65,   106,    46,    51,
-   104,   104,   104,    46,   127,   165,    83,   224,   196,    36,
-   134,   171,  1027,  1064,   105,   203,  1031,   104,   104,   333,
-   104,     1,     2,   314,   105,   307,   308,   309,    95,   153,
-  1194,     3,     4,     5,   847,   130,   131,   127,   307,   308,
-   324,   158,    22,   167,   106,   193,   105,    95,   196,  1027,
-    98,    31,   699,  1031,   106,   203,   217,  1203,  1204,    39,
-    40,   505,   306,   240,    55,    65,   198,    95,   216,   467,
-   193,   399,    44,   387,   492,    51,   224,   397,    51,   106,
-   204,    50,   453,    44,   703,  1191,    55,  1251,  1252,    51,
-   319,   320,   253,    50,   242,    51,   273,     8,    55,   276,
-   248,   397,   200,   193,     3,     4,   105,   106,   224,    83,
-    66,    83,    51,   273,   105,   559,    51,  1095,     3,     4,
-   302,   269,    83,    95,     3,     4,   408,   441,   104,   547,
-   278,   104,   751,     3,     4,   115,   116,   117,    51,   287,
-   876,   302,   878,   105,   458,   333,   765,   127,   105,  1154,
-   130,   131,     3,     4,     5,   287,    41,   106,    51,   470,
-   337,   378,    41,    11,   287,   347,   105,   147,   292,   104,
-   302,   151,   389,     3,     4,    86,   393,   337,  1193,  1157,
-   482,   483,    93,    51,    50,   333,    51,   364,    55,   287,
-     3,     4,   105,     6,   174,    46,    95,   287,    65,   846,
-    50,    71,   300,    51,   364,   519,   354,    55,   356,    50,
-    95,    44,   105,   193,    51,  1193,    95,    51,   198,   343,
-    50,   201,   107,    36,    51,    95,    65,   444,   107,    55,
-   378,   329,   546,   356,   358,     3,     4,   105,     6,  1217,
-   105,   389,   340,     5,    95,   393,    94,    98,    44,   531,
-    83,    84,   368,    51,    51,    44,    51,   237,   353,   354,
-   384,     1,   531,   411,    55,    95,   356,   104,    36,    66,
-   104,   104,    51,   389,   109,    51,    86,   393,   105,   395,
-   396,    44,    95,    93,    55,   697,    10,    83,    84,   269,
-   451,   605,   576,   607,    83,    84,   444,   581,     1,   697,
-   416,   920,    44,   491,   618,   924,   104,   287,   104,   104,
-    50,   540,   541,   104,   475,   104,   498,   494,    51,   467,
-    83,    84,   302,    86,   768,   104,   442,    95,   104,   445,
-    93,    51,   776,   104,   494,   655,   650,   498,   652,   319,
-   320,    83,   105,   491,   324,   659,    51,    50,    51,   663,
-   330,   601,     3,     4,     3,   335,    42,     8,   546,   655,
-     9,    66,   664,   524,    50,   667,   527,     8,    51,    26,
-    27,   104,    50,   353,   354,    32,   356,    55,    51,     3,
-     4,     5,    51,    66,   104,    44,   568,    51,   576,    51,
-    41,   105,   106,   581,    51,    46,    53,    21,   546,   713,
-    16,   715,     7,     8,   718,   106,    22,   505,    13,     1,
-    61,     3,     4,     5,     6,     7,     8,   605,    46,   607,
-    71,    13,    46,    39,    83,    84,     3,  1046,   576,    44,
-    35,   104,    83,   581,    44,   104,    28,    42,    53,    44,
-   104,   932,   104,    35,    95,   104,    62,    50,   105,    41,
-    42,    99,    55,   577,    46,    51,   107,   605,   582,   607,
-    51,   559,   105,    51,   109,   597,    26,    27,    83,    61,
-    55,    95,    83,    83,    98,    83,   653,    51,    83,    71,
-    51,    51,   106,   463,   464,    44,   652,   467,    51,  1225,
-    51,    83,    38,   109,    83,   652,     3,     4,    51,   115,
-   116,   117,   822,    95,   652,   819,   735,   736,   104,   820,
-  1129,   825,  1131,   104,   130,   107,   104,   699,   679,   667,
-   749,   750,   833,   834,    83,    84,   822,   829,   830,   711,
-   104,   147,    83,   104,   104,   151,    51,   839,   840,    44,
-   854,   104,    10,   104,    44,   104,   857,   858,   672,   697,
-   711,   104,    51,    51,     3,     4,   105,   106,   174,   104,
-   540,   541,    53,   813,   816,   817,   106,   728,    44,   786,
-    44,   753,    44,   105,   106,     3,     4,    44,    83,   711,
-   104,   729,   198,    83,    84,   201,    86,   203,    44,   104,
-   104,    44,    41,    93,     3,    44,   576,    46,    47,   109,
-   216,   581,    44,    50,  1048,   104,   729,    83,    84,    83,
-    84,    83,    61,    41,    44,   109,    83,   597,    46,    47,
-    44,   237,    71,   105,   106,   936,   242,    83,    84,    78,
-    83,   779,   248,    61,    83,    84,   106,    44,   786,   729,
-   764,    83,    44,    71,    46,   104,    95,   808,   109,   773,
-    78,   105,   106,    83,  1088,    83,   779,     3,   107,    83,
-   971,   104,   278,    65,   846,  1109,    86,    95,  1102,   817,
-   768,  1105,    51,    93,   769,   799,    83,   105,   776,   107,
-    83,    83,    26,    27,   664,   105,   302,   667,   104,   779,
-    32,     3,     4,     5,     6,     7,     8,   858,   104,    44,
-   104,    13,   984,   319,   320,    50,    50,   887,   324,    46,
-    55,    55,   104,   874,   330,   876,    28,    86,    55,   335,
-    71,    72,    73,    35,    93,  1143,  1144,  1038,    65,    41,
-    42,   711,    53,   950,    46,    47,   105,   353,    83,   887,
-   888,   105,   106,    51,   876,   104,   878,   895,   896,    61,
-   898,  1062,   104,   869,   902,   735,   736,   873,    35,    71,
-    55,    56,   378,    34,   880,   888,    78,  1078,   109,   749,
-   750,    83,   895,   896,   109,   898,   105,   106,   105,   902,
-    44,   105,   106,    95,   932,   105,   106,  1101,   105,   769,
-  1104,   886,   887,   105,   105,   107,   105,    61,   888,   779,
-   105,   106,   950,   105,   928,   895,   896,    71,   898,   932,
-   209,   210,   902,   109,    78,  1126,   977,  1128,    61,    83,
-    84,   104,     6,     7,     8,   104,    51,  1141,   444,    13,
-     5,  1142,  1114,   109,  1145,    55,    55,   985,    83,    26,
-    27,    53,   932,   104,   104,   104,   104,   463,   464,   829,
-   830,    35,     6,     7,     8,   104,    55,  1107,    42,    13,
-    44,  1022,   985,    50,    53,   109,  1148,  1149,    55,   985,
-   986,   109,    83,    53,    53,   491,   106,   993,   121,  1027,
-   104,    35,   109,  1031,    55,  1009,  1138,  1139,    42,  1021,
-  1014,    95,  1069,    55,  1205,   985,   876,    55,   878,    83,
-   109,  1062,  1068,   104,  1027,    53,   886,   887,  1031,   104,
-   104,  1068,  1194,   104,    83,    55,  1032,  1033,   104,  1043,
-  1068,   104,   902,   104,   540,   541,   104,  1051,    83,   106,
-     3,     4,    83,     6,     7,     8,  1084,  1027,    55,   105,
-   105,  1031,    50,    50,     8,     7,     8,  1095,   105,    15,
-  1048,    13,   932,   196,     3,     4,    53,     6,     7,     8,
-    55,  1084,    35,     3,    51,  1081,  1248,  1249,   104,  1251,
-  1252,   104,  1095,    35,     3,     4,    49,    50,  1094,    55,
-    42,   597,    44,   105,   105,   105,    35,   105,  1270,   105,
-    83,  1139,     3,     4,  1084,   238,   105,    53,    83,   105,
-    49,    50,   106,    53,    84,  1095,  1154,    84,    16,  1157,
-   106,  1109,    41,   105,   105,  1113,   104,    46,    47,   105,
-    49,    83,    95,  1240,   105,    50,    55,   100,   101,   102,
-    41,  1154,    61,   105,  1157,    46,    69,    70,    71,    72,
-    73,  1021,    71,    55,   105,  1193,    95,   105,   664,    78,
-    61,   100,   101,   102,    83,    53,   104,   104,    51,   104,
-    71,   304,   305,   104,  1154,   104,    95,  1157,   105,  1217,
-  1193,   109,    83,   109,   105,    10,    90,   105,   107,     9,
-    83,   697,   105,    51,    95,   104,    83,  1203,  1204,  1250,
-   333,   104,  1240,  1225,  1217,   711,   107,    44,    51,   105,
-    47,     4,     5,  1193,     7,     8,    10,     9,   351,   104,
-    13,   105,   104,   104,    61,     1,    10,  1233,   105,   735,
-   736,   126,     1,     2,    71,    28,     0,  1217,     0,   289,
-   697,    78,    35,   749,   750,     2,    83,    84,    24,    42,
-    26,    27,   127,    22,   387,   127,    32,   711,   138,   498,
-   121,   752,    31,   769,   411,     8,  1064,   985,   165,   886,
-   330,    40,   276,  1134,    50,    51,   808,    53,   411,    55,
-   786,   414,   415,   681,   417,   418,   419,   420,   421,   422,
-   423,   424,   425,   426,   427,   428,   429,   430,   431,   432,
-   433,    44,    95,    31,    31,   753,   568,   440,   441,   732,
-    86,   817,   902,   779,   354,   475,   679,    93,    61,   324,
-   730,     1,     2,   829,   830,   458,  1028,  1234,    71,   105,
-     4,     5,  1084,     7,     8,    78,  1236,   470,   248,    13,
-    83,    84,    22,  1021,   477,    -1,   115,   116,   117,   786,
-    -1,    31,    44,    -1,    28,  1225,    -1,    -1,   127,    39,
-    40,    35,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,
-   876,    -1,   878,     7,     8,    49,    -1,    -1,   147,    13,
-   886,    -1,   151,    75,    76,    -1,   519,    79,    80,    81,
-    82,    83,    84,    -1,   527,     3,     4,     5,     6,     7,
-     8,    35,    -1,    -1,    -1,    13,    -1,    -1,    42,    83,
-    44,    -1,    -1,   546,    -1,    -1,    -1,    -1,    -1,    -1,
-    28,    95,    -1,    -1,   193,    -1,    -1,    35,    -1,    -1,
-    -1,    -1,   201,    41,    42,   115,   116,   117,    46,    47,
-    -1,   574,   575,    -1,   950,    -1,    -1,   127,    -1,    83,
-   130,   131,     1,    61,     3,     4,     5,     6,     7,     8,
-     7,     8,    -1,    71,    13,    -1,    13,   147,    -1,    -1,
-    78,   151,   605,    -1,   607,    83,    -1,    26,    27,    28,
-    -1,    -1,    -1,    -1,    -1,   618,    35,    95,    35,   622,
-    39,    -1,    41,    42,   174,    42,    45,    46,    -1,   107,
-    -1,     3,     4,    -1,    -1,    -1,     8,    -1,    -1,    -1,
-    -1,    -1,    61,   193,    -1,  1021,    -1,   650,   287,   652,
-    -1,   201,    71,    -1,    -1,    -1,   659,    -1,    -1,    -1,
-   663,    -1,    -1,    44,    83,    -1,   216,    -1,    -1,    41,
-    -1,    -1,    -1,    -1,    46,   678,    95,    96,    97,    -1,
-   319,   320,    -1,    20,    21,   324,   105,   237,   107,    61,
-    -1,    -1,  1068,   243,    75,    76,   335,    -1,    79,    71,
-    81,    -1,    83,    84,    -1,     1,    78,    -1,    -1,    -1,
-   713,    83,   715,    -1,    -1,   718,    -1,   356,   721,    -1,
-    -1,    -1,    59,    95,    -1,    -1,    -1,    -1,    24,    -1,
-    26,    27,    -1,    -1,    -1,   107,    32,   287,     1,    76,
-     3,     4,     5,     6,     7,     8,    -1,    -1,    44,    -1,
-    13,    -1,    -1,    -1,    50,    51,    -1,    53,   761,    55,
-     6,     7,     8,  1139,    -1,    28,    -1,    13,    -1,   319,
-   320,    -1,    35,    36,   324,    -1,    -1,    -1,    41,    42,
-   330,    -1,    -1,    46,    -1,   335,    -1,    83,    84,    35,
-    86,    -1,    55,    -1,    -1,    -1,    42,    93,    61,    -1,
-    -1,    -1,    -1,   353,   354,   808,   356,   810,    71,   105,
-    -1,   148,   149,    -1,    -1,    -1,   819,   820,    -1,    -1,
-    83,    -1,   825,    -1,   463,   464,    -1,    -1,   467,    -1,
-   833,   834,    95,    -1,    -1,    -1,     1,    -1,    -1,    -1,
-    -1,    -1,   105,   106,   107,    -1,    -1,    -1,    -1,  1225,
-    -1,   854,    -1,    -1,   857,   858,    -1,    -1,   195,    24,
-    -1,    26,    27,    -1,  1240,   202,    -1,    32,    -1,    -1,
-     0,     1,    -1,     3,     4,     5,     6,     7,     8,    44,
-    -1,    -1,    -1,    13,    -1,    50,    51,    -1,    53,    -1,
-    55,    -1,    -1,    -1,    -1,    -1,    26,    27,    28,    -1,
-    -1,   540,   541,   453,    -1,    35,    -1,    -1,    -1,    39,
-    -1,    41,    42,   463,   464,    45,    46,   467,    83,    84,
-    -1,    86,    -1,   926,   927,    -1,    -1,   264,    93,   266,
-   267,    61,    -1,   936,    -1,    -1,    -1,   576,    -1,    -1,
-   105,    71,   581,    64,    65,    66,    67,    68,    69,    70,
-    71,    72,    73,    83,    63,    64,    65,    66,    67,    68,
-    69,    70,    71,    72,    73,    95,    96,    97,   971,    -1,
-   973,    -1,    -1,    -1,    -1,   105,     1,   107,     3,     4,
-     5,     6,     7,     8,   321,   322,     3,     4,    13,    -1,
-   540,   541,    -1,    -1,    -1,   332,    -1,    -1,    -1,    -1,
-    -1,    26,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,
-    35,    -1,    -1,    -1,    39,    -1,    41,    42,    -1,    -1,
-    45,    46,    -1,    -1,    41,   664,   576,    44,   667,    46,
-    47,   581,    49,    -1,    -1,  1038,    61,    -1,    55,    -1,
-    -1,    -1,  1045,    -1,    61,    -1,    71,    67,    68,    69,
-    70,    71,    72,    73,    71,    -1,    -1,    -1,    83,  1062,
-    -1,    78,    -1,    -1,    -1,    -1,    83,    -1,    -1,    -1,
-    95,    96,    97,    -1,    -1,  1078,    -1,    -1,    95,    -1,
-   105,   106,   107,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-   107,    -1,    -1,    -1,    -1,    -1,   735,   736,  1101,    -1,
-    -1,  1104,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     1,
-   749,   750,     4,     5,   664,     7,     8,   667,    -1,    -1,
-    -1,    13,    -1,  1126,    -1,  1128,    -1,    -1,   465,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    28,    -1,  1141,  1142,
-   779,    -1,  1145,    35,    -1,    37,    38,    -1,    -1,    -1,
-    42,    43,    44,   490,    -1,     3,     4,    -1,    -1,    51,
-    52,    53,    54,    -1,    -1,    57,    58,    59,    60,    61,
-    62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-    72,    73,    -1,    75,    76,   735,   736,    79,    80,    -1,
-   829,   830,    84,    41,    -1,    -1,    -1,    -1,    46,   749,
-   750,    -1,  1205,    95,    -1,   542,   543,    -1,   545,    -1,
-    -1,    -1,    -1,    61,    -1,   107,   108,    -1,    -1,   769,
-   557,   558,    -1,    71,    -1,    -1,    -1,    -1,    -1,   779,
-    78,    -1,    -1,    -1,    -1,    83,   573,    -1,    -1,    -1,
-    -1,    -1,    24,   580,    26,    27,    -1,    95,   887,    -1,
-    32,    -1,   589,   590,   591,    -1,    -1,    -1,    -1,   107,
-    -1,    -1,    -1,   902,    46,    -1,    -1,   604,    50,   606,
-    -1,    53,   609,    -1,    -1,    -1,    -1,    -1,    -1,   829,
-   830,    -1,    -1,    65,    -1,     1,    -1,     3,     4,     5,
-     6,     7,     8,   932,    -1,    -1,    -1,    13,    -1,    -1,
-     3,     4,    84,    -1,    86,     8,    -1,    -1,    -1,    -1,
-    -1,    93,    28,    -1,    -1,    -1,    -1,    -1,    -1,    35,
-    36,    -1,    -1,    -1,   106,    41,    42,    -1,   665,   666,
-    46,    -1,    -1,    -1,    -1,    -1,   886,   887,    41,    55,
-    -1,    44,    -1,    46,    -1,    61,    -1,    -1,    -1,   686,
-   687,    -1,   902,   690,    -1,    71,    -1,    -1,    61,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    83,    71,    -1,
-    -1,    -1,    -1,    -1,    -1,    78,    -1,    -1,    -1,    95,
-    83,    84,   932,    -1,    -1,    -1,    -1,    -1,    -1,   105,
-   106,   107,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,   107,    -1,    -1,    -1,   745,   746,
-   747,    -1,     1,    -1,     3,     4,     5,     6,     7,     8,
-     9,    10,    -1,    12,    13,    14,    15,    16,    17,    18,
-    19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,    38,
-    -1,    40,    41,    42,     3,     4,    -1,    46,    -1,    -1,
-    49,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,
-     3,     4,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    69,    70,    71,     3,     4,    -1,    75,    76,    -1,     3,
-     4,    -1,    41,    -1,    83,    44,    85,    46,    87,    88,
-    89,    -1,    91,    92,    93,   842,    95,    -1,    41,    -1,
-    -1,    -1,    61,    46,    47,    -1,   105,   106,   107,   108,
-    -1,    41,    71,    -1,    -1,    -1,    46,    41,    61,    78,
-    -1,    -1,    46,    47,    83,    84,    -1,    -1,    71,    -1,
-    -1,    61,    -1,    -1,    -1,    78,    95,    61,    -1,    -1,
-    83,    71,    -1,    -1,    -1,    -1,    -1,    71,   107,    -1,
-    -1,    -1,    95,    83,    78,    -1,    -1,    -1,    -1,    83,
-   907,   908,   909,    -1,   107,    95,    -1,    -1,    -1,    -1,
-    -1,    95,    -1,    -1,    -1,    -1,   923,   107,    -1,    -1,
-    -1,   105,    -1,   107,   931,    -1,    -1,    -1,    -1,    -1,
-   937,   938,   939,   940,   941,   942,     1,    -1,     3,     4,
-     5,     6,     7,     8,     9,    10,    -1,    12,    13,    14,
-    -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-    25,    26,    27,    28,    29,    30,    31,    -1,    33,    -1,
-    35,    -1,    37,    38,    -1,    40,    41,    42,    -1,    -1,
-    -1,    46,    -1,    -1,    49,    50,    -1,    -1,    -1,    -1,
-    -1,     4,     5,    58,     7,     8,    61,    -1,    -1,    -1,
-    13,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,
-    75,    76,    -1,    -1,    -1,    28,    -1,    -1,    83,    -1,
-    85,    -1,    35,    88,    -1,    -1,    91,    92,    93,    42,
-    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-   105,   106,   107,   108,     1,    -1,     3,     4,     5,     6,
-     7,     8,     9,    10,    -1,    12,    13,    14,    -1,    16,
-    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-    27,    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,
-    37,    38,    95,    40,    41,    42,    -1,    -1,    -1,    46,
-    -1,    -1,    49,    50,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,
-    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,    85,    -1,
-    -1,    88,    -1,    -1,    91,    92,    93,    -1,    95,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   105,   106,
-   107,   108,     1,    -1,     3,     4,     5,     6,     7,     8,
-     9,    10,    -1,    12,    13,    14,    -1,    16,    17,    18,
-    19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,    38,
-    -1,    40,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,
-    49,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,
-    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,    -1,
-    -1,    -1,    -1,    -1,    83,    -1,    85,    -1,    -1,    88,
-    -1,    -1,    91,    92,    93,    -1,    95,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,   105,   106,   107,   108,
-     1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
-    -1,    12,    13,    14,    -1,    16,    17,    18,    19,    20,
-    21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
-    31,    -1,    33,    -1,    35,    -1,    37,    38,    -1,    40,
-    41,    42,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    -1,    -1,
-    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,    70,
-    71,    -1,    -1,    -1,    75,    76,    -1,    -1,    -1,    -1,
-    -1,    -1,    83,    -1,    85,    -1,    -1,    88,    -1,    -1,
-    91,    92,    93,    -1,    95,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,   105,   106,   107,   108,     1,    -1,
-     3,     4,     5,     6,     7,     8,     9,    10,    -1,    12,
-    13,    14,    -1,    16,    17,    18,    19,    20,    21,    22,
-    23,    24,    25,    26,    27,    28,    29,    30,    31,    -1,
-    33,    -1,    35,    -1,    37,    38,    -1,    40,    41,    42,
-    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    69,    70,    71,    -1,
-    -1,    -1,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,
-    83,    -1,    85,    -1,    -1,    88,    -1,    -1,    91,    92,
-    93,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,   105,   106,   107,   108,     1,    -1,     3,     4,
-     5,     6,     7,     8,     9,    10,    -1,    12,    13,    14,
-    -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-    25,    26,    27,    28,    29,    30,    31,    -1,    33,    -1,
-    35,    -1,    37,    38,    -1,    40,    41,    42,    -1,    -1,
-    -1,    46,    -1,    -1,    49,    50,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,
-    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,
-    85,    -1,    -1,    88,    -1,    -1,    91,    92,    93,    -1,
-    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-   105,   106,   107,   108,     1,    -1,     3,     4,     5,     6,
-     7,     8,     9,    10,    -1,    12,    13,    14,    -1,    16,
-    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-    27,    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,
-    37,    38,    -1,    40,    41,    42,    -1,    -1,    -1,    46,
-    -1,    -1,    49,    50,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,
-    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,    85,    -1,
-    -1,    88,    -1,    -1,    91,    92,    93,    -1,    95,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   105,    -1,
-   107,   108,     1,    -1,     3,     4,     5,     6,     7,     8,
-     9,    10,    -1,    12,    13,    14,    -1,    16,    17,    18,
-    19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
-    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,    38,
-    -1,    40,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,
-    49,    50,    -1,    -1,    -1,    -1,    -1,     4,     5,    58,
-     7,     8,    61,    -1,    -1,    -1,    13,    -1,    -1,    -1,
-    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,    -1,
-    -1,    28,    -1,    -1,    83,    -1,    85,    -1,    35,    88,
-    -1,    -1,    91,    92,    93,    42,    95,    -1,    -1,    -1,
-    -1,    -1,    49,    -1,    -1,    -1,   105,    -1,   107,   108,
-     1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
-    11,    12,    13,    61,    62,    63,    64,    65,    66,    67,
-    68,    69,    70,    71,    72,    73,    83,    28,    29,    30,
-    31,    -1,    33,    -1,    35,    -1,    37,    38,    95,    40,
-    41,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,
-    -1,    -1,     4,     5,     6,     7,     8,    58,    -1,    -1,
-    61,    13,    -1,    -1,    -1,    -1,     3,     4,    69,    70,
-    71,    -1,    -1,    -1,    75,    76,    28,    -1,    -1,    -1,
-    -1,    -1,    83,    35,    -1,    -1,    -1,    -1,    -1,    -1,
-    42,    -1,    -1,    94,    95,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,   104,    41,    -1,   107,   108,     1,    46,
-     3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-    13,    -1,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    71,    28,    29,    30,    31,    -1,
-    33,    78,    35,    95,    37,    38,    83,    40,    41,    42,
-    -1,    -1,    -1,    46,    -1,    -1,    -1,    -1,    95,    -1,
-     4,     5,     6,     7,     8,    58,    -1,    -1,    61,    13,
-   107,    -1,    -1,    -1,     3,     4,    69,    70,    71,    -1,
-    -1,    -1,    75,    76,    28,    -1,    -1,    -1,    -1,    -1,
-    83,    35,    -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,
-    -1,    94,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,   104,    41,    -1,   107,   108,     1,    46,     3,     4,
-     5,     6,     7,     8,     9,    10,    11,    12,    13,    -1,
-    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    71,    28,    29,    30,    31,    -1,    33,    78,
-    35,    95,    37,    38,    83,    40,    41,    42,    -1,    -1,
-    -1,    46,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,
-    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,   107,    -1,
-    -1,    -1,     3,     4,    69,    70,    71,    -1,    -1,    -1,
-    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,
-    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   104,
-    41,    -1,   107,   108,     1,    46,     3,     4,     5,     6,
-     7,     8,     9,    10,    11,    12,    13,    -1,    -1,    -1,
-    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    71,    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,
-    37,    38,    83,    40,    41,    42,    -1,    -1,    -1,    46,
-    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,
-    -1,    58,    -1,    -1,    61,    -1,   107,    -1,    -1,    -1,
-    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,
-    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    94,    95,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,   104,    -1,    -1,
-   107,   108,     1,    -1,     3,     4,     5,     6,     7,     8,
-     9,    10,    11,    12,    13,    60,    61,    62,    63,    64,
-    65,    66,    67,    68,    69,    70,    71,    72,    73,    28,
-    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,    38,
-    -1,    40,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,
-    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,    -1,
-    -1,    -1,    -1,    -1,    83,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    94,    95,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,   104,    -1,    -1,   107,   108,
-     1,    -1,     3,     4,     5,    -1,     7,     8,     9,    10,
-    -1,    12,    13,    62,    63,    64,    65,    66,    67,    68,
-    69,    70,    71,    72,    73,    -1,    -1,    28,    29,    30,
-    31,    -1,    33,    -1,    35,    -1,    37,    38,    -1,    40,
-    41,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,    50,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    -1,    -1,
-    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,    70,
-    71,    -1,    -1,    -1,    75,    76,    -1,    -1,    -1,    -1,
-    -1,    -1,    83,    84,     1,    -1,     3,     4,     5,    -1,
-     7,     8,     9,    10,    95,    12,    13,    -1,    -1,    -1,
-    -1,    -1,    -1,    20,    -1,   106,   107,   108,    -1,    -1,
-    -1,    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,
-    37,    38,    -1,    40,    41,    42,    -1,    -1,    -1,    46,
-    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,
-    -1,    -1,    -1,    -1,    -1,     1,    83,     3,     4,     5,
-     6,     7,     8,     9,    10,    -1,    12,    13,    95,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   106,
-   107,   108,    28,    29,    30,    31,    -1,    33,    -1,    35,
-    -1,    37,    38,    -1,    40,    41,    42,    -1,    -1,    -1,
-    46,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,
-    76,    -1,    -1,    -1,    -1,    -1,     1,    83,     3,     4,
-     5,    -1,     7,     8,     9,    10,    -1,    12,    13,    95,
-    -1,    -1,    -1,    -1,    -1,    20,    -1,    -1,    -1,   105,
-    -1,   107,   108,    28,    29,    30,    31,    -1,    33,    -1,
-    35,    -1,    37,    38,    -1,    40,    41,    42,    -1,    -1,
-    -1,    46,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,
-    75,    76,    -1,    -1,    -1,    -1,    -1,     1,    83,     3,
-     4,     5,    -1,     7,     8,     9,    10,    -1,    12,    13,
-    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,   106,   107,   108,    28,    29,    30,    31,    -1,    33,
-    -1,    35,    -1,    37,    38,    -1,    40,    41,    42,    -1,
-    -1,    -1,    46,    -1,    -1,    -1,    50,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,
-    -1,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,
-    84,     1,    -1,     3,     4,     5,    -1,     7,     8,     9,
-    10,    95,    12,    13,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,   107,   108,    -1,    -1,    -1,    28,    29,
-    30,    31,    -1,    33,    -1,    35,    -1,    37,    38,    -1,
-    40,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,
-    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    -1,
-    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,
-    70,    71,    -1,    -1,    -1,    75,    76,    -1,    -1,    -1,
-    -1,    -1,     1,    83,     3,     4,     5,    -1,     7,     8,
-     9,    10,    -1,    12,    13,    95,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,   107,   108,    28,
-    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,    38,
-    -1,    40,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,
-    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,
-    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,    -1,
-    -1,    -1,    -1,     1,    83,     3,     4,     5,    -1,     7,
-     8,     9,    10,    -1,    12,    13,    95,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   107,   108,
-    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,
-    38,    -1,    40,    41,    42,    -1,    -1,    -1,    46,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,    -1,    -1,
-    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,
-    -1,    -1,    -1,    -1,     1,    83,     3,     4,     5,    -1,
-     7,     8,     9,    10,    -1,    12,    13,    95,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   107,
-   108,    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,
-    37,    38,    -1,    40,    41,    42,    -1,    -1,    -1,    46,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,
-    -1,    -1,    -1,    -1,    -1,     1,    83,     3,     4,     5,
-    -1,     7,     8,     9,    10,    -1,    12,    13,    95,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   105,    -1,
-   107,   108,    28,    29,    30,    31,    -1,    33,    -1,    35,
-    -1,    37,    38,    -1,    40,    41,    42,    -1,    -1,    -1,
-    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,
-    76,    -1,    -1,    -1,    -1,    -1,     1,    83,     3,     4,
-     5,    -1,     7,     8,     9,    10,    -1,    12,    13,    95,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   104,    -1,
-    -1,   107,   108,    28,    29,    30,    31,    -1,    33,    -1,
-    35,    -1,    37,    38,    -1,    40,    41,    42,    -1,    -1,
-    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,
-    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,     3,
-     4,     5,    -1,     7,     8,     9,    10,    -1,    12,    13,
-    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,   107,   108,    28,    29,    30,    31,    -1,    33,
-    -1,    35,    -1,    37,    -1,    -1,    40,    41,    42,    -1,
-    -1,     1,    46,     3,     4,     5,     6,     7,     8,    -1,
-    -1,    -1,    -1,    13,    58,    -1,    -1,    61,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    69,    70,    71,    28,    -1,
-    -1,    75,    76,    -1,    -1,    35,    36,    -1,    -1,    83,
-    -1,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,    -1,
-    -1,    95,    -1,    -1,    -1,    55,    -1,    -1,    -1,    -1,
-    -1,    61,    -1,   107,   108,   109,    -1,    -1,    -1,    -1,
-     1,    71,     3,     4,     5,     6,     7,     8,    -1,    -1,
-    -1,    -1,    13,    83,    -1,    -1,     1,    -1,     3,     4,
-     5,     6,     7,     8,    -1,    95,    -1,    28,    13,    -1,
-    -1,    -1,    -1,    -1,    35,    36,   106,   107,    -1,    -1,
-    41,    42,    -1,    28,    -1,    46,    -1,    -1,    -1,    -1,
-    35,    -1,    -1,    -1,    55,    -1,    41,    42,    -1,    -1,
-    61,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    71,    -1,    -1,    -1,    -1,    -1,    61,    -1,    -1,    -1,
-    -1,    -1,    83,    -1,    -1,    -1,    71,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    83,    -1,
-    -1,    -1,    -1,    -1,    -1,   106,   107,    -1,    -1,    -1,
-    95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-   105,    -1,   107,     3,     4,     5,     6,     7,     8,     9,
-    10,    -1,    12,    13,    14,    -1,    16,    17,    18,    19,
-    20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
-    30,    31,    -1,    33,    -1,    35,    -1,    37,    -1,    -1,
-    40,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,    49,
-    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    -1,
-    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,
-    70,    71,    -1,    -1,    -1,    75,    76,    -1,    -1,    -1,
-    -1,    -1,    -1,    83,    -1,    85,    -1,    -1,    88,    -1,
-    -1,    91,    92,    93,    -1,    95,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,   105,   106,   107,   108,     3,
-     4,     5,     6,     7,     8,     9,    10,    -1,    12,    13,
-    14,    -1,    16,    17,    18,    19,    20,    21,    22,    23,
-    24,    25,    26,    27,    28,    29,    30,    31,    -1,    33,
-    -1,    35,    -1,    37,    -1,    -1,    40,    41,    42,    -1,
-    -1,    -1,    46,    -1,    -1,    49,    50,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,
-    -1,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,
-    -1,    85,    -1,    -1,    88,    -1,    -1,    91,    92,    93,
-    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,   105,    -1,   107,   108,     3,     4,     5,     6,     7,
-     8,     9,    10,    -1,    12,    13,    14,    -1,    16,    17,
-    18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
-    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,
-    -1,    -1,    40,    41,    42,    -1,    -1,    -1,    46,    -1,
-    -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,
-    -1,    -1,    -1,    -1,    -1,    83,    -1,    85,    -1,    -1,
-    88,    -1,    -1,    91,    92,    93,    -1,    95,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,   105,    -1,   107,
-   108,     3,     4,     5,    -1,     7,     8,     9,    10,    -1,
-    12,    13,     4,     5,     6,     7,     8,    -1,    -1,    11,
-    -1,    13,    -1,    -1,    -1,    -1,    28,    29,    30,    31,
-    -1,    33,    -1,    35,    -1,    37,    28,    -1,    40,    41,
-    42,    -1,    -1,    35,    46,     3,     4,     5,    -1,     7,
-    42,    -1,    -1,    -1,    -1,    13,    58,    -1,    -1,    61,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,    70,    71,
-    28,    -1,    -1,    75,    76,    -1,    -1,    35,    -1,    37,
-    -1,    83,    84,    41,    42,     3,     4,     5,    46,     7,
-     8,     9,    10,    95,    12,    13,    -1,    -1,    -1,    -1,
-    -1,    -1,    94,    95,    -1,   107,   108,    -1,    -1,    -1,
-    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,    37,
-    -1,    -1,    40,    41,    42,    -1,    -1,    -1,    46,    -1,
-    -1,    -1,    50,    -1,    -1,    -1,    -1,    95,    -1,    -1,
-    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,
-    -1,    -1,    -1,    -1,    -1,    83,     3,     4,     5,    -1,
-     7,     8,     9,    10,    -1,    12,    13,    95,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   107,
-   108,    28,    29,    30,    31,    -1,    33,    -1,    35,    -1,
-    37,    -1,    -1,    40,    41,    42,    -1,    -1,    -1,    46,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,    76,
-    -1,    -1,    -1,    -1,    -1,    -1,    83,     3,     4,     5,
-    -1,     7,     8,     9,    10,    -1,    12,    13,    95,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   105,    -1,
-   107,   108,    28,    29,    30,    31,    -1,    33,    -1,    35,
-    -1,    37,    -1,    -1,    40,    41,    42,    -1,    -1,    -1,
-    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,    75,
-    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,     3,     4,
-     5,    -1,     7,     8,     9,    10,    -1,    12,    13,    95,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   105,
-    -1,   107,   108,    28,    29,    30,    31,    -1,    33,    -1,
-    35,    -1,    37,    -1,    -1,    40,    41,    42,    -1,    -1,
-    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,    -1,
-    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,     3,
-     4,     5,    -1,     7,     8,     9,    10,    -1,    12,    13,
-    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,   107,   108,    28,    29,    30,    31,    -1,    33,
-    -1,    35,    -1,    37,    -1,    -1,    40,    41,    42,    -1,
-    -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    58,    -1,    -1,    61,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    69,    70,    71,    -1,    -1,
-    -1,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    83,
-     3,     4,     5,    -1,     7,     8,     9,    10,    -1,    12,
-    13,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,   107,   108,    28,    29,    30,    31,    -1,
-    33,    -1,    35,    -1,    37,    -1,    -1,    40,    41,    42,
-    -1,    -1,    -1,    46,     3,     4,     5,    -1,     7,     8,
-     9,    10,    -1,    12,    13,    58,    -1,    -1,    61,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    69,    70,    71,    28,
-    29,    -1,    75,    76,    33,    -1,    35,    -1,    37,    -1,
-    83,    40,    41,    42,    -1,    -1,    -1,    46,    -1,    -1,
-    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    58,
-    -1,    -1,    61,    -1,   107,   108,    -1,    -1,    -1,    -1,
-    69,    70,    71,    -1,    -1,    -1,    75,    76,    -1,    -1,
-    -1,     3,     4,     5,    83,     7,     8,     9,    10,    -1,
-    12,    13,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    28,    29,   107,   108,
-    -1,    33,    -1,    35,    -1,    37,    -1,    -1,    40,    41,
-    42,    -1,    -1,    -1,    46,     3,     4,     5,     6,     7,
-     8,    -1,    -1,    -1,    -1,    13,    58,    -1,    -1,    61,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    69,    70,    71,
-    28,    -1,    -1,    75,    76,    -1,    -1,    35,    -1,    -1,
-    -1,    83,    -1,    41,    42,    -1,    44,    -1,    46,    47,
-    -1,    49,    -1,    95,    -1,    -1,    -1,    55,    -1,    -1,
-    -1,    -1,    -1,    61,    -1,   107,   108,     3,     4,     5,
-     6,     7,     8,    71,    -1,    11,    -1,    13,    -1,    -1,
-    78,    -1,    -1,    -1,    -1,    83,    -1,    -1,    -1,    -1,
-    -1,    -1,    28,    -1,    -1,    -1,    -1,    95,    -1,    35,
-    -1,    -1,    -1,    -1,    -1,    41,    42,    -1,    44,   107,
-    46,    47,     3,     4,     5,     6,     7,     8,    -1,    -1,
-    11,    -1,    13,    -1,    -1,    61,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    71,    -1,    28,    -1,    -1,
-    -1,    -1,    78,    -1,    35,    -1,    -1,    83,    84,    -1,
-    41,    42,    -1,    44,    -1,    46,    -1,    -1,    -1,    95,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    61,   107,    -1,    -1,     3,     4,     5,     6,     7,     8,
-    71,    -1,    11,    -1,    13,    -1,    -1,    78,    -1,    -1,
-    -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    28,
-    -1,    -1,    -1,    94,    95,    -1,    35,    -1,    -1,    -1,
-    -1,    -1,    41,    42,    -1,    -1,   107,    46,     3,     4,
-     5,     6,     7,     8,    -1,    -1,    -1,    -1,    13,    -1,
-    -1,    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    71,    28,     4,     5,     6,     7,     8,    78,
-    35,    11,    -1,    13,    83,    -1,    41,    42,    -1,    -1,
-    -1,    46,    47,    -1,    -1,    94,    95,    -1,    28,    -1,
-    -1,    -1,    -1,    -1,    -1,    35,    61,    -1,   107,    -1,
-    -1,    -1,    42,    -1,    44,    -1,    71,    -1,     4,     5,
-    -1,     7,     8,    78,    -1,    -1,    -1,    13,    83,    -1,
-    -1,    61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    95,    71,    28,    -1,    -1,    -1,    -1,    -1,    78,    35,
-   105,    -1,   107,    83,    84,    -1,    42,    -1,    44,    -1,
-    -1,    47,    -1,    -1,    94,    95,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    61,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    71,    -1,    -1,    -1,    -1,
-    -1,    -1,    78,    -1,    -1,    -1,    -1,    83,    84,    -1,
-    -1,    -1,    -1,    -1,    -1,    52,    53,    54,    -1,    95,
-    57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
-    67,    68,    69,    70,    71,    72,    73,    52,    53,    54,
-    -1,    -1,    57,    58,    59,    60,    61,    62,    63,    64,
-    65,    66,    67,    68,    69,    70,    71,    72,    73,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    -1,    -1,
-    -1,    -1,   109,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
-   105,   106,    57,    58,    59,    60,    61,    62,    63,    64,
-    65,    66,    67,    68,    69,    70,    71,    72,    73,    51,
-    52,    53,    54,    -1,    -1,    57,    58,    59,    60,    61,
-    62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
-    72,    73,    52,    53,    54,    55,    -1,    57,    58,    59,
-    60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
-    70,    71,    72,    73,    52,    53,    54,    -1,    -1,    57,
-    58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
-    68,    69,    70,    71,    72,    73,    52,    53,    54,    -1,
-    -1,    57,    58,    59,    60,    61,    62,    63,    64,    65,
-    -1,    67,    68,    69,    70,    71,    72,    73,    54,    -1,
-    -1,    57,    58,    59,    60,    61,    62,    63,    64,    65,
-    66,    67,    68,    69,    70,    71,    72,    73,    58,    59,
-    60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
-    70,    71,    72,    73,    59,    60,    61,    62,    63,    64,
-    65,    66,    67,    68,    69,    70,    71,    72,    73
-};
-/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
-#line 3 "bison.simple"
-
-/* Skeleton output parser for bison,
-   Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
-
-   This program 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 1, or (at your option)
-   any later version.
-
-   This program 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 this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-#ifndef alloca
-#ifdef __GNUC__
-#define alloca __builtin_alloca
-#else /* not GNU C.  */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
-#include <alloca.h>
-#else /* not sparc */
-#if defined (MSDOS) && !defined (__TURBOC__)
-#include <malloc.h>
-#else /* not MSDOS, or __TURBOC__ */
-#if defined(_AIX)
-#include <malloc.h>
- #pragma alloca
-#endif /* not _AIX */
-#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc.  */
-#endif /* not GNU C.  */
-#endif /* alloca not defined.  */
-
-/* This is the parser code that is written into each bison parser
-  when the %semantic_parser declaration is not specified in the grammar.
-  It was written by Richard Stallman by simplifying the hairy parser
-  used when %semantic_parser is specified.  */
-
-/* Note: there must be only one dollar sign in this file.
-   It is replaced by the list of actions, each action
-   as one case of the switch.  */
-
-#define yyerrok		(yyerrstatus = 0)
-#define yyclearin	(yychar = YYEMPTY)
-#define YYEMPTY		-2
-#define YYEOF		0
-#define YYACCEPT	return(0)
-#define YYABORT 	return(1)
-#define YYERROR		goto yyerrlab1
-/* Like YYERROR except do call yyerror.
-   This remains here temporarily to ease the
-   transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  */
-#define YYFAIL		goto yyerrlab
-#define YYRECOVERING()  (!!yyerrstatus)
-#define YYBACKUP(token, value) \
-do								\
-  if (yychar == YYEMPTY && yylen == 1)				\
-    { yychar = (token), yylval = (value);			\
-      yychar1 = YYTRANSLATE (yychar);				\
-      YYPOPSTACK;						\
-      goto yybackup;						\
-    }								\
-  else								\
-    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
-while (0)
-
-#define YYTERROR	1
-#define YYERRCODE	256
-
-#ifndef YYPURE
-#define YYLEX		yylex()
-#endif
-
-#ifdef YYPURE
-#ifdef YYLSP_NEEDED
-#define YYLEX		yylex(&yylval, &yylloc)
-#else
-#define YYLEX		yylex(&yylval)
-#endif
-#endif
-
-/* If nonreentrant, generate the variables here */
-
-#ifndef YYPURE
-
-int	yychar;			/*  the lookahead symbol		*/
-YYSTYPE	yylval;			/*  the semantic value of the		*/
-				/*  lookahead symbol			*/
-
-#ifdef YYLSP_NEEDED
-YYLTYPE yylloc;			/*  location data for the lookahead	*/
-				/*  symbol				*/
-#endif
-
-int yynerrs;			/*  number of parse errors so far       */
-#endif  /* not YYPURE */
-
-#if YYDEBUG != 0
-int yydebug;			/*  nonzero means print parse trace	*/
-/* Since this is uninitialized, it does not stop multiple parsers
-   from coexisting.  */
-#endif
-
-/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
-
-#ifndef	YYINITDEPTH
-#define YYINITDEPTH 200
-#endif
-
-/*  YYMAXDEPTH is the maximum size the stacks can grow to
-    (effective only if the built-in stack extension method is used).  */
-
-#if YYMAXDEPTH == 0
-#undef YYMAXDEPTH
-#endif
-
-#ifndef YYMAXDEPTH
-#define YYMAXDEPTH 10000
-#endif
-
-#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
-#define __yy_bcopy(FROM,TO,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
-#else				/* not GNU C or C++ */
-#ifndef __cplusplus
-
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
-static void
-__yy_bcopy (from, to, count)
-     char *from;
-     char *to;
-     int count;
-{
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
-}
-
-#else /* __cplusplus */
-
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
-static void
-__yy_bcopy (char *from, char *to, int count)
-{
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
-}
-
-#endif
-#endif
-
-#line 169 "bison.simple"
-int
-yyparse()
-{
-  register int yystate;
-  register int yyn;
-  register short *yyssp;
-  register YYSTYPE *yyvsp;
-  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
-  int yychar1;		/*  lookahead token as an internal (translated) token number */
-
-  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
-  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
-
-  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
-  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
-
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;
-
-#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
-#else
-#define YYPOPSTACK   (yyvsp--, yyssp--)
-#endif
-
-  int yystacksize = YYINITDEPTH;
-
-#ifdef YYPURE
-  int yychar;
-  YYSTYPE yylval;
-  int yynerrs;
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylloc;
-#endif
-#endif
-
-  YYSTYPE yyval;		/*  the variable used to return		*/
-				/*  semantic values from the action	*/
-				/*  routines				*/
-
-  int yylen;
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Starting parse\n");
-#endif
-
-  yystate = 0;
-  yyerrstatus = 0;
-  yynerrs = 0;
-  yychar = YYEMPTY;		/* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.  */
-
-  yyssp = yyss - 1;
-  yyvsp = yyvs;
-#ifdef YYLSP_NEEDED
-  yylsp = yyls;
-#endif
-
-/* Push a new state, which is found in  yystate  .  */
-/* In all cases, when you get here, the value and location stacks
-   have just been pushed. so pushing a state here evens the stacks.  */
-yynewstate:
-
-  *++yyssp = yystate;
-
-  if (yyssp >= yyss + yystacksize - 1)
-    {
-      /* Give user a chance to reallocate the stack */
-      /* Use copies of these so that the &'s don't force the real ones into memory. */
-      YYSTYPE *yyvs1 = yyvs;
-      short *yyss1 = yyss;
-#ifdef YYLSP_NEEDED
-      YYLTYPE *yyls1 = yyls;
-#endif
-
-      /* Get the current used size of the three stacks, in elements.  */
-      int size = yyssp - yyss + 1;
-
-#ifdef yyoverflow
-      /* Each stack pointer address is followed by the size of
-	 the data in use in that stack, in bytes.  */
-      yyoverflow("parser stack overflow",
-		 &yyss1, size * sizeof (*yyssp),
-		 &yyvs1, size * sizeof (*yyvsp),
-#ifdef YYLSP_NEEDED
-		 &yyls1, size * sizeof (*yylsp),
-#endif
-		 &yystacksize);
-
-      yyss = yyss1; yyvs = yyvs1;
-#ifdef YYLSP_NEEDED
-      yyls = yyls1;
-#endif
-#else /* no yyoverflow */
-      /* Extend the stack our own way.  */
-      if (yystacksize >= YYMAXDEPTH)
-	{
-	  yyerror("parser stack overflow");
-	  return 2;
-	}
-      yystacksize *= 2;
-      if (yystacksize > YYMAXDEPTH)
-	yystacksize = YYMAXDEPTH;
-      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
-      __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
-      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
-      __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
-#ifdef YYLSP_NEEDED
-      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
-      __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
-#endif
-#endif /* no yyoverflow */
-
-      yyssp = yyss + size - 1;
-      yyvsp = yyvs + size - 1;
-#ifdef YYLSP_NEEDED
-      yylsp = yyls + size - 1;
-#endif
-
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
-#endif
-
-      if (yyssp >= yyss + yystacksize - 1)
-	YYABORT;
-    }
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Entering state %d\n", yystate);
-#endif
-
- yybackup:
-
-/* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
-/* yyresume: */
-
-  /* First try to decide what to do without reference to lookahead token.  */
-
-  yyn = yypact[yystate];
-  if (yyn == YYFLAG)
-    goto yydefault;
-
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
-
-  if (yychar == YYEMPTY)
-    {
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Reading a token: ");
-#endif
-      yychar = YYLEX;
-    }
-
-  /* Convert token to internal form (in yychar1) for indexing tables with */
-
-  if (yychar <= 0)		/* This means end of input. */
-    {
-      yychar1 = 0;
-      yychar = YYEOF;		/* Don't call YYLEX any more */
-
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Now at end of input.\n");
-#endif
-    }
-  else
-    {
-      yychar1 = YYTRANSLATE(yychar);
-
-#if YYDEBUG != 0
-      if (yydebug)
-	{
-	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-	  /* Give the individual parser a way to print the precise meaning
-	     of a token, for further debugging info.  */
-#ifdef YYPRINT
-	  YYPRINT (stderr, yychar, yylval);
-#endif
-	  fprintf (stderr, ")\n");
-	}
-#endif
-    }
-
-  yyn += yychar1;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
-    goto yydefault;
-
-  yyn = yytable[yyn];
-
-  /* yyn is what to do for this token type in this state.
-     Negative => reduce, -yyn is rule number.
-     Positive => shift, yyn is new state.
-       New state is final state => don't bother to shift,
-       just return success.
-     0, or most negative number => error.  */
-
-  if (yyn < 0)
-    {
-      if (yyn == YYFLAG)
-	goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-  else if (yyn == 0)
-    goto yyerrlab;
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  /* Shift the lookahead token.  */
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
-
-  /* Discard the token being shifted unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
-
-  *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
-
-  /* count tokens shifted since error; after three, turn off error status.  */
-  if (yyerrstatus) yyerrstatus--;
-
-  yystate = yyn;
-  goto yynewstate;
-
-/* Do the default action for the current state.  */
-yydefault:
-
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-
-/* Do a reduction.  yyn is the number of a rule to reduce with.  */
-yyreduce:
-  yylen = yyr2[yyn];
-  yyval = yyvsp[1-yylen]; /* implement default value of the action */
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      int i;
-
-      fprintf (stderr, "Reducing via rule %d (line %d), ",
-	       yyn, yyrline[yyn]);
-
-      /* Print the symboles being reduced, and their result.  */
-      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
-	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
-      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
-
-
-  switch (yyn) {
-
-case 2:
-#line 285 "cp-parse.y"
-{ finish_file (); ;
-    break;}
-case 3:
-#line 293 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 4:
-#line 294 "cp-parse.y"
-{yyval.ttype = NULL_TREE; ;
-    break;}
-case 5:
-#line 296 "cp-parse.y"
-{yyval.ttype = NULL_TREE; ;
-    break;}
-case 6:
-#line 300 "cp-parse.y"
-{ have_extern_spec = 1;
-		  used_extern_spec = 0;
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 7:
-#line 305 "cp-parse.y"
-{ have_extern_spec = 0; ;
-    break;}
-case 8:
-#line 309 "cp-parse.y"
-{ if (pedantic)
-		      pedwarn ("ANSI C++ forbids use of `asm' keyword"); ;
-    break;}
-case 10:
-#line 316 "cp-parse.y"
-{ if (pending_inlines) do_pending_inlines (); ;
-    break;}
-case 11:
-#line 318 "cp-parse.y"
-{ if (pending_inlines) do_pending_inlines (); ;
-    break;}
-case 12:
-#line 320 "cp-parse.y"
-{ if (pending_inlines) do_pending_inlines (); ;
-    break;}
-case 14:
-#line 323 "cp-parse.y"
-{ if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype);
-		  assemble_asm (yyvsp[-2].ttype); ;
-    break;}
-case 15:
-#line 326 "cp-parse.y"
-{ pop_lang_context (); ;
-    break;}
-case 16:
-#line 328 "cp-parse.y"
-{ pop_lang_context (); ;
-    break;}
-case 17:
-#line 330 "cp-parse.y"
-{ if (pending_inlines) do_pending_inlines ();
-		  pop_lang_context (); ;
-    break;}
-case 18:
-#line 333 "cp-parse.y"
-{ if (pending_inlines) do_pending_inlines ();
-		  pop_lang_context (); ;
-    break;}
-case 19:
-#line 339 "cp-parse.y"
-{ push_lang_context (yyvsp[0].ttype); ;
-    break;}
-case 20:
-#line 344 "cp-parse.y"
-{ begin_template_parm_list (); ;
-    break;}
-case 21:
-#line 346 "cp-parse.y"
-{ yyval.ttype = end_template_parm_list (yyvsp[-1].ttype); ;
-    break;}
-case 22:
-#line 351 "cp-parse.y"
-{ yyval.ttype = process_template_parm (NULL_TREE, yyvsp[0].ttype); ;
-    break;}
-case 23:
-#line 353 "cp-parse.y"
-{ yyval.ttype = process_template_parm (yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 24:
-#line 364 "cp-parse.y"
-{
-		  if (yyvsp[-1].ttype != class_type_node)
-		    error ("template type parameter must use keyword `class'");
-		  yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE);
-		;
-    break;}
-case 25:
-#line 370 "cp-parse.y"
-{
-		  if (yyvsp[-3].ttype != class_type_node)
-		    error ("template type parameter must use keyword `class'");
-		  warning ("restricted template type parameters not yet implemented");
-		  yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype);
-		;
-    break;}
-case 26:
-#line 377 "cp-parse.y"
-{
-		  if (yyvsp[-2].ttype != class_type_node)
-		    error ("template type parameter must use keyword `class'");
-		  warning ("restricted template type parameters not yet implemented");
-		  yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype);
-		;
-    break;}
-case 28:
-#line 388 "cp-parse.y"
-{ warning ("use of `overload' is an anachronism"); ;
-    break;}
-case 29:
-#line 392 "cp-parse.y"
-{ declare_overloaded (yyvsp[0].ttype); ;
-    break;}
-case 30:
-#line 394 "cp-parse.y"
-{ declare_overloaded (yyvsp[0].ttype); ;
-    break;}
-case 31:
-#line 401 "cp-parse.y"
-{ yychar = '{'; goto template1; ;
-    break;}
-case 33:
-#line 404 "cp-parse.y"
-{ yychar = '{'; goto template1; ;
-    break;}
-case 35:
-#line 407 "cp-parse.y"
-{ yychar = ':'; goto template1; ;
-    break;}
-case 37:
-#line 410 "cp-parse.y"
-{
-		  yychar = ':';
-		template1:
-		  if (current_aggr == exception_type_node)
-		    error ("template type must define an aggregate or union");
-		  /* Maybe pedantic warning for union?
-		     How about an enum? :-)  */
-		  end_template_decl (yyvsp[-2].ttype, yyvsp[-1].ttype, current_aggr);
-		  reinit_parse_for_template (yychar, yyvsp[-2].ttype, yyvsp[-1].ttype);
-		  yychar = YYEMPTY;
-		;
-    break;}
-case 39:
-#line 423 "cp-parse.y"
-{
-		  end_template_decl (yyvsp[-2].ttype, yyvsp[-1].ttype, current_aggr);
-		  /* declare $2 as template name with $1 parm list */
-		;
-    break;}
-case 40:
-#line 428 "cp-parse.y"
-{
-		  end_template_decl (yyvsp[-2].ttype, yyvsp[-1].ttype, current_aggr);
-		  /* declare $2 as template name with $1 parm list */
-		;
-    break;}
-case 41:
-#line 435 "cp-parse.y"
-{
-		  tree d;
-		  int momentary;
-		  momentary = suspend_momentary ();
-		  d = start_decl (yyvsp[-4].ttype, /*current_declspecs*/NULL_TREE, 0, yyvsp[-3].ttype);
-		  cplus_decl_attributes (d, yyvsp[-1].ttype);
-		  finish_decl (d, NULL_TREE, yyvsp[-2].ttype, 0);
-		  end_template_decl (yyvsp[-5].ttype, d, 0);
-		  if (yyvsp[0].itype != ';')
-		    reinit_parse_for_template ((int) yyvsp[0].itype, yyvsp[-5].ttype, d);
-		  resume_momentary (momentary);
-		;
-    break;}
-case 42:
-#line 450 "cp-parse.y"
-{
-		  tree d;
-		  int momentary;
-
-		  current_declspecs = yyvsp[-5].ttype;
-		  momentary = suspend_momentary ();
-		  d = start_decl (yyvsp[-4].ttype, current_declspecs,
-				  0, yyvsp[-3].ttype);
-		  cplus_decl_attributes (d, yyvsp[-1].ttype);
-		  finish_decl (d, NULL_TREE, yyvsp[-2].ttype, 0);
-		  end_exception_decls ();
-		  end_template_decl (yyvsp[-6].ttype, d, 0);
-		  if (yyvsp[0].itype != ';')
-		    {
-		      reinit_parse_for_template ((int) yyvsp[0].itype, yyvsp[-6].ttype, d);
-		      yychar = YYEMPTY;
-		    }
-		  note_list_got_semicolon (yyvsp[-5].ttype);
-		  resume_momentary (momentary);
-		;
-    break;}
-case 43:
-#line 471 "cp-parse.y"
-{
-		  tree d = start_decl (yyvsp[-1].ttype, yyvsp[-2].ttype, 0, NULL_TREE);
-		  finish_decl (d, NULL_TREE, NULL_TREE, 0);
-		  end_template_decl (yyvsp[-3].ttype, d, 0);
-		  if (yyvsp[0].itype != ';')
-		    reinit_parse_for_template ((int) yyvsp[0].itype, yyvsp[-3].ttype, d);
-		;
-    break;}
-case 44:
-#line 479 "cp-parse.y"
-{ end_template_decl (yyvsp[-2].ttype, 0, 0); ;
-    break;}
-case 45:
-#line 480 "cp-parse.y"
-{ end_template_decl (yyvsp[-2].ttype, 0, 0); ;
-    break;}
-case 46:
-#line 483 "cp-parse.y"
-{ yyval.itype = '{'; ;
-    break;}
-case 47:
-#line 484 "cp-parse.y"
-{ yyval.itype = ':'; ;
-    break;}
-case 48:
-#line 485 "cp-parse.y"
-{ yyval.itype = ';'; ;
-    break;}
-case 49:
-#line 486 "cp-parse.y"
-{ yyval.itype = '='; ;
-    break;}
-case 50:
-#line 487 "cp-parse.y"
-{ yyval.itype = RETURN; ;
-    break;}
-case 51:
-#line 492 "cp-parse.y"
-{ if (pedantic)
-		    pedwarn ("ANSI C++ forbids data definition with no type or storage class");
-  		  else if (! flag_traditional && ! have_extern_spec)
-  		    warning ("data definition has no type or storage class"); ;
-    break;}
-case 52:
-#line 497 "cp-parse.y"
-{;
-    break;}
-case 53:
-#line 500 "cp-parse.y"
-{ tree d;
-		  d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE);
-		  finish_decl (d, NULL_TREE, NULL_TREE, 0);
-		;
-    break;}
-case 54:
-#line 505 "cp-parse.y"
-{
-		  end_exception_decls ();
-		  note_list_got_semicolon (yyval.ttype);
-		;
-    break;}
-case 55:
-#line 511 "cp-parse.y"
-{ tree d;
-		  d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE);
-		  finish_decl (d, NULL_TREE, NULL_TREE, 0);
-		  end_exception_decls ();
-		  note_list_got_semicolon (yyval.ttype);
-		;
-    break;}
-case 56:
-#line 518 "cp-parse.y"
-{ pedwarn ("empty declaration"); ;
-    break;}
-case 57:
-#line 520 "cp-parse.y"
-{
-	    tree t = yyval.ttype;
-	    shadow_tag (t);
-	    if (TREE_CODE (t) == TREE_LIST
-		&& TREE_PURPOSE (t) == NULL_TREE)
-	      {
-		t = TREE_VALUE (t);
-		if (TREE_CODE (t) == RECORD_TYPE)
-		  {
-		    if (CLASSTYPE_USE_TEMPLATE (t) == 0)
-		      CLASSTYPE_USE_TEMPLATE (t) = 2;
-		    else if (CLASSTYPE_USE_TEMPLATE (t) == 1)
-		      error ("override declaration for already-expanded template");
-		  }
-	      }
-	    note_list_got_semicolon (yyval.ttype);
-	  ;
-    break;}
-case 61:
-#line 544 "cp-parse.y"
-{
-		  finish_function (lineno, 1);
-		  /* finish_function performs these three statements:
-
-		     expand_end_bindings (getdecls (), 1, 0);
-		     poplevel (1, 1, 0);
-
-		     expand_end_bindings (0, 0, 0);
-		     poplevel (0, 0, 1);
-		     */
-		  if (yyval.ttype) process_next_inline (yyval.ttype);
-		;
-    break;}
-case 62:
-#line 557 "cp-parse.y"
-{
-		  finish_function (lineno, 1);
-		  /* finish_function performs these three statements:
-
-		     expand_end_bindings (getdecls (), 1, 0);
-		     poplevel (1, 1, 0);
-
-		     expand_end_bindings (0, 0, 0);
-		     poplevel (0, 0, 1);
-		     */
-		  if (yyval.ttype) process_next_inline (yyval.ttype);
-		;
-    break;}
-case 63:
-#line 570 "cp-parse.y"
-{ finish_function (lineno, 0);
-		  if (yyval.ttype) process_next_inline (yyval.ttype); ;
-    break;}
-case 64:
-#line 573 "cp-parse.y"
-{ finish_function (lineno, 0);
-		  if (yyval.ttype) process_next_inline (yyval.ttype); ;
-    break;}
-case 65:
-#line 576 "cp-parse.y"
-{ finish_function (lineno, 0);
-		  if (yyval.ttype) process_next_inline (yyval.ttype); ;
-    break;}
-case 66:
-#line 579 "cp-parse.y"
-{;
-    break;}
-case 67:
-#line 581 "cp-parse.y"
-{;
-    break;}
-case 68:
-#line 583 "cp-parse.y"
-{;
-    break;}
-case 69:
-#line 588 "cp-parse.y"
-{ if (! start_function (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype, 0))
-		    YYERROR1;
-		  reinit_parse_for_function ();
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 70:
-#line 593 "cp-parse.y"
-{ if (! start_function (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype, 0))
-		    YYERROR1;
-		  reinit_parse_for_function ();
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 71:
-#line 598 "cp-parse.y"
-{ if (! start_function (NULL_TREE, yyval.ttype, yyvsp[0].ttype, 0))
-		    YYERROR1;
-		  reinit_parse_for_function ();
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 72:
-#line 603 "cp-parse.y"
-{ if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-3].ttype, yyvsp[-1].ttype), yyvsp[0].ttype, 0))
-		    YYERROR1;
-		  reinit_parse_for_function ();
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 73:
-#line 608 "cp-parse.y"
-{ if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-3].ttype, yyvsp[-1].ttype), yyvsp[0].ttype, 0))
-		    YYERROR1;
-		  reinit_parse_for_function ();
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 74:
-#line 613 "cp-parse.y"
-{ if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[-1].ttype), yyvsp[0].ttype, 0))
-		    YYERROR1;
-		  reinit_parse_for_function ();
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 75:
-#line 618 "cp-parse.y"
-{ if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[-1].ttype), yyvsp[0].ttype, 0))
-		    YYERROR1;
-		  reinit_parse_for_function ();
-		  yyval.ttype = NULL_TREE; ;
-    break;}
-case 76:
-#line 623 "cp-parse.y"
-{ start_function (NULL_TREE, TREE_VALUE (yyval.ttype), NULL_TREE, 1);
-		  reinit_parse_for_function (); ;
-    break;}
-case 77:
-#line 630 "cp-parse.y"
-{
-		  tree decl = build_parse_node (CALL_EXPR, TREE_VALUE (yyval.ttype), yyvsp[-3].ttype, yyvsp[-1].ttype);
-		  yyval.ttype = start_method (TREE_CHAIN (yyval.ttype), decl, yyvsp[0].ttype);
-		  if (! yyval.ttype)
-		    YYERROR1;
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  reinit_parse_for_method (yychar, yyval.ttype); ;
-    break;}
-case 78:
-#line 639 "cp-parse.y"
-{
-		  tree decl = build_parse_node (CALL_EXPR, TREE_VALUE (yyval.ttype), empty_parms (), yyvsp[-1].ttype);
-		  yyval.ttype = start_method (TREE_CHAIN (yyval.ttype), decl, yyvsp[0].ttype);
-		  if (! yyval.ttype)
-		    YYERROR1;
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  reinit_parse_for_method (yychar, yyval.ttype); ;
-    break;}
-case 79:
-#line 648 "cp-parse.y"
-{ yyval.ttype = start_method (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype);
-		  if (! yyval.ttype)
-		    YYERROR1;
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  reinit_parse_for_method (yychar, yyval.ttype); ;
-    break;}
-case 80:
-#line 655 "cp-parse.y"
-{
-		  tree decl = build_parse_node (CALL_EXPR, TREE_VALUE (yyval.ttype), yyvsp[-3].ttype, yyvsp[-1].ttype);
-		  yyval.ttype = start_method (TREE_CHAIN (yyval.ttype), decl, yyvsp[0].ttype);
-		  if (! yyval.ttype)
-		    YYERROR1;
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  reinit_parse_for_method (yychar, yyval.ttype); ;
-    break;}
-case 81:
-#line 664 "cp-parse.y"
-{
-		  tree decl = build_parse_node (CALL_EXPR, TREE_VALUE (yyval.ttype), empty_parms (), yyvsp[-1].ttype);
-		  yyval.ttype = start_method (TREE_CHAIN (yyval.ttype), decl, yyvsp[0].ttype);
-		  if (! yyval.ttype)
-		    YYERROR1;
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  reinit_parse_for_method (yychar, yyval.ttype); ;
-    break;}
-case 82:
-#line 673 "cp-parse.y"
-{ yyval.ttype = start_method (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype);
-		  if (! yyval.ttype)
-		    YYERROR1;
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  reinit_parse_for_method (yychar, yyval.ttype); ;
-    break;}
-case 83:
-#line 680 "cp-parse.y"
-{ yyval.ttype = start_method (NULL_TREE, yyval.ttype, yyvsp[0].ttype);
-		  if (! yyval.ttype)
-		    YYERROR1;
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  reinit_parse_for_method (yychar, yyval.ttype); ;
-    break;}
-case 84:
-#line 689 "cp-parse.y"
-{
-		  if (! current_function_parms_stored)
-		    store_parm_decls ();
-		  yyval.ttype = yyvsp[0].ttype;
-		;
-    break;}
-case 85:
-#line 697 "cp-parse.y"
-{ store_return_init (yyval.ttype, NULL_TREE); ;
-    break;}
-case 86:
-#line 699 "cp-parse.y"
-{ store_return_init (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 87:
-#line 701 "cp-parse.y"
-{ store_return_init (yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 88:
-#line 703 "cp-parse.y"
-{ store_return_init (yyval.ttype, NULL_TREE); ;
-    break;}
-case 89:
-#line 708 "cp-parse.y"
-{
-		  if (yyvsp[0].itype == 0)
-		    error ("no base initializers given following ':'");
-		  setup_vtbl_ptr ();
-		;
-    break;}
-case 90:
-#line 717 "cp-parse.y"
-{
-		  if (! current_function_parms_stored)
-		    store_parm_decls ();
-
-		  /* Flag that we are processing base and member initializers.  */
-		  current_vtable_decl = error_mark_node;
-
-		  if (DECL_CONSTRUCTOR_P (current_function_decl))
-		    {
-		      /* Make a contour for the initializer list.  */
-		      pushlevel (0);
-		      clear_last_expr ();
-		      expand_start_bindings (0);
-		    }
-		  else if (current_class_type == NULL_TREE)
-		    error ("base initializers not allowed for non-member functions");
-		  else if (! DECL_CONSTRUCTOR_P (current_function_decl))
-		    error ("only constructors take base initializers");
-		;
-    break;}
-case 91:
-#line 740 "cp-parse.y"
-{ yyval.itype = 0; ;
-    break;}
-case 92:
-#line 742 "cp-parse.y"
-{ yyval.itype = 1; ;
-    break;}
-case 95:
-#line 748 "cp-parse.y"
-{
-		  if (current_class_name && !flag_traditional)
-		    pedwarn ("ANSI C++ forbids old style base class initialization",
-			     IDENTIFIER_POINTER (current_class_name));
-		  expand_member_init (C_C_D, NULL_TREE, yyvsp[-1].ttype);
-		;
-    break;}
-case 96:
-#line 755 "cp-parse.y"
-{
-		  if (current_class_name && !flag_traditional)
-		    pedwarn ("ANSI C++ forbids old style base class initialization",
-			     IDENTIFIER_POINTER (current_class_name));
-		  expand_member_init (C_C_D, NULL_TREE, void_type_node);
-		;
-    break;}
-case 97:
-#line 762 "cp-parse.y"
-{
-		  expand_member_init (C_C_D, yyval.ttype, yyvsp[-1].ttype);
-		;
-    break;}
-case 98:
-#line 766 "cp-parse.y"
-{ expand_member_init (C_C_D, yyval.ttype, void_type_node); ;
-    break;}
-case 99:
-#line 768 "cp-parse.y"
-{ expand_member_init (C_C_D, yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 100:
-#line 770 "cp-parse.y"
-{ expand_member_init (C_C_D, yyval.ttype, void_type_node); ;
-    break;}
-case 101:
-#line 772 "cp-parse.y"
-{ expand_member_init (C_C_D, yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 102:
-#line 774 "cp-parse.y"
-{ expand_member_init (C_C_D, yyval.ttype, void_type_node); ;
-    break;}
-case 103:
-#line 776 "cp-parse.y"
-{
-		  do_member_init (yyval.ttype, yyvsp[-3].ttype, yyvsp[-1].ttype);
-		;
-    break;}
-case 104:
-#line 780 "cp-parse.y"
-{
-		  do_member_init (yyval.ttype, yyvsp[-1].ttype, void_type_node);
-		;
-    break;}
-case 114:
-#line 804 "cp-parse.y"
-{ yyval.ttype = build_parse_node (BIT_NOT_EXPR,yyvsp[0].ttype);;
-    break;}
-case 116:
-#line 810 "cp-parse.y"
-{
-  		  extern tree template_type_seen_before_scope;
-
-		  if (yyvsp[0].ttype) 
-		    yyval.ttype = yyvsp[0].ttype;
-		  else if (yyval.ttype != error_mark_node)
-		    yyval.ttype = IDENTIFIER_TYPE_VALUE (yyval.ttype);
-		  /* This is a kludge: In order to detect nested types inside
-		   * template classes, we have to tell the lexer that it should
-		   * try to replace a following SCOPE token with the correct
-		   * SCOPED_TYPENAME for the nested type.  This SCOPED_TYPENAME
-		   * token will be handled in the rule "scoped_typename".
-		   * - niklas@appli.se */
-		  if (yychar == SCOPE)
-		    {
-		      /* We set template_type_seen_before_scope to be
-			 an error_mark_node so we can avoid meaningless
-			 and unhelpful syntax errors later.  */
-		      if (yyval.ttype != error_mark_node)
-			template_type_seen_before_scope = TYPE_IDENTIFIER (yyval.ttype);
-		      else
-			template_type_seen_before_scope = error_mark_node;
-		      yychar = YYLEX;
-		    }
-		;
-    break;}
-case 117:
-#line 839 "cp-parse.y"
-{ yyval.ttype = lookup_template_class (yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ;
-    break;}
-case 118:
-#line 841 "cp-parse.y"
-{ yyval.ttype = lookup_template_class (yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ;
-    break;}
-case 119:
-#line 847 "cp-parse.y"
-{ yyungetc ('{', 1); yyval.ttype = 0; ;
-    break;}
-case 120:
-#line 848 "cp-parse.y"
-{ yyungetc (':', 1); yyval.ttype = 0; ;
-    break;}
-case 121:
-#line 850 "cp-parse.y"
-{ yyval.ttype = instantiate_class_template (yyvsp[0].ttype, 1); ;
-    break;}
-case 122:
-#line 855 "cp-parse.y"
-{ yyval.ttype = instantiate_class_template (yyvsp[0].ttype, 1); ;
-    break;}
-case 123:
-#line 860 "cp-parse.y"
-{ yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 124:
-#line 862 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
-    break;}
-case 125:
-#line 867 "cp-parse.y"
-{ yyval.ttype = groktypename (yyval.ttype); ;
-    break;}
-case 127:
-#line 873 "cp-parse.y"
-{
-		  tree t, decl, id, tmpl;
-
-		  id = TREE_VALUE (yyvsp[-1].ttype);
-		  tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE (id));
-		  t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, id, yyvsp[0].ttype);
-		  set_current_level_tags_transparency (1);
-		  my_friendly_assert (TREE_CODE (t) == RECORD_TYPE, 257);
-		  yyval.ttype = t;
-
-		  /* Now, put a copy of the decl in global scope, to avoid
-		     recursive expansion.  */
-		  decl = IDENTIFIER_LOCAL_VALUE (id);
-		  if (!decl)
-		    decl = IDENTIFIER_CLASS_VALUE (id);
-		  /* Now, put a copy of the decl in global scope, to avoid
-		     recursive expansion.  */
-                  if (decl)
-                    {
-		      /* Need to copy it to clear the chain pointer,
-			 and need to get it into permanent storage.  */
-                      my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 258);
-		      push_obstacks (&permanent_obstack, &permanent_obstack);
-                      decl = copy_node (decl);
-		      if (DECL_LANG_SPECIFIC (decl))
-			copy_lang_decl (decl);
-		      pop_obstacks ();
-		      pushdecl_top_level (decl);
-		    }
-		;
-    break;}
-case 128:
-#line 904 "cp-parse.y"
-{
-		  int old_interface = interface_unknown;
-
-		  interface_unknown = 1;
-		  yyval.ttype = finish_struct (yyvsp[-3].ttype, yyvsp[-1].ttype, 0);
-
-		  pop_obstacks ();
-		  end_template_instantiation (yyvsp[-5].ttype, yyvsp[-3].ttype);
-
-                  /* Now go after the methods & class data.  */
-		  old_interface = interface_unknown;
-		  interface_unknown = 1;
-                  instantiate_member_templates (yyvsp[-5].ttype);
-		  interface_unknown = old_interface;
-		  CLASSTYPE_GOT_SEMICOLON (yyval.ttype) = 1;
-		;
-    break;}
-case 129:
-#line 924 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 130:
-#line 926 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 131:
-#line 931 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; /* never used from here... */;
-    break;}
-case 132:
-#line 933 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; /*???*/ ;
-    break;}
-case 133:
-#line 937 "cp-parse.y"
-{ yyval.code = NEGATE_EXPR; ;
-    break;}
-case 134:
-#line 939 "cp-parse.y"
-{ yyval.code = CONVERT_EXPR; ;
-    break;}
-case 135:
-#line 941 "cp-parse.y"
-{ yyval.code = PREINCREMENT_EXPR; ;
-    break;}
-case 136:
-#line 943 "cp-parse.y"
-{ yyval.code = PREDECREMENT_EXPR; ;
-    break;}
-case 137:
-#line 945 "cp-parse.y"
-{ yyval.code = TRUTH_NOT_EXPR; ;
-    break;}
-case 138:
-#line 949 "cp-parse.y"
-{ yyval.ttype = build_x_compound_expr (yyval.ttype); ;
-    break;}
-case 140:
-#line 956 "cp-parse.y"
-{ error ("ANSI C++ forbids an empty condition for `%s'",
-			 cond_stmt_keyword);
-		  yyval.ttype = integer_zero_node; ;
-    break;}
-case 141:
-#line 960 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 142:
-#line 965 "cp-parse.y"
-{ yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 143:
-#line 967 "cp-parse.y"
-{ chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
-    break;}
-case 144:
-#line 969 "cp-parse.y"
-{ chainon (yyval.ttype, build_tree_list (NULL_TREE, error_mark_node)); ;
-    break;}
-case 145:
-#line 974 "cp-parse.y"
-{
-		  if (TREE_CODE (yyval.ttype) == TYPE_EXPR)
-		    yyval.ttype = build_component_type_expr (C_C_D, yyval.ttype, NULL_TREE, 1);
-		;
-    break;}
-case 146:
-#line 980 "cp-parse.y"
-{ yyvsp[0].itype = pedantic;
-		  pedantic = 0; ;
-    break;}
-case 147:
-#line 983 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype;
-		  pedantic = yyvsp[-2].itype; ;
-    break;}
-case 148:
-#line 986 "cp-parse.y"
-{ yyval.ttype = build_x_indirect_ref (yyvsp[0].ttype, "unary *"); ;
-    break;}
-case 149:
-#line 988 "cp-parse.y"
-{ yyval.ttype = build_x_unary_op (ADDR_EXPR, yyvsp[0].ttype); ;
-    break;}
-case 150:
-#line 990 "cp-parse.y"
-{ yyval.ttype = build_x_unary_op (BIT_NOT_EXPR, yyvsp[0].ttype); ;
-    break;}
-case 151:
-#line 992 "cp-parse.y"
-{ yyval.ttype = build_x_unary_op ((enum tree_code) yyval.ttype, yyvsp[0].ttype);
-		  if (yyvsp[-1].code == NEGATE_EXPR && TREE_CODE (yyvsp[0].ttype) == INTEGER_CST)
-		    TREE_NEGATED_INT (yyval.ttype) = 1;
-		;
-    break;}
-case 152:
-#line 998 "cp-parse.y"
-{ tree label = lookup_label (yyvsp[0].ttype);
-		  TREE_USED (label) = 1;
-		  yyval.ttype = build1 (ADDR_EXPR, ptr_type_node, label);
-		  TREE_CONSTANT (yyval.ttype) = 1; ;
-    break;}
-case 153:
-#line 1003 "cp-parse.y"
-{ if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF
-		      && DECL_BIT_FIELD (TREE_OPERAND (yyvsp[0].ttype, 1)))
-		    error ("sizeof applied to a bit-field");
-		  /* ANSI says arrays and functions are converted inside comma.
-		     But we can't really convert them in build_compound_expr
-		     because that would break commas in lvalues.
-		     So do the conversion here if operand was a comma.  */
-		  if (TREE_CODE (yyvsp[0].ttype) == COMPOUND_EXPR
-		      && (TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == ARRAY_TYPE
-			  || TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == FUNCTION_TYPE))
-		    yyvsp[0].ttype = default_conversion (yyvsp[0].ttype);
-		  else if (TREE_CODE (yyvsp[0].ttype) == TREE_LIST)
-	            {
-		      tree t = TREE_VALUE (yyvsp[0].ttype);
-		      if (t != NULL_TREE
-			  && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
-			pedwarn ("ANSI C++ forbids using sizeof() on a function");
-		    }
-		  yyval.ttype = c_sizeof (TREE_TYPE (yyvsp[0].ttype)); ;
-    break;}
-case 154:
-#line 1023 "cp-parse.y"
-{ yyval.ttype = c_sizeof (groktypename (yyvsp[-1].ttype)); ;
-    break;}
-case 155:
-#line 1025 "cp-parse.y"
-{ if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF
-		      && DECL_BIT_FIELD (TREE_OPERAND (yyvsp[0].ttype, 1)))
-		    error ("`__alignof' applied to a bit-field");
-		  if (TREE_CODE (yyvsp[0].ttype) == INDIRECT_REF)
-		    {
-		      tree t = TREE_OPERAND (yyvsp[0].ttype, 0);
-		      tree best = t;
-		      int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
-		      while (TREE_CODE (t) == NOP_EXPR
-			     && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
-			{
-			  int thisalign;
-			  t = TREE_OPERAND (t, 0);
-			  thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
-			  if (thisalign > bestalign)
-			    best = t, bestalign = thisalign;
-			}
-		      yyval.ttype = c_alignof (TREE_TYPE (TREE_TYPE (best)));
-		    }
-		  else
-		    {
-		      /* ANSI says arrays and fns are converted inside comma.
-			 But we can't convert them in build_compound_expr
-			 because that would break commas in lvalues.
-			 So do the conversion here if operand was a comma.  */
-		      if (TREE_CODE (yyvsp[0].ttype) == COMPOUND_EXPR
-			  && (TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == ARRAY_TYPE
-			      || TREE_CODE (TREE_TYPE (yyvsp[0].ttype)) == FUNCTION_TYPE))
-			yyvsp[0].ttype = default_conversion (yyvsp[0].ttype);
-		      yyval.ttype = c_alignof (TREE_TYPE (yyvsp[0].ttype));
-		    }
-		;
-    break;}
-case 156:
-#line 1058 "cp-parse.y"
-{ yyval.ttype = c_alignof (groktypename (yyvsp[-1].ttype)); ;
-    break;}
-case 157:
-#line 1061 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-1].ttype, yyvsp[0].ttype, NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 158:
-#line 1063 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 159:
-#line 1065 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-4].ttype, yyvsp[-3].ttype, yyvsp[-1].ttype, yyval.ttype != NULL_TREE); ;
-    break;}
-case 160:
-#line 1067 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-5].ttype, yyvsp[-3].ttype, yyvsp[-1].ttype, yyval.ttype != NULL_TREE); ;
-    break;}
-case 161:
-#line 1069 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-2].ttype, yyvsp[-1].ttype, NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 162:
-#line 1071 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 163:
-#line 1073 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-3].ttype, yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype != NULL_TREE); ;
-    break;}
-case 164:
-#line 1075 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype != NULL_TREE); ;
-    break;}
-case 165:
-#line 1083 "cp-parse.y"
-{
-		  tree absdcl, typename;
-
-		illegal_new_array:
-		  absdcl = build_parse_node (ARRAY_REF, yyvsp[-4].ttype, yyvsp[-1].ttype);
-		  typename = build_decl_list (yyvsp[-5].ttype, absdcl);
-		  pedwarn ("ANSI C++ forbids array dimensions with parenthesized type");
-		  yyval.ttype = build_new (yyvsp[-7].ttype, typename, NULL_TREE, yyval.ttype != NULL_TREE);
-		;
-    break;}
-case 166:
-#line 1093 "cp-parse.y"
-{ goto illegal_new_array; ;
-    break;}
-case 167:
-#line 1096 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-4].ttype, build_decl_list (yyvsp[-2].ttype, yyvsp[-1].ttype), NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 168:
-#line 1098 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-5].ttype, build_decl_list (yyvsp[-2].ttype, yyvsp[-1].ttype), NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 169:
-#line 1100 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-4].ttype, build_decl_list (yyvsp[-2].ttype, yyvsp[-1].ttype), NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 170:
-#line 1102 "cp-parse.y"
-{ yyval.ttype = build_new (yyvsp[-5].ttype, build_decl_list (yyvsp[-2].ttype, yyvsp[-1].ttype), NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 171:
-#line 1105 "cp-parse.y"
-{ yyungetc (':', 1); yyval.ttype = build_new (yyvsp[-1].ttype, yyvsp[0].ttype, NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 172:
-#line 1107 "cp-parse.y"
-{ yyungetc (':', 1); yyval.ttype = build_new (yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE, yyval.ttype != NULL_TREE); ;
-    break;}
-case 173:
-#line 1110 "cp-parse.y"
-{ tree expr = stabilize_reference (convert_from_reference (yyvsp[0].ttype));
-		  tree type = TREE_TYPE (expr);
-
-		  if (TREE_CODE (type) != POINTER_TYPE)
-		    {
-		      error ("non-pointer type to `delete'");
-		      yyval.ttype = error_mark_node;
-		      break;
-		    }
-		  else if (integer_zerop (expr))
-		    {
-		      /* ANSI C++ June 5 1992 WP 5.3.4.  Deleting a pointer
-			 with the value zero is legal and has no effect.  */
-		      yyval.ttype = build1 (NOP_EXPR, void_type_node, expr);
-		      break;
-		    }
-		  else if (TREE_READONLY (TREE_TYPE (type)))
-		    {
-		      error ("`const *' cannot be deleted");
-		      yyval.ttype = error_mark_node;
-		      break;
-		    }
-		  yyval.ttype = build_delete (type, expr, integer_three_node,
-				     LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE,
-				     TYPE_HAS_DESTRUCTOR (TREE_TYPE (type)),
-				     0);
-		;
-    break;}
-case 174:
-#line 1138 "cp-parse.y"
-{
-		  tree exp = stabilize_reference (convert_from_reference (yyvsp[0].ttype));
-		  tree type = TREE_TYPE (exp);
-		  tree elt_size = c_sizeof (type);
-
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-
-		  if (TREE_CODE (type) == POINTER_TYPE
-		      && TREE_READONLY (TREE_TYPE (type)))
-		    {
-		      error ("`const *' cannot be deleted");
-		      yyval.ttype = error_mark_node;
-		      break;
-		    }
-		  yyval.ttype = build_vec_delete (exp, NULL_TREE, elt_size, NULL_TREE,
-					 integer_one_node, integer_two_node);
-		;
-    break;}
-case 175:
-#line 1157 "cp-parse.y"
-{
-		  tree maxindex = build_binary_op (MINUS_EXPR, yyvsp[-2].ttype,
-						   integer_one_node, 1);
-		  tree exp = stabilize_reference (convert_from_reference (yyvsp[0].ttype));
-		  tree type = TREE_TYPE (exp);
-		  tree elt_size = c_sizeof (type);
-
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-
-		  if (! flag_traditional)
-		    pedwarn ("ANSI C++ forbids array size in vector delete");
-		  if (TREE_CODE (type) == POINTER_TYPE
-		      && TREE_READONLY (TREE_TYPE (type)))
-		    {
-		      error ("`const *' cannot be deleted");
-		      yyval.ttype = error_mark_node;
-		      break;
-		    }
-		  yyval.ttype = build_vec_delete (exp, maxindex, elt_size, NULL_TREE,
-					 integer_one_node, integer_two_node);
-		;
-    break;}
-case 177:
-#line 1184 "cp-parse.y"
-{ tree type = groktypename (yyvsp[-2].ttype);
-		  yyval.ttype = build_c_cast (type, yyvsp[0].ttype); ;
-    break;}
-case 178:
-#line 1187 "cp-parse.y"
-{ tree type = groktypename (yyvsp[-5].ttype);
-		  tree init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype));
-		  if (pedantic)
-		    pedwarn ("ANSI C++ forbids constructor-expressions");
-		  /* Indicate that this was a GNU C constructor expression.  */
-		  TREE_HAS_CONSTRUCTOR (init) = 1;
-		  yyval.ttype = digest_init (type, init, (tree *) 0);
-		  if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
-		    {
-		      int failure = complete_array_type (type, yyval.ttype, 1);
-		      if (failure)
-			my_friendly_abort (78);
-		    }
-		;
-    break;}
-case 179:
-#line 1202 "cp-parse.y"
-{ yyval.ttype = build_headof (yyvsp[-1].ttype); ;
-    break;}
-case 180:
-#line 1204 "cp-parse.y"
-{ yyval.ttype = build_classof (yyvsp[-1].ttype); ;
-    break;}
-case 181:
-#line 1206 "cp-parse.y"
-{ if (is_aggr_typedef (yyvsp[-1].ttype, 1))
-		    {
-		      tree type = IDENTIFIER_TYPE_VALUE (yyvsp[-1].ttype);
-		      yyval.ttype = CLASSTYPE_DOSSIER (type);
-		    }
-		  else
-		    yyval.ttype = error_mark_node;
-		;
-    break;}
-case 183:
-#line 1219 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 184:
-#line 1221 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 185:
-#line 1223 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 186:
-#line 1225 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 187:
-#line 1227 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 188:
-#line 1229 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 189:
-#line 1231 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 190:
-#line 1233 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 191:
-#line 1235 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (LT_EXPR, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 192:
-#line 1237 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (GT_EXPR, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 193:
-#line 1239 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 194:
-#line 1241 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 195:
-#line 1243 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 196:
-#line 1245 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 197:
-#line 1247 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 198:
-#line 1249 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (TRUTH_ANDIF_EXPR, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 199:
-#line 1251 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (TRUTH_ORIF_EXPR, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 200:
-#line 1253 "cp-parse.y"
-{ yyval.ttype = build_x_conditional_expr (yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 201:
-#line 1255 "cp-parse.y"
-{ yyval.ttype = build_modify_expr (yyval.ttype, NOP_EXPR, yyvsp[0].ttype); ;
-    break;}
-case 202:
-#line 1257 "cp-parse.y"
-{ register tree rval;
-		  if (rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, yyval.ttype, yyvsp[0].ttype,
-					     make_node (yyvsp[-1].code)))
-		    yyval.ttype = rval;
-		  else
-		    yyval.ttype = build_modify_expr (yyval.ttype, yyvsp[-1].code, yyvsp[0].ttype); ;
-    break;}
-case 203:
-#line 1264 "cp-parse.y"
-{ yyval.ttype = build_m_component_ref (yyval.ttype, build_indirect_ref (yyvsp[0].ttype, 0)); ;
-    break;}
-case 204:
-#line 1267 "cp-parse.y"
-{ yyval.ttype = build_x_binary_op (MEMBER_REF, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 205:
-#line 1283 "cp-parse.y"
-{ yyval.ttype = do_identifier (yyval.ttype); ;
-    break;}
-case 206:
-#line 1285 "cp-parse.y"
-{
-		  tree op = yyval.ttype;
-		  if (TREE_CODE (op) != IDENTIFIER_NODE)
-		    yyval.ttype = op;
-		  else
-		    {
-		      yyval.ttype = lookup_name (op, 0);
-		      if (yyval.ttype == NULL_TREE)
-			{
-			  error ("operator %s not defined", operator_name_string (op));
-			  yyval.ttype = error_mark_node;
-			}
-		    }
-		;
-    break;}
-case 208:
-#line 1301 "cp-parse.y"
-{ yyval.ttype = combine_strings (yyval.ttype); ;
-    break;}
-case 209:
-#line 1303 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 210:
-#line 1305 "cp-parse.y"
-{ yyval.ttype = error_mark_node; ;
-    break;}
-case 211:
-#line 1307 "cp-parse.y"
-{ if (current_function_decl == 0)
-		    {
-		      error ("braced-group within expression allowed only inside a function");
-		      YYERROR;
-		    }
-		  keep_next_level ();
-		  yyval.ttype = expand_start_stmt_expr (); ;
-    break;}
-case 212:
-#line 1315 "cp-parse.y"
-{ tree rtl_exp;
-		  if (pedantic)
-		    pedwarn ("ANSI C++ forbids braced-groups within expressions");
-		  rtl_exp = expand_end_stmt_expr (yyvsp[-2].ttype);
-		  /* The statements have side effects, so the group does.  */
-		  TREE_SIDE_EFFECTS (rtl_exp) = 1;
-		  /* Make a BIND_EXPR for the BLOCK already made.  */
-		  yyval.ttype = build (BIND_EXPR, TREE_TYPE (rtl_exp),
-			      NULL_TREE, rtl_exp, yyvsp[-1].ttype);
-		  /* Remove the block from the tree at this point.
-		     It gets put back at the proper place
-		     when the BIND_EXPR is expanded.  */
-		  delete_block (yyvsp[-1].ttype);
-		;
-    break;}
-case 213:
-#line 1330 "cp-parse.y"
-{ /* [eichin:19911016.1902EST] */
-                  yyval.ttype = build_x_function_call (yyvsp[-3].ttype, yyvsp[-1].ttype, current_class_decl); 
-                  /* here we instantiate_class_template as needed... */
-                  do_pending_templates ();
-                ;
-    break;}
-case 214:
-#line 1334 "cp-parse.y"
-{
-                  if (TREE_CODE (yyvsp[-1].ttype) == CALL_EXPR
-                      && TREE_TYPE (yyvsp[-1].ttype) != void_type_node)
-	            yyval.ttype = require_complete_type (yyvsp[-1].ttype);
-                  else
-                    yyval.ttype = yyvsp[-1].ttype;
-                ;
-    break;}
-case 215:
-#line 1342 "cp-parse.y"
-{
-		  if (yyval.ttype != error_mark_node)
-		    {
-		      yyval.ttype = build_x_function_call (yyval.ttype, NULL_TREE, current_class_decl);
-		      if (TREE_CODE (yyval.ttype) == CALL_EXPR
-			  && TREE_TYPE (yyval.ttype) != void_type_node)
-			yyval.ttype = require_complete_type (yyval.ttype);
-		    }
-                ;
-    break;}
-case 216:
-#line 1352 "cp-parse.y"
-{
-		do_array:
-		  {
-		    tree array_expr = yyval.ttype;
-		    tree index_exp = yyvsp[-1].ttype;
-		    tree type = TREE_TYPE (array_expr);
-		    if (type == error_mark_node || index_exp == error_mark_node)
-		      yyval.ttype = error_mark_node;
-		    else if (type == NULL_TREE)
-		      {
-			/* Something has gone very wrong.  Assume we
-			   are mistakenly reducing an expression
-			   instead of a declaration.  */
-			error ("parser may be lost: is there a '{' missing somewhere?");
-			yyval.ttype = NULL_TREE;
-		      }
-		    else
-		      {
-			if (TREE_CODE (type) == OFFSET_TYPE)
-			  type = TREE_TYPE (type);
-			if (TREE_CODE (type) == REFERENCE_TYPE)
-			  type = TREE_TYPE (type);
-
-			if (TYPE_LANG_SPECIFIC (type)
-			    && TYPE_OVERLOADS_ARRAY_REF (type))
-			  yyval.ttype = build_opfncall (ARRAY_REF, LOOKUP_NORMAL, array_expr, index_exp, NULL_TREE);
-			else if (TREE_CODE (type) == POINTER_TYPE
-				 || TREE_CODE (type) == ARRAY_TYPE)
-			  yyval.ttype = build_array_ref (array_expr, index_exp);
-			else
-			  {
-			    type = TREE_TYPE (index_exp);
-			    if (TREE_CODE (type) == OFFSET_TYPE)
-			      type = TREE_TYPE (type);
-			    if (TREE_CODE (type) == REFERENCE_TYPE)
-			      type = TREE_TYPE (type);
-			    
-			    if (TYPE_LANG_SPECIFIC (type)
-				&& TYPE_OVERLOADS_ARRAY_REF (type))
-			      error ("array expression backwards");
-			    else if (TREE_CODE (type) == POINTER_TYPE
-				     || TREE_CODE (type) == ARRAY_TYPE)
-			      yyval.ttype = build_array_ref (index_exp, array_expr);
-			    else
-			      error("[] applied to non-pointer type");
-			  }
-		      }
-		  }
-		;
-    break;}
-case 217:
-#line 1402 "cp-parse.y"
-{ yyval.ttype = build_component_ref (yyval.ttype, yyvsp[0].ttype, NULL_TREE, 1); ;
-    break;}
-case 218:
-#line 1404 "cp-parse.y"
-{
-		  tree basetype = yyvsp[-1].ttype;
-		  if (is_aggr_typedef (basetype, 1))
-		    {
-		      basetype = IDENTIFIER_TYPE_VALUE (basetype);
-
-		      if (yyval.ttype == error_mark_node)
-			;
-		      else if (binfo_or_else (basetype, TREE_TYPE (yyval.ttype)))
-			yyval.ttype = build_component_ref (build_scoped_ref (yyval.ttype, yyvsp[-1].ttype), yyvsp[0].ttype, NULL_TREE, 1);
-		      else
-			yyval.ttype = error_mark_node;
-		    }
-		  else yyval.ttype = error_mark_node;
-		;
-    break;}
-case 219:
-#line 1420 "cp-parse.y"
-{ yyval.ttype = build_x_unary_op (POSTINCREMENT_EXPR, yyval.ttype); ;
-    break;}
-case 220:
-#line 1422 "cp-parse.y"
-{ yyval.ttype = build_x_unary_op (POSTDECREMENT_EXPR, yyval.ttype); ;
-    break;}
-case 221:
-#line 1426 "cp-parse.y"
-{ if (current_class_decl)
-		    {
-#ifdef WARNING_ABOUT_CCD
-		      TREE_USED (current_class_decl) = 1;
-#endif
-		      yyval.ttype = current_class_decl;
-		    }
-		  else if (current_function_decl
-			   && DECL_STATIC_FUNCTION_P (current_function_decl))
-		    {
-		      error ("`this' is unavailable for static member functions");
-		      yyval.ttype = error_mark_node;
-		    }
-		  else
-		    {
-		      if (current_function_decl)
-			error ("invalid use of `this' in non-member function");
-		      else
-			error ("invalid use of `this' at top level");
-		      yyval.ttype = error_mark_node;
-		    }
-		;
-    break;}
-case 222:
-#line 1449 "cp-parse.y"
-{
-		  tree type;
-		  tree id = yyval.ttype;
-
-		  /* This is a C cast in C++'s `functional' notation.  */
-		  if (yyvsp[-1].ttype == error_mark_node)
-		    {
-		      yyval.ttype = error_mark_node;
-		      break;
-		    }
-#if 0
-		  if (yyvsp[-1].ttype == NULL_TREE)
-		    {
-		      error ("cannot cast null list to type `%s'",
-		             IDENTIFIER_POINTER (TYPE_NAME (id)));
-		      yyval.ttype = error_mark_node;
-		      break;
-		    }
-#endif
-#if 0
-		  /* type is not set! (mrs) */
-		  if (type == error_mark_node)
-		    yyval.ttype = error_mark_node;
-		  else
-#endif
-		    {
-		      if (id == ridpointers[(int) RID_CONST])
-		        type = build_type_variant (integer_type_node, 1, 0);
-		      else if (id == ridpointers[(int) RID_VOLATILE])
-		        type = build_type_variant (integer_type_node, 0, 1);
-#if 0
-		      /* should not be able to get here (mrs) */
-		      else if (id == ridpointers[(int) RID_FRIEND])
-		        {
-		          error ("cannot cast expression to `friend' type");
-		          yyval.ttype = error_mark_node;
-		          break;
-		        }
-#endif
-		      else my_friendly_abort (79);
-		      yyval.ttype = build_c_cast (type, build_compound_expr (yyvsp[-1].ttype));
-		    }
-		;
-    break;}
-case 223:
-#line 1493 "cp-parse.y"
-{ yyval.ttype = build_functional_cast (yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 224:
-#line 1495 "cp-parse.y"
-{ yyval.ttype = build_functional_cast (yyval.ttype, NULL_TREE); ;
-    break;}
-case 225:
-#line 1497 "cp-parse.y"
-{ yyval.ttype = build_functional_cast (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
-    break;}
-case 226:
-#line 1499 "cp-parse.y"
-{ yyval.ttype = build_functional_cast (yyvsp[-1].ttype, NULL_TREE); ;
-    break;}
-case 227:
-#line 1501 "cp-parse.y"
-{
-		do_scoped_id:
-		  yyval.ttype = IDENTIFIER_GLOBAL_VALUE (yyvsp[0].ttype);
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  if (! yyval.ttype)
-		    {
-		      if (yychar == '(' || yychar == LEFT_RIGHT)
-			yyval.ttype = implicitly_declare (yyvsp[0].ttype);
-		      else
-			{
-			  if (IDENTIFIER_GLOBAL_VALUE (yyvsp[0].ttype) != error_mark_node)
-			    error ("undeclared variable `%s' (first use here)",
-				   IDENTIFIER_POINTER (yyvsp[0].ttype));
-			  yyval.ttype = error_mark_node;
-			  /* Prevent repeated error messages.  */
-			  IDENTIFIER_GLOBAL_VALUE (yyvsp[0].ttype) = error_mark_node;
-			}
-		    }
-		  else
-		    {
-		      if (TREE_CODE (yyval.ttype) == ADDR_EXPR)
-			assemble_external (TREE_OPERAND (yyval.ttype, 0));
-		      else
-			assemble_external (yyval.ttype);
-		      TREE_USED (yyval.ttype) = 1;
-		    }
-		  if (TREE_CODE (yyval.ttype) == CONST_DECL)
-		    {
-		      /* XXX CHS - should we set TREE_USED of the constant? */
-		      yyval.ttype = DECL_INITIAL (yyval.ttype);
-		      /* This is to prevent an enum whose value is 0
-			 from being considered a null pointer constant.  */
-		      yyval.ttype = build1 (NOP_EXPR, TREE_TYPE (yyval.ttype), yyval.ttype);
-		      TREE_CONSTANT (yyval.ttype) = 1;
-		    }
-
-		;
-    break;}
-case 228:
-#line 1540 "cp-parse.y"
-{
-		  if (TREE_CODE (yyvsp[0].ttype) == IDENTIFIER_NODE)
-		    goto do_scoped_id;
-		do_scoped_operator:
-		  yyval.ttype = yyvsp[0].ttype;
-		;
-    break;}
-case 229:
-#line 1547 "cp-parse.y"
-{ yyval.ttype = build_offset_ref (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 230:
-#line 1549 "cp-parse.y"
-{ yyval.ttype = build_member_call (yyval.ttype, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
-    break;}
-case 231:
-#line 1551 "cp-parse.y"
-{ yyval.ttype = build_member_call (yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ;
-    break;}
-case 232:
-#line 1553 "cp-parse.y"
-{ yyval.ttype = build_method_call (yyval.ttype, yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE,
-					  (LOOKUP_NORMAL|LOOKUP_AGGR)); ;
-    break;}
-case 233:
-#line 1556 "cp-parse.y"
-{ yyval.ttype = build_method_call (yyval.ttype, yyvsp[-1].ttype, NULL_TREE, NULL_TREE,
-					  (LOOKUP_NORMAL|LOOKUP_AGGR)); ;
-    break;}
-case 234:
-#line 1559 "cp-parse.y"
-{ yyval.ttype = build_scoped_method_call (yyval.ttype, yyvsp[-4].ttype, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
-    break;}
-case 235:
-#line 1561 "cp-parse.y"
-{ yyval.ttype = build_scoped_method_call (yyval.ttype, yyvsp[-2].ttype, yyvsp[-1].ttype, NULL_TREE); ;
-    break;}
-case 236:
-#line 1603 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 237:
-#line 1605 "cp-parse.y"
-{
-		  yyval.ttype = yyvsp[-1].ttype;
-		  pedwarn ("old style placement syntax, use () instead");
-		;
-    break;}
-case 238:
-#line 1610 "cp-parse.y"
-{ yyval.ttype = void_type_node; ;
-    break;}
-case 239:
-#line 1612 "cp-parse.y"
-{ yyval.ttype = combine_strings (yyvsp[-1].ttype); ;
-    break;}
-case 240:
-#line 1617 "cp-parse.y"
-{ yyval.itype = 0; ;
-    break;}
-case 241:
-#line 1619 "cp-parse.y"
-{ yyval.itype = 1; ;
-    break;}
-case 242:
-#line 1623 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 243:
-#line 1625 "cp-parse.y"
-{ if (yyvsp[0].ttype)
-		    error ("extra `::' before `delete' ignored");
-		  yyval.ttype = error_mark_node;
-		;
-    break;}
-case 245:
-#line 1635 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 246:
-#line 1640 "cp-parse.y"
-{
-		  if (! current_function_parms_stored)
-		    store_parm_decls ();
-		  setup_vtbl_ptr ();
-		;
-    break;}
-case 247:
-#line 1648 "cp-parse.y"
-{
-		  if (yyval.ttype == error_mark_node)
-		    ;
-		  else
-		    {
-		      tree type = TREE_TYPE (yyval.ttype);
-
-		      if (! PROMOTES_TO_AGGR_TYPE (type, REFERENCE_TYPE))
-			{
-			  error ("object in '.' expression is not of aggregate type");
-			  yyval.ttype = error_mark_node;
-			}
-		    }
-		;
-    break;}
-case 248:
-#line 1663 "cp-parse.y"
-{
-		  yyval.ttype = build_x_arrow (yyval.ttype);
-		;
-    break;}
-case 250:
-#line 1673 "cp-parse.y"
-{
-		  resume_momentary (yyvsp[-1].itype);
-		  note_list_got_semicolon (yyval.ttype);
-		;
-    break;}
-case 251:
-#line 1679 "cp-parse.y"
-{ tree d;
-		  int yes = suspend_momentary ();
-		  d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE);
-		  finish_decl (d, NULL_TREE, NULL_TREE, 0);
-		  resume_momentary (yes);
-		  note_list_got_semicolon (yyval.ttype);
-		;
-    break;}
-case 252:
-#line 1687 "cp-parse.y"
-{ resume_momentary ((int) yyvsp[-1].itype); ;
-    break;}
-case 253:
-#line 1690 "cp-parse.y"
-{ tree d;
-		  int yes = suspend_momentary ();
-		  d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE);
-		  finish_decl (d, NULL_TREE, NULL_TREE, 0);
-		  resume_momentary (yes);
-		;
-    break;}
-case 254:
-#line 1697 "cp-parse.y"
-{
-		  shadow_tag (yyval.ttype);
-		  note_list_got_semicolon (yyval.ttype);
-		;
-    break;}
-case 255:
-#line 1702 "cp-parse.y"
-{ warning ("empty declaration"); ;
-    break;}
-case 258:
-#line 1712 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 259:
-#line 1714 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 260:
-#line 1723 "cp-parse.y"
-{ yyval.ttype = list_hash_lookup_or_cons (yyval.ttype); ;
-    break;}
-case 261:
-#line 1725 "cp-parse.y"
-{ yyval.ttype = hash_tree_chain (yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 262:
-#line 1727 "cp-parse.y"
-{ yyval.ttype = hash_tree_chain (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 263:
-#line 1729 "cp-parse.y"
-{ yyval.ttype = hash_tree_chain (yyvsp[-1].ttype, hash_chainon (yyvsp[0].ttype, yyval.ttype)); ;
-    break;}
-case 264:
-#line 1735 "cp-parse.y"
-{ yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 265:
-#line 1737 "cp-parse.y"
-{ if (extra_warnings)
-		    warning ("`%s' is not at beginning of declaration",
-			     IDENTIFIER_POINTER (yyval.ttype));
-		  yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 266:
-#line 1742 "cp-parse.y"
-{ yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 267:
-#line 1744 "cp-parse.y"
-{ if (extra_warnings)
-		    warning ("`%s' is not at beginning of declaration",
-			     IDENTIFIER_POINTER (yyvsp[0].ttype));
-		  yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 268:
-#line 1756 "cp-parse.y"
-{ yyval.ttype = IDENTIFIER_AS_LIST (yyval.ttype);
-		  TREE_STATIC (yyval.ttype) = 1; ;
-    break;}
-case 269:
-#line 1759 "cp-parse.y"
-{ yyval.ttype = IDENTIFIER_AS_LIST (yyval.ttype); ;
-    break;}
-case 270:
-#line 1761 "cp-parse.y"
-{ yyval.ttype = hash_tree_chain (yyvsp[0].ttype, yyval.ttype);
-		  TREE_STATIC (yyval.ttype) = 1; ;
-    break;}
-case 271:
-#line 1764 "cp-parse.y"
-{ if (extra_warnings && TREE_STATIC (yyval.ttype))
-		    warning ("`%s' is not at beginning of declaration",
-			     IDENTIFIER_POINTER (yyvsp[0].ttype));
-		  yyval.ttype = hash_tree_chain (yyvsp[0].ttype, yyval.ttype);
-		  TREE_STATIC (yyval.ttype) = TREE_STATIC (yyvsp[-1].ttype); ;
-    break;}
-case 272:
-#line 1780 "cp-parse.y"
-{ yyval.ttype = get_decl_list (yyval.ttype); ;
-    break;}
-case 273:
-#line 1782 "cp-parse.y"
-{ yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 274:
-#line 1784 "cp-parse.y"
-{ yyval.ttype = decl_tree_cons (NULL_TREE, yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 275:
-#line 1786 "cp-parse.y"
-{ yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-1].ttype, hash_chainon (yyvsp[0].ttype, yyval.ttype)); ;
-    break;}
-case 276:
-#line 1791 "cp-parse.y"
-{ yyval.ttype = get_decl_list (yyval.ttype); ;
-    break;}
-case 277:
-#line 1793 "cp-parse.y"
-{ yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 282:
-#line 1805 "cp-parse.y"
-{ yyval.ttype = TREE_TYPE (yyvsp[-1].ttype);
-		  if (pedantic)
-		    pedwarn ("ANSI C++ forbids `typeof'"); ;
-    break;}
-case 283:
-#line 1809 "cp-parse.y"
-{ yyval.ttype = groktypename (yyvsp[-1].ttype);
-		  if (pedantic)
-		    pedwarn ("ANSI C++ forbids `typeof'"); ;
-    break;}
-case 292:
-#line 1834 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 293:
-#line 1836 "cp-parse.y"
-{ if (TREE_CHAIN (yyvsp[-1].ttype)) yyvsp[-1].ttype = combine_strings (yyvsp[-1].ttype); yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 294:
-#line 1841 "cp-parse.y"
-{ current_declspecs = yyvsp[-5].ttype;
-		  yyvsp[0].itype = suspend_momentary ();
-		  yyval.ttype = start_decl (yyvsp[-4].ttype, current_declspecs, 1, yyvsp[-3].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 295:
-#line 1847 "cp-parse.y"
-{ finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0);
-		  yyval.itype = yyvsp[-2].itype; ;
-    break;}
-case 296:
-#line 1850 "cp-parse.y"
-{ tree d;
-		  current_declspecs = yyvsp[-4].ttype;
-		  yyval.itype = suspend_momentary ();
-		  d = start_decl (yyvsp[-3].ttype, current_declspecs, 0, yyvsp[-2].ttype);
-		  cplus_decl_attributes (d, yyvsp[0].ttype);
-		  finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ;
-    break;}
-case 297:
-#line 1860 "cp-parse.y"
-{ yyval.ttype = start_decl (yyvsp[-4].ttype, current_declspecs, 1, yyvsp[-3].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 298:
-#line 1864 "cp-parse.y"
-{ finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); ;
-    break;}
-case 299:
-#line 1866 "cp-parse.y"
-{ tree d = start_decl (yyvsp[-3].ttype, current_declspecs, 0, yyvsp[-2].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype);
-		  finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ;
-    break;}
-case 300:
-#line 1873 "cp-parse.y"
-{ current_declspecs = yyvsp[-5].ttype;
-		  yyvsp[0].itype = suspend_momentary ();
-		  yyval.ttype = start_decl (yyvsp[-4].ttype, current_declspecs, 1, yyvsp[-3].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 301:
-#line 1879 "cp-parse.y"
-{ finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0);
-		  yyval.itype = yyvsp[-2].itype; ;
-    break;}
-case 302:
-#line 1882 "cp-parse.y"
-{ tree d;
-		  current_declspecs = yyvsp[-4].ttype;
-		  yyval.itype = suspend_momentary ();
-		  d = start_decl (yyvsp[-3].ttype, current_declspecs, 0, yyvsp[-2].ttype);
-		  cplus_decl_attributes (d, yyvsp[0].ttype);
-		  finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ;
-    break;}
-case 303:
-#line 1894 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 304:
-#line 1896 "cp-parse.y"
-{ yyval.ttype = yyvsp[-2].ttype; ;
-    break;}
-case 305:
-#line 1901 "cp-parse.y"
-{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
-    break;}
-case 306:
-#line 1903 "cp-parse.y"
-{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-2].ttype); ;
-    break;}
-case 307:
-#line 1908 "cp-parse.y"
-{ if (strcmp (IDENTIFIER_POINTER (yyvsp[0].ttype), "packed"))
-	    warning ("`%s' attribute directive ignored",
-		     IDENTIFIER_POINTER (yyvsp[0].ttype));
-	  yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 308:
-#line 1913 "cp-parse.y"
-{ /* if not "aligned(n)", then issue warning */
-	  if (strcmp (IDENTIFIER_POINTER (yyvsp[-3].ttype), "aligned") != 0
-	      || TREE_CODE (yyvsp[-1].ttype) != INTEGER_CST)
-	    {
-	      warning ("`%s' attribute directive ignored",
-		       IDENTIFIER_POINTER (yyvsp[-3].ttype));
-	      yyval.ttype = yyvsp[-3].ttype;
-	    }
-	  else
-	    yyval.ttype = tree_cons (yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE); ;
-    break;}
-case 309:
-#line 1924 "cp-parse.y"
-{ /* if not "format(...)", then issue warning */
-	  if (strcmp (IDENTIFIER_POINTER (yyvsp[-7].ttype), "format") != 0
-	      || TREE_CODE (yyvsp[-3].ttype) != INTEGER_CST
-	      || TREE_CODE (yyvsp[-1].ttype) != INTEGER_CST)
-	    {
-	      warning ("`%s' attribute directive ignored",
-		       IDENTIFIER_POINTER (yyvsp[-7].ttype));
-	      yyval.ttype = yyvsp[-7].ttype;
-	    }
-	  else
-	    yyval.ttype = tree_cons (yyvsp[-7].ttype, tree_cons (yyvsp[-5].ttype, tree_cons (yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE), NULL_TREE), NULL_TREE); ;
-    break;}
-case 310:
-#line 1940 "cp-parse.y"
-{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
-    break;}
-case 311:
-#line 1942 "cp-parse.y"
-{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
-    break;}
-case 313:
-#line 1948 "cp-parse.y"
-{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
-		  TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1;
-		  if (pedantic)
-		    pedwarn ("ANSI C++ forbids empty initializer braces"); ;
-    break;}
-case 314:
-#line 1953 "cp-parse.y"
-{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-1].ttype));
-		  TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ;
-    break;}
-case 315:
-#line 1956 "cp-parse.y"
-{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype));
-		  TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ;
-    break;}
-case 316:
-#line 1959 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 317:
-#line 1966 "cp-parse.y"
-{ yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 318:
-#line 1968 "cp-parse.y"
-{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 319:
-#line 1971 "cp-parse.y"
-{ yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 320:
-#line 1973 "cp-parse.y"
-{ yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 321:
-#line 1975 "cp-parse.y"
-{ yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 322:
-#line 1977 "cp-parse.y"
-{ yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 323:
-#line 1982 "cp-parse.y"
-{ yyvsp[0].itype = suspend_momentary ();
-		  yyval.ttype = start_enum (yyvsp[-1].ttype); ;
-    break;}
-case 324:
-#line 1985 "cp-parse.y"
-{ yyval.ttype = finish_enum (yyvsp[-3].ttype, yyvsp[-2].ttype);
-		  resume_momentary ((int) yyvsp[-4].itype);
-		  check_for_missing_semicolon (yyvsp[-3].ttype); ;
-    break;}
-case 325:
-#line 1989 "cp-parse.y"
-{ yyval.ttype = finish_enum (start_enum (yyvsp[-2].ttype), NULL_TREE);
-		  check_for_missing_semicolon (yyval.ttype); ;
-    break;}
-case 326:
-#line 1992 "cp-parse.y"
-{ yyvsp[0].itype = suspend_momentary ();
-		  yyval.ttype = start_enum (make_anon_name ()); ;
-    break;}
-case 327:
-#line 1995 "cp-parse.y"
-{ yyval.ttype = finish_enum (yyvsp[-3].ttype, yyvsp[-2].ttype);
-		  resume_momentary ((int) yyvsp[-5].itype);
-		  check_for_missing_semicolon (yyvsp[-3].ttype); ;
-    break;}
-case 328:
-#line 1999 "cp-parse.y"
-{ yyval.ttype = finish_enum (start_enum (make_anon_name()), NULL_TREE);
-		  check_for_missing_semicolon (yyval.ttype); ;
-    break;}
-case 329:
-#line 2002 "cp-parse.y"
-{ yyval.ttype = xref_tag (enum_type_node, yyvsp[0].ttype, NULL_TREE); ;
-    break;}
-case 330:
-#line 2006 "cp-parse.y"
-{
-		  int semi;
-		  tree id;
-
-#if 0
-		  /* Need to rework class nesting in the
-		     presence of nested classes, etc.  */
-		  shadow_tag (CLASSTYPE_AS_LIST (yyval.ttype)); */
-#endif
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  semi = yychar == ';';
-		  /* finish_struct nukes this anyway; if
-		     finish_exception does too, then it can go. */
-		  if (semi)
-		    note_got_semicolon (yyval.ttype);
-
-		  if (TREE_CODE (yyval.ttype) == ENUMERAL_TYPE)
-		    /* $$ = $1 from default rule.  */;
-		  else if (CLASSTYPE_DECLARED_EXCEPTION (yyval.ttype))
-		    {
-		      if (! semi)
-			yyval.ttype = finish_exception (yyval.ttype, yyvsp[-1].ttype);
-		      else
-			warning ("empty exception declaration\n");
-		    }
-		  else
-		    {
-		      yyval.ttype = finish_struct (yyval.ttype, yyvsp[-1].ttype, semi);
-		      if (semi) note_got_semicolon (yyval.ttype);
-		    }
-
-		  pop_obstacks ();
-
-		  id = TYPE_IDENTIFIER (yyval.ttype);
-		  if (IDENTIFIER_TEMPLATE (id))
-		    {
-		      tree decl;
-
-		      /* I don't know if the copying of this TYPE_DECL is
-		       * really needed.  However, it's such a small per-
-		       * formance penalty that the extra safety is a bargain.
-		       * - niklas@appli.se
-		       */
-		      push_obstacks (&permanent_obstack, &permanent_obstack);
-		      decl = copy_node (lookup_name (id, 0));
-		      if (DECL_LANG_SPECIFIC (decl))
-			copy_lang_decl (decl);
-		      pop_obstacks ();
-		      undo_template_name_overload (id, 0);
-		      pushdecl_top_level (decl);
-		    }
-		  if (! semi)
-		    check_for_missing_semicolon (yyval.ttype); ;
-    break;}
-case 331:
-#line 2061 "cp-parse.y"
-{
-#if 0
-  /* It's no longer clear what the following error is supposed to
-     accomplish.  If it turns out to be needed, add a comment why.  */
-		  if (TYPE_BINFO_BASETYPES (yyval.ttype) && !TYPE_SIZE (yyval.ttype))
-		    {
-		      error ("incomplete definition of type `%s'",
-			     TYPE_NAME_STRING (yyval.ttype));
-		      yyval.ttype = error_mark_node;
-		    }
-#endif
-		;
-    break;}
-case 335:
-#line 2083 "cp-parse.y"
-{ if (pedantic)
-		    pedwarn ("ANSI C++ forbids comma at end of enumerator list"); ;
-    break;}
-case 337:
-#line 2089 "cp-parse.y"
-{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
-    break;}
-case 338:
-#line 2091 "cp-parse.y"
-{ yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 339:
-#line 2093 "cp-parse.y"
-{ error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype));
-		;
-    break;}
-case 340:
-#line 2096 "cp-parse.y"
-{ error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype));
-		;
-    break;}
-case 341:
-#line 2099 "cp-parse.y"
-{ error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype));
-		;
-    break;}
-case 342:
-#line 2102 "cp-parse.y"
-{ error ("no body nor ';' separates two class, struct or union declarations");
-		;
-    break;}
-case 343:
-#line 2108 "cp-parse.y"
-{ aggr1: current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 344:
-#line 2110 "cp-parse.y"
-{ current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 345:
-#line 2112 "cp-parse.y"
-{ yyungetc (':', 1); goto aggr1; ;
-    break;}
-case 346:
-#line 2114 "cp-parse.y"
-{ yyungetc ('{', 1);
-		aggr2:
-		  current_aggr = yyval.ttype;
-		  yyval.ttype = yyvsp[-1].ttype;
-		  overload_template_name (yyval.ttype, 0); ;
-    break;}
-case 347:
-#line 2120 "cp-parse.y"
-{ yyungetc (':', 1); goto aggr2; ;
-    break;}
-case 348:
-#line 2125 "cp-parse.y"
-{ current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 349:
-#line 2130 "cp-parse.y"
-{
-		  yyval.ttype = xref_tag (current_aggr, yyvsp[0].ttype, NULL_TREE);
-		;
-    break;}
-case 350:
-#line 2134 "cp-parse.y"
-{
-		  if (yyvsp[0].ttype)
-		    yyval.ttype = xref_tag (current_aggr, yyvsp[-2].ttype, yyvsp[0].ttype);
-		  else
-		    yyval.ttype = yyvsp[-1].ttype;
-		;
-    break;}
-case 351:
-#line 2142 "cp-parse.y"
-{
-		  yyval.ttype = xref_defn_tag (current_aggr, yyvsp[0].ttype, NULL_TREE);
-		;
-    break;}
-case 352:
-#line 2146 "cp-parse.y"
-{
-		  if (yyvsp[0].ttype)
-		    yyval.ttype = xref_defn_tag (current_aggr, yyvsp[-2].ttype, yyvsp[0].ttype);
-		  else
-		    yyval.ttype = yyvsp[-1].ttype;
-		;
-    break;}
-case 353:
-#line 2155 "cp-parse.y"
-{ yyval.ttype = xref_tag (yyval.ttype, make_anon_name (), NULL_TREE);
-		  yyungetc ('{', 1); ;
-    break;}
-case 356:
-#line 2163 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 357:
-#line 2165 "cp-parse.y"
-{ yyungetc(':', 1); yyval.ttype = NULL_TREE; ;
-    break;}
-case 358:
-#line 2167 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 360:
-#line 2173 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 361:
-#line 2178 "cp-parse.y"
-{ if (! is_aggr_typedef (yyval.ttype, 1))
-		    yyval.ttype = NULL_TREE;
-		  else yyval.ttype = build_tree_list ((tree)visibility_default, yyval.ttype); ;
-    break;}
-case 362:
-#line 2182 "cp-parse.y"
-{ if (! is_aggr_typedef (yyval.ttype, 1))
-		    yyval.ttype = NULL_TREE;
-		  else yyval.ttype = build_tree_list ((tree)visibility_default, yyval.ttype); ;
-    break;}
-case 363:
-#line 2186 "cp-parse.y"
-{ if (! is_aggr_typedef (yyvsp[0].ttype, 1))
-		    yyval.ttype = NULL_TREE;
-		  else yyval.ttype = build_tree_list ((tree) yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 364:
-#line 2190 "cp-parse.y"
-{ if (! is_aggr_typedef (yyvsp[0].ttype, 1))
-		    yyval.ttype = NULL_TREE;
-		  else yyval.ttype = build_tree_list ((tree) yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 365:
-#line 2197 "cp-parse.y"
-{
-  		  /* Kludge!!! See rule "template_type" and the code
-		   * dealing with "template_type_seen_before_scope" in
-		   * yylex(). */
-  		  yyval.ttype = yyvsp[0].ttype;
-		;
-    break;}
-case 366:
-#line 2206 "cp-parse.y"
-{
-  		  extern tree template_type_seen_before_scope;
-		  tree id = yyvsp[0].ttype ? TYPE_IDENTIFIER (yyvsp[0].ttype) : yyvsp[-2].ttype;
-
-  		  /* Check the rule template_type to get this... */
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  if (yychar == SCOPE) {
-		    template_type_seen_before_scope = id;
-		    yychar = YYLEX;
-		  }
-		;
-    break;}
-case 369:
-#line 2224 "cp-parse.y"
-{ if (yyval.ttype != ridpointers[(int)RID_VIRTUAL])
-		    sorry ("non-virtual visibility");
-		  yyval.itype = visibility_default_virtual; ;
-    break;}
-case 370:
-#line 2228 "cp-parse.y"
-{ int err = 0;
-		  if (yyvsp[0].itype == visibility_protected)
-		    {
-		      warning ("`protected' visibility not implemented");
-		      yyvsp[0].itype = visibility_public;
-		      err++;
-		    }
-		  else if (yyvsp[0].itype == visibility_public)
-		    {
-		      if (yyvsp[-1].itype == visibility_private)
-			{
-			mixed:
-			  error ("base class cannot be public and private");
-			}
-		      else if (yyvsp[-1].itype == visibility_default_virtual)
-			yyval.itype = visibility_public_virtual;
-		    }
-		  else /* $2 == visibility_private */
-		    {
-		      if (yyvsp[-1].itype == visibility_public)
-			goto mixed;
-		      else if (yyvsp[-1].itype == visibility_default_virtual)
-			yyval.itype = visibility_private_virtual;
-		    }
-		;
-    break;}
-case 371:
-#line 2254 "cp-parse.y"
-{ if (yyvsp[0].ttype != ridpointers[(int)RID_VIRTUAL])
-		    sorry ("non-virtual visibility");
-		  if (yyval.itype == visibility_public)
-		    yyval.itype = visibility_public_virtual;
-		  else if (yyval.itype == visibility_private)
-		    yyval.itype = visibility_private_virtual; ;
-    break;}
-case 372:
-#line 2263 "cp-parse.y"
-{ tree t;
-		  push_obstacks_nochange ();
-		  end_temporary_allocation ();
-
-		  if (! IS_AGGR_TYPE (yyvsp[-1].ttype))
-		    {
-		      yyvsp[-1].ttype = make_lang_type (RECORD_TYPE);
-		      TYPE_NAME (yyvsp[-1].ttype) = get_identifier ("erroneous type");
-		    }
-		  if (TYPE_SIZE (yyvsp[-1].ttype))
-		    duplicate_tag_error (yyvsp[-1].ttype);
-                  if (TYPE_SIZE (yyvsp[-1].ttype) || TYPE_BEING_DEFINED (yyvsp[-1].ttype))
-                    {
-                      t = make_lang_type (TREE_CODE (yyvsp[-1].ttype));
-                      pushtag (TYPE_IDENTIFIER (yyvsp[-1].ttype), t);
-                      yyvsp[-1].ttype = t;
-                    }
-		  pushclass (yyvsp[-1].ttype, 0);
-		  TYPE_BEING_DEFINED (yyvsp[-1].ttype) = 1;
-		  t = TYPE_IDENTIFIER (yyvsp[-1].ttype);
-		  if (IDENTIFIER_TEMPLATE (t))
-		    overload_template_name (t, 1);
-		;
-    break;}
-case 373:
-#line 2290 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 374:
-#line 2292 "cp-parse.y"
-{ yyval.ttype = build_tree_list ((tree)visibility_default, yyval.ttype); ;
-    break;}
-case 375:
-#line 2294 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, build_tree_list ((tree) yyvsp[-2].itype, yyvsp[0].ttype)); ;
-    break;}
-case 377:
-#line 2300 "cp-parse.y"
-{ if (yyval.ttype == void_type_node) yyval.ttype = NULL_TREE; ;
-    break;}
-case 378:
-#line 2302 "cp-parse.y"
-{ if (yyvsp[0].ttype != NULL_TREE && yyvsp[0].ttype != void_type_node)
-		    yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 379:
-#line 2305 "cp-parse.y"
-{ if (pedantic)
-		    pedwarn ("ANSI C++ forbids extra semicolons here"); ;
-    break;}
-case 380:
-#line 2311 "cp-parse.y"
-{
-		do_components:
-		  if (yyvsp[-1].ttype == void_type_node)
-		    /* We just got some friends.
-		       They have been recorded elsewhere.  */
-		    yyval.ttype = NULL_TREE;
-		  else if (yyvsp[-1].ttype == NULL_TREE)
-		    {
-		      tree t = groktypename (build_decl_list (yyval.ttype, NULL_TREE));
-		      if (t == NULL_TREE)
-			{
-			  error ("error in component specification");
-			  yyval.ttype = NULL_TREE;
-			}
-		      else if (TREE_CODE (t) == UNION_TYPE)
-			{
-			  /* handle anonymous unions */
-			  if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
-			    yyval.ttype = build_lang_field_decl (FIELD_DECL,
-							NULL_TREE, t);
-			  else
-			    {
-			      /* This is a local union decl with a name, but
-				 no components, I think this is the right thing
-				 to do.  (mrs)  */
-#if 0
-			      /* I copied this from below, it is probably
-				 needed, but I cannot prove that to myself
-				 right now, but if you find it is needed
-				 please turn it on. (mrs)  */
-			      if (TYPE_LANG_SPECIFIC (t)
-				  && CLASSTYPE_DECLARED_EXCEPTION (t))
-				shadow_tag (yyval.ttype);
-#endif
-			      yyval.ttype = NULL_TREE;
-			    }
-			}
-		      else if (TREE_CODE (t) == ENUMERAL_TYPE)
-			yyval.ttype = grok_enum_decls (t, NULL_TREE);
-		      else if (TREE_CODE (t) == RECORD_TYPE)
-			{
-			  if (TYPE_LANG_SPECIFIC (t)
-			      && CLASSTYPE_DECLARED_EXCEPTION (t))
-			    shadow_tag (yyval.ttype);
-			  yyval.ttype = NULL_TREE;
-			}
-		      else if (t != void_type_node)
-			{
-			  error ("empty component declaration");
-			  yyval.ttype = NULL_TREE;
-			}
-		      else yyval.ttype = NULL_TREE;
-		    }
-		  else
-		    {
-		      tree t = TREE_TYPE (yyvsp[-1].ttype);
-		      if (TREE_CODE (t) == ENUMERAL_TYPE && TREE_NONLOCAL_FLAG (t))
-			yyval.ttype = grok_enum_decls (t, yyvsp[-1].ttype);
-		      else
-			yyval.ttype = yyvsp[-1].ttype;
-		    }
-		  end_exception_decls ();
-		;
-    break;}
-case 381:
-#line 2375 "cp-parse.y"
-{ yyval.ttype = groktypefield (yyval.ttype, yyvsp[-2].ttype); ;
-    break;}
-case 382:
-#line 2377 "cp-parse.y"
-{ error ("missing ';' before right brace");
-		  yyungetc ('}', 0);
-		  yyval.ttype = groktypefield (yyval.ttype, yyvsp[-2].ttype); ;
-    break;}
-case 383:
-#line 2381 "cp-parse.y"
-{ yyval.ttype = groktypefield (yyval.ttype, empty_parms ()); ;
-    break;}
-case 384:
-#line 2383 "cp-parse.y"
-{ error ("missing ';' before right brace");
-		  yyungetc ('}', 0);
-		  yyval.ttype = groktypefield (yyval.ttype, empty_parms ()); ;
-    break;}
-case 385:
-#line 2387 "cp-parse.y"
-{ goto do_components; ;
-    break;}
-case 386:
-#line 2390 "cp-parse.y"
-{ yyval.ttype = grokfield (yyvsp[-1].ttype, yyval.ttype,
-				  NULL_TREE, NULL_TREE, NULL_TREE); ;
-    break;}
-case 387:
-#line 2393 "cp-parse.y"
-{ error ("missing ';' before right brace");
-		  yyungetc ('}', 0);
-		  goto do_components; ;
-    break;}
-case 388:
-#line 2397 "cp-parse.y"
-{ yyval.ttype = groktypefield (yyval.ttype, yyvsp[-2].ttype); ;
-    break;}
-case 389:
-#line 2399 "cp-parse.y"
-{ error ("missing ';' before right brace");
-		  yyungetc ('}', 0);
-		  yyval.ttype = groktypefield (yyval.ttype, yyvsp[-2].ttype); ;
-    break;}
-case 390:
-#line 2403 "cp-parse.y"
-{ yyval.ttype = groktypefield (yyval.ttype, empty_parms ()); ;
-    break;}
-case 391:
-#line 2405 "cp-parse.y"
-{ error ("missing ';' before right brace");
-		  yyungetc ('}', 0);
-		  yyval.ttype = groktypefield (yyval.ttype, empty_parms ()); ;
-    break;}
-case 392:
-#line 2409 "cp-parse.y"
-{ yyval.ttype = grokbitfield (NULL_TREE, NULL_TREE, yyvsp[-1].ttype); ;
-    break;}
-case 393:
-#line 2411 "cp-parse.y"
-{ error ("missing ';' before right brace");
-		  yyungetc ('}', 0);
-		  yyval.ttype = grokbitfield (NULL_TREE, NULL_TREE, yyvsp[-1].ttype); ;
-    break;}
-case 394:
-#line 2415 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 395:
-#line 2420 "cp-parse.y"
-{ yyval.ttype = finish_method (yyval.ttype); ;
-    break;}
-case 396:
-#line 2422 "cp-parse.y"
-{ yyval.ttype = finish_method (yyval.ttype); ;
-    break;}
-case 397:
-#line 2424 "cp-parse.y"
-{ yyval.ttype = grokfield (yyval.ttype, NULL_TREE, yyvsp[-1].ttype, NULL_TREE, NULL_TREE); ;
-    break;}
-case 398:
-#line 2426 "cp-parse.y"
-{ error ("missing ';' before right brace");
-		  yyungetc ('}', 0);
-		  yyval.ttype = grokfield (yyval.ttype, NULL_TREE, yyvsp[-1].ttype, NULL_TREE, NULL_TREE); ;
-    break;}
-case 399:
-#line 2433 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 401:
-#line 2436 "cp-parse.y"
-{
-		  /* In this context, void_type_node encodes
-		     friends.  They have been recorded elsewhere.  */
-		  if (yyval.ttype == void_type_node)
-		    yyval.ttype = yyvsp[0].ttype;
-		  else
-		    yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype);
-		;
-    break;}
-case 402:
-#line 2448 "cp-parse.y"
-{ current_declspecs = yyvsp[-4].ttype;
-		  yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 403:
-#line 2452 "cp-parse.y"
-{ current_declspecs = yyvsp[-6].ttype;
-		  yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ;
-    break;}
-case 404:
-#line 2456 "cp-parse.y"
-{ current_declspecs = yyvsp[-4].ttype;
-		  yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 405:
-#line 2460 "cp-parse.y"
-{ current_declspecs = yyvsp[-3].ttype;
-		  yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 406:
-#line 2464 "cp-parse.y"
-{ current_declspecs = yyvsp[-2].ttype;
-		  yyval.ttype = grokbitfield (NULL_TREE, NULL_TREE, yyvsp[0].ttype); ;
-    break;}
-case 407:
-#line 2470 "cp-parse.y"
-{ yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 408:
-#line 2473 "cp-parse.y"
-{ yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ;
-    break;}
-case 409:
-#line 2476 "cp-parse.y"
-{ yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 410:
-#line 2479 "cp-parse.y"
-{ yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype);
-		  cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 411:
-#line 2482 "cp-parse.y"
-{ yyval.ttype = grokbitfield (NULL_TREE, NULL_TREE, yyvsp[0].ttype); ;
-    break;}
-case 413:
-#line 2492 "cp-parse.y"
-{ TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 414:
-#line 2497 "cp-parse.y"
-{ yyval.ttype = build_enumerator (yyval.ttype, NULL_TREE); ;
-    break;}
-case 415:
-#line 2499 "cp-parse.y"
-{ yyval.ttype = build_enumerator (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 416:
-#line 2504 "cp-parse.y"
-{ yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 417:
-#line 2506 "cp-parse.y"
-{ yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 418:
-#line 2511 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 420:
-#line 2514 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 421:
-#line 2519 "cp-parse.y"
-{ yyval.ttype = IDENTIFIER_AS_LIST (yyval.ttype); ;
-    break;}
-case 422:
-#line 2521 "cp-parse.y"
-{ yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 423:
-#line 2526 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 424:
-#line 2528 "cp-parse.y"
-{ yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 425:
-#line 2536 "cp-parse.y"
-{ yyval.itype = suspend_momentary (); ;
-    break;}
-case 426:
-#line 2537 "cp-parse.y"
-{ resume_momentary ((int) yyvsp[-1].itype); yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 427:
-#line 2543 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 428:
-#line 2545 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 429:
-#line 2547 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ;
-    break;}
-case 430:
-#line 2549 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, NULL_TREE, NULL_TREE); ;
-    break;}
-case 431:
-#line 2551 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 432:
-#line 2553 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ;
-    break;}
-case 433:
-#line 2555 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 434:
-#line 2557 "cp-parse.y"
-{ yyval.ttype = make_pointer_declarator (yyvsp[-2].ttype, yyvsp[-1].ttype); ;
-    break;}
-case 435:
-#line 2559 "cp-parse.y"
-{ see_typename (); ;
-    break;}
-case 437:
-#line 2562 "cp-parse.y"
-{ yyval.ttype = make_reference_declarator (yyvsp[-2].ttype, yyvsp[-1].ttype); ;
-    break;}
-case 438:
-#line 2564 "cp-parse.y"
-{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 439:
-#line 2566 "cp-parse.y"
-{ yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 441:
-#line 2572 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 442:
-#line 2574 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 443:
-#line 2576 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ;
-    break;}
-case 444:
-#line 2578 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, NULL_TREE, NULL_TREE); ;
-    break;}
-case 445:
-#line 2580 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 446:
-#line 2582 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ;
-    break;}
-case 447:
-#line 2584 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 448:
-#line 2586 "cp-parse.y"
-{ see_typename (); ;
-    break;}
-case 450:
-#line 2589 "cp-parse.y"
-{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 451:
-#line 2591 "cp-parse.y"
-{ yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 452:
-#line 2599 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 453:
-#line 2601 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 454:
-#line 2603 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ;
-    break;}
-case 455:
-#line 2605 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, NULL_TREE, NULL_TREE); ;
-    break;}
-case 456:
-#line 2607 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 457:
-#line 2609 "cp-parse.y"
-{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 458:
-#line 2611 "cp-parse.y"
-{ yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 459:
-#line 2613 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 460:
-#line 2615 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ;
-    break;}
-case 461:
-#line 2617 "cp-parse.y"
-{ see_typename (); ;
-    break;}
-case 462:
-#line 2621 "cp-parse.y"
-{ see_typename (); ;
-    break;}
-case 463:
-#line 2624 "cp-parse.y"
-{
-		destructor_name:
-		  see_typename ();
-		  yyval.ttype = build_parse_node (BIT_NOT_EXPR, yyvsp[0].ttype);
-		;
-    break;}
-case 464:
-#line 2630 "cp-parse.y"
-{ goto destructor_name; ;
-    break;}
-case 465:
-#line 2632 "cp-parse.y"
-{ goto destructor_name; ;
-    break;}
-case 466:
-#line 2634 "cp-parse.y"
-{ see_typename ();
-		  if (TREE_CODE (yyval.ttype) != SCOPE_REF)
-		    yyval.ttype = build_push_scope (yyval.ttype, yyvsp[0].ttype);
-		  else if (TREE_OPERAND (yyval.ttype, 1) == NULL_TREE)
-		    TREE_OPERAND (yyval.ttype, 1) = yyvsp[0].ttype;
-		  else
-		    yyval.ttype = build_parse_node (SCOPE_REF, yyval.ttype, yyvsp[0].ttype);
-		;
-    break;}
-case 467:
-#line 2643 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 468:
-#line 2645 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype)); ;
-    break;}
-case 469:
-#line 2647 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype)); ;
-    break;}
-case 470:
-#line 2649 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-2].ttype, empty_parms (), yyvsp[0].ttype)); ;
-    break;}
-case 471:
-#line 2651 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-4].ttype, NULL_TREE, NULL_TREE)); ;
-    break;}
-case 472:
-#line 2654 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 473:
-#line 2656 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype)); ;
-    break;}
-case 474:
-#line 2658 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype)); ;
-    break;}
-case 475:
-#line 2660 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-2].ttype, empty_parms (), yyvsp[0].ttype)); ;
-    break;}
-case 476:
-#line 2662 "cp-parse.y"
-{ yyval.ttype = build_push_scope (yyval.ttype, build_parse_node (CALL_EXPR, yyvsp[-4].ttype, NULL_TREE, NULL_TREE)); ;
-    break;}
-case 477:
-#line 2664 "cp-parse.y"
-{ yyval.ttype = build_parse_node (SCOPE_REF, NULL_TREE, yyvsp[0].ttype); ;
-    break;}
-case 478:
-#line 2668 "cp-parse.y"
-{ yyval.ttype = resolve_scope_to_name (NULL_TREE, yyval.ttype);
-		  if (yyval.ttype == NULL_TREE)
-		    {
-		      error ("undefined explicitly scoped type");
-		      yyval.ttype = error_mark_node; 
-		    }
-		;
-    break;}
-case 479:
-#line 2676 "cp-parse.y"
-{
-                  if (yyval.ttype == error_mark_node)
-                    /* leave it alone */;
-                  else
-		    {
-		      yyval.ttype = resolve_scope_to_name (NULL_TREE, TYPE_IDENTIFIER (yyval.ttype));
-		      if (yyval.ttype == NULL_TREE)
-			{
-			  error ("undefined explicitly scoped type");
-			  yyval.ttype = error_mark_node; 
-			}
-		    }
-/*                  if ($3) popclass (1); */
-		;
-    break;}
-case 482:
-#line 2697 "cp-parse.y"
-{
-  		  /* Kludge!!! See rule "template_type" and the code
-		   * dealing with "template_type_seen_before_scope" in
-		   * yylex(). */
-		  yyval.ttype = yyvsp[0].ttype;
-		;
-    break;}
-case 483:
-#line 2719 "cp-parse.y"
-{ see_typename ();
-		  yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 484:
-#line 2723 "cp-parse.y"
-{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 485:
-#line 2725 "cp-parse.y"
-{ yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ;
-    break;}
-case 486:
-#line 2727 "cp-parse.y"
-{ see_typename (); ;
-    break;}
-case 487:
-#line 2729 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 488:
-#line 2731 "cp-parse.y"
-{ yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 489:
-#line 2733 "cp-parse.y"
-{ yyval.ttype = make_reference_declarator (yyvsp[0].ttype, NULL_TREE); ;
-    break;}
-case 490:
-#line 2735 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 491:
-#line 2737 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ;
-    break;}
-case 492:
-#line 2739 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 493:
-#line 2741 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ;
-    break;}
-case 494:
-#line 2743 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, NULL_TREE, yyvsp[-2].ttype, yyvsp[0].ttype); ;
-    break;}
-case 495:
-#line 2745 "cp-parse.y"
-{ yyval.ttype = build_parse_node (CALL_EXPR, NULL_TREE, empty_parms (), yyvsp[0].ttype); ;
-    break;}
-case 496:
-#line 2747 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ;
-    break;}
-case 497:
-#line 2749 "cp-parse.y"
-{ yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, NULL_TREE); ;
-    break;}
-case 498:
-#line 2754 "cp-parse.y"
-{ tree t;
-		  t = yyval.ttype;
-		  while (TREE_OPERAND (t, 1))
-		    t = TREE_OPERAND (t, 1);
-		  TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, 0);
-		;
-    break;}
-case 499:
-#line 2761 "cp-parse.y"
-{ tree t;
-		  t = yyval.ttype;
-		  while (TREE_OPERAND (t, 1))
-		    t = TREE_OPERAND (t, 1);
-		  TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, yyvsp[0].ttype);
-		;
-    break;}
-case 500:
-#line 2768 "cp-parse.y"
-{ tree t;
-		  t = yyval.ttype;
-		  while (TREE_OPERAND (t, 1))
-		    t = TREE_OPERAND (t, 1);
-		  TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, 0);
-		;
-    break;}
-case 501:
-#line 2775 "cp-parse.y"
-{ tree t;
-		  t = yyval.ttype;
-		  while (TREE_OPERAND (t, 1))
-		    t = TREE_OPERAND (t, 1);
-		  TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, yyvsp[0].ttype);
-		;
-    break;}
-case 502:
-#line 2785 "cp-parse.y"
-{ tree t;
-		  t = yyval.ttype;
-		  while (TREE_OPERAND (t, 1))
-		    t = TREE_OPERAND (t, 1);
-		  TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, yyvsp[0].ttype);
-		;
-    break;}
-case 503:
-#line 2792 "cp-parse.y"
-{ tree t;
-		  t = yyval.ttype;
-		  while (TREE_OPERAND (t, 1))
-		    t = TREE_OPERAND (t, 1);
-		  TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, yyvsp[0].ttype);
-		;
-    break;}
-case 509:
-#line 2819 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  pushlevel (0);
-		  clear_last_expr ();
-		  push_momentary ();
-		  expand_start_bindings (0); ;
-    break;}
-case 511:
-#line 2831 "cp-parse.y"
-{ if (pedantic)
-		    pedwarn ("ANSI C++ forbids label declarations"); ;
-    break;}
-case 514:
-#line 2842 "cp-parse.y"
-{ tree link;
-		  for (link = yyvsp[-1].ttype; link; link = TREE_CHAIN (link))
-		    {
-		      tree label = shadow_label (TREE_VALUE (link));
-		      C_DECLARED_LABEL_FLAG (label) = 1;
-		      declare_nonlocal_label (label);
-		    }
-		;
-    break;}
-case 515:
-#line 2856 "cp-parse.y"
-{;
-    break;}
-case 517:
-#line 2861 "cp-parse.y"
-{ yyval.ttype = convert (void_type_node, integer_zero_node); ;
-    break;}
-case 518:
-#line 2863 "cp-parse.y"
-{ pop_implicit_try_blocks (NULL_TREE);
-		  expand_end_bindings (getdecls (), kept_level_p (), 1);
-		  yyval.ttype = poplevel (kept_level_p (), 1, 0);
-		  pop_momentary (); ;
-    break;}
-case 519:
-#line 2868 "cp-parse.y"
-{ pop_implicit_try_blocks (NULL_TREE);
-		  expand_end_bindings (getdecls (), kept_level_p (), 1);
-		  yyval.ttype = poplevel (kept_level_p (), 0, 0);
-		  pop_momentary (); ;
-    break;}
-case 520:
-#line 2876 "cp-parse.y"
-{ cond_stmt_keyword = "if"; ;
-    break;}
-case 521:
-#line 2878 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  expand_start_cond (truthvalue_conversion (yyvsp[0].ttype), 0); ;
-    break;}
-case 523:
-#line 2885 "cp-parse.y"
-{ finish_stmt (); ;
-    break;}
-case 524:
-#line 2887 "cp-parse.y"
-{ pop_implicit_try_blocks (NULL_TREE);
-		  expand_end_bindings (getdecls (), kept_level_p (), 1);
-		  yyval.ttype = poplevel (kept_level_p (), 1, 0);
-		  pop_momentary (); ;
-    break;}
-case 525:
-#line 2895 "cp-parse.y"
-{ finish_stmt (); ;
-    break;}
-case 527:
-#line 2901 "cp-parse.y"
-{ finish_stmt (); ;
-    break;}
-case 528:
-#line 2903 "cp-parse.y"
-{
-  		  tree expr = yyvsp[-1].ttype;
-		  emit_line_note (input_filename, lineno);
-		  /* Do default conversion if safe and possibly important,
-		     in case within ({...}).  */
-		  if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
-		       && lvalue_p (expr))
-		      || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
-		    expr = default_conversion (expr);
-		  cplus_expand_expr_stmt (expr);
-		  clear_momentary ();
-		  finish_stmt (); ;
-    break;}
-case 529:
-#line 2916 "cp-parse.y"
-{ expand_start_else (); ;
-    break;}
-case 530:
-#line 2918 "cp-parse.y"
-{ expand_end_cond ();
-		  finish_stmt (); ;
-    break;}
-case 531:
-#line 2921 "cp-parse.y"
-{ expand_end_cond ();
-		  finish_stmt (); ;
-    break;}
-case 532:
-#line 2924 "cp-parse.y"
-{ emit_nop ();
-		  emit_line_note (input_filename, lineno);
-		  expand_start_loop (1);
-		  cond_stmt_keyword = "while"; ;
-    break;}
-case 533:
-#line 2929 "cp-parse.y"
-{ expand_exit_loop_if_false (0, truthvalue_conversion (yyvsp[0].ttype)); ;
-    break;}
-case 534:
-#line 2931 "cp-parse.y"
-{ expand_end_loop ();
-		  finish_stmt (); ;
-    break;}
-case 535:
-#line 2934 "cp-parse.y"
-{ emit_nop ();
-		  emit_line_note (input_filename, lineno);
-		  expand_start_loop_continue_elsewhere (1); ;
-    break;}
-case 536:
-#line 2938 "cp-parse.y"
-{ expand_loop_continue_here ();
-		  cond_stmt_keyword = "do"; ;
-    break;}
-case 537:
-#line 2941 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  expand_exit_loop_if_false (0, truthvalue_conversion (yyvsp[-1].ttype));
-		  expand_end_loop ();
-		  clear_momentary ();
-		  finish_stmt (); ;
-    break;}
-case 538:
-#line 2947 "cp-parse.y"
-{ emit_nop ();
-		  emit_line_note (input_filename, lineno);
-		  if (yyvsp[0].ttype) cplus_expand_expr_stmt (yyvsp[0].ttype);
-		  expand_start_loop_continue_elsewhere (1); ;
-    break;}
-case 539:
-#line 2952 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  if (yyvsp[-1].ttype) expand_exit_loop_if_false (0, truthvalue_conversion (yyvsp[-1].ttype)); ;
-    break;}
-case 540:
-#line 2957 "cp-parse.y"
-{ push_momentary (); ;
-    break;}
-case 541:
-#line 2959 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  expand_loop_continue_here ();
-		  if (yyvsp[-3].ttype) cplus_expand_expr_stmt (yyvsp[-3].ttype);
-		  pop_momentary ();
-		  expand_end_loop ();
-		  finish_stmt (); ;
-    break;}
-case 542:
-#line 2966 "cp-parse.y"
-{ emit_nop ();
-		  emit_line_note (input_filename, lineno);
-		  expand_start_loop_continue_elsewhere (1); ;
-    break;}
-case 543:
-#line 2970 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  if (yyvsp[-1].ttype) expand_exit_loop_if_false (0, truthvalue_conversion (yyvsp[-1].ttype)); ;
-    break;}
-case 544:
-#line 2975 "cp-parse.y"
-{ push_momentary ();
-		  yyvsp[0].itype = lineno; ;
-    break;}
-case 545:
-#line 2978 "cp-parse.y"
-{ emit_line_note (input_filename, (int) yyvsp[-2].itype);
-		  expand_loop_continue_here ();
-		  if (yyvsp[-3].ttype) cplus_expand_expr_stmt (yyvsp[-3].ttype);
-		  pop_momentary ();
-		  expand_end_loop ();
-		  pop_implicit_try_blocks (NULL_TREE);
-		  if (yyvsp[-8].itype)
-		    {
-		      register int keep = yyvsp[-8].itype > 0;
-		      if (keep) expand_end_bindings (0, keep, 1);
-		      poplevel (keep, 1, 0);
-		      pop_momentary ();
-		    }
-		  finish_stmt ();
-		;
-    break;}
-case 546:
-#line 2994 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  c_expand_start_case (yyvsp[-1].ttype);
-		  /* Don't let the tree nodes for $3 be discarded by
-		     clear_momentary during the parsing of the next stmt.  */
-		  push_momentary (); ;
-    break;}
-case 547:
-#line 3000 "cp-parse.y"
-{ expand_end_case (yyvsp[-3].ttype);
-		  pop_momentary ();
-		  finish_stmt (); ;
-    break;}
-case 548:
-#line 3004 "cp-parse.y"
-{ register tree value = yyvsp[-1].ttype;
-		  register tree label
-		    = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
-
-		  /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
-		     Strip such NOP_EXPRs.  */
-		  if (TREE_CODE (value) == NOP_EXPR
-		      && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
-		    value = TREE_OPERAND (value, 0);
-
-		  if (TREE_READONLY_DECL_P (value))
-		    {
-		      value = decl_constant_value (value);
-		      /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
-			 Strip such NOP_EXPRs.  */
-		      if (TREE_CODE (value) == NOP_EXPR
-			  && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
-			value = TREE_OPERAND (value, 0);
-		    }
-		  value = fold (value);
-
-		  if (TREE_CODE (value) != INTEGER_CST
-		      && value != error_mark_node)
-		    {
-		      error ("case label does not reduce to an integer constant");
-		      value = error_mark_node;
-		    }
-		  else
-		    /* Promote char or short to int.  */
-		    value = default_conversion (value);
-		  if (value != error_mark_node)
-		    {
-		      tree duplicate;
-		      int success = pushcase (value, label, &duplicate);
-		      if (success == 1)
-			error ("case label not within a switch statement");
-		      else if (success == 2)
-			{
-			  error ("duplicate case value");
-			  error_with_decl (duplicate, "this is the first entry for that value");
-			}
-		      else if (success == 3)
-			warning ("case value out of range");
-		      else if (success == 5)
-			error ("case label within scope of cleanup or variable array");
-		    }
-		  define_case_label (label);
-		;
-    break;}
-case 550:
-#line 3054 "cp-parse.y"
-{ register tree value1 = yyvsp[-3].ttype;
-		  register tree value2 = yyvsp[-1].ttype;
-		  register tree label
-		    = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
-
-		  if (pedantic)
-		    pedwarn ("ANSI C++ forbids range expressions in switch statement");
-
-		  /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
-		     Strip such NOP_EXPRs.  */
-		  if (TREE_CODE (value1) == NOP_EXPR
-		      && TREE_TYPE (value1) == TREE_TYPE (TREE_OPERAND (value1, 0)))
-		    value1 = TREE_OPERAND (value1, 0);
-
-		  if (TREE_READONLY_DECL_P (value1))
-		    {
-		      value1 = decl_constant_value (value1);
-		      /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
-			 Strip such NOP_EXPRs.  */
-		      if (TREE_CODE (value1) == NOP_EXPR
-			  && TREE_TYPE (value1) == TREE_TYPE (TREE_OPERAND (value1, 0)))
-			value1 = TREE_OPERAND (value1, 0);
-		    }
-		  value1 = fold (value1);
-
-		  /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
-		     Strip such NOP_EXPRs.  */
-		  if (TREE_CODE (value2) == NOP_EXPR
-		      && TREE_TYPE (value2) == TREE_TYPE (TREE_OPERAND (value2, 0)))
-		    value2 = TREE_OPERAND (value2, 0);
-
-		  if (TREE_READONLY_DECL_P (value2))
-		    {
-		      value2 = decl_constant_value (value2);
-		      /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
-			 Strip such NOP_EXPRs.  */
-		      if (TREE_CODE (value2) == NOP_EXPR
-			  && TREE_TYPE (value2) == TREE_TYPE (TREE_OPERAND (value2, 0)))
-			value2 = TREE_OPERAND (value2, 0);
-		    }
-		  value2 = fold (value2);
-
-
-		  if (TREE_CODE (value1) != INTEGER_CST
-		      && value1 != error_mark_node)
-		    {
-		      error ("case label does not reduce to an integer constant");
-		      value1 = error_mark_node;
-		    }
-		  if (TREE_CODE (value2) != INTEGER_CST
-		      && value2 != error_mark_node)
-		    {
-		      error ("case label does not reduce to an integer constant");
-		      value2 = error_mark_node;
-		    }
-		  if (value1 != error_mark_node
-		      && value2 != error_mark_node)
-		    {
-		      tree duplicate;
-		      int success = pushcase_range (value1, value2, label,
-						    &duplicate);
-		      if (success == 1)
-			error ("case label not within a switch statement");
-		      else if (success == 2)
-			{
-			  error ("duplicate (or overlapping) case value");
-			  error_with_decl (duplicate, "this is the first entry overlapping that value");
-			}
-		      else if (success == 3)
-			warning ("case value out of range");
-		      else if (success == 4)
-			warning ("empty range specified");
-		      else if (success == 5)
-			error ("case label within scope of cleanup or variable array");
-		    }
-		  define_case_label (label);
-		;
-    break;}
-case 552:
-#line 3133 "cp-parse.y"
-{
-		  tree duplicate;
-		  register tree label
-		    = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
-		  int success = pushcase (NULL_TREE, label, &duplicate);
-		  if (success == 1)
-		    error ("default label not within a switch statement");
-		  else if (success == 2)
-		    {
-		      error ("multiple default labels in one switch");
-		      error_with_decl (duplicate, "this is the first default label");
-		    }
-		  define_case_label (NULL_TREE);
-		;
-    break;}
-case 554:
-#line 3149 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  if ( ! expand_exit_something ())
-		    error ("break statement not within loop or switch"); ;
-    break;}
-case 555:
-#line 3153 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  if (! expand_continue_loop (0))
-		    error ("continue statement not within a loop"); ;
-    break;}
-case 556:
-#line 3157 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  c_expand_return (NULL_TREE); ;
-    break;}
-case 557:
-#line 3160 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  c_expand_return (yyvsp[-1].ttype);
-		  finish_stmt ();
-		;
-    break;}
-case 558:
-#line 3165 "cp-parse.y"
-{ if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype);
-		  emit_line_note (input_filename, lineno);
-		  expand_asm (yyvsp[-2].ttype);
-		  finish_stmt ();
-		;
-    break;}
-case 559:
-#line 3172 "cp-parse.y"
-{ if (TREE_CHAIN (yyvsp[-4].ttype)) yyvsp[-4].ttype = combine_strings (yyvsp[-4].ttype);
-		  emit_line_note (input_filename, lineno);
-		  c_expand_asm_operands (yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE, NULL_TREE,
-					 yyvsp[-6].ttype == ridpointers[(int)RID_VOLATILE],
-					 input_filename, lineno);
-		  finish_stmt ();
-		;
-    break;}
-case 560:
-#line 3181 "cp-parse.y"
-{ if (TREE_CHAIN (yyvsp[-6].ttype)) yyvsp[-6].ttype = combine_strings (yyvsp[-6].ttype);
-		  emit_line_note (input_filename, lineno);
-		  c_expand_asm_operands (yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE,
-					 yyvsp[-8].ttype == ridpointers[(int)RID_VOLATILE],
-					 input_filename, lineno);
-		  finish_stmt ();
-		;
-    break;}
-case 561:
-#line 3191 "cp-parse.y"
-{ if (TREE_CHAIN (yyvsp[-8].ttype)) yyvsp[-8].ttype = combine_strings (yyvsp[-8].ttype);
-		  emit_line_note (input_filename, lineno);
-		  c_expand_asm_operands (yyvsp[-8].ttype, yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype,
-					 yyvsp[-10].ttype == ridpointers[(int)RID_VOLATILE],
-					 input_filename, lineno);
-		  finish_stmt ();
-		;
-    break;}
-case 562:
-#line 3199 "cp-parse.y"
-{ emit_line_note (input_filename, lineno);
-		  expand_computed_goto (yyvsp[-1].ttype); ;
-    break;}
-case 563:
-#line 3202 "cp-parse.y"
-{ tree decl;
-		  emit_line_note (input_filename, lineno);
-		  decl = lookup_label (yyvsp[-1].ttype);
-		  TREE_USED (decl) = 1;
-		  expand_goto (decl); ;
-    break;}
-case 564:
-#line 3208 "cp-parse.y"
-{ finish_stmt (); ;
-    break;}
-case 565:
-#line 3210 "cp-parse.y"
-{ error ("label must be followed by statement");
-		  yyungetc ('}', 0);
-		  finish_stmt (); ;
-    break;}
-case 566:
-#line 3214 "cp-parse.y"
-{ finish_stmt (); ;
-    break;}
-case 567:
-#line 3217 "cp-parse.y"
-{ cplus_expand_throw (NULL_TREE); ;
-    break;}
-case 568:
-#line 3218 "cp-parse.y"
-{ cplus_expand_throw (yyvsp[-1].ttype); ;
-    break;}
-case 569:
-#line 3220 "cp-parse.y"
-{ cplus_expand_raise (yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE, 0);
-		  finish_stmt (); ;
-    break;}
-case 570:
-#line 3223 "cp-parse.y"
-{ cplus_expand_raise (yyvsp[-2].ttype, NULL_TREE, NULL_TREE, 0);
-		  finish_stmt (); ;
-    break;}
-case 571:
-#line 3226 "cp-parse.y"
-{ cplus_expand_raise (yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE, 0);
-		  finish_stmt (); ;
-    break;}
-case 572:
-#line 3229 "cp-parse.y"
-{ cplus_expand_raise (yyvsp[-2].ttype, NULL_TREE, NULL_TREE, 0);
-		  finish_stmt (); ;
-    break;}
-case 573:
-#line 3232 "cp-parse.y"
-{ cplus_expand_reraise (yyvsp[-1].ttype);
-		  finish_stmt (); ;
-    break;}
-case 574:
-#line 3235 "cp-parse.y"
-{
-		  tree decl = cplus_expand_end_try (yyvsp[-3].itype);
-		  yyvsp[-2].ttype = current_exception_type;
-		  yyvsp[0].ttype = current_exception_decl;
-		  yyval.ttype = current_exception_object;
-		  cplus_expand_start_except (yyvsp[-1].ttype, decl);
-		  pushlevel (0);
-		  clear_last_expr ();
-		  push_momentary ();
-		  expand_start_bindings (0);
-		;
-    break;}
-case 575:
-#line 3247 "cp-parse.y"
-{
-		  tree decls = getdecls ();
-		  /* If there is a default exception to handle,
-		     handle it here.  */
-		  if (yyvsp[-1].ttype)
-		    {
-		      tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0);
-		      tree block;
-
-		      pushlevel (1);
-		      expand_start_bindings (0);
-		      expand_expr (yyvsp[-1].ttype, 0, 0, 0);
-		      expand_end_bindings (0, 1, 0);
-		      block = poplevel (1, 0, 0);
-
-		      /* This is a catch block.  */
-		      TREE_LANG_FLAG_2 (block) = 1;
-		      BLOCK_VARS (block) = decl;
-		    }
-
-		  expand_end_bindings (decls, decls != 0, 1);
-		  poplevel (decls != 0, 1, 0);
-		  pop_momentary ();
-		  current_exception_type = yyvsp[-5].ttype;
-		  current_exception_decl = yyvsp[-3].ttype;
-		  current_exception_object = yyvsp[-2].ttype;
-		  cplus_expand_end_except (yyvsp[-1].ttype);
-		;
-    break;}
-case 576:
-#line 3276 "cp-parse.y"
-{
-		  cplus_expand_end_try (yyvsp[-1].itype);
-		  /* These are the important actions of
-		     `cplus_expand_end_except' which we must emulate.  */
-		  if (expand_escape_except ())
-		    expand_end_except ();
-		  expand_end_bindings (0, 0, 1);
-		  poplevel (0, 0, 0);
-		;
-    break;}
-case 577:
-#line 3286 "cp-parse.y"
-{
-		  tree decl = cplus_expand_end_try (yyvsp[-2].itype);
-		  yyvsp[-1].ttype = current_exception_type;
-		  yyvsp[0].ttype = current_exception_decl;
-		  yyval.ttype = current_exception_object;
-		  cplus_expand_start_except (NULL, decl);
-		  pushlevel (0);
-		  clear_last_expr ();
-		  push_momentary ();
-		  expand_start_bindings (0);
-		;
-    break;}
-case 578:
-#line 3298 "cp-parse.y"
-{
-		  tree decls = getdecls ();
-		  /* If there is a default exception to handle,
-		     handle it here.  */
-		  if (yyvsp[0].ttype)
-		    {
-		      tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0);
-		      tree block;
-
-		      pushlevel (1);
-		      expand_start_bindings (0);
-		      expand_expr (yyvsp[0].ttype, 0, 0, 0);
-		      expand_end_bindings (0, 1, 0);
-		      block = poplevel (1, 0, 0);
-
-		      /* This is a catch block.  */
-		      TREE_LANG_FLAG_2 (block) = 1;
-		      BLOCK_VARS (block) = decl;
-		    }
-
-		  expand_end_bindings (decls, decls != 0, 1);
-		  poplevel (decls != 0, 1, 0);
-		  pop_momentary ();
-		  current_exception_type = yyvsp[-3].ttype;
-		  current_exception_decl = yyvsp[-2].ttype;
-		  current_exception_object = yyvsp[-1].ttype;
-		  cplus_expand_end_except (yyvsp[0].ttype);
-		;
-    break;}
-case 579:
-#line 3327 "cp-parse.y"
-{ tree name = get_identifier ("(compiler error)");
-		  tree orig_ex_type = current_exception_type;
-		  tree orig_ex_decl = current_exception_decl;
-		  tree orig_ex_obj = current_exception_object;
-		  tree decl = cplus_expand_end_try (yyvsp[-2].itype), decls;
-
-		  /* Start hidden EXCEPT.  */
-		  cplus_expand_start_except (name, decl);
-		  pushlevel (0);
-		  clear_last_expr ();
-		  push_momentary ();
-		  expand_start_bindings (0);
-
-		  /* This sets up the reraise.  */
-		  cplus_expand_reraise (yyvsp[0].ttype);
-
-		  decls = getdecls ();
-		  expand_end_bindings (decls, decls != 0, 1);
-		  poplevel (decls != 0, 1, 0);
-		  pop_momentary ();
-		  current_exception_type = orig_ex_type;
-		  current_exception_decl = orig_ex_decl;
-		  current_exception_object = orig_ex_obj;
-		  /* This will reraise for us.  */
-		  cplus_expand_end_except (error_mark_node);
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  if (yychar != ';')
-		    error ("missing ';' after reraise statement");
-		;
-    break;}
-case 580:
-#line 3358 "cp-parse.y"
-{ yyerror ("`except' missing after `try' statement");
-		  /* Terminate the binding contour started by special
-		     code in `.pushlevel'.  Automagically pops off
-		     the conditional we started for `try' stmt.  */
-		  cplus_expand_end_try (yyvsp[0].itype);
-		  expand_end_bindings (0, 0, 1);
-		  poplevel (0, 0, 0);
-		  pop_momentary ();
-		  YYERROR; ;
-    break;}
-case 581:
-#line 3373 "cp-parse.y"
-{
-		  yyval.itype = 1;
-		  pop_implicit_try_blocks (NULL_TREE);
-		;
-    break;}
-case 582:
-#line 3378 "cp-parse.y"
-{
-		  yyval.itype = 1;
-		  pop_implicit_try_blocks (NULL_TREE);
-		;
-    break;}
-case 583:
-#line 3383 "cp-parse.y"
-{
-		  yyval.itype = 0;
-		  pop_implicit_try_blocks (NULL_TREE);
-		;
-    break;}
-case 584:
-#line 3391 "cp-parse.y"
-{ tree label;
-		do_label:
-		  label = define_label (input_filename, lineno, yyvsp[-1].ttype);
-		  if (label)
-		    expand_label (label);
-		;
-    break;}
-case 585:
-#line 3398 "cp-parse.y"
-{ goto do_label; ;
-    break;}
-case 586:
-#line 3400 "cp-parse.y"
-{ tree label = define_label (input_filename, lineno, yyvsp[0].ttype);
-		  if (label)
-		    expand_label (label);
-		;
-    break;}
-case 587:
-#line 3406 "cp-parse.y"
-{ cplus_expand_start_try (0); ;
-    break;}
-case 589:
-#line 3412 "cp-parse.y"
-{
-		  yyval.itype = 1;
-		  pop_implicit_try_blocks (NULL_TREE);
-		;
-    break;}
-case 590:
-#line 3417 "cp-parse.y"
-{
-		  yyval.itype = 1;
-		  pop_implicit_try_blocks (NULL_TREE);
-		;
-    break;}
-case 591:
-#line 3422 "cp-parse.y"
-{
-		  yyval.itype = 0;
-		  pop_implicit_try_blocks (NULL_TREE);
-		;
-    break;}
-case 593:
-#line 3429 "cp-parse.y"
-{ cplus_expand_start_try (0); ;
-    break;}
-case 595:
-#line 3433 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 596:
-#line 3435 "cp-parse.y"
-{
-		  tree type = lookup_exception_type (current_class_type, current_class_name, yyvsp[0].ttype);
-		  if (type == NULL_TREE)
-		    {
-		      error ("`%s' is not an exception type",
-			     IDENTIFIER_POINTER (TREE_VALUE (yyvsp[0].ttype)));
-		      current_exception_type = NULL_TREE;
-		      TREE_TYPE (current_exception_object) = error_mark_node;
-		    }
-		  else
-		    {
-		      current_exception_type = type;
-		      /* In-place union.  */
-		      TREE_TYPE (current_exception_object) = type;
-		    }
-		  yyvsp[0].ttype = cplus_expand_start_catch (yyvsp[0].ttype);
-		  pushlevel (1);
-		  expand_start_bindings (0);
-		;
-    break;}
-case 597:
-#line 3455 "cp-parse.y"
-{
-		  expand_end_bindings (0, 1, 0);
-		  yyvsp[0].ttype = poplevel (1, 0, 0);
-
-		  cplus_expand_end_catch (0);
-
-		  /* Mark this as a catch block.  */
-		  TREE_LANG_FLAG_2 (yyvsp[0].ttype) = 1;
-		  if (yyvsp[-2].ttype != error_mark_node)
-		    {
-		      tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME (yyvsp[-2].ttype), 0);
-		      DECL_RTL (decl) = DECL_RTL (yyvsp[-2].ttype);
-		      TREE_CHAIN (decl) = BLOCK_VARS (yyvsp[0].ttype);
-		      BLOCK_VARS (yyvsp[0].ttype) = decl;
-		    }
-		;
-    break;}
-case 598:
-#line 3472 "cp-parse.y"
-{
-		  if (yyvsp[-1].ttype)
-		    error ("duplicate default in exception handler");
-		  current_exception_type = NULL_TREE;
-		  /* Takes it right out of scope.  */
-		  TREE_TYPE (current_exception_object) = error_mark_node;
-
-		  if (! expand_catch_default ())
-		    compiler_error ("default catch botch");
-
-		  /* The default exception is handled as the
-		     last in the chain of exceptions handled.  */
-		  do_pending_stack_adjust ();
-		  start_sequence ();
-		  yyvsp[-1].ttype = make_node (RTL_EXPR);
-		  TREE_TYPE (yyvsp[-1].ttype) = void_type_node;
-		;
-    break;}
-case 599:
-#line 3490 "cp-parse.y"
-{
-		  extern struct rtx_def *get_insns ();
-		  do_pending_stack_adjust ();
-		  if (! expand_catch (NULL_TREE))
-		    compiler_error ("except nesting botch");
-		  if (! expand_end_catch ())
-		    compiler_error ("except nesting botch");
-		  RTL_EXPR_SEQUENCE (yyvsp[-3].ttype) = get_insns ();
-		  if (yyvsp[0].ttype)
-		    {
-		      /* Mark this block as the default catch block.  */
-		      TREE_LANG_FLAG_1 (yyvsp[0].ttype) = 1;
-		      TREE_LANG_FLAG_2 (yyvsp[0].ttype) = 1;
-		    }
-		  end_sequence ();
-		;
-    break;}
-case 600:
-#line 3510 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 602:
-#line 3515 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 603:
-#line 3517 "cp-parse.y"
-{
-		  tree type = groktypename (yyvsp[-2].ttype);
-		  current_exception_type = type;
-		  /* In-place union.  */
-		  if (yyvsp[-1].ttype)
-		    {
-		      tree tmp;
-		      tmp = pushdecl (build_decl (VAR_DECL, yyvsp[-1].ttype, type));
-		      current_exception_object =
-		          build1 (INDIRECT_REF, type, tmp);
-		     }
-		  yyvsp[-2].ttype = ansi_expand_start_catch(type);
-		  pushlevel (1);
-		  expand_start_bindings (0);
-		;
-    break;}
-case 604:
-#line 3533 "cp-parse.y"
-{
-		  expand_end_bindings (0, 1, 0);
-		  yyvsp[0].ttype = poplevel (1, 0, 0);
-
-		  cplus_expand_end_catch (0);
-
-		  /* Mark this as a catch block.  */
-		  TREE_LANG_FLAG_2 (yyvsp[0].ttype) = 1;
-		  if (yyvsp[-4].ttype != error_mark_node)
-		    {
-		      tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME (yyvsp[-4].ttype), 0);
-		      DECL_RTL (decl) = DECL_RTL (yyvsp[-4].ttype);
-		      TREE_CHAIN (decl) = BLOCK_VARS (yyvsp[0].ttype);
-		      BLOCK_VARS (yyvsp[0].ttype) = decl;
-		    }
-		;
-    break;}
-case 605:
-#line 3553 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 606:
-#line 3555 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 607:
-#line 3557 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 608:
-#line 3562 "cp-parse.y"
-{ yyval.itype = 0; ;
-    break;}
-case 609:
-#line 3564 "cp-parse.y"
-{ yyval.itype = 0; ;
-    break;}
-case 610:
-#line 3566 "cp-parse.y"
-{ yyval.itype = 1; ;
-    break;}
-case 611:
-#line 3568 "cp-parse.y"
-{ yyval.itype = -1; ;
-    break;}
-case 612:
-#line 3575 "cp-parse.y"
-{ emit_line_note (input_filename, lineno); ;
-    break;}
-case 613:
-#line 3577 "cp-parse.y"
-{ emit_line_note (input_filename, lineno); ;
-    break;}
-case 614:
-#line 3582 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 616:
-#line 3585 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 617:
-#line 3591 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 620:
-#line 3598 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 621:
-#line 3603 "cp-parse.y"
-{ yyval.ttype = build_tree_list (yyval.ttype, yyvsp[-1].ttype); ;
-    break;}
-case 622:
-#line 3608 "cp-parse.y"
-{ yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, NULL_TREE); ;
-    break;}
-case 623:
-#line 3610 "cp-parse.y"
-{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 624:
-#line 3619 "cp-parse.y"
-{
-		  if (strict_prototype)
-		    yyval.ttype = void_list_node;
-		  else
-		    yyval.ttype = NULL_TREE;
-		;
-    break;}
-case 625:
-#line 3626 "cp-parse.y"
-{
-		  yyval.ttype = chainon (yyval.ttype, void_list_node);
-		  TREE_PARMLIST (yyval.ttype) = 1;
-		;
-    break;}
-case 626:
-#line 3631 "cp-parse.y"
-{
-		  TREE_PARMLIST (yyval.ttype) = 1;
-		;
-    break;}
-case 627:
-#line 3636 "cp-parse.y"
-{
-		  TREE_PARMLIST (yyval.ttype) = 1;
-		;
-    break;}
-case 628:
-#line 3640 "cp-parse.y"
-{
-		  /* ARM $8.2.5 has this as a boxed-off comment.  */
-		  if (pedantic)
-		    warning ("use of `...' without a first argument is non-portable");
-		  yyval.ttype = NULL_TREE;
-		;
-    break;}
-case 629:
-#line 3647 "cp-parse.y"
-{
-		  TREE_PARMLIST (yyval.ttype) = 1;
-		;
-    break;}
-case 630:
-#line 3651 "cp-parse.y"
-{
-		  TREE_PARMLIST (yyval.ttype) = 1;
-		;
-    break;}
-case 631:
-#line 3655 "cp-parse.y"
-{
-		  /* This helps us recover from really nasty
-		     parse errors, for example, a missing right
-		     parenthesis.  */
-		  yyerror ("possibly missing ')'");
-		  yyval.ttype = chainon (yyval.ttype, void_list_node);
-		  TREE_PARMLIST (yyval.ttype) = 1;
-		  yyungetc (':', 0);
-		  yychar = ')';
-		;
-    break;}
-case 632:
-#line 3670 "cp-parse.y"
-{ yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 633:
-#line 3672 "cp-parse.y"
-{ yyval.ttype = build_tree_list (yyvsp[0].ttype, yyval.ttype); ;
-    break;}
-case 634:
-#line 3674 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
-    break;}
-case 635:
-#line 3676 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, build_tree_list (yyvsp[0].ttype, yyvsp[-2].ttype)); ;
-    break;}
-case 636:
-#line 3678 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
-    break;}
-case 637:
-#line 3680 "cp-parse.y"
-{ yyval.ttype = chainon (yyval.ttype, build_tree_list (yyvsp[0].ttype, yyvsp[-2].ttype)); ;
-    break;}
-case 638:
-#line 3701 "cp-parse.y"
-{ yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype);
-		  see_typename (); ;
-    break;}
-case 639:
-#line 3704 "cp-parse.y"
-{ yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype);
-		  see_typename (); ;
-    break;}
-case 642:
-#line 3711 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 643:
-#line 3715 "cp-parse.y"
-{ see_typename (); ;
-    break;}
-case 644:
-#line 3719 "cp-parse.y"
-{ dont_see_typename (); ;
-    break;}
-case 645:
-#line 3738 "cp-parse.y"
-{
-		  warning ("type specifier omitted for parameter");
-		  yyval.ttype = build_tree_list (TREE_PURPOSE (TREE_VALUE (yyvsp[-2].ttype)), yyval.ttype);
-		;
-    break;}
-case 646:
-#line 3746 "cp-parse.y"
-{ yyval.ttype = NULL_TREE; ;
-    break;}
-case 647:
-#line 3748 "cp-parse.y"
-{ yyval.ttype = yyvsp[0].ttype; ;
-    break;}
-case 648:
-#line 3750 "cp-parse.y"
-{ yyval.ttype = yyvsp[-1].ttype; ;
-    break;}
-case 649:
-#line 3755 "cp-parse.y"
-{ yyval.ttype = void_list_node; ;
-    break;}
-case 650:
-#line 3757 "cp-parse.y"
-{ yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 651:
-#line 3759 "cp-parse.y"
-{ yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 652:
-#line 3761 "cp-parse.y"
-{ yyval.ttype = build_decl_list (void_type_node, yyvsp[0].ttype); ;
-    break;}
-case 653:
-#line 3763 "cp-parse.y"
-{ yyval.ttype = build_decl_list (void_type_node, yyvsp[0].ttype); ;
-    break;}
-case 654:
-#line 3765 "cp-parse.y"
-{ yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ;
-    break;}
-case 656:
-#line 3771 "cp-parse.y"
-{ yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ;
-    break;}
-case 658:
-#line 3777 "cp-parse.y"
-{
-  		  TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype;
-		  yyval.ttype = yyvsp[0].ttype;
-		;
-    break;}
-case 660:
-#line 3786 "cp-parse.y"
-{
-  		  TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype;
-		  yyval.ttype = yyvsp[0].ttype;
-		;
-    break;}
-case 661:
-#line 3794 "cp-parse.y"
-{ yyval.ttype = ansi_opname[MULT_EXPR]; ;
-    break;}
-case 662:
-#line 3796 "cp-parse.y"
-{ yyval.ttype = ansi_opname[TRUNC_DIV_EXPR]; ;
-    break;}
-case 663:
-#line 3798 "cp-parse.y"
-{ yyval.ttype = ansi_opname[TRUNC_MOD_EXPR]; ;
-    break;}
-case 664:
-#line 3800 "cp-parse.y"
-{ yyval.ttype = ansi_opname[PLUS_EXPR]; ;
-    break;}
-case 665:
-#line 3802 "cp-parse.y"
-{ yyval.ttype = ansi_opname[MINUS_EXPR]; ;
-    break;}
-case 666:
-#line 3804 "cp-parse.y"
-{ yyval.ttype = ansi_opname[BIT_AND_EXPR]; ;
-    break;}
-case 667:
-#line 3806 "cp-parse.y"
-{ yyval.ttype = ansi_opname[BIT_IOR_EXPR]; ;
-    break;}
-case 668:
-#line 3808 "cp-parse.y"
-{ yyval.ttype = ansi_opname[BIT_XOR_EXPR]; ;
-    break;}
-case 669:
-#line 3810 "cp-parse.y"
-{ yyval.ttype = ansi_opname[BIT_NOT_EXPR]; ;
-    break;}
-case 670:
-#line 3812 "cp-parse.y"
-{ yyval.ttype = ansi_opname[COMPOUND_EXPR]; ;
-    break;}
-case 671:
-#line 3814 "cp-parse.y"
-{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
-    break;}
-case 672:
-#line 3816 "cp-parse.y"
-{ yyval.ttype = ansi_opname[LT_EXPR]; ;
-    break;}
-case 673:
-#line 3818 "cp-parse.y"
-{ yyval.ttype = ansi_opname[GT_EXPR]; ;
-    break;}
-case 674:
-#line 3820 "cp-parse.y"
-{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
-    break;}
-case 675:
-#line 3822 "cp-parse.y"
-{ yyval.ttype = ansi_assopname[yyvsp[0].code]; ;
-    break;}
-case 676:
-#line 3824 "cp-parse.y"
-{
-		  yyval.ttype = ansi_opname [MODIFY_EXPR];
-		  if (current_class_type)
-		    {
-		      TYPE_HAS_ASSIGNMENT (current_class_type) = 1;
-		      TYPE_GETS_ASSIGNMENT (current_class_type) = 1;
-		    }
-		;
-    break;}
-case 677:
-#line 3833 "cp-parse.y"
-{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
-    break;}
-case 678:
-#line 3835 "cp-parse.y"
-{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
-    break;}
-case 679:
-#line 3837 "cp-parse.y"
-{ yyval.ttype = ansi_opname[POSTINCREMENT_EXPR]; ;
-    break;}
-case 680:
-#line 3839 "cp-parse.y"
-{ yyval.ttype = ansi_opname[PREDECREMENT_EXPR]; ;
-    break;}
-case 681:
-#line 3841 "cp-parse.y"
-{ yyval.ttype = ansi_opname[TRUTH_ANDIF_EXPR]; ;
-    break;}
-case 682:
-#line 3843 "cp-parse.y"
-{ yyval.ttype = ansi_opname[TRUTH_ORIF_EXPR]; ;
-    break;}
-case 683:
-#line 3845 "cp-parse.y"
-{ yyval.ttype = ansi_opname[TRUTH_NOT_EXPR]; ;
-    break;}
-case 684:
-#line 3847 "cp-parse.y"
-{ yyval.ttype = ansi_opname[COND_EXPR]; ;
-    break;}
-case 685:
-#line 3849 "cp-parse.y"
-{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
-    break;}
-case 686:
-#line 3851 "cp-parse.y"
-{ yyval.ttype = ansi_opname[COMPONENT_REF];
-		  if (current_class_type)
-		    {
-		      tree t = current_class_type;
-		      while (t)
-			{
-			  TYPE_OVERLOADS_ARROW (t) = 1;
-			  t = TYPE_NEXT_VARIANT (t);
-			}
-		    }
-		;
-    break;}
-case 687:
-#line 3863 "cp-parse.y"
-{ yyval.ttype = ansi_opname[MEMBER_REF];
-		  if (current_class_type)
-		    {
-		      tree t = current_class_type;
-		      while (t)
-			{
-			  TYPE_OVERLOADS_ARROW (t) = 1;
-			  t = TYPE_NEXT_VARIANT (t);
-			}
-		    }
-		;
-    break;}
-case 688:
-#line 3875 "cp-parse.y"
-{
-		  if (yychar == YYEMPTY)
-		    yychar = YYLEX;
-		  if (yychar == '(' || yychar == LEFT_RIGHT)
-		    {
-		      yyval.ttype = ansi_opname[METHOD_CALL_EXPR];
-		      if (current_class_type)
-			{
-			  tree t = current_class_type;
-			  while (t)
-			    {
-			      TYPE_OVERLOADS_METHOD_CALL_EXPR (t) = 1;
-			      t = TYPE_NEXT_VARIANT (t);
-			    }
-			}
-		    }
-		  else
-		    {
-		      yyval.ttype = build_parse_node (CALL_EXPR, ansi_opname[COMPONENT_REF], void_list_node, yyvsp[0].ttype);
-		      if (current_class_type)
-			{
-			  tree t = current_class_type;
-			  while (t)
-			    {
-			      TYPE_OVERLOADS_ARROW (t) = 1;
-			      t = TYPE_NEXT_VARIANT (t);
-			    }
-			}
-		    }
-		;
-    break;}
-case 689:
-#line 3906 "cp-parse.y"
-{ yyval.ttype = ansi_opname[CALL_EXPR];
-		  if (current_class_type)
-		    {
-		      tree t = current_class_type;
-		      while (t)
-			{
-			  TYPE_OVERLOADS_CALL_EXPR (t) = 1;
-			  t = TYPE_NEXT_VARIANT (t);
-			}
-		    }
-		;
-    break;}
-case 690:
-#line 3918 "cp-parse.y"
-{ yyval.ttype = ansi_opname[ARRAY_REF];
-		  if (current_class_type)
-		    {
-		      tree t = current_class_type;
-		      while (t)
-			{
-			  TYPE_OVERLOADS_ARRAY_REF (t) = 1;
-			  t = TYPE_NEXT_VARIANT (t);
-			}
-		    }
-		;
-    break;}
-case 691:
-#line 3930 "cp-parse.y"
-{
-		  yyval.ttype = ansi_opname[NEW_EXPR];
-		  if (current_class_type)
-		    {
-		      tree t = current_class_type;
-		      while (t)
-			{
-			  TREE_GETS_NEW (t) = 1;
-			  t = TYPE_NEXT_VARIANT (t);
-			}
-		    }
-		;
-    break;}
-case 692:
-#line 3943 "cp-parse.y"
-{
-		  yyval.ttype = ansi_opname[DELETE_EXPR];
-		  if (current_class_type)
-		    {
-		      tree t = current_class_type;
-		      while (t)
-			{
-			  TREE_GETS_DELETE (t) = 1;
-			  t = TYPE_NEXT_VARIANT (t);
-			}
-		    }
-		;
-    break;}
-case 693:
-#line 3959 "cp-parse.y"
-{ yyval.ttype = build1 (TYPE_EXPR, yyvsp[-1].ttype, yyvsp[0].ttype); ;
-    break;}
-case 694:
-#line 3961 "cp-parse.y"
-{ yyval.ttype = ansi_opname[ERROR_MARK]; ;
-    break;}
-}
-   /* the action file gets copied in in place of this dollarsign */
-#line 440 "bison.simple"
-
-  yyvsp -= yylen;
-  yyssp -= yylen;
-#ifdef YYLSP_NEEDED
-  yylsp -= yylen;
-#endif
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "state stack now");
-      while (ssp1 != yyssp)
-	fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
-    }
-#endif
-
-  *++yyvsp = yyval;
-
-#ifdef YYLSP_NEEDED
-  yylsp++;
-  if (yylen == 0)
-    {
-      yylsp->first_line = yylloc.first_line;
-      yylsp->first_column = yylloc.first_column;
-      yylsp->last_line = (yylsp-1)->last_line;
-      yylsp->last_column = (yylsp-1)->last_column;
-      yylsp->text = 0;
-    }
-  else
-    {
-      yylsp->last_line = (yylsp+yylen-1)->last_line;
-      yylsp->last_column = (yylsp+yylen-1)->last_column;
-    }
-#endif
-
-  /* Now "shift" the result of the reduction.
-     Determine what state that goes to,
-     based on the state we popped back to
-     and the rule number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
-  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTBASE];
-
-  goto yynewstate;
-
-yyerrlab:   /* here on detecting error */
-
-  if (! yyerrstatus)
-    /* If not already recovering from an error, report this error.  */
-    {
-      ++yynerrs;
-
-#ifdef YYERROR_VERBOSE
-      yyn = yypact[yystate];
-
-      if (yyn > YYFLAG && yyn < YYLAST)
-	{
-	  int size = 0;
-	  char *msg;
-	  int x, count;
-
-	  count = 0;
-	  for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
-	    if (yycheck[x + yyn] == x)
-	      size += strlen(yytname[x]) + 15, count++;
-	  msg = (char *) malloc(size + 15);
-	  if (msg != 0)
-	    {
-	      strcpy(msg, "parse error");
-
-	      if (count < 5)
-		{
-		  count = 0;
-		  for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
-		    if (yycheck[x + yyn] == x)
-		      {
-			strcat(msg, count == 0 ? ", expecting `" : " or `");
-			strcat(msg, yytname[x]);
-			strcat(msg, "'");
-			count++;
-		      }
-		}
-	      yyerror(msg);
-	      free(msg);
-	    }
-	  else
-	    yyerror ("parse error; also virtual memory exceeded");
-	}
-      else
-#endif /* YYERROR_VERBOSE */
-	yyerror("parse error");
-    }
-
-yyerrlab1:   /* here on error raised explicitly by an action */
-
-  if (yyerrstatus == 3)
-    {
-      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
-
-      /* return failure if at end of input */
-      if (yychar == YYEOF)
-	YYABORT;
-
-#if YYDEBUG != 0
-      if (yydebug)
-	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
-#endif
-
-      yychar = YYEMPTY;
-    }
-
-  /* Else will try to reuse lookahead token
-     after shifting the error token.  */
-
-  yyerrstatus = 3;		/* Each real token shifted decrements this */
-
-  goto yyerrhandle;
-
-yyerrdefault:  /* current state does not do anything special for the error token. */
-
-#if 0
-  /* This is wrong; only states that explicitly want error tokens
-     should shift them.  */
-  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
-  if (yyn) goto yydefault;
-#endif
-
-yyerrpop:   /* pop the current state because it cannot handle the error token */
-
-  if (yyssp == yyss) YYABORT;
-  yyvsp--;
-  yystate = *--yyssp;
-#ifdef YYLSP_NEEDED
-  yylsp--;
-#endif
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "Error: state stack now");
-      while (ssp1 != yyssp)
-	fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
-    }
-#endif
-
-yyerrhandle:
-
-  yyn = yypact[yystate];
-  if (yyn == YYFLAG)
-    goto yyerrdefault;
-
-  yyn += YYTERROR;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
-    goto yyerrdefault;
-
-  yyn = yytable[yyn];
-  if (yyn < 0)
-    {
-      if (yyn == YYFLAG)
-	goto yyerrpop;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-  else if (yyn == 0)
-    goto yyerrpop;
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting error token, ");
-#endif
-
-  *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
-
-  yystate = yyn;
-  goto yynewstate;
-}
-#line 3964 "cp-parse.y"
-
-
-tree
-get_current_declspecs ()
-{
-  return current_declspecs;
-}
diff --git a/gnu/gcc2/cc1plus/cp-parse.h b/gnu/gcc2/cc1plus/cp-parse.h
deleted file mode 100644
index 87ea2b8de0f0..000000000000
--- a/gnu/gcc2/cc1plus/cp-parse.h
+++ /dev/null
@@ -1,88 +0,0 @@
-typedef union {long itype; tree ttype; char *strtype; enum tree_code code; } YYSTYPE;
-#define	IDENTIFIER	258
-#define	TYPENAME	259
-#define	SCOPED_TYPENAME	260
-#define	SCSPEC	261
-#define	TYPESPEC	262
-#define	TYPE_QUAL	263
-#define	CONSTANT	264
-#define	STRING	265
-#define	ELLIPSIS	266
-#define	SIZEOF	267
-#define	ENUM	268
-#define	IF	269
-#define	ELSE	270
-#define	WHILE	271
-#define	DO	272
-#define	FOR	273
-#define	SWITCH	274
-#define	CASE	275
-#define	DEFAULT	276
-#define	BREAK	277
-#define	CONTINUE	278
-#define	RETURN	279
-#define	GOTO	280
-#define	ASM_KEYWORD	281
-#define	GCC_ASM_KEYWORD	282
-#define	TYPEOF	283
-#define	ALIGNOF	284
-#define	HEADOF	285
-#define	CLASSOF	286
-#define	ATTRIBUTE	287
-#define	EXTENSION	288
-#define	LABEL	289
-#define	AGGR	290
-#define	VISSPEC	291
-#define	DELETE	292
-#define	NEW	293
-#define	OVERLOAD	294
-#define	THIS	295
-#define	OPERATOR	296
-#define	DYNAMIC	297
-#define	POINTSAT_LEFT_RIGHT	298
-#define	LEFT_RIGHT	299
-#define	TEMPLATE	300
-#define	SCOPE	301
-#define	START_DECLARATOR	302
-#define	EMPTY	303
-#define	TYPENAME_COLON	304
-#define	ASSIGN	305
-#define	RANGE	306
-#define	OROR	307
-#define	ANDAND	308
-#define	MIN_MAX	309
-#define	EQCOMPARE	310
-#define	ARITHCOMPARE	311
-#define	LSHIFT	312
-#define	RSHIFT	313
-#define	UNARY	314
-#define	PLUSPLUS	315
-#define	MINUSMINUS	316
-#define	HYPERUNARY	317
-#define	PAREN_STAR_PAREN	318
-#define	POINTSAT	319
-#define	POINTSAT_STAR	320
-#define	DOT_STAR	321
-#define	RAISE	322
-#define	RAISES	323
-#define	RERAISE	324
-#define	TRY	325
-#define	EXCEPT	326
-#define	CATCH	327
-#define	THROW	328
-#define	ANSI_TRY	329
-#define	ANSI_THROW	330
-#define	TYPENAME_ELLIPSIS	331
-#define	PTYPENAME	332
-#define	PRE_PARSED_FUNCTION_DECL	333
-#define	EXTERN_LANG_STRING	334
-#define	ALL	335
-#define	PRE_PARSED_CLASS_DECL	336
-#define	TYPENAME_DEFN	337
-#define	IDENTIFIER_DEFN	338
-#define	PTYPENAME_DEFN	339
-#define	END_OF_SAVED_INPUT	340
-
-
-extern YYSTYPE yylval;
-#define YYEMPTY		-2
diff --git a/gnu/gcc2/cc1plus/cp-pt.c b/gnu/gcc2/cc1plus/cp-pt.c
deleted file mode 100644
index 75e39677eb74..000000000000
--- a/gnu/gcc2/cc1plus/cp-pt.c
+++ /dev/null
@@ -1,2123 +0,0 @@
-/* Handle parameterized types (templates) for GNU C++.
-   Copyright (C) 1992, 1993 Free Software Foundation, Inc.
-   Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
-
-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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* Known bugs or deficiencies include:
-   * templates for class static data don't work (methods only)
-   * duplicated method templates can crash the compiler
-   * interface/impl data is taken from file defining the template
-   * all methods must be provided in header files; can't use a source
-     file that contains only the method templates and "just win"
-   * method templates must be seen before the expansion of the
-     class template is done
- */
-
-#include "config.h"
-#include <stdio.h>
-#include "obstack.h"
-
-#include "tree.h"
-#include "cp-tree.h"
-#include "cp-decl.h"
-#include "cp-parse.h"
-
-extern struct obstack permanent_obstack;
-extern tree grokdeclarator ();
-
-extern int lineno;
-extern char *input_filename;
-struct pending_inline *pending_template_expansions;
-
-int processing_template_decl;
-int processing_template_defn;
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-static int unify ();
-static void add_pending_template ();
-
-void overload_template_name (), pop_template_decls ();
-
-/* We've got a template header coming up; set obstacks up to save the
-   nodes created permanently.  (There might be cases with nested templates
-   where we don't have to do this, but they aren't implemented, and it
-   probably wouldn't be worth the effort.)  */
-void
-begin_template_parm_list ()
-{
-  pushlevel (0);
-  push_obstacks (&permanent_obstack, &permanent_obstack);
-}
-
-/* Process information from new template parameter NEXT and append it to the
-   LIST being built.  The rules for use of a template parameter type name
-   by later parameters are not well-defined for us just yet.  However, the
-   only way to avoid having to parse expressions of unknown complexity (and
-   with tokens of unknown types) is to disallow it completely.	So for now,
-   that is what is assumed.  */
-tree
-process_template_parm (list, next)
-     tree list, next;
-{
-  tree parm;
-  int is_type;
-  parm = next;
-  my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);
-  is_type = TREE_CODE (TREE_PURPOSE (parm)) == IDENTIFIER_NODE;
-  if (!is_type)
-    {
-      parm = TREE_PURPOSE (parm);
-      my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 260);
-      parm = TREE_VALUE (parm);
-      /* is a const-param */
-      parm = grokdeclarator (TREE_VALUE (next), TREE_PURPOSE (next),
-			     NORMAL, 0, NULL_TREE);
-      /* A template parameter is not modifiable.  */
-      TREE_READONLY (parm) = 1;
-      if (TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE
-	  || TREE_CODE (TREE_TYPE (parm)) == UNION_TYPE)
-	{
-	  sorry ("aggregate template parameter types");
-	  TREE_TYPE (parm) = void_type_node;
-	}
-    }
-  return chainon (list, parm);
-}
-
-/* The end of a template parameter list has been reached.  Process the
-   tree list into a parameter vector, converting each parameter into a more
-   useful form.	 Type parameters are saved as IDENTIFIER_NODEs, and others
-   as PARM_DECLs.  */
-
-tree
-end_template_parm_list (parms)
-     tree parms;
-{
-  int nparms = 0;
-  tree saved_parmlist;
-  tree parm;
-  for (parm = parms; parm; parm = TREE_CHAIN (parm))
-    nparms++;
-  saved_parmlist = make_tree_vec (nparms);
-
-  pushlevel (0);
-
-  for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++)
-    {
-      tree p = parm, decl;
-      if (TREE_CODE (p) == TREE_LIST)
-	{
-	  tree t;
-	  p = TREE_PURPOSE (p);
-	  my_friendly_assert (TREE_CODE (p) == IDENTIFIER_NODE, 261);
-	  t = make_node (TEMPLATE_TYPE_PARM);
-	  TEMPLATE_TYPE_SET_INFO (t, saved_parmlist, nparms);
-	  decl = build_lang_decl (TYPE_DECL, p, t);
-	  TYPE_NAME (t) = decl;
-	}
-      else
-	{
-	  tree tinfo = make_node (TEMPLATE_CONST_PARM);
-	  my_friendly_assert (TREE_PERMANENT (tinfo), 262);
-	  if (!TREE_PERMANENT (p))
-	    {
-	      tree old_p = p;
-	      TREE_PERMANENT (old_p) = 1;
-	      p = copy_node (p);
-	      TREE_PERMANENT (old_p) = 0;
-	    }
-	  TEMPLATE_CONST_SET_INFO (tinfo, saved_parmlist, nparms);
-	  TREE_TYPE (tinfo) = TREE_TYPE (p);
-	  decl = build_decl (CONST_DECL, DECL_NAME (p), TREE_TYPE (p));
-	  DECL_INITIAL (decl) = tinfo;
-	}
-      TREE_VEC_ELT (saved_parmlist, nparms) = p;
-      pushdecl (decl);
-    }
-  set_current_level_tags_transparency (1);
-  processing_template_decl++;
-  return saved_parmlist;
-}
-
-/* end_template_decl is called after a template declaration is seen.
-   D1 is template header; D2 is class_head_sans_basetype or a
-   TEMPLATE_DECL with its DECL_RESULT field set.  */
-void
-end_template_decl (d1, d2, is_class)
-     tree d1, d2, is_class;
-{
-  tree decl;
-  struct template_info *tmpl;
-
-  tmpl = (struct template_info *) obstack_alloc (&permanent_obstack,
-					    sizeof (struct template_info));
-  tmpl->text = 0;
-  tmpl->length = 0;
-  tmpl->aggr = is_class;
-
-  /* cloned from reinit_parse_for_template */
-  tmpl->filename = input_filename;
-  tmpl->lineno = lineno;
-  tmpl->parm_vec = d1;          /* [eichin:19911015.2306EST] */
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "end_template_decl");
-  debug_bindings_indentation += 4;
-#endif
-
-  if (d2 == NULL_TREE || d2 == error_mark_node)
-    {
-      decl = 0;
-      goto lose;
-    }
-
-  if (is_class)
-    {
-      decl = build_lang_decl (TEMPLATE_DECL, d2, NULL_TREE);
-    }
-  else
-    {
-      if (TREE_CODE (d2) == TEMPLATE_DECL)
-	decl = d2;
-      else
-	{
-	  /* Class destructor templates and operator templates are
-	     slipping past as non-template nodes.  Process them here, since
-	     I haven't figured out where to catch them earlier.  I could
-	     go do that, but it's a choice between getting that done and
-	     staying only N months behind schedule.  Sorry....  */
-	  enum tree_code code;
-	  my_friendly_assert (TREE_CODE (d2) == CALL_EXPR, 263);
-	  code = TREE_CODE (TREE_OPERAND (d2, 0));
-	  my_friendly_assert (code == BIT_NOT_EXPR
-		  || code == OP_IDENTIFIER
-		  || code == SCOPE_REF, 264);
-	  d2 = grokdeclarator (d2, NULL_TREE, MEMFUNCDEF, 0, NULL_TREE);
-	  decl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (d2),
-				  TREE_TYPE (d2));
-	  DECL_TEMPLATE_RESULT (decl) = d2;
-	  DECL_CONTEXT (decl) = DECL_CONTEXT (d2);
-	  DECL_CLASS_CONTEXT (decl) = DECL_CLASS_CONTEXT (d2);
-	  DECL_NAME (decl) = DECL_NAME (d2);
-	  TREE_TYPE (decl) = TREE_TYPE (d2);
-	  TREE_PUBLIC (decl) = TREE_PUBLIC (d2) = 0;
-	  DECL_EXTERNAL (decl) = (DECL_EXTERNAL (d2)
-				  && !(DECL_CLASS_CONTEXT (d2)
-				       && !DECL_THIS_EXTERN (d2)));
-	}
-
-      /* All routines creating TEMPLATE_DECL nodes should now be using
-	 build_lang_decl, which will have set this up already.	*/
-      my_friendly_assert (DECL_LANG_SPECIFIC (decl) != 0, 265);
-
-      /* @@ Somewhere, permanent allocation isn't being used.  */
-      if (! DECL_TEMPLATE_IS_CLASS (decl)
-	  && TREE_CODE (DECL_TEMPLATE_RESULT (decl)) == FUNCTION_DECL)
-	{
-	  tree result = DECL_TEMPLATE_RESULT (decl);
-	  /* Will do nothing if allocation was already permanent.  */
-	  DECL_ARGUMENTS (result) = copy_to_permanent (DECL_ARGUMENTS (result));
-	}
-
-      /* If this is for a method, there's an extra binding level here.	*/
-      if (! DECL_TEMPLATE_IS_CLASS (decl)
-	  && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
-	{
-	  /* @@ Find out where this should be getting set!  */
-	  tree r = DECL_TEMPLATE_RESULT (decl);
-	  if (DECL_CLASS_CONTEXT (r) == NULL_TREE)
-	    DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r);
-	}
-    }
-  DECL_TEMPLATE_INFO (decl) = tmpl;
-  DECL_TEMPLATE_PARMS (decl) = d1;
-lose:
-  if (decl)
-    {
-      /* If context of decl is non-null (i.e., method template), add it
-	 to the appropriate class template, and pop the binding levels.  */
-      if (! DECL_TEMPLATE_IS_CLASS (decl)
-	  && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
-	{
-	  tree ctx = DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl));
-	  tree tmpl;
-	  my_friendly_assert (TREE_CODE (ctx) == UNINSTANTIATED_P_TYPE, 266);
-	  tmpl = UPT_TEMPLATE (ctx);
-	  DECL_TEMPLATE_MEMBERS (tmpl) =
-	    perm_tree_cons (DECL_NAME (decl), decl,
-			    DECL_TEMPLATE_MEMBERS (tmpl));
-	  poplevel (0, 0, 0);
-	  poplevel (0, 0, 0);
-	}
-      /* Otherwise, go back to top level first, and push the template decl
-	 again there.  */
-      else
-	{
-	  poplevel (0, 0, 0);
-	  poplevel (0, 0, 0);
-	  if (TREE_TYPE (decl)
-	      && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl)) != NULL_TREE)
-	    push_overloaded_decl (decl, 0);
-	  else
-	    pushdecl (decl);
-	}
-    }
-#if 0 /* It happens sometimes, with syntactic or semantic errors.
-
-	 One specific case:
-	 template <class A, int X, int Y> class Foo { ... };
-	 template <class A, int X, int y> Foo<X,Y>::method (Foo& x) { ... }
-	 Note the missing "A" in the class containing "method".  */
-  my_friendly_assert (global_bindings_p (), 267);
-#else
-  while (! global_bindings_p ())
-    poplevel (0, 0, 0);
-#endif
-  pop_obstacks ();
-  processing_template_decl--;
-  (void) get_pending_sizes ();
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-
-/* Convert all template arguments to their appropriate types, and return
-   a vector containing the resulting values.  If any error occurs, return
-   error_mark_node.  */
-static tree
-coerce_template_parms (parms, arglist, in_decl)
-     tree parms, arglist;
-     tree in_decl;
-{
-  int nparms, i, lost = 0;
-  tree vec;
-
-  if (TREE_CODE (arglist) == TREE_VEC)
-    nparms = TREE_VEC_LENGTH (arglist);
-  else
-    nparms = list_length (arglist);
-  if (nparms != TREE_VEC_LENGTH (parms))
-    {
-      error ("incorrect number of parameters (%d, should be %d)",
-	     nparms, TREE_VEC_LENGTH (parms));
-      if (in_decl)
-	error_with_decl (in_decl, "in template expansion for decl `%s'");
-      return error_mark_node;
-    }
-
-  if (TREE_CODE (arglist) == TREE_VEC)
-    vec = copy_node (arglist);
-  else
-    {
-      vec = make_tree_vec (nparms);
-      for (i = 0; i < nparms; i++)
-	{
-	  tree arg = arglist;
-	  arglist = TREE_CHAIN (arglist);
-	  if (arg == error_mark_node)
-	    lost++;
-	  else
-	    arg = TREE_VALUE (arg);
-	  TREE_VEC_ELT (vec, i) = arg;
-	}
-    }
-  for (i = 0; i < nparms; i++)
-    {
-      tree arg = TREE_VEC_ELT (vec, i);
-      tree parm = TREE_VEC_ELT (parms, i);
-      tree val;
-      int is_type, requires_type;
-
-      is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't';
-      requires_type = TREE_CODE (parm) == IDENTIFIER_NODE;
-      if (is_type != requires_type)
-	{
-	  if (in_decl)
-	    error_with_decl (in_decl,
-			     "type/value mismatch in template parameter list for `%s'");
-	  lost++;
-	  TREE_VEC_ELT (vec, i) = error_mark_node;
-	  continue;
-	}
-      if (is_type)
-	val = groktypename (arg);
-      else
-	val = digest_init (TREE_TYPE (parm), arg, (tree *) 0);
-
-      if (val == error_mark_node)
-	lost++;
-
-      TREE_VEC_ELT (vec, i) = val;
-    }
-  if (lost)
-    return error_mark_node;
-  return vec;
-}
-
-/* Given class template name and parameter list, produce a user-friendly name
-   for the instantiation.  Note that this name isn't necessarily valid as
-   input to the compiler, because ">" characters may be adjacent.  */
-static char *
-mangle_class_name_for_template (name, parms, arglist)
-     char *name;
-     tree parms, arglist;
-{
-  static struct obstack scratch_obstack;
-  static char *scratch_firstobj;
-  int i, nparms;
-  char ibuf[100];
-
-  if (!scratch_firstobj)
-    {
-      gcc_obstack_init (&scratch_obstack);
-      scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
-    }
-  else
-    obstack_free (&scratch_obstack, scratch_firstobj);
-
-#if 0
-#define buflen	sizeof(buf)
-#define check	if (bufp >= buf+buflen-1) goto too_long
-#define ccat(c) *bufp++=(c); check
-#define advance	bufp+=strlen(bufp); check
-#define cat(s)	strncpy(bufp, s, buf+buflen-bufp-1); advance
-#else
-#define check
-#define ccat(c)	obstack_1grow (&scratch_obstack, (c));
-#define advance
-#define cat(s)	obstack_grow (&scratch_obstack, (s), strlen (s))
-#endif
-#define icat(n)	sprintf(ibuf,"%d",(n)); cat(ibuf)
-#define xcat(n)	sprintf(ibuf,"%ux",n); cat(ibuf)
-
-  cat (name);
-  ccat ('<');
-  nparms = TREE_VEC_LENGTH (parms);
-  my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268);
-  for (i = 0; i < nparms; i++)
-    {
-      tree parm = TREE_VEC_ELT (parms, i), arg = TREE_VEC_ELT (arglist, i);
-      tree type, id;
-
-      if (i)
-	ccat (',');
-
-      if (TREE_CODE (parm) == IDENTIFIER_NODE)
-	{
-	  /* parm is a type */
-	  char *typename;
-
-	  if (TYPE_NAME (arg)
-	      && (TREE_CODE (arg) == RECORD_TYPE
-		  || TREE_CODE (arg) == UNION_TYPE
-		  || TREE_CODE (arg) == ENUMERAL_TYPE)
-	      && TYPE_IDENTIFIER (arg)
-	      && IDENTIFIER_POINTER (TYPE_IDENTIFIER (arg)))
-	    typename = IDENTIFIER_POINTER (TYPE_IDENTIFIER (arg));
-	  else
-	    typename = type_as_string (arg);
-	  cat (typename);
-	  continue;
-	}
-      else
-	my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
-
-      /* Should do conversions as for "const" initializers.  */
-      type = TREE_TYPE (parm);
-      id = DECL_NAME (parm);
-	
-      if (TREE_CODE (arg) == TREE_LIST)
-	{
-	  /* New list cell was built because old chain link was in
-	     use.  */
-	  my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270);
-	  arg = TREE_VALUE (arg);
-	}
-      
-      switch (TREE_CODE (type))
-	{
-	case INTEGER_TYPE:
-	case ENUMERAL_TYPE:
-	  if (TREE_CODE (arg) == INTEGER_CST)
-	    {
-	      if (TREE_INT_CST_HIGH (arg)
-		  != (TREE_INT_CST_LOW (arg) >> (HOST_BITS_PER_WIDE_INT - 1)))
-		{
-		  tree val = arg;
-		  if (TREE_INT_CST_HIGH (val) < 0)
-		    {
-		      ccat ('-');
-		      val = build_int_2 (~TREE_INT_CST_LOW (val),
-					 -TREE_INT_CST_HIGH (val));
-		    }
-		  /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
-		     systems?  */
-		  {
-		    static char format[10]; /* "%x%09999x\0" */
-		    if (!format[0])
-		      sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
-		    sprintf (ibuf, format, TREE_INT_CST_HIGH (val),
-			     TREE_INT_CST_LOW (val));
-		    cat (ibuf);
-		  }
-		}
-	      else
-		icat (TREE_INT_CST_LOW (arg));
-	    }
-	  else
-	    {
-	      error ("invalid integer constant for template parameter");
-	      cat ("*error*");
-	    }
-	  break;
-#ifndef REAL_IS_NOT_DOUBLE
-	case REAL_TYPE:
-	  sprintf (ibuf, "%e", TREE_REAL_CST (arg));
-	  cat (ibuf);
-	  break;
-#endif
-	case POINTER_TYPE:
-	  if (TREE_CODE (arg) != ADDR_EXPR)
-	    {
-	      error ("invalid pointer constant for template parameter");
-	      cat ("*error*");
-	      break;
-	    }
-	  ccat ('&');
-	  arg = TREE_OPERAND (arg, 0);
-	  if (TREE_CODE (arg) == FUNCTION_DECL)
-	    cat (fndecl_as_string (0, arg, 0));
-	  else
-	    {
-	      my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd',
-				  271);
-	      cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
-	    }
-	  break;
-	default:
-	  sorry ("encoding %s as template parm",
-		 tree_code_name [(int) TREE_CODE (type)]);
-	  my_friendly_abort (81);
-	}
-    }
-  {
-    char *bufp = obstack_next_free (&scratch_obstack);
-    int offset = 0;
-    while (bufp[offset - 1] == ' ')
-      offset--;
-    obstack_blank_fast (&scratch_obstack, offset);
-  }
-  ccat ('>');
-  ccat ('\0');
-  return (char *) obstack_base (&scratch_obstack);
-
- too_long:
-  fatal ("out of (preallocated) string space creating template instantiation name");
-  /* NOTREACHED */
-  return NULL;
-}
-
-/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
-   parameters, find the desired type.
-
-   D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
-   Since ARGLIST is build on the decl_obstack, we must copy it here
-   to keep it from being reclaimed when the decl storage is reclaimed.
-
-   IN_DECL, if non-NULL, is the template declaration we are trying to
-   instantiate.  */
-tree
-lookup_template_class (d1, arglist, in_decl)
-     tree d1, arglist;
-     tree in_decl;
-{
-  tree template, parmlist;
-  char *mangled_name;
-  tree id;
-
-  my_friendly_assert (TREE_CODE (d1) == IDENTIFIER_NODE, 272);
-  template = IDENTIFIER_GLOBAL_VALUE (d1); /* XXX */
-  if (! template)
-    template = IDENTIFIER_CLASS_VALUE (d1);
-  /* With something like `template <class T> class X class X { ... };'
-     we could end up with D1 having nothing but an IDENTIFIER_LOCAL_VALUE.
-     We don't want to do that, but we have to deal with the situation, so
-     let's give them some syntax errors to chew on instead of a crash.  */
-  if (! template)
-    return error_mark_node;
-  if (TREE_CODE (template) != TEMPLATE_DECL)
-    {
-      error ("non-template type '%s' used as a template",
-	     IDENTIFIER_POINTER (d1));
-      if (in_decl)
-	error_with_decl (in_decl, "for template declaration `%s'");
-      return error_mark_node;
-    }
-  parmlist = DECL_TEMPLATE_PARMS (template);
-
-  arglist = coerce_template_parms (parmlist, arglist, in_decl);
-  if (arglist == error_mark_node)
-    return error_mark_node;
-  if (uses_template_parms (arglist))
-    {
-      tree t = make_lang_type (UNINSTANTIATED_P_TYPE);
-      tree d;
-      id = make_anon_name ();
-      d = build_lang_decl (TYPE_DECL, id, t);
-      TYPE_NAME (t) = d;
-      TYPE_VALUES (t) = build_tree_list (template, arglist);
-      pushdecl_top_level (d);
-    }
-  else
-    {
-      mangled_name = mangle_class_name_for_template (IDENTIFIER_POINTER (d1),
-						     parmlist, arglist);
-      id = get_identifier (mangled_name);
-    }
-  if (!IDENTIFIER_TEMPLATE (id))
-    {
-      arglist = copy_to_permanent (arglist);
-      IDENTIFIER_TEMPLATE (id) = perm_tree_cons (template, arglist, NULL_TREE);
-    }
-  return id;
-}
-
-void
-push_template_decls (parmlist, arglist, class_level)
-     tree parmlist, arglist;
-     int class_level;
-{
-  int i, nparms;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "push_template_decls");
-  debug_bindings_indentation += 4;
-#endif
-
-  /* Don't want to push values into global context.  */
-  if (!class_level)
-    pushlevel (0);
-  nparms = TREE_VEC_LENGTH (parmlist);
-
-  for (i = 0; i < nparms; i++)
-    {
-      int requires_type, is_type;
-      tree parm = TREE_VEC_ELT (parmlist, i);
-      tree arg = TREE_VEC_ELT (arglist, i);
-      tree decl = 0;
-
-      requires_type = TREE_CODE (parm) == IDENTIFIER_NODE;
-      is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't';
-      if (is_type)
-	{
-	  /* add typename to namespace */
-	  if (!requires_type)
-	    {
-	      error ("template use error: type provided where value needed");
-	      continue;
-	    }
-	  decl = arg;
-	  my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 't', 273);
-	  decl = build_lang_decl (TYPE_DECL, parm, decl);
-	}
-      else
-	{
-	  /* add const decl to namespace */
-	  tree val;
-	  if (requires_type)
-	    {
-	      error ("template use error: value provided where type needed");
-	      continue;
-	    }
-	  val = digest_init (TREE_TYPE (parm), arg, (tree *) 0);
-	  if (val != error_mark_node)
-	    {
-	      decl = build_decl (VAR_DECL, DECL_NAME (parm), TREE_TYPE (parm));
-	      DECL_INITIAL (decl) = val;
-	      TREE_READONLY (decl) = 1;
-	    }
-	}
-      if (decl != 0)
-	{
-	  layout_decl (decl, 0);
-	  if (class_level)
-	    pushdecl_class_level (decl);
-	  else
-	    pushdecl (decl);
-	}
-    }
-  if (!class_level)
-    set_current_level_tags_transparency (1);
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-void
-pop_template_decls (parmlist, arglist, class_level)
-     tree parmlist, arglist;
-     int class_level;
-{
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "pop_template_decls");
-  debug_bindings_indentation += 4;
-#endif
-
-  if (!class_level)
-    poplevel (0, 0, 0);
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-/* Should be defined in cp-parse.h.  */
-extern int yychar;
-
-int
-uses_template_parms (t)
-     tree t;
-{
-  if (!t)
-    return 0;
-  switch (TREE_CODE (t))
-    {
-    case INDIRECT_REF:
-    case COMPONENT_REF:
-      /* We assume that the object must be instantiated in order to build
-	 the COMPONENT_REF, so we test only whether the type of the
-	 COMPONENT_REF uses template parms.  */
-      return uses_template_parms (TREE_TYPE (t));
-
-    case IDENTIFIER_NODE:
-      if (!IDENTIFIER_TEMPLATE (t))
-	return 0;
-      return uses_template_parms (TREE_VALUE (IDENTIFIER_TEMPLATE (t)));
-
-      /* aggregates of tree nodes */
-    case TREE_VEC:
-      {
-	int i = TREE_VEC_LENGTH (t);
-	while (i--)
-	  if (uses_template_parms (TREE_VEC_ELT (t, i)))
-	    return 1;
-	return 0;
-      }
-    case TREE_LIST:
-      if (uses_template_parms (TREE_PURPOSE (t))
-	  || uses_template_parms (TREE_VALUE (t)))
-	return 1;
-      return uses_template_parms (TREE_CHAIN (t));
-
-      /* constructed type nodes */
-    case POINTER_TYPE:
-    case REFERENCE_TYPE:
-      return uses_template_parms (TREE_TYPE (t));
-    case RECORD_TYPE:
-    case UNION_TYPE:
-      if (!TYPE_NAME (t))
-	return 0;
-      if (!TYPE_IDENTIFIER (t))
-	return 0;
-      return uses_template_parms (TYPE_IDENTIFIER (t));
-    case FUNCTION_TYPE:
-      if (uses_template_parms (TYPE_ARG_TYPES (t)))
-	return 1;
-      return uses_template_parms (TREE_TYPE (t));
-    case ARRAY_TYPE:
-      if (uses_template_parms (TYPE_DOMAIN (t)))
-	return 1;
-      return uses_template_parms (TREE_TYPE (t));
-    case OFFSET_TYPE:
-      if (uses_template_parms (TYPE_OFFSET_BASETYPE (t)))
-	return 1;
-      return uses_template_parms (TREE_TYPE (t));
-    case METHOD_TYPE:
-      if (uses_template_parms (TYPE_OFFSET_BASETYPE (t)))
-	return 1;
-      if (uses_template_parms (TYPE_ARG_TYPES (t)))
-	return 1;
-      return uses_template_parms (TREE_TYPE (t));
-
-      /* decl nodes */
-    case TYPE_DECL:
-      return uses_template_parms (DECL_NAME (t));
-    case FUNCTION_DECL:
-      if (uses_template_parms (TREE_TYPE (t)))
-	return 1;
-      /* fall through */
-    case VAR_DECL:
-    case PARM_DECL:
-      /* ??? What about FIELD_DECLs?  */
-      /* The type of a decl can't use template parms if the name of the
-	 variable doesn't, because it's impossible to resolve them.  So
-	 ignore the type field for now.	 */
-      if (DECL_CONTEXT (t) && uses_template_parms (DECL_CONTEXT (t)))
-	return 1;
-      if (uses_template_parms (TREE_TYPE (t)))
-	{
-	  error ("template parms used where they can't be resolved");
-	}
-      return 0;
-
-    case CALL_EXPR:
-      return uses_template_parms (TREE_TYPE (t));
-    case ADDR_EXPR:
-      return uses_template_parms (TREE_OPERAND (t, 0));
-
-      /* template parm nodes */
-    case TEMPLATE_TYPE_PARM:
-    case TEMPLATE_CONST_PARM:
-      return 1;
-
-      /* simple type nodes */
-    case INTEGER_TYPE:
-      if (uses_template_parms (TYPE_MIN_VALUE (t)))
-	return 1;
-      return uses_template_parms (TYPE_MAX_VALUE (t));
-
-    case REAL_TYPE:
-    case VOID_TYPE:
-    case ENUMERAL_TYPE:
-      return 0;
-
-      /* constants */
-    case INTEGER_CST:
-    case REAL_CST:
-    case STRING_CST:
-      return 0;
-
-    case ERROR_MARK:
-      /* Non-error_mark_node ERROR_MARKs are bad things.  */
-      my_friendly_assert (t == error_mark_node, 274);
-      /* NOTREACHED */
-      return 0;
-
-    case UNINSTANTIATED_P_TYPE:
-      return 1;
-
-    default:
-      switch (TREE_CODE_CLASS (TREE_CODE (t)))
-	{
-	case '1':
-	case '2':
-	case '3':
-	case '<':
-	  {
-	    int i;
-	    for (i = tree_code_length[(int) TREE_CODE (t)]; --i >= 0;)
-	      if (uses_template_parms (TREE_OPERAND (t, i)))
-		return 1;
-	    return 0;
-	  }
-	default:
-	  break;
-	}
-      sorry ("testing %s for template parms",
-	     tree_code_name [(int) TREE_CODE (t)]);
-      my_friendly_abort (82);
-      /* NOTREACHED */
-      return 0;
-    }
-}
-
-void
-instantiate_member_templates (arg)
-     tree arg;
-{
-  tree t;
-  tree classname = TREE_VALUE (arg);
-  tree id = classname;
-  tree members = DECL_TEMPLATE_MEMBERS (TREE_PURPOSE (IDENTIFIER_TEMPLATE (id)));
-
-  for (t = members; t; t = TREE_CHAIN (t))
-    {
-      tree parmvec, type, classparms, tdecl, t2;
-      int nparms, xxx, i;
-
-      my_friendly_assert (TREE_VALUE (t) != NULL_TREE, 275);
-      my_friendly_assert (TREE_CODE (TREE_VALUE (t)) == TEMPLATE_DECL, 276);
-      /* @@ Should verify that class parm list is a list of
-	 distinct template parameters, and covers all the template
-	 parameters.  */
-      tdecl = TREE_VALUE (t);
-      type = DECL_CONTEXT (DECL_TEMPLATE_RESULT (tdecl));
-      classparms = UPT_PARMS (type);
-      nparms = TREE_VEC_LENGTH (classparms);
-      parmvec = make_tree_vec (nparms);
-      for (i = 0; i < nparms; i++)
-	TREE_VEC_ELT (parmvec, i) = NULL_TREE;
-      switch (unify (DECL_TEMPLATE_PARMS (tdecl),
-		     &TREE_VEC_ELT (parmvec, 0), nparms,
-		     type, IDENTIFIER_TYPE_VALUE (classname),
-		     &xxx))
-	{
-	case 0:
-	  /* Success -- well, no inconsistency, at least.  */
-	  for (i = 0; i < nparms; i++)
-	    if (TREE_VEC_ELT (parmvec, i) == NULL_TREE)
-	      goto failure;
-	  t2 = instantiate_template (tdecl,
-				     &TREE_VEC_ELT (parmvec, 0));
-	  type = IDENTIFIER_TYPE_VALUE (id);
-	  my_friendly_assert (type != 0, 277);
-	  if (CLASSTYPE_INTERFACE_UNKNOWN (type))
-	    {
-	      DECL_EXTERNAL (t2) = 0;
-	      TREE_PUBLIC (t2) = 0;
-	    }
-	  else
-	    {
-	      DECL_EXTERNAL (t2) = CLASSTYPE_INTERFACE_ONLY (type);
-	      TREE_PUBLIC (t2) = 1;
-	    }
-	  break;
-	case 1:
-	  /* Failure.  */
-	failure:
-	  error ("type unification error instantiating %s::%s",
-		 IDENTIFIER_POINTER (classname),
-		 IDENTIFIER_POINTER (DECL_NAME (tdecl)));
-	  error_with_decl (tdecl, "for template declaration `%s'");
-
-	  continue /* loop of members */;
-	default:
-	  /* Eek, a bug.  */
-	  my_friendly_abort (83);
-	}
-    }
-}
-
-tree
-instantiate_class_template (classname, setup_parse)
-     tree classname;
-     int setup_parse;
-{
-  struct template_info *template_info;
-  tree template, t1;
-
-  if (classname == error_mark_node)
-    return error_mark_node;
-
-  my_friendly_assert (TREE_CODE (classname) == IDENTIFIER_NODE, 278);
-  template = IDENTIFIER_TEMPLATE (classname);
-
-  if (IDENTIFIER_HAS_TYPE_VALUE (classname))
-    {
-      tree type = IDENTIFIER_TYPE_VALUE (classname);
-      if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
-	return type;
-      if (TYPE_BEING_DEFINED (type)
-	  || TYPE_SIZE (type)
-	  || CLASSTYPE_USE_TEMPLATE (type) != 0)
-	return type;
-    }
-  if (uses_template_parms (classname))
-    {
-      if (!TREE_TYPE (classname))
-	{
-	  tree t = make_lang_type (RECORD_TYPE);
-	  tree d = build_lang_decl (TYPE_DECL, classname, t);
-	  DECL_NAME (d) = classname;
-	  TYPE_NAME (t) = d;
-	  pushdecl (d);
-	}
-      return NULL_TREE;
-    }
-
-  t1 = TREE_PURPOSE (template);
-  my_friendly_assert (TREE_CODE (t1) == TEMPLATE_DECL, 279);
-
-  /* If a template is declared but not defined, accept it; don't crash.
-     Later uses requiring the definition will be flagged as errors by
-     other code.  Thanks to niklas@appli.se for this bug fix.  */
-  if (DECL_TEMPLATE_INFO (t1)->text == 0)
-    setup_parse = 0;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "instantiate_class_template");
-  debug_bindings_indentation += 4;
-#endif
-
-  push_to_top_level ();
-  push_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (template)),
-		       TREE_VALUE (template), 0);
-  set_current_level_tags_transparency (1);
-  template_info = DECL_TEMPLATE_INFO (t1);
-  if (setup_parse)
-    {
-      feed_input (template_info->text, template_info->length, (struct obstack *)0);
-      lineno = template_info->lineno;
-      input_filename = template_info->filename;
-      /* Get interface/implementation back in sync.  */
-      extract_interface_info ();
-      overload_template_name (classname, 0);
-      yychar = PRE_PARSED_CLASS_DECL;
-      yylval.ttype = build_tree_list (class_type_node, classname);
-      processing_template_defn++;
-    }
-  else
-    {
-      tree t, decl, id, tmpl;
-
-      id = classname;
-      tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE (id));
-      t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, id, NULL_TREE);
-      my_friendly_assert (TREE_CODE (t) == RECORD_TYPE, 280);
-#if 1
-      lineno = template_info->lineno;
-      input_filename = template_info->filename;
-      /* Get interface/implementation back in sync.  */
-      extract_interface_info ();
-#endif
-
-      /* Now, put a copy of the decl in global scope, to avoid
-       * recursive expansion.  */
-      decl = IDENTIFIER_LOCAL_VALUE (id);
-      if (!decl)
-	decl = IDENTIFIER_CLASS_VALUE (id);
-      if (decl)
-	{
-	  my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 281);
-	  /* We'd better make sure we're on the permanent obstack or else
-	   * we'll get a "friendly" abort 124 in pushdecl.  Perhaps a
-	   * copy_to_permanent would be sufficient here, but then a
-	   * sharing problem might occur.  I don't know -- niklas@appli.se */
-	  push_obstacks (&permanent_obstack, &permanent_obstack);
-	  pushdecl_top_level (copy_node (decl));
-	  pop_obstacks ();
-	}
-      pop_from_top_level ();
-    }
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-
-  return NULL_TREE;
-}
-
-static int
-list_eq (t1, t2)
-     tree t1, t2;
-{
-  if (t1 == NULL_TREE)
-    return t2 == NULL_TREE;
-  if (t2 == NULL_TREE)
-    return 0;
-  /* Don't care if one declares its arg const and the other doesn't -- the
-     main variant of the arg type is all that matters.  */
-  if (TYPE_MAIN_VARIANT (TREE_VALUE (t1))
-      != TYPE_MAIN_VARIANT (TREE_VALUE (t2)))
-    return 0;
-  return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2));
-}
-
-static tree
-tsubst (t, args, nargs, in_decl)
-     tree t, *args;
-     int nargs;
-     tree in_decl;
-{
-  tree type;
-
-  if (t == NULL_TREE || t == error_mark_node)
-    return t;
-
-  type = TREE_TYPE (t);
-  if (type
-      /* Minor optimization.
-	 ?? Are these really the most frequent cases?  Is the savings
-	 significant?  */
-      && type != integer_type_node
-      && type != void_type_node
-      && type != char_type_node)
-    type = build_type_variant (tsubst (type, args, nargs, in_decl),
-			       TYPE_READONLY (type),
-			       TYPE_VOLATILE (type));
-  switch (TREE_CODE (t))
-    {
-    case ERROR_MARK:
-    case IDENTIFIER_NODE:
-    case OP_IDENTIFIER:
-    case VOID_TYPE:
-    case REAL_TYPE:
-    case ENUMERAL_TYPE:
-    case INTEGER_CST:
-    case REAL_CST:
-    case STRING_CST:
-    case RECORD_TYPE:
-    case UNION_TYPE:
-      return t;
-
-    case INTEGER_TYPE:
-      if (t == integer_type_node)
-	return t;
-
-      if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
-	  && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
-	return t;
-      return build_index_2_type (tsubst (TYPE_MIN_VALUE (t), args, nargs, in_decl),
-				 tsubst (TYPE_MAX_VALUE (t), args, nargs, in_decl));
-
-    case TEMPLATE_TYPE_PARM:
-      return build_type_variant (args[TEMPLATE_TYPE_IDX (t)],
-				 TYPE_READONLY (t),
-				 TYPE_VOLATILE (t));
-
-    case TEMPLATE_CONST_PARM:
-      return args[TEMPLATE_CONST_IDX (t)];
-
-    case FUNCTION_DECL:
-      {
-	tree r;
-	tree fnargs, result;
-	
-	if (type == TREE_TYPE (t)
-	    && (DECL_CONTEXT (t) == NULL_TREE
-		|| TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) != 't'))
-	  return t;
-	fnargs = tsubst (DECL_ARGUMENTS (t), args, nargs, t);
-	result = tsubst (DECL_RESULT (t), args, nargs, t);
-	if (DECL_CONTEXT (t) != NULL_TREE
-	    && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't')
-	  {
-	    /* Look it up in that class, and return the decl node there,
-	       instead of creating a new one.  */
-	    tree ctx, methods, name, method;
-	    int n_methods;
-	    int i, found = 0;
-
-	    name = DECL_NAME (t);
-	    ctx = tsubst (DECL_CONTEXT (t), args, nargs, t);
-	    methods = CLASSTYPE_METHOD_VEC (ctx);
-	    if (methods == NULL_TREE)
-	      /* No methods at all -- no way this one can match.  */
-	      goto no_match;
-	    n_methods = TREE_VEC_LENGTH (methods);
-
-	    r = NULL_TREE;
-
-	    if (!strncmp (OPERATOR_TYPENAME_FORMAT,
-			  IDENTIFIER_POINTER (name),
-			  sizeof (OPERATOR_TYPENAME_FORMAT) - 1))
-	      {
-		/* Type-conversion operator.  Reconstruct the name, in
-		   case it's the name of one of the template's parameters.  */
-		name = build_typename_overload (TREE_TYPE (type));
-	      }
-
-	    if (DECL_CONTEXT (t) != NULL_TREE
-		&& TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't'
-		&& constructor_name (DECL_CONTEXT (t)) == DECL_NAME (t))
-	      name = constructor_name (ctx);
-#if 0
-	    fprintf (stderr, "\nfor function %s in class %s:\n",
-		     IDENTIFIER_POINTER (name),
-		     IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx)));
-#endif
-	    for (i = 0; i < n_methods; i++)
-	      {
-		int pass;
-
-		method = TREE_VEC_ELT (methods, i);
-		if (method == NULL_TREE || DECL_NAME (method) != name)
-		  continue;
-
-		pass = 0;
-	      maybe_error:
-		for (; method; method = TREE_CHAIN (method))
-		  {
-		    my_friendly_assert (TREE_CODE (method) == FUNCTION_DECL,
-					282);
-		    if (TREE_TYPE (method) != type)
-		      {
-			tree mtype = TREE_TYPE (method);
-			tree t1, t2;
-
-			/* Keep looking for a method that matches
-			   perfectly.  This takes care of the problem
-			   where destructors (which have implicit int args)
-			   look like constructors which have an int arg.  */
-			if (pass == 0)
-			  continue;
-
-			t1 = TYPE_ARG_TYPES (mtype);
-			t2 = TYPE_ARG_TYPES (type);
-			if (TREE_CODE (mtype) == FUNCTION_TYPE)
-			  t2 = TREE_CHAIN (t2);
-
-			if (list_eq (t1, t2))
-			  {
-			    if (TREE_CODE (mtype) == FUNCTION_TYPE)
-			      {
-				tree newtype;
-				newtype = build_function_type (TREE_TYPE (type),
-							       TYPE_ARG_TYPES (type));
-				newtype = build_type_variant (newtype,
-							      TYPE_READONLY (type),
-							      TYPE_VOLATILE (type));
-				type = newtype;
-				if (TREE_TYPE (type) != TREE_TYPE (mtype))
-				  goto maybe_bad_return_type;
-			      }
-			    else if (TYPE_METHOD_BASETYPE (mtype)
-				     == TYPE_METHOD_BASETYPE (type))
-			      {
-				/* Types didn't match, but arg types and
-				   `this' do match, so the return type is
-				   all that should be messing it up.  */
-			      maybe_bad_return_type:
-				if (TREE_TYPE (type) != TREE_TYPE (mtype))
-				  error ("inconsistent return types for method `%s' in class `%s'",
-					 IDENTIFIER_POINTER (name),
-					 IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx)));
-			      }
-			    r = method;
-			    break;
-			  }
-			found = 1;
-			continue;
-		      }
-#if 0
-		    fprintf (stderr, "\tfound %s\n\n",
-			     IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method)));
-#endif
-		    if (DECL_ARGUMENTS (method)
-			&& ! TREE_PERMANENT (DECL_ARGUMENTS (method)))
-		      /* @@ Is this early enough?  Might we want to do
-			 this instead while processing the expansion?	 */
-		      DECL_ARGUMENTS (method)
-			= tsubst (DECL_ARGUMENTS (t), args, nargs, t);
-		    r = method;
-		    break;
-		  }
-		if (r == NULL_TREE && pass == 0)
-		  {
-		    pass = 1;
-		    method = TREE_VEC_ELT (methods, i);
-		    goto maybe_error;
-		  }
-	      }
-	    if (r == NULL_TREE)
-	      {
-	      no_match:
-		error (found
-		       ? "template for method `%s' doesn't match any in class `%s'"
-		       : "method `%s' not found in class `%s'",
-		       IDENTIFIER_OPNAME_P (name)
-		       ? operator_name_string (name) : IDENTIFIER_POINTER (name),
-		       IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx)));
-		if (in_decl)
-		  error_with_decl (in_decl, "in attempt to instantiate `%s' declared at this point in file");
-		return error_mark_node;
-	      }
-	  }
-	else
-	  {
-	    r = DECL_NAME (t);
-	    {
-	      tree decls, val;
-	      int got_it = 0;
-
-	      decls = IDENTIFIER_GLOBAL_VALUE (r);
-	      if (decls == NULL_TREE)
-		/* no match */;
-	      else if (TREE_CODE (decls) == TREE_LIST)
-		while (decls)
-		  {
-		    val = TREE_VALUE (decls);
-		    decls = TREE_CHAIN (decls);
-		  try_one:
-		    if (TREE_CODE (val) == FUNCTION_DECL
-			&& TREE_TYPE (val) == type)
-		      {
-			got_it = 1;
-			r = val;
-			break;
-		      }
-		  }
-	      else
-		{
-		  val = decls;
-		  decls = NULL_TREE;
-		  goto try_one;
-		}
-
-	      if (!got_it)
-		{
-		  r = build_decl_overload (r, TYPE_VALUES (type),
-					   DECL_CONTEXT (t) != NULL_TREE);
-		  r = build_lang_decl (FUNCTION_DECL, r, type);
-		}
-	    }
-	  }
-	TREE_PUBLIC (r) = TREE_PUBLIC (t);
-	DECL_EXTERNAL (r) = DECL_EXTERNAL (t);
-	TREE_STATIC (r) = TREE_STATIC (t);
-	DECL_INLINE (r) = DECL_INLINE (t);
-	DECL_SOURCE_FILE (r) = DECL_SOURCE_FILE (t);
-	DECL_SOURCE_LINE (r) = DECL_SOURCE_LINE (t);
-	DECL_CLASS_CONTEXT (r) = tsubst (DECL_CLASS_CONTEXT (t), args, nargs, t);
-	make_decl_rtl (r, NULL_PTR, 1);
-	DECL_ARGUMENTS (r) = fnargs;
-	DECL_RESULT (r) = result;
-	if (DECL_CONTEXT (t) == NULL_TREE
-	    || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) != 't')
-	  push_overloaded_decl_top_level (r, 0);
-	return r;
-      }
-
-    case PARM_DECL:
-      {
-	tree r;
-	r = build_decl (PARM_DECL, DECL_NAME (t), type);
-	DECL_INITIAL (r) = TREE_TYPE (r);
-	if (TREE_CHAIN (t))
-	  TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, nargs, TREE_CHAIN (t));
-	return r;
-      }
-
-    case TREE_LIST:
-      {
-	tree purpose, value, chain, result;
-	int via_public, via_virtual, via_protected;
-
-	if (t == void_list_node)
-	  return t;
-
-	via_public = TREE_VIA_PUBLIC (t);
-	via_protected = TREE_VIA_PROTECTED (t);
-	via_virtual = TREE_VIA_VIRTUAL (t);
-
-	purpose = TREE_PURPOSE (t);
-	if (purpose)
-	  purpose = tsubst (purpose, args, nargs, in_decl);
-	value = TREE_VALUE (t);
-	if (value)
-	  value = tsubst (value, args, nargs, in_decl);
-	chain = TREE_CHAIN (t);
-	if (chain && chain != void_type_node)
-	  chain = tsubst (chain, args, nargs, in_decl);
-	if (purpose == TREE_PURPOSE (t)
-	    && value == TREE_VALUE (t)
-	    && chain == TREE_CHAIN (t))
-	  return t;
-	result = hash_tree_cons (via_public, via_virtual, via_protected,
-				 purpose, value, chain);
-	TREE_PARMLIST (result) = TREE_PARMLIST (t);
-	return result;
-      }
-    case TREE_VEC:
-      {
-	int len = TREE_VEC_LENGTH (t), need_new = 0, i;
-	tree *elts = (tree *) alloca (len * sizeof (tree));
-	bzero (elts, len * sizeof (tree));
-
-	for (i = 0; i < len; i++)
-	  {
-	    elts[i] = tsubst (TREE_VEC_ELT (t, i), args, nargs, in_decl);
-	    if (elts[i] != TREE_VEC_ELT (t, i))
-	      need_new = 1;
-	  }
-
-	if (!need_new)
-	  return t;
-
-	t = make_tree_vec (len);
-	for (i = 0; i < len; i++)
-	  TREE_VEC_ELT (t, i) = elts[i];
-	return t;
-      }
-    case POINTER_TYPE:
-    case REFERENCE_TYPE:
-      {
-	tree r;
-	enum tree_code code;
-	if (type == TREE_TYPE (t))
-	  return t;
-
-	code = TREE_CODE (t);
-	if (code == POINTER_TYPE)
-	  r = build_pointer_type (type);
-	else
-	  r = build_reference_type (type);
-	r = build_type_variant (r, TYPE_READONLY (t), TYPE_VOLATILE (t));
-	/* Will this ever be needed for TYPE_..._TO values?  */
-	layout_type (r);
-	return r;
-      }
-    case FUNCTION_TYPE:
-    case METHOD_TYPE:
-      {
-	tree values = TYPE_VALUES (t); /* same as TYPE_ARG_TYPES */
-	tree context = TYPE_CONTEXT (t);
-	tree new_value;
-
-	/* Don't bother recursing if we know it won't change anything.	*/
-	if (! (values == void_type_node
-	       || values == integer_type_node))
-	  values = tsubst (values, args, nargs, in_decl);
-	if (context)
-	  context = tsubst (context, args, nargs, in_decl);
-	/* Could also optimize cases where return value and
-	   values have common elements (e.g., T min(const &T, const T&).  */
-
-	/* If the above parameters haven't changed, just return the type.  */
-	if (type == TREE_TYPE (t)
-	    && values == TYPE_VALUES (t)
-	    && context == TYPE_CONTEXT (t))
-	  return t;
-
-	/* Construct a new type node and return it.  */
-	if (TREE_CODE (t) == FUNCTION_TYPE
-	    && context == NULL_TREE)
-	  {
-	    new_value = build_function_type (type, values);
-	  }
-	else if (context == NULL_TREE)
-	  {
-	    tree base = tsubst (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))),
-				args, nargs, in_decl);
-	    new_value = build_cplus_method_type (base, type,
-						 TREE_CHAIN (values));
-	  }
-	else
-	  {
-	    new_value = make_node (TREE_CODE (t));
-	    TREE_TYPE (new_value) = type;
-	    TYPE_CONTEXT (new_value) = context;
-	    TYPE_VALUES (new_value) = values;
-	    TYPE_SIZE (new_value) = TYPE_SIZE (t);
-	    TYPE_ALIGN (new_value) = TYPE_ALIGN (t);
-	    TYPE_MODE (new_value) = TYPE_MODE (t);
-	    if (TYPE_METHOD_BASETYPE (t))
-	      TYPE_METHOD_BASETYPE (new_value) = tsubst (TYPE_METHOD_BASETYPE (t),
-							 args, nargs, in_decl);
-	    /* Need to generate hash value.  */
-	    my_friendly_abort (84);
-	  }
-	new_value = build_type_variant (new_value,
-					TYPE_READONLY (t),
-					TYPE_VOLATILE (t));
-	return new_value;
-      }
-    case ARRAY_TYPE:
-      {
-	tree domain = tsubst (TYPE_DOMAIN (t), args, nargs, in_decl);
-	tree r;
-	if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
-	  return t;
-	r = build_cplus_array_type (type, domain);
-	return r;
-      }
-
-    case UNINSTANTIATED_P_TYPE:
-      {
-	int nparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (UPT_TEMPLATE (t)));
-	tree argvec = make_tree_vec (nparms);
-	tree parmvec = UPT_PARMS (t);
-	int i;
-	tree id;
-	for (i = 0; i < nparms; i++)
-	  TREE_VEC_ELT (argvec, i) = tsubst (TREE_VEC_ELT (parmvec, i),
-					     args, nargs, in_decl);
-	id = lookup_template_class (DECL_NAME (UPT_TEMPLATE (t)), argvec, NULL_TREE);
-	if (! IDENTIFIER_HAS_TYPE_VALUE (id)) {
-	  instantiate_class_template(id, 0);
-	  /* set up pending_classes */
-	  add_pending_template (id);
-
-	  TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (id)) =
-	    IDENTIFIER_TYPE_VALUE (id);
-	}
-	return build_type_variant (IDENTIFIER_TYPE_VALUE (id),
-				   TYPE_READONLY (t),
-				   TYPE_VOLATILE (t));
-      }
-
-    case MINUS_EXPR:
-    case PLUS_EXPR:
-      return fold (build (TREE_CODE (t), TREE_TYPE (t),
-			  tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl),
-			  tsubst (TREE_OPERAND (t, 1), args, nargs, in_decl)));
-
-    case NEGATE_EXPR:
-    case NOP_EXPR:
-      return fold (build1 (TREE_CODE (t), TREE_TYPE (t),
-			   tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl)));
-
-    default:
-      sorry ("use of `%s' in function template",
-	     tree_code_name [(int) TREE_CODE (t)]);
-      return error_mark_node;
-    }
-}
-
-tree
-instantiate_template (tmpl, targ_ptr)
-     tree tmpl, *targ_ptr;
-{
-  tree targs, fndecl;
-  int i, len;
-  struct pending_inline *p;
-  struct template_info *t;
-  struct obstack *old_fmp_obstack;
-  extern struct obstack *function_maybepermanent_obstack;
-
-  push_obstacks (&permanent_obstack, &permanent_obstack);
-  old_fmp_obstack = function_maybepermanent_obstack;
-  function_maybepermanent_obstack = &permanent_obstack;
-
-  my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283);
-  len = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl));
-
-  for (fndecl = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
-       fndecl; fndecl = TREE_CHAIN (fndecl))
-    {
-      tree *t1 = &TREE_VEC_ELT (TREE_PURPOSE (fndecl), 0);
-      for (i = len - 1; i >= 0; i--)
-	if (t1[i] != targ_ptr[i])
-	  goto no_match;
-
-      /* Here, we have a match.  */
-      fndecl = TREE_VALUE (fndecl);
-      function_maybepermanent_obstack = old_fmp_obstack;
-      pop_obstacks ();
-      return fndecl;
-
-    no_match:
-      ;
-    }
-
-  targs = make_tree_vec (len);
-  i = len;
-  while (i--)
-    TREE_VEC_ELT (targs, i) = targ_ptr[i];
-
-  /* substitute template parameters */
-  fndecl = tsubst (DECL_RESULT (tmpl), targ_ptr,
-		   TREE_VEC_LENGTH (targs), tmpl);
-
-  /* If it's a static member fn in the template, we need to change it
-     into a FUNCTION_TYPE and chop off its this pointer.  */
-  if (TREE_CODE (TREE_TYPE (DECL_RESULT (tmpl))) == METHOD_TYPE
-      && fndecl != error_mark_node
-      && DECL_STATIC_FUNCTION_P (fndecl))
-    {
-      tree olddecl = DECL_RESULT (tmpl);
-      revert_static_member_fn (&TREE_TYPE (olddecl), &DECL_RESULT (tmpl),
-			       &TYPE_ARG_TYPES (TREE_TYPE (olddecl)));
-      /* Chop off the this pointer that grokclassfn so kindly added
-	 for us (it didn't know yet if the fn was static or not).  */
-      DECL_ARGUMENTS (olddecl) = TREE_CHAIN (DECL_ARGUMENTS (olddecl));
-      DECL_ARGUMENTS (fndecl) = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
-    }
-     
-  t = DECL_TEMPLATE_INFO (tmpl);
-  if (t->text)
-    {
-      p = (struct pending_inline *) permalloc (sizeof (struct pending_inline));
-      p->parm_vec = t->parm_vec;
-      p->bindings = targs;
-      p->can_free = 0;
-      p->deja_vu = 0;
-      p->lineno = t->lineno;
-      p->filename = t->filename;
-      p->buf = t->text;
-      p->len = t->length;
-      p->fndecl = fndecl;
-      p->interface = 1;		/* unknown */
-    }
-  else
-    p = (struct pending_inline *)0;
-
-  DECL_TEMPLATE_INSTANTIATIONS (tmpl) =
-    tree_cons (targs, fndecl, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
-
-  function_maybepermanent_obstack = old_fmp_obstack;
-  pop_obstacks ();
-
-  if (fndecl == error_mark_node || p == (struct pending_inline *)0)
-    {
-      /* do nothing */
-    }
-  else if (DECL_INLINE (fndecl))
-    {
-      DECL_PENDING_INLINE_INFO (fndecl) = p;
-      p->next = pending_inlines;
-      pending_inlines = p;
-    }
-  else
-    {
-      p->next = pending_template_expansions;
-      pending_template_expansions = p;
-    }
-  return fndecl;
-}
-
-void
-undo_template_name_overload (id, classlevel)
-     tree id;
-     int classlevel;
-{
-  tree template;
-
-  template = IDENTIFIER_TEMPLATE (id);
-  if (!template)
-    return;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "undo_template_name_overload");
-  debug_bindings_indentation += 4;
-#endif
-
-#if 0 /* not yet, should get fixed properly later */
-  poplevel (0, 0, 0);
-#endif
-  if (!classlevel)
-    poplevel (0, 0, 0);
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-void
-overload_template_name (id, classlevel)
-     tree id;
-     int classlevel;
-{
-  tree template, t, decl;
-  struct template_info *tinfo;
-
-  my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 284);
-  template = IDENTIFIER_TEMPLATE (id);
-  if (!template)
-    return;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "overload_template_name(%d)", classlevel);
-  debug_bindings_indentation += 4;
-#endif
-  template = TREE_PURPOSE (template);
-  tinfo = DECL_TEMPLATE_INFO (template);
-  template = DECL_NAME (template);
-  my_friendly_assert (template != NULL_TREE, 285);
-
-  if (!classlevel)
-    {
-      pushlevel (1);
-      declare_pseudo_global_level ();
-    }
-
-  t = xref_tag (tinfo->aggr, id, NULL_TREE);
-  my_friendly_assert (TREE_CODE (t) == RECORD_TYPE
-	  || TREE_CODE (t) == UNINSTANTIATED_P_TYPE, 286);
-
-  decl = build_decl (TYPE_DECL, template, t);
-
-#if 0 /* fix this later */
-  /* We don't want to call here if the work has already been done.  */
-  t = (classlevel
-       ? IDENTIFIER_CLASS_VALUE (template)
-       : IDENTIFIER_LOCAL_VALUE (template));
-  if (t
-      && TREE_CODE (t) == TYPE_DECL
-      && TREE_TYPE (t) == t)
-    my_friendly_abort (85);
-#endif
-
-  if (classlevel)
-    pushdecl_class_level (decl);
-  else
-#if 0 /* not yet, should get fixed properly later */
-    pushdecl (decl);
-  pushlevel (1);
-#else
-    {
-      pushdecl (decl);
-      /* @@ Is this necessary now?  */
-      IDENTIFIER_LOCAL_VALUE (template) = decl;
-    }
-#endif
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-/* T1 is PRE_PARSED_CLASS_DECL; T3 is result of XREF_TAG lookup.  */
-void
-end_template_instantiation (t1, t3)
-     tree t1, t3;
-{
-  extern struct pending_input *to_be_restored;
-  tree t, decl;
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  indent_to (stderr, debug_bindings_indentation);
-  fprintf (stderr, "end_template_instantiation");
-  debug_bindings_indentation += 4;
-#endif
-
-  processing_template_defn--;
-
-  /* Restore the old parser input state.  */
-  if (yychar == YYEMPTY)
-    yychar = yylex ();
-  if (yychar != END_OF_SAVED_INPUT)
-    error ("parse error at end of class template");
-  else
-    {
-      restore_pending_input (to_be_restored);
-      to_be_restored = 0;
-    }
-
-  /* Our declarations didn't get stored in the global slot, since
-     there was a (supposedly tags-transparent) scope in between.  */
-  t = IDENTIFIER_TYPE_VALUE (TREE_VALUE (t1));
-  my_friendly_assert (t != NULL_TREE
-		      && TREE_CODE_CLASS (TREE_CODE (t)) == 't',
-		      287);
-  CLASSTYPE_USE_TEMPLATE (t) = 2;
-  /* Always make methods of template classes static, until we've
-     got a decent scheme for handling them.  The pragmas as they
-     are now are inadequate.  */
-  CLASSTYPE_INTERFACE_UNKNOWN (t) = 1;
-  decl = IDENTIFIER_GLOBAL_VALUE (TREE_VALUE (t1));
-  my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 288);
-
-  undo_template_name_overload (TREE_VALUE (t1), 0);
-  t = IDENTIFIER_TEMPLATE (TREE_VALUE (t1));
-  pop_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (t)), TREE_VALUE (t),
-		      0);
-  pop_from_top_level ();
-
-  /* This will fix up the type-value field.  */
-  pushdecl_top_level (decl);
-
-  /* Restore interface/implementation settings.	 */
-  extract_interface_info ();
-
-#ifdef DEBUG_CP_BINDING_LEVELS
-  debug_bindings_indentation -= 4;
-#endif
-}
-
-/* Store away the text of an inline template function.	No rtl is
-   generated for this function until it is actually needed.  */
-
-void
-reinit_parse_for_template (yychar, d1, d2)
-     int yychar;
-     tree d1, d2;
-{
-  struct template_info *template_info;
-
-  if (d2 == NULL_TREE || d2 == error_mark_node)
-    {
-    lose:
-      /* @@ Should use temp obstack, and discard results.  */
-      reinit_parse_for_block (yychar, &permanent_obstack, 1);
-      return;
-    }
-
-  if (TREE_CODE (d2) == IDENTIFIER_NODE)
-    d2 = IDENTIFIER_GLOBAL_VALUE (d2);
-  if (!d2)
-    goto lose;
-  template_info = DECL_TEMPLATE_INFO (d2);
-  if (!template_info)
-    {
-      template_info = (struct template_info *) permalloc (sizeof (struct template_info));
-      bzero (template_info, sizeof (struct template_info));
-      DECL_TEMPLATE_INFO (d2) = template_info;
-    }
-  template_info->filename = input_filename;
-  template_info->lineno = lineno;
-  reinit_parse_for_block (yychar, &permanent_obstack, 1);
-  template_info->text = obstack_base (&permanent_obstack);
-  template_info->length = obstack_object_size (&permanent_obstack);
-  obstack_finish (&permanent_obstack);
-  template_info->parm_vec = d1;
-}
-
-/* Type unification.
-
-   We have a function template signature with one or more references to
-   template parameters, and a parameter list we wish to fit to this
-   template.  If possible, produce a list of parameters for the template
-   which will cause it to fit the supplied parameter list.
-
-   Return zero for success, 2 for an incomplete match that doesn't resolve
-   all the types, and 1 for complete failure.  An error message will be
-   printed only for an incomplete match.
-
-   TPARMS[NTPARMS] is an array of template parameter types;
-   TARGS[NTPARMS] is the array of template parameter values.  PARMS is
-   the function template's signature (using TEMPLATE_PARM_IDX nodes),
-   and ARGS is the argument list we're trying to match against it.  */
-
-int
-type_unification (tparms, targs, parms, args, nsubsts)
-     tree tparms, *targs, parms, args;
-     int *nsubsts;
-{
-  tree parm, arg;
-  int i;
-  int ntparms = TREE_VEC_LENGTH (tparms);
-
-  my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289);
-  my_friendly_assert (TREE_CODE (parms) == TREE_LIST, 290);
-  /* ARGS could be NULL (via a call from cp-parse.y to
-     build_x_function_call).  */
-  if (args)
-    my_friendly_assert (TREE_CODE (args) == TREE_LIST, 291);
-  my_friendly_assert (ntparms > 0, 292);
-
-  bzero (targs, sizeof (tree) * ntparms);
-
-  while (parms
-	 && parms != void_list_node
-	 && args)
-    {
-      parm = TREE_VALUE (parms);
-      parms = TREE_CHAIN (parms);
-      arg = TREE_VALUE (args);
-      args = TREE_CHAIN (args);
-
-      if (arg == error_mark_node)
-	return 1;
-      if (arg == unknown_type_node)
-	return 1;
-#if 0
-      if (TREE_CODE (arg) == VAR_DECL)
-	arg = TREE_TYPE (arg);
-      else if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'e')
-	arg = TREE_TYPE (arg);
-#else
-      my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293);
-      arg = TREE_TYPE (arg);
-#endif
-
-      switch (unify (tparms, targs, ntparms, parm, arg, nsubsts))
-	{
-	case 0:
-	  break;
-	case 1:
-	  return 1;
-	}
-    }
-  /* Fail if we've reached the end of the parm list, and more args
-     are present, and the parm list isn't variadic.  */
-  if (args && parms == void_list_node)
-    return 1;
-  /* Fail if parms are left and they don't have default values.	 */
-  if (parms
-      && parms != void_list_node
-      && TREE_PURPOSE (parms) == NULL_TREE)
-    return 1;
-  for (i = 0; i < ntparms; i++)
-    if (!targs[i])
-      {
-	error ("incomplete type unification");
-	return 2;
-      }
-  return 0;
-}
-
-/* Tail recursion is your friend.  */
-static int
-unify (tparms, targs, ntparms, parm, arg, nsubsts)
-     tree tparms, *targs, parm, arg;
-     int *nsubsts;
-{
-  int idx;
-
-  /* I don't think this will do the right thing with respect to types.
-     But the only case I've seen it in so far has been array bounds, where
-     signedness is the only information lost, and I think that will be
-     okay.  */
-  while (TREE_CODE (parm) == NOP_EXPR)
-    parm = TREE_OPERAND (parm, 0);
-
-  if (arg == error_mark_node)
-    return 1;
-  if (arg == unknown_type_node)
-    return 1;
-  if (arg == parm)
-    return 0;
-
-  switch (TREE_CODE (parm))
-    {
-    case TEMPLATE_TYPE_PARM:
-      (*nsubsts)++;
-      if (TEMPLATE_TYPE_TPARMLIST (parm) != tparms)
-	{
-	  error ("mixed template headers?!");
-	  my_friendly_abort (86);
-	  return 1;
-	}
-      idx = TEMPLATE_TYPE_IDX (parm);
-      /* Simple cases: Value already set, does match or doesn't.  */
-      if (targs[idx] == arg)
-	return 0;
-      else if (targs[idx])
-	return 1;
-      /* Check for mixed types and values.  */
-      if (TREE_CODE (TREE_VEC_ELT (tparms, idx)) != IDENTIFIER_NODE)
-	return 1;
-      targs[idx] = arg;
-      return 0;
-    case TEMPLATE_CONST_PARM:
-      (*nsubsts)++;
-      idx = TEMPLATE_CONST_IDX (parm);
-      if (targs[idx] == arg)
-	return 0;
-      else if (targs[idx])
-	{
-	  my_friendly_abort (87);
-	  return 1;
-	}
-/*	else if (typeof arg != tparms[idx])
-	return 1;*/
-
-      targs[idx] = copy_to_permanent (arg);
-      return 0;
-
-    case POINTER_TYPE:
-      if (TREE_CODE (arg) != POINTER_TYPE)
-	return 1;
-      return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg),
-		    nsubsts);
-
-    case REFERENCE_TYPE:
-      return unify (tparms, targs, ntparms, TREE_TYPE (parm), arg, nsubsts);
-
-    case ARRAY_TYPE:
-      if (TREE_CODE (arg) != ARRAY_TYPE)
-	return 1;
-      if (unify (tparms, targs, ntparms, TYPE_DOMAIN (parm), TYPE_DOMAIN (arg),
-		 nsubsts) != 0)
-	return 1;
-      return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg),
-		    nsubsts);
-
-    case REAL_TYPE:
-    case INTEGER_TYPE:
-      if (TREE_CODE (parm) == INTEGER_TYPE && TREE_CODE (arg) == INTEGER_TYPE)
-	{
-	  if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg)
-	      && unify (tparms, targs, ntparms,
-			TYPE_MIN_VALUE (parm), TYPE_MIN_VALUE (arg), nsubsts))
-	    return 1;
-	  if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg)
-	      && unify (tparms, targs, ntparms,
-			TYPE_MAX_VALUE (parm), TYPE_MAX_VALUE (arg), nsubsts))
-	    return 1;
-	}
-      /* As far as unification is concerned, this wins.	 Later checks
-	 will invalidate it if necessary.  */
-      return 0;
-
-      /* Types INTEGER_CST and MINUS_EXPR can come from array bounds.  */
-    case INTEGER_CST:
-      if (TREE_CODE (arg) != INTEGER_CST)
-	return 1;
-      return !tree_int_cst_equal (parm, arg);
-
-    case MINUS_EXPR:
-      {
-	tree t1, t2;
-	t1 = TREE_OPERAND (parm, 0);
-	t2 = TREE_OPERAND (parm, 1);
-	if (TREE_CODE (t1) != TEMPLATE_CONST_PARM)
-	  return 1;
-	return unify (tparms, targs, ntparms, t1,
-		      fold (build (PLUS_EXPR, integer_type_node, arg, t2)),
-		      nsubsts);
-      }
-
-    case TREE_VEC:
-      {
-	int i;
-	if (TREE_CODE (arg) != TREE_VEC)
-	  return 1;
-	if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
-	  return 1;
-	for (i = TREE_VEC_LENGTH (parm) - 1; i >= 0; i--)
-	  if (unify (tparms, targs, ntparms,
-		     TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
-		     nsubsts))
-	    return 1;
-	return 0;
-      }
-
-    case UNINSTANTIATED_P_TYPE:
-      {
-	tree a;
-	/* Unification of something that is not a template fails. (mrs) */
-	if (TYPE_NAME (arg) == 0)
-	  return 1;
-	a = IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (arg));
-	/* Unification of something that is not a template fails. (mrs) */
-	if (a == 0)
-	  return 1;
-	if (UPT_TEMPLATE (parm) != TREE_PURPOSE (a))
-	  /* different templates */
-	  return 1;
-	return unify (tparms, targs, ntparms, UPT_PARMS (parm), TREE_VALUE (a),
-		      nsubsts);
-      }
-
-    case RECORD_TYPE:
-      /* Unification of something that is not a template fails. (mrs) */
-      return 1;
-
-    default:
-      sorry ("use of `%s' in template type unification",
-	     tree_code_name [(int) TREE_CODE (parm)]);
-      return 1;
-    }
-}
-
-
-#undef DEBUG
-
-int
-do_pending_expansions ()
-{
-  struct pending_inline *i, *new_list = 0;
-
-  if (!pending_template_expansions)
-    return 0;
-
-#ifdef DEBUG
-  fprintf (stderr, "\n\n\t\t IN DO_PENDING_EXPANSIONS\n\n");
-#endif
-
-  i = pending_template_expansions;
-  while (i)
-    {
-      tree context;
-
-      struct pending_inline *next = i->next;
-      tree t = i->fndecl;
-
-      int decision = 0;
-#define DECIDE(N) if(1){decision=(N); goto decided;}else
-
-      my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL
-			  || TREE_CODE (t) == VAR_DECL, 294);
-      if (TREE_ASM_WRITTEN (t))
-	DECIDE (0);
-      /* If it's a method, let the class type decide it.
-	 @@ What if the method template is in a separate file?
-	 Maybe both file contexts should be taken into account?  */
-      context = DECL_CONTEXT (t);
-      if (context != NULL_TREE
-	  && TREE_CODE_CLASS (TREE_CODE (context)) == 't')
-	{
-	  /* If `unknown', we might want a static copy.
-	     If `implementation', we want a global one.
-	     If `interface', ext ref.  */
-	  if (!CLASSTYPE_INTERFACE_UNKNOWN (context))
-	    DECIDE (!CLASSTYPE_INTERFACE_ONLY (context));
-#if 0 /* This doesn't get us stuff needed only by the file initializer.  */
-	  DECIDE (TREE_USED (t));
-#else /* This compiles too much stuff, but that's probably better in
-	 most cases than never compiling the stuff we need.  */
-	  DECIDE (1);
-#endif
-	}
-      /* else maybe call extract_interface_info? */
-      if (TREE_USED (t)) /* is this right? */
-	DECIDE (1);
-
-    decided:
-#ifdef DEBUG
-      print_node_brief (stderr, decision ? "yes: " : "no: ", t, 0);
-      fprintf (stderr, "\t%s\n",
-	       (DECL_ASSEMBLER_NAME (t)
-		? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t))
-		: ""));
-#endif
-      if (decision == 1)
-	{
-	  i->next = pending_inlines;
-	  pending_inlines = i;
-	}
-      else
-	{
-	  i->next = new_list;
-	  new_list = i;
-	}
-      i = next;
-    }
-  pending_template_expansions = new_list;
-  if (!pending_inlines)
-    return 0;
-  do_pending_inlines ();
-  return 1;
-}
-
-
-struct pending_template {
-  struct pending_template *next;
-  tree id;
-};
-
-static struct pending_template* pending_templates;
-
-void
-do_pending_templates ()
-{
-  struct pending_template* t;
-  
-  for ( t = pending_templates; t; t = t->next)
-    {
-      instantiate_class_template (t->id, 1);
-    }
-
-  for ( t = pending_templates; t; t = pending_templates)
-    {
-      pending_templates = t->next;
-      free(t);
-    }
-}
-
-static void
-add_pending_template (pt)
-     tree pt;
-{
-  struct pending_template *p;
-  
-  p = (struct pending_template *) malloc (sizeof (struct pending_template));
-  p->next = pending_templates;
-  pending_templates = p;
-  p->id = pt;
-}
diff --git a/gnu/gcc2/cc1plus/cp-ptree.c b/gnu/gcc2/cc1plus/cp-ptree.c
deleted file mode 100644
index a976fac36ddf..000000000000
--- a/gnu/gcc2/cc1plus/cp-ptree.c
+++ /dev/null
@@ -1,153 +0,0 @@
-/* Prints out trees in human readable form.
-   Copyright (C) 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-#include "config.h"
-#include "tree.h"
-#include <stdio.h>
-#include "cp-tree.h"
-
-void
-print_lang_decl (file, node, indent)
-     FILE *file;
-     tree node;
-     int indent;
-{
-  if (!DECL_LANG_SPECIFIC (node))
-    return;
-  /* A FIELD_DECL only has the flags structure, which we aren't displaying
-     anyways.  */
-  if (TREE_CODE (node) == FIELD_DECL)
-    return;
-  indent_to (file, indent + 3);
-  if (DECL_MAIN_VARIANT (node))
-    {
-      fprintf (file, " decl-main-variant ");
-      fprintf (file, HOST_PTR_PRINTF, DECL_MAIN_VARIANT (node));
-    }
-  if (DECL_PENDING_INLINE_INFO (node))
-    {
-      fprintf (file, " pending-inline-info ");
-      fprintf (file, HOST_PTR_PRINTF, DECL_PENDING_INLINE_INFO (node));
-    }
-  if (DECL_TEMPLATE_INFO (node))
-    {
-      fprintf (file, " template-info ");
-      fprintf (file, HOST_PTR_PRINTF,  DECL_TEMPLATE_INFO (node));
-    }
-}
-
-void
-print_lang_type (file, node, indent)
-     FILE *file;
-     register tree node;
-     int indent;
-{
-  if (TREE_CODE (node) == TEMPLATE_TYPE_PARM)
-    {
-      print_node (file, "tinfo", TYPE_VALUES (node), indent + 4);
-      return;
-    }
-
-  if (TREE_CODE (node) == UNINSTANTIATED_P_TYPE)
-    {
-      print_node (file, "template", UPT_TEMPLATE (node), indent + 4);
-      print_node (file, "parameters", UPT_PARMS (node), indent + 4);
-      return;
-    }
-
-  if (! (TREE_CODE (node) == RECORD_TYPE
-	 || TREE_CODE (node) == UNION_TYPE))
-    return;
-
-  if (!TYPE_LANG_SPECIFIC (node))
-    return;
-
-  indent_to (file, indent + 3);
-
-  if (TYPE_NEEDS_CONSTRUCTOR (node))
-    fputs ( "needs-constructor", file);
-  if (TYPE_NEEDS_DESTRUCTOR (node))
-    fputs (" needs-destructor", file);
-  if (TYPE_HAS_CONVERSION (node))
-    fputs (" has-type-conversion", file);
-  if (TYPE_HAS_INT_CONVERSION (node))
-    fputs (" has-int-conversion", file);
-  if (TYPE_HAS_REAL_CONVERSION (node))
-    fputs (" has-float-conversion", file);
-  if (TYPE_HAS_INIT_REF (node))
-    fputs (" X(X&)", file);
-  if (TREE_GETS_NEW (node))
-    fputs (" gets-new", file);
-  if (TREE_GETS_DELETE (node))
-    fputs (" gets-delete", file);
-  if (TYPE_HAS_ASSIGNMENT (node))
-    fputs (" has=", file);
-  if (TYPE_GETS_ASSIGNMENT (node))
-    fputs (" gets=", file);
-  if (TYPE_HAS_ASSIGN_REF (node))
-    fputs (" this=(X&)", file);
-  if (TYPE_GETS_ASSIGN_REF (node))
-    fputs (" gets=(X&)", file);
-  if (TYPE_OVERLOADS_METHOD_CALL_EXPR (node))
-    fputs (" op->()", file);
-  if (TYPE_GETS_INIT_AGGR (node))
-    fputs (" gets X(X, ...)", file);
-  if (TYPE_OVERLOADS_CALL_EXPR (node))
-    fputs (" op()", file);
-  if (TYPE_OVERLOADS_ARRAY_REF (node))
-    fputs (" op[]", file);
-  if (TYPE_OVERLOADS_ARROW (node))
-    fputs (" op->", file);
-  if (TYPE_USES_MULTIPLE_INHERITANCE (node))
-    fputs (" uses-multiple-inheritance", file);
-
-  if (TREE_CODE (node) == RECORD_TYPE)
-    {
-      fprintf (file, " n_parents %d n_ancestors %d",
-	       CLASSTYPE_N_BASECLASSES (node),
-	       CLASSTYPE_N_SUPERCLASSES (node));
-      fprintf (file, " use_template=%d", CLASSTYPE_USE_TEMPLATE (node));
-      if (CLASSTYPE_INTERFACE_ONLY (node))
-	fprintf (file, " interface-only");
-      if (CLASSTYPE_INTERFACE_UNKNOWN (node))
-	fprintf (file, " interface-unknown");
-      print_node (file, "member-functions", CLASSTYPE_METHOD_VEC (node),
-		  indent + 4);
-      print_node (file, "baselinks",
-		  TYPE_BINFO_BASETYPES (node) ? CLASSTYPE_BASELINK_VEC (node) : NULL_TREE,
-		  indent + 4);
-    }
-}
-
-void
-print_lang_identifier (file, node, indent)
-     FILE *file;
-     tree node;
-     int indent;
-{
-  print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
-  print_node (file, "class", IDENTIFIER_CLASS_VALUE (node), indent + 4);
-  print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
-  print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
-  print_node (file, "template", IDENTIFIER_TEMPLATE (node), indent + 4);
-  print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
-  print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
-}
diff --git a/gnu/gcc2/cc1plus/cp-search.c b/gnu/gcc2/cc1plus/cp-search.c
deleted file mode 100644
index 9f3e0a5a1549..000000000000
--- a/gnu/gcc2/cc1plus/cp-search.c
+++ /dev/null
@@ -1,4284 +0,0 @@
-/* Breadth-first and depth-first routines for
-   searching multiple-inheritance lattice for GNU C++.
-   Copyright (C) 1987, 1989, 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-#if 0
-/* Remove before release, should only appear for development and testing. */
-#define CHECK_convert_pointer_to_single_level
-#endif
-
-/* High-level class interface. */
-
-#include "config.h"
-#include "tree.h"
-#include <stdio.h>
-#include "cp-tree.h"
-#include "obstack.h"
-#include "flags.h"
-
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
-void init_search ();
-extern struct obstack *current_obstack;
-
-#include "stack.h"
-
-/* Obstack used for remembering decision points of breadth-first.  */
-static struct obstack search_obstack;
-
-/* Obstack used to bridge from one function context to another.  */
-static struct obstack bridge_obstack;
-
-/* Methods for pushing and popping objects to and from obstacks.  */
-
-struct stack_level *
-push_stack_level (obstack, tp, size)
-     struct obstack *obstack;
-     char *tp;  /* Sony NewsOS 5.0 compiler doesn't like void * here.  */
-     int size;
-{
-  struct stack_level *stack;
-  /* FIXME.  Doesn't obstack_grow, in the case when the current chunk has
-     insufficient space, move the base so that obstack_next_free is not
-     valid?  Perhaps obstack_copy should be used rather than obstack_grow,
-     and its returned value be used.  -- Raeburn
-   */
-  stack = (struct stack_level *) obstack_next_free (obstack);
-  obstack_grow (obstack, tp, size);
-  obstack_finish (obstack);
-  stack->obstack = obstack;
-  stack->first = (tree *) obstack_base (obstack);
-  stack->limit = obstack_room (obstack) / sizeof (tree *);
-  return stack;
-}
-
-struct stack_level *
-pop_stack_level (stack)
-     struct stack_level *stack;
-{
-  struct stack_level *tem = stack;
-  struct obstack *obstack = tem->obstack;
-  stack = tem->prev;
-  obstack_free (obstack, tem);
-  return stack;
-}
-
-#define search_level stack_level
-static struct search_level *search_stack;
-
-static tree lookup_field_1 ();
-static int lookup_fnfields_1 ();
-static void dfs_walk ();
-static int markedp ();
-static void dfs_unmark ();
-static void dfs_init_vbase_pointers ();
-
-static tree vbase_types;
-static tree vbase_decl, vbase_decl_ptr;
-static tree vbase_decl_ptr_intermediate;
-static tree vbase_init_result;
-
-/* Allocate a level of searching.  */
-static struct search_level *
-push_search_level (stack, obstack)
-     struct stack_level *stack;
-     struct obstack *obstack;
-{
-  struct search_level tem;
-  tem.prev = stack;
-
-  return push_stack_level (obstack, (char *) &tem, sizeof (tem));
-}
-
-/* Discard a level of search allocation.  */
-#define pop_search_level pop_stack_level
-
-/* Search memoization.  */
-struct type_level
-{
-  struct stack_level base;
-
-  /* First object allocated in obstack of entries.  */
-  char *entries;
-
-  /* Number of types memoized in this context.  */
-  int len;
-
-  /* Type being memoized; save this if we are saving
-     memoized contexts.  */
-  tree type;
-};
-
-/* Obstack used for memoizing member and member function lookup.  */
-
-static struct obstack type_obstack, type_obstack_entries;
-static struct type_level *type_stack;
-static tree _vptr_name;
-
-/* Make things that look like tree nodes, but allocate them
-   on type_obstack_entries.  */
-static int my_tree_node_counter;
-static tree my_tree_cons (), my_build_string ();
-
-extern int flag_memoize_lookups, flag_save_memoized_contexts;
-
-/* Variables for gathering statistics.  */
-static int my_memoized_entry_counter;
-static int memoized_fast_finds[2], memoized_adds[2], memoized_fast_rejects[2];
-static int memoized_fields_searched[2];
-static int n_fields_searched;
-static int n_calls_lookup_field, n_calls_lookup_field_1;
-static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1;
-static int n_calls_get_base_type;
-static int n_outer_fields_searched;
-static int n_contexts_saved;
-
-/* Local variables to help save memoization contexts.  */
-static tree prev_type_memoized;
-static struct type_level *prev_type_stack;
-
-/* Allocate a level of type memoization context.  */
-static struct type_level *
-push_type_level (stack, obstack)
-     struct stack_level *stack;
-     struct obstack *obstack;
-{
-  struct type_level tem;
-
-  tem.base.prev = stack;
-
-  obstack_finish (&type_obstack_entries);
-  tem.entries = (char *) obstack_base (&type_obstack_entries);
-  tem.len = 0;
-  tem.type = NULL_TREE;
-
-  return (struct type_level *)push_stack_level (obstack, (char *) &tem,
-						sizeof (tem));
-}
-
-/* Discard a level of type memoization context.  */
-
-static struct type_level *
-pop_type_level (stack)
-     struct type_level *stack;
-{
-  obstack_free (&type_obstack_entries, stack->entries);
-  return (struct type_level *)pop_stack_level ((struct stack_level *)stack);
-}
-
-/* Make something that looks like a TREE_LIST, but
-   do it on the type_obstack_entries obstack.  */
-static tree
-my_tree_cons (purpose, value, chain)
-     tree purpose, value, chain;
-{
-  tree p = (tree)obstack_alloc (&type_obstack_entries, sizeof (struct tree_list));
-  ++my_tree_node_counter;
-  TREE_TYPE (p) = NULL_TREE;
-  ((HOST_WIDE_INT *)p)[3] = 0;
-  TREE_SET_CODE (p, TREE_LIST);
-  TREE_PURPOSE (p) = purpose;
-  TREE_VALUE (p) = value;
-  TREE_CHAIN (p) = chain;
-  return p;
-}
-
-static tree
-my_build_string (str)
-     char *str;
-{
-  tree p = (tree)obstack_alloc (&type_obstack_entries, sizeof (struct tree_string));
-  ++my_tree_node_counter;
-  TREE_TYPE (p) = 0;
-  ((int *)p)[3] = 0;
-  TREE_SET_CODE (p, STRING_CST);
-  TREE_STRING_POINTER (p) = str;
-  TREE_STRING_LENGTH (p) = strlen (str);
-  return p;
-}
-
-/* Memoizing machinery to make searches for multiple inheritance
-   reasonably efficient.  */
-#define MEMOIZE_HASHSIZE 8
-typedef struct memoized_entry
-{
-  struct memoized_entry *chain;
-  int uid;
-  tree data_members[MEMOIZE_HASHSIZE];
-  tree function_members[MEMOIZE_HASHSIZE];
-} *ME;
-
-#define MEMOIZED_CHAIN(ENTRY) (((ME)ENTRY)->chain)
-#define MEMOIZED_UID(ENTRY) (((ME)ENTRY)->uid)
-#define MEMOIZED_FIELDS(ENTRY,INDEX) (((ME)ENTRY)->data_members[INDEX])
-#define MEMOIZED_FNFIELDS(ENTRY,INDEX) (((ME)ENTRY)->function_members[INDEX])
-/* The following is probably a lousy hash function.  */
-#define MEMOIZED_HASH_FN(NODE) (((long)(NODE)>>4)&(MEMOIZE_HASHSIZE - 1))
-
-static struct memoized_entry *
-my_new_memoized_entry (chain)
-     struct memoized_entry *chain;
-{
-  struct memoized_entry *p =
-    (struct memoized_entry *)obstack_alloc (&type_obstack_entries,
-					    sizeof (struct memoized_entry));
-  bzero (p, sizeof (struct memoized_entry));
-  MEMOIZED_CHAIN (p) = chain;
-  MEMOIZED_UID (p) = ++my_memoized_entry_counter;
-  return p;
-}
-
-/* Make an entry in the memoized table for type TYPE
-   that the entry for NAME is FIELD.  */
-
-tree
-make_memoized_table_entry (type, name, function_p)
-     tree type, name;
-     int function_p;
-{
-  int index = MEMOIZED_HASH_FN (name);
-  tree entry, *prev_entry;
-
-  memoized_adds[function_p] += 1;
-  if (CLASSTYPE_MTABLE_ENTRY (type) == 0)
-    {
-      obstack_ptr_grow (&type_obstack, type);
-      obstack_blank (&type_obstack, sizeof (struct memoized_entry *));
-      CLASSTYPE_MTABLE_ENTRY (type) = (char *)my_new_memoized_entry ((struct memoized_entry *)0);
-      type_stack->len++;
-      if (type_stack->len * 2 >= type_stack->base.limit)
-	my_friendly_abort (88);
-    }
-  if (function_p)
-    prev_entry = &MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
-  else
-    prev_entry = &MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
-
-  entry = my_tree_cons (name, NULL_TREE, *prev_entry);
-  *prev_entry = entry;
-
-  /* Don't know the error message to give yet.  */
-  TREE_TYPE (entry) = error_mark_node;
-
-  return entry;
-}
-
-/* When a new function or class context is entered, we build
-   a table of types which have been searched for members.
-   The table is an array (obstack) of types.  When a type is
-   entered into the obstack, its CLASSTYPE_MTABLE_ENTRY
-   field is set to point to a new record, of type struct memoized_entry.
-
-   A non-NULL TREE_TYPE of the entry contains a visibility error message.
-
-   The slots for the data members are arrays of tree nodes.
-   These tree nodes are lists, with the TREE_PURPOSE
-   of this list the known member name, and the TREE_VALUE
-   as the FIELD_DECL for the member.
-
-   For member functions, the TREE_PURPOSE is again the
-   name of the member functions for that class,
-   and the TREE_VALUE of the list is a pairs
-   whose TREE_PURPOSE is a member functions of this name,
-   and whose TREE_VALUE is a list of known argument lists this
-   member function has been called with.  The TREE_TYPE of the pair,
-   if non-NULL, is an error message to print.  */
-
-/* Tell search machinery that we are entering a new context, and
-   to update tables appropriately.
-
-   TYPE is the type of the context we are entering, which can
-   be NULL_TREE if we are not in a class's scope.
-
-   USE_OLD, if nonzero tries to use previous context.  */
-void
-push_memoized_context (type, use_old)
-     tree type;
-     int use_old;
-{
-  int len;
-  tree *tem;
-
-  if (prev_type_stack)
-    {
-      if (use_old && prev_type_memoized == type)
-	{
-#ifdef GATHER_STATISTICS
-	  n_contexts_saved++;
-#endif
-	  type_stack = prev_type_stack;
-	  prev_type_stack = 0;
-
-	  tem = &type_stack->base.first[0];
-	  len = type_stack->len;
-	  while (len--)
-	    CLASSTYPE_MTABLE_ENTRY (tem[len*2]) = (char *)tem[len*2+1];
-	  return;
-	}
-      /* Otherwise, need to pop old stack here.  */
-      type_stack = pop_type_level (prev_type_stack);
-      prev_type_memoized = 0;
-      prev_type_stack = 0;
-    }
-
-  type_stack = push_type_level ((struct stack_level *)type_stack,
-				&type_obstack);
-  type_stack->type = type;
-}
-
-/* Tell search machinery that we have left a context.
-   We do not currently save these contexts for later use.
-   If we wanted to, we could not use pop_search_level, since
-   poping that level allows the data we have collected to
-   be clobbered; a stack of obstacks would be needed.  */
-void
-pop_memoized_context (use_old)
-     int use_old;
-{
-  int len;
-  tree *tem = &type_stack->base.first[0];
-
-  if (! flag_save_memoized_contexts)
-    use_old = 0;
-  else if (use_old)
-    {
-      len = type_stack->len;
-      while (len--)
-	tem[len*2+1] = (tree)CLASSTYPE_MTABLE_ENTRY (tem[len*2]);
-
-      prev_type_stack = type_stack;
-      prev_type_memoized = type_stack->type;
-    }
-
-  if (flag_memoize_lookups)
-    {
-      len = type_stack->len;
-      while (len--)
-	CLASSTYPE_MTABLE_ENTRY (tem[len*2])
-	  = (char *)MEMOIZED_CHAIN (CLASSTYPE_MTABLE_ENTRY (tem[len*2]));
-    }
-  if (! use_old)
-    type_stack = pop_type_level (type_stack);
-  else
-    type_stack = (struct type_level *)type_stack->base.prev;
-}
-
-/* This can go away when the new searching strategy as a little mileage on it. */
-#define NEW_SEARCH 1
-#if NEW_SEARCH
-/* This is the newer recursive depth first one, the old one follows. */
-static tree
-get_binfo_recursive (binfo, is_private, parent, rval, rval_private_ptr, xtype,
-		     friends, protect)
-     tree binfo, parent, rval, xtype, friends;
-     int *rval_private_ptr, protect, is_private;
-{
-  tree binfos;
-  int i, n_baselinks;
-
-  if (BINFO_TYPE (binfo) == parent)
-    {
-      if (rval == NULL_TREE)
-	{
-	  rval = binfo;
-	  *rval_private_ptr = is_private;
-	}
-      else
-	{
-	  /* I believe it is the case that this error is only an error
-	     when used by someone that wants error messages printed.
-	     Routines that call this one, that don't set protect want
-	     the first one found, even if there are more.  */
-	  if (protect)
-	    {
-	      /* Found two or more possible return values.  */
-	      error_with_aggr_type (parent, "type `%s' is ambiguous base class for type `%s'",
-				    TYPE_NAME_STRING (xtype));
-	      rval = error_mark_node;
-	    }
-	}
-      return rval;
-    }
-
-  binfos = BINFO_BASETYPES (binfo);
-  n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  /* Process base types.  */
-  for (i = 0; i < n_baselinks; i++)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-      if (BINFO_MARKED (base_binfo) == 0)
-	{
-	  int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo);
-
-	  SET_BINFO_MARKED (base_binfo);
-
-	  if (via_private == 0)
-	    ;
-	  else if (protect == 0)
-	    via_private = 0;
-	  else if (protect == 1 && BINFO_TYPE (binfo) == current_class_type)
-	    /* The immediate base class of the class we are in
-	       does let its public members through.  */
-	    via_private = 0;
-#ifndef NOJJG
-	  else if (protect
-		   && friends != NULL_TREE
-		   && BINFO_TYPE (binfo) == xtype
-		   && value_member (current_class_type, friends))
-	    /* Friend types of the most derived type have access
-	       to its baseclass pointers.  */
-	    via_private = 0;
-#endif
-
-	  rval = get_binfo_recursive (base_binfo, via_private, parent, rval,
-				      rval_private_ptr, xtype, friends,
-				      protect);
-	  if (rval == error_mark_node)
-	    return rval;
-	}
-    }
-
-  return rval;
-}
-
-/* Check whether the type given in BINFO is derived from PARENT.  If
-   it isn't, return 0.  If it is, but the derivation is MI-ambiguous
-   AND protect != 0, emit an error message and return error_mark_node.
-
-   Otherwise, if TYPE is derived from PARENT, return the actual base
-   information, unless a one of the protection violations below
-   occurs, in which case emit an error message and return error_mark_node.
-
-   The below should be worded better.  It may not be exactly what the code
-   does, but there should be a lose correlation.  If you understand the code
-   well, please try and make the comments below more readable.
-
-   If PROTECT is 1, then check if access to a public field of PARENT
-   would be private.
-
-   If PROTECT is 2, then check if the given type is derived from
-   PARENT via private visibility rules.
-
-   If PROTECT is 3, then immediately private baseclass is ok,
-   but deeper than that, check if private.  */
-tree
-get_binfo (parent, binfo, protect)
-     register tree parent, binfo;
-     int protect;
-{
-  tree xtype, type;
-  tree otype;
-  int head = 0, tail = 0;
-  int is_private = 0;
-  tree rval = NULL_TREE;
-  int rval_private = 0;
-  tree friends;
-
-#ifdef GATHER_STATISTICS
-  n_calls_get_base_type++;
-#endif
-
-  if (TREE_CODE (parent) == TREE_VEC)
-    parent = BINFO_TYPE (parent);
-  /* unions cannot participate in inheritance relationships */
-  else if (TREE_CODE (parent) == UNION_TYPE)
-    return NULL_TREE;
-  else if (TREE_CODE (parent) != RECORD_TYPE)
-    my_friendly_abort (89);
-
-  parent = TYPE_MAIN_VARIANT (parent);
-
-  if (TREE_CODE (binfo) == TREE_VEC)
-    type = BINFO_TYPE (binfo);
-  else if (TREE_CODE (binfo) == RECORD_TYPE)
-    {
-      type = binfo;
-      binfo = TYPE_BINFO (type);
-    }
-  else my_friendly_abort (90);
-  xtype = type;
-  friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE;
-
-  rval = get_binfo_recursive (binfo, is_private, parent, rval, &rval_private,
-			      xtype, friends, protect);
-
-  dfs_walk (binfo, dfs_unmark, markedp);
-
-  if (rval && protect && rval_private)
-    {
-      if (protect == 3)
-	{
-	  tree binfos = BINFO_BASETYPES (TYPE_BINFO (xtype));
-	  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-	  for (i = 0; i < n_baselinks; i++)
-	    {
-	      tree base_binfo = TREE_VEC_ELT (binfos, i);
-	      if (parent == BINFO_TYPE (base_binfo))
-		/* It's ok, since it's immediate.  */
-		return rval;
-	    }
-	}
-      error_with_aggr_type (xtype, "type `%s' is derived from private `%s'",
-			    TYPE_NAME_STRING (parent));
-      return error_mark_node;
-    }
-
-  return rval;
-}
-#else
-/* Check whether the type given in BINFO is derived from PARENT.  If
-   it isn't, return 0.  If it is, but the derivation is MI-ambiguous
-   AND protect != 0, emit an error message and return error_mark_node.
-
-   Otherwise, if TYPE is derived from PARENT, return the actual base
-   information, unless a one of the protection violations below
-   occurs, in which case emit an error message and return error_mark_node.
-
-   The below should be worded better.  It may not be exactly what the code
-   does, but there should be a lose correlation.  If you understand the code
-   well, please try and make the comments below more readable.
-
-   If PROTECT is 1, then check if access to a public field of PARENT
-   would be private.
-
-   If PROTECT is 2, then check if the given type is derived from
-   PARENT via private visibility rules.
-
-   If PROTECT is 3, then immediately private baseclass is ok,
-   but deeper than that, check if private.  */
-tree
-get_binfo (parent, binfo, protect)
-     register tree parent, binfo;
-     int protect;
-{
-  tree xtype, type;
-  tree otype;
-  int head = 0, tail = 0;
-  int is_private = 0;
-  tree rval = NULL_TREE;
-  int rval_private = 0;
-  tree friends;
-
-#ifdef GATHER_STATISTICS
-  n_calls_get_base_type++;
-#endif
-
-  if (TREE_CODE (parent) == TREE_VEC)
-    parent = BINFO_TYPE (parent);
-  /* unions cannot participate in inheritance relationships */
-  else if (TREE_CODE (parent) == UNION_TYPE)
-    return NULL_TREE;
-  else if (TREE_CODE (parent) != RECORD_TYPE)
-    my_friendly_abort (89);
-
-  parent = TYPE_MAIN_VARIANT (parent);
-  search_stack = push_search_level (search_stack, &search_obstack);
-
-  if (TREE_CODE (binfo) == TREE_VEC)
-    type = BINFO_TYPE (binfo);
-  else if (TREE_CODE (binfo) == RECORD_TYPE)
-    {
-      type = binfo;
-      binfo = TYPE_BINFO (type);
-    }
-  else my_friendly_abort (90);
-  xtype = type;
-  friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE;
-
-  while (1)
-    {
-      tree binfos = BINFO_BASETYPES (binfo);
-      int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-      /* Process and/or queue base types.  */
-      for (i = 0; i < n_baselinks; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-	  if (BINFO_MARKED (base_binfo) == 0)
-	    {
-	      int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo);
-
-	      SET_BINFO_MARKED (base_binfo);
-
-	      if (via_private == 0)
-		;
-	      else if (protect == 0)
-		via_private = 0;
-	      else if (protect == 1 && BINFO_TYPE (binfo) == current_class_type)
-		/* The immediate base class of the class we are in
-		   does let its public members through.  */
-		via_private = 0;
-#ifndef NOJJG
-	      else if (protect
-		       && friends != NULL_TREE
-		       && BINFO_TYPE (binfo) == xtype
-		       && value_member (current_class_type, friends))
-		/* Friend types of the most derived type have access
-		   to its baseclass pointers.  */
-		via_private = 0;
-#endif
-
-	      otype = type;
-	      obstack_ptr_grow (&search_obstack, base_binfo);
-	      obstack_ptr_grow (&search_obstack, (void *) via_private);
-	      tail += 2;
-	      if (tail >= search_stack->limit)
-		my_friendly_abort (91);
-	    }
-#if 0
-	  /* This code cannot possibly be right.  Ambiguities can only be
-	     checked by traversing the whole tree, and seeing if it pops
-	     up twice. */
-	  else if (protect && ! TREE_VIA_VIRTUAL (base_binfo))
-	    {
-	      error_with_aggr_type (parent, "type `%s' is ambiguous base class for type `%s'",
-				    TYPE_NAME_STRING (xtype));
-	      error ("(base class for types `%s' and `%s')",
-		     TYPE_NAME_STRING (BINFO_TYPE (binfo)),
-		     TYPE_NAME_STRING (otype));
-	      rval = error_mark_node;
-	      goto cleanup;
-	    }
-#endif
-	}
-
-    dont_queue:
-      /* Process head of queue, if one exists.  */
-      if (head >= tail)
-	break;
-
-      binfo = search_stack->first[head++];
-      is_private = (int) search_stack->first[head++];
-      if (BINFO_TYPE (binfo) == parent)
-	{
-	  if (rval == 0)
-	    {
-	      rval = binfo;
-	      rval_private = is_private;
-	    }
-	  else
-	    /* I believe it is the case that this error is only an error when
-	       used by someone that wants error messages printed.  Routines that
-	       call this one, that don't set protect want the first one found,
-	       even if there are more.  */
-	    if (protect)
-	      {
-		/* Found two or more possible return values.  */
-		error_with_aggr_type (parent, "type `%s' is ambiguous base class for type `%s'",
-				      TYPE_NAME_STRING (xtype));
-		rval = error_mark_node;
-		goto cleanup;
-	      }
-	  goto dont_queue;
-	}
-    }
-
- cleanup:
-  {
-    tree *tp = search_stack->first;
-    tree *search_tail = tp + tail;
-
-    while (tp < search_tail)
-      {
-	CLEAR_BINFO_MARKED (*tp);
-	tp += 2;
-      }
-  }
-  search_stack = pop_search_level (search_stack);
-
-  if (rval == error_mark_node)
-    return error_mark_node;
-
-  if (rval && protect && rval_private)
-    {
-      if (protect == 3)
-	{
-	  tree binfos = BINFO_BASETYPES (TYPE_BINFO (xtype));
-	  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-	  for (i = 0; i < n_baselinks; i++)
-	    {
-	      tree base_binfo = TREE_VEC_ELT (binfos, i);
-	      if (parent == BINFO_TYPE (base_binfo))
-		/* It's ok, since it's immediate.  */
-		return rval;
-	    }
-	}
-      error_with_aggr_type (xtype, "type `%s' is derived from private `%s'",
-			    TYPE_NAME_STRING (parent));
-      return error_mark_node;
-    }
-
-  return rval;
-}
-#endif
-
-#if NEW_SEARCH
-/* This is the newer depth first get_base_distance, the older one follows.  */
-static
-get_base_distance_recursive (binfo, depth, is_private, basetype_path, rval,
-			     rval_private_ptr, new_binfo_ptr, parent, path_ptr,
-			     protect, via_virtual_ptr, via_virtual)
-     tree binfo, basetype_path, *new_binfo_ptr, parent, *path_ptr;
-     int *rval_private_ptr, depth, is_private, rval, protect, *via_virtual_ptr,
-       via_virtual;
-{
-  tree binfos;
-  int i, n_baselinks;
-
-  if (BINFO_TYPE (binfo) == parent)
-    {
-      if (rval == -1)
-	{
-	  rval = depth;
-	  *rval_private_ptr = is_private;
-	  *new_binfo_ptr = binfo;
-	  *via_virtual_ptr = via_virtual;
-	}
-      else
-	{
-	  int same_object = tree_int_cst_equal (BINFO_OFFSET (*new_binfo_ptr),
-						BINFO_OFFSET (binfo));
-
-	  if (*via_virtual_ptr && via_virtual==0)
-	    {
-	      *rval_private_ptr = is_private;
-	      *new_binfo_ptr = binfo;
-	      *via_virtual_ptr = via_virtual;
-	    }
-	  else if (same_object)
-	    {
-	      /* Note, this should probably succeed to find, and
-		 override the old one if the old one was private and
-		 this one isn't.  */
-	      return rval;
-	    }
-
-	  rval = -2;
-	}
-      return rval;
-    }
-
-  binfos = BINFO_BASETYPES (binfo);
-  n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-  depth += 1;
-
-  /* Process base types.  */
-  for (i = 0; i < n_baselinks; i++)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-      if (BINFO_MARKED (base_binfo) == 0)
-	{
-	  int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo);
-	  int was;
-
-	  /* When searching for a non-virtual, we cannot mark
-	     virtually found binfos. */
-	  if (!via_virtual)
-	    SET_BINFO_MARKED (base_binfo);
-
-	  if (via_private == 0)
-	    ;
-	  else if (protect == 0)
-	    via_private = 0;
-
-#define WATCH_VALUES(rval, via_private) (rval == -1 ? 3 : via_private)
-
-	  was = WATCH_VALUES (rval, *via_virtual_ptr);
-	  rval = get_base_distance_recursive (base_binfo, depth, via_private,
-					      binfo, rval, rval_private_ptr,
-					      new_binfo_ptr, parent, path_ptr,
-					      protect, via_virtual_ptr,
-					      TREE_VIA_VIRTUAL (base_binfo)|via_virtual);
-	  /* watch for updates, only update, if path is good. */
-	  if (path_ptr && WATCH_VALUES (rval, *via_virtual_ptr) != was)
-	    BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
-	  if (rval == -2 && *via_virtual_ptr == 0)
-	    return rval;
-
-#undef WATCH_VALUES
-
-	}
-    }
-
-  return rval;
-}
-
-/* Return the number of levels between type PARENT and the type given
-   in BINFO, following the leftmost path to PARENT not found along a
-   virtual path, if there are no real PARENTs (all come from virtual
-   base classes), then follow the leftmost path to PARENT.
-
-   Return -1 if TYPE is not derived from PARENT.
-   Return -2 if PARENT is an ambiguous base class of TYPE.
-   Return -3 if PARENT is private to TYPE, and protect is non-zero.
-
-   If PATH_PTR is non-NULL, then also build the list of types
-   from PARENT to TYPE, with TREE_VIA_VIRUAL and TREE_VIA_PUBLIC
-   set.
-
-   It is unclear whether or not the path should be built if -2 and/or
-   -3 is returned.  Maybe, maybe not.  I suspect that there is code
-   that relies upon it being built, such as prepare_fresh_vtable.
-   (mrs)
-
-   Also, it would appear that we only sometimes want -2.  The question is
-   under what exact conditions do we want to see -2, and when do we not
-   want to see -2.  (mrs)
-
-   It is also unlikely that this thing finds all ambiguties, as I
-   don't trust any deviation from the method used in get_binfo.  It
-   would be nice to use that method here, as it is simple and straight
-   forward.  The code here and in recursive_bounded_basetype_p is not.
-   For now, I shall include an extra call to find ambiguities.  (mrs)
-   */
-
-int
-get_base_distance (parent, binfo, protect, path_ptr)
-     register tree parent, binfo;
-     int protect;
-     tree *path_ptr;
-{
-  int head, tail;
-  int is_private = 0;
-  int rval = -1;
-  int depth = 0;
-  int rval_private = 0;
-  tree type, basetype_path;
-  tree friends;
-  int use_leftmost;
-  tree new_binfo;
-  int via_virtual;
-
-  if (TYPE_READONLY (parent) || TYPE_VOLATILE (parent))
-    parent = TYPE_MAIN_VARIANT (parent);
-  use_leftmost = (parent == TYPE_MAIN_VARIANT (parent));
-
-  if (TREE_CODE (binfo) == TREE_VEC)
-    type = BINFO_TYPE (binfo);
-  else if (TREE_CODE (binfo) == RECORD_TYPE)
-    {
-      type = binfo;
-      binfo = TYPE_BINFO (type);
-    }
-  else my_friendly_abort (92);
-
-  friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE;
-
-  if (path_ptr)
-    {
-      basetype_path = TYPE_BINFO (type);
-      BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
-    }
-
-  if (TYPE_MAIN_VARIANT (parent) == type)
-    {
-      /* If the distance is 0, then we don't really need
-	 a path pointer, but we shouldn't let garbage go back.  */
-      if (path_ptr)
-	*path_ptr = basetype_path;
-      return 0;
-    }
-
-  rval = get_base_distance_recursive (binfo, 0, 0, NULL_TREE, rval,
-				      &rval_private, &new_binfo, parent,
-				      path_ptr, protect, &via_virtual, 0);
-
-  if (path_ptr)
-    BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
-
-  basetype_path = binfo;
-
-  dfs_walk (binfo, dfs_unmark, markedp);
-
-  binfo = new_binfo;
-
-  /* Visibilities don't count if we found an ambiguous basetype.  */
-  if (rval == -2)
-    rval_private = 0;
-
-  if (rval && protect && rval_private)
-    return -3;
-
-  if (path_ptr)
-    *path_ptr = binfo;
-  return rval;
-}
-#else
-/* Recursively search for a path from PARENT to BINFO.
-   If RVAL is > 0 and we succeed, update the BINFO_INHERITANCE_CHAIN
-   pointers.
-   If we find a distinct basetype that's not the one from BINFO,
-   return -2;
-   If we don't find any path, return 0.
-
-   If we encounter a virtual basetype on the path, return RVAL
-   and don't change any pointers after that point.  */
-static int
-recursive_bounded_basetype_p (parent, binfo, rval, update_chain)
-     tree parent, binfo;
-     int rval;
-     int update_chain;
-{
-  tree binfos;
-
-  if (BINFO_TYPE (parent) == BINFO_TYPE (binfo))
-    {
-      if (tree_int_cst_equal (BINFO_OFFSET (parent), BINFO_OFFSET (binfo)))
-	return rval;
-      return -2;
-    }
-
-  if (TREE_VIA_VIRTUAL (binfo))
-    update_chain = 0;
-
-  if (binfos = BINFO_BASETYPES (binfo))
-    {
-      int i, nval;
-      for (i = 0; i < TREE_VEC_LENGTH (binfos); i++)
-	{
-	  nval = recursive_bounded_basetype_p (parent, TREE_VEC_ELT (binfos, i),
-					       rval, update_chain);
-	  if (nval < 0)
-	    return nval;
-	  if (nval > 0 && update_chain)
-	    BINFO_INHERITANCE_CHAIN (TREE_VEC_ELT (binfos, i)) = binfo;
-	}
-      return rval;
-    }
-  return 0;
-}
-
-/* -------------------------------------------------- */
-/* These two routines are ONLY here to check for ambiguities for
-   get_base_distance, as it probably cannot check by itself for
-   all ambiguities.  When get_base_distance is sure to check for all,
-   these routines can go.  (mrs) */
-
-static tree
-get_binfo2_recursive (binfo, parent, type)
-     register tree binfo, parent;
-     tree type;
-{
-  tree rval = NULL_TREE;
-  tree nrval;
-  tree binfos = BINFO_BASETYPES (binfo);
-  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  if (BINFO_TYPE (binfo) == parent)
-    {
-      return binfo;
-    }
-
-  /* Process base types.  */
-  for (i = 0; i < n_baselinks; i++)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-      if (BINFO_MARKED (base_binfo) == 0)
-	{
-	  SET_BINFO_MARKED (base_binfo);
-
-	  nrval = get_binfo2_recursive (base_binfo, parent, type);
-
-	  if (nrval == error_mark_node)
-	    return nrval;
-	  if (nrval)
-	    if (rval == 0)
-	      {
-		rval = nrval;
-	      }
-	    else
-	      return error_mark_node;
-	}
-    }
-  return rval;
-}
-
-static tree
-get_binfo2 (parent, binfo)
-     register tree parent, binfo;
-{
-  tree type;
-  tree rval = NULL_TREE;
-
-  if (TREE_CODE (parent) == TREE_VEC)
-    parent = BINFO_TYPE (parent);
-  /* unions cannot participate in inheritance relationships */
-  else if (TREE_CODE (parent) == UNION_TYPE)
-    return 0;
-  else if (TREE_CODE (parent) != RECORD_TYPE)
-    my_friendly_abort (89);
-
-  parent = TYPE_MAIN_VARIANT (parent);
-
-  if (TREE_CODE (binfo) == TREE_VEC)
-    type = BINFO_TYPE (binfo);
-  else if (TREE_CODE (binfo) == RECORD_TYPE)
-    {
-      type = binfo;
-      binfo = TYPE_BINFO (type);
-    }
-  else my_friendly_abort (90);
-
-  rval = get_binfo2_recursive (binfo, parent, type);
-
-  dfs_walk (binfo, dfs_unmark, markedp);
-
-  return rval;
-}
-
-/* -------------------------------------------------- */
-
-/* Return the number of levels between type PARENT and the type given
-   in BINFO, following the leftmost path to PARENT.  If PARENT is its
-   own main type variant, then if PARENT appears in different places
-   from TYPE's point of view, the leftmost PARENT will be the one
-   chosen.
-
-   Return -1 if TYPE is not derived from PARENT.
-   Return -2 if PARENT is an ambiguous base class of TYPE.
-   Return -3 if PARENT is private to TYPE, and protect is non-zero.
-
-   If PATH_PTR is non-NULL, then also build the list of types
-   from PARENT to TYPE, with TREE_VIA_VIRUAL and TREE_VIA_PUBLIC
-   set.
-
-   It is unclear whether or not the path should be built if -2 and/or
-   -3 is returned.  Maybe, maybe not.  I suspect that there is code
-   that relies upon it being built, such as prepare_fresh_vtable.
-   (mrs)
-
-   Also, it would appear that we only sometimes want -2.  The question is
-   under what exact conditions do we want to see -2, and when do we not
-   want to see -2.  (mrs)
-
-   It is also unlikely that this thing finds all ambiguties, as I
-   don't trust any deviation from the method used in get_binfo.  It
-   would be nice to use that method here, as it is simple and straight
-   forward.  The code here and in recursive_bounded_basetype_p is not.
-   For now, I shall include an extra call to find ambiguities.  (mrs)
-   */
-
-int
-get_base_distance (parent, binfo, protect, path_ptr)
-     register tree parent, binfo;
-     int protect;
-     tree *path_ptr;
-{
-  int head, tail;
-  int is_private = 0;
-  int rval = -1;
-  int depth = 0;
-  int rval_private = 0;
-  tree type, basetype_path;
-  tree friends;
-  int use_leftmost;
-
-  if (TYPE_READONLY (parent) || TYPE_VOLATILE (parent))
-    parent = TYPE_MAIN_VARIANT (parent);
-  use_leftmost = (parent == TYPE_MAIN_VARIANT (parent));
-
-  if (TREE_CODE (binfo) == TREE_VEC)
-    type = BINFO_TYPE (binfo);
-  else if (TREE_CODE (binfo) == RECORD_TYPE)
-    {
-      type = binfo;
-      binfo = TYPE_BINFO (type);
-    }
-  else if (TREE_CODE (binfo) == UNION_TYPE)
-    {
-      /* UNION_TYPEs do not participate in inheritance relationships.  */
-      return -1;
-    }
-  else my_friendly_abort (92);
-
-  friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE;
-
-  if (path_ptr)
-    {
-      basetype_path = TYPE_BINFO (type);
-      BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
-    }
-
-  if (TYPE_MAIN_VARIANT (parent) == type)
-    {
-      /* If the distance is 0, then we don't really need
-	 a path pointer, but we shouldn't let garbage go back.  */
-      if (path_ptr)
-	*path_ptr = basetype_path;
-      return 0;
-    }
-
-  search_stack = push_search_level (search_stack, &search_obstack);
-
-  /* Keep space for TYPE.  */
-  obstack_ptr_grow (&search_obstack, binfo);
-  obstack_ptr_grow (&search_obstack, NULL_PTR);
-  obstack_ptr_grow (&search_obstack, NULL_PTR);
-  if (path_ptr)
-    {
-      obstack_ptr_grow (&search_obstack, NULL_PTR);
-      head = 4;
-    }
-  else head = 3;
-  tail = head;
-
-  while (1)
-    {
-      tree binfos = BINFO_BASETYPES (binfo);
-      int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-      /* Process and/or queue base types.  */
-      for (i = 0; i < n_baselinks; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-	  if (BINFO_MARKED (base_binfo) == 0)
-	    {
-	      int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo);
-
-	      SET_BINFO_MARKED (base_binfo);
-
-	      if (via_private == 0)
-		;
-	      else if (protect == 0)
-		via_private = 0;
-
-	      obstack_ptr_grow (&search_obstack, base_binfo);
-	      obstack_ptr_grow (&search_obstack, (HOST_WIDE_INT) depth);
-	      obstack_ptr_grow (&search_obstack, (HOST_WIDE_INT) via_private);
-	      tail += 3;
-	      if (path_ptr)
-		{
-		  obstack_ptr_grow (&search_obstack, basetype_path);
-		  tail += 1;
-		}
-	      if (tail >= search_stack->limit)
-		my_friendly_abort (93);
-	    }
-#if 0
-	  /* This code cannot possibly be right.  Ambiguities can only be
-	     checked by traversing the whole tree, and seeing if it pops
-	     up twice. */
-	  else if (! TREE_VIA_VIRTUAL (base_binfo))
-	    {
-	      rval = -2;
-	      goto done;
-	    }
-#endif
-	}
-
-      /* Process head of queue, if one exists.  */
-      if (head >= tail)
-	break;
-
-      binfo = search_stack->first[head++];
-      depth = (int) search_stack->first[head++] + 1;
-      is_private = (int) search_stack->first[head++];
-      if (path_ptr)
-	{
-	  basetype_path = search_stack->first[head++];
-	  BINFO_INHERITANCE_CHAIN (binfo) = basetype_path;
-	  basetype_path = binfo;
-	}
-      if (BINFO_TYPE (binfo) == parent)
-	{
-	  /* It is wrong to set this and break, the proper thing to do
-	     would be to set it only if it has not been set before,
-	     and if is has been set, an ambiguity exists, and just
-	     continue searching the tree for more of them as is done
-	     in get_binfo.  But until the code below can cope, this
-	     can't be done. Also, it is not clear what should happen if
-	     use_leftmost is set.  */
-	  rval = depth;
-	  rval_private = is_private;
-	  break;
-	}
-    }
-#if 0
-  /* Unneeded now, as we know the above code in the #if 0 is wrong.  */
- done:
-#endif
-  {
-    int increment = path_ptr ? 4 : 3;
-    tree *tp = search_stack->first;
-    tree *search_tail = tp + tail;
-
-    /* We can skip the first entry, since it wasn't marked.  */
-    tp += increment;
-
-    basetype_path = binfo;
-    while (tp < search_tail)
-      {
-	CLEAR_BINFO_MARKED (*tp);
-	tp += increment;
-      }
-
-    /* Now, guarantee that we are following the leftmost path in the
-       chain.  Algorithm: the search stack holds tuples in BFS order.
-       The last tuple on the search stack contains the tentative binfo
-       for the basetype we are looking for.  We know that starting
-       with FIRST, each tuple with only a single basetype must be on
-       the leftmost path.  Each time we come to a split, we select
-       the tuple for the leftmost basetype that can reach the ultimate
-       basetype.  */
-
-    if (use_leftmost
-	&& rval > 0
-	&& (! BINFO_OFFSET_ZEROP (binfo) || TREE_VIA_VIRTUAL (binfo)))
-      {
-	tree tp_binfos;
-
-	/* Farm out the tuples with a single basetype.  */
-	for (tp = search_stack->first; tp < search_tail; tp += increment)
-	  {
-	    tp_binfos = BINFO_BASETYPES (*tp);
-	    if (tp_binfos && TREE_VEC_LENGTH (tp_binfos) > 1)
-	      break;
-	  }
-
-	if (tp < search_tail)
-	  {
-	    /* Pick the best path.  */
-	    tree base_binfo;
-	    int i;
-	    int nrval = rval;
-	    for (i = 0; i < TREE_VEC_LENGTH (tp_binfos); i++)
-	      {
-		base_binfo = TREE_VEC_ELT (tp_binfos, i);
-		if (tp+((i+1)*increment) < search_tail)
-		  my_friendly_assert (base_binfo == tp[(i+1)*increment], 295);
-		if (nrval = recursive_bounded_basetype_p (binfo, base_binfo, rval, 1))
-		  break;
-	      }
-	    rval = nrval;
-	    if (rval > 0)
-	      BINFO_INHERITANCE_CHAIN (base_binfo) = *tp;
-	  }
-
-	/* Because I don't trust recursive_bounded_basetype_p to find
-	   all ambiguities, I will just make sure here.  When it is
-	   sure that all ambiguities are found, the two routines and
-	   this call can be removed.  Not toally sure this should be
-	   here, but I think it should. (mrs) */
-
-	if (get_binfo2 (parent, type) == error_mark_node && rval != -2)
-	  {
-#if 1
-	    /* This warning is here because the code over in
-	       prepare_fresh_vtable relies on partial completion
-	       offered by recursive_bounded_basetype_p I think, but
-	       that behavior is not documented.  It needs to be.  I
-	       don't think prepare_fresh_vtable is the only routine
-	       that relies upon path_ptr being set to something in a
-	       particular way when this routine returns -2.  (mrs) */
-	    /* See PR 428 for a test case that can tickle this. */
-	    warning ("internal consistency check failed, please report, recovering.");
-	    rval = -2;
-#endif
-	  }
-
-	/* Visibilities don't count if we found an ambiguous basetype.  */
-	if (rval == -2)
-	  rval_private = 0;
-      }
-  }
-  search_stack = pop_search_level (search_stack);
-
-  if (rval && protect && rval_private)
-    return -3;
-
-  if (path_ptr)
-    *path_ptr = binfo;
-  return rval;
-}
-#endif
-
-/* Search for a member with name NAME in a multiple inheritance lattice
-   specified by TYPE.  If it does not exist, return NULL_TREE.
-   If the member is ambiguously referenced, return `error_mark_node'.
-   Otherwise, return the FIELD_DECL.  */
-
-/* Do a 1-level search for NAME as a member of TYPE.  The caller
-   must figure out whether it has a visible path to this field.
-   (Since it is only one level, this is reasonable.)  */
-static tree
-lookup_field_1 (type, name)
-     tree type, name;
-{
-  register tree field = TYPE_FIELDS (type);
-
-#ifdef GATHER_STATISTICS
-  n_calls_lookup_field_1++;
-#endif
-  while (field)
-    {
-#ifdef GATHER_STATISTICS
-      n_fields_searched++;
-#endif
-      if (DECL_NAME (field) == NULL_TREE
-	  && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
-	{
-	  tree temp = lookup_field_1 (TREE_TYPE (field), name);
-	  if (temp)
-	    return temp;
-	}
-      if (DECL_NAME (field) == name)
-	{
-	  if ((TREE_CODE(field) == VAR_DECL || TREE_CODE(field) == CONST_DECL)
-	      && DECL_ASSEMBLER_NAME (field) != NULL)
-	    GNU_xref_ref(current_function_decl,
-			 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (field)));
-	  return field;
-	}
-      field = TREE_CHAIN (field);
-    }
-  /* Not found.  */
-  if (name == _vptr_name)
-    {
-      /* Give the user what s/he thinks s/he wants.  */
-      if (TYPE_VIRTUAL_P (type))
-	return CLASSTYPE_VFIELD (type);
-    }
-  return NULL_TREE;
-}
-
-/* Compute the visibility of FIELD.  This is done by computing
-   the visibility available to each type in BASETYPES (which comes
-   as a list of [via_public/basetype] in reverse order, namely base
-   class before derived class).  The first one which defines a
-   visibility defines the visibility for the field.  Otherwise, the
-   visibility of the field is that which occurs normally.
-
-   Uses global variables CURRENT_CLASS_TYPE and
-   CURRENT_FUNCTION_DECL to use friend relationships
-   if necessary.
-
-   This will be static when lookup_fnfield comes into this file.  */
-
-#define PUBLIC_RETURN return (DECL_PUBLIC (field) = 1), visibility_public
-#define PROTECTED_RETURN return (DECL_PROTECTED (field) = 1), visibility_protected
-#define PRIVATE_RETURN return (DECL_PRIVATE (field) = 1), visibility_private
-
-enum visibility_type
-compute_visibility (basetype_path, field)
-     tree basetype_path, field;
-{
-  enum visibility_type visibility = visibility_public;
-  tree types;
-  tree context = DECL_CLASS_CONTEXT (field);
-
-  /* Fields coming from nested anonymous unions have their DECL_CLASS_CONTEXT
-     slot set to the union type rather than the record type containing
-     the anonymous union.  In this case, DECL_FIELD_CONTEXT is correct.  */
-  if (context && TREE_CODE (context) == UNION_TYPE
-      && ANON_AGGRNAME_P (TYPE_IDENTIFIER (context)))
-    context = DECL_FIELD_CONTEXT (field);
-     
-  /* Virtual function tables are never private.
-     But we should know that we are looking for this,
-     and not even try to hide it.  */
-  if (DECL_NAME (field) && VFIELD_NAME_P (DECL_NAME (field)) == 1)
-    return visibility_public;
-
-  /* Member function manipulating its own members.  */
-  if (current_class_type == context
-      || (context && current_class_type == TYPE_MAIN_VARIANT (context)))
-    PUBLIC_RETURN;
-
-  /* Make these special cases fast.  */
-  if (BINFO_TYPE (basetype_path) == current_class_type)
-    {
-      if (DECL_PUBLIC (field))
-	return visibility_public;
-      if (DECL_PROTECTED (field))
-	return visibility_protected;
-      if (DECL_PRIVATE (field))
-	return visibility_private;
-    }
-
-  /* Member found immediately within object.  */
-  if (BINFO_INHERITANCE_CHAIN (basetype_path) == NULL_TREE)
-    {
-      /* At object's top level, public members are public.  */
-      if (TREE_PROTECTED (field) == 0 && TREE_PRIVATE (field) == 0)
-	PUBLIC_RETURN;
-
-      /* Friend function manipulating members it gets (for being a friend).  */
-      if (is_friend (context, current_function_decl))
-	PUBLIC_RETURN;
-
-      /* Inner than that, without special visibility,
-
-	   protected members are ok if type of object is current_class_type
-	   is derived therefrom.  This means that if the type of the object
-	   is a base type for our current class type, we cannot access
-	   protected members.
-
-	   private members are not ok.  */
-      if (current_class_type && DECL_VISIBILITY (field) == NULL_TREE)
-	{
-	  if (TREE_PRIVATE (field))
-	    PRIVATE_RETURN;
-
-	  if (TREE_PROTECTED (field))
-	    {
-	      if (context == current_class_type
-		  || UNIQUELY_DERIVED_FROM_P (context, current_class_type))
-		PUBLIC_RETURN;
-	      else
-		PROTECTED_RETURN;
-	    }
-	  else my_friendly_abort (94);
-	}
-    }
-  /* Friend function manipulating members it gets (for being a friend).  */
-  if (is_friend (context, current_function_decl))
-    PUBLIC_RETURN;
-
-  /* must reverse more than one element */
-  basetype_path = reverse_path (basetype_path);
-  types = basetype_path;
-
-  while (types)
-    {
-      tree member;
-      tree binfo = types;
-      tree type = BINFO_TYPE (binfo);
-
-      member = purpose_member (type, DECL_VISIBILITY (field));
-      if (member)
-	{
-	  visibility = (enum visibility_type)TREE_VALUE (member);
-	  if (visibility == visibility_public
-	      || is_friend (type, current_function_decl)
-	      || (visibility == visibility_protected
-		  && current_class_type
-		  && UNIQUELY_DERIVED_FROM_P (context, current_class_type)))
-	    visibility = visibility_public;
-	  goto ret;
-	}
-
-      /* Friends inherit the visibility of the class they inherit from.  */
-      if (is_friend (type, current_function_decl))
-	{
-	  if (type == context)
-	    {
-	      visibility = visibility_public;
-	      goto ret;
-	    }
-	  if (TREE_PROTECTED (field))
-	    {
-	      visibility = visibility_public;
-	      goto ret;
-	    }
-#if 0
-	  /* This short-cut is too short.  */
-	  if (visibility == visibility_public)
-	    goto ret;
-#endif
-	  /* else, may be a friend of a deeper base class */
-	}
-
-      if (type == context)
-	break;
-
-      types = BINFO_INHERITANCE_CHAIN (types);
-      /* If the next type was not VIA_PUBLIC, then fields of all
-	 remaining class past that one are private.  */
-      if (types)
-	{
-	  if (TREE_VIA_PROTECTED (types))
-	    visibility = visibility_protected;
-	  else if (! TREE_VIA_PUBLIC (types))
-	    visibility = visibility_private;
-	}
-    }
-
-  /* No special visibilities apply.  Use normal rules.
-     No assignment needed for BASETYPEs here from the nreverse.
-     This is because we use it only for information about the
-     path to the base.  The code earlier dealt with what
-     happens when we are at the base level.  */
-
-  if (visibility == visibility_public)
-    {
-      basetype_path = reverse_path (basetype_path);
-      if (TREE_PRIVATE (field))
-	PRIVATE_RETURN;
-      if (TREE_PROTECTED (field))
-	{
-	  /* Used to check if the current class type was derived from
-	     the type that contains the field.  This is wrong for
-	     multiple inheritance because is gives one class reference
-	     to protected members via another classes protected path.
-	     I.e., if A; B1 : A; B2 : A;  Then B1 and B2 can access
-	     their own members which are protected in A, but not
-	     those same members in one another.  */
-	  if (current_class_type
-	      && UNIQUELY_DERIVED_FROM_P (context, current_class_type))
-	    PUBLIC_RETURN;
-	  PROTECTED_RETURN;
-	}
-      PUBLIC_RETURN;
-    }
-
-  if (visibility == visibility_protected)
-    {
-      /* reverse_path? */
-      if (TREE_PRIVATE (field))
-	PRIVATE_RETURN;
-      /* We want to make sure that all non-private members in
-	 the current class (as derived) are accessible.  */
-      if (current_class_type
-	  && UNIQUELY_DERIVED_FROM_P (context, current_class_type))
-	PUBLIC_RETURN;
-      PROTECTED_RETURN;
-    }
-
-  if (visibility == visibility_private
-      && current_class_type != NULL_TREE)
-    {
-      if (TREE_PRIVATE (field))
-	{
-	  reverse_path (basetype_path);
-	  PRIVATE_RETURN;
-	}
-
-      /* See if the field isn't protected.  */
-      if (TREE_PROTECTED (field))
-	{
-	  tree test = basetype_path;
-	  while (test)
-	    {
-	      if (BINFO_TYPE (test) == current_class_type)
-		break;
-	      test = BINFO_INHERITANCE_CHAIN (test);
-	    }
-	  reverse_path (basetype_path);
-	  if (test)
-	    PUBLIC_RETURN;
-	  PROTECTED_RETURN;
-	}
-
-      /* See if the field isn't a public member of
-	 a private base class.  */
-
-      visibility = visibility_public;
-      types = BINFO_INHERITANCE_CHAIN (basetype_path);
-      while (types)
-	{
-	  if (! TREE_VIA_PUBLIC (types))
-	    {
-	      if (visibility == visibility_private)
-		{
-		  visibility = visibility_private;
-		  goto ret;
-		}
-	      visibility = visibility_private;
-	    }
-	  if (BINFO_TYPE (types) == context)
-	    {
-	      visibility = visibility_public;
-	      goto ret;
-	    }
-	  types = BINFO_INHERITANCE_CHAIN (types);
-	}
-      my_friendly_abort (95);
-    }
-
- ret:
-  reverse_path (basetype_path);
-
-  if (visibility == visibility_public)
-    DECL_PUBLIC (field) = 1;
-  else if (visibility == visibility_protected)
-    DECL_PROTECTED (field) = 1;
-  else if (visibility == visibility_private)
-    DECL_PRIVATE (field) = 1;
-  else my_friendly_abort (96);
-  return visibility;
-}
-
-/* Routine to see if the sub-object denoted by the binfo PARENT can be
-   found as a base class and sub-object of the object denoted by
-   BINFO.  This routine relies upon binfos not being shared, except
-   for binfos for virtual bases.  */
-static int
-is_subobject_of_p (parent, binfo)
-     tree parent, binfo;
-{
-  tree binfos = BINFO_BASETYPES (binfo);
-  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  if (parent == binfo)
-    return 1;
-
-  /* Process and/or queue base types.  */
-  for (i = 0; i < n_baselinks; i++)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-      if (TREE_VIA_VIRTUAL (base_binfo))
-	base_binfo = TYPE_BINFO (BINFO_TYPE (base_binfo));
-      if (is_subobject_of_p (parent, base_binfo))
-	return 1;
-    }
-  return 0;
-}
-
-/* See if a one FIELD_DECL hides another.  This routine is meant to
-   correspond to ANSI working paper Sept 17, 1992 10p4.  The two
-   binfos given are the binfos corresponding to the particular places
-   the FIELD_DECLs are found.  This routine relies upon binfos not
-   being shared, except for virtual bases. */
-static int
-hides (hider_binfo, hidee_binfo)
-     tree hider_binfo, hidee_binfo;
-{
-  /* hider hides hidee, if hider has hidee as a base class and
-     the instance of hidee is a sub-object of hider.  The first
-     part is always true is the second part is true.
-
-     When hider and hidee are the same (two ways to get to the exact
-     same member) we consider either one as hiding the other. */
-  return is_subobject_of_p (hidee_binfo, hider_binfo);
-}
-
-/* Very similar to lookup_fnfields_1 but it ensures that at least one
-   function was declared inside the class given by TYPE.  It really should
-   only return functions that match the given TYPE.  */
-static int
-lookup_fnfields_here (type, name)
-     tree type, name;
-{
-  int index = lookup_fnfields_1 (type, name);
-  tree fndecls;
-
-  if (index <= 0)
-    return index;
-  fndecls = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
-  while (fndecls)
-    {
-      if (TYPE_MAIN_VARIANT (DECL_CLASS_CONTEXT (fndecls))
-	  == TYPE_MAIN_VARIANT (type))
-	return index;
-      fndecls = TREE_CHAIN (fndecls);
-    }
-  return -1;
-}
-
-/* Look for a field named NAME in an inheritance lattice dominated by
-   XBASETYPE.  PROTECT is zero if we can avoid computing visibility
-   information, otherwise it is 1.  WANT_TYPE is 1 when we should only
-   return TYPE_DECLs, if no TYPE_DECL can be found return NULL_TREE.
-
-   It was not clear what should happen if WANT_TYPE is set, and an
-   ambiguity is found.  At least one use (lookup_name) to not see
-   the error.  */
-tree
-lookup_field (xbasetype, name, protect, want_type)
-     register tree xbasetype, name;
-     int protect, want_type;
-{
-  int head = 0, tail = 0;
-  tree rval, rval_binfo = NULL_TREE, rval_binfo_h;
-  tree type, basetype_chain, basetype_path;
-  enum visibility_type this_v = visibility_default;
-  tree entry, binfo, binfo_h;
-  enum visibility_type own_visibility = visibility_default;
-  int vbase_name_p = VBASE_NAME_P (name);
-
-  /* rval_binfo is the binfo associated with the found member, note,
-     this can be set with useful information, even when rval is not
-     set, because it must deal with ALL members, not just non-function
-     members.  It is used for ambiguity checking and the hidden
-     checks.  Whereas rval is only set if a proper (not hidden)
-     non-function member is found.  */
-
-  /* rval_binfo_h and binfo_h are binfo values used when we perform the
-     hiding checks, as virtual base classes may not be shared.  The strategy
-     is we always go into the the binfo hierarchy owned by TYPE_BINFO of
-     virtual base classes, as we cross virtual base class lines.  This way
-     we know that binfo of a virtual base class will always == itself when
-     found along any line.  (mrs)  */
-
-  /* Things for memoization.  */
-  char *errstr = 0;
-
-  /* Set this to nonzero if we don't know how to compute
-     accurate error messages for visibility.  */
-  int index = MEMOIZED_HASH_FN (name);
-
-  if (TREE_CODE (xbasetype) == TREE_VEC)
-    basetype_path = xbasetype, type = BINFO_TYPE (xbasetype);
-  else if (IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype)))
-    basetype_path = TYPE_BINFO (xbasetype), type = xbasetype;
-  else my_friendly_abort (97);
-
-  if (CLASSTYPE_MTABLE_ENTRY (type))
-    {
-      tree tem = MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
-
-      while (tem && TREE_PURPOSE (tem) != name)
-	{
-	  memoized_fields_searched[0]++;
-	  tem = TREE_CHAIN (tem);
-	}
-      if (tem)
-	{
-	  if (protect && TREE_TYPE (tem))
-	    {
-	      error (TREE_STRING_POINTER (TREE_TYPE (tem)),
-		     IDENTIFIER_POINTER (name),
-		     TYPE_NAME_STRING (DECL_FIELD_CONTEXT (TREE_VALUE (tem))));
-	      return error_mark_node;
-	    }
-	  if (TREE_VALUE (tem) == NULL_TREE)
-	    memoized_fast_rejects[0] += 1;
-	  else
-	    memoized_fast_finds[0] += 1;
-	  return TREE_VALUE (tem);
-	}
-    }
-
-#ifdef GATHER_STATISTICS
-  n_calls_lookup_field++;
-#endif
-  if (protect && flag_memoize_lookups && ! global_bindings_p ())
-    entry = make_memoized_table_entry (type, name, 0);
-  else
-    entry = 0;
-
-  rval = lookup_field_1 (type, name);
-  if (rval || lookup_fnfields_here (type, name)>=0)
-    {
-      rval_binfo = basetype_path;
-      rval_binfo_h = rval_binfo;
-    }
-
-  if (rval && TREE_CODE (rval) != TYPE_DECL && want_type)
-    rval = NULL_TREE;
-
-  if (rval)
-    {
-      if (protect)
-	{
-	  if (TREE_PRIVATE (rval) | TREE_PROTECTED (rval))
-	    this_v = compute_visibility (basetype_path, rval);
-	  if (TREE_CODE (rval) == CONST_DECL)
-	    {
-	      if (this_v == visibility_private)
-		errstr = "enum `%s' is a private value of class `%s'";
-	      else if (this_v == visibility_protected)
-		errstr = "enum `%s' is a protected value of class `%s'";
-	    }
-	  else
-	    {
-	      if (this_v == visibility_private)
-		errstr = "member `%s' is a private member of class `%s'";
-	      else if (this_v == visibility_protected)
-		errstr = "member `%s' is a protected member of class `%s'";
-	    }
-	}
-
-      if (entry)
-	{
-	  if (errstr)
-	    {
-	      /* This depends on behavior of lookup_field_1!  */
-	      tree error_string = my_build_string (errstr);
-	      TREE_TYPE (entry) = error_string;
-	    }
-	  else
-	    {
-	      /* Let entry know there is no problem with this access.  */
-	      TREE_TYPE (entry) = NULL_TREE;
-	    }
-	  TREE_VALUE (entry) = rval;
-	}
-
-      if (errstr && protect)
-	{
-	  error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type));
-	  return error_mark_node;
-	}
-      return rval;
-    }
-
-  basetype_chain = CLASSTYPE_BINFO_AS_LIST (type);
-  TREE_VIA_PUBLIC (basetype_chain) = 1;
-
-  /* The ambiguity check relies upon breadth first searching. */
-
-  search_stack = push_search_level (search_stack, &search_obstack);
-  BINFO_VIA_PUBLIC (basetype_path) = 1;
-  BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
-  binfo = basetype_path;
-  binfo_h = binfo;
-
-  while (1)
-    {
-      tree binfos = BINFO_BASETYPES (binfo);
-      int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-      tree nval;
-
-      /* Process and/or queue base types.  */
-      for (i = 0; i < n_baselinks; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-	  if (BINFO_FIELDS_MARKED (base_binfo) == 0)
-	    {
-	      tree btypes;
-
-	      SET_BINFO_FIELDS_MARKED (base_binfo);
-	      btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain);
-	      TREE_VIA_PUBLIC (btypes) = TREE_VIA_PUBLIC (base_binfo);
-	      TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo);
-	      TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo);
-	      if (TREE_VIA_VIRTUAL (base_binfo))
-		btypes = tree_cons (NULL_TREE,
-				    TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
-				    btypes);
-	      else
-		btypes = tree_cons (NULL_TREE,
-				    TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
-				    btypes);
-	      obstack_ptr_grow (&search_obstack, btypes);
-	      tail += 1;
-	      if (tail >= search_stack->limit)
-		my_friendly_abort (98);
-	    }
-	}
-
-      /* Process head of queue, if one exists.  */
-      if (head >= tail)
-	break;
-
-      basetype_chain = search_stack->first[head++];
-      binfo_h = TREE_VALUE (basetype_chain);
-      basetype_chain = TREE_CHAIN (basetype_chain);
-      basetype_path = TREE_VALUE (basetype_chain);
-      if (TREE_CHAIN (basetype_chain))
-	BINFO_INHERITANCE_CHAIN (basetype_path) = TREE_VALUE (TREE_CHAIN (basetype_chain));
-      else
-	BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
-
-      binfo = basetype_path;
-      type = BINFO_TYPE (binfo);
-
-      /* See if we can find NAME in TYPE.  If RVAL is nonzero,
-	 and we do find NAME in TYPE, verify that such a second
-	 sighting is in fact legal.  */
-
-      nval = lookup_field_1 (type, name);
-
-      if (nval || lookup_fnfields_here (type, name)>=0)
-	{
-	  if (rval_binfo && hides (rval_binfo_h, binfo_h))
-	    {
-	      /* This is ok, the member found is in rval_binfo, not
-		 here (binfo). */
-	    }
-	  else if (rval_binfo==NULL_TREE || hides (binfo_h, rval_binfo_h))
-	    {
-	      /* This is ok, the member found is here (binfo), not in
-		 rval_binfo. */
-	      if (nval)
-		{
-		  rval = nval;
-		  if (entry || protect)
-		    this_v = compute_visibility (basetype_path, rval);
-		  /* These may look ambiguous, but they really are not.  */
-		  if (vbase_name_p)
-		    break;
-		}
-	      else
-		{
-		  /* Undo finding it before, as something else hides it. */
-		  rval = NULL_TREE;
-		}
-	      rval_binfo = binfo;
-	      rval_binfo_h = binfo_h;
-	    }
-	  else
-	    {
-	      /* This is ambiguous. */
-	      errstr = "request for member `%s' is ambiguous";
-	      protect = 2;
-	      break;
-	    }
-	}
-    }
-  {
-    tree *tp = search_stack->first;
-    tree *search_tail = tp + tail;
-
-    if (entry)
-      TREE_VALUE (entry) = rval;
-
-    if (want_type && (rval == NULL_TREE || TREE_CODE (rval) != TYPE_DECL))
-      {
-	rval = NULL_TREE;
-	errstr = 0;
-      }
-
-    /* If this FIELD_DECL defines its own visibility, deal with that.  */
-    if (rval && errstr == 0
-	&& ((protect&1) || entry)
-	&& DECL_LANG_SPECIFIC (rval)
-	&& DECL_VISIBILITY (rval))
-      {
-	while (tp < search_tail)
-	  {
-	    /* If is possible for one of the derived types on the
-	       path to have defined special visibility for this
-	       field.  Look for such declarations and report an
-	       error if a conflict is found.  */
-	    enum visibility_type new_v;
-
-	    if (this_v != visibility_default)
-	      new_v = compute_visibility (TREE_VALUE (TREE_CHAIN (*tp)), rval);
-	    if (this_v != visibility_default && new_v != this_v)
-	      {
-		errstr = "conflicting visibilities to member `%s'";
-		this_v = visibility_default;
-	      }
-	    own_visibility = new_v;
-	    CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp)));
-	    tp += 1;
-	  }
-      }
-    else
-      {
-	while (tp < search_tail)
-	  {
-	    CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp)));
-	    tp += 1;
-	  }
-      }
-  }
-  search_stack = pop_search_level (search_stack);
-
-  if (errstr == 0)
-    {
-      if (own_visibility == visibility_private)
-	errstr = "member `%s' declared private";
-      else if (own_visibility == visibility_protected)
-	errstr = "member `%s' declared protected";
-      else if (this_v == visibility_private)
-	errstr = TREE_PRIVATE (rval)
-	  ? "member `%s' is private"
-	    : "member `%s' is from private base class";
-      else if (this_v == visibility_protected)
-	errstr = TREE_PROTECTED (rval)
-	  ? "member `%s' is protected"
-	    : "member `%s' is from protected base class";
-    }
-
-  if (entry)
-    {
-      if (errstr)
-	{
-	  tree error_string = my_build_string (errstr);
-	  /* Save error message with entry.  */
-	  TREE_TYPE (entry) = error_string;
-	}
-      else
-	{
-	  /* Mark entry as having no error string.  */
-	  TREE_TYPE (entry) = NULL_TREE;
-	}
-    }
-
-  if (errstr && protect)
-    {
-      error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type));
-      rval = error_mark_node;
-    }
-  return rval;
-}
-
-/* Try to find NAME inside a nested class.  */
-tree
-lookup_nested_field (name, complain)
-     tree name;
-     int complain;
-{
-  register tree t;
-
-  tree id = NULL_TREE;
-  if (TREE_CHAIN (current_class_type))
-    {
-      /* Climb our way up the nested ladder, seeing if we're trying to
-	 modify a field in an enclosing class.  If so, we should only
-	 be able to modify if it's static.  */
-      for (t = TREE_CHAIN (current_class_type);
-	   t && DECL_CONTEXT (t);
-	   t = TREE_CHAIN (DECL_CONTEXT (t)))
-	{
-	  if (TREE_CODE (DECL_CONTEXT (t)) != RECORD_TYPE)
-	    break;
-
-	  /* N.B.: lookup_field will do the visibility checking for us */
-	  id = lookup_field (DECL_CONTEXT (t), name, complain, 0);
-	  if (id == error_mark_node)
-	    {
-	      id = NULL_TREE;
-	      continue;
-	    }
-
-	  if (id != NULL_TREE)
-	    {
-	      if (TREE_CODE (id) == FIELD_DECL
-		  && ! TREE_STATIC (id)
-		  && TREE_TYPE (id) != error_mark_node)
-		{
-		  if (complain)
-		    {
-		      /* At parse time, we don't want to give this error, since
-			 we won't have enough state to make this kind of
-			 decision properly.  But there are times (e.g., with
-			 enums in nested classes) when we do need to call
-			 this fn at parse time.  So, in those cases, we pass
-			 complain as a 0 and just return a NULL_TREE.  */
-		      error ("assignment to non-static member `%s' of enclosing class `%s'",
-			     lang_printable_name (id),
-			     IDENTIFIER_POINTER (TYPE_IDENTIFIER
-						 (DECL_CONTEXT (t))));
-		      /* Mark this for do_identifier().  It would otherwise
-			 claim that the variable was undeclared.  */
-		      TREE_TYPE (id) = error_mark_node;
-		    }
-		  else
-		    {
-		      id = NULL_TREE;
-		      continue;
-		    }
-		}
-	      break;
-	    }
-	}
-    }
-
-  return id;
-}
-
-/* TYPE is a class type. Return the index of the fields within
-   the method vector with name NAME, or -1 is no such field exists.  */
-static int
-lookup_fnfields_1 (type, name)
-     tree type, name;
-{
-  register tree method_vec = CLASSTYPE_METHOD_VEC (type);
-
-  if (method_vec != 0)
-    {
-      register tree *methods = &TREE_VEC_ELT (method_vec, 0);
-      register tree *end = TREE_VEC_END (method_vec);
-
-#ifdef GATHER_STATISTICS
-      n_calls_lookup_fnfields_1++;
-#endif
-      if (*methods && name == constructor_name (type))
-	return 0;
-
-      while (++methods != end)
-	{
-#ifdef GATHER_STATISTICS
-	  n_outer_fields_searched++;
-#endif
-	  if (DECL_NAME (*methods) == name)
-	    break;
-	}
-      if (methods != end)
-	return methods - &TREE_VEC_ELT (method_vec, 0);
-    }
-
-  return -1;
-}
-
-/* Starting from BASETYPE, return a TREE_BASELINK-like object
-   which gives the following information (in a list):
-
-   TREE_TYPE: list of basetypes needed to get to...
-   TREE_VALUE: list of all functions in of given type
-   which have name NAME.
-
-   No visibility information is computed by this function,
-   other then to adorn the list of basetypes with
-   TREE_VIA_PUBLIC.
-
-   If there are two ways to find a name (two members), if COMPLAIN is
-   non-zero, then error_mark_node is returned, and an error message is
-   printed, otherwise, just an error_mark_node is returned.
-
-   As a special case, is COMPLAIN is -1, we don't complain, and we
-   don't return error_mark_node, but rather the complete list of
-   virtuals.  This is used by get_virtuals_named_this.  */
-tree
-lookup_fnfields (basetype_path, name, complain)
-     tree basetype_path, name;
-     int complain;
-{
-  int head = 0, tail = 0;
-  tree type, rval, rval_binfo = NULL_TREE, rvals = NULL_TREE, rval_binfo_h;
-  tree entry, binfo, basetype_chain, binfo_h;
-  int find_all = 0;
-
-  /* rval_binfo is the binfo associated with the found member, note,
-     this can be set with useful information, even when rval is not
-     set, because it must deal with ALL members, not just function
-     members.  It is used for ambiguity checking and the hidden
-     checks.  Whereas rval is only set if a proper (not hidden)
-     function member is found.  */
-
-  /* rval_binfo_h and binfo_h are binfo values used when we perform the
-     hiding checks, as virtual base classes may not be shared.  The strategy
-     is we always go into the the binfo hierarchy owned by TYPE_BINFO of
-     virtual base classes, as we cross virtual base class lines.  This way
-     we know that binfo of a virtual base class will always == itself when
-     found along any line.  (mrs)  */
-
-  /* For now, don't try this.  */
-  int protect = complain;
-
-  /* Things for memoization.  */
-  char *errstr = 0;
-
-  /* Set this to nonzero if we don't know how to compute
-     accurate error messages for visibility.  */
-  int index = MEMOIZED_HASH_FN (name);
-
-  if (complain == -1)
-    {
-      find_all = 1;
-      protect = complain = 0;
-    }
-
-  binfo = basetype_path;
-  binfo_h = binfo;
-  type = BINFO_TYPE (basetype_path);
-
-  /* The memoization code is in need of maintenance. */
-  if (!find_all && CLASSTYPE_MTABLE_ENTRY (type))
-    {
-      tree tem = MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
-
-      while (tem && TREE_PURPOSE (tem) != name)
-	{
-	  memoized_fields_searched[1]++;
-	  tem = TREE_CHAIN (tem);
-	}
-      if (tem)
-	{
-	  if (protect && TREE_TYPE (tem))
-	    {
-	      error (TREE_STRING_POINTER (TREE_TYPE (tem)),
-		     IDENTIFIER_POINTER (name),
-		     TYPE_NAME_STRING (DECL_CLASS_CONTEXT (TREE_VALUE (TREE_VALUE (tem)))));
-	      return error_mark_node;
-	    }
-	  if (TREE_VALUE (tem) == NULL_TREE)
-	    {
-	      memoized_fast_rejects[1] += 1;
-	      return NULL_TREE;
-	    }
-	  else
-	    {
-	      /* Want to return this, but we must make sure
-		 that visibility information is consistent.  */
-	      tree baselink = TREE_VALUE (tem);
-	      tree memoized_basetypes = TREE_PURPOSE (baselink);
-	      tree these_basetypes = basetype_path;
-	      while (memoized_basetypes && these_basetypes)
-		{
-		  memoized_fields_searched[1]++;
-		  if (TREE_VALUE (memoized_basetypes) != these_basetypes)
-		    break;
-		  memoized_basetypes = TREE_CHAIN (memoized_basetypes);
-		  these_basetypes = BINFO_INHERITANCE_CHAIN (these_basetypes);
-		}
-	      /* The following statement is true only when both are NULL.  */
-	      if (memoized_basetypes == these_basetypes)
-		{
-		  memoized_fast_finds[1] += 1;
-		  return TREE_VALUE (tem);
-		}
-	      /* else, we must re-find this field by hand.  */
-	      baselink = tree_cons (basetype_path, TREE_VALUE (baselink), TREE_CHAIN (baselink));
-	      return baselink;
-	    }
-	}
-    }
-
-#ifdef GATHER_STATISTICS
-  n_calls_lookup_fnfields++;
-#endif
-  if (protect && flag_memoize_lookups && ! global_bindings_p ())
-    entry = make_memoized_table_entry (type, name, 1);
-  else
-    entry = 0;
-
-  index = lookup_fnfields_here (type, name);
-  if (index >= 0 || lookup_field_1 (type, name))
-    {
-      rval_binfo = basetype_path;
-      rval_binfo_h = rval_binfo;
-    }
-
-  if (index >= 0)
-    {
-      rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
-      rvals = my_tree_cons (basetype_path, rval, rvals);
-      if (BINFO_BASETYPES (binfo) && CLASSTYPE_BASELINK_VEC (type))
-	TREE_TYPE (rvals) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index);
-
-      if (entry)
-	{
-	  TREE_VALUE (entry) = rvals;
-	  TREE_TYPE (entry) = NULL_TREE;
-	}
-
-      if (errstr && protect)
-	{
-	  error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type));
-	  return error_mark_node;
-	}
-      return rvals;
-    }
-  rval = NULL_TREE;
-
-  basetype_chain = CLASSTYPE_BINFO_AS_LIST (type);
-  TREE_VIA_PUBLIC (basetype_chain) = 1;
-
-  /* The ambiguity check relies upon breadth first searching. */
-
-  search_stack = push_search_level (search_stack, &search_obstack);
-  BINFO_VIA_PUBLIC (basetype_path) = 1;
-  BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
-  binfo = basetype_path;
-  binfo_h = binfo;
-
-  while (1)
-    {
-      tree binfos = BINFO_BASETYPES (binfo);
-      int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-      int index;
-
-      /* Process and/or queue base types.  */
-      for (i = 0; i < n_baselinks; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-	  if (BINFO_FIELDS_MARKED (base_binfo) == 0)
-	    {
-	      tree btypes;
-
-	      SET_BINFO_FIELDS_MARKED (base_binfo);
-	      btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain);
-	      TREE_VIA_PUBLIC (btypes) = TREE_VIA_PUBLIC (base_binfo);
-	      TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo);
-	      TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo);
-	      if (TREE_VIA_VIRTUAL (base_binfo))
-		btypes = tree_cons (NULL_TREE,
-				    TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
-				    btypes);
-	      else
-		btypes = tree_cons (NULL_TREE,
-				    TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
-				    btypes);
-	      obstack_ptr_grow (&search_obstack, btypes);
-	      tail += 1;
-	      if (tail >= search_stack->limit)
-		my_friendly_abort (99);
-	    }
-	}
-
-      /* Process head of queue, if one exists.  */
-      if (head >= tail)
-	break;
-
-      basetype_chain = search_stack->first[head++];
-      binfo_h = TREE_VALUE (basetype_chain);
-      basetype_chain = TREE_CHAIN (basetype_chain);
-      basetype_path = TREE_VALUE (basetype_chain);
-      if (TREE_CHAIN (basetype_chain))
-	BINFO_INHERITANCE_CHAIN (basetype_path) = TREE_VALUE (TREE_CHAIN (basetype_chain));
-      else
-	BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
-
-      binfo = basetype_path;
-      type = BINFO_TYPE (binfo);
-
-      /* See if we can find NAME in TYPE.  If RVAL is nonzero,
-	 and we do find NAME in TYPE, verify that such a second
-	 sighting is in fact legal.  */
-
-      index = lookup_fnfields_here (type, name);
-
-      if (index >= 0 || (lookup_field_1 (type, name)!=NULL_TREE && !find_all))
-	{
-	  if (rval_binfo && !find_all && hides (rval_binfo_h, binfo_h))
-	    {
-	      /* This is ok, the member found is in rval_binfo, not
-		 here (binfo). */
-	    }
-	  else if (rval_binfo==NULL_TREE || find_all || hides (binfo_h, rval_binfo_h))
-	    {
-	      /* This is ok, the member found is here (binfo), not in
-		 rval_binfo. */
-	      if (index >= 0)
-		{
-		  rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
-		  /* Note, rvals can only be previously set if find_all is
-		     true.  */
-		  rvals = my_tree_cons (basetype_path, rval, rvals);
-		  if (TYPE_BINFO_BASETYPES (type)
-		      && CLASSTYPE_BASELINK_VEC (type))
-		    TREE_TYPE (rvals) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index);
-		}
-	      else
-		{
-		  /* Undo finding it before, as something else hides it. */
-		  rval = NULL_TREE;
-		  rvals = NULL_TREE;
-		}
-	      rval_binfo = binfo;
-	      rval_binfo_h = binfo_h;
-	    }
-	  else
-	    {
-	      /* This is ambiguous. */
-	      errstr = "request for member `%s' is ambiguous";
-	      rvals = error_mark_node;
-	      break;
-	    }
-	}
-    }
-  {
-    tree *tp = search_stack->first;
-    tree *search_tail = tp + tail;
-
-    while (tp < search_tail)
-      {
-	CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp)));
-	tp += 1;
-      }
-  }
-  search_stack = pop_search_level (search_stack);
-
-  if (entry)
-    {
-      if (errstr)
-	{
-	  tree error_string = my_build_string (errstr);
-	  /* Save error message with entry.  */
-	  TREE_TYPE (entry) = error_string;
-	}
-      else
-	{
-	  /* Mark entry as having no error string.  */
-	  TREE_TYPE (entry) = NULL_TREE;
-	  TREE_VALUE (entry) = rvals;
-	}
-    }
-
-  if (errstr && protect)
-    {
-      error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type));
-      rvals = error_mark_node;
-    }
-
-  return rvals;
-}
-
-/* BREADTH-FIRST SEARCH ROUTINES.  */
-
-/* Search a multiple inheritance hierarchy by breadth-first search.
-
-   TYPE is an aggregate type, possibly in a multiple-inheritance hierarchy.
-   TESTFN is a function, which, if true, means that our condition has been met,
-   and its return value should be returned.
-   QFN, if non-NULL, is a predicate dictating whether the type should
-   even be queued.  */
-
-HOST_WIDE_INT
-breadth_first_search (binfo, testfn, qfn)
-     tree binfo;
-     int (*testfn)();
-     int (*qfn)();
-{
-  int head = 0, tail = 0;
-  int rval = 0;
-
-  search_stack = push_search_level (search_stack, &search_obstack);
-
-  while (1)
-    {
-      tree binfos = BINFO_BASETYPES (binfo);
-      int n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-      int i;
-
-      /* Process and/or queue base types.  */
-      for (i = 0; i < n_baselinks; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-	  if (BINFO_MARKED (base_binfo) == 0
-	      && (qfn == 0 || (*qfn) (binfo, i)))
-	    {
-	      SET_BINFO_MARKED (base_binfo);
-	      obstack_ptr_grow (&search_obstack, binfo);
-	      obstack_ptr_grow (&search_obstack, (HOST_WIDE_INT) i);
-	      tail += 2;
-	      if (tail >= search_stack->limit)
-		my_friendly_abort (100);
-	    }
-	}
-      /* Process head of queue, if one exists.  */
-      if (head >= tail)
-	{
-	  rval = 0;
-	  break;
-	}
-
-      binfo = search_stack->first[head++];
-      i = (int) search_stack->first[head++];
-      if (rval = (*testfn) (binfo, i))
-	break;
-      binfo = BINFO_BASETYPE (binfo, i);
-    }
-  {
-    tree *tp = search_stack->first;
-    tree *search_tail = tp + tail;
-    while (tp < search_tail)
-      {
-	tree binfo = *tp++;
-	int i = (HOST_WIDE_INT)(*tp++);
-	CLEAR_BINFO_MARKED (BINFO_BASETYPE (binfo, i));
-      }
-  }
-
-  search_stack = pop_search_level (search_stack);
-  return rval;
-}
-
-/* Functions to use in breadth first searches.  */
-typedef tree (*pft)();
-typedef int (*pfi)();
-
-int tree_needs_constructor_p (binfo, i)
-     tree binfo;
-     int i;
-{
-  tree basetype;
-  my_friendly_assert (i != 0, 296);
-  basetype = BINFO_TYPE (BINFO_BASETYPE (binfo, i));
-  return TYPE_NEEDS_CONSTRUCTOR (basetype);
-}
-
-static tree declarator;
-
-static tree
-get_virtuals_named_this (binfo)
-     tree binfo;
-{
-  tree fields;
-
-  fields = lookup_fnfields (binfo, declarator, -1);
-  /* fields cannot be error_mark_node */
-
-  if (fields == 0)
-    return 0;
-
-  /* Get to the function decls, and return the first virtual function
-     with this name, if there is one.  */
-  while (fields)
-    {
-      tree fndecl;
-
-      for (fndecl = TREE_VALUE (fields); fndecl; fndecl = DECL_CHAIN (fndecl))
-	if (DECL_VINDEX (fndecl))
-	  return fields;
-      fields = next_baselink (fields);
-    }
-  return NULL_TREE;
-}
-
-static tree get_virtual_destructor (binfo, i)
-     tree binfo;
-     int i;
-{
-  tree type = BINFO_TYPE (binfo);
-  if (i >= 0)
-    type = BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), i));
-  if (TYPE_HAS_DESTRUCTOR (type)
-      && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0)))
-    return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0);
-  return 0;
-}
-
-int tree_has_any_destructor_p (binfo, i)
-     tree binfo;
-     int i;
-{
-  tree type = BINFO_TYPE (binfo);
-  if (i >= 0)
-    type = BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), i));
-  return TYPE_NEEDS_DESTRUCTOR (type);
-}
-
-/* Given a class type TYPE, and a function decl FNDECL,
-   look for the first function the TYPE's hierarchy which
-   FNDECL could match as a virtual function.
-
-   DTORP is nonzero if we are looking for a destructor.  Destructors
-   need special treatment because they do not match by name.  */
-tree
-get_first_matching_virtual (binfo, fndecl, dtorp)
-     tree binfo, fndecl;
-     int dtorp;
-{
-  tree tmp = NULL_TREE;
-
-  /* Breadth first search routines start searching basetypes
-     of TYPE, so we must perform first ply of search here.  */
-  if (dtorp)
-    {
-      if (tree_has_any_destructor_p (binfo, -1))
-	tmp = get_virtual_destructor (binfo, -1);
-
-      if (tmp)
-	{
-	  if (get_base_distance (DECL_CONTEXT (tmp),
-				 DECL_CONTEXT (fndecl), 0, 0) > 0)
-	    DECL_CONTEXT (fndecl) = DECL_CONTEXT (tmp);
-	  return tmp;
-	}
-
-      tmp = (tree) breadth_first_search (binfo,
-					 (pfi) get_virtual_destructor,
-					 tree_has_any_destructor_p);
-      if (tmp)
-	{
-	  if (get_base_distance (DECL_CONTEXT (tmp),
-				 DECL_CONTEXT (fndecl), 0, 0) > 0)
-	    DECL_CONTEXT (fndecl) = DECL_CONTEXT (tmp);
-	}
-      return tmp;
-    }
-  else
-    {
-      tree drettype, dtypes, btypes, instptr_type;
-      tree basetype = DECL_CLASS_CONTEXT (fndecl);
-      tree baselink, best = NULL_TREE;
-      tree name = DECL_ASSEMBLER_NAME (fndecl);
-
-      declarator = DECL_NAME (fndecl);
-      if (IDENTIFIER_VIRTUAL_P (declarator) == 0)
-	return NULL_TREE;
-
-      drettype = TREE_TYPE (TREE_TYPE (fndecl));
-      dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
-      if (DECL_STATIC_FUNCTION_P (fndecl))
-	instptr_type = NULL_TREE;
-      else
-	instptr_type = TREE_TYPE (TREE_VALUE (dtypes));
-
-      for (baselink = get_virtuals_named_this (binfo);
-	   baselink; baselink = next_baselink (baselink))
-	{
-	  for (tmp = TREE_VALUE (baselink); tmp; tmp = DECL_CHAIN (tmp))
-	    {
-	      if (! DECL_VINDEX (tmp))
-		continue;
-
-	      btypes = TYPE_ARG_TYPES (TREE_TYPE (tmp));
-	      if (instptr_type == NULL_TREE)
-		{
-		  if (compparms (TREE_CHAIN (btypes), dtypes, 3))
-		    /* Caller knows to give error in this case.  */
-		    return tmp;
-		  return NULL_TREE;
-		}
-
-	      if ((TYPE_READONLY (TREE_TYPE (TREE_VALUE (btypes)))
-		   == TYPE_READONLY (instptr_type))
-		  && compparms (TREE_CHAIN (btypes), TREE_CHAIN (dtypes), 3))
-		{
-		  if (IDENTIFIER_ERROR_LOCUS (name) == NULL_TREE
-		      && ! comptypes (TREE_TYPE (TREE_TYPE (tmp)), drettype, 1))
-		    {
-		      error_with_decl (fndecl, "conflicting return type specified for virtual function `%s'");
-		      SET_IDENTIFIER_ERROR_LOCUS (name, basetype);
-		    }
-		  break;
-		}
-	    }
-	  if (tmp)
-	    {
-	      /* If this is ambiguous, we will warn about it later.  */
-	      if (best)
-		{
-		  if (get_base_distance (DECL_CLASS_CONTEXT (best),
-					 DECL_CLASS_CONTEXT (tmp), 0, 0) > 0)
-		    best = tmp;
-		}
-	      else
-		best = tmp;
-	    }
-	}
-      if (IDENTIFIER_ERROR_LOCUS (name) == NULL_TREE
-	  && best == NULL_TREE && warn_overloaded_virtual)
-	{
-	  warning_with_decl (fndecl,
-			     "conflicting specification deriving virtual function `%s'");
-	  SET_IDENTIFIER_ERROR_LOCUS (name, basetype);
-	}
-      if (best)
-	{
-	  if (get_base_distance (DECL_CONTEXT (best),
-				 DECL_CONTEXT (fndecl), 0, 0) > 0)
-	    DECL_CONTEXT (fndecl) = DECL_CONTEXT (best);
-	}
-      return best;
-    }
-}
-
-/* Return the list of virtual functions which are abstract in type TYPE.
-   This information is cached, and so must be built on a
-   non-temporary obstack.  */
-tree
-get_abstract_virtuals (type)
-     tree type;
-{
-  /* For each layer of base class (i.e., the first base class, and each
-     virtual base class from that one), modify the virtual function table
-     of the derived class to contain the new virtual function.
-     A class has as many vfields as it has virtual base classes (total).  */
-  tree vfields, vbases, base, tmp;
-  tree vfield = CLASSTYPE_VFIELD (type);
-  tree fcontext = vfield ? DECL_FCONTEXT (vfield) : NULL_TREE;
-  tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (type);
-
-  for (vfields = CLASSTYPE_VFIELDS (type); vfields; vfields = TREE_CHAIN (vfields))
-    {
-      int normal;
-
-      /* This code is most likely wrong, and probably only works for single
-	 inheritance or by accident. */
-
-      /* Find the right base class for this derived class, call it BASE.  */
-      base = VF_BASETYPE_VALUE (vfields);
-      if (base == type)
-	continue;
-
-      /* We call this case NORMAL iff this virtual function table
-	 pointer field has its storage reserved in this class.
-	 This is normally the case without virtual baseclasses
-	 or off-center multiple baseclasses.  */
-      normal = (base == fcontext
-		&& (VF_BINFO_VALUE (vfields) == NULL_TREE
-		    || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields))));
-
-      if (normal)
-	tmp = TREE_CHAIN (TYPE_BINFO_VIRTUALS (type));
-      else
-	{
-	  /* n.b.: VF_BASETYPE_VALUE (vfields) is the first basetype
-	     that provides the virtual function table, whereas
-	     VF_DERIVED_VALUE (vfields) is an immediate base type of TYPE
-	     that dominates VF_BASETYPE_VALUE (vfields).  The list of
-	     vfields we want lies between these two values.  */
-	  tree binfo = get_binfo (VF_NORMAL_VALUE (vfields), type, 0);
-	  tmp = TREE_CHAIN (BINFO_VIRTUALS (binfo));
-	}
-
-      /* Get around dossier entry if there is one.  */
-      if (flag_dossier)
-	tmp = TREE_CHAIN (tmp);
-
-      while (tmp)
-	{
-	  tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (tmp));
-	  tree base_fndecl = TREE_OPERAND (base_pfn, 0);
-	  if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl))
-	    abstract_virtuals = tree_cons (NULL_TREE, base_fndecl, abstract_virtuals);
-	  tmp = TREE_CHAIN (tmp);
-	}
-    }
-  for (vbases = CLASSTYPE_VBASECLASSES (type); vbases; vbases = TREE_CHAIN (vbases))
-    {
-      if (! BINFO_VIRTUALS (vbases))
-	continue;
-
-      tmp = TREE_CHAIN (BINFO_VIRTUALS (vbases));
-      while (tmp)
-	{
-	  tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (tmp));
-	  tree base_fndecl = TREE_OPERAND (base_pfn, 0);
-	  if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl))
-	    abstract_virtuals = tree_cons (NULL_TREE, base_fndecl, abstract_virtuals);
-	  tmp = TREE_CHAIN (tmp);
-	}
-    }
-  return nreverse (abstract_virtuals);
-}
-
-/* For the type TYPE, return a list of member functions available from
-   base classes with name NAME.  The TREE_VALUE of the list is a chain of
-   member functions with name NAME.  The TREE_PURPOSE of the list is a
-   basetype, or a list of base types (in reverse order) which were
-   traversed to reach the chain of member functions.  If we reach a base
-   type which provides a member function of name NAME, and which has at
-   most one base type itself, then we can terminate the search.  */
-
-tree
-get_baselinks (type_as_binfo_list, type, name)
-     tree type_as_binfo_list;
-     tree type, name;
-{
-  int head = 0, tail = 0, index;
-  tree rval = 0, nval = 0;
-  tree basetypes = type_as_binfo_list;
-  tree binfo = TYPE_BINFO (type);
-
-  search_stack = push_search_level (search_stack, &search_obstack);
-
-  while (1)
-    {
-      tree binfos = BINFO_BASETYPES (binfo);
-      int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-      /* Process and/or queue base types.  */
-      for (i = 0; i < n_baselinks; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-	  tree btypes;
-
-	  btypes = hash_tree_cons (TREE_VIA_PUBLIC (base_binfo),
-				   TREE_VIA_VIRTUAL (base_binfo),
-				   TREE_VIA_PROTECTED (base_binfo),
-				   NULL_TREE, base_binfo,
-				   basetypes);
-	  obstack_ptr_grow (&search_obstack, btypes);
-	  search_stack->first = (tree *)obstack_base (&search_obstack);
-	  tail += 1;
-	}
-
-    dont_queue:
-      /* Process head of queue, if one exists.  */
-      if (head >= tail)
-	break;
-
-      basetypes = search_stack->first[head++];
-      binfo = TREE_VALUE (basetypes);
-      type = BINFO_TYPE (binfo);
-      index = lookup_fnfields_1 (type, name);
-      if (index >= 0)
-	{
-	  nval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
-	  rval = hash_tree_cons (0, 0, 0, basetypes, nval, rval);
-	  if (TYPE_BINFO_BASETYPES (type) == 0)
-	    goto dont_queue;
-	  else if (TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) == 1)
-	    {
-	      if (CLASSTYPE_BASELINK_VEC (type))
-		TREE_TYPE (rval) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index);
-	      goto dont_queue;
-	    }
-	}
-      nval = NULL_TREE;
-    }
-
-  search_stack = pop_search_level (search_stack);
-  return rval;
-}
-
-tree
-next_baselink (baselink)
-     tree baselink;
-{
-  tree tmp = TREE_TYPE (baselink);
-  baselink = TREE_CHAIN (baselink);
-  while (tmp)
-    {
-      /* @@ does not yet add previous base types.  */
-      baselink = tree_cons (TREE_PURPOSE (tmp), TREE_VALUE (tmp),
-			    baselink);
-      TREE_TYPE (baselink) = TREE_TYPE (tmp);
-      tmp = TREE_CHAIN (tmp);
-    }
-  return baselink;
-}
-
-/* DEPTH-FIRST SEARCH ROUTINES.  */
-
-/* Assign unique numbers to _CLASSTYPE members of the lattice
-   specified by TYPE.  The root nodes are marked first; the nodes
-   are marked depth-fisrt, left-right.  */
-
-static int cid;
-
-/* Matrix implementing a relation from CLASSTYPE X CLASSTYPE => INT.
-   Relation yields 1 if C1 <= C2, 0 otherwise.  */
-typedef char mi_boolean;
-static mi_boolean *mi_matrix;
-
-/* Type for which this matrix is defined.  */
-static tree mi_type;
-
-/* Size of the matrix for indexing purposes.  */
-static int mi_size;
-
-/* Return nonzero if class C2 derives from class C1.  */
-#define BINFO_DERIVES_FROM(C1, C2)	\
-  ((mi_matrix+mi_size*(BINFO_CID (C1)-1))[BINFO_CID (C2)-1])
-#define TYPE_DERIVES_FROM(C1, C2)	\
-  ((mi_matrix+mi_size*(CLASSTYPE_CID (C1)-1))[CLASSTYPE_CID (C2)-1])
-#define BINFO_DERIVES_FROM_STAR(C)	\
-  (mi_matrix+(BINFO_CID (C)-1))
-
-/* This routine converts a pointer to be a pointer of an immediate
-   base class.  The normal convert_pointer_to routine would diagnose
-   the conversion as ambiguous, under MI code that has the base class
-   as an ambiguous base class. */
-static tree
-convert_pointer_to_single_level (to_type, expr)
-     tree to_type, expr;
-{
-  tree binfo_of_derived;
-  tree last;
-
-  binfo_of_derived = TYPE_BINFO (TREE_TYPE (TREE_TYPE (expr)));
-  last = get_binfo (to_type, TREE_TYPE (TREE_TYPE (expr)), 0);
-  BINFO_INHERITANCE_CHAIN (last) = binfo_of_derived;
-  BINFO_INHERITANCE_CHAIN (binfo_of_derived) = NULL_TREE;
-  return build_vbase_path (PLUS_EXPR, TYPE_POINTER_TO (to_type), expr, last, 1);
-}
-
-/* The main function which implements depth first search.
-
-   This routine has to remember the path it walked up, when
-   dfs_init_vbase_pointers is the work function, as otherwise there
-   would be no record. */
-static void
-dfs_walk (binfo, fn, qfn)
-     tree binfo;
-     void (*fn)();
-     int (*qfn)();
-{
-  tree binfos = BINFO_BASETYPES (binfo);
-  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  for (i = 0; i < n_baselinks; i++)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-      if ((*qfn)(base_binfo))
-	{
-#define NEW_CONVERT 1
-#if NEW_CONVERT
-	  if (fn == dfs_init_vbase_pointers)
-	    {
-	      /* When traversing an arbitrary MI hierarchy, we need to keep
-		 a record of the path we took to get down to the final base
-		 type, as otherwise there would be no record of it, and just
-		 trying to blindly convert at the bottom would be ambiguous.
-
-		 The easiest way is to do the conversions one step at a time,
-		 as we know we want the immediate base class at each step.
-
-		 The only special trick to converting one step at a time,
-		 is that when we hit the last virtual base class, we must
-		 use the SLOT value for it, and not use the normal convert
-		 routine.  We use the last virtual base class, as in our
-		 implementation, we have pointers to all virtual base
-		 classes in the base object.  */
-
-	      tree saved_vbase_decl_ptr_intermediate
-		= vbase_decl_ptr_intermediate;
-
-	      if (TREE_VIA_VIRTUAL (base_binfo))
-		{
-		  /* No need for the conversion here, as we know it is the
-		     right type.  */
-		  vbase_decl_ptr_intermediate =
-		    (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo));
-		}
-	      else
-		{
-#ifdef CHECK_convert_pointer_to_single_level
-		  /* This code here introduces a little software fault
-		     tolerance It should be that case that the second
-		     one always gets the same valid answer that the
-		     first one gives, if the first one gives a valid
-		     answer.
-
-		     If it doesn't, the second algorithm is at fault
-		     and needs to be fixed.
-
-		     The first one is known to be bad and produce
-		     error_mark_node when dealing with MI base
-		     classes.  It is the only problem supposed to be
-		     fixed by the second. */
-#endif
-		  tree vdpi1, vdpi2;
-
-#ifdef CHECK_convert_pointer_to_single_level
-		  vdpi1 = convert_pointer_to (BINFO_TYPE (base_binfo),
-					      vbase_decl_ptr_intermediate);
-#endif
-		  vdpi2 = convert_pointer_to_single_level (BINFO_TYPE (base_binfo),
-							   vbase_decl_ptr_intermediate);
-		  vbase_decl_ptr_intermediate = vdpi2;
-#ifdef CHECK_convert_pointer_to_single_level
-		  if (vdpi1 == error_mark_node && vdpi2 != vdpi1)
-		    {
-		      extern int errorcount;
-		      errorcount -=2;
-		      warning ("internal: Don't worry, be happy, I can fix tangs man.  (ignore above error)");
-		    }
-		  else if (simple_cst_equal (vdpi1, vdpi2) != 1) {
-		    if (simple_cst_equal (vdpi1, vdpi2) == 0)
-		      warning ("internal: convert_pointer_to_single_level: They are not the same, going with old algorithm");
-		    else
-		      warning ("internal: convert_pointer_to_single_level: They might not be the same, going with old algorithm");
-		    vbase_decl_ptr_intermediate = vdpi1;
-		  }
-#endif
-		}
-
-	      dfs_walk (base_binfo, fn, qfn);
-
-	      vbase_decl_ptr_intermediate = saved_vbase_decl_ptr_intermediate;
-	    } else
-#endif
-	      dfs_walk (base_binfo, fn, qfn);
-	}
-    }
-
-  fn (binfo);
-}
-
-/* Predicate functions which serve for dfs_walk.  */
-static int numberedp (binfo) tree binfo;
-{ return BINFO_CID (binfo); }
-static int unnumberedp (binfo) tree binfo;
-{ return BINFO_CID (binfo) == 0; }
-
-static int markedp (binfo) tree binfo;
-{ return BINFO_MARKED (binfo); }
-static int bfs_markedp (binfo, i) tree binfo; int i;
-{ return BINFO_MARKED (BINFO_BASETYPE (binfo, i)); }
-static int unmarkedp (binfo) tree binfo;
-{ return BINFO_MARKED (binfo) == 0; }
-static int bfs_unmarkedp (binfo, i) tree binfo; int i;
-{ return BINFO_MARKED (BINFO_BASETYPE (binfo, i)) == 0; }
-static int marked_vtable_pathp (binfo) tree binfo;
-{ return BINFO_VTABLE_PATH_MARKED (binfo); }
-static int bfs_marked_vtable_pathp (binfo, i) tree binfo; int i;
-{ return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo, i)); }
-static int unmarked_vtable_pathp (binfo) tree binfo;
-{ return BINFO_VTABLE_PATH_MARKED (binfo) == 0; }
-static int bfs_unmarked_vtable_pathp (binfo, i) tree binfo; int i;
-{ return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo, i)) == 0; }
-static int marked_new_vtablep (binfo) tree binfo;
-{ return BINFO_NEW_VTABLE_MARKED (binfo); }
-static int bfs_marked_new_vtablep (binfo, i) tree binfo; int i;
-{ return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo, i)); }
-static int unmarked_new_vtablep (binfo) tree binfo;
-{ return BINFO_NEW_VTABLE_MARKED (binfo) == 0; }
-static int bfs_unmarked_new_vtablep (binfo, i) tree binfo; int i;
-{ return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo, i)) == 0; }
-
-static int dfs_search_slot_nonempty_p (binfo) tree binfo;
-{ return CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo)) != 0; }
-
-static int dfs_debug_unmarkedp (binfo) tree binfo;
-{ return CLASSTYPE_DEBUG_REQUESTED (BINFO_TYPE (binfo)) == 0; }
-
-/* The worker functions for `dfs_walk'.  These do not need to
-   test anything (vis a vis marking) if they are paired with
-   a predicate function (above).  */
-
-/* Assign each type within the lattice a number which is unique
-   in the lattice.  The first number assigned is 1.  */
-
-static void
-dfs_number (binfo)
-     tree binfo;
-{
-  BINFO_CID (binfo) = ++cid;
-}
-
-static void
-dfs_unnumber (binfo)
-     tree binfo;
-{
-  BINFO_CID (binfo) = 0;
-}
-
-static void
-dfs_mark (binfo) tree binfo;
-{ SET_BINFO_MARKED (binfo); }
-
-static void
-dfs_unmark (binfo) tree binfo;
-{ CLEAR_BINFO_MARKED (binfo); }
-
-static void
-dfs_mark_vtable_path (binfo) tree binfo;
-{ SET_BINFO_VTABLE_PATH_MARKED (binfo); }
-
-static void
-dfs_unmark_vtable_path (binfo) tree binfo;
-{ CLEAR_BINFO_VTABLE_PATH_MARKED (binfo); }
-
-static void
-dfs_mark_new_vtable (binfo) tree binfo;
-{ SET_BINFO_NEW_VTABLE_MARKED (binfo); }
-
-static void
-dfs_unmark_new_vtable (binfo) tree binfo;
-{ CLEAR_BINFO_NEW_VTABLE_MARKED (binfo); }
-
-static void
-dfs_clear_search_slot (binfo) tree binfo;
-{ CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo)) = 0; }
-
-static void
-dfs_debug_mark (binfo)
-     tree binfo;
-{
-  tree t = BINFO_TYPE (binfo);
-
-  /* Use heuristic that if there are virtual functions,
-     ignore until we see a non-inline virtual function.  */
-  tree methods = CLASSTYPE_METHOD_VEC (t);
-
-  CLASSTYPE_DEBUG_REQUESTED (t) = 1;
-
-  /* If interface info is known, the value of (?@@?) is correct.  */
-  if (methods == 0
-      || ! CLASSTYPE_INTERFACE_UNKNOWN (t)
-      || (write_virtuals == 2 && TYPE_VIRTUAL_P (t)))
-    return;
-
-  /* If debug info is requested from this context for this type, supply it.
-     If debug info is requested from another context for this type,
-     see if some third context can supply it.  */
-  if (current_function_decl == NULL_TREE
-      || DECL_CLASS_CONTEXT (current_function_decl) != t)
-    {
-      if (TREE_VEC_ELT (methods, 0))
-	methods = TREE_VEC_ELT (methods, 0);
-      else
-	methods = TREE_VEC_ELT (methods, 1);
-      while (methods)
-	{
-	  if (DECL_VINDEX (methods)
-	      && DECL_SAVED_INSNS (methods) == 0
-	      && DECL_PENDING_INLINE_INFO (methods) == 0
-	      && DECL_ABSTRACT_VIRTUAL_P (methods) == 0)
-	    {
-	      /* Somebody, somewhere is going to have to define this
-		 virtual function.  When they do, they will provide
-		 the debugging info.  */
-	      return;
-	    }
-	  methods = TREE_CHAIN (methods);
-	}
-    }
-  /* We cannot rely on some alien method to solve our problems,
-     so we must write out the debug info ourselves.  */
-  DECL_IGNORED_P (TYPE_NAME (t)) = 0;
-  if (! TREE_ASM_WRITTEN (TYPE_NAME (t)))
-    rest_of_type_compilation (t, global_bindings_p ());
-}
-
-/*  Attach to the type of the virtual base class, the pointer to the
-    virtual base class, given the global pointer vbase_decl_ptr.  */
-static void
-dfs_find_vbases (binfo)
-     tree binfo;
-{
-  tree binfos = BINFO_BASETYPES (binfo);
-  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  for (i = n_baselinks-1; i >= 0; i--)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-      if (TREE_VIA_VIRTUAL (base_binfo)
-	  && CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo)) == 0)
-	{
-	  tree vbase = BINFO_TYPE (base_binfo);
-	  tree binfo = binfo_member (vbase, vbase_types);
-
-	  CLASSTYPE_SEARCH_SLOT (vbase)
-	    = (char *) build (PLUS_EXPR, TYPE_POINTER_TO (vbase),
-			      vbase_decl_ptr, BINFO_OFFSET (binfo));
-	}
-    }
-  SET_BINFO_VTABLE_PATH_MARKED (binfo);
-  SET_BINFO_NEW_VTABLE_MARKED (binfo);
-}
-
-static void
-dfs_init_vbase_pointers (binfo)
-     tree binfo;
-{
-  tree type = BINFO_TYPE (binfo);
-  tree fields = TYPE_FIELDS (type);
-  tree path, this_vbase_ptr;
-  int distance;
-
-  CLEAR_BINFO_VTABLE_PATH_MARKED (binfo);
-
-  /* If there is a dossier, it is the first field, though perhaps from
-     the base class.  Otherwise, the first fields are virtual base class
-     pointer fields.  */
-  if (CLASSTYPE_DOSSIER (type) && VFIELD_NAME_P (DECL_NAME (fields)))
-    /* Get past vtable for the object.  */
-    fields = TREE_CHAIN (fields);
-
-  if (fields == NULL_TREE
-      || DECL_NAME (fields) == NULL_TREE
-      || ! VBASE_NAME_P (DECL_NAME (fields)))
-    return;
-
-#if NEW_CONVERT
-  this_vbase_ptr = vbase_decl_ptr_intermediate;
-
-  if (TYPE_POINTER_TO (type) != TREE_TYPE (this_vbase_ptr))
-    my_friendly_abort (125);
-#endif
-
-#if NEW_CONVERT == 0
-  distance = get_base_distance (type, TREE_TYPE (vbase_decl), 0, &path);
-  if (distance == -2)
-    {
-      error ("inheritance lattice too complex below");
-    }
-  while (path)
-    {
-      if (TREE_VIA_VIRTUAL (path))
-	break;
-      distance -= 1;
-      path = BINFO_INHERITANCE_CHAIN (path);
-    }
-
-  if (distance > 0)
-    this_vbase_ptr = convert_pointer_to (type, (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (path)));
-  else
-    this_vbase_ptr = convert_pointer_to (type, vbase_decl_ptr);
-
-  /* This happens when it is ambiguous. */
-  if (this_vbase_ptr == error_mark_node)
-    return;
-#endif
-
-  while (fields && DECL_NAME (fields)
-	 && VBASE_NAME_P (DECL_NAME (fields)))
-    {
-      tree ref = build (COMPONENT_REF, TREE_TYPE (fields),
-			build_indirect_ref (this_vbase_ptr, 0), fields);
-      tree init = (tree)CLASSTYPE_SEARCH_SLOT (TREE_TYPE (TREE_TYPE (fields)));
-      vbase_init_result = tree_cons (binfo_member (TREE_TYPE (TREE_TYPE (fields)),
-						   vbase_types),
-				     build_modify_expr (ref, NOP_EXPR, init),
-				     vbase_init_result);
-      fields = TREE_CHAIN (fields);
-    }
-}
-
-/* Sometimes this needs to clear both VTABLE_PATH and NEW_VTABLE.  Other
-   times, just NEW_VTABLE, but optimizer should make both with equal
-   efficiency (though it does not currently).  */
-static void
-dfs_clear_vbase_slots (binfo)
-     tree binfo;
-{
-  tree type = BINFO_TYPE (binfo);
-  CLASSTYPE_SEARCH_SLOT (type) = 0;
-  CLEAR_BINFO_VTABLE_PATH_MARKED (binfo);
-  CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
-}
-
-tree
-init_vbase_pointers (type, decl_ptr)
-     tree type;
-     tree decl_ptr;
-{
-  if (TYPE_USES_VIRTUAL_BASECLASSES (type))
-    {
-      int old_flag = flag_this_is_variable;
-      tree binfo = TYPE_BINFO (type);
-      flag_this_is_variable = -2;
-      vbase_types = CLASSTYPE_VBASECLASSES (type);
-      vbase_decl_ptr = decl_ptr;
-      vbase_decl = build_indirect_ref (decl_ptr, 0);
-      vbase_decl_ptr_intermediate = vbase_decl_ptr;
-      vbase_init_result = NULL_TREE;
-      dfs_walk (binfo, dfs_find_vbases, unmarked_vtable_pathp);
-      dfs_walk (binfo, dfs_init_vbase_pointers, marked_vtable_pathp);
-      dfs_walk (binfo, dfs_clear_vbase_slots, marked_new_vtablep);
-      flag_this_is_variable = old_flag;
-      return vbase_init_result;
-    }
-  return 0;
-}
-
-/* Build a COMPOUND_EXPR which when expanded will generate the code
-   needed to initialize all the virtual function table slots of all
-   the virtual baseclasses.  FOR_TYPE is the type which determines the
-   virtual baseclasses to use; TYPE is the type of the object to which
-   the initialization applies.  TRUE_EXP is the true object we are
-   initializing, and DECL_PTR is the pointer to the sub-object we
-   are initializing.
-
-   CTOR_P is non-zero if the caller of this function is a top-level
-   constructor.  It is zero when called from a destructor.  When
-   non-zero, we can use computed offsets to store the vtables.  When
-   zero, we must store new vtables through virtual baseclass pointers.  */
-
-tree
-build_vbase_vtables_init (main_binfo, binfo, true_exp, decl_ptr, ctor_p)
-     tree main_binfo, binfo;
-     tree true_exp, decl_ptr;
-     int ctor_p;
-{
-  tree for_type = BINFO_TYPE (main_binfo);
-  tree type = BINFO_TYPE (binfo);
-  if (TYPE_USES_VIRTUAL_BASECLASSES (type))
-    {
-      int old_flag = flag_this_is_variable;
-      tree vtable_init_result = NULL_TREE;
-      tree vbases = CLASSTYPE_VBASECLASSES (type);
-
-      vbase_types = CLASSTYPE_VBASECLASSES (for_type);
-      vbase_decl_ptr = true_exp ? build_unary_op (ADDR_EXPR, true_exp, 0) : decl_ptr;
-      vbase_decl = true_exp ? true_exp : build_indirect_ref (decl_ptr, 0);
-
-      if (ctor_p)
-	{
-	  /* This is an object of type IN_TYPE,  */
-	  flag_this_is_variable = -2;
-	  dfs_walk (main_binfo, dfs_find_vbases, unmarked_new_vtablep);
-	}
-
-      /* Initialized with vtables of type TYPE.  */
-      while (vbases)
-	{
-	  /* This time through, not every class's vtable
-	     is going to be initialized.  That is, we only initialize
-	     the "last" vtable pointer.  */
-
-	  if (CLASSTYPE_VSIZE (BINFO_TYPE (vbases)))
-	    {
-	      tree addr;
-	      tree vtbl = BINFO_VTABLE (vbases);
-	      tree init = build_unary_op (ADDR_EXPR, vtbl, 0);
-	      assemble_external (vtbl);
-	      TREE_USED (vtbl) = 1;
-
-	      if (ctor_p == 0)
-		addr = convert_pointer_to (vbases, vbase_decl_ptr);
-	      else
-		addr = (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (vbases));
-
-	      if (addr)
-		{
-		  tree ref = build_vfield_ref (build_indirect_ref (addr, 0),
-					       BINFO_TYPE (vbases));
-		  init = convert_force (TREE_TYPE (ref), init);
-		  vtable_init_result = tree_cons (NULL_TREE, build_modify_expr (ref, NOP_EXPR, init),
-						  vtable_init_result);
-		}
-	    }
-	  vbases = TREE_CHAIN (vbases);
-	}
-
-      dfs_walk (binfo, dfs_clear_vbase_slots, marked_new_vtablep);
-
-      flag_this_is_variable = old_flag;
-      if (vtable_init_result)
-	return build_compound_expr (vtable_init_result);
-    }
-  return error_mark_node;
-}
-
-void
-clear_search_slots (type)
-     tree type;
-{
-  dfs_walk (TYPE_BINFO (type),
-	    dfs_clear_search_slot, dfs_search_slot_nonempty_p);
-}
-
-static void
-dfs_get_vbase_types (binfo)
-     tree binfo;
-{
-  int i;
-  tree binfos = BINFO_BASETYPES (binfo);
-  tree type = BINFO_TYPE (binfo);
-  tree these_vbase_types = CLASSTYPE_VBASECLASSES (type);
-
-  if (these_vbase_types)
-    {
-      while (these_vbase_types)
-	{
-	  tree this_type = BINFO_TYPE (these_vbase_types);
-
-	  /* We really need to start from a fresh copy of this
-	     virtual basetype!  CLASSTYPE_MARKED2 is the shortcut
-	     for BINFO_VBASE_MARKED.  */
-	  if (! CLASSTYPE_MARKED2 (this_type))
-	    {
-	      vbase_types = make_binfo (integer_zero_node,
-					this_type,
-					TYPE_BINFO_VTABLE (this_type),
-					TYPE_BINFO_VIRTUALS (this_type),
-					vbase_types);
-	      TREE_VIA_VIRTUAL (vbase_types) = 1;
-	      SET_CLASSTYPE_MARKED2 (this_type);
-	    }
-	  these_vbase_types = TREE_CHAIN (these_vbase_types);
-	}
-    }
-  else for (i = binfos ? TREE_VEC_LENGTH (binfos)-1 : -1; i >= 0; i--)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-      if (TREE_VIA_VIRTUAL (base_binfo) && ! BINFO_VBASE_MARKED (base_binfo))
-	{
-	  vbase_types = make_binfo (integer_zero_node, BINFO_TYPE (base_binfo),
-				    BINFO_VTABLE (base_binfo),
-				    BINFO_VIRTUALS (base_binfo), vbase_types);
-	  TREE_VIA_VIRTUAL (vbase_types) = 1;
-	  SET_BINFO_VBASE_MARKED (base_binfo);
-	}
-    }
-  SET_BINFO_MARKED (binfo);
-}
-
-/* Some virtual baseclasses might be virtual baseclasses for
-   other virtual baseclasses.  We sort the virtual baseclasses
-   topologically: in the list returned, the first virtual base
-   classes have no virtual baseclasses themselves, and any entry
-   on the list has no dependency on virtual base classes later in the
-   list.  */
-tree
-get_vbase_types (type)
-     tree type;
-{
-  tree ordered_vbase_types = NULL_TREE, prev, next;
-  tree vbases;
-
-  vbase_types = NULL_TREE;
-  dfs_walk (TYPE_BINFO (type), dfs_get_vbase_types, unmarkedp);
-  dfs_walk (TYPE_BINFO (type), dfs_unmark, markedp);
-
-  while (vbase_types)
-    {
-      /* Now sort these types.  This is essentially a bubble merge.  */
-
-      /* Farm out virtual baseclasses which have no marked ancestors.  */
-      for (vbases = vbase_types, prev = NULL_TREE;
-	   vbases; vbases = next)
-	{
-	  next = TREE_CHAIN (vbases);
-	  /* If VBASES does not have any vbases itself, or it's
-	     topologically safe, it goes into the sorted list.  */
-	  if (! CLASSTYPE_VBASECLASSES (BINFO_TYPE (vbases))
-	      || BINFO_VBASE_MARKED (vbases) == 0)
-	    {
-	      if (prev)
-		TREE_CHAIN (prev) = TREE_CHAIN (vbases);
-	      else
-		vbase_types = TREE_CHAIN (vbases);
-	      TREE_CHAIN (vbases) = NULL_TREE;
-	      ordered_vbase_types = chainon (ordered_vbase_types, vbases);
-	      CLEAR_BINFO_VBASE_MARKED (vbases);
-	    }
-	  else
-	    prev = vbases;
-	}
-
-      /* Now unmark types all of whose ancestors are now on the
-	 `ordered_vbase_types' list.  */
-      for (vbases = vbase_types; vbases; vbases = TREE_CHAIN (vbases))
-	{
-	  /* If all our virtual baseclasses are unmarked, ok.  */
-	  tree t = CLASSTYPE_VBASECLASSES (BINFO_TYPE (vbases));
-	  while (t && (BINFO_VBASE_MARKED (t) == 0
-		       || ! CLASSTYPE_VBASECLASSES (BINFO_TYPE (t))))
-	    t = TREE_CHAIN (t);
-	  if (t == NULL_TREE)
-	    CLEAR_BINFO_VBASE_MARKED (vbases);
-	}
-    }
-
-  return ordered_vbase_types;
-}
-
-static void
-dfs_record_inheritance (binfo)
-     tree binfo;
-{
-  tree binfos = BINFO_BASETYPES (binfo);
-  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-  mi_boolean *derived_row = BINFO_DERIVES_FROM_STAR (binfo);
-
-  for (i = n_baselinks-1; i >= 0; i--)
-    {
-      int j;
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-      tree baseclass = BINFO_TYPE (base_binfo);
-      mi_boolean *base_row = BINFO_DERIVES_FROM_STAR (base_binfo);
-
-      /* Don't search if there's nothing there!  MI_SIZE can be
-	 zero as a result of parse errors.  */
-      if (TYPE_BINFO_BASETYPES (baseclass) && mi_size > 0)
-	for (j = mi_size*(CLASSTYPE_CID (baseclass)-1); j >= 0; j -= mi_size)
-	  derived_row[j] |= base_row[j];
-      TYPE_DERIVES_FROM (baseclass, BINFO_TYPE (binfo)) = 1;
-    }
-
-  SET_BINFO_MARKED (binfo);
-}
-
-/* Given a _CLASSTYPE node in a multiple inheritance lattice,
-   convert the lattice into a simple relation such that,
-   given to CIDs, C1 and C2, one can determine if C1 <= C2
-   or C2 <= C1 or C1 <> C2.
-
-   Once constructed, we walk the lattice depth fisrt,
-   applying various functions to elements as they are encountered.
-
-   We use xmalloc here, in case we want to randomly free these tables.  */
-
-#define SAVE_MI_MATRIX
-
-void
-build_mi_matrix (type)
-     tree type;
-{
-  tree binfo = TYPE_BINFO (type);
-  cid = 0;
-
-#ifdef SAVE_MI_MATRIX
-  if (CLASSTYPE_MI_MATRIX (type))
-    {
-      mi_size = CLASSTYPE_N_SUPERCLASSES (type) + CLASSTYPE_N_VBASECLASSES (type);
-      mi_matrix = CLASSTYPE_MI_MATRIX (type);
-      mi_type = type;
-      dfs_walk (binfo, dfs_number, unnumberedp);
-      return;
-    }
-#endif
-
-  mi_size = CLASSTYPE_N_SUPERCLASSES (type) + CLASSTYPE_N_VBASECLASSES (type);
-  mi_matrix = (char *)xmalloc ((mi_size+1) * (mi_size+1));
-  mi_type = type;
-  bzero (mi_matrix, mi_size * mi_size);
-  dfs_walk (binfo, dfs_number, unnumberedp);
-  dfs_walk (binfo, dfs_record_inheritance, unmarkedp);
-  dfs_walk (binfo, dfs_unmark, markedp);
-}
-
-void
-free_mi_matrix ()
-{
-  dfs_walk (TYPE_BINFO (mi_type), dfs_unnumber, numberedp);
-
-#ifdef SAVE_MI_MATRIX
-  CLASSTYPE_MI_MATRIX (mi_type) = mi_matrix;
-#else
-  free (mi_matrix);
-  mi_size = 0;
-  cid = 0;
-#endif
-}
-
-/* Local variables for detecting ambiguities of virtual functions
-   when two or more classes are joined at a multiple inheritance
-   seam.  */
-typedef struct
-{
-  tree decl;
-  tree args;
-  tree ptr;
-} mi_ventry;
-static mi_ventry *mi_vmatrix;
-static int *mi_vmax;
-static int mi_vrows, mi_vcols;
-#define MI_VMATRIX(ROW,COL) ((mi_vmatrix + (ROW)*mi_vcols)[COL])
-
-/* Build a table of virtual functions for a multiple-inheritance
-   structure.  Here, there are N base classes, and at most
-   M entries per class.
-
-   This function does nothing if N is 0 or 1.  */
-void
-build_mi_virtuals (rows, cols)
-     int rows, cols;
-{
-  if (rows < 2 || cols == 0)
-    return;
-  mi_vrows = rows;
-  mi_vcols = cols;
-  mi_vmatrix = (mi_ventry *)xmalloc ((rows+1) * cols * sizeof (mi_ventry));
-  mi_vmax = (int *)xmalloc ((rows+1) * sizeof (int));
-
-  bzero (mi_vmax, rows * sizeof (int));
-
-  /* Row indices start at 1, so adjust this.  */
-  mi_vmatrix -= cols;
-  mi_vmax -= 1;
-}
-
-/* Comparison function for ordering virtual function table entries.  */
-static int
-rank_mi_virtuals (v1, v2)
-     mi_ventry *v1, *v2;
-{
-  tree p1, p2;
-  int i;
-
-  i = (long) (DECL_NAME (v1->decl)) - (long) (DECL_NAME (v2->decl));
-  if (i)
-    return i;
-  p1 = v1->args;
-  p2 = v2->args;
-
-  if (p1 == p2)
-    return 0;
-
-  while (p1 && p2)
-    {
-      i = ((long) (TREE_VALUE (p1)) - (long) (TREE_VALUE (p2)));
-      if (i)
-	return i;
-
-      if (TREE_CHAIN (p1))
-	{
-	  if (! TREE_CHAIN (p2))
-	    return 1;
-	  p1 = TREE_CHAIN (p1);
-	  p2 = TREE_CHAIN (p2);
-	}
-      else if (TREE_CHAIN (p2))
-	return -1;
-      else
-	{
-	  /* When matches of argument lists occur, pick lowest
-	     address to keep searching time to a minimum on
-	     later passes--like hashing, only different.
-	     *MUST BE STABLE*.  */
-	  if ((long) (v2->args) < (long) (v1->args))
-	    v1->args = v2->args;
-	  else
-	    v2->args = v1->args;
-	  return 0;
-	}
-    }
-  return 0;
-}
-
-/* Install the virtuals functions got from the initializer VIRTUALS to
-   the table at index ROW.  */
-void
-add_mi_virtuals (row, virtuals)
-     int row;
-     tree virtuals;
-{
-  int col = 0;
-
-  if (mi_vmatrix == 0)
-    return;
-  while (virtuals)
-    {
-      tree decl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
-      MI_VMATRIX (row, col).decl = decl;
-      MI_VMATRIX (row, col).args = FUNCTION_ARG_CHAIN (decl);
-      MI_VMATRIX (row, col).ptr = TREE_VALUE (virtuals);
-      virtuals = TREE_CHAIN (virtuals);
-      col += 1;
-    }
-  mi_vmax[row] = col;
-
-  qsort (mi_vmatrix + row * mi_vcols,
-	 col,
-	 sizeof (mi_ventry),
-	 rank_mi_virtuals);
-}
-
-/* If joining two types results in an ambiguity in the virtual
-   function table, report such here.  */
-void
-report_ambiguous_mi_virtuals (rows, type)
-     int rows;
-     tree type;
-{
-  int *mi_vmin;
-  int row1, col1, row, col;
-
-  if (mi_vmatrix == 0)
-    return;
-
-  /* Now virtuals are all sorted, so we merge to find ambiguous cases.  */
-  mi_vmin = (int *)alloca ((rows+1) * sizeof (int));
-  bzero (mi_vmin, rows * sizeof (int));
-
-  /* adjust.  */
-  mi_vmin -= 1;
-
-  /* For each base class with virtual functions (and this includes views
-     of the virtual baseclasses from different base classes), see that
-     each virtual function in that base class has a unique meet.
-
-     When the column loop is finished, THIS_DECL is in fact the meet.
-     If that value does not appear in the virtual function table for
-     the row, install it.  This happens when that virtual function comes
-     from a virtual baseclass, or a non-leftmost baseclass.  */
-
-  for (row1 = 1; row1 < rows; row1++)
-    {
-      tree this_decl = 0;
-
-      for (col1 = mi_vmax[row1]-1; col1 >= mi_vmin[row1]; col1--)
-	{
-	  tree these_args = MI_VMATRIX (row1, col1).args;
-	  tree this_context;
-
-	  this_decl = MI_VMATRIX (row1, col1).decl;
-	  if (this_decl == 0)
-	    continue;
-	  this_context = TYPE_BINFO (DECL_CLASS_CONTEXT (this_decl));
-
-	  if (this_context != TYPE_BINFO (type))
-	    this_context = get_binfo (this_context, type, 0);
-
-	  for (row = row1+1; row <= rows; row++)
-	    for (col = mi_vmax[row]-1; col >= mi_vmin[row]; col--)
-	      {
-		mi_ventry this_entry;
-
-		if (MI_VMATRIX (row, col).decl == 0)
-		  continue;
-
-		this_entry.decl = this_decl;
-		this_entry.args = these_args;
-		this_entry.ptr = MI_VMATRIX (row1, col1).ptr;
-		if (rank_mi_virtuals (&this_entry, &MI_VMATRIX (row, col)) == 0)
-		  {
-		    /* They are equal.  There are four possibilities:
-
-		       (1) Derived class is defining this virtual function.
-		       (2) Two paths to the same virtual function in the
-		       same base class.
-		       (3) A path to a virtual function declared in one base
-		       class, and another path to a virtual function in a
-		       base class of the base class.
-		       (4) Two paths to the same virtual function in different
-		       base classes.
-
-		       The first three cases are ok (non-ambiguous).  */
-
-		    tree that_context, tmp;
-		    int this_before_that;
-
-		    if (type == BINFO_TYPE (this_context))
-		      /* case 1.  */
-		      goto ok;
-		    that_context = get_binfo (DECL_CLASS_CONTEXT (MI_VMATRIX (row, col).decl), type, 0);
-		    if (that_context == this_context)
-		      /* case 2.  */
-		      goto ok;
-		    if (that_context != NULL_TREE)
-		      {
-			tmp = get_binfo (that_context, this_context, 0);
-			this_before_that = (that_context != tmp);
-			if (this_before_that == 0)
-			  /* case 3a.  */
-			  goto ok;
-			tmp = get_binfo (this_context, that_context, 0);
-			this_before_that = (this_context == tmp);
-			if (this_before_that != 0)
-			  /* case 3b.  */
-			  goto ok;
-
-			/* case 4.  */
-			/* These two are not hard errors, but could be
-			   symptoms of bad code.  The resultant code
-			   the compiler generates needs to be checked.
-			   (mrs) */
-#if 0
-			error_with_decl (MI_VMATRIX (row, col).decl, "ambiguous virtual function `%s'");
-			error_with_decl (this_decl, "ambiguating function `%s' (joined by type `%s')", IDENTIFIER_POINTER (current_class_name));
-#endif
-		      }
-		  ok:
-		    MI_VMATRIX (row, col).decl = 0;
-
-		    /* Let zeros propagate.  */
-		    if (col == mi_vmax[row]-1)
-		      {
-			int i = col;
-			while (i >= mi_vmin[row]
-			       && MI_VMATRIX (row, i).decl == 0)
-			  i--;
-			mi_vmax[row] = i+1;
-		      }
-		    else if (col == mi_vmin[row])
-		      {
-			int i = col;
-			while (i < mi_vmax[row]
-			       && MI_VMATRIX (row, i).decl == 0)
-			  i++;
-			mi_vmin[row] = i;
-		      }
-		  }
-	      }
-	}
-    }
-  free (mi_vmatrix + mi_vcols);
-  mi_vmatrix = 0;
-  free (mi_vmax + 1);
-  mi_vmax = 0;
-}
-
-/* If we want debug info for a type TYPE, make sure all its base types
-   are also marked as being potentially interesting.  This avoids
-   the problem of not writing any debug info for intermediate basetypes
-   that have abstract virtual functions.  */
-
-void
-note_debug_info_needed (type)
-     tree type;
-{
-  dfs_walk (TYPE_BINFO (type), dfs_debug_mark, dfs_debug_unmarkedp);
-}
-
-/* Subroutines of push_class_decls ().  */
-
-/* Add the instance variables which this class contributed to the
-   current class binding contour.  When a redefinition occurs,
-   if the redefinition is strictly within a single inheritance path,
-   we just overwrite (in the case of a data field) or
-   cons (in the case of a member function) the old declaration with
-   the new.  If the fields are not within a single inheritance path,
-   we must cons them in either case.  */
-
-static void
-dfs_pushdecls (binfo)
-     tree binfo;
-{
-  tree type = BINFO_TYPE (binfo);
-  tree fields, *methods, *end;
-  tree method_vec;
-
-  for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
-    {
-      /* Unmark so that if we are in a constructor, and then find that
-	 this field was initialized by a base initializer,
-	 we can emit an error message.  */
-      if (TREE_CODE (fields) == FIELD_DECL)
-	TREE_USED (fields) = 0;
-
-      if (DECL_NAME (fields) == NULL_TREE
-	  && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
-	{
-	  dfs_pushdecls (TYPE_BINFO (TREE_TYPE (fields)));
-	  continue;
-	}
-      if (TREE_CODE (fields) != TYPE_DECL)
-	{
-	  DECL_PUBLIC (fields) = 0;
-	  DECL_PROTECTED (fields) = 0;
-	  DECL_PRIVATE (fields) = 0;
-	}
-
-      if (DECL_NAME (fields))
-	{
-	  tree value = IDENTIFIER_CLASS_VALUE (DECL_NAME (fields));
-	  if (value)
-	    {
-	      tree context;
-
-	      /* Possible ambiguity.  If its defining type(s)
-		 is (are all) derived from us, no problem.  */
-
-	      if (TREE_CODE (value) != TREE_LIST)
-		{
-		  context = DECL_CLASS_CONTEXT (value);
-
-		  if (context && (context == type
-				  || TYPE_DERIVES_FROM (context, type)))
-		    value = fields;
-		  else
-		    value = tree_cons (NULL_TREE, fields,
-				       build_tree_list (NULL_TREE, value));
-		}
-	      else
-		{
-		  /* All children may derive from us, in which case
-		     there is no problem.  Otherwise, we have to
-		     keep lists around of what the ambiguities might be.  */
-		  tree values;
-		  int problem = 0;
-
-		  for (values = value; values; values = TREE_CHAIN (values))
-		    {
-		      tree sub_values = TREE_VALUE (values);
-
-		      if (TREE_CODE (sub_values) == TREE_LIST)
-			{
-			  for (; sub_values; sub_values = TREE_CHAIN (sub_values))
-			    {
-			      context = DECL_CLASS_CONTEXT (TREE_VALUE (sub_values));
-
-			      if (! TYPE_DERIVES_FROM (context, type))
-				{
-				  value = tree_cons (NULL_TREE, TREE_VALUE (values), value);
-				  problem = 1;
-				  break;
-				}
-			    }
-			}
-		      else
-			{
-			  context = DECL_CLASS_CONTEXT (sub_values);
-
-			  if (! TYPE_DERIVES_FROM (context, type))
-			    {
-			      value = tree_cons (NULL_TREE, values, value);
-			      problem = 1;
-			      break;
-			    }
-			}
-		    }
-		  if (! problem) value = fields;
-		}
-
-	      /* Mark this as a potentially ambiguous member.  */
-	      if (TREE_CODE (value) == TREE_LIST)
-		{
-		  /* Leaving TREE_TYPE blank is intentional.
-		     We cannot use `error_mark_node' (lookup_name)
-		     or `unknown_type_node' (all member functions use this).  */
-		  TREE_NONLOCAL_FLAG (value) = 1;
-		}
-
-	      IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = value;
-	    }
-	  else IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = fields;
-	}
-    }
-
-  method_vec = CLASSTYPE_METHOD_VEC (type);
-  if (method_vec != 0)
-    {
-      /* Farm out constructors and destructors.  */
-      methods = &TREE_VEC_ELT (method_vec, 1);
-      end = TREE_VEC_END (method_vec);
-
-      /* This does not work for multiple inheritance yet.  */
-      while (methods != end)
-	{
-	  /* This will cause lookup_name to return a pointer
-	     to the tree_list of possible methods of this name.
-	     If the order is a problem, we can nreverse them.  */
-	  tree tmp;
-	  tree old = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
-
-	  if (old && TREE_CODE (old) == TREE_LIST)
-	    tmp = tree_cons (DECL_NAME (*methods), *methods, old);
-	  else
-	    {
-	      /* Only complain if we shadow something we can access.  */
-	      if (old && (DECL_CLASS_CONTEXT (old) == current_class_type
-			  || ! TREE_PRIVATE (old)))
-		/* Should figure out visibility more accurately.  */
-		warning ("shadowing member `%s' with member function",
-			 IDENTIFIER_POINTER (DECL_NAME (*methods)));
-	      tmp = build_tree_list (DECL_NAME (*methods), *methods);
-	    }
-
-	  TREE_TYPE (tmp) = unknown_type_node;
-#if 0
-	  TREE_OVERLOADED (tmp) = DECL_OVERLOADED (*methods);
-#endif
-	  TREE_NONLOCAL_FLAG (tmp) = 1;
-	  IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = tmp;
-
-	  tmp = *methods;
-	  while (tmp != 0)
-	    {
-	      DECL_PUBLIC (tmp) = 0;
-	      DECL_PROTECTED (tmp) = 0;
-	      DECL_PRIVATE (tmp) = 0;
-	      tmp = DECL_CHAIN (tmp);
-	    }
-
-	  methods++;
-	}
-    }
-  SET_BINFO_MARKED (binfo);
-}
-
-/* Consolidate unique (by name) member functions.  */
-static void
-dfs_compress_decls (binfo)
-     tree binfo;
-{
-  tree type = BINFO_TYPE (binfo);
-  tree method_vec = CLASSTYPE_METHOD_VEC (type);
-
-  if (method_vec != 0)
-    {
-      /* Farm out constructors and destructors.  */
-      tree *methods = &TREE_VEC_ELT (method_vec, 1);
-      tree *end = TREE_VEC_END (method_vec);
-
-      for (; methods != end; methods++)
-	{
-	  tree tmp = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
-
-	  /* This was replaced in scope by somebody else.  Just leave it
-	     alone.  */
-	  if (TREE_CODE (tmp) != TREE_LIST)
-	    continue;
-
-	  if (TREE_CHAIN (tmp) == NULL_TREE
-	      && TREE_VALUE (tmp)
-	      && DECL_CHAIN (TREE_VALUE (tmp)) == NULL_TREE)
-	    {
-	      IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = TREE_VALUE (tmp);
-	    }
-	}
-    }
-  CLEAR_BINFO_MARKED (binfo);
-}
-
-/* When entering the scope of a class, we cache all of the
-   fields that that class provides within its inheritance
-   lattice.  Where ambiguities result, we mark them
-   with `error_mark_node' so that if they are encountered
-   without explicit qualification, we can emit an error
-   message.  */
-void
-push_class_decls (type)
-     tree type;
-{
-  tree id;
-  struct obstack *ambient_obstack = current_obstack;
-
-#if 0
-  tree tags = CLASSTYPE_TAGS (type);
-
-  while (tags)
-    {
-      tree code_type_node;
-      tree tag;
-
-      switch (TREE_CODE (TREE_VALUE (tags)))
-	{
-	case ENUMERAL_TYPE:
-	  code_type_node = enum_type_node;
-	  break;
-	case RECORD_TYPE:
-	  code_type_node = record_type_node;
-	  break;
-	case CLASS_TYPE:
-	  code_type_node = class_type_node;
-	  break;
-	case UNION_TYPE:
-	  code_type_node = union_type_node;
-	  break;
-	default:
-	  my_friendly_abort (297);
-	}
-      tag = xref_tag (code_type_node, TREE_PURPOSE (tags),
-		      TYPE_BINFO_BASETYPE (TREE_VALUE (tags), 0));
-#if 0 /* not yet, should get fixed properly later */
-      pushdecl (make_type_decl (TREE_PURPOSE (tags), TREE_VALUE (tags)));
-#else
-      pushdecl (build_decl (TYPE_DECL, TREE_PURPOSE (tags), TREE_VALUE (tags)));
-#endif
-    }
-#endif
-
-  current_obstack = &bridge_obstack;
-  search_stack = push_search_level (search_stack, &bridge_obstack);
-
-  id = TYPE_IDENTIFIER (type);
-  if (IDENTIFIER_TEMPLATE (id) != 0)
-    {
-#if 0
-      tree tmpl = IDENTIFIER_TEMPLATE (id);
-      push_template_decls (DECL_ARGUMENTS (TREE_PURPOSE (tmpl)),
-			   TREE_VALUE (tmpl), 1);
-#endif
-      overload_template_name (id, 0);
-    }
-
-  /* Push class fields into CLASS_VALUE scope, and mark.  */
-  dfs_walk (TYPE_BINFO (type), dfs_pushdecls, unmarkedp);
-
-  /* Compress fields which have only a single entry
-     by a given name, and unmark.  */
-  dfs_walk (TYPE_BINFO (type), dfs_compress_decls, markedp);
-  current_obstack = ambient_obstack;
-}
-
-static void
-dfs_popdecls (binfo)
-     tree binfo;
-{
-  tree type = BINFO_TYPE (binfo);
-  tree fields = TYPE_FIELDS (type);
-  tree method_vec = CLASSTYPE_METHOD_VEC (type);
-
-  while (fields)
-    {
-      if (DECL_NAME (fields) == NULL_TREE
-	  && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
-	{
-	  dfs_popdecls (TYPE_BINFO (TREE_TYPE (fields)));
-	}
-      else if (DECL_NAME (fields))
-	IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = NULL_TREE;
-      fields = TREE_CHAIN (fields);
-    }
-  if (method_vec != 0)
-    {
-      tree *methods = &TREE_VEC_ELT (method_vec, 0);
-      tree *end = TREE_VEC_END (method_vec);
-
-      /* Clear out ctors and dtors.  */
-      if (*methods)
-	IDENTIFIER_CLASS_VALUE (TYPE_IDENTIFIER (type)) = NULL_TREE;
-
-      for (methods += 1; methods != end; methods++)
-	IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = NULL_TREE;
-    }
-
-  SET_BINFO_MARKED (binfo);
-}
-
-void
-pop_class_decls (type)
-     tree type;
-{
-  tree binfo = TYPE_BINFO (type);
-
-  /* Clear out the IDENTIFIER_CLASS_VALUE which this
-     class may have occupied, and mark.  */
-  dfs_walk (binfo, dfs_popdecls, unmarkedp);
-
-  /* Unmark.  */
-  dfs_walk (binfo, dfs_unmark, markedp);
-
-#if 0
-  tmpl = IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (type));
-  if (tmpl != 0)
-    pop_template_decls (DECL_ARGUMENTS (TREE_PURPOSE (tmpl)),
-			TREE_VALUE (tmpl), 1);
-#endif
-
-  search_stack = pop_search_level (search_stack);
-}
-
-/* Given a base type PARENT, and a derived type TYPE, build
-   a name which distinguishes exactly the PARENT member of TYPE's type.
-
-   FORMAT is a string which controls how sprintf formats the name
-   we have generated.
-
-   For example, given
-
-	class A; class B; class C : A, B;
-
-   it is possible to distinguish "A" from "C's A".  And given
-
-	class L;
-	class A : L; class B : L; class C : A, B;
-
-   it is possible to distinguish "L" from "A's L", and also from
-   "C's L from A".
-
-   Make sure to use the DECL_ASSEMBLER_NAME of the TYPE_NAME of the
-   type, as template have DECL_NAMEs like: X<int>, whereas the
-   DECL_ASSEMBLER_NAME is set to be something the assembler can handle.
-  */
-tree
-build_type_pathname (format, parent, type)
-     char *format;
-     tree parent, type;
-{
-  extern struct obstack temporary_obstack;
-  char *first, *base, *name;
-  int i;
-  tree id;
-
-  parent = TYPE_MAIN_VARIANT (parent);
-
-  /* Remember where to cut the obstack to.  */
-  first = obstack_base (&temporary_obstack);
-
-  /* Put on TYPE+PARENT.  */
-  obstack_grow (&temporary_obstack,
-		TYPE_ASSEMBLER_NAME_STRING (type),
-		TYPE_ASSEMBLER_NAME_LENGTH (type));
-#ifdef JOINER
-  obstack_1grow (&temporary_obstack, JOINER);
-#else
-  obstack_1grow (&temporary_obstack, '_');
-#endif
-  obstack_grow0 (&temporary_obstack,
-		 TYPE_ASSEMBLER_NAME_STRING (parent),
-		 TYPE_ASSEMBLER_NAME_LENGTH (parent));
-  i = obstack_object_size (&temporary_obstack);
-  base = obstack_base (&temporary_obstack);
-  obstack_finish (&temporary_obstack);
-
-  /* Put on FORMAT+TYPE+PARENT.  */
-  obstack_blank (&temporary_obstack, strlen (format) + i + 1);
-  name = obstack_base (&temporary_obstack);
-  sprintf (name, format, base);
-  id = get_identifier (name);
-  obstack_free (&temporary_obstack, first);
-
-  return id;
-}
-
-static int
-bfs_unmark_finished_struct (binfo, i)
-     tree binfo;
-     int i;
-{
-  if (i >= 0)
-    binfo = BINFO_BASETYPE (binfo, i);
-
-  if (BINFO_NEW_VTABLE_MARKED (binfo))
-    {
-      tree decl, context;
-
-      if (TREE_VIA_VIRTUAL (binfo))
-	binfo = binfo_member (BINFO_TYPE (binfo),
-			      CLASSTYPE_VBASECLASSES (current_class_type));
-
-      decl = BINFO_VTABLE (binfo);
-      context = DECL_CONTEXT (decl);
-      DECL_CONTEXT (decl) = 0;
-      if (write_virtuals >= 0
-	  && DECL_INITIAL (decl) != BINFO_VIRTUALS (binfo))
-	DECL_INITIAL (decl) = build_nt (CONSTRUCTOR, NULL_TREE,
-					BINFO_VIRTUALS (binfo));
-      finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0);
-      DECL_CONTEXT (decl) = context;
-    }
-  CLEAR_BINFO_VTABLE_PATH_MARKED (binfo);
-  CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
-  return 0;
-}
-
-void
-unmark_finished_struct (type)
-     tree type;
-{
-  tree binfo = TYPE_BINFO (type);
-  bfs_unmark_finished_struct (binfo, -1);
-  breadth_first_search (binfo, bfs_unmark_finished_struct, bfs_marked_vtable_pathp);
-}
-
-void
-print_search_statistics ()
-{
-#ifdef GATHER_STATISTICS
-  if (flag_memoize_lookups)
-    {
-      fprintf (stderr, "%d memoized contexts saved\n",
-	       n_contexts_saved);
-      fprintf (stderr, "%d local tree nodes made\n", my_tree_node_counter);
-      fprintf (stderr, "%d local hash nodes made\n", my_memoized_entry_counter);
-      fprintf (stderr, "fields statistics:\n");
-      fprintf (stderr, "  memoized finds = %d; rejects = %d; (searches = %d)\n",
-	       memoized_fast_finds[0], memoized_fast_rejects[0],
-	       memoized_fields_searched[0]);
-      fprintf (stderr, "  memoized_adds = %d\n", memoized_adds[0]);
-      fprintf (stderr, "fnfields statistics:\n");
-      fprintf (stderr, "  memoized finds = %d; rejects = %d; (searches = %d)\n",
-	       memoized_fast_finds[1], memoized_fast_rejects[1],
-	       memoized_fields_searched[1]);
-      fprintf (stderr, "  memoized_adds = %d\n", memoized_adds[1]);
-    }
-  fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
-	   n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
-  fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
-	   n_outer_fields_searched, n_calls_lookup_fnfields);
-  fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
-#else
-  fprintf (stderr, "no search statistics\n");
-#endif
-}
-
-void
-init_search_processing ()
-{
-  gcc_obstack_init (&search_obstack);
-  gcc_obstack_init (&type_obstack);
-  gcc_obstack_init (&type_obstack_entries);
-  gcc_obstack_init (&bridge_obstack);
-
-  /* This gives us room to build our chains of basetypes,
-     whether or not we decide to memoize them.  */
-  type_stack = push_type_level (0, &type_obstack);
-  _vptr_name = get_identifier ("_vptr");
-}
-
-void
-reinit_search_statistics ()
-{
-  my_memoized_entry_counter = 0;
-  memoized_fast_finds[0] = 0;
-  memoized_fast_finds[1] = 0;
-  memoized_adds[0] = 0;
-  memoized_adds[1] = 0;
-  memoized_fast_rejects[0] = 0;
-  memoized_fast_rejects[1] = 0;
-  memoized_fields_searched[0] = 0;
-  memoized_fields_searched[1] = 0;
-  n_fields_searched = 0;
-  n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
-  n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
-  n_calls_get_base_type = 0;
-  n_outer_fields_searched = 0;
-  n_contexts_saved = 0;
-}
diff --git a/gnu/gcc2/cc1plus/cp-spew.c b/gnu/gcc2/cc1plus/cp-spew.c
deleted file mode 100644
index 92f8e618832a..000000000000
--- a/gnu/gcc2/cc1plus/cp-spew.c
+++ /dev/null
@@ -1,1086 +0,0 @@
-/* Type Analyzer for GNU C++.
-   Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc.
-   Hacked... nay, bludgeoned... by Mark Eichin (eichin@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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* This file is the type analyzer for GNU C++.  To debug it, define SPEW_DEBUG
-   when compiling cp-parse.c and cp-spew.c.  */
-
-#include "config.h"
-#include <stdio.h>
-#include "input.h"
-#include "tree.h"
-#include "cp-lex.h"
-#include "cp-parse.h"
-#include "cp-tree.h"
-#include "flags.h"
-#include "obstack.h"
-
-/* This takes a token stream that hasn't decided much about types and
-   tries to figure out as much as it can, with excessive lookahead and
-   backtracking. */
-
-/* fifo of tokens recognized and available to parser. */
-struct token  {
-  /* The values for YYCHAR will fit in a short.  */
-  short		yychar;
-  short		end_of_file;
-  YYSTYPE	yylval;
-};
-
-static int do_aggr ();
-static struct token frob_identifier ();
-static struct token hack_scope ();
-static tree hack_ptype ();
-static tree hack_more_ids ();
-
-/* From cp-lex.c: */
-/* the declaration found for the last IDENTIFIER token read in.
-   yylex must look this up to detect typedefs, which get token type TYPENAME,
-   so it is left around in case the identifier is not a typedef but is
-   used in a context which makes it a reference to a variable.  */
-extern tree lastiddecl;		/* let our brains leak out here too */
-extern int	yychar;		/*  the lookahead symbol		*/
-extern YYSTYPE	yylval;		/*  the semantic value of the		*/
-				/*  lookahead symbol			*/
-extern int end_of_file;
-
-struct obstack token_obstack;
-int first_token;
-  
-#ifdef SPEW_DEBUG
-int spew_debug = 0;
-static unsigned int yylex_ctr = 0;
-static int debug_yychar ();
-#endif
-
-static char follows_typename[END_OF_SAVED_INPUT+1];
-static char follows_identifier[END_OF_SAVED_INPUT+1];
-
-/* This is a hack!!! TEMPLATE_TYPE_SEEN_BEFORE_SCOPE consists of the name
- * of the last template_type parsed in cp-parse.y if it is followed by a
- * scope operator.  It will be reset inside the next invocation of yylex().
- * This is used for recognizing nested types inside templates.
- * - niklas@appli.se */
-tree template_type_seen_before_scope;
-
-/* Initialize token_obstack. Called once, from init_lex.  */
-void
-init_spew ()
-{
-  static char *chars_following_identifier = ".+-|/%^!?:";
-  short *ps;
-  static short toks_follow_ids[] =
-    { POINTSAT_LEFT_RIGHT, ASSIGN, RANGE, OROR, ANDAND, MIN_MAX, EQCOMPARE,
-      ARITHCOMPARE, LSHIFT, RSHIFT, UNARY, PLUSPLUS, MINUSMINUS, POINTSAT,
-      POINTSAT_STAR, DOT_STAR, CONSTANT, STRING, SIZEOF, ENUM, IF,
-      ELSE, WHILE, DO, FOR, SWITCH, CASE, DEFAULT, BREAK, CONTINUE,
-      RETURN, GOTO, ASM_KEYWORD, GCC_ASM_KEYWORD, TYPEOF, ALIGNOF, HEADOF,
-      CLASSOF, ATTRIBUTE, AGGR, VISSPEC, DELETE, RAISE, RERAISE, TRY, EXCEPT,
-      CATCH, THROW, ANSI_TRY, ANSI_THROW, EXTERN_LANG_STRING, ALL,
-      END_OF_SAVED_INPUT, -1 };
-  static short toks_follow_types[] =
-    { IDENTIFIER, TYPENAME, SCOPED_TYPENAME, SCSPEC, TYPESPEC, TYPE_QUAL,
-      ELLIPSIS, THIS, OPERATOR, DYNAMIC, TEMPLATE, SCOPE, START_DECLARATOR,
-      TYPENAME_COLON, PAREN_STAR_PAREN, TYPENAME_ELLIPSIS, PTYPENAME,
-      PRE_PARSED_FUNCTION_DECL, PRE_PARSED_CLASS_DECL, -1 };
-
-  gcc_obstack_init(&token_obstack);
-
-  /* Initialize the arrays saying what tokens are definitely
-     (or possibly) valid following typenames and identifiers.  */
-  while (*chars_following_identifier)
-    follows_identifier[*chars_following_identifier++] = 1;
-  for (ps = toks_follow_ids; *ps != -1; ps++)
-    follows_identifier[*ps] = 1;
-  for (ps = toks_follow_types; *ps != -1; ps++)
-    follows_typename[*ps] = 1;
-}
-
-#ifdef SPEW_DEBUG
-/* Use functions for debugging...  */
-
-/* Return the number of tokens available on the fifo. */
-static int
-num_tokens ()
-{
-  return (obstack_object_size(&token_obstack)/sizeof(struct token))
-    - first_token;
-}
-
-/* Fetch the token N down the line from the head of the fifo. */
-static struct token*
-nth_token (n)
-     int n;
-{
-  /* could just have this do slurp_ implicitly, but this way is easier
-   * to debug... */
-  my_friendly_assert (n < num_tokens(), 298);
-  return ((struct token*)obstack_base(&token_obstack))+n+first_token;
-}
-
-/* Add a token to the token fifo. */
-static void
-add_token (t)
-     struct token* t;
-{
-  obstack_grow(&token_obstack,t,sizeof (struct token));
-}
-
-/* Consume the next token out of the fifo.  */
-static void
-consume_token()
-{
-  if (num_tokens() == 1)
-    {
-      obstack_free(&token_obstack, obstack_base (&token_obstack));
-      first_token = 0;
-    }
-  else
-    first_token++;
-}
-
-#else
-/* ...otherwise use macros.  */
-
-#define num_tokens() \
-  ((obstack_object_size(&token_obstack)/sizeof(struct token)) - first_token)
-
-#define nth_token(N) \
-  (((struct token*)obstack_base(&token_obstack))+(N)+first_token)
-
-#define add_token(T) obstack_grow(&token_obstack, (T), sizeof (struct token))
-
-#define consume_token() \
-  (num_tokens() == 1							\
-   ? (obstack_free (&token_obstack, obstack_base (&token_obstack)),	\
-      (first_token = 0))						\
-   : first_token++)
-#endif
-
-/* Pull in enough tokens from real_yylex that the queue is N long.  */
-
-static void
-scan_tokens (n)
-     int n;
-{
-  int i;
-  struct token *tmp;
-
-  /* We cannot read past certain tokens, so make sure we don't.  */
-  i = num_tokens ();
-  if (i > n)
-    return;
-  while (i-- > 0)
-    {
-      tmp = nth_token (i);
-      /* Never read past these characters: they might separate
-	 the current input stream from one we save away later.  */
-      if (tmp->yychar == '{' || tmp->yychar == ':')
-	goto pad_tokens;
-    }
-
-  while (num_tokens() <= n)
-    {
-      obstack_blank(&token_obstack,sizeof (struct token));
-      tmp = ((struct token *)obstack_next_free (&token_obstack))-1;
-      tmp->yychar = real_yylex();
-      tmp->end_of_file = end_of_file;
-      tmp->yylval = yylval;
-      end_of_file = 0;
-      if (tmp->yychar == '{'
-	  || tmp->yychar == ':'
-	  || tmp->yychar == ';')
-	{
-	pad_tokens:
-	  while (num_tokens () <= n)
-	    {
-	      obstack_blank(&token_obstack,sizeof (struct token));
-	      tmp = ((struct token *)obstack_next_free (&token_obstack))-1;
-	      tmp->yychar = EMPTY;
-	      tmp->end_of_file = 0;
-	    }
-	}
-    }
-}
-
-/* Create room for N tokens at the front of the fifo.  This is used
-   to insert new tokens into the stream ahead of the current token.  */
-
-static void
-shift_tokens (n)
-     int n;
-{
-  if (first_token >= n)
-    first_token -= n;
-  else
-    {
-      int old_token_count = num_tokens ();
-      char *tmp;
-
-      obstack_blank (&token_obstack, (n-first_token) * sizeof (struct token));
-      if (old_token_count)
-	{
-	  tmp = (char *)alloca ((num_tokens () + (n-first_token))
-				* sizeof (struct token));
-	  /* This move does not rely on the system being able to handle
-	     overlapping moves.  */
-	  bcopy (nth_token (0), tmp, old_token_count * sizeof (struct token));
-	  bcopy (tmp, nth_token (n), old_token_count * sizeof (struct token));
-	}
-      first_token = 0;
-    }
-}
-
-static int
-probe_obstack (h, obj, nlevels)
-     struct obstack *h;
-     tree obj;
-     unsigned int nlevels;
-{
-  register struct _obstack_chunk*  lp;	/* below addr of any objects in this chunk */
-  register struct _obstack_chunk*  plp;	/* point to previous chunk if any */
-
-  lp = (h)->chunk;
-  /* We use >= rather than > since the object cannot be exactly at
-     the beginning of the chunk but might be an empty object exactly
-     at the end of an adjacent chunk. */
-  for (; nlevels != 0 && lp != 0 && ((tree)lp >= obj || (tree)lp->limit < obj);
-       nlevels -= 1)
-    {
-      plp = lp->prev;
-      lp = plp;      
-    }
-  return nlevels != 0 && lp != 0;
-}
-
-/* from cp-lex.c: */
-/* Value is 1 if we should try to make the next identifier look like a
-   typename (when it may be a local variable or a class variable).
-   Value is 0 if we treat this name in a default fashion.
-   Value is -1 if we must not see a type name.  */
-extern int looking_for_typename;
-
-extern struct obstack *current_obstack, *saveable_obstack;
-
-int
-yylex()
-{
-  struct token tmp_token;
-  tree trrr;
-
- retry:
-#ifdef SPEW_DEBUG
-  if (spew_debug)
-  {
-    yylex_ctr ++;
-    fprintf(stderr, "\t\t## %d ##",yylex_ctr);
-  }
-#endif
-  
-  /* This is a kludge for recognizing nested types in templates */
-  if (template_type_seen_before_scope)
-    {
-      shift_tokens (2);		/* Sync in hack_more_ids (yes, it's ugly) */
-      nth_token (1)->yychar = SCOPE;
-      yylval.ttype = hack_more_ids (0, template_type_seen_before_scope);
-      template_type_seen_before_scope = 0;
-      if (!yylval.ttype)
-	{
-	  /* Sync back again, leaving SCOPE on the token stream, because we
-	   * failed to substitute the original SCOPE token with a
-	   * SCOPED_TYPENAME.  See rule "template_type" in cp-parse.y */
-	  consume_token ();
-	}
-      else
-	{
-	  yychar = SCOPED_TYPENAME;
-#ifdef SPEW_DEBUG    
-	  if (spew_debug)
-	    debug_yychar(yychar);
-#endif
-	  return yychar;
-	}
-    }
-
-  /* if we've got tokens, send them */
-  if (num_tokens())
-    {
-      tmp_token= *nth_token(0);
-
-      /* TMP_TOKEN.YYLVAL.TTYPE may have been allocated on the wrong obstack.
-	 If we don't find it in CURRENT_OBSTACK's current or immediately
-	 previous chunk, assume it was and copy it to the current obstack.  */
-      if ((tmp_token.yychar == CONSTANT
-	   || tmp_token.yychar == STRING)
-	  && ! TREE_PERMANENT (tmp_token.yylval.ttype)
-	  && ! probe_obstack (current_obstack, tmp_token.yylval.ttype, 2)
-	  && ! probe_obstack (saveable_obstack, tmp_token.yylval.ttype, 2))
-	tmp_token.yylval.ttype = copy_node (tmp_token.yylval.ttype);
-    }
-  else
-    {
-      /* if not, grab the next one and think about it */
-      tmp_token.yychar = real_yylex ();
-      tmp_token.yylval = yylval;
-      tmp_token.end_of_file = end_of_file;
-      add_token(&tmp_token);
-    }
-
-  /* many tokens just need to be returned. At first glance, all we
-   * have to do is send them back up, but some of them are needed to
-   * figure out local context. */
-  switch(tmp_token.yychar)
-    {
-    case EMPTY:
-      /* This is a lexical no-op.  */
-      consume_token ();
-#ifdef SPEW_DEBUG    
-      if (spew_debug)
-	debug_yychar (tmp_token.yychar);
-#endif
-      goto retry;
-
-    case IDENTIFIER:
-      /* Note: this calls arbitrate_lookup.  */
-      trrr = lookup_name (tmp_token.yylval.ttype, -2);
-      if (trrr)
-	{
-	  tmp_token.yychar = identifier_type (trrr);
-	  switch (tmp_token.yychar)
-	    {
-	    case TYPENAME:
-	      lastiddecl = identifier_typedecl_value (tmp_token.yylval.ttype);
-	      if (lastiddecl == NULL_TREE)
-		lastiddecl = trrr;
-	      break;
-	    case IDENTIFIER:
-	      lastiddecl = trrr;
-	      break;
-	    case PTYPENAME:
-	      /* This is for cases like
-		    template<class A> X<A>::operator[] ...
-		 since "X" is (presumably) a PTYPENAME; we might want to
-		 avoid seeing the entire thing as a type name, but X<A>
-		 must be one.
-
-		 It might not work right if the thing after the ::
-		 can be a typename nested in X<A>, but I don't think the
-		 PT code would be up to dealing with that anyways.  --KR  */
-	      if (looking_for_typename == -1)
-		{
-		  scan_tokens (2);
-		  if (nth_token(1)->yychar == '<')
-		    looking_for_typename = 0;
-		}
-	      break;
-	    default:
-	      my_friendly_abort (101);
-	    }
-	}
-      else
-	lastiddecl = trrr;
-      /* and fall through to... */
-    case TYPENAME:
-    case PTYPENAME:
-      /* if (new_token) add_token (&tmp_token); */
-      *nth_token(0) = tmp_token;
-      tmp_token = frob_identifier ();
-      if (looking_for_typename < 0)
-	{
-	  tmp_token.yychar = IDENTIFIER;
-	  lastiddecl = 0;
-	  looking_for_typename = 0;
-	}
-      else if (lastiddecl && TREE_CODE (lastiddecl) == TYPE_DECL)
-	{
-	  scan_tokens (2);
-	  if (nth_token(0)->yychar == IDENTIFIER
-	      && nth_token (1)->yychar != SCOPE)
-	    looking_for_typename = -1;
-	  else
-	    looking_for_typename = 0;
-	  goto finish_typename_processing;
-	}
-      else
-	looking_for_typename = 0;
-      break;
-
-    case TYPESPEC:
-    case SCSPEC:
-      consume_token ();
-    finish_typename_processing:
-      /* Now see if we should insert a START_DECLARATOR token.
-         Here are the cases caught:
-
-	 typespec ( * ID ) (	// ptr to function
-	 typespec ( & ID ) (	// ref to function
-	 typespec ( * ID ) [	// array of pointers
-	 typespec ( & ID ) [	// array of references
-
-	 This is a terrible kludge.  */
-
-      scan_tokens (2);
-      if (nth_token (0)->yychar == '('
-	  && (nth_token (1)->yychar == '*'
-	      || nth_token (1)->yychar == '&'))
-	{
-	  scan_tokens (5);
-	  if (nth_token (3)->yychar == ')'
-	      && (nth_token (4)->yychar == '('
-		  || nth_token (4)->yychar == '['
-		  || nth_token (4)->yychar == LEFT_RIGHT)
-	      && (nth_token (2)->yychar == IDENTIFIER
-		  || nth_token (2)->yychar == TYPENAME))
-	    {
-	      shift_tokens (1);
-	      nth_token (0)->yychar = START_DECLARATOR;
-	    }
-	}
-      /* Extend to handle:
-
-	 typespec (ID::* qf)(   // ptr to member function
-	 typespec (ID::* qf)[   // array of ptr to member functions
-
-	 */
-      if (nth_token (0)->yychar == '('
-	  && (nth_token (1)->yychar == IDENTIFIER
-	      || nth_token (1)->yychar == TYPENAME))
-	{
-	  scan_tokens (7);
-	  if (nth_token (2)->yychar == SCOPE
-	      && nth_token (3)->yychar == '*'
-	      && (nth_token (4)->yychar == IDENTIFIER
-		  || nth_token (4)->yychar == TYPENAME)
-	      && nth_token (5)->yychar == ')'
-	      && (nth_token (6)->yychar == '('
-		  || nth_token (6)->yychar == '['
-		  || nth_token (6)->yychar == LEFT_RIGHT))
-	    {
-	      shift_tokens (1);
-	      nth_token (0)->yychar = START_DECLARATOR;
-	    }
-	}
-      break;
-
-#if 0
-    case '(':
-      /* Handle casts.  We are looking for one of:
-         `( TYPENAME' followed by `)', or
-	 `( TYPENAME *' followed by one of `[,*,&,)', or
-	 `( TYPENAME &' followed by one of `[,*,&,)', or
-	 `( TYPENAME [' followed by `]'.  We are punting
-	 generality on scanning casts to array types.  */
-      scan_tokens (4);
-      if (nth_token (1)->yychar == IDENTIFIER)
-	{
-	  tree type = identifier_typedecl_value (nth_token (1)->yylval.ttype);
-	  if (type)
-	    switch (nth_token (2)->yychar)
-	      {
-	      default:
-		break;
-	      }
-	}
-      break;
-
-    case SCOPE:
-      /* if (new_token) add_token (&tmp_token); */
-      *nth_token(0) = tmp_token;
-      tmp_token = hack_scope ();
-      break;
-#endif
-
-    case AGGR:
-      *nth_token(0) = tmp_token;
-      do_aggr ();
-      /* fall through to output... */
-    case ENUM:
-      /* Set this again, in case we are rescanning.  */
-      looking_for_typename = 1;
-      /* fall through... */
-    default:
-#ifdef SPEW_DEBUG    
-      if (spew_debug)
-	debug_yychar(tmp_token.yychar);
-#endif
-      consume_token();
-      yylval = tmp_token.yylval;
-      yychar = tmp_token.yychar;
-      end_of_file = tmp_token.end_of_file;
-      return tmp_token.yychar;
-    }
-
-  if (tmp_token.yychar == SCOPED_TYPENAME)
-    {
-#if 0
-      tree t2 = resolve_scope_to_name (NULL_TREE, tmp_token.yylval.ttype);
-      if (t2 != NULL_TREE)
-	{
-	  tmp_token.yylval.ttype = t2;
-	  tmp_token.yychar = TYPENAME;
-	}
-      else
-	{
-	  /* unwind? */
-	}
-    }
-  else
-    {
-      /* couldn't get here, as is... */
-#endif
-      tmp_token.yychar = TYPENAME;
-    }
-
-  yylval = tmp_token.yylval;
-  yychar = tmp_token.yychar;
-  end_of_file = tmp_token.end_of_file;
-#ifdef SPEW_DEBUG    
-  if (spew_debug)
-    debug_yychar(yychar);
-#endif
-/*  consume_token(); */ /* already eaten by frob_identifier?... */
-  return yychar;
-}
-
-/* token[0] == AGGR (struct/union/enum)
- * thus, token[1] is either a TYPENAME or a TYPENAME_DEFN
- * if token[2] == '{' or ':' then it's TYPENAME_DEFN
- */
-static int
-do_aggr ()
-{
-  int yc1, yc2;
-  
-  scan_tokens (2);
-  yc1 = nth_token (1)->yychar;
-  if (yc1 != TYPENAME && yc1 != IDENTIFIER && yc1 != PTYPENAME)
-    return 0;
-  yc2 = nth_token (2)->yychar;
-  if (yc2 == '{' || yc2 == ':')
-    {
-      switch (yc1)
-	{
-	case TYPENAME:
-	  nth_token (1)->yychar = TYPENAME_DEFN;
-	  break;
-	case PTYPENAME:
-	  nth_token (1)->yychar = PTYPENAME_DEFN;
-	  break;
-	case IDENTIFIER:
-	  nth_token (1)->yychar = IDENTIFIER_DEFN;
-	  break;
-	default:
-	  my_friendly_abort (102);
-	}
-    }
-  return 0;
-}  
-
-static struct token
-frob_identifier ()
-{
-  /* we could have a type, if it is followed by :: (if so, suck it all up); */
-  /* we could have a ptypename; */
-  /* we could have a normal identifier. */
-  tree t1;
-  struct token rt;
-  
-  scan_tokens(1);
-  rt = *nth_token(0);
-
-#if 0
-  if (nth_token(1)->yychar == '<')
-    {
-      t1 = hack_ptype();	/* suck up the whole thing */
-      if (t1)
-	{
-	  rt.yylval.ttype = t1;
-	  rt.yychar = TYPENAME;
-	  *nth_token(0) = rt;
-	}
-      /* else fall out bottom */
-    }	
-#endif
-
-  if (nth_token(1)->yychar == SCOPE)
-    {
-#if 0
-      t1 = hack_more_ids(0);
-      if (t1 && TREE_CODE(t1) == SCOPE_REF)
-#else
-      t1 = hack_more_ids(0, nth_token (0)->yylval.ttype);
-      if (t1)
-#endif
-	{
-	  rt.yylval.ttype = t1;
-	  rt.yychar = SCOPED_TYPENAME ;
-	  return rt;
-	}
-      else
-	{
-	  /* deal with types (enums?) in classes... */
-	  struct token *tok;
-	  tree ta, tb;
-	  scan_tokens(3);
-
-	  /* Have to check for a type conversion operator
-	     to a nested type.  */
-	  if (nth_token (2)->yychar == OPERATOR)
-	    tok = nth_token (3);
-	  else
-	    tok = nth_token(2);
-
-	  if (tok->yychar == IDENTIFIER || tok->yychar == TYPENAME)
-	    {
-	      ta = build_parse_node (SCOPE_REF,
-				     nth_token(0)->yylval.ttype,
-				     tok->yylval.ttype);
-	      tb = resolve_scope_to_name (NULL_TREE, ta);
-
-	      if (tb != NULL_TREE)
-		{
-		  if (nth_token (2)->yychar == OPERATOR)
-		    {
-		      /* Have to keep these tokens around
-			 so we can finish parsing the declaration.
-			 What do we do for
-
-			 int foo::operator bar::baz (); 
-
-			 where bar is a nested class in foo?  */
-		      nth_token (3)->yychar = TYPENAME;
-		      nth_token (3)->yylval.ttype = tb;
-		    }
-		  else
-		    {
-		      consume_token (); /* base type */
-		      consume_token (); /* SCOPE */
-		      consume_token (); /* member type */
-		      rt.yychar = TYPENAME;
-		      rt.yylval.ttype = tb;
-		      rt.end_of_file = tok->end_of_file;
-		      return rt;
-		    }
-		  
-		}
-	    }      
-	  /* else fall out bottom */
-	}
-    }
-	     
-  consume_token();
-  return rt;
-}
-
-/* When this function is called, nth_token(0) is the current
-   token we are scanning.  This means that the next token we'll
-   scan is nth_token (1).  Usually the next token we'll scan
-   is nth_token (0) (and the current token is in [yylval,yychar]).  */
-tree
-arbitrate_lookup (name, exp_decl, type_decl)
-     tree name, exp_decl, type_decl;
-{
-  int ch;
-
-  scan_tokens (3);
-  ch = nth_token (1)->yychar;
-
-  switch (ch)
-    {
-    case '(':
-    case LEFT_RIGHT:
-      /* If we guessed wrong here, `build_functional_cast' can fix it.  */
-      return type_decl;
-
-    case '=':
-      if (global_bindings_p ())
-	/* Probably a default parameter.  */
-	return type_decl;
-      /* Probably not an initialization.  */
-      return exp_decl;
-
-    case '[':
-      /* This needs special help because an expression inside the
-	 brackets means nothing.  */
-      {
-	int i;
-
-	for (i = 0; i < 42; i++)
-	  {
-	    int ith_yychar;
-
-	    scan_tokens (3+i);
-	    ith_yychar = nth_token (2+i)->yychar;
-
-	    /* If we hit an undefined identifier, assume
-	       the decl in arbitration is its type specifier.  */
-	    if (ith_yychar == IDENTIFIER
-		&& lookup_name (nth_token (2+i)->yylval.ttype, 0) == 0)
-	      return type_decl;
-	    else if (ith_yychar == ']')
-	      {
-		/* There are only a few things we expect after a ']'
-		   in a declarator.  */
-		i += 1;
-		scan_tokens (4+i);
-		ith_yychar = nth_token (2+i)->yychar;
-
-		/* These are inconclusive.  */
-		if (ith_yychar == LEFT_RIGHT
-		    || ith_yychar == '('
-		    || ith_yychar == '['
-		    || ith_yychar == ',')
-		  continue;
-		/* stmt or decl?  We'll probably never know.  */
-		else if (ith_yychar == ';')
-		  goto warn_ambiguous;
-
-		if (ith_yychar == '=')
-		  {
-		    if (nth_token (3+i)->yychar == '{')
-		      return type_decl;
-		    continue;
-		  }
-
-		/* Whatever it is, it looks like we're processing an expr.  */
-		return exp_decl;
-	      }
-	  }
-	goto warn_ambiguous;
-      }
-
-    case ',':
-    case ';':
-    case '&':
-    case '<':
-    case '*':
-    case ']':
-    case ')':
-    case '>':
-      /* see if the next token looks like it wants to be part
-	 of a declaration list or an expression list.  */
-      {
-	int i;
-
-	/* Some heuristics: if we are inside a function definition,
-	   prefer the local declaration.  */
-	if (! global_bindings_p ())
-	  {
-	    if (IDENTIFIER_LOCAL_VALUE (name) == exp_decl)
-	      return exp_decl;
-	    if (IDENTIFIER_LOCAL_VALUE (name) != type_decl
-		&& IDENTIFIER_CLASS_VALUE (name) == exp_decl)
-	      return exp_decl;
-	  }
-	/* If these symbols follow in a list, we know it's a list of
-	   expressions.  */
-	if (follows_identifier[nth_token (2)->yychar])
-	  return exp_decl;
-
-	/* If we see a id&, or id&) the we are probably in an argument list. */
-	if (ch=='&'
-	    && (nth_token (2)->yychar == ',' || nth_token (2)->yychar == ')'))
-	  return type_decl;
-
-	/* Look for the first identifier or other distinguishing token
-	   we find in the next several tokens.  */
-	for (i = 0; i < 42; i++)
-	  {
-	    int ith_yychar;
-
-	    scan_tokens (3+i);
-	    ith_yychar = nth_token (2+i)->yychar;
-
-	    if (ith_yychar == IDENTIFIER)
-	      {
-		tree as_type = lookup_name (nth_token (2+i)->yylval.ttype, 1);
-		if (as_type && TREE_CODE (as_type) != TYPE_DECL)
-		  return exp_decl;
-		/* An undeclared identifier or a typename means we're
-		   probably looking at a typename.  */
-		return type_decl;
-	      }
-	    else if (ith_yychar == EMPTY
-		     || follows_identifier[ith_yychar])
-	      return exp_decl;
-	    else if (follows_typename[ith_yychar])
-	      return type_decl;
-	    /* stmt or decl?  We'll probably never know.  */
-	    else if (ith_yychar == ';')
-	      goto warn_ambiguous;
-	  }
-	goto warn_ambiguous;
-      }
-
-    default:
-      if (follows_identifier[ch])
-	return exp_decl;
-      if (follows_typename[ch])
-	return type_decl;
-
-      /* Fall through...  */
-    warn_ambiguous:
-      warning ("name `%s' could be type or expression; compiler assuming type",
-	       IDENTIFIER_POINTER (DECL_NAME (type_decl)));
-      return type_decl;
-    }
-}
-
-/* now returns decl_node */
-
-#if 0
-static tree
-hack_ptype()
-{
-  /* when we get here, we know that [0] is a ptype and [1] is '<'.
-   * now we loop over simple parameters. */
-  struct token this_param;
-  int n = 2;
-  tree tplist = 0;
-  tree tc;
-  scan_tokens(n+1);
-  
-  while((this_param = *nth_token(n)).yychar != '>')
-    {
-      /* if it is a type, add it to the list */
-      tree thistype;
-    
-      switch(this_param.yychar)
-	{
-	case IDENTIFIER:
-	case TYPENAME:
-	case TYPESPEC:
-	  break;
-	default:
-	  return 0;
-	}
-
-      thistype = this_param.yylval.ttype;
-      thistype = lookup_name(thistype, 1);
-      thistype = TREE_TYPE (thistype);
-        
-      if (tplist)
-	tplist = chainon (tplist, build_tree_list (NULL_TREE, thistype));
-      else
-	tplist = build_tree_list(NULL_TREE, thistype);
-    
-    
-      /* then suck up the comma */
-      n++;
-      scan_tokens(n+1);
-      this_param = *nth_token(n);
-      if (this_param.yychar == ',')
-	{
-	  n++;
-	  scan_tokens(n+1);
-	  continue;
-	}
-      if (this_param.yychar == '>')
-	break;
-      return 0;
-    }
-
-  /* once we're done, lookup_template_class -> identifier */
-  tc = lookup_template_class (nth_token(0)->yylval.ttype,tplist);
-  /* then lookup_name on that to get a type, if there is one */
-  tc = lookup_name (tc, 1);
-  if (tc)
-    {
-      int i;
-      /* don't actually eat the trailing '>'... we can replace it! */
-      for (i=0; i<n; i++)
-	consume_token();
-      /*    IDENTIFIER_TYPE_VALUE (DECL_NAME (tc)) = */
-      return DECL_NAME (tc);
-    }
-  return NULL_TREE;
-}
-#endif
-
-#if 0
-static tree
-hack_more_ids (n)
-     int n;
-{
-  /*
-   * The recursion should probably do consume_tokens(), since once we've started
-   * down an IDENTIFIER SCOPE ... chain, we don't need to back-track - we just
-   * get as much as we can, make SCOPE_REF's out of it, and return it.
-   */
-  struct token this_iter, this2_iter;
-  int tmp_y;
-  
-  scan_tokens(n+1);
-  this_iter = *nth_token(n);
-
-  tmp_y = nth_token(n)->yychar;
-  if (tmp_y == IDENTIFIER || tmp_y == TYPENAME)
-    {
-      scan_tokens(n+2+2);
-      if (nth_token(n+1)->yychar == SCOPE)
-	{
-	  if (nth_token(n+1+2)->yychar == SCOPE)
-	    {
-	      tree hmi;
-	
-	      consume_token();	/* last IDENTIFIER (this_iter) */
-	      consume_token();	/* last SCOPE */
-	      this2_iter = *nth_token(n);
-	
-	      hmi = hack_more_ids (n);
-	
-	      if (hmi)
-		return build_parse_node (SCOPE_REF, this_iter.yylval.ttype, hmi);
-	      consume_token(); /* last IDENTIFIER (this2_iter) */
-	      return build_parse_node (SCOPE_REF, this_iter.yylval.ttype,
-				       this2_iter.yylval.ttype);
-	    }
-	  else
-	    {
-	      /* consume_token();	*/	/* last IDENTIFIER */
-	      /* leave whatever else we got */
-	      /* return this_iter.yylval.ttype; */
-	      return NULL_TREE;
-	    }
-	}
-    }
-  return NULL_TREE;		/* @@ may need to backtrack */
-}
-#else
-/* niklas@appli.se says:  I didn't understand how the code above was intended
- * to work, so I rewrote it (also changed the interface a bit).  This code
- * dives down an IDENTIFIER/TYPENAME SCOPE ... chain as long as the parsed
- * type prefix constitutes recognizable (by resolve_scope_to_name) types.
- * Interface changed like this:
- * 1. Takes an extra argument containing the name of the the type recognized
- *    so far.
- * 2. Now returns the name of the type instead of a SCOPE_REF. */
-static tree
-hack_more_ids(n, outer)
-  int n;
-  tree outer;
-{
-  int ch;
-  tree type, val;
-
-  scan_tokens (n + 2);
-  if (nth_token (n + 1)->yychar != SCOPE
-      || ((ch = nth_token (n + 2)->yychar) != IDENTIFIER && ch != TYPENAME))
-    return NULL_TREE;
-  val = build_parse_node (SCOPE_REF, outer, nth_token (n + 2)->yylval.ttype);
-  type = resolve_scope_to_name (NULL_TREE, val);
-  if (type == NULL_TREE)
-    return NULL_TREE;
-  consume_token ();
-  consume_token ();
-  val = hack_more_ids (n, type);
-  if (! val)
-    consume_token ();
-  return val ? val : type;
-}
-#endif
-
-#if 0
-static struct token
-hack_scope ()
-{
-  /* we've got a :: - what follows is either a global var or a type. */
-  /* hmm, template names can be in the global scope too... */
-  tree t1;
-  struct token rt;
-  
-  scan_tokens(1);
-  if (nth_token(1)->yychar == IDENTIFIER)
-    {
-      /* @@ this is probably not right, but doesn't get hit yet */
-      t1 = build_parse_node (SCOPE_REF,
-			     NULL_TREE, /* to get "global" scope */
-			     hack_more_ids(0)); /* do some prefetching */
-      rt.yylval.ttype = t1;
-      rt.yychar =		/*SCOPED_*/TYPENAME;
-      return rt;
-    }
-  else
-    {
-      rt = *nth_token(0);
-      consume_token();
-      return rt;
-    }
-}
-#endif
-  
-/*
- * Generations:
- * 	
- * PINST: PTYPE { saved_arg_count = arg_count($1) }
- *        '<' { arg_c = 0; } PARGS '>'
- *        ;
- * PARG: TYPE
- *       | VALUE
- *       ;
- * (of course the arg counting doesn't work for recursion... Do it right.)
- * PARGS: PARG { assert(arg_c == saved_arg_count); }
- *        | PARG ',' PARGS	{ arg_c++; }
- *        ;
- * ATYPE: PINST
- *        | TYPEID
- *        ;
- * TYPE: ATYPE
- *       | ATYPE { basetype = $1; } '::' TYPEKIDS
- *       ;
- * TYPEKIDS: TYPE { assert ($1 is a member of basetype); }
- * 	  | TYPEKIDS { basetype += $1} TYPE { assert( $3 is in basetype ); }
- * 	  ;
- *
- *
- * state0: ; ATYPE
- * 	TYPE '<': ac = args($0), base = CALL state1, state3	
- * 	TYPE '::': base=$0, state3
- * 	else return TYPE
- * state1: ; begin PARGS
- * 	if(ac < list length) punt
- * 	PARG ",": add to list, state1
- * 	PARG ">": add to list, return
- * 	else unravel
- * state3: ; begin TYPEKIDS
- * 	TYPE: 
- */
-  
-  
-#ifdef SPEW_DEBUG    
-/* debug_yychar takes a yychar (token number) value and prints its name. */
-static int
-debug_yychar (yy)
-     int yy;
-{
-  /* In cp-parse.y: */
-  extern char *debug_yytranslate ();
-  
-  int i;
-  
-  if(yy<256) {
-    fprintf (stderr, "<%d: %c >\n", yy, yy);
-    return 0;
-  }
-  fprintf (stderr, "<%d:%s>\n", yy, debug_yytranslate (yy));
-  return 1;
-}
-
-#endif
diff --git a/gnu/gcc2/cc1plus/cp-tree.c b/gnu/gcc2/cc1plus/cp-tree.c
deleted file mode 100644
index 8728d645997a..000000000000
--- a/gnu/gcc2/cc1plus/cp-tree.c
+++ /dev/null
@@ -1,1706 +0,0 @@
-/* Language-dependent node constructors for parse phase of GNU compiler.
-   Copyright (C) 1987, 1988, 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-#include "config.h"
-#include <stdio.h>
-#include "obstack.h"
-#include "tree.h"
-#include "cp-tree.h"
-#include "flags.h"
-
-#define CEIL(x,y) (((x) + (y) - 1) / (y))
-
-/* Return nonzero if REF is an lvalue valid for this language.
-   Lvalues can be assigned, unless they have TREE_READONLY.
-   Lvalues can have their address taken, unless they have DECL_REGISTER.  */
-
-int
-lvalue_p (ref)
-     tree ref;
-{
-  register enum tree_code code = TREE_CODE (ref);
-
-  if (language_lvalue_valid (ref))
-    switch (code)
-      {
-	/* preincrements and predecrements are valid lvals, provided
-	   what they refer to are valid lvals. */
-      case PREINCREMENT_EXPR:
-      case PREDECREMENT_EXPR:
-      case COMPONENT_REF:
-	return lvalue_p (TREE_OPERAND (ref, 0));
-
-      case STRING_CST:
-	return 1;
-
-      case VAR_DECL:
-	if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
-	    && DECL_LANG_SPECIFIC (ref)
-	    && DECL_IN_AGGR_P (ref))
-	  return 0;
-      case INDIRECT_REF:
-      case ARRAY_REF:
-      case PARM_DECL:
-      case RESULT_DECL:
-      case ERROR_MARK:
-	if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
-	    && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
-	  return 1;
-	break;
-
-      case TARGET_EXPR:
-      case WITH_CLEANUP_EXPR:
-	return 1;
-
-      case CALL_EXPR:
-	if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE
-	    /* unary_complex_lvalue knows how to deal with this case.  */
-	    || TREE_ADDRESSABLE (TREE_TYPE (ref)))
-	  return 1;
-	break;
-
-	/* A currently unresolved scope ref.  */
-      case SCOPE_REF:
-	my_friendly_abort (103);
-      case OFFSET_REF:
-	if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
-	  return 1;
-	if (TREE_CODE (TREE_OPERAND (ref, 1)) == VAR_DECL)
-	  if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
-	      && DECL_LANG_SPECIFIC (ref)
-	      && DECL_IN_AGGR_P (ref))
-	    return 0;
-	  else
-	    return 1;
-	break;
-
-      case ADDR_EXPR:
-	/* ANSI C++ June 5 1992 WP 5.4.14.  The result of a cast to a
-	   reference is an lvalue.  */
-	if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
-	  return 1;
-	break;
-      }
-  return 0;
-}
-
-/* Return nonzero if REF is an lvalue valid for this language;
-   otherwise, print an error message and return zero.  */
-
-int
-lvalue_or_else (ref, string)
-     tree ref;
-     char *string;
-{
-  int win = lvalue_p (ref);
-  if (! win)
-    error ("invalid lvalue in %s", string);
-  return win;
-}
-
-/* INIT is a CALL_EXPR which needs info about its target.
-   TYPE is the type that this initialization should appear to have.
-
-   Build an encapsulation of the initialization to perform
-   and return it so that it can be processed by language-independent
-   and language-specific expression expanders.
-
-   If WITH_CLEANUP_P is nonzero, we build a cleanup for this expression.
-   Otherwise, cleanups are not built here.  For example, when building
-   an initialization for a stack slot, since the called function handles
-   the cleanup, we would not want to do it here.  */
-tree
-build_cplus_new (type, init, with_cleanup_p)
-     tree type;
-     tree init;
-     int with_cleanup_p;
-{
-  tree slot = build (VAR_DECL, type);
-  tree rval = build (NEW_EXPR, type,
-		     TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
-  TREE_SIDE_EFFECTS (rval) = 1;
-  TREE_ADDRESSABLE (rval) = 1;
-  rval = build (TARGET_EXPR, type, slot, rval, 0);
-  TREE_SIDE_EFFECTS (rval) = 1;
-  TREE_ADDRESSABLE (rval) = 1;
-
-  if (with_cleanup_p && TYPE_NEEDS_DESTRUCTOR (type))
-    {
-      rval = build (WITH_CLEANUP_EXPR, type, rval, 0,
-		    build_delete (TYPE_POINTER_TO (type),
-				  build_unary_op (ADDR_EXPR, slot, 0),
-				  integer_two_node,
-				  LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0, 0));
-      TREE_SIDE_EFFECTS (rval) = 1;
-    }
-  return rval;
-}
-
-/* Recursively search EXP for CALL_EXPRs that need cleanups and replace
-   these CALL_EXPRs with tree nodes that will perform the cleanups.  */
-
-tree
-break_out_cleanups (exp)
-     tree exp;
-{
-  tree tmp = exp;
-
-  if (TREE_CODE (tmp) == CALL_EXPR
-      && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
-    return build_cplus_new (TREE_TYPE (tmp), tmp, 1);
-
-  while (TREE_CODE (tmp) == NOP_EXPR
-	 || TREE_CODE (tmp) == CONVERT_EXPR
-	 || TREE_CODE (tmp) == NON_LVALUE_EXPR)
-    {
-      if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
-	  && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
-	{
-	  TREE_OPERAND (tmp, 0)
-	    = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
-			       TREE_OPERAND (tmp, 0), 1);
-	  break;
-	}
-      else
-	tmp = TREE_OPERAND (tmp, 0);
-    }
-  return exp;
-}
-
-/* Recursively perform a preorder search EXP for CALL_EXPRs, making
-   copies where they are found.  Returns a deep copy all nodes transitively
-   containing CALL_EXPRs.  */
-
-tree
-break_out_calls (exp)
-     tree exp;
-{
-  register tree t1, t2;
-  register enum tree_code code;
-  register int changed = 0;
-  register int i;
-
-  if (exp == NULL_TREE)
-    return exp;
-
-  code = TREE_CODE (exp);
-
-  if (code == CALL_EXPR)
-    return copy_node (exp);
-
-  /* Don't try and defeat a save_expr, as it should only be done once. */
-    if (code == SAVE_EXPR)
-       return exp;
-
-  switch (TREE_CODE_CLASS (code))
-    {
-    default:
-      abort ();
-
-    case 'c':  /* a constant */
-    case 't':  /* a type node */
-    case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
-      return exp;
-
-    case 'd':  /* A decl node */
-      t1 = break_out_calls (DECL_INITIAL (exp));
-      if (t1 != DECL_INITIAL (exp))
-	{
-	  exp = copy_node (exp);
-	  DECL_INITIAL (exp) = t1;
-	}
-      return exp;
-
-    case 'b':  /* A block node */
-      {
-	/* Don't know how to handle these correctly yet.   Must do a
-	   break_out_calls on all DECL_INITIAL values for local variables,
-	   and also break_out_calls on all sub-blocks and sub-statements.  */
-	abort ();
-      }
-      return exp;
-
-    case 'e':  /* an expression */
-    case 'r':  /* a reference */
-    case 's':  /* an expression with side effects */
-      for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
-	{
-	  t1 = break_out_calls (TREE_OPERAND (exp, i));
-	  if (t1 != TREE_OPERAND (exp, i))
-	    {
-	      if (changed++ == 0)
-		exp = copy_node (exp);
-	      TREE_OPERAND (exp, i) = t1;
-	    }
-	}
-      return exp;
-
-    case '<':  /* a comparison expression */
-    case '2':  /* a binary arithmetic expression */
-      t2 = break_out_calls (TREE_OPERAND (exp, 1));
-      if (t2 != TREE_OPERAND (exp, 1))
-	changed = 1;
-    case '1':  /* a unary arithmetic expression */
-      t1 = break_out_calls (TREE_OPERAND (exp, 0));
-      if (t1 != TREE_OPERAND (exp, 0))
-	changed = 1;
-      if (changed)
-	{
-	  if (tree_code_length[(int) code] == 1)
-	    return build1 (code, TREE_TYPE (exp), t1);
-	  else
-	    return build (code, TREE_TYPE (exp), t1, t2);
-	}
-      return exp;
-    }
-
-}
-
-extern struct obstack *current_obstack;
-extern struct obstack permanent_obstack, class_obstack;
-extern struct obstack *saveable_obstack;
-
-/* Here is how primitive or already-canonicalized types' hash
-   codes are made.  MUST BE CONSISTENT WITH tree.c !!! */
-#define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
-
-/* Construct, lay out and return the type of methods belonging to class
-   BASETYPE and whose arguments are described by ARGTYPES and whose values
-   are described by RETTYPE.  If each type exists already, reuse it.  */
-tree
-build_cplus_method_type (basetype, rettype, argtypes)
-     tree basetype, rettype, argtypes;
-{
-  register tree t;
-  tree ptype = build_pointer_type (basetype);
-  int hashcode;
-
-  /* Make a node of the sort we want.  */
-  t = make_node (METHOD_TYPE);
-
-  TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
-  TREE_TYPE (t) = rettype;
-#if 0
-  /* it is wrong to flag the object the pointer points to as readonly
-     when flag_this_is_variable is 0. */
-  ptype = build_type_variant (ptype, flag_this_is_variable <= 0, 0);
-#else
-  ptype = build_type_variant (ptype, 0, 0);
-#endif
-  /* The actual arglist for this function includes a "hidden" argument
-     which is "this".  Put it into the list of argument types.  */
-
-  TYPE_ARG_TYPES (t) = tree_cons (NULL, ptype, argtypes);
-
-  /* If we already have such a type, use the old one and free this one.
-     Note that it also frees up the above cons cell if found.  */
-  hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
-  t = type_hash_canon (hashcode, t);
-
-  if (TYPE_SIZE (t) == 0)
-    layout_type (t);
-
-  return t;
-}
-
-tree
-build_cplus_staticfn_type (basetype, rettype, argtypes)
-     tree basetype, rettype, argtypes;
-{
-  register tree t;
-  int hashcode;
-
-  /* Make a node of the sort we want.  */
-  t = make_node (FUNCTION_TYPE);
-
-  TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
-  TREE_TYPE (t) = rettype;
-
-  /* The actual arglist for this function includes a "hidden" argument
-     which is "this".  Put it into the list of argument types.  */
-
-  TYPE_ARG_TYPES (t) = argtypes;
-
-  /* If we already have such a type, use the old one and free this one.
-     Note that it also frees up the above cons cell if found.  */
-  hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
-  t = type_hash_canon (hashcode, t);
-
-  if (TYPE_SIZE (t) == 0)
-    layout_type (t);
-
-  return t;
-}
-
-tree
-build_cplus_array_type (elt_type, index_type)
-     tree elt_type;
-     tree index_type;
-{
-  register struct obstack *ambient_obstack = current_obstack;
-  register struct obstack *ambient_saveable_obstack = saveable_obstack;
-  tree t;
-
-  /* We need a new one.  If both ELT_TYPE and INDEX_TYPE are permanent,
-     make this permanent too.  */
-  if (TREE_PERMANENT (elt_type)
-      && (index_type == 0 || TREE_PERMANENT (index_type)))
-    {
-      current_obstack = &permanent_obstack;
-      saveable_obstack = &permanent_obstack;
-    }
-
-  t = build_array_type (elt_type, index_type);
-
-  /* Push these needs up so that initialization takes place
-     more easily.  */
-  TYPE_NEEDS_CONSTRUCTING (t) = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
-  TYPE_NEEDS_DESTRUCTOR (t) = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
-  current_obstack = ambient_obstack;
-  saveable_obstack = ambient_saveable_obstack;
-  return t;
-}
-
-/* Add OFFSET to all base types of T.
-
-   OFFSET, which is a type offset, is number of bytes.
-
-   Note that we don't have to worry about having two paths to the
-   same base type, since this type owns its association list.  */
-void
-propagate_binfo_offsets (binfo, offset)
-     tree binfo;
-     tree offset;
-{
-  tree binfos = BINFO_BASETYPES (binfo);
-  int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  for (i = 0; i < n_baselinks; /* note increment is done in the loop.  */)
-    {
-      tree base_binfo = TREE_VEC_ELT (binfos, i);
-
-      if (TREE_VIA_VIRTUAL (base_binfo))
-	i += 1;
-      else
-	{
-	  int j;
-	  tree base_binfos = BINFO_BASETYPES (base_binfo);
-	  tree delta;
-
-	  for (j = i+1; j < n_baselinks; j++)
-	    if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
-	      {
-		/* The next basetype offset must take into account the space
-		   between the classes, not just the size of each class.  */
-		delta = size_binop (MINUS_EXPR,
-				    BINFO_OFFSET (TREE_VEC_ELT (binfos, j)),
-				    BINFO_OFFSET (base_binfo));
-		break;
-	      }
-
-#if 0
-	  if (BINFO_OFFSET_ZEROP (base_binfo))
-	    BINFO_OFFSET (base_binfo) = offset;
-	  else
-	    BINFO_OFFSET (base_binfo)
-	      = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
-#else
-	  BINFO_OFFSET (base_binfo) = offset;
-#endif
-	  if (base_binfos)
-	    {
-	      int k;
-	      tree chain = NULL_TREE;
-
-	      /* Now unshare the structure beneath BASE_BINFO.  */
-	      for (k = TREE_VEC_LENGTH (base_binfos)-1;
-		   k >= 0; k--)
-		{
-		  tree base_base_binfo = TREE_VEC_ELT (base_binfos, k);
-		  if (! TREE_VIA_VIRTUAL (base_base_binfo))
-		    TREE_VEC_ELT (base_binfos, k)
-		      = make_binfo (BINFO_OFFSET (base_base_binfo),
-				    BINFO_TYPE (base_base_binfo),
-				    BINFO_VTABLE (base_base_binfo),
-				    BINFO_VIRTUALS (base_base_binfo),
-				    chain);
-		  chain = TREE_VEC_ELT (base_binfos, k);
-		  TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
-		  TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
-		}
-	      /* Now propagate the offset to the base types.  */
-	      propagate_binfo_offsets (base_binfo, offset);
-	    }
-
-	  /* Go to our next class that counts for offset propagation.  */
-	  i = j;
-	  if (i < n_baselinks)
-	    offset = size_binop (PLUS_EXPR, offset, delta);
-	}
-    }
-}
-
-/* Compute the actual offsets that our virtual base classes
-   will have *for this type*.  This must be performed after
-   the fields are laid out, since virtual baseclasses must
-   lay down at the end of the record.
-
-   Returns the maximum number of virtual functions any of the virtual
-   baseclasses provide.  */
-int
-layout_vbasetypes (rec, max)
-     tree rec;
-     int max;
-{
-  /* Get all the virtual base types that this type uses.
-     The TREE_VALUE slot holds the virtual baseclass type.  */
-  tree vbase_types = get_vbase_types (rec);
-
-#ifdef STRUCTURE_SIZE_BOUNDARY
-  unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
-#else
-  unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
-#endif
-
-  /* Record size so far is CONST_SIZE + VAR_SIZE bits,
-     where CONST_SIZE is an integer
-     and VAR_SIZE is a tree expression.
-     If VAR_SIZE is null, the size is just CONST_SIZE.
-     Naturally we try to avoid using VAR_SIZE.  */
-  register unsigned const_size = 0;
-  register tree var_size = 0;
-  int nonvirtual_const_size;
-  tree nonvirtual_var_size;
-
-  CLASSTYPE_VBASECLASSES (rec) = vbase_types;
-
-  if (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST)
-    const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
-  else
-    var_size = TYPE_SIZE (rec);
-
-  nonvirtual_const_size = const_size;
-  nonvirtual_var_size = var_size;
-
-  while (vbase_types)
-    {
-      tree basetype = BINFO_TYPE (vbase_types);
-      tree offset;
-
-      if (const_size == 0)
-	offset = integer_zero_node;
-      else
-	offset = size_int ((const_size + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
-
-      if (CLASSTYPE_VSIZE (basetype) > max)
-	max = CLASSTYPE_VSIZE (basetype);
-      BINFO_OFFSET (vbase_types) = offset;
-
-      if (TREE_CODE (TYPE_SIZE (basetype)) == INTEGER_CST)
-	const_size += MAX (record_align,
-			   TREE_INT_CST_LOW (TYPE_SIZE (basetype))
-			   - TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype)));
-      else if (var_size == 0)
-	var_size = TYPE_SIZE (basetype);
-      else
-	var_size = size_binop (PLUS_EXPR, var_size, TYPE_SIZE (basetype));
-
-      vbase_types = TREE_CHAIN (vbase_types);
-    }
-
-  if (const_size != nonvirtual_const_size)
-    {
-      CLASSTYPE_VBASE_SIZE (rec)
-	= size_int (const_size - nonvirtual_const_size);
-      TYPE_SIZE (rec) = size_int (const_size);
-    }
-
-  /* Now propagate offset information throughout the lattice
-     under the vbase type.  */
-  for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
-       vbase_types = TREE_CHAIN (vbase_types))
-    {
-      tree base_binfos = BINFO_BASETYPES (vbase_types);
-
-      if (base_binfos)
-	{
-	  tree chain = NULL_TREE;
-	  int j;
-	  /* Now unshare the structure beneath BASE_BINFO.  */
-
-	  for (j = TREE_VEC_LENGTH (base_binfos)-1;
-	       j >= 0; j--)
-	    {
-	      tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
-	      if (! TREE_VIA_VIRTUAL (base_base_binfo))
-		TREE_VEC_ELT (base_binfos, j)
-		  = make_binfo (BINFO_OFFSET (base_base_binfo),
-				BINFO_TYPE (base_base_binfo),
-				BINFO_VTABLE (base_base_binfo),
-				BINFO_VIRTUALS (base_base_binfo),
-				chain);
-	      chain = TREE_VEC_ELT (base_binfos, j);
-	      TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
-	      TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
-	    }
-
-	  propagate_binfo_offsets (vbase_types, BINFO_OFFSET (vbase_types));
-	}
-    }
-
-  return max;
-}
-
-/* Lay out the base types of a record type, REC.
-   Tentatively set the size and alignment of REC
-   according to the base types alone.
-
-   Offsets for immediate nonvirtual baseclasses are also computed here.
-
-   Returns list of virtual base classes in a FIELD_DECL chain.  */
-tree
-layout_basetypes (rec, binfos)
-     tree rec, binfos;
-{
-  /* Chain to hold all the new FIELD_DECLs which point at virtual
-     base classes.  */
-  tree vbase_decls = NULL_TREE;
-
-#ifdef STRUCTURE_SIZE_BOUNDARY
-  unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
-#else
-  unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
-#endif
-
-  /* Record size so far is CONST_SIZE + VAR_SIZE bits,
-     where CONST_SIZE is an integer
-     and VAR_SIZE is a tree expression.
-     If VAR_SIZE is null, the size is just CONST_SIZE.
-     Naturally we try to avoid using VAR_SIZE.  */
-  register unsigned const_size = 0;
-  register tree var_size = 0;
-  int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-
-  /* Handle basetypes almost like fields, but record their
-     offsets differently.  */
-
-  for (i = 0; i < n_baseclasses; i++)
-    {
-      int inc, desired_align, int_vbase_size;
-      register tree base_binfo = TREE_VEC_ELT (binfos, i);
-      register tree basetype = BINFO_TYPE (base_binfo);
-      tree decl, offset;
-
-      if (TYPE_SIZE (basetype) == 0)
-	{
-#if 0
-	  /* This error is now reported in xref_tag, thus giving better
-	     location information.  */
-	  error_with_aggr_type (base_binfo,
-				"base class `%s' has incomplete type");
-
-	  TREE_VIA_PUBLIC (base_binfo) = 1;
-	  TREE_VIA_PROTECTED (base_binfo) = 0;
-	  TREE_VIA_VIRTUAL (base_binfo) = 0;
-
-	  /* Should handle this better so that
-
-	     class A;
-	     class B: private A { virtual void F(); };
-
-	     does not dump core when compiled. */
-	  my_friendly_abort (121);
-#endif
-	  continue;
-	}
-
-      /* All basetypes are recorded in the association list of the
-	 derived type.  */
-
-      if (TREE_VIA_VIRTUAL (base_binfo))
-	{
-	  int j;
-	  char *name = (char *)alloca (TYPE_NAME_LENGTH (basetype)
-				       + sizeof (VBASE_NAME) + 1);
-
-	  /* The offset for a virtual base class is only used in computing
-	     virtual function tables and for initializing virtual base
-	     pointers.  It is built once `get_vbase_types' is called.  */
-
-	  /* If this basetype can come from another vbase pointer
-	     without an additional indirection, we will share
-	     that pointer.  If an indirection is involved, we
-	     make our own pointer.  */
-	  for (j = 0; j < n_baseclasses; j++)
-	    {
-	      tree other_base_binfo = TREE_VEC_ELT (binfos, j);
-	      if (! TREE_VIA_VIRTUAL (other_base_binfo)
-		  && binfo_member (basetype,
-				   CLASSTYPE_VBASECLASSES (BINFO_TYPE (other_base_binfo))))
-		goto got_it;
-	    }
-	  sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (basetype));
-	  decl = build_lang_decl (FIELD_DECL, get_identifier (name),
-				  build_pointer_type (basetype));
-	  /* If you change any of the below, take a look at all the
-	     other VFIELD_BASEs and VTABLE_BASEs in the code, and change
-	     them too. */
-	  DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
-	  DECL_VIRTUAL_P (decl) = 1;
-	  DECL_FIELD_CONTEXT (decl) = rec;
-	  DECL_CLASS_CONTEXT (decl) = rec;
-	  DECL_FCONTEXT (decl) = basetype;
-	  DECL_FIELD_SIZE (decl) = 0;
-	  DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node);
-	  TREE_CHAIN (decl) = vbase_decls;
-	  BINFO_VPTR_FIELD (base_binfo) = decl;
-	  vbase_decls = decl;
-
-	  if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (basetype)
-	      && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0)) == NULL_TREE)
-	    {
-	      warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0),
-				 "destructor `%s' non-virtual");
-	      warning ("in inheritance relationship `%s: virtual %s'",
-		       TYPE_NAME_STRING (rec),
-		       TYPE_NAME_STRING (basetype));
-	    }
-	got_it:
-	  /* The space this decl occupies has already been accounted for.  */
-	  continue;
-	}
-
-      if (const_size == 0)
-	offset = integer_zero_node;
-      else
-	{
-	  /* Give each base type the alignment it wants.  */
-	  const_size = CEIL (const_size, TYPE_ALIGN (basetype))
-	    * TYPE_ALIGN (basetype);
-	  offset = size_int ((const_size + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
-
-	  if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (basetype)
-	      && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0)) == NULL_TREE)
-	    {
-	      warning_with_decl (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0),
-				 "destructor `%s' non-virtual");
-	      warning ("in inheritance relationship `%s:%s %s'",
-		       TYPE_NAME_STRING (rec),
-		       TREE_VIA_VIRTUAL (base_binfo) ? " virtual" : "",
-		       TYPE_NAME_STRING (basetype));
-	    }
-	}
-      BINFO_OFFSET (base_binfo) = offset;
-      if (CLASSTYPE_VSIZE (basetype))
-	{
-	  BINFO_VTABLE (base_binfo) = TYPE_BINFO_VTABLE (basetype);
-	  BINFO_VIRTUALS (base_binfo) = TYPE_BINFO_VIRTUALS (basetype);
-	}
-      TREE_CHAIN (base_binfo) = TYPE_BINFO (rec);
-      TYPE_BINFO (rec) = base_binfo;
-
-      /* Add only the amount of storage not present in
-	 the virtual baseclasses.  */
-
-      int_vbase_size = TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype));
-      if (TREE_INT_CST_LOW (TYPE_SIZE (basetype)) > int_vbase_size)
-	{
-	  inc = MAX (record_align,
-		     (TREE_INT_CST_LOW (TYPE_SIZE (basetype))
-		      - int_vbase_size));
-
-	  /* Record must have at least as much alignment as any field.  */
-	  desired_align = TYPE_ALIGN (basetype);
-	  record_align = MAX (record_align, desired_align);
-
-	  const_size += inc;
-	}
-    }
-
-  if (const_size)
-    CLASSTYPE_SIZE (rec) = size_int (const_size);
-  else
-    CLASSTYPE_SIZE (rec) = integer_zero_node;
-  CLASSTYPE_ALIGN (rec) = record_align;
-
-  return vbase_decls;
-}
-
-/* Hashing of lists so that we don't make duplicates.
-   The entry point is `list_hash_canon'.  */
-
-/* Each hash table slot is a bucket containing a chain
-   of these structures.  */
-
-struct list_hash
-{
-  struct list_hash *next;	/* Next structure in the bucket.  */
-  int hashcode;			/* Hash code of this list.  */
-  tree list;			/* The list recorded here.  */
-};
-
-/* Now here is the hash table.  When recording a list, it is added
-   to the slot whose index is the hash code mod the table size.
-   Note that the hash table is used for several kinds of lists.
-   While all these live in the same table, they are completely independent,
-   and the hash code is computed differently for each of these.  */
-
-#define TYPE_HASH_SIZE 59
-struct list_hash *list_hash_table[TYPE_HASH_SIZE];
-
-/* Compute a hash code for a list (chain of TREE_LIST nodes
-   with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
-   TREE_COMMON slots), by adding the hash codes of the individual entries.  */
-
-int
-list_hash (list)
-     tree list;
-{
-  register int hashcode = 0;
-
-  if (TREE_CHAIN (list))
-    hashcode += TYPE_HASH (TREE_CHAIN (list));
-
-  if (TREE_VALUE (list))
-    hashcode += TYPE_HASH (TREE_VALUE (list));
-  else
-    hashcode += 1007;
-  if (TREE_PURPOSE (list))
-    hashcode += TYPE_HASH (TREE_PURPOSE (list));
-  else
-    hashcode += 1009;
-  return hashcode;
-}
-
-/* Look in the type hash table for a type isomorphic to TYPE.
-   If one is found, return it.  Otherwise return 0.  */
-
-tree
-list_hash_lookup (hashcode, list)
-     int hashcode;
-     tree list;
-{
-  register struct list_hash *h;
-  for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
-    if (h->hashcode == hashcode
-	&& TREE_VIA_VIRTUAL (h->list) == TREE_VIA_VIRTUAL (list)
-	&& TREE_VIA_PUBLIC (h->list) == TREE_VIA_PUBLIC (list)
-	&& TREE_VIA_PROTECTED (h->list) == TREE_VIA_PROTECTED (list)
-	&& TREE_PURPOSE (h->list) == TREE_PURPOSE (list)
-	&& TREE_VALUE (h->list) == TREE_VALUE (list)
-	&& TREE_CHAIN (h->list) == TREE_CHAIN (list))
-      {
-	my_friendly_assert (TREE_TYPE (h->list) == TREE_TYPE (list), 299);
-	return h->list;
-      }
-  return 0;
-}
-
-/* Add an entry to the list-hash-table
-   for a list TYPE whose hash code is HASHCODE.  */
-
-void
-list_hash_add (hashcode, list)
-     int hashcode;
-     tree list;
-{
-  register struct list_hash *h;
-
-  h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
-  h->hashcode = hashcode;
-  h->list = list;
-  h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
-  list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
-}
-
-/* Given TYPE, and HASHCODE its hash code, return the canonical
-   object for an identical list if one already exists.
-   Otherwise, return TYPE, and record it as the canonical object
-   if it is a permanent object.
-
-   To use this function, first create a list of the sort you want.
-   Then compute its hash code from the fields of the list that
-   make it different from other similar lists.
-   Then call this function and use the value.
-   This function frees the list you pass in if it is a duplicate.  */
-
-/* Set to 1 to debug without canonicalization.  Never set by program.  */
-int debug_no_list_hash = 0;
-
-tree
-list_hash_canon (hashcode, list)
-     int hashcode;
-     tree list;
-{
-  tree t1;
-
-  if (debug_no_list_hash)
-    return list;
-
-  t1 = list_hash_lookup (hashcode, list);
-  if (t1 != 0)
-    {
-      obstack_free (&class_obstack, list);
-      return t1;
-    }
-
-  /* If this is a new list, record it for later reuse.  */
-  list_hash_add (hashcode, list);
-
-  return list;
-}
-
-tree
-hash_tree_cons (via_public, via_virtual, via_protected, purpose, value, chain)
-     int via_public, via_virtual, via_protected;
-     tree purpose, value, chain;
-{
-  struct obstack *ambient_obstack = current_obstack;
-  tree t;
-  int hashcode;
-
-  current_obstack = &class_obstack;
-  t = tree_cons (purpose, value, chain);
-  TREE_VIA_PUBLIC (t) = via_public;
-  TREE_VIA_PROTECTED (t) = via_protected;
-  TREE_VIA_VIRTUAL (t) = via_virtual;
-  hashcode = list_hash (t);
-  t = list_hash_canon (hashcode, t);
-  current_obstack = ambient_obstack;
-  return t;
-}
-
-/* Constructor for hashed lists.  */
-tree
-hash_tree_chain (value, chain)
-     tree value, chain;
-{
-  struct obstack *ambient_obstack = current_obstack;
-  tree t;
-  int hashcode;
-
-  current_obstack = &class_obstack;
-  t = tree_cons (NULL_TREE, value, chain);
-  hashcode = list_hash (t);
-  t = list_hash_canon (hashcode, t);
-  current_obstack = ambient_obstack;
-  return t;
-}
-
-/* Similar, but used for concatenating two lists.  */
-tree
-hash_chainon (list1, list2)
-     tree list1, list2;
-{
-  if (list2 == 0)
-    return list1;
-  if (list1 == 0)
-    return list2;
-  if (TREE_CHAIN (list1) == NULL_TREE)
-    return hash_tree_chain (TREE_VALUE (list1), list2);
-  return hash_tree_chain (TREE_VALUE (list1),
-			  hash_chainon (TREE_CHAIN (list1), list2));
-}
-
-tree
-get_decl_list (value)
-     tree value;
-{
-  tree list = NULL_TREE;
-
-  if (TREE_CODE (value) == IDENTIFIER_NODE)
-    {
-      list = IDENTIFIER_AS_LIST (value);
-      if (list != NULL_TREE
-	  && (TREE_CODE (list) != TREE_LIST
-	      || TREE_VALUE (list) != value))
-	list = NULL_TREE;
-      else if (IDENTIFIER_HAS_TYPE_VALUE (value)
-	       && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE)
-	{
-	  tree type = IDENTIFIER_TYPE_VALUE (value);
-	  if (CLASSTYPE_ID_AS_LIST (type) == NULL_TREE)
-	    CLASSTYPE_ID_AS_LIST (type) = perm_tree_cons (NULL_TREE, value, NULL_TREE);
-	  list = CLASSTYPE_ID_AS_LIST (type);
-	}
-    }
-  else if (TREE_CODE (value) == RECORD_TYPE
-	   && TYPE_LANG_SPECIFIC (value))
-    list = CLASSTYPE_AS_LIST (value);
-
-  if (list != NULL_TREE)
-    {
-      my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 301);
-      return list;
-    }
-
-  return build_decl_list (NULL_TREE, value);
-}
-
-/* Look in the type hash table for a type isomorphic to
-   `build_tree_list (NULL_TREE, VALUE)'.
-   If one is found, return it.  Otherwise return 0.  */
-
-tree
-list_hash_lookup_or_cons (value)
-     tree value;
-{
-  register int hashcode = TYPE_HASH (value);
-  register struct list_hash *h;
-  struct obstack *ambient_obstack;
-  tree list = NULL_TREE;
-
-  if (TREE_CODE (value) == IDENTIFIER_NODE)
-    {
-      list = IDENTIFIER_AS_LIST (value);
-      if (list != NULL_TREE
-	  && (TREE_CODE (list) != TREE_LIST
-	      || TREE_VALUE (list) != value))
-	list = NULL_TREE;
-      else if (IDENTIFIER_HAS_TYPE_VALUE (value)
-	       && TREE_CODE (IDENTIFIER_TYPE_VALUE (value)) == RECORD_TYPE)
-	{
-	  /* If the type name and constructor name are different, don't
-	     write constructor name into type.  */
-	  if (identifier_typedecl_value (value)
-	      && identifier_typedecl_value (value) != constructor_name (value))
-	    list = tree_cons (NULL_TREE, value, NULL_TREE);
-	  else
-	    {
-	      tree type = IDENTIFIER_TYPE_VALUE (value);
-	      if (CLASSTYPE_ID_AS_LIST (type) == NULL_TREE)
-		CLASSTYPE_ID_AS_LIST (type) = perm_tree_cons (NULL_TREE, value,
-							      NULL_TREE);
-	      list = CLASSTYPE_ID_AS_LIST (type);
-	    }
-	}
-    }
-  else if (TREE_CODE (value) == TYPE_DECL
-	   && TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE
-	   && TYPE_LANG_SPECIFIC (TREE_TYPE (value)))
-    list = CLASSTYPE_ID_AS_LIST (TREE_TYPE (value));
-  else if (TREE_CODE (value) == RECORD_TYPE
-	   && TYPE_LANG_SPECIFIC (value))
-    list = CLASSTYPE_AS_LIST (value);
-
-  if (list != NULL_TREE)
-    {
-      my_friendly_assert (TREE_CHAIN (list) == NULL_TREE, 302);
-      return list;
-    }
-
-  if (debug_no_list_hash)
-    return hash_tree_chain (value, NULL_TREE);
-
-  for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
-    if (h->hashcode == hashcode
-	&& TREE_VIA_VIRTUAL (h->list) == 0
-	&& TREE_VIA_PUBLIC (h->list) == 0
-	&& TREE_VIA_PROTECTED (h->list) == 0
-	&& TREE_PURPOSE (h->list) == 0
-	&& TREE_VALUE (h->list) == value)
-      {
-	my_friendly_assert (TREE_TYPE (h->list) == 0, 303);
-	my_friendly_assert (TREE_CHAIN (h->list) == 0, 304);
-	return h->list;
-      }
-
-  ambient_obstack = current_obstack;
-  current_obstack = &class_obstack;
-  list = build_tree_list (NULL_TREE, value);
-  list_hash_add (hashcode, list);
-  current_obstack = ambient_obstack;
-  return list;
-}
-
-/* Build an association between TYPE and some parameters:
-
-   OFFSET is the offset added to `this' to convert it to a pointer
-   of type `TYPE *'
-
-   VTABLE is the virtual function table with which to initialize
-   sub-objects of type TYPE.
-
-   VIRTUALS are the virtual functions sitting in VTABLE.
-
-   CHAIN are more associations we must retain.  */
-
-tree
-make_binfo (offset, type, vtable, virtuals, chain)
-     tree offset, type;
-     tree vtable, virtuals;
-     tree chain;
-{
-  tree binfo = make_tree_vec (6);
-  tree old_binfo = TYPE_BINFO (type);
-  tree last;
-
-  TREE_CHAIN (binfo) = chain;
-  if (chain)
-    TREE_USED (binfo) = TREE_USED (chain);
-
-  TREE_TYPE (binfo) = TYPE_MAIN_VARIANT (type);
-  BINFO_OFFSET (binfo) = offset;
-  BINFO_VTABLE (binfo) = vtable;
-  BINFO_VIRTUALS (binfo) = virtuals;
-  BINFO_VPTR_FIELD (binfo) = NULL_TREE;
-
-  last = binfo;
-  if (old_binfo != NULL_TREE
-      && BINFO_BASETYPES (old_binfo) != NULL_TREE)
-    {
-      int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (type);
-      tree binfos = TYPE_BINFO_BASETYPES (type);
-
-      BINFO_BASETYPES (binfo) = make_tree_vec (n_baseclasses);
-      for (i = 0; i < n_baseclasses; i++)
-	{
-	  tree base_binfo = TREE_VEC_ELT (binfos, i);
-	  tree old_base_binfo = old_binfo ? BINFO_BASETYPE (old_binfo, i) : 0;
-	  BINFO_BASETYPE (binfo, i) = base_binfo;
-	  if (old_binfo)
-	    {
-	      TREE_VIA_PUBLIC (base_binfo) = TREE_VIA_PUBLIC (old_base_binfo);
-	      TREE_VIA_PROTECTED (base_binfo) = TREE_VIA_PROTECTED (old_base_binfo);
-	      TREE_VIA_VIRTUAL (base_binfo) = TREE_VIA_VIRTUAL (old_base_binfo);
-	    }
-	}
-    }
-  return binfo;
-}
-
-tree
-copy_binfo (list)
-     tree list;
-{
-  tree binfo = copy_list (list);
-  tree rval = binfo;
-  while (binfo)
-    {
-      TREE_USED (binfo) = 0;
-      if (BINFO_BASETYPES (binfo))
-	BINFO_BASETYPES (binfo) = copy_node (BINFO_BASETYPES (binfo));
-      binfo = TREE_CHAIN (binfo);
-    }
-  return rval;
-}
-
-/* Return the binfo value for ELEM in TYPE.  */
-
-tree
-binfo_value (elem, type)
-     tree elem;
-     tree type;
-{
-  if (get_base_distance (elem, type, 0, (tree *)0) == -2)
-    compiler_error ("base class `%s' ambiguous in binfo_value",
-		    TYPE_NAME_STRING (elem));
-  if (elem == type)
-    return TYPE_BINFO (type);
-  return get_binfo (elem, type, 0);
-}
-
-tree
-reverse_path (path)
-     tree path;
-{
-  register tree prev = 0, tmp, next;
-  for (tmp = path; tmp; tmp = next)
-    {
-      next = BINFO_INHERITANCE_CHAIN (tmp);
-      BINFO_INHERITANCE_CHAIN (tmp) = prev;
-      prev = tmp;
-    }
-  return prev;
-}
-
-tree
-virtual_member (elem, list)
-     tree elem;
-     tree list;
-{
-  tree t;
-  tree rval, nval;
-
-  for (t = list; t; t = TREE_CHAIN (t))
-    if (elem == BINFO_TYPE (t))
-      return t;
-  rval = 0;
-  for (t = list; t; t = TREE_CHAIN (t))
-    {
-      tree binfos = BINFO_BASETYPES (t);
-      int i;
-
-      if (binfos != NULL_TREE)
-	for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
-	  {
-	    nval = binfo_value (elem, BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
-	    if (nval)
-	      {
-		if (rval && BINFO_OFFSET (nval) != BINFO_OFFSET (rval))
-		  my_friendly_abort (104);
-		rval = nval;
-	      }
-	  }
-    }
-  return rval;
-}
-
-/* Return the offset (as an INTEGER_CST) for ELEM in LIST.
-   INITIAL_OFFSET is the value to add to the offset that ELEM's
-   binfo entry in LIST provides.
-
-   Returns NULL if ELEM does not have an binfo value in LIST.  */
-
-tree
-virtual_offset (elem, list, initial_offset)
-     tree elem;
-     tree list;
-     tree initial_offset;
-{
-  tree vb, offset;
-  tree rval, nval;
-
-  for (vb = list; vb; vb = TREE_CHAIN (vb))
-    if (elem == BINFO_TYPE (vb))
-      return size_binop (PLUS_EXPR, initial_offset, BINFO_OFFSET (vb));
-  rval = 0;
-  for (vb = list; vb; vb = TREE_CHAIN (vb))
-    {
-      tree binfos = BINFO_BASETYPES (vb);
-      int i;
-
-      if (binfos == NULL_TREE)
-	continue;
-
-      for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--)
-	{
-	  nval = binfo_value (elem, BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
-	  if (nval)
-	    {
-	      if (rval && BINFO_OFFSET (nval) != BINFO_OFFSET (rval))
-		my_friendly_abort (105);
-	      offset = BINFO_OFFSET (vb);
-	      rval = nval;
-	    }
-	}
-    }
-  if (rval == NULL_TREE)
-    return rval;
-  return size_binop (PLUS_EXPR, offset, BINFO_OFFSET (rval));
-}
-
-void
-debug_binfo (elem)
-     tree elem;
-{
-  int i;
-  tree virtuals;
-
-  fprintf (stderr, "type \"%s\"; offset = %d\n",
-	   TYPE_NAME_STRING (BINFO_TYPE (elem)),
-	   TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
-  fprintf (stderr, "vtable type:\n");
-  debug_tree (BINFO_TYPE (elem));
-  if (BINFO_VTABLE (elem))
-    fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
-  else
-    fprintf (stderr, "no vtable decl yet\n");
-  fprintf (stderr, "virtuals:\n");
-  virtuals = BINFO_VIRTUALS (elem);
-  if (virtuals != 0)
-    {
-      virtuals = TREE_CHAIN (virtuals);
-      if (flag_dossier)
-	virtuals = TREE_CHAIN (virtuals);
-    }
-  i = 1;
-  while (virtuals)
-    {
-      tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
-      fprintf (stderr, "%s [%d =? %d]\n",
-	       IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
-	       i, TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
-      virtuals = TREE_CHAIN (virtuals);
-      i += 1;
-    }
-}
-
-/* Return the length of a chain of nodes chained through DECL_CHAIN.
-   We expect a null pointer to mark the end of the chain.
-   This is the Lisp primitive `length'.  */
-
-int
-decl_list_length (t)
-     tree t;
-{
-  register tree tail;
-  register int len = 0;
-
-  my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL, 300);
-  for (tail = t; tail; tail = DECL_CHAIN (tail))
-    len++;
-
-  return len;
-}
-
-tree
-fnaddr_from_vtable_entry (entry)
-     tree entry;
-{
-  return TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry))));
-}
-
-void
-set_fnaddr_from_vtable_entry (entry, value)
-     tree entry, value;
-{
-  TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (entry)))) = value;
-}
-
-tree
-function_arg_chain (t)
-     tree t;
-{
-  return TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (t)));
-}
-
-int
-promotes_to_aggr_type (t, code)
-     tree t;
-     enum tree_code code;
-{
-  if (TREE_CODE (t) == code)
-    t = TREE_TYPE (t);
-  return IS_AGGR_TYPE (t);
-}
-
-int
-is_aggr_type_2 (t1, t2)
-     tree t1, t2;
-{
-  if (TREE_CODE (t1) != TREE_CODE (t2))
-    return 0;
-  return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
-}
-
-/* Give message using types TYPE1 and TYPE2 as arguments.
-   PFN is the function which will print the message;
-   S is the format string for PFN to use.  */
-void
-message_2_types (pfn, s, type1, type2)
-     void (*pfn) ();
-     char *s;
-     tree type1, type2;
-{
-  tree name1 = TYPE_NAME (type1);
-  tree name2 = TYPE_NAME (type2);
-  if (TREE_CODE (name1) == TYPE_DECL)
-    name1 = DECL_NAME (name1);
-  if (TREE_CODE (name2) == TYPE_DECL)
-    name2 = DECL_NAME (name2);
-  (*pfn) (s, IDENTIFIER_POINTER (name1), IDENTIFIER_POINTER (name2));
-}
-
-#define PRINT_RING_SIZE 4
-
-char *
-lang_printable_name (decl)
-     tree decl;
-{
-  static tree decl_ring[PRINT_RING_SIZE];
-  static char *print_ring[PRINT_RING_SIZE];
-  static int ring_counter;
-  int i;
-
-  if (TREE_CODE (decl) != FUNCTION_DECL
-      || DECL_LANG_SPECIFIC (decl) == 0)
-    {
-      if (DECL_NAME (decl))
-	{
-	  if (THIS_NAME_P (DECL_NAME (decl)))
-	    return "this";
-	  return IDENTIFIER_POINTER (DECL_NAME (decl));
-	}
-      return "((anonymous))";
-    }
-
-  /* See if this print name is lying around.  */
-  for (i = 0; i < PRINT_RING_SIZE; i++)
-    if (decl_ring[i] == decl)
-      /* yes, so return it.  */
-      return print_ring[i];
-
-  if (++ring_counter == PRINT_RING_SIZE)
-    ring_counter = 0;
-
-  if (current_function_decl != NULL_TREE)
-    {
-      if (decl_ring[ring_counter] == current_function_decl)
-	ring_counter += 1;
-      if (ring_counter == PRINT_RING_SIZE)
-	ring_counter = 0;
-      if (decl_ring[ring_counter] == current_function_decl)
-	my_friendly_abort (106);
-    }
-
-  if (print_ring[ring_counter])
-    free (print_ring[ring_counter]);
-
-  {
-    int print_ret_type_p
-      = (!DECL_CONSTRUCTOR_P (decl)
-	 && !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)));
-
-    char *name = (char *)fndecl_as_string (0, decl, print_ret_type_p);
-    print_ring[ring_counter] = (char *)malloc (strlen (name) + 1);
-    strcpy (print_ring[ring_counter], name);
-    decl_ring[ring_counter] = decl;
-  }
-  return print_ring[ring_counter];
-}
-
-/* Comparison function for sorting identifiers in RAISES lists.
-   Note that because IDENTIFIER_NODEs are unique, we can sort
-   them by address, saving an indirection.  */
-static int
-id_cmp (p1, p2)
-     tree *p1, *p2;
-{
-  return (HOST_WIDE_INT)TREE_VALUE (*p1) - (HOST_WIDE_INT)TREE_VALUE (*p2);
-}
-
-/* Build the FUNCTION_TYPE or METHOD_TYPE which may raise exceptions
-   listed in RAISES.  */
-tree
-build_exception_variant (ctype, type, raises)
-     tree ctype, type;
-     tree raises;
-{
-  int i;
-  tree v = TYPE_MAIN_VARIANT (type);
-  tree t, t2, cname;
-  tree *a = (tree *)alloca ((list_length (raises)+1) * sizeof (tree));
-  int constp = TYPE_READONLY (type);
-  int volatilep = TYPE_VOLATILE (type);
-
-  if (raises && TREE_CHAIN (raises))
-    {
-      for (i = 0, t = raises; t; t = TREE_CHAIN (t), i++)
-	a[i] = t;
-      /* NULL terminator for list.  */
-      a[i] = NULL_TREE;
-      qsort (a, i, sizeof (tree), id_cmp);
-      while (i--)
-	TREE_CHAIN (a[i]) = a[i+1];
-      raises = a[0];
-    }
-  else if (raises)
-    /* do nothing.  */;
-  else
-    return build_type_variant (v, constp, volatilep);
-
-  if (ctype)
-    {
-      cname = TYPE_NAME (ctype);
-      if (TREE_CODE (cname) == TYPE_DECL)
-	cname = DECL_NAME (cname);
-    }
-  else
-    cname = NULL_TREE;
-
-  for (t = raises; t; t = TREE_CHAIN (t))
-    {
-      /* See that all the exceptions we are thinking about
-	 raising have been declared.  */
-      tree this_cname = lookup_exception_cname (ctype, cname, t);
-      tree decl = lookup_exception_object (this_cname, TREE_VALUE (t), 1);
-
-      if (decl == NULL_TREE)
-	decl = lookup_exception_object (this_cname, TREE_VALUE (t), 0);
-      /* Place canonical exception decl into TREE_TYPE of RAISES list.  */
-      TREE_TYPE (t) = decl;
-    }
-
-  for (v = TYPE_NEXT_VARIANT (v); v; v = TYPE_NEXT_VARIANT (v))
-    {
-      if (TYPE_READONLY (v) != constp
-	  || TYPE_VOLATILE (v) != volatilep)
-	continue;
-
-      t = raises;
-      t2 = TYPE_RAISES_EXCEPTIONS (v);
-      while (t && t2)
-	{
-	  if (TREE_TYPE (t) == TREE_TYPE (t2))
-	    {
-	      t = TREE_CHAIN (t);
-	      t2 = TREE_CHAIN (t2);
-	    }
-	  else break;
-	}
-      if (t || t2)
-	continue;
-      /* List of exceptions raised matches previously found list.
-
-         @@ Nice to free up storage used in consing up the
-	 @@ list of exceptions raised.  */
-      return v;
-    }
-
-  /* Need to build a new variant.  */
-  v = copy_node (type);
-  TYPE_NEXT_VARIANT (v) = TYPE_NEXT_VARIANT (type);
-  TYPE_NEXT_VARIANT (type) = v;
-  if (raises && ! TREE_PERMANENT (raises))
-    {
-      push_obstacks_nochange ();
-      end_temporary_allocation ();
-      raises = copy_list (raises);
-      pop_obstacks ();
-    }
-  TYPE_RAISES_EXCEPTIONS (v) = raises;
-  return v;
-}
-
-/* Subroutine of copy_to_permanent
-
-   Assuming T is a node build bottom-up, make it all exist on
-   permanent obstack, if it is not permanent already.  */
-static tree
-make_deep_copy (t)
-     tree t;
-{
-  enum tree_code code;
-
-  if (t == NULL_TREE || TREE_PERMANENT (t))
-    return t;
-
-  switch (code = TREE_CODE (t))
-    {
-    case ERROR_MARK:
-      return error_mark_node;
-
-    case VAR_DECL:
-    case FUNCTION_DECL:
-    case CONST_DECL:
-      break;
-
-    case PARM_DECL:
-      {
-	tree chain = TREE_CHAIN (t);
-	t = copy_node (t);
-	TREE_CHAIN (t) = make_deep_copy (chain);
-	TREE_TYPE (t) = make_deep_copy (TREE_TYPE (t));
-	DECL_INITIAL (t) = make_deep_copy (DECL_INITIAL (t));
-	DECL_SIZE (t) = make_deep_copy (DECL_SIZE (t));
-	return t;
-      }
-
-    case TREE_LIST:
-      {
-	tree chain = TREE_CHAIN (t);
-	t = copy_node (t);
-	TREE_PURPOSE (t) = make_deep_copy (TREE_PURPOSE (t));
-	TREE_VALUE (t) = make_deep_copy (TREE_VALUE (t));
-	TREE_CHAIN (t) = make_deep_copy (chain);
-	return t;
-      }
-
-    case TREE_VEC:
-      {
-	int len = TREE_VEC_LENGTH (t);
-
-	t = copy_node (t);
-	while (len--)
-	  TREE_VEC_ELT (t, len) = make_deep_copy (TREE_VEC_ELT (t, len));
-	return t;
-      }
-
-    case INTEGER_CST:
-    case REAL_CST:
-    case STRING_CST:
-      return copy_node (t);
-
-    case COND_EXPR:
-    case TARGET_EXPR:
-    case NEW_EXPR:
-      t = copy_node (t);
-      TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
-      TREE_OPERAND (t, 1) = make_deep_copy (TREE_OPERAND (t, 1));
-      TREE_OPERAND (t, 2) = make_deep_copy (TREE_OPERAND (t, 2));
-      return t;
-
-    case SAVE_EXPR:
-      t = copy_node (t);
-      TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
-      return t;
-
-    case MODIFY_EXPR:
-    case PLUS_EXPR:
-    case MINUS_EXPR:
-    case MULT_EXPR:
-    case TRUNC_DIV_EXPR:
-    case TRUNC_MOD_EXPR:
-    case MIN_EXPR:
-    case MAX_EXPR:
-    case LSHIFT_EXPR:
-    case RSHIFT_EXPR:
-    case BIT_IOR_EXPR:
-    case BIT_XOR_EXPR:
-    case BIT_AND_EXPR:
-    case BIT_ANDTC_EXPR:
-    case TRUTH_ANDIF_EXPR:
-    case TRUTH_ORIF_EXPR:
-    case LT_EXPR:
-    case LE_EXPR:
-    case GT_EXPR:
-    case GE_EXPR:
-    case EQ_EXPR:
-    case NE_EXPR:
-    case CEIL_DIV_EXPR:
-    case FLOOR_DIV_EXPR:
-    case ROUND_DIV_EXPR:
-    case CEIL_MOD_EXPR:
-    case FLOOR_MOD_EXPR:
-    case ROUND_MOD_EXPR:
-    case COMPOUND_EXPR:
-    case PREDECREMENT_EXPR:
-    case PREINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-    case CALL_EXPR:
-      t = copy_node (t);
-      TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
-      TREE_OPERAND (t, 1) = make_deep_copy (TREE_OPERAND (t, 1));
-      return t;
-
-    case CONVERT_EXPR:
-    case ADDR_EXPR:
-    case INDIRECT_REF:
-    case NEGATE_EXPR:
-    case BIT_NOT_EXPR:
-    case TRUTH_NOT_EXPR:
-    case NOP_EXPR:
-    case COMPONENT_REF:
-      t = copy_node (t);
-      TREE_OPERAND (t, 0) = make_deep_copy (TREE_OPERAND (t, 0));
-      return t;
-
-      /*  This list is incomplete, but should suffice for now.
-	  It is very important that `sorry' does not call
-	  `report_error_function'.  That could cause an infinite loop.  */
-    default:
-      sorry ("initializer contains unrecognized tree code");
-      return error_mark_node;
-
-    }
-  my_friendly_abort (107);
-  /* NOTREACHED */
-  return NULL_TREE;
-}
-
-/* Assuming T is a node built bottom-up, make it all exist on
-   permanent obstack, if it is not permanent already.  */
-tree
-copy_to_permanent (t)
-     tree t;
-{
-  register struct obstack *ambient_obstack = current_obstack;
-  register struct obstack *ambient_saveable_obstack = saveable_obstack;
-
-  if (t == NULL_TREE || TREE_PERMANENT (t))
-    return t;
-
-  saveable_obstack = &permanent_obstack;
-  current_obstack = saveable_obstack;
-
-  t = make_deep_copy (t);
-
-  current_obstack = ambient_obstack;
-  saveable_obstack = ambient_saveable_obstack;
-
-  return t;
-}
-
-void
-print_lang_statistics ()
-{
-  extern struct obstack maybepermanent_obstack;
-  print_obstack_statistics ("class_obstack", &class_obstack);
-  print_obstack_statistics ("permanent_obstack", &permanent_obstack);
-  print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack);
-  print_search_statistics ();
-  print_class_statistics ();
-}
-
-/* This is used by the `assert' macro.  It is provided in libgcc.a,
-   which `cc' doesn't know how to link.  Note that the C++ front-end
-   no longer actually uses the `assert' macro (instead, it calls
-   my_friendly_assert).  But all of the back-end files still need this.  */
-void
-__eprintf (string, expression, line, filename)
-#ifdef __STDC__
-     const char *string;
-     const char *expression;
-     unsigned line;
-     const char *filename;
-#else
-     char *string;
-     char *expression;
-     unsigned line;
-     char *filename;
-#endif
-{
-  fprintf (stderr, string, expression, line, filename);
-  fflush (stderr);
-  abort ();
-}
-
-/* Return, as an INTEGER_CST node, the number of elements for
-   TYPE (which is an ARRAY_TYPE).  This counts only elements of the top array. */
-
-tree
-array_type_nelts_top (type)
-     tree type;
-{
-  return fold (build (PLUS_EXPR, integer_type_node,
-		      array_type_nelts (type),
-		      integer_one_node));
-}
-
-/* Return, as an INTEGER_CST node, the number of elements for
-   TYPE (which is an ARRAY_TYPE).  This one is a recursive count of all
-   ARRAY_TYPEs that are clumped together. */
-
-tree
-array_type_nelts_total (type)
-     tree type;
-{
-  tree sz = array_type_nelts_top (type);
-  type = TREE_TYPE (type);
-  while (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      tree n = array_type_nelts_top (type);
-      sz = fold (build (MULT_EXPR, integer_type_node, sz, n));
-      type = TREE_TYPE (type);
-    }
-  return sz;
-}
diff --git a/gnu/gcc2/cc1plus/cp-tree.def b/gnu/gcc2/cc1plus/cp-tree.def
deleted file mode 100644
index b1a9b3855cd2..000000000000
--- a/gnu/gcc2/cc1plus/cp-tree.def
+++ /dev/null
@@ -1,85 +0,0 @@
-/* This file contains the definitions and documentation for the
-   additional tree codes used in the GNU C++ compiler (see tree.def
-   for the standard codes).
-   Copyright (C) 1987, 1988, 1990, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
- 
-/* For DELETE_EXPR, operand 0 is the store to be destroyed.
-   Operand 1 is the value to pass to the destroying function
-   saying whether the store should be deallocated as well.  */
-DEFTREECODE (DELETE_EXPR, "dl_expr", "e", 2)
-
-/* Value is reference to particular overloaded class method.
-   Operand 0 is the class name (an IDENTIFIER_NODE);
-   operand 1 is the field (also an IDENTIFIER_NODE).
-   The COMPLEXITY field holds the class level (usually 0).  */
-DEFTREECODE (SCOPE_REF, "scope_ref", "r", 2)
-
-/* When composing an object with a member, this is the result.
-   Operand 0 is the object.  Operand 1 is the member (usually
-   a dereferenced pointer to member).  */
-DEFTREECODE (MEMBER_REF, "member_ref", "r", 2)
-
-/* Type conversion operator in C++.  TREE_TYPE is type that this
-   operator converts to.  Operand is expression to be converted.  */
-DEFTREECODE (TYPE_EXPR, "type_expr", "e", 1)
-
-/* For CPLUS_NEW_EXPR, operand 0 is function which performs initialization,
-   operand 1 is argument list to initialization function,
-   and operand 2 is the slot which was allocated for this expression.  */
-DEFTREECODE (NEW_EXPR, "nw_expr", "e", 3)
-
-/* Distinguish variables that are only used to identify exceptions
-   that were caught.  Only the DECL_NAME (and TREE_CHAIN)
-   is really used.  */
-DEFTREECODE (CPLUS_CATCH_DECL, "catch_decl", "d", 0)
-
-/* Template definition.  The following fields have the specified uses,
-   although there are other macros in cp-tree.h that should be used for
-   accessing this data.
-        DECL_ARGUMENTS          template parm vector
-        DECL_TEMPLATE_INFO      template text &c
-	DECL_VINDEX		list of instantiations already produced;
-				only done for functions so far
-   For class template:
-        DECL_INITIAL            associated templates (methods &c)
-        DECL_RESULT             null
-   For non-class templates:
-	TREE_TYPE		type of object to be constructed
-        DECL_RESULT             decl for object to be created
-                                (e.g., FUNCTION_DECL with tmpl parms used)
- */
-DEFTREECODE (TEMPLATE_DECL, "template_decl", "d", 0)
-
-/* Index into a template parameter list.  This parameter must be a type.
-   Use TYPE_FIELDS to find parmlist and index.  */
-DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", "t", 0)
-
-/* Index into a template parameter list.  This parameter must not be a
-   type.  */
-DEFTREECODE (TEMPLATE_CONST_PARM, "template_const_parm", "c", 2)
-
-/* For uninstantiated parameterized types.
-        TYPE_VALUES     tree list:
-                TREE_PURPOSE    template decl
-                TREE_VALUE      parm vector
-                TREE_CHAIN      null
-   Other useful fields to be defined later.  */
-DEFTREECODE (UNINSTANTIATED_P_TYPE, "uninstantiated_p_type", "t", 0)
diff --git a/gnu/gcc2/cc1plus/cp-tree.h b/gnu/gcc2/cc1plus/cp-tree.h
deleted file mode 100644
index fa55b655b2f8..000000000000
--- a/gnu/gcc2/cc1plus/cp-tree.h
+++ /dev/null
@@ -1,2006 +0,0 @@
-/* Definitions for C++ parsing and type checking.
-   Copyright (C) 1987, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-#include "cp-class.h"
-
-/* Borrow everything that is C from c-tree.h,
-   but do so by copy, not by inclusion, since c-tree.h defines
-   lang_identifier.  */
-
-#ifndef PARANOID
-#define PARANOID 0
-#endif
-
-/* Language-dependent contents of an identifier.  */
-
-struct lang_identifier
-{
-  struct tree_identifier ignore;
-  tree global_value, local_value;
-  tree class_value;
-  tree class_template_info;
-  struct lang_id2 *x;
-};
-
-struct lang_id2
-{
-  tree label_value, implicit_decl;
-  tree type_desc, as_list, error_locus;
-};
-
-/* To identify to the debug emitters if it should pay attention to the
-   flag `-Wtemplate-debugging'.  */
-#define HAVE_TEMPLATES 1
-
-/* Macros for access to language-specific slots in an identifier.  */
-
-#if !PARANOID
-#define IDENTIFIER_GLOBAL_VALUE(NODE)	\
-  (((struct lang_identifier *)(NODE))->global_value)
-#define IDENTIFIER_CLASS_VALUE(NODE)	\
-  (((struct lang_identifier *)(NODE))->class_value)
-#define IDENTIFIER_LOCAL_VALUE(NODE)	\
-  (((struct lang_identifier *)(NODE))->local_value)
-#define IDENTIFIER_TEMPLATE(NODE)	\
-  (((struct lang_identifier *)(NODE))->class_template_info)
-#else
-#define IDENTIFIER_LANG_SPECIFIC_PTR(NODE) \
-  (my_friendly_assert (TREE_CODE (NODE) == IDENTIFIER_NODE, 325),	\
-   (struct lang_identifier *) (NODE))
-#define IDENTIFIER_GLOBAL_VALUE(NODE)	\
-  (((struct lang_identifier *)(NODE))->global_value)
-#define IDENTIFIER_CLASS_VALUE(NODE)	\
-  (((struct lang_identifier *)(NODE))->class_value)
-#define IDENTIFIER_LOCAL_VALUE(NODE)	\
-  (((struct lang_identifier *)(NODE))->local_value)
-#define IDENTIFIER_TEMPLATE(NODE)	\
-  (IDENTIFIER_LANG_SPECIFIC_PTR (NODE) -> class_template_info)
-#endif
-
-#if !PARANOID
-#define IDENTIFIER_TYPE_VALUE(NODE) (TREE_TYPE (NODE))
-#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = TYPE)
-#else
-#define IDENTIFIER_TYPE_VALUE(NODE) (*IDENTIFIER_TYPE_VALUE_PTR(NODE))
-#ifdef __GNUC__
-__inline
-#endif
-static tree * IDENTIFIER_TYPE_VALUE_PTR(NODE) tree NODE; { return
-  (my_friendly_assert (TREE_CODE (NODE) == IDENTIFIER_NODE, 326),
-   &TREE_TYPE (NODE)) ;}
-#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (IDENTIFIER_TYPE_VALUE(NODE)=TYPE)
-#endif
-#define IDENTIFIER_HAS_TYPE_VALUE(NODE) (TREE_TYPE (NODE) ? 1 : 0)
-
-#define IDENTIFIER_LABEL_VALUE(NODE)	\
-  (((struct lang_identifier *)(NODE))->x \
-   ? ((struct lang_identifier *)(NODE))->x->label_value : 0)
-#define SET_IDENTIFIER_LABEL_VALUE(NODE,VALUE)	\
-  (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
-   ((struct lang_identifier *)(NODE))->x->label_value = (VALUE))
-#define IDENTIFIER_IMPLICIT_DECL(NODE)	\
-  (((struct lang_identifier *)(NODE))->x \
-   ? ((struct lang_identifier *)(NODE))->x->implicit_decl : 0)
-#define SET_IDENTIFIER_IMPLICIT_DECL(NODE,VALUE)	\
-  (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
-   ((struct lang_identifier *)(NODE))->x->implicit_decl = (VALUE))
-#define IDENTIFIER_AS_DESC(NODE)		\
-  (((struct lang_identifier *)(NODE))->x \
-   ? ((struct lang_identifier *)(NODE))->x->type_desc : 0)
-#define SET_IDENTIFIER_AS_DESC(NODE,DESC)	\
-  (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
-   ((struct lang_identifier *)(NODE))->x->type_desc = (DESC))
-#define IDENTIFIER_AS_LIST(NODE)		\
-  (((struct lang_identifier *)(NODE))->x \
-   ? ((struct lang_identifier *)(NODE))->x->as_list : 0)
-#define SET_IDENTIFIER_AS_LIST(NODE,LIST)	\
-  (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
-   ((struct lang_identifier *)(NODE))->x->as_list = (LIST))
-#define IDENTIFIER_ERROR_LOCUS(NODE)	\
-  (((struct lang_identifier *)(NODE))->x \
-   ? ((struct lang_identifier *)(NODE))->x->error_locus : 0)
-#define SET_IDENTIFIER_ERROR_LOCUS(NODE,VALUE)	\
-  (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
-   ((struct lang_identifier *)(NODE))->x->error_locus = (VALUE))
-
-#define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1(NODE)
-
-/* Nonzero if this identifier is the prefix for a mangled C++ operator name.  */
-#define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2(NODE)
-
-#define IDENTIFIER_TYPENAME_P(NODE)	\
-  (! strncmp (IDENTIFIER_POINTER (NODE),			\
-	      IDENTIFIER_POINTER (ansi_opname[(int) TYPE_EXPR]),	\
-	      IDENTIFIER_LENGTH (ansi_opname[(int) TYPE_EXPR])))
-
-/* Nonzero means reject anything that ANSI standard C forbids.  */
-extern int pedantic;
-
-/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
-#define C_TYPE_FIELDS_READONLY(type) TYPE_LANG_FLAG_0 (type)
-
-/* If non-zero, a VAR_DECL whose cleanup will cause a throw to the
-   next exception handler.  */
-extern tree exception_throw_decl;
-
-extern tree double_type_node, long_double_type_node, float_type_node;
-extern tree char_type_node, unsigned_char_type_node, signed_char_type_node;
-extern tree ptrdiff_type_node;
-
-extern tree short_integer_type_node, short_unsigned_type_node;
-extern tree long_integer_type_node, long_unsigned_type_node;
-extern tree long_long_integer_type_node, long_long_unsigned_type_node;
-extern tree unsigned_type_node;
-extern tree string_type_node, char_array_type_node, int_array_type_node;
-extern tree wchar_array_type_node;
-extern tree wchar_type_node, signed_wchar_type_node, unsigned_wchar_type_node;
-extern tree intQI_type_node, unsigned_intQI_type_node;
-extern tree intHI_type_node, unsigned_intHI_type_node;
-extern tree intSI_type_node, unsigned_intSI_type_node;
-extern tree intDI_type_node, unsigned_intDI_type_node;
-
-extern int current_function_returns_value;
-extern int current_function_returns_null;
-extern tree current_function_return_value;
-
-extern tree ridpointers[];
-extern tree ansi_opname[];
-extern tree ansi_assopname[];
-
-/* Nonzero means `$' can be in an identifier.  */
-
-extern int dollars_in_ident;
-
-/* Nonzero means allow type mismatches in conditional expressions;
-   just make their values `void'.   */
-
-extern int flag_cond_mismatch;
-
-/* Nonzero means don't recognize the keyword `asm'.  */
-
-extern int flag_no_asm;
-
-/* For cross referencing.  */
-
-extern int flag_gnu_xref;
-
-/* For environments where you can use GNU binutils (as, ld in particular).  */
-
-extern int flag_gnu_binutils;
-
-/* Nonzero means ignore `#ident' directives.  */
-
-extern int flag_no_ident;
-
-/* Nonzero means warn about implicit declarations.  */
-
-extern int warn_implicit;
-
-/* Nonzero means warn about function definitions that default the return type
-   or that use a null return and have a return-type other than void.  */
-
-extern int warn_return_type, explicit_warn_return_type;
-
-/* Nonzero means give string constants the type `const char *'
-   to get extra warnings from them.  These warnings will be too numerous
-   to be useful, except in thoroughly ANSIfied programs.  */
-
-extern int warn_write_strings;
-
-/* Nonzero means warn about sizeof(function) or addition/subtraction
-   of function pointers.  */
-
-extern int warn_pointer_arith;
-
-/* Nonzero means warn for all old-style non-prototype function decls.  */
-
-extern int warn_strict_prototypes;
-
-/* Nonzero means warn about suggesting putting in ()'s.  */
-
-extern int warn_parentheses;
-
-/* Warn about a subscript that has type char.  */
-
-extern int warn_char_subscripts;
-
-/* Nonzero means warn about pointer casts that can drop a type qualifier
-   from the pointer target type.  */
-
-extern int warn_cast_qual;
-
-/* Warn about traditional constructs whose meanings changed in ANSI C.  */
-
-extern int warn_traditional;
-
-/* Nonzero means warn about non virtual destructors in classes that have
-   virtual functions. */
-
-extern int warn_nonvdtor;
-
-/* Nonzero means do some things the same way PCC does.  */
-
-extern int flag_traditional;
-
-/* Nonzero means to treat bitfields as unsigned unless they say `signed'.  */
-
-extern int flag_signed_bitfields;
-
-/* 3 means write out only virtuals function tables `defined'
-   in this implementation file.
-   2 means write out only specific virtual function tables
-   and give them (C) public visibility.
-   1 means write out virtual function tables and give them
-   (C) public visibility.
-   0 means write out virtual function tables and give them
-   (C) static visibility (default).
-   -1 means declare virtual function tables extern.  */
-
-extern int write_virtuals;
-
-/* INTERFACE_ONLY nonzero means that we are in an "interface"
-   section of the compiler.  INTERFACE_UNKNOWN nonzero means
-   we cannot trust the value of INTERFACE_ONLY.  If INTERFACE_UNKNOWN
-   is zero and INTERFACE_ONLY is zero, it means that we are responsible
-   for exporting definitions that others might need.  */
-extern int interface_only, interface_unknown;
-
-/* Nonzero means we should attempt to elide constructors when possible.  */
-
-extern int flag_elide_constructors;
-
-/* Nonzero means recognize and handle exception handling constructs.  */
-
-extern int flag_handle_exceptions;
-
-/* Nonzero means recognize and handle ansi-style exception handling constructs.  */
-
-extern int flag_ansi_exceptions;
-
-/* Nonzero means that member functions defined in class scope are
-   inline by default.  */
-
-extern int flag_default_inline;
-
-/* Nonzero means emit cadillac protocol.  */
-
-extern int flag_cadillac;
-
-/* C++ language-specific tree codes.  */
-#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
-enum cplus_tree_code {
-  __DUMMY = LAST_AND_UNUSED_TREE_CODE,
-#include "cp-tree.def"
-  LAST_CPLUS_TREE_CODE
-};
-#undef DEFTREECODE
-
-enum languages { lang_c, lang_cplusplus };
-
-/* Macros to make error reporting functions' lives easier.  */
-#if !PARANOID
-#define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE)))
-#else
-#define TYPE_IDENTIFIER(NODE) (*TYPE_IDENTIFIER_PTR (NODE))
-#ifdef __GNUC__
-__inline
-#endif
-static tree *
-TYPE_IDENTIFIER_PTR(NODE) tree NODE; { return
-  (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 327),
-   &DECL_NAME (TYPE_NAME (NODE))) ;}
-#endif
-
-#define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE)))
-#define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE)))
-
-#define TYPE_ASSEMBLER_NAME_STRING(NODE) (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME  (NODE))))
-#define TYPE_ASSEMBLER_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE))))
-
-#define IS_AGGR_TYPE_2(TYPE1,TYPE2) \
-  (TREE_CODE (TYPE1) == TREE_CODE (TYPE2)	\
-   && IS_AGGR_TYPE (TYPE1)&IS_AGGR_TYPE (TYPE2))
-
-/* Macros which might want to be replaced by function calls.  */
-
-#if 1
-/* Virtual function addresses can be gotten from a virtual function
-   table entry using this macro.  */
-#define FNADDR_FROM_VTABLE_ENTRY(ENTRY) \
-  TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (ENTRY))))
-#define SET_FNADDR_FROM_VTABLE_ENTRY(ENTRY,VALUE) \
-  (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (ENTRY)))) = (VALUE))
-
-#define FUNCTION_ARG_CHAIN(NODE) (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE))))
-#define PROMOTES_TO_AGGR_TYPE(NODE,CODE)	\
-  (((CODE) == TREE_CODE (NODE)			\
-       && IS_AGGR_TYPE (TREE_TYPE (NODE)))	\
-   || IS_AGGR_TYPE (NODE))
-
-#else
-#define FNADDR_FROM_VTABLE_ENTRY(ENTRY) (fnaddr_from_vtable_entry (ENTRY))
-#define SET_FNADDR_FROM_VTABLE_ENTRY(ENTRY,VALUE) \
-  (set_fnaddr_from_vtable_entry (ENTRY, VALUE))
-/* #define TYPE_NAME_STRING(NODE) (type_name_string (NODE)) */
-#define FUNCTION_ARG_CHAIN(NODE) (function_arg_chain (NODE))
-#define PROMOTES_TO_AGGR_TYPE(NODE,CODE) (promotes_to_aggr_type (NODE, CODE))
-/* #define IS_AGGR_TYPE_2(TYPE1, TYPE2) (is_aggr_type_2 (TYPE1, TYPE2)) */
-#endif
-/* Nonzero iff TYPE is uniquely derived from PARENT.  Under MI, PARENT can be an
-   ambiguous base class of TYPE, and this macro will be false.  */
-#define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) (get_base_distance (PARENT, TYPE, 0, (tree *)0) >= 0)
-
-enum conversion_type { ptr_conv, constptr_conv, int_conv, real_conv, last_conversion_type };
-
-/* Statistics show that while the GNU C++ compiler may generate
-   thousands of different types during a compilation run, it
-   generates relatively few (tens) of classtypes.  Because of this,
-   it is not costly to store a generous amount of information
-   in classtype nodes.  This struct must fill out to a multiple of 4 bytes.  */
-struct lang_type
-{
-  struct
-    {
-      unsigned has_type_conversion : 1;
-      unsigned has_int_conversion : 1;
-      unsigned has_float_conversion : 1;
-      unsigned has_init_ref : 1;
-      unsigned gets_init_ref : 1;
-      unsigned gets_init_aggr : 1;
-      unsigned has_assignment : 1;
-      unsigned gets_assignment : 1;
-
-      unsigned needs_constructor : 1;
-      unsigned has_default_ctor : 1;
-      unsigned uses_multiple_inheritance : 1;
-      unsigned const_needs_init : 1;
-      unsigned ref_needs_init : 1;
-      unsigned gets_const_init_ref : 1;
-      unsigned has_const_assign_ref : 1;
-      unsigned gets_const_assign_ref : 1;
-
-      unsigned vtable_needs_writing : 1;
-      unsigned has_assign_ref : 1;
-      unsigned gets_assign_ref : 1;
-      unsigned gets_new : 1;
-      unsigned gets_delete : 1;
-      unsigned has_call_overloaded : 1;
-      unsigned has_array_ref_overloaded : 1;
-      unsigned has_arrow_overloaded : 1;
-
-      unsigned local_typedecls : 1;
-      unsigned interface_only : 1;
-      unsigned interface_unknown : 1;
-      unsigned needs_virtual_reinit : 1;
-      unsigned declared_exception : 1;
-      unsigned declared_class : 1;
-      unsigned being_defined : 1;
-      unsigned redefined : 1;
-
-      unsigned marked : 1;
-      unsigned marked2 : 1;
-      unsigned marked3 : 1;
-      unsigned marked4 : 1;
-      unsigned marked5 : 1;
-      unsigned marked6 : 1;
-      unsigned use_template : 2;
-
-      unsigned debug_requested : 1;
-      unsigned dynamic : 1;
-      unsigned has_method_call_overloaded : 1;
-      unsigned private_attr : 1;
-      unsigned alters_visibilities : 1;
-      unsigned got_semicolon : 1;
-      unsigned dummy : 1;
-
-      /* The MIPS compiler gets it wrong if this struct also
-	 does not fill out to a multiple of 4 bytes.  */
-      unsigned n_vancestors : 16;
-    } type_flags;
-
-  int cid;
-  int n_ancestors;
-  int vsize;
-  int max_depth;
-
-  union tree_node *vbinfo[2];
-  union tree_node *baselink_vec;
-  union tree_node *vfields;
-  union tree_node *vbases;
-  union tree_node *vbase_size;
-
-  union tree_node *tags;
-  char *memoized_table_entry;
-
-  char *search_slot;
-
-#ifdef ONLY_INT_FIELDS
-  unsigned int mode : 8;
-#else
-  enum machine_mode mode : 8;
-#endif
-
-  unsigned char size_unit;
-  unsigned char align;
-  unsigned char sep_unit;
-
-  union tree_node *sep;
-  union tree_node *size;
-
-  union tree_node *base_init_list;
-  union tree_node *abstract_virtuals;
-  union tree_node *as_list;
-  union tree_node *id_as_list;
-  union tree_node *binfo_as_list;
-  union tree_node *vtbl_ptr;
-  union tree_node *instance_variable;
-  union tree_node *friend_classes;
-
-  char *mi_matrix;
-  union tree_node *conversions[last_conversion_type];
-
-  union tree_node *dossier;
-};
-
-/* Indicates whether a template should be (or has been) expanded for this
-   class definition.  0=do, 1=did, 2=don't, 3=didn't.  */
-#define CLASSTYPE_USE_TEMPLATE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.use_template)
-
-/* Fields used for storing information before the class is defined.
-   After the class is defined, these fields hold other information.  */
-
-/* List of friends which were defined inline in this class definition.  */
-#define CLASSTYPE_INLINE_FRIENDS(NODE) (TYPE_NONCOPIED_PARTS (NODE))
-
-/* Nonzero for _CLASSTYPE means that the _CLASSTYPE either has
-   a special meaning for the assignment operator ("operator="),
-   or one of its fields (or base members) has a special meaning
-   defined.  */
-#define TYPE_HAS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assignment)
-#define TYPE_GETS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assignment)
-
-/* Nonzero for _CLASSTYPE means that operator new and delete are defined,
-   respectively.  */
-#define TREE_GETS_NEW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_new)
-#define TREE_GETS_DELETE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_delete)
-
-/* Nonzero for TREE_LIST or _TYPE node means that this node is class-local.  */
-#define TREE_NONLOCAL_FLAG(NODE) (TREE_LANG_FLAG_0 (NODE))
-
-/* Nonzero for a _CLASSTYPE node which we know to be private.  */
-#define TYPE_PRIVATE_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.private_attr)
-
-/* Nonzero means that this _CLASSTYPE node defines ways of converting
-   itself to other types.  */
-#define TYPE_HAS_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_type_conversion)
-
-/* Nonzero means that this _CLASSTYPE node can convert itself to an
-   INTEGER_TYPE.  */
-#define TYPE_HAS_INT_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_int_conversion)
-
-/* Nonzero means that this _CLASSTYPE node can convert itself to an
-   REAL_TYPE.  */
-#define TYPE_HAS_REAL_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_float_conversion)
-
-/* Nonzero means that this _CLASSTYPE node overloads operator=(X&).  */
-#define TYPE_HAS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assign_ref)
-#define TYPE_GETS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assign_ref)
-#define TYPE_HAS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_const_assign_ref)
-#define TYPE_GETS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_assign_ref)
-
-/* Nonzero means that this _CLASSTYPE node has an X(X&) constructor.  */
-#define TYPE_HAS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_init_ref)
-#define TYPE_GETS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_ref)
-#define TYPE_GETS_CONST_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_init_ref)
-
-/* Nonzero means that this _CLASSTYPE node has an X(X ...) constructor.
-   Note that there must be other arguments, or this constructor is flagged
-   as being erroneous.  */
-#define TYPE_GETS_INIT_AGGR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_aggr)
-
-/* Nonzero means that this type is being defined.  I.e., the left brace
-   starting the definition of this type has been seen.  */
-#define TYPE_BEING_DEFINED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.being_defined)
-/* Nonzero means that this type has been redefined.  In this case, if
-   convenient, don't reprocess any methods that appear in its redefinition.  */
-#define TYPE_REDEFINED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.redefined)
-
-/* Nonzero means that this _CLASSTYPE node overloads the method call
-   operator.  In this case, all method calls go through `operator->()(...).  */
-#define TYPE_OVERLOADS_METHOD_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_method_call_overloaded)
-
-/* The is the VAR_DECL that contains NODE's dossier.  */
-#define CLASSTYPE_DOSSIER(NODE) (TYPE_LANG_SPECIFIC(NODE)->dossier)
-
-/* Nonzero means that this _CLASSTYPE node overloads operator().  */
-#define TYPE_OVERLOADS_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_call_overloaded)
-
-/* Nonzero means that this _CLASSTYPE node overloads operator[].  */
-#define TYPE_OVERLOADS_ARRAY_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_array_ref_overloaded)
-
-/* Nonzero means that this _CLASSTYPE node overloads operator->.  */
-#define TYPE_OVERLOADS_ARROW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_arrow_overloaded)
-
-/* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses
-   multiple inheritance.  If this is 0 for the root of a type
-   hierarchy, then we can use more efficient search techniques.  */
-#define TYPE_USES_MULTIPLE_INHERITANCE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.uses_multiple_inheritance)
-
-/* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses
-   virtual base classes.  If this is 0 for the root of a type
-   hierarchy, then we can use more efficient search techniques.  */
-#define TYPE_USES_VIRTUAL_BASECLASSES(NODE) (TREE_LANG_FLAG_3(NODE))
-
-/* List of lists of member functions defined in this class.  */
-#define CLASSTYPE_METHOD_VEC(NODE) TYPE_METHODS(NODE)
-
-/* Pointer from any member function to the head of the list of
-   member functions of the type that member function belongs to.  */
-#define CLASSTYPE_BASELINK_VEC(NODE) (TYPE_LANG_SPECIFIC(NODE)->baselink_vec)
-
-/* Mark bits for depth-first and breath-first searches.  */
-#if !PARANOID
-#define CLASSTYPE_MARKED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked)
-#define CLASSTYPE_MARKED2(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2)
-#define CLASSTYPE_MARKED3(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3)
-#define CLASSTYPE_MARKED4(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4)
-#define CLASSTYPE_MARKED5(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5)
-#define CLASSTYPE_MARKED6(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6)
-/* Macros to modify the above flags */
-#define SET_CLASSTYPE_MARKED(NODE) (CLASSTYPE_MARKED(NODE) = 1)
-#define CLEAR_CLASSTYPE_MARKED(NODE) (CLASSTYPE_MARKED(NODE) = 0)
-#define SET_CLASSTYPE_MARKED2(NODE) (CLASSTYPE_MARKED2(NODE) = 1)
-#define CLEAR_CLASSTYPE_MARKED2(NODE) (CLASSTYPE_MARKED2(NODE) = 0)
-#define SET_CLASSTYPE_MARKED3(NODE) (CLASSTYPE_MARKED3(NODE) = 1)
-#define CLEAR_CLASSTYPE_MARKED3(NODE) (CLASSTYPE_MARKED3(NODE) = 0)
-#define SET_CLASSTYPE_MARKED4(NODE) (CLASSTYPE_MARKED4(NODE) = 1)
-#define CLEAR_CLASSTYPE_MARKED4(NODE) (CLASSTYPE_MARKED4(NODE) = 0)
-#define SET_CLASSTYPE_MARKED5(NODE) (CLASSTYPE_MARKED5(NODE) = 1)
-#define CLEAR_CLASSTYPE_MARKED5(NODE) (CLASSTYPE_MARKED5(NODE) = 0)
-#define SET_CLASSTYPE_MARKED6(NODE) (CLASSTYPE_MARKED6(NODE) = 1)
-#define CLEAR_CLASSTYPE_MARKED6(NODE) (CLASSTYPE_MARKED6(NODE) = 0)
-#else
-#define CLASSTYPE_MARKED(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 328), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked)
-#define CLASSTYPE_MARKED2(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 329), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2)
-#define CLASSTYPE_MARKED3(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 330), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3)
-#define CLASSTYPE_MARKED4(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 331), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4)
-#define CLASSTYPE_MARKED5(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 332), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5)
-#define CLASSTYPE_MARKED6(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 333), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6)
-/* Macros to modify the above flags */
-#define SET_CLASSTYPE_MARKED(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 334), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked = 1)
-#define CLEAR_CLASSTYPE_MARKED(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 335), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked = 0)
-#define SET_CLASSTYPE_MARKED2(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 336), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2 = 1)
-#define CLEAR_CLASSTYPE_MARKED2(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 337), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2 = 0)
-#define SET_CLASSTYPE_MARKED3(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 338), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3 = 1)
-#define CLEAR_CLASSTYPE_MARKED3(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 339), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3 = 0)
-#define SET_CLASSTYPE_MARKED4(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 340), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4 = 1)
-#define CLEAR_CLASSTYPE_MARKED4(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 341), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4 = 0)
-#define SET_CLASSTYPE_MARKED5(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 342), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5 = 1)
-#define CLEAR_CLASSTYPE_MARKED5(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 343), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5 = 0)
-#define SET_CLASSTYPE_MARKED6(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 344), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6 = 1)
-#define CLEAR_CLASSTYPE_MARKED6(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 345), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6 = 0)
-#endif
-
-#define CLASSTYPE_TAGS(NODE) (TYPE_LANG_SPECIFIC(NODE)->tags)
-
-/* Remove when done merging.  */
-#define CLASSTYPE_VFIELD(NODE) TYPE_VFIELD(NODE)
-
-/* The number of virtual functions defined for this
-   _CLASSTYPE node.  */
-#define CLASSTYPE_VSIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vsize)
-/* The virtual base classes that this type uses.  */
-#define CLASSTYPE_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbases)
-/* The virtual function pointer fields that this type contains.  */
-#define CLASSTYPE_VFIELDS(NODE) (TYPE_LANG_SPECIFIC(NODE)->vfields)
-
-/* Number of baseclasses defined for this type.
-   0 means no base classes.  */
-#define CLASSTYPE_N_BASECLASSES(NODE) \
-  (TYPE_BINFO_BASETYPES (NODE) ? TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES(NODE)) : 0)
-
-/* Memoize the number of super classes (base classes) tha this node
-   has.  That way we can know immediately (albeit conservatively how
-   large a multiple-inheritance matrix we need to build to find
-   derivation information.  */
-#define CLASSTYPE_N_SUPERCLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->n_ancestors)
-#define CLASSTYPE_N_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.n_vancestors)
-
-/* Record how deep the inheritance is for this class so `void*' conversions
-   are less favorable than a conversion to the most base type.  */
-#define CLASSTYPE_MAX_DEPTH(NODE) (TYPE_LANG_SPECIFIC(NODE)->max_depth)
-
-/* Used for keeping search-specific information.  Any search routine
-   which uses this must define what exactly this slot is used for.  */
-#define CLASSTYPE_SEARCH_SLOT(NODE) (TYPE_LANG_SPECIFIC(NODE)->search_slot)
-
-/* Entry for keeping memoization tables for this type to
-   hopefully speed up search routines.  Since it is a pointer,
-   it can mean almost anything.  */
-#define CLASSTYPE_MTABLE_ENTRY(NODE) (TYPE_LANG_SPECIFIC(NODE)->memoized_table_entry)
-
-/* This is the total size of the baseclasses defined for this type.
-   Needed because it is desirable to layout such information
-   before beginning to process the class itself, and we
-   don't want to compute it second time when actually laying
-   out the type for real.  */
-#define CLASSTYPE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->size)
-#define CLASSTYPE_SIZE_UNIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->size_unit)
-#define CLASSTYPE_MODE(NODE) (TYPE_LANG_SPECIFIC(NODE)->mode)
-#define CLASSTYPE_ALIGN(NODE) (TYPE_LANG_SPECIFIC(NODE)->align)
-
-/* This is the space needed for virtual base classes.  NULL if
-   there are no virtual basetypes.  */
-#define CLASSTYPE_VBASE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbase_size)
-
-/* A cons list of structure elements which either have constructors
-   to be called, or virtual function table pointers which
-   need initializing.  Depending on what is being initialized,
-   the TREE_PURPOSE and TREE_VALUE fields have different meanings:
-
-   Member initialization: <FIELD_DECL, TYPE>
-   Base class construction: <NULL_TREE, BASETYPE>
-   Base class initialization: <BASE_INITIALIZATION, THESE_INITIALIZATIONS>
-   Whole type: <MEMBER_INIT, BASE_INIT>.  */
-#define CLASSTYPE_BASE_INIT_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->base_init_list)
-
-/* A cons list of virtual functions which cannot be inherited by
-   derived classes.  When deriving from this type, the derived
-   class must provide its own definition for each of these functions.  */
-#define CLASSTYPE_ABSTRACT_VIRTUALS(NODE) (TYPE_LANG_SPECIFIC(NODE)->abstract_virtuals)
-
-#define CLASSTYPE_ALTERS_VISIBILITIES_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.alters_visibilities)
-
-/* Nonzero means that this aggr type has been `closed' by a semicolon.  */
-#define CLASSTYPE_GOT_SEMICOLON(NODE) (TYPE_LANG_SPECIFIC (NODE)->type_flags.got_semicolon)
-
-/* Nonzero means that the main virtual function table pointer needs to be
-   set because base constructors have placed the wrong value there.
-   If this is zero, it means that they placed the right value there,
-   and there is no need to change it.  */
-#define CLASSTYPE_NEEDS_VIRTUAL_REINIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_virtual_reinit)
-
-/* Nonzero means that if this type has virtual functions, that
-   the virtual function table will be written out.  */
-#define CLASSTYPE_VTABLE_NEEDS_WRITING(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.vtable_needs_writing)
-
-/* Nonzero means that this type defines its own local type declarations.  */
-#define CLASSTYPE_LOCAL_TYPEDECLS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.local_typedecls)
-
-/* Nonzero means that this type has an X() constructor.  */
-#define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_default_ctor)
-
-/* Many routines need to cons up a list of basetypes for visibility
-   checking.  This field contains a TREE_LIST node whose TREE_VALUE
-   is the main variant of the type, and whose TREE_VIA_PUBLIC
-   and TREE_VIA_VIRTUAL bits are correctly set.  */
-#define CLASSTYPE_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->as_list)
-/* Same, but cache a list whose value is the name of this type.  */
-#define CLASSTYPE_ID_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->id_as_list)
-/* Same, but cache a list whose value is the binfo of this type.  */
-#define CLASSTYPE_BINFO_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->binfo_as_list)
-
-/* Slot in which to cache a copy of the local vtable pointer.  */
-#define CLASSTYPE_VTBL_PTR(NODE) (TYPE_LANG_SPECIFIC(NODE)->vtbl_ptr)
-
-/* Hold the instance object associated with this method.  */
-#define CLASSTYPE_INST_VAR(NODE) (TYPE_LANG_SPECIFIC(NODE)->instance_variable)
-
-/* A list of class types with which this type is a friend.  */
-#define CLASSTYPE_FRIEND_CLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->friend_classes)
-
-/* Keep an inheritance lattice around so we can quickly tell whether
-   a type is derived from another or not.  */
-#define CLASSTYPE_MI_MATRIX(NODE) (TYPE_LANG_SPECIFIC(NODE)->mi_matrix)
-
-/* If there is exactly one conversion to a non-void, non-const pointer type,
-   remember that here.  If there are more than one, put
-   `error_mark_node' here.  If there are none, this holds NULL_TREE.  */
-#define CLASSTYPE_CONVERSION(NODE,KIND) \
-  (TYPE_LANG_SPECIFIC(NODE)->conversions[(int) KIND])
-
-/* Say whether this node was declared as a "class" or a "struct".  */
-#define CLASSTYPE_DECLARED_CLASS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_class)
-/* Say whether this node was declared as a "class" or a "struct".  */
-#define CLASSTYPE_DECLARED_EXCEPTION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_exception)
-
-/* Nonzero if this class has const members which have no specified initialization.  */
-#define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.const_needs_init)
-
-/* Nonzero if this class has ref members which have no specified initialization.  */
-#define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.ref_needs_init)
-
-/* Nonzero if this class is included from a header file which employs
-   `#pragma interface', and it is not included in its implementation file.  */
-#define CLASSTYPE_INTERFACE_ONLY(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_only)
-
-/* Same as above, but for classes whose purpose we do not know.  */
-#define CLASSTYPE_INTERFACE_UNKNOWN(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_unknown)
-
-/* Nonzero if a _DECL node requires us to output debug info for this class.  */
-#define CLASSTYPE_DEBUG_REQUESTED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.debug_requested)
-
-/* Additional macros for inheritance information.  */
-
-#define CLASSTYPE_VBINFO(NODE,VIA_PUBLIC) \
-  (TYPE_LANG_SPECIFIC (NODE)->vbinfo[VIA_PUBLIC])
-
-/* When following an binfo-specific chain, this is the cumulative
-   via-public flag.  */
-#define BINFO_VIA_PUBLIC(NODE) TREE_LANG_FLAG_5 (NODE)
-
-/* When building a matrix to determine by a single lookup
-   whether one class is derived from another or not,
-   this field is the index of the class in the table.  */
-#define CLASSTYPE_CID(NODE) (TYPE_LANG_SPECIFIC(NODE)->cid)
-#define BINFO_CID(NODE) CLASSTYPE_CID(BINFO_TYPE(NODE))
-
-/* Nonzero means marked by DFS or BFS search, including searches
-   by `get_binfo' and `get_base_distance'.  */
-#define BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED(BINFO_TYPE(NODE)):TREE_LANG_FLAG_0(NODE))
-/* Macros needed because of C compilers that don't allow conditional
-   expressions to be lvalues.  Grr!  */
-#define SET_BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_0(NODE)=1))
-#define CLEAR_BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_0(NODE)=0))
-
-/* Nonzero means marked in building initialization list.  */
-#define BINFO_BASEINIT_MARKED(NODE) CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
-/* Modifier macros */
-#define SET_BINFO_BASEINIT_MARKED(NODE) SET_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
-#define CLEAR_BINFO_BASEINIT_MARKED(NODE) CLEAR_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
-
-/* Nonzero means marked in search through virtual inheritance hierarchy.  */
-#define BINFO_VBASE_MARKED(NODE) CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
-/* Modifier macros */
-#define SET_BINFO_VBASE_MARKED(NODE) SET_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
-#define CLEAR_BINFO_VBASE_MARKED(NODE) CLEAR_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
-
-/* Nonzero means marked in search for members or member functions.  */
-#define BINFO_FIELDS_MARKED(NODE) \
-  (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)):TREE_LANG_FLAG_2(NODE))
-#define SET_BINFO_FIELDS_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED2(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_2(NODE)=1))
-#define CLEAR_BINFO_FIELDS_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED2(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_2(NODE)=0))
-
-/* Nonzero means that this class is on a path leading to a new vtable.  */
-#define BINFO_VTABLE_PATH_MARKED(NODE) \
-  (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):TREE_LANG_FLAG_3(NODE))
-#define SET_BINFO_VTABLE_PATH_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_3(NODE)=1))
-#define CLEAR_BINFO_VTABLE_PATH_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_3(NODE)=0))
-
-/* Nonzero means that this class has a new vtable.  */
-#define BINFO_NEW_VTABLE_MARKED(NODE) \
-  (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):TREE_LANG_FLAG_4(NODE))
-#define SET_BINFO_NEW_VTABLE_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_4(NODE)=1))
-#define CLEAR_BINFO_NEW_VTABLE_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_4(NODE)=0))
-
-/* Nonzero means this class has initialized its virtual baseclasses.  */
-#define BINFO_VBASE_INIT_MARKED(NODE) \
-  (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):TREE_LANG_FLAG_5(NODE))
-#define SET_BINFO_VBASE_INIT_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_5(NODE)=1))
-#define CLEAR_BINFO_VBASE_INIT_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_5(NODE)=0))
-
-/* Accessor macros for the vfield slots in structures.  */
-
-/* Get the assoc info that caused this vfield to exist.  */
-#define VF_BINFO_VALUE(NODE) TREE_PURPOSE (NODE)
-
-/* Get that same information as a _TYPE.  */
-#define VF_BASETYPE_VALUE(NODE) TREE_VALUE (NODE)
-
-/* Get the value of the top-most type dominating the non-`normal' vfields.  */
-#define VF_DERIVED_VALUE(NODE) (VF_BINFO_VALUE (NODE) ? BINFO_TYPE (VF_BINFO_VALUE (NODE)) : NULL_TREE)
-
-/* Get the value of the top-most type that's `normal' for the vfield.  */
-#define VF_NORMAL_VALUE(NODE) TREE_TYPE (NODE)
-
-/* Nonzero for TREE_LIST node means that this list of things
-   is a list of parameters, as opposed to a list of expressions.  */
-#define TREE_PARMLIST(NODE) ((NODE)->common.unsigned_flag) /* overloaded! */
-
-/* Nonzero for FIELD_DECL node means that this FIELD_DECL is
-   a member of an anonymous union construct.  The name of the
-   union is .  */
-#define TREE_ANON_UNION_ELEM(NODE) ((NODE)->decl.regdecl_flag) /* overloaded! */
-
-/* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
-   this type can raise.  */
-#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_NONCOPIED_PARTS (NODE)
-
-struct lang_decl_flags
-{
-#ifdef ONLY_INT_FIELDS
-  int language : 8;
-#else
-  enum languages language : 8;
-#endif
-
-  unsigned operator_attr : 1;
-  unsigned constructor_attr : 1;
-  unsigned returns_first_arg : 1;
-  unsigned preserves_first_arg : 1;
-  unsigned friend_attr : 1;
-  unsigned static_function : 1;
-  unsigned const_memfunc : 1;
-  unsigned volatile_memfunc : 1;
-
-  unsigned abstract_virtual : 1;
-  unsigned permanent_attr : 1 ;
-  unsigned constructor_for_vbase_attr : 1;
-  unsigned dummy : 13;
-
-  tree visibility;
-  tree context;
-};
-
-struct lang_decl
-{
-  struct lang_decl_flags decl_flags;
-
-  struct template_info *template_info;
-  tree main_decl_variant;
-  struct pending_inline *pending_inline_info;
-  tree vbase_init_list;
-  tree chain;
-};
-
-/* Non-zero if NODE is a _DECL with TREE_READONLY set.  */
-#define TREE_READONLY_DECL_P(NODE) \
-  (TREE_READONLY (NODE) && TREE_CODE_CLASS (TREE_CODE (NODE)) == 'd')
-
-/* For FUNCTION_DECLs: return the language in which this decl
-   was declared.  */
-#define DECL_LANGUAGE(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.language)
-
-/* For FUNCTION_DECLs: nonzero means that this function is a constructor.  */
-#define DECL_CONSTRUCTOR_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_attr)
-/* For FUNCTION_DECLs: nonzero means that this function is a constructor
-   for an object with virtual baseclasses.  */
-#define DECL_CONSTRUCTOR_FOR_VBASE_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_for_vbase_attr)
-
-/* For FUNCTION_DECLs: nonzero means that the constructor
-   is known to return a non-zero `this' unchanged.  */
-#define DECL_RETURNS_FIRST_ARG(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.returns_first_arg)
-
-/* Nonzero for FUNCTION_DECL means that this constructor is known to
-   not make any assignment to `this', and therefore can be trusted
-   to return it unchanged.  Otherwise, we must re-assign `current_class_decl'
-   after performing base initializations.  */
-#define DECL_PRESERVES_THIS(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.preserves_first_arg)
-
-/* Nonzero for _DECL means that this decl appears in (or will appear
-   in) as a member in a RECORD_TYPE or UNION_TYPE node.  It is also for
-   detecting circularity in case members are multiply defined.  In the
-   case of a VAR_DECL, it is also used to determine how program storage
-   should be allocated.  */
-#define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3(NODE))
-
-/* Nonzero for FUNCTION_DECL means that this decl is just a
-   friend declaration, and should not be added to the list of
-   member functions for this class.  */
-#define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.friend_attr)
-
-/* Nonzero for FUNCTION_DECL means that this decl is a static
-   member function.  */
-#define DECL_STATIC_FUNCTION_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.static_function)
-
-/* Nonzero for FUNCTION_DECL means that this member function
-   has `this' as const X *const.  */
-#define DECL_CONST_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.const_memfunc)
-
-/* Nonzero for FUNCTION_DECL means that this member function
-   has `this' as volatile X *const.  */
-#define DECL_VOLATILE_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.volatile_memfunc)
-
-/* Nonzero for FUNCTION_DECL means that this member function
-   exists as part of an abstract class's interface.  */
-#define DECL_ABSTRACT_VIRTUAL_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.abstract_virtual)
-
-/* Nonzero if allocated on permanent_obstack.  */
-#define LANG_DECL_PERMANENT(LANGDECL) ((LANGDECL)->decl_flags.permanent_attr)
-
-/* The _TYPE context in which this _DECL appears.  This field is used
-   only to compute visibility information.  */
-#define DECL_CLASS_CONTEXT(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.context)
-
-/* For a FUNCTION_DECL: the chain through which the next method
-   in the method chain is found.  We now use TREE_CHAIN to
-   link into the FIELD_DECL chain.  */
-#if 1
-#define DECL_CHAIN(NODE) (DECL_LANG_SPECIFIC(NODE)->chain)
-#else
-#define DECL_CHAIN(NODE) (TREE_CHAIN (NODE))
-#endif
-
-/* Points back to the decl which caused this lang_decl to be allocated.  */
-#define DECL_MAIN_VARIANT(NODE) (DECL_LANG_SPECIFIC(NODE)->main_decl_variant)
-
-/* For a FUNCTION_DECL: if this function was declared inline inside of
-   a class declaration, this is where the text for the function is
-   squirreled away.  */
-#define DECL_PENDING_INLINE_INFO(NODE) (DECL_LANG_SPECIFIC(NODE)->pending_inline_info)
-
-/* Holds information about how virtual base classes should be initialized
-   by this constructor *if* this constructor is the one to perform
-   such initialization.  */
-#define DECL_VBASE_INIT_LIST(NODE) (DECL_LANG_SPECIFIC(NODE)->vbase_init_list)
-
-/* For a TEMPLATE_DECL: template-specific information.  */
-#define DECL_TEMPLATE_INFO(NODE) (DECL_LANG_SPECIFIC(NODE)->template_info)
-
-/* Nonzero in INT_CST means that this int is negative by dint of
-   using a twos-complement negated operand.  */
-#define TREE_NEGATED_INT(NODE) (TREE_LANG_FLAG_0 (NODE))
-
-/* Nonzero in any kind of _EXPR or _REF node means that it is a call
-   to a storage allocation routine.  If, later, alternate storage
-   is found to hold the object, this call can be ignored.  */
-#define TREE_CALLS_NEW(NODE) (TREE_LANG_FLAG_1 (NODE))
-
-/* Nonzero in any kind of _TYPE that uses multiple inheritance
-   or virtual baseclasses.  */
-#define TYPE_USES_COMPLEX_INHERITANCE(NODE) (TREE_LANG_FLAG_1 (NODE))
-
-/* Nonzero in IDENTIFIER_NODE means that this name is overloaded, and
-   should be looked up in a non-standard way.  */
-#define TREE_OVERLOADED(NODE) (TREE_LANG_FLAG_0 (NODE))
-#define DECL_OVERLOADED(NODE) (DECL_LANG_FLAG_4 (NODE))
-
-/* Nonzero if this (non-TYPE)_DECL has its virtual attribute set.
-   For a FUNCTION_DECL, this is when the function is a virtual function.
-   For a VAR_DECL, this is when the variable is a virtual function table.
-   For a FIELD_DECL, when the field is the field for the virtual function table.
-   For an IDENTIFIER_NODE, nonzero if any function with this name
-   has been declared virtual.
-
-   For a _TYPE if it uses virtual functions (or is derived from
-   one that does).  */
-#define TYPE_VIRTUAL_P(NODE) (TREE_LANG_FLAG_2 (NODE))
-
-/* Same, but tells if this field is private in current context.  */
-#define DECL_PRIVATE(NODE) (DECL_LANG_FLAG_5 (NODE))
-
-/* Same, but tells if this field is private in current context.  */
-#define DECL_PROTECTED(NODE) (DECL_LANG_FLAG_6(NODE))
-
-#define DECL_PUBLIC(NODE) (DECL_LANG_FLAG_7(NODE))
-
-/* Record whether a typedef for type `int' was actually `signed int'.  */
-#define C_TYPEDEF_EXPLICITLY_SIGNED(exp) DECL_LANG_FLAG_1 ((exp))
-
-/* Nonzero if the type T promotes to itself.
-   ANSI C states explicitly the list of types that promote;
-   in particular, short promotes to int even if they have the same width.  */
-#define C_PROMOTING_INTEGER_TYPE_P(t)				\
-  (TREE_CODE ((t)) == INTEGER_TYPE				\
-   && (TYPE_MAIN_VARIANT (t) == char_type_node			\
-       || TYPE_MAIN_VARIANT (t) == signed_char_type_node	\
-       || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node	\
-       || TYPE_MAIN_VARIANT (t) == short_integer_type_node	\
-       || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node))
-
-/* Mark which labels are explicitly declared.
-   These may be shadowed, and may be referenced from nested functions.  */
-#define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
-
-/* Record whether a type or decl was written with nonconstant size.
-   Note that TYPE_SIZE may have simplified to a constant.  */
-#define C_TYPE_VARIABLE_SIZE(type) TREE_LANG_FLAG_4 (type)
-#define C_DECL_VARIABLE_SIZE(type) DECL_LANG_FLAG_8 (type)
-
-/* Nonzero for _TYPE means that the _TYPE defines
-   at least one constructor.  */
-#define TYPE_HAS_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1(NODE))
-
-/* When appearing in an INDIRECT_REF, it means that the tree structure
-   underneath is actually a call to a constructor.  This is needed
-   when the constructor must initialize local storage (which can
-   be automatically destroyed), rather than allowing it to allocate
-   space from the heap.
-
-   When appearing in a SAVE_EXPR, it means that underneath
-   is a call to a constructor.
-
-   When appearing in a CONSTRUCTOR, it means that it was
-   a GNU C constructor expression.
-
-   When appearing in a FIELD_DECL, it means that this field
-   has been duly initialized in its constructor.  */
-#define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4(NODE))
-
-/* Indicates that a NON_LVALUE_EXPR came from a C++ reference.
-   Used to generate more helpful error message in case somebody
-   tries to take its address.  */
-#define TREE_REFERENCE_EXPR(NODE) (TREE_LANG_FLAG_3(NODE))
-
-/* Nonzero for _TYPE means that the _TYPE defines a destructor.  */
-#define TYPE_HAS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_2(NODE))
-
-/* Nonzero for _TYPE node means that creating an object of this type
-   will involve a call to a constructor.  This can apply to objects
-   of ARRAY_TYPE if the type of the elements needs a constructor.  */
-#define TYPE_NEEDS_CONSTRUCTING(NODE) (TYPE_LANG_FLAG_3(NODE))
-#define TYPE_NEEDS_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_constructor)
-
-/* Nonzero for _TYPE node means that destroying an object of this type
-   will involve a call to a destructor.  This can apply to objects
-   of ARRAY_TYPE is the type of the elements needs a destructor.  */
-#define TYPE_NEEDS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_4(NODE))
-
-/* Nonzero for VAR_DECL node means that `external' was specified in
-   its declaration.  */
-#define DECL_THIS_EXTERN(NODE) (DECL_LANG_FLAG_2(NODE))
-
-/* Nonzero for SAVE_EXPR if used to initialize a PARM_DECL.  */
-#define PARM_DECL_EXPR(NODE) (TREE_LANG_FLAG_2(NODE))
-
-/* Nonzero in FUNCTION_DECL means it is really an operator.
-   Just used to communicate formatting information to dbxout.c.  */
-#define DECL_OPERATOR(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.operator_attr)
-
-/* Define fields and accessors for nodes representing declared names.  */
-
-#if 0
-/* C++: A derived class may be able to directly use the virtual
-   function table of a base class.  When it does so, it may
-   still have a decl node used to access the virtual function
-   table (so that variables of this type can initialize their
-   virtual function table pointers by name).  When such thievery
-   is committed, know exactly which base class's virtual function
-   table is the one being stolen.  This effectively computes the
-   transitive closure.  */
-#define DECL_VPARENT(NODE) ((NODE)->decl.arguments)
-#endif
-
-/* Make a slot so we can implement nested types.  This slot holds
-   the IDENTIFIER_NODE that uniquely names the nested type.  This
-   is for TYPE_DECLs only.  */
-#if !PARANOID
-#define DECL_NESTED_TYPENAME(NODE) ((NODE)->decl.arguments)
-#else
-#define DECL_NESTED_TYPENAME(NODE) (*DECL_NESTED_TYPENAME_PTR(NODE))
-#ifdef __GNUC__
-__inline
-#endif
-static tree * DECL_NESTED_TYPENAME_PTR(NODE) tree NODE; { return
-  (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 'd', 346),
-   &(NODE)->decl.arguments) ;}
-#endif
-
-/* C++: all of these are overloaded!  These apply only to TYPE_DECLs.  */
-#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE))
-#define DECL_UNDEFINED_FRIENDS(NODE) ((NODE)->decl.result)
-#define DECL_WAITING_FRIENDS(NODE) ((tree)(NODE)->decl.rtl)
-#define SET_DECL_WAITING_FRIENDS(NODE,VALUE) ((NODE)->decl.rtl=(struct rtx_def*)VALUE)
-
-/* The DECL_VISIBILITY is used to record under which context
-   special visibility rules apply.  */
-#define DECL_VISIBILITY(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.visibility)
-
-/* C++: all of these are overloaded!
-   These apply to PARM_DECLs and VAR_DECLs.  */
-#define DECL_REFERENCE_SLOT(NODE) ((tree)(NODE)->decl.arguments)
-#define SET_DECL_REFERENCE_SLOT(NODE,VAL) ((NODE)->decl.arguments=VAL)
-
-/* For local VAR_DECLs, holds index into gc-protected obstack.  */
-#define DECL_GC_OFFSET(NODE) ((NODE)->decl.result)
-
-/* Accessor macros for C++ template decl nodes.  */
-#define DECL_TEMPLATE_IS_CLASS(NODE)    (DECL_RESULT(NODE) == NULL_TREE)
-#define DECL_TEMPLATE_PARMS(NODE)       DECL_ARGUMENTS(NODE)
-/* For class templates.  */
-#define DECL_TEMPLATE_MEMBERS(NODE)     DECL_INITIAL(NODE)
-/* For function, method, class-data templates.  */
-#define DECL_TEMPLATE_RESULT(NODE)      DECL_RESULT(NODE)
-#define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX(NODE)
-
-/* ...and for unexpanded-parameterized-type nodes.  */
-#define UPT_TEMPLATE(NODE)      TREE_PURPOSE(TYPE_VALUES(NODE))
-#define UPT_PARMS(NODE)         TREE_VALUE(TYPE_VALUES(NODE))
-
-/* An enumeration of the kind of tags that C++ accepts.  */
-enum tag_types { record_type, class_type, union_type, enum_type, exception_type };
-
-/* Zero means prototype weakly, as in ANSI C (no args means nothing).
-   Each language context defines how this variable should be set.  */
-extern int strict_prototype;
-extern int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus;
-
-/* Non-zero means that if a label exists, and no other identifier
-   applies, use the value of the label.  */
-extern int flag_labels_ok;
-
-/* Non-zero means to collect statistics which might be expensive
-   and to print them when we are done.  */
-extern int flag_detailed_statistics;
-
-/* Non-zero means warn in function declared in derived class has the
-   same name as a virtual in the base class, but fails to match the
-   type signature of any virtual function in the base class.  */
-extern int warn_overloaded_virtual;
-
-/* in cp-decl{2}.c */
-extern tree void_list_node;
-extern tree void_zero_node;
-extern tree default_function_type;
-extern tree vtable_entry_type;
-extern tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node;
-extern tree class_star_type_node;
-
-/* A node that is a list (length 1) of error_mark_nodes.  */
-extern tree error_mark_list;
-
-extern tree ptr_type_node;
-extern tree class_type_node, record_type_node, union_type_node, enum_type_node;
-extern tree exception_type_node, unknown_type_node;
-
-/* The largest size a virtual function table can be.
-   Must be a (power of 2).  */
-#ifndef VINDEX_MAX
-#define VINDEX_MAX ((unsigned)128)
-/* This is the integer ~ (vindex_max - 1).  */
-#endif
-extern tree vtbl_mask;
-
-/* Array type `(void *)[]' */
-extern tree vtbl_type_node;
-
-extern tree long_long_integer_type_node, long_long_unsigned_type_node;
-/* For building calls to `delete'.  */
-extern tree integer_two_node, integer_three_node;
-
-/* in cp-except.c */
-extern tree current_exception_type;
-extern tree current_exception_decl;
-extern tree current_exception_object;
-
-/* in cp-pt.c  */
-/* PARM_VEC is a vector of template parameters, either IDENTIFIER_NODEs or
-   PARM_DECLs.  BINDINGS, if non-null, is a vector of bindings for those
-   parameters.  */
-struct template_info {
-  /* Vector of template parameters, either PARM_DECLs or IDENTIFIER_NODEs.  */
-  tree parm_vec;
-  /* If non-null, a vector of bindings for the template parms.  */
-  tree bindings;
-
-  /* Text of template, and length.  */
-  char *text;
-  int length;
-  /* Where it came from.  */
-  char *filename;
-  int lineno;
-
-  /* What kind of aggregate -- struct, class, or null.  */
-  tree aggr;
-};
-extern int processing_template_decl, processing_template_defn;
-
-#define PRINT_LANG_DECL
-#define PRINT_LANG_TYPE
-
-#define UNKNOWN_TYPE LANG_TYPE
-
-/* in cp-class.c */
-extern tree current_class_name;
-extern tree current_class_type;
-
-extern tree current_lang_name, lang_name_cplusplus, lang_name_c;
-
-/* Points to the name of that function. May not be the DECL_NAME
-   of CURRENT_FUNCTION_DECL due to overloading */
-extern tree original_function_name;
-
-# define IS_AGGR_TYPE(t) (TYPE_LANG_FLAG_5 (t))
-
-# define IS_AGGR_TYPE_CODE(t) \
-  (t == RECORD_TYPE || t == UNION_TYPE)
-
-extern tree current_class_name, current_class_type, current_class_decl, C_C_D;
-extern tree current_vtable_decl;
-
-/* in cp-init.c  */
-extern tree global_base_init_list;
-extern tree current_base_init_list, current_member_init_list;
-
-extern int current_function_assigns_this;
-extern int current_function_just_assigned_this;
-extern int current_function_parms_stored;
-
-/* Here's where we control how name mangling takes place.  */
-
-#define OPERATOR_ASSIGN_FORMAT "__a%s"
-#define OPERATOR_FORMAT "__%s"
-#define OPERATOR_TYPENAME_FORMAT "__op"
-
-/* Cannot use '$' up front, because this confuses gdb
-   (names beginning with '$' are gdb-local identifiers).
-
-   Note that all forms in which the '$' is significant are long enough
-   for direct indexing (meaning that if we know there is a '$'
-   at a particular location, we can index into the string at
-   any other location that provides distinguishing characters).  */
-
-/* Define NO_DOLLAR_IN_LABEL in your favorite tm file if your assembler
-   doesn't allow '$' in symbol names.  */
-#ifndef NO_DOLLAR_IN_LABEL
-
-#define JOINER '$'
-
-#define VPTR_NAME "$v"
-#define THROW_NAME "$eh_throw"
-#define DESTRUCTOR_DECL_PREFIX "_$_"
-#define IN_CHARGE_NAME "__in$chrg"
-#define AUTO_VTABLE_NAME "__vtbl$me__"
-#define AUTO_TEMP_NAME "_$tmp_"
-#define AUTO_TEMP_FORMAT "_$tmp_%d"
-#define VTBL_PTR_TYPE "$vtbl_ptr_type"
-#define VTABLE_BASE "$vb"
-#define VTABLE_NAME_FORMAT "_vt$%s"
-#define VFIELD_BASE "$vf"
-#define VFIELD_NAME "_vptr$"
-#define VFIELD_NAME_FORMAT "_vptr$%s"
-#define VBASE_NAME "_vb$"
-#define VBASE_NAME_FORMAT "_vb$%s"
-#define STATIC_NAME_FORMAT "_%s$%s"
-#define FILE_FUNCTION_FORMAT "_GLOBAL_$D$%s"
-#define ANON_AGGRNAME_FORMAT "$_%d"
-
-#else /* NO_DOLLAR_IN_LABEL */
-
-#ifndef NO_DOT_IN_LABEL
-
-#define JOINER '.'
-
-#define VPTR_NAME ".v"
-#define THROW_NAME ".eh_throw"
-#define DESTRUCTOR_DECL_PREFIX "_._"
-#define IN_CHARGE_NAME "__in.chrg"
-#define AUTO_VTABLE_NAME "__vtbl.me__"
-#define AUTO_TEMP_NAME "_.tmp_"
-#define AUTO_TEMP_FORMAT "_.tmp_%d"
-#define VTBL_PTR_TYPE ".vtbl_ptr_type"
-#define VTABLE_BASE ".vb"
-#define VTABLE_NAME_FORMAT "_vt.%s"
-#define VFIELD_BASE ".vf"
-#define VFIELD_NAME "_vptr."
-#define VFIELD_NAME_FORMAT "_vptr.%s"
-#define VBASE_NAME "_vb."
-#define VBASE_NAME_FORMAT "_vb.%s"
-#define STATIC_NAME_FORMAT "_%s.%s"
-#define FILE_FUNCTION_FORMAT "_GLOBAL_.D.%s"
-
-#define ANON_AGGRNAME_FORMAT "._%d"
-
-#else /* NO_DOT_IN_LABEL */
-
-#define VPTR_NAME "__vptr"
-#define VPTR_NAME_P(ID_NODE) \
-  (!strncmp (IDENTIFIER_POINTER (ID_NODE), VPTR_NAME, sizeof (VPTR_NAME) - 1))
-#define THROW_NAME "__eh_throw"
-#define DESTRUCTOR_DECL_PREFIX "__destr_"
-#define DESTRUCTOR_NAME_P(ID_NODE) \
-  (!strncmp (IDENTIFIER_POINTER (ID_NODE), DESTRUCTOR_DECL_PREFIX, \
-	     sizeof (DESTRUCTOR_DECL_PREFIX) - 1))
-#define IN_CHARGE_NAME "__in_chrg"
-#define AUTO_VTABLE_NAME "__vtbl_me__"
-#define AUTO_TEMP_NAME "__tmp_"
-#define TEMP_NAME_P(ID_NODE) \
-  (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \
-	     sizeof (AUTO_TEMP_NAME) - 1))
-#define AUTO_TEMP_FORMAT "__tmp_%d"
-#define VTBL_PTR_TYPE "__vtbl_ptr_type"
-#define VTABLE_BASE "__vtb"
-#define VTABLE_NAME_FORMAT "__vt_%s"
-#define VFIELD_BASE "__vfb"
-#define VFIELD_NAME "__vptr_"
-#define VFIELD_NAME_P(ID_NODE) \
-  (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \
-	    sizeof (VFIELD_NAME) - 1))
-#define VFIELD_NAME_FORMAT "_vptr_%s"
-#define VBASE_NAME "__vb_"
-#define VBASE_NAME_P(ID_NODE) \
-  (!strncmp (IDENTIFIER_POINTER (ID_NODE), VBASE_NAME, \
-	     sizeof (VBASE_NAME) - 1))
-#define VBASE_NAME_FORMAT "__vb_%s"
-#define STATIC_NAME_FORMAT "__static_%s_%s"
-#define FILE_FUNCTION_FORMAT "__GLOBAL_D_%s"
-
-#define ANON_AGGRNAME_PREFIX "__anon_"
-#define ANON_AGGRNAME_P(ID_NODE) \
-  (!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \
-	     sizeof (ANON_AGGRNAME_PREFIX) - 1))
-#define ANON_AGGRNAME_FORMAT "__anon_%d"
-#define ANON_PARMNAME_FORMAT "__%d"
-#define ANON_PARMNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == '_' \
-				  && IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
-				  && IDENTIFIER_POINTER (ID_NODE)[2] <= '9')
-
-#endif	/* NO_DOT_IN_LABEL */
-#endif	/* NO_DOLLAR_IN_LABEL */
-
-#define THIS_NAME "this"
-#define DESTRUCTOR_NAME_FORMAT "~%s"
-#define FILE_FUNCTION_PREFIX_LEN 9
-#define VTABLE_DELTA_NAME "delta"
-#define VTABLE_DELTA2_NAME "delta2"
-#define VTABLE_INDEX_NAME "index"
-#define VTABLE_PFN_NAME "pfn"
-#define EXCEPTION_CLEANUP_NAME "exception cleanup"
-
-#define THIS_NAME_P(ID_NODE) (strcmp(IDENTIFIER_POINTER (ID_NODE), "this") == 0)
-
-#if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL)
-
-#define VPTR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \
-			      && IDENTIFIER_POINTER (ID_NODE)[1] == 'v')
-#define DESTRUCTOR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == JOINER)
-
-#define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
-  && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \
-  && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
-
-#define VBASE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \
-  && IDENTIFIER_POINTER (ID_NODE)[2] == 'b' \
-  && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
-
-#define OPERATOR_TYPENAME_P(ID_NODE) \
-  (IDENTIFIER_POINTER (ID_NODE)[0] == '_'	\
-   && IDENTIFIER_POINTER (ID_NODE)[1] == '_'	\
-   && IDENTIFIER_POINTER (ID_NODE)[2] == 'o'	\
-   && IDENTIFIER_POINTER (ID_NODE)[3] == 'p')
-
-#define TEMP_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1))
-#define VFIELD_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
-
-/* For anonymous aggregate types, we need some sort of name to
-   hold on to.  In practice, this should not appear, but it should
-   not be harmful if it does.  */
-#define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \
-				  && IDENTIFIER_POINTER (ID_NODE)[1] == '_')
-#define ANON_PARMNAME_FORMAT "_%d"
-#define ANON_PARMNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == '_' \
-				  && IDENTIFIER_POINTER (ID_NODE)[1] <= '9')
-#endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */
-
-/* Define the sets of attributes that member functions and baseclasses
-   can have.  These are sensible combinations of {public,private,protected}
-   cross {virtual,non-virtual}.  */
-
-enum visibility_type {
-  visibility_default,
-  visibility_public,
-  visibility_private,
-  visibility_protected,
-  visibility_default_virtual,
-  visibility_public_virtual,
-  visibility_private_virtual
-};
-
-/* in cp-lex.c  */
-extern tree current_unit_name, current_unit_language;
-
-/* Things for handling inline functions.  */
-
-struct pending_inline
-{
-  struct pending_inline *next;	/* pointer to next in chain */
-  int lineno;			/* line number we got the text from */
-  char *filename;		/* name of file we were processing */
-  tree fndecl;			/* FUNCTION_DECL that brought us here */
-  int token;			/* token we were scanning */
-  int token_value;		/* value of token we were scanning (YYSTYPE) */
-
-  char *buf;			/* pointer to character stream */
-  int len;			/* length of stream */
-  tree parm_vec, bindings;	/* in case this is derived from a template */
-  unsigned int can_free : 1;	/* free this after we're done with it? */
-  unsigned int deja_vu : 1;	/* set iff we don't want to see it again.  */
-  unsigned int interface : 2;	/* 0=interface 1=unknown 2=implementation */
-};
-
-/* in cp-method.c */
-extern struct pending_inline *pending_inlines;
-
-/* 1 for -fall-virtual: make every member function (except
-   constructors) lay down in the virtual function table.
-   Calls can then either go through the virtual function table or not,
-   depending on whether we know what function will actually be called.  */
-
-extern int flag_all_virtual;
-
-/* Positive values means that we cannot make optimizing assumptions about
-   `this'.  Negative values means we know `this' to be of static type.  */
-
-extern int flag_this_is_variable;
-
-/* Controls whether enums and ints freely convert.
-   1 means with complete freedom.
-   0 means enums can convert to ints, but not vice-versa.  */
-
-extern int flag_int_enum_equivalence;
-
-/* Nonzero means layout structures so that we can do garbage collection.  */
-
-extern int flag_gc;
-
-/* Nonzero means generate 'dossiers' that give run-time type information.  */
-
-extern int flag_dossier;
-
-/* Current end of entries in the gc obstack for stack pointer variables.  */
-
-extern int current_function_obstack_index;
-
-/* Flag saying whether we have used the obstack in this function or not.  */
-
-extern int current_function_obstack_usage;
-
-enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG };
-
-extern tree current_class_decl, C_C_D;	/* PARM_DECL: the class instance variable */
-
-/* The following two can be derived from the previous one */
-extern tree current_class_name;	/* IDENTIFIER_NODE: name of current class */
-extern tree current_class_type;	/* _TYPE: the type of the current class */
-
-/* Some macros for char-based bitfields.  */
-#define B_SET(a,x) (a[x>>3] |= (1 << (x&7)))
-#define B_CLR(a,x) (a[x>>3] &= ~(1 << (x&7)))
-#define B_TST(a,x) (a[x>>3] & (1 << (x&7)))
-
-/* These are uses as bits in flags passed to build_method_call
-   to control its error reporting behavior.
-
-   LOOKUP_PROTECT means flag visibility violations.
-   LOOKUP_COMPLAIN mean complain if no suitable member function
-     matching the arguments is found.
-   LOOKUP_NORMAL is just a combination of these two.
-   LOOKUP_AGGR requires the instance to be of aggregate type.
-   LOOKUP_NONVIRTUAL means make a direct call to the member function found
-   LOOKUP_GLOBAL means search through the space of overloaded functions,
-     rather than the space of member functions.
-   LOOKUP_HAS_IN_CHARGE means that the "in charge" variable is already
-     in the parameter list.
-   LOOKUP_PROTECTED_OK means that even if the constructor we find appears
-     to be non-visible to current scope, call it anyway.
-   LOOKUP_NO_CONVERSION means that user-defined conversions are not
-     permitted.  Built-in conversions are permitted.
-   LOOKUP_DESTRUCTOR means explicit call to destructor.  */
-
-#define LOOKUP_PROTECT (1)
-#define LOOKUP_COMPLAIN (2)
-#define LOOKUP_NORMAL (3)
-#define LOOKUP_AGGR (4)
-#define LOOKUP_NONVIRTUAL (8)
-#define LOOKUP_GLOBAL (16)
-#define LOOKUP_HAS_IN_CHARGE (32)
-#define LOOKUP_SPECULATIVELY (64)
-#define LOOKUP_PROTECTED_OK (128)
-/* 256 is free */
-#define LOOKUP_NO_CONVERSION (512)
-#define LOOKUP_DESTRUCTOR (512)
-
-/* Anatomy of a DECL_FRIENDLIST (which is a TREE_LIST):
-   purpose = friend name (IDENTIFIER_NODE);
-   value = TREE_LIST of FUNCTION_DECLS;
-   chain, type = EMPTY;  */
-#define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
-#define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
-
-/* These macros are for accessing the fields of TEMPLATE...PARM nodes.  */
-#define TEMPLATE_TYPE_TPARMLIST(NODE) TREE_PURPOSE (TYPE_FIELDS (NODE))
-#define TEMPLATE_TYPE_IDX(NODE) TREE_INT_CST_LOW (TREE_VALUE (TYPE_FIELDS (NODE)))
-#define TEMPLATE_TYPE_SET_INFO(NODE,P,I) \
-  (TYPE_FIELDS (NODE) = build_tree_list (P, build_int_2 (I, 0)))
-#define TEMPLATE_CONST_TPARMLIST(NODE) (*(tree*)&TREE_INT_CST_LOW(NODE))
-#define TEMPLATE_CONST_IDX(NODE) (TREE_INT_CST_HIGH(NODE))
-#define TEMPLATE_CONST_SET_INFO(NODE,P,I) \
-  (TEMPLATE_CONST_TPARMLIST (NODE) = saved_parmlist, \
-   TEMPLATE_CONST_IDX (NODE) = I)
-
-/* in cp-lex.c  */
-/* Indexed by TREE_CODE, these tables give C-looking names to
-   operators represented by TREE_CODES.  For example,
-   opname_tab[(int) MINUS_EXPR] == "-".  */
-extern char **opname_tab, **assignop_tab;
-
-/* in cp-call.c */
-extern int rank_for_overload			PROTO((struct candidate *, struct candidate *));
-extern void compute_conversion_costs		PROTO((tree, tree, struct candidate *, int));
-extern int get_arglist_len_in_bytes		PROTO((tree));
-extern tree build_vfield_ref			PROTO((tree, tree));
-extern tree find_scoped_type			PROTO((tree, tree, tree));
-extern tree resolve_scope_to_name		PROTO((tree, tree));
-extern tree build_scoped_method_call		PROTO((tree, tree, tree, tree));
-extern tree build_method_call			PROTO((tree, tree, tree, tree, int));
-extern tree build_overload_call_real		PROTO((tree, tree, int, struct candidate *, int));
-extern tree build_overload_call			PROTO((tree, tree, int, struct candidate *));
-extern tree build_overload_call_maybe		PROTO((tree, tree, int, struct candidate *));
-
-/* in cp-class.c */
-extern tree build_vbase_pointer			PROTO((tree, tree));
-extern tree build_vbase_path			PROTO((enum tree_code, tree, tree, tree, int));
-extern tree build_vtable_entry			PROTO((tree, tree));
-extern tree build_vfn_ref			PROTO((tree *, tree, tree));
-extern void add_method				PROTO((tree, tree *, tree));
-extern void duplicate_tag_error			PROTO((tree));
-extern tree finish_struct			PROTO((tree, tree, int));
-extern int resolves_to_fixed_type_p		PROTO((tree, int *));
-extern void init_class_processing		PROTO((void));
-extern void pushclass				PROTO((tree, int));
-extern void popclass				PROTO((int));
-extern void push_lang_context			PROTO((tree));
-extern void pop_lang_context			PROTO((void));
-extern int root_lang_context_p			PROTO((void));
-extern tree instantiate_type			PROTO((tree, tree, int));
-extern void print_class_statistics		PROTO((void));
-
-/* in cp-cvt.c */
-extern tree convert_to_reference		PROTO((tree, tree, tree, tree, int, char *, int, int));
-extern tree convert_from_reference		PROTO((tree));
-extern tree convert_to_aggr			PROTO((tree, tree, char **, int));
-extern tree convert_pointer_to			PROTO((tree, tree));
-extern tree convert_pointer_to_vbase		PROTO((tree, tree));
-extern tree convert				PROTO((tree, tree));
-extern tree convert_force			PROTO((tree, tree));
-extern tree build_type_conversion		PROTO((enum tree_code, tree, tree, int));
-extern int build_default_binary_type_conversion	PROTO((enum tree_code, tree *, tree *));
-extern int build_default_unary_type_conversion	PROTO((enum tree_code, tree *));
-
-/* cp-decl.c */
-#ifdef PARANOID
-extern void binding_levels_sane			PROTO((void));
-#endif
-extern int global_bindings_p			PROTO((void));
-extern void keep_next_level			PROTO((void));
-extern int kept_level_p				PROTO((void));
-extern void declare_parm_level			PROTO((void));
-extern void declare_implicit_exception		PROTO((void));
-extern int have_exceptions_p			PROTO((void));
-extern void declare_uninstantiated_type_level	PROTO((void));
-extern int uninstantiated_type_level_p		PROTO((void));
-extern void declare_pseudo_global_level		PROTO((void));
-extern int pseudo_global_level_p		PROTO((void));
-extern void pushlevel				PROTO((int));
-extern void pushlevel_temporary			PROTO((int));
-extern tree poplevel				PROTO((int, int, int));
-extern void delete_block			PROTO((tree));
-extern void insert_block			PROTO((tree));
-extern void add_block_current_level		PROTO((tree));
-extern void set_block				PROTO((tree));
-extern void pushlevel_class			PROTO((void));
-extern tree poplevel_class			PROTO((void));
-/* skip print_other_binding_stack and print_binding_level */
-extern void print_binding_stack			PROTO((void));
-extern void push_to_top_level			PROTO((void));
-extern void pop_from_top_level			PROTO((void));
-extern void set_identifier_type_value		PROTO((tree, tree));
-extern void set_identifier_local_value		PROTO((tree, tree));
-extern tree make_type_decl			PROTO((tree, tree));
-extern void pushtag				PROTO((tree, tree));
-extern tree make_anon_name			PROTO((void));
-extern void clear_anon_tags			PROTO((void));
-extern void adjust_type_value			PROTO((tree));
-extern tree pushdecl				PROTO((tree));
-extern tree pushdecl_top_level			PROTO((tree));
-extern void push_overloaded_decl_top_level	PROTO((tree, int));
-extern tree pushdecl_class_level		PROTO((tree));
-extern int overloaded_globals_p			PROTO((tree));
-extern tree push_overloaded_decl		PROTO((tree, int));
-extern tree implicitly_declare			PROTO((tree));
-extern tree lookup_label			PROTO((tree));
-extern tree shadow_label			PROTO((tree));
-extern tree define_label			PROTO((char *, int, tree));
-extern void define_case_label			PROTO((tree));
-extern tree getdecls				PROTO((void));
-extern tree gettags				PROTO((void));
-extern void set_current_level_tags_transparency	PROTO((int));
-extern tree typedecl_for_tag			PROTO((tree));
-extern tree lookup_name				PROTO((tree, int));
-extern tree lookup_name_current_level		PROTO((tree));
-extern void init_decl_processing		PROTO((void));
-/* skipped define_function */
-extern void shadow_tag				PROTO((tree));
-extern void grok_ctor_properties		PROTO((tree, tree));
-extern tree groktypename			PROTO((tree));
-extern tree start_decl				PROTO((tree, tree, int, tree));
-extern void finish_decl				PROTO((tree, tree, tree, int));
-extern int complete_array_type			PROTO((tree, tree, int));
-extern tree grokdeclarator			(); /* PROTO((tree, tree, enum decl_context, int, tree)); */
-extern tree xref_defn_tag			PROTO((tree, tree, tree));
-extern tree xref_tag				PROTO((tree, tree, tree));
-extern tree start_enum				PROTO((tree));
-extern tree finish_enum				PROTO((tree, tree));
-extern tree build_enumerator			PROTO((tree, tree));
-extern tree grok_enum_decls			PROTO((tree, tree));
-extern int start_function			PROTO((tree, tree, tree, int));
-extern void store_parm_decls			PROTO((void));
-extern void store_return_init			PROTO((tree, tree));
-extern void finish_function			PROTO((int, int));
-extern tree start_method			PROTO((tree, tree, tree));
-extern tree finish_method			PROTO((tree));
-extern void hack_incomplete_structures		PROTO((tree));
-extern tree maybe_build_cleanup			PROTO((tree));
-extern void cplus_expand_expr_stmt		PROTO((tree));
-extern void finish_stmt				PROTO((void));
-extern void pop_implicit_try_blocks		PROTO((tree));
-extern void push_exception_cleanup		PROTO((tree));
-extern void revert_static_member_fn		PROTO((tree *, tree *, tree *));
-
-/* in cp-decl2.c */
-extern int lang_decode_option			PROTO((char *));
-extern tree grok_method_quals			PROTO((tree, tree, tree));
-extern void grokclassfn				PROTO((tree, tree, tree, enum overload_flags, tree));
-extern void bad_specifiers			PROTO((char *, int, int, int, int));
-extern void check_classfn			PROTO((tree, tree, tree));
-extern tree grokfield				PROTO((tree, tree, tree, tree, tree));
-extern tree grokbitfield			PROTO((tree, tree, tree));
-extern tree groktypefield			PROTO((tree, tree));
-extern tree grokoptypename			PROTO((tree, int));
-extern tree build_push_scope			PROTO((tree, tree));
-extern tree constructor_name			PROTO((tree));
-extern void setup_vtbl_ptr			PROTO((void));
-extern void mark_inline_for_output		PROTO((tree));
-extern void clear_temp_name			PROTO((void));
-extern tree get_temp_name			PROTO((tree, int));
-extern tree get_temp_regvar			PROTO((tree, tree));
-extern void finish_anon_union			PROTO((tree));
-extern tree finish_table			PROTO((tree, tree, tree, int));
-extern void finish_builtin_type			PROTO((tree, char *, tree *, int, tree));
-extern tree coerce_new_type			PROTO((tree));
-extern tree coerce_delete_type			PROTO((tree));
-extern void walk_vtables			PROTO((void (*)(), void (*)()));
-extern void finish_file				PROTO((void));
-
-/* in cp-dem.c */
-extern char *cplus_demangle			PROTO((char *));
-
-/* in cp-edsel.c */
-
-/* in cp-except.c */
-extern tree lookup_exception_cname		PROTO((tree, tree, tree));
-extern tree lookup_exception_tname		PROTO((tree));
-extern tree lookup_exception_object		PROTO((tree, tree, int));
-extern tree lookup_exception_type		PROTO((tree, tree, tree));
-extern tree finish_exception			PROTO((tree, tree));
-extern void finish_exception_decl		PROTO((tree, tree));
-extern void end_exception_decls			PROTO((void));
-extern void cplus_expand_start_try		PROTO((int));
-extern tree cplus_expand_end_try		PROTO((int));
-extern void cplus_expand_start_except		PROTO((tree, tree));
-extern void cplus_expand_end_except		PROTO((tree));
-extern void cplus_expand_raise			PROTO((tree, tree, tree, int));
-extern tree ansi_exception_object_lookup	PROTO((tree));
-extern void cplus_expand_throw			PROTO((tree));
-extern tree cplus_expand_start_catch		PROTO((tree));
-extern tree ansi_expand_start_catch		PROTO((tree));
-extern void cplus_expand_end_catch		PROTO((int));
-extern void cplus_expand_reraise		PROTO((tree));
-extern void setup_exception_throw_decl		PROTO((void));
-extern void init_exception_processing		PROTO((void));
-extern void init_exception_processing_1		PROTO((void));
-
-/* in cp-expr.c */
-/* skip cplus_expand_expr */
-extern void init_cplus_expand			PROTO((void));
-extern void fixup_result_decl			PROTO((tree, struct rtx_def *));
-extern int decl_in_memory_p			PROTO((tree));
-
-/* in cp-gc.c */
-extern int type_needs_gc_entry			PROTO((tree));
-extern int value_safe_from_gc			PROTO((tree, tree));
-extern void build_static_gc_entry		PROTO((tree, tree));
-extern tree protect_value_from_gc		PROTO((tree, tree));
-extern tree build_headof			PROTO((tree));
-extern tree build_classof			PROTO((tree));
-extern tree build_t_desc			PROTO((tree, int));
-extern tree build_i_desc			PROTO((tree));
-extern tree build_m_desc			PROTO((tree));
-extern void expand_gc_prologue_and_epilogue	PROTO((void));
-extern void lang_expand_end_bindings		PROTO((struct rtx_def *, struct rtx_def *));
-extern void init_gc_processing			PROTO((void));
-
-/* in cp-init.c */
-extern void emit_base_init			PROTO((tree, int));
-extern void check_base_init			PROTO((tree));
-extern tree build_virtual_init			PROTO((tree, tree, tree));
-extern void do_member_init			PROTO((tree, tree, tree));
-extern void expand_member_init			PROTO((tree, tree, tree));
-extern void expand_aggr_init			PROTO((tree, tree, int));
-extern int is_aggr_typedef			PROTO((tree, int));
-extern tree build_member_call			PROTO((tree, tree, tree));
-extern tree build_offset_ref			PROTO((tree, tree));
-extern tree get_member_function			PROTO((tree *, tree, tree));
-extern tree resolve_offset_ref			PROTO((tree));
-extern tree decl_constant_value			PROTO((tree));
-extern int is_friend				PROTO((tree, tree));
-extern void xref_friend				PROTO((tree, tree, tree));
-extern void xref_friends			PROTO((tree, tree, tree));
-extern void make_friend_class			PROTO((tree, tree));
-extern tree do_friend				PROTO((tree, tree, tree, tree, enum overload_flags, tree));
-extern void embrace_waiting_friends		PROTO((tree));
-extern tree build_builtin_call			PROTO((tree, tree, tree));
-extern tree build_new				PROTO((tree, tree, tree, int));
-extern tree expand_vec_init			PROTO((tree, tree, tree, tree, int));
-extern tree build_x_delete			PROTO((tree, tree, int, tree));
-extern tree build_delete			PROTO((tree, tree, tree, int, int, int));
-extern tree build_vbase_delete			PROTO((tree, tree));
-extern tree build_vec_delete			PROTO((tree, tree, tree, tree, tree, tree));
-
-/* in cp-input.c */
-
-/* in cp-lex.c */
-extern tree make_pointer_declarator		PROTO((tree, tree));
-extern tree make_reference_declarator		PROTO((tree, tree));
-extern char *operator_name_string		PROTO((tree));
-extern void lang_init				PROTO((void));
-extern void lang_finish				PROTO((void));
-extern void init_filename_times			PROTO((void));
-extern void reinit_lang_specific		PROTO((void));
-extern void init_lex				PROTO((void));
-extern void reinit_parse_for_function		PROTO((void));
-extern int *init_parse				PROTO((void));
-extern void print_parse_statistics		PROTO((void));
-extern void extract_interface_info		PROTO((void));
-extern void set_vardecl_interface_info		PROTO((tree, tree));
-extern void do_pending_inlines			PROTO((void));
-extern void process_next_inline			PROTO((tree));
-#if 0
-extern void consume_string			PROTO((struct obstack *));
-#endif
-/* skip restore_pending_input */
-extern void yyungetc				PROTO((int, int));
-extern void reinit_parse_for_method		PROTO((int, tree));
-#if 0
-extern void reinit_parse_for_block		PROTO((int, struct obstack *, int));
-#endif
-extern tree cons_up_default_function		PROTO((tree, tree, int));
-extern void check_for_missing_semicolon		PROTO((tree));
-extern void note_got_semicolon			PROTO((tree));
-extern void note_list_got_semicolon		PROTO((tree));
-extern int check_newline			PROTO((void));
-extern void dont_see_typename			PROTO((void));
-extern int identifier_type			PROTO((tree));
-extern void see_typename			PROTO((void));
-extern tree do_identifier			PROTO((tree));
-extern tree identifier_typedecl_value		PROTO((tree));
-extern int real_yylex				PROTO((void));
-extern tree build_lang_decl			PROTO((enum tree_code, tree, tree));
-extern tree build_lang_field_decl		PROTO((enum tree_code, tree, tree));
-extern void copy_lang_decl			PROTO((tree));
-extern tree make_lang_type			PROTO((enum tree_code));
-extern void copy_decl_lang_specific		PROTO((tree));
-extern void dump_time_statistics		PROTO((void));
-/* extern void compiler_error			PROTO((char *, HOST_WIDE_INT, HOST_WIDE_INT)); */
-extern void compiler_error_with_decl		PROTO((tree, char *));
-extern void yyerror				PROTO((char *));
-
-/* in cp-method.c */
-extern void init_method				PROTO((void));
-extern tree make_anon_parm_name			PROTO((void));
-extern void clear_anon_parm_name		PROTO((void));
-extern char *fndecl_as_string			PROTO((tree, tree, int));
-extern char *type_as_string			PROTO((tree));
-extern char *decl_as_string			PROTO((tree));
-extern void do_inline_function_hair		PROTO((tree, tree));
-/* skip report_type_mismatch */
-extern char *build_overload_name		PROTO((tree, int, int));
-extern tree cplus_exception_name		PROTO((tree));
-extern tree build_decl_overload			PROTO((tree, tree, int));
-extern tree build_typename_overload		PROTO((tree));
-extern tree build_t_desc_overload		PROTO((tree));
-extern void declare_overloaded			PROTO((tree));
-#ifdef NO_AUTO_OVERLOAD
-extern int is_overloaded			PROTO((tree));
-#endif
-extern tree build_opfncall			PROTO((enum tree_code, int, tree, tree, tree));
-extern tree hack_identifier			PROTO((tree, tree, int));
-extern tree build_component_type_expr		PROTO((tree, tree, tree, int));
-
-/* in cp-pt.c */
-extern void begin_template_parm_list		PROTO((void));
-extern tree process_template_parm		PROTO((tree, tree));
-extern tree end_template_parm_list		PROTO((tree));
-extern void end_template_decl			PROTO((tree, tree, tree));
-extern tree lookup_template_class		PROTO((tree, tree, tree));
-extern void push_template_decls			PROTO((tree, tree, int));
-extern void pop_template_decls			PROTO((tree, tree, int));
-extern int uses_template_parms			PROTO((tree));
-extern void instantiate_member_templates	PROTO((tree));
-extern tree instantiate_class_template		PROTO((tree, int));
-extern tree instantiate_template		PROTO((tree, tree *));
-extern void undo_template_name_overload		PROTO((tree, int));
-extern void overload_template_name		PROTO((tree, int));
-extern void end_template_instantiation		PROTO((tree, tree));
-extern void reinit_parse_for_template		PROTO((int, tree, tree));
-extern int type_unification			PROTO((tree, tree *, tree, tree, int *));
-extern int do_pending_expansions		PROTO((void));
-extern void do_pending_templates		PROTO((void));
-
-/* in cp-search.c */
-extern tree make_memoized_table_entry		PROTO((tree, tree, int));
-extern void push_memoized_context		PROTO((tree, int));
-extern void pop_memoized_context		PROTO((int));
-extern tree get_binfo				PROTO((tree, tree, int));
-extern int get_base_distance			PROTO((tree, tree, int, tree *));
-extern enum visibility_type check_visibility	PROTO((tree, tree));
-extern tree lookup_field			PROTO((tree, tree, int, int));
-extern tree lookup_nested_field			PROTO((tree, int));
-extern tree lookup_fnfields			PROTO((tree, tree, int));
-extern HOST_WIDE_INT breadth_first_search	PROTO((tree, int (*)(), int (*)()));
-extern int tree_needs_constructor_p		PROTO((tree, int));
-extern int tree_has_any_destructor_p		PROTO((tree, int));
-extern tree get_first_matching_virtual		PROTO((tree, tree, int));
-extern tree get_abstract_virtuals		PROTO((tree));
-extern tree get_baselinks			PROTO((tree, tree, tree));
-extern tree next_baselink			PROTO((tree));
-extern tree init_vbase_pointers			PROTO((tree, tree));
-extern tree build_vbase_vtables_init		PROTO((tree, tree, tree, tree, int));
-extern void clear_search_slots			PROTO((tree));
-extern tree get_vbase_types			PROTO((tree));
-extern void build_mi_matrix			PROTO((tree));
-extern void free_mi_matrix			PROTO((void));
-extern void build_mi_virtuals			PROTO((int, int));
-extern void add_mi_virtuals			PROTO((int, tree));
-extern void report_ambiguous_mi_virtuals	PROTO((int, tree));
-extern void note_debug_info_needed		PROTO((tree));
-extern void push_class_decls			PROTO((tree));
-extern void pop_class_decls			PROTO((tree));
-extern tree build_type_pathname			PROTO((char *, tree, tree));
-extern void unmark_finished_struct		PROTO((tree));
-extern void print_search_statistics		PROTO((void));
-extern void init_search_processing		PROTO((void));
-extern void reinit_search_statistics		PROTO((void));
-
-/* in cp-spew.c */
-extern void init_spew				PROTO((void));
-extern int yylex				PROTO((void));
-extern tree arbitrate_lookup			PROTO((tree, tree, tree));
-
-/* in cp-tree.c */
-extern int lvalue_p				PROTO((tree));
-extern int lvalue_or_else			PROTO((tree, char *));
-extern tree build_cplus_new			PROTO((tree, tree, int));
-extern tree break_out_cleanups			PROTO((tree));
-extern tree break_out_calls			PROTO((tree));
-extern tree build_cplus_method_type		PROTO((tree, tree, tree));
-extern tree build_cplus_staticfn_type		PROTO((tree, tree, tree));
-extern tree build_cplus_array_type		PROTO((tree, tree));
-extern void propagate_binfo_offsets		PROTO((tree, tree));
-extern int layout_vbasetypes			PROTO((tree, int));
-extern tree layout_basetypes			PROTO((tree, tree));
-extern int list_hash				PROTO((tree));
-extern tree list_hash_lookup			PROTO((int, tree));
-extern void list_hash_add			PROTO((int, tree));
-extern tree list_hash_canon			PROTO((int, tree));
-extern tree hash_tree_cons			PROTO((int, int, int, tree, tree, tree));
-extern tree hash_tree_chain			PROTO((tree, tree));
-extern tree hash_chainon			PROTO((tree, tree));
-extern tree get_decl_list			PROTO((tree));
-extern tree list_hash_lookup_or_cons		PROTO((tree));
-extern tree make_binfo				PROTO((tree, tree, tree, tree, tree));
-extern tree copy_binfo				PROTO((tree));
-extern tree binfo_value				PROTO((tree, tree));
-extern tree reverse_path			PROTO((tree));
-extern tree virtual_member			PROTO((tree, tree));
-extern tree virtual_offset			PROTO((tree, tree, tree));
-extern void debug_binfo				PROTO((tree));
-extern int decl_list_length			PROTO((tree));
-extern tree fnaddr_from_vtable_entry		PROTO((tree));
-extern void set_fnaddr_from_vtable_entry	PROTO((tree, tree));
-extern tree function_arg_chain			PROTO((tree));
-extern int promotes_to_aggr_type		PROTO((tree, enum tree_code));
-extern int is_aggr_type_2			PROTO((tree, tree));
-extern void message_2_types			PROTO((void (*)(), char *, tree, tree));
-extern char *lang_printable_name		PROTO((tree));
-extern tree build_exception_variant		PROTO((tree, tree, tree));
-extern tree copy_to_permanent			PROTO((tree));
-extern void print_lang_statistics		PROTO((void));
-/* skip __eprintf */
-extern tree array_type_nelts_total		PROTO((tree));
-extern tree array_type_nelts_top		PROTO((tree));
-
-/* in cp-typeck.c */
-extern tree target_type				PROTO((tree));
-extern tree require_complete_type		PROTO((tree));
-extern int type_unknown_p			PROTO((tree));
-extern tree require_instantiated_type		PROTO((tree, tree, tree));
-extern tree commonparms				PROTO((tree, tree));
-extern tree common_type				PROTO((tree, tree));
-extern int compexcepttypes			PROTO((tree, tree, int));
-extern int comptypes				PROTO((tree, tree, int));
-extern int comp_target_types			PROTO((tree, tree, int));
-extern tree common_base_types			PROTO((tree, tree));
-extern int compparms				PROTO((tree, tree, int));
-extern int comp_target_types			PROTO((tree, tree, int));
-extern tree unsigned_type			PROTO((tree));
-extern tree signed_type				PROTO((tree));
-extern tree signed_or_unsigned_type		PROTO((int, tree));
-extern tree c_sizeof				PROTO((tree));
-extern tree c_sizeof_nowarn			PROTO((tree));
-extern tree c_alignof				PROTO((tree));
-extern tree default_conversion			PROTO((tree));
-extern tree build_component_ref_1		PROTO((tree, tree, int));
-extern tree build_component_ref			PROTO((tree, tree, tree, int));
-extern tree build_x_indirect_ref		PROTO((tree, char *));
-extern tree build_indirect_ref			PROTO((tree, char *));
-extern tree build_x_array_ref			PROTO((tree, tree));
-extern tree build_array_ref			PROTO((tree, tree));
-extern tree build_x_function_call		PROTO((tree, tree, tree));
-extern tree build_function_call_real		PROTO((tree, tree, int));
-extern tree build_function_call			PROTO((tree, tree));
-extern tree build_function_call_maybe		PROTO((tree, tree));
-extern tree convert_arguments			PROTO((tree, tree, tree, tree, int));
-extern tree build_x_binary_op			PROTO((enum tree_code, tree, tree));
-extern tree build_binary_op			PROTO((enum tree_code, tree, tree, int));
-extern tree build_binary_op_nodefault		PROTO((enum tree_code, tree, tree, enum tree_code));
-extern tree build_component_addr		PROTO((tree, tree, char *));
-extern tree build_x_unary_op			PROTO((enum tree_code, tree));
-extern tree build_unary_op			PROTO((enum tree_code, tree, int));
-extern tree unary_complex_lvalue		PROTO((enum tree_code, tree));
-extern int mark_addressable			PROTO((tree));
-extern tree build_x_conditional_expr		PROTO((tree, tree, tree));
-extern tree build_conditional_expr		PROTO((tree, tree, tree));
-extern tree build_x_compound_expr		PROTO((tree));
-extern tree build_compound_expr			PROTO((tree));
-extern tree build_c_cast			PROTO((tree, tree));
-extern tree build_modify_expr			PROTO((tree, enum tree_code, tree));
-extern int language_lvalue_valid		PROTO((tree));
-extern void warn_for_assignment			PROTO((char *, char *, char *, tree, int, int));
-extern tree convert_for_initialization		PROTO((tree, tree, tree, int, char *, tree, int));
-extern void c_expand_asm_operands		PROTO((tree, tree, tree, tree, int, char *, int));
-extern void c_expand_return			PROTO((tree));
-extern tree c_expand_start_case			PROTO((tree));
-extern void record_format_info			PROTO((tree, int, int, int));
-extern tree build_component_ref			PROTO((tree, tree, tree, int));
-
-/* in cp-type2.c */
-extern tree error_not_base_type			PROTO((tree, tree));
-extern tree binfo_or_else			PROTO((tree, tree));
-extern void error_with_aggr_type		(); /* PROTO((tree, char *, HOST_WIDE_INT)); */
-extern void readonly_error			PROTO((tree, char *, int));
-extern void abstract_virtuals_error		PROTO((tree, tree));
-extern void incomplete_type_error		PROTO((tree, tree));
-extern void my_friendly_abort			PROTO((int));
-extern void my_friendly_assert			PROTO((int, int));
-extern tree store_init_value			PROTO((tree, tree));
-extern tree digest_init				PROTO((tree, tree, tree *));
-extern tree build_scoped_ref			PROTO((tree, tree));
-extern tree build_x_arrow			PROTO((tree));
-extern tree build_m_component_ref		PROTO((tree, tree));
-extern tree build_functional_cast		PROTO((tree, tree));
-extern char *enum_name_string			PROTO((tree, tree));
-extern void report_case_error			PROTO((int, tree, tree, tree));
-
-/* in cp-xref.c */
-extern void GNU_xref_begin			PROTO((char *));
-extern void GNU_xref_end			PROTO((int));
-extern void GNU_xref_file			PROTO((char *));
-extern void GNU_xref_start_scope		PROTO((HOST_WIDE_INT));
-extern void GNU_xref_end_scope			PROTO((HOST_WIDE_INT, HOST_WIDE_INT, int, int, int));
-extern void GNU_xref_def			PROTO((tree, char *));
-extern void GNU_xref_decl			PROTO((tree, tree));
-extern void GNU_xref_call			PROTO((tree, char *));
-extern void GNU_xref_function			PROTO((tree, tree));
-extern void GNU_xref_assign			PROTO((tree));
-extern void GNU_xref_hier			PROTO((char *, char *, int, int, int));
-extern void GNU_xref_member			PROTO((tree, tree));
-
-/* -- end of C++ */
diff --git a/gnu/gcc2/cc1plus/cp-type2.c b/gnu/gcc2/cc1plus/cp-type2.c
deleted file mode 100644
index eaa009e84114..000000000000
--- a/gnu/gcc2/cc1plus/cp-type2.c
+++ /dev/null
@@ -1,1635 +0,0 @@
-/* Report error messages, build initializers, and perform
-   some front-end optimizations for C++ compiler.
-   Copyright (C) 1987, 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* This file is part of the C++ front end.
-   It contains routines to build C++ expressions given their operands,
-   including computing the types of the result, C and C++ specific error
-   checks, and some optimization.
-
-   There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
-   and to process initializations in declarations (since they work
-   like a strange sort of assignment).  */
-
-#include "config.h"
-#include <stdio.h>
-#include "tree.h"
-#include "cp-tree.h"
-#include "flags.h"
-
-static tree process_init_constructor ();
-extern void pedwarn (), error ();
-
-extern int errorcount;
-extern int sorrycount;
-
-/* Print an error message stemming from an attempt to use
-   BASETYPE as a base class for TYPE.  */
-tree
-error_not_base_type (basetype, type)
-     tree basetype, type;
-{
-  tree name1;
-  tree name2;
-  if (TREE_CODE (basetype) == FUNCTION_DECL)
-    basetype = DECL_CLASS_CONTEXT (basetype);
-  name1 = TYPE_NAME (basetype);
-  name2 = TYPE_NAME (type);
-  if (TREE_CODE (name1) == TYPE_DECL)
-    name1 = DECL_NAME (name1);
-  if (TREE_CODE (name2) == TYPE_DECL)
-    name2 = DECL_NAME (name2);
-  error ("type `%s' is not a base type for type `%s'",
-	 IDENTIFIER_POINTER (name1), IDENTIFIER_POINTER (name2));
-  return error_mark_node;
-}
-
-tree
-binfo_or_else (parent_or_type, type)
-     tree parent_or_type, type;
-{
-  tree binfo;
-  if (TYPE_MAIN_VARIANT (parent_or_type) == TYPE_MAIN_VARIANT (type))
-    return parent_or_type;
-  if (binfo = get_binfo (parent_or_type, TYPE_MAIN_VARIANT (type), 0))
-    {
-      if (binfo == error_mark_node)
-	return NULL_TREE;
-      return binfo;
-    }
-  error_not_base_type (parent_or_type, type);
-  return NULL_TREE;
-}
-
-/* Print an error message stemming from an invalid use of an
-   aggregate type.
-
-   TYPE is the type or binfo which draws the error.
-   MSG is the message to print.
-   ARG is an optional argument which may provide more information.  */
-void
-error_with_aggr_type (type, msg, arg)
-     tree type;
-     char *msg;
-     HOST_WIDE_INT arg;
-{
-  tree name;
-
-  if (TREE_CODE (type) == TREE_VEC)
-    type = BINFO_TYPE (type);
-
-  name = TYPE_NAME (type);
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-  error (msg, IDENTIFIER_POINTER (name), arg);
-}
-
-/* According to ARM $7.1.6, "A `const' object may be initialized, but its
-   value may not be changed thereafter.  Thus, we emit hard errors for these,
-   rather than just pedwarns.  If `SOFT' is 1, then we just pedwarn.  (For
-   example, conversions to references.)  */
-void
-readonly_error (arg, string, soft)
-     tree arg;
-     char *string;
-     int soft;
-{
-  char *fmt;
-  void (*fn)();
-
-  if (soft)
-    fn = pedwarn;
-  else
-    fn = error;
-
-  if (TREE_CODE (arg) == COMPONENT_REF)
-    {
-      if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
-        fmt = "%s of member `%s' in read-only structure";
-      else
-        fmt = "%s of read-only member `%s'";
-      (*fn) (fmt, string, lang_printable_name (TREE_OPERAND (arg, 1)));
-    }
-  else if (TREE_CODE (arg) == VAR_DECL)
-    {
-      if (DECL_LANG_SPECIFIC (arg)
-	  && DECL_IN_AGGR_P (arg)
-	  && !TREE_STATIC (arg))
-	fmt = "%s of constant field `%s'";
-      else
-	fmt = "%s of read-only variable `%s'";
-      (*fn) (fmt, string, lang_printable_name (arg));
-    }
-  else if (TREE_CODE (arg) == PARM_DECL)
-    (*fn) ("%s of read-only parameter `%s'", string,
-	   lang_printable_name (arg));
-  else if (TREE_CODE (arg) == INDIRECT_REF
-           && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
-           && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
-               || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
-    (*fn) ("%s of read-only reference `%s'",
-	   string, lang_printable_name (TREE_OPERAND (arg, 0)));
-  else	       
-    (*fn) ("%s of read-only location", string);
-}
-
-/* Print an error message for invalid use of a type which declares
-   virtual functions which are not inheritable.  */
-void
-abstract_virtuals_error (decl, type)
-     tree decl;
-     tree type;
-{
-  char *typename = TYPE_NAME_STRING (type);
-  tree u = CLASSTYPE_ABSTRACT_VIRTUALS (type);
-
-  if (decl)
-    {
-      if (TREE_CODE (decl) == RESULT_DECL)
-	return;
-
-      if (TREE_CODE (decl) == VAR_DECL)
-	error_with_decl (decl, "cannot declare variable `%s' to be of type `%s'", typename);
-      else if (TREE_CODE (decl) == PARM_DECL)
-	error_with_decl (decl, "cannot declare parameter `%s' to be of type `%s'", typename);
-      else if (TREE_CODE (decl) == FIELD_DECL)
-	error_with_decl (decl, "cannot declare field `%s' to be of type `%s'", typename);
-      else if (TREE_CODE (decl) == FUNCTION_DECL
-	       && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
-	error_with_decl (decl, "invalid return type for method `%s'");
-      else if (TREE_CODE (decl) == FUNCTION_DECL)
-	error_with_decl (decl, "invalid return type for function `%s'");
-    }
-  else error ("cannot allocate an object of type `%s'", typename);
-  /* Only go through this once.  */
-  if (TREE_PURPOSE (u) == NULL_TREE)
-    {
-      error ("  since the following virtual functions are abstract:");
-      TREE_PURPOSE (u) = error_mark_node;
-      while (u)
-	{
-	  error_with_decl (TREE_VALUE (u), "\t%s");
-	  u = TREE_CHAIN (u);
-	}
-    }
-  else error ("  since type `%s' has abstract virtual functions", typename);
-}
-
-/* Print an error message for invalid use of an incomplete type.
-   VALUE is the expression that was used (or 0 if that isn't known)
-   and TYPE is the type that was invalid.  */
-
-void
-incomplete_type_error (value, type)
-     tree value;
-     tree type;
-{
-  char *errmsg;
-
-  /* Avoid duplicate error message.  */
-  if (TREE_CODE (type) == ERROR_MARK)
-    return;
-
-  if (value != 0 && (TREE_CODE (value) == VAR_DECL
-		     || TREE_CODE (value) == PARM_DECL))
-    error ("`%s' has an incomplete type",
-	   IDENTIFIER_POINTER (DECL_NAME (value)));
-  else
-    {
-    retry:
-      /* We must print an error message.  Be clever about what it says.  */
-
-      switch (TREE_CODE (type))
-	{
-	case RECORD_TYPE:
-	  errmsg = "invalid use of undefined type `struct %s'";
-	  break;
-
-	case UNION_TYPE:
-	  errmsg = "invalid use of undefined type `union %s'";
-	  break;
-
-	case ENUMERAL_TYPE:
-	  errmsg = "invalid use of undefined type `enum %s'";
-	  break;
-
-	case VOID_TYPE:
-	  error ("invalid use of void expression");
-	  return;
-
-	case ARRAY_TYPE:
-	  if (TYPE_DOMAIN (type))
-	    {
-	      type = TREE_TYPE (type);
-	      goto retry;
-	    }
-	  error ("invalid use of array with unspecified bounds");
-	  return;
-
-	case OFFSET_TYPE:
-	  error ("invalid use of member type (did you forget the `&' ?)");
-	  return;
-
-	default:
-	  my_friendly_abort (108);
-	}
-
-      error_with_aggr_type (type, errmsg);
-    }
-}
-
-/* There are times when the compiler can get very confused, confused
-   to the point of giving up by aborting, simply because of previous
-   input errors.  It is much better to have the user go back and
-   correct those errors first, and see if it makes us happier, than it
-   is to abort on him.  This is because when one has a 10,000 line
-   program, and the compiler comes back with ``core dump'', the user
-   is left not knowing even where to begin to fix things and no place
-   to even try and work around things.
-
-   The parameter is to uniquely identify the problem to the user, so
-   that they can say, I am having problem 59, and know that fix 7 will
-   probably solve their problem.  Or, we can document what problem
-   59 is, so they can understand how to work around it, should they
-   ever run into it.
-
-   Note, there will be no more calls in the C++ front end to abort,
-   because the C++ front end is so unreliable still.  The C front end
-   can get away with calling abort, because for most of the calls to
-   abort on most machines, it, I suspect, can be proven that it is
-   impossible to ever call abort.  The same is not yet true for C++,
-   one day, maybe it will be.
-
-   We used to tell people to "fix the above error[s] and try recompiling
-   the program" via a call to fatal, but that message tended to look
-   silly.  So instead, we just do the equivalent of a call to fatal in the
-   same situation (call exit).  */
-
-/* First used: 0 (reserved), Last used: 347 */
-
-void
-my_friendly_abort (i)
-     int i;
-{
-  if (errorcount > 0 || sorrycount > 0)
-    exit (34);
-
-  if (i == 0)
-    error ("Internal compiler error.");
-  else
-    error ("Internal compiler error %d.", i);
-
-  fatal ("Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.");
-}
-
-void
-my_friendly_assert (cond, where)
-     int cond, where;
-{
-  if (cond == 0)
-    my_friendly_abort (where);
-}
-
-/* Return nonzero if VALUE is a valid constant-valued expression
-   for use in initializing a static variable; one that can be an
-   element of a "constant" initializer.
-
-   Return 1 if the value is absolute; return 2 if it is relocatable.
-   We assume that VALUE has been folded as much as possible;
-   therefore, we do not need to check for such things as
-   arithmetic-combinations of integers.  */
-
-static int
-initializer_constant_valid_p (value)
-     tree value;
-{
-  switch (TREE_CODE (value))
-    {
-    case CONSTRUCTOR:
-      return TREE_STATIC (value);
-
-    case INTEGER_CST:
-    case REAL_CST:
-    case STRING_CST:
-      return 1;
-
-    case ADDR_EXPR:
-      return 2;
-
-    case CONVERT_EXPR:
-    case NOP_EXPR:
-      /* Allow conversions between types of the same kind.  */
-      if (TREE_CODE (TREE_TYPE (value))
-	  == TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))))
-	return initializer_constant_valid_p (TREE_OPERAND (value, 0));
-      /* Allow (int) &foo.  */
-      if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
-	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
-	return initializer_constant_valid_p (TREE_OPERAND (value, 0));
-      return 0;
-
-    case PLUS_EXPR:
-      {
-	int valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0));
-	int valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1));
-	if (valid0 == 1 && valid1 == 2)
-	  return 2;
-	if (valid0 == 2 && valid1 == 1)
-	  return 2;
-	return 0;
-      }
-
-    case MINUS_EXPR:
-      {
-	int valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0));
-	int valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1));
-	if (valid0 == 2 && valid1 == 1)
-	  return 2;
-	return 0;
-      }
-    }
-
-  return 0;
-}
-
-/* Perform appropriate conversions on the initial value of a variable,
-   store it in the declaration DECL,
-   and print any error messages that are appropriate.
-   If the init is invalid, store an ERROR_MARK.
-
-   C++: Note that INIT might be a TREE_LIST, which would mean that it is
-   a base class initializer for some aggregate type, hopefully compatible
-   with DECL.  If INIT is a single element, and DECL is an aggregate
-   type, we silently convert INIT into a TREE_LIST, allowing a constructor
-   to be called.
-
-   If INIT is a TREE_LIST and there is no constructor, turn INIT
-   into a CONSTRUCTOR and use standard initialization techniques.
-   Perhaps a warning should be generated?
-
-   Returns value of initializer if initialization could not be
-   performed for static variable.  In that case, caller must do
-   the storing.  */
-
-tree
-store_init_value (decl, init)
-     tree decl, init;
-{
-  register tree value, type;
-
-  /* If variable's type was invalidly declared, just ignore it.  */
-
-  type = TREE_TYPE (decl);
-  if (TREE_CODE (type) == ERROR_MARK)
-    return NULL_TREE;
-
-  /* Take care of C++ business up here.  */
-  type = TYPE_MAIN_VARIANT (type);
-
-  /* implicitly tests if IS_AGGR_TYPE.  */
-  if (TYPE_NEEDS_CONSTRUCTING (type))
-    my_friendly_abort (109);
-  else if (IS_AGGR_TYPE (type))
-    {
-      /* @@ This may be wrong, but I do not know what is right.  */
-      if (TREE_CODE (init) == TREE_LIST)
-	{
-	  error_with_aggr_type (type, "constructor syntax used, but no constructor declared for type `%s'");
-	  init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init));
-	}
-    }
-  else if (TREE_CODE (init) == TREE_LIST
-	   && TREE_TYPE (init) != unknown_type_node)
-    {
-      if (TREE_CODE (decl) == RESULT_DECL)
-	{
-	  if (TREE_CHAIN (init))
-	    {
-	      warning ("comma expression used to initialize return value");
-	      init = build_compound_expr (init);
-	    }
-	  else
-	    init = TREE_VALUE (init);
-	}
-      else if (TREE_TYPE (init) != 0
-	       && TREE_CODE (TREE_TYPE (init)) == OFFSET_TYPE)
-	{
-	  /* Use the type of our variable to instantiate
-	     the type of our initializer.  */
-	  init = instantiate_type (type, init, 1);
-	}
-      else if (TREE_CODE (init) == TREE_LIST
-	       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
-	{
-	  error ("cannot initialize arrays using this syntax");
-	  return NULL_TREE;
-	}
-      else
-	{
-	  error ("bad syntax in initialization");
-	  return NULL_TREE;
-	}
-    }
-
-  /* End of special C++ code.  */
-
-  /* Digest the specified initializer into an expression.  */
-
-  value = digest_init (type, init, (tree *) 0);
-
-  /* Store the expression if valid; else report error.  */
-
-  if (TREE_CODE (value) == ERROR_MARK)
-    ;
-  else if (TREE_STATIC (decl)
-	   && (! TREE_CONSTANT (value)
-	       || ! initializer_constant_valid_p (value)
-	       /* Since ctors and dtors are the only things that can
-		  reference vtables, and they are always written down
-		  the the vtable definition, we can leave the
-		  vtables in initialized data space.
-		  However, other initialized data cannot be initialized
-		  this way.  Instead a global file-level initializer
-		  must do the job.  */
-	       || (flag_pic && !DECL_VIRTUAL_P (decl) && TREE_PUBLIC (decl))))
-    return value;
-  else
-    {
-      if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
-	{
-	  if (! TREE_CONSTANT (value) || ! TREE_STATIC (value))
-	    pedwarn ("ANSI C++ forbids non-constant aggregate initializer expressions");
-	}
-    }
-  DECL_INITIAL (decl) = value;
-  return NULL_TREE;
-}
-
-/* Digest the parser output INIT as an initializer for type TYPE.
-   Return a C expression of type TYPE to represent the initial value.
-
-   If TAIL is nonzero, it points to a variable holding a list of elements
-   of which INIT is the first.  We update the list stored there by
-   removing from the head all the elements that we use.
-   Normally this is only one; we use more than one element only if
-   TYPE is an aggregate and INIT is not a constructor.  */
-
-tree
-digest_init (type, init, tail)
-     tree type, init, *tail;
-{
-  enum tree_code code = TREE_CODE (type);
-  tree element = 0;
-  tree old_tail_contents;
-  /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
-     tree node which has no TREE_TYPE.  */
-  int raw_constructor
-    = TREE_CODE (init) == CONSTRUCTOR && TREE_TYPE (init) == 0;
-
-  /* By default, assume we use one element from a list.
-     We correct this later in the sole case where it is not true.  */
-
-  if (tail)
-    {
-      old_tail_contents = *tail;
-      *tail = TREE_CHAIN (*tail);
-    }
-
-  if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST
-				  && TREE_VALUE (init) == error_mark_node))
-    return error_mark_node;
-
-  /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
-  if (TREE_CODE (init) == NON_LVALUE_EXPR)
-    init = TREE_OPERAND (init, 0);
-
-  if (init && raw_constructor
-      && CONSTRUCTOR_ELTS (init) != 0
-      && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)
-    {
-      element = TREE_VALUE (CONSTRUCTOR_ELTS (init));
-      /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
-      if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
-	element = TREE_OPERAND (element, 0);
-      if (element == error_mark_node)
-	return element;
-    }
-
-  /* Any type can be initialized from an expression of the same type,
-     optionally with braces.  */
-
-  if (init && TREE_TYPE (init)
-      && (TYPE_MAIN_VARIANT (TREE_TYPE (init)) == type
-	  || (code == ARRAY_TYPE && comptypes (TREE_TYPE (init), type, 1))))
-    {
-      if (pedantic && code == ARRAY_TYPE
-	  && TREE_CODE (init) != STRING_CST)
-	pedwarn ("ANSI C++ forbids initializing array from array expression");
-      if (TREE_CODE (init) == CONST_DECL)
-	init = DECL_INITIAL (init);
-      else if (TREE_READONLY_DECL_P (init))
-	init = decl_constant_value (init);
-      return init;
-    }
-
-  if (element && (TREE_TYPE (element) == type
-		  || (code == ARRAY_TYPE && TREE_TYPE (element)
-		      && comptypes (TREE_TYPE (element), type, 1))))
-    {
-      if (pedantic && code == ARRAY_TYPE)
-	pedwarn ("ANSI C++ forbids initializing array from array expression");
-      if (pedantic && (code == RECORD_TYPE || code == UNION_TYPE))
-	pedwarn ("ANSI C++ forbids single nonscalar initializer with braces");
-      if (TREE_CODE (element) == CONST_DECL)
-	element = DECL_INITIAL (element);
-      else if (TREE_READONLY_DECL_P (element))
-	element = decl_constant_value (element);
-      return element;
-    }
-
-  /* Check for initializing a union by its first field.
-     Such an initializer must use braces.  */
-
-  if (code == UNION_TYPE)
-    {
-      tree result, field = TYPE_FIELDS (type);
-
-      /* Find the first named field.  ANSI decided in September 1990
-	 that only named fields count here.  */
-      while (field && DECL_NAME (field) == 0)
-	field = TREE_CHAIN (field);
-
-      if (field == 0)
-	{
-	  error ("union with no named members cannot be initialized");
-	  return error_mark_node;
-	}
-
-      if (raw_constructor && !TYPE_NEEDS_CONSTRUCTING (type))
-	{
-	  result = process_init_constructor (type, init, NULL_PTR);
-	  return result;
-	}
-
-      if (! raw_constructor)
-	{
-	  error ("type mismatch in initialization");
-	  return error_mark_node;
-	}
-      if (element == 0)
-	{
-	  if (!TYPE_NEEDS_CONSTRUCTING (type))
-	    {
-	      error ("union initializer requires one element");
-	      return error_mark_node;
-	    }
-	}
-      else
-	{
-	  /* Take just the first element from within the constructor
-	     and it should match the type of the first element.  */
-	  element = digest_init (TREE_TYPE (field), element, (tree *) 0);
-	  result = build (CONSTRUCTOR, type, 0, build_tree_list (field, element));
-	  TREE_CONSTANT (result) = TREE_CONSTANT (element);
-	  TREE_STATIC (result) = (initializer_constant_valid_p (element)
-				  && TREE_CONSTANT (element));
-	  return result;
-	}
-    }
-
-  /* Initialization of an array of chars from a string constant
-     optionally enclosed in braces.  */
-
-  if (code == ARRAY_TYPE)
-    {
-      tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
-      if ((typ1 == char_type_node
-	   || typ1 == signed_char_type_node
-	   || typ1 == unsigned_char_type_node
-	   || typ1 == unsigned_wchar_type_node
-	   || typ1 == signed_wchar_type_node)
-	  && ((init && TREE_CODE (init) == STRING_CST)
-	      || (element && TREE_CODE (element) == STRING_CST)))
-	{
-	  tree string = element ? element : init;
-
-	  if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
-	       != char_type_node)
-	      && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
-	    {
-	      error ("char-array initialized from wide string");
-	      return error_mark_node;
-	    }
-	  if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
-	       == char_type_node)
-	      && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
-	    {
-	      error ("int-array initialized from non-wide string");
-	      return error_mark_node;
-	    }
-
-	  if (pedantic && typ1 != char_type_node)
-	    pedwarn ("ANSI C++ forbids string initializer except for `char' elements");
-	  TREE_TYPE (string) = type;
-	  if (TYPE_DOMAIN (type) != 0
-	      && TREE_CONSTANT (TYPE_SIZE (type)))
-	    {
-	      register int size
-		= TREE_INT_CST_LOW (TYPE_SIZE (type));
-	      size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
-	      /* In C it is ok to subtract 1 from the length of the string
-		 because it's ok to ignore the terminating null char that is
-		 counted in the length of the constant, but in C++ this would
-		 be invalid.  */
-	      if (size < TREE_STRING_LENGTH (string))
-		warning ("initializer-string for array of chars is too long");
-	    }
-	  return string;
-	}
-    }
-
-  /* Handle scalar types, including conversions.  */
-
-  if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
-      || code == ENUMERAL_TYPE || code == REFERENCE_TYPE)
-    {
-      if (raw_constructor)
-	{
-	  if (element == 0)
-	    {
-	      error ("initializer for scalar variable requires one element");
-	      return error_mark_node;
-	    }
-	  init = element;
-	}
-
-      return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
-					 "initialization", NULL_TREE, 0);
-    }
-
-  /* Come here only for records and arrays (and unions with constructors).  */
-
-  if (TYPE_SIZE (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
-    {
-      error ("variable-sized object may not be initialized");
-      return error_mark_node;
-    }
-
-  if (code == ARRAY_TYPE || code == RECORD_TYPE || code == UNION_TYPE)
-    {
-      if (raw_constructor)
-	return process_init_constructor (type, init, 0);
-      else if (TYPE_NEEDS_CONSTRUCTING (type))
-	{
-	  /* This can only be reached when caller is initializing
-	     ARRAY_TYPE.  In that case, we don't want to convert
-	     INIT to TYPE.  We will let `expand_vec_init' do it.  */
-	  return init;
-	}
-      else if (tail != 0)
-	{
-	  *tail = old_tail_contents;
-	  return process_init_constructor (type, 0, tail);
-	}
-      else if (flag_traditional)
-	/* Traditionally one can say `char x[100] = 0;'.  */
-	return process_init_constructor (type,
-					 build_nt (CONSTRUCTOR, 0,
-						   tree_cons (0, init, 0)),
-					 0);
-      if (code != ARRAY_TYPE)
-	return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
-					   "initialization", NULL_TREE, 0);
-    }
-
-  error ("invalid initializer");
-  return error_mark_node;
-}
-
-/* Process a constructor for a variable of type TYPE.
-   The constructor elements may be specified either with INIT or with ELTS,
-   only one of which should be non-null.
-
-   If INIT is specified, it is a CONSTRUCTOR node which is specifically
-   and solely for initializing this datum.
-
-   If ELTS is specified, it is the address of a variable containing
-   a list of expressions.  We take as many elements as we need
-   from the head of the list and update the list.
-
-   In the resulting constructor, TREE_CONSTANT is set if all elts are
-   constant, and TREE_STATIC is set if, in addition, all elts are simple enough
-   constants that the assembler and linker can compute them.  */
-
-static tree
-process_init_constructor (type, init, elts)
-     tree type, init, *elts;
-{
-  extern tree empty_init_node;
-  register tree tail;
-  /* List of the elements of the result constructor,
-     in reverse order.  */
-  register tree members = NULL;
-  tree result;
-  int allconstant = 1;
-  int allsimple = 1;
-  int erroneous = 0;
-
-  /* Make TAIL be the list of elements to use for the initialization,
-     no matter how the data was given to us.  */
-
-  if (elts)
-    {
-      if (extra_warnings)
-	warning ("aggregate has a partly bracketed initializer");
-      tail = *elts;
-    }
-  else
-    tail = CONSTRUCTOR_ELTS (init);
-
-  /* Gobble as many elements as needed, and make a constructor or initial value
-     for each element of this aggregate.  Chain them together in result.
-     If there are too few, use 0 for each scalar ultimate component.  */
-
-  if (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      tree domain = TYPE_DOMAIN (type);
-      register long len;
-      register int i;
-
-      if (domain)
-	len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
-	       - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
-	       + 1);
-      else
-	len = -1;  /* Take as many as there are */
-
-      for (i = 0; (len < 0 || i < len) && tail != 0; i++)
-	{
-	  register tree next1;
-
-	  if (TREE_VALUE (tail) != 0)
-	    {
-	      tree tail1 = tail;
-	      next1 = digest_init (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
-				   TREE_VALUE (tail), &tail1);
-	      my_friendly_assert (tail1 == 0
-				  || TREE_CODE (tail1) == TREE_LIST, 319);
-	      if (tail == tail1 && len < 0)
-		{
-		  error ("non-empty initializer for array of empty elements");
-		  /* Just ignore what we were supposed to use.  */
-		  tail1 = 0;
-		}
-	      tail = tail1;
-	    }
-	  else
-	    {
-	      next1 = error_mark_node;
-	      tail = TREE_CHAIN (tail);
-	    }
-
-	  if (next1 == error_mark_node)
-	    erroneous = 1;
-	  else if (!TREE_CONSTANT (next1))
-	    allconstant = 0;
-	  else if (! initializer_constant_valid_p (next1))
-	    allsimple = 0;
-	  members = tree_cons (NULL_TREE, next1, members);
-	}
-    }
-  if (TREE_CODE (type) == RECORD_TYPE && init != empty_init_node)
-    {
-      register tree field;
-
-      if (tail)
-	{
-	  if (TYPE_USES_VIRTUAL_BASECLASSES (type))
-	    {
-	      sorry ("initializer list for object of class with virtual baseclasses");
-	      return error_mark_node;
-	    }
-
-	  if (TYPE_BINFO_BASETYPES (type))
-	    {
-	      sorry ("initializer list for object of class with baseclasses");
-	      return error_mark_node;
-	    }
-
-	  if (TYPE_VIRTUAL_P (type))
-	    {
-	      sorry ("initializer list for object using virtual functions");
-	      return error_mark_node;
-	    }
-	}
-
-      for (field = TYPE_FIELDS (type); field && tail;
-	   field = TREE_CHAIN (field))
-	{
-	  register tree next1;
-
-	  if (! DECL_NAME (field))
-	    {
-	      members = tree_cons (field, integer_zero_node, members);
-	      continue;
-	    }
-
-	  if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL)
-	    continue;
-
-	  /* A static mmmember isn't considered "part of the object", so
-	     it has no business even thinking about involving itself in
-	     what an initializer-list is trying to do.  */
-	  if (TREE_CODE (field) == VAR_DECL && TREE_STATIC (field))
-	    continue;
-
-	  if (TREE_VALUE (tail) != 0)
-	    {
-	      tree tail1 = tail;
-	      next1 = digest_init (TREE_TYPE (field),
-				   TREE_VALUE (tail), &tail1);
-	      my_friendly_assert (tail1 == 0
-				  || TREE_CODE (tail1) == TREE_LIST, 320);
-	      if (TREE_CODE (field) == VAR_DECL
-		  && ! global_bindings_p ())
-		warning_with_decl (field, "initialization of static member `%s'");
-	      tail = tail1;
-	    }
-	  else
-	    {
-	      next1 = error_mark_node;
-	      tail = TREE_CHAIN (tail);
-	    }
-
-	  if (next1 == error_mark_node)
-	    erroneous = 1;
-	  else if (!TREE_CONSTANT (next1))
-	    allconstant = 0;
-	  else if (! initializer_constant_valid_p (next1))
-	    allsimple = 0;
-	  members = tree_cons (field, next1, members);
-	}
-      for (; field; field = TREE_CHAIN (field))
-	{
-	  if (TREE_CODE (field) != FIELD_DECL)
-	    continue;
-
-	  /* Does this field have a default initialization?  */
-	  if (DECL_INITIAL (field))
-	    {
-	      register tree next1 = DECL_INITIAL (field);
-	      if (TREE_CODE (next1) == ERROR_MARK)
-		erroneous = 1;
-	      else if (!TREE_CONSTANT (next1))
-		allconstant = 0;
-	      else if (! initializer_constant_valid_p (next1))
-		allsimple = 0;
-	      members = tree_cons (field, next1, members);
-	    }
-	  else if (TREE_READONLY (field))
-	    error ("uninitialized const member `%s'",
-		   IDENTIFIER_POINTER (DECL_NAME (field)));
-	  else if (TYPE_LANG_SPECIFIC (TREE_TYPE (field))
-		   && CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
-	    error ("member `%s' with uninitialized const fields",
-		   IDENTIFIER_POINTER (DECL_NAME (field)));
-	  else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
-	    error ("member `%s' is uninitialized reference",
-		   IDENTIFIER_POINTER (DECL_NAME (field)));
-	}
-    }
-
-  if (TREE_CODE (type) == UNION_TYPE)
-    {
-      register tree field = TYPE_FIELDS (type);
-      register tree next1;
-
-      /* Find the first named field.  ANSI decided in September 1990
-	 that only named fields count here.  */
-      while (field && DECL_NAME (field) == 0)
-	field = TREE_CHAIN (field);
-
-      /* For a union, get the initializer for 1 fld.  */
-
-      if (tail == NULL_TREE)
-	{
-	  error ("empty initializer for union");
-	  tail = build_tree_list (NULL_TREE, NULL_TREE);
-	}
-
-      /* If this element specifies a field, initialize via that field.  */
-      if (TREE_PURPOSE (tail) != NULL_TREE)
-	{
-	  int win = 0;
-
-	  if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
-	    /* Handle the case of a call by build_c_cast.  */
-	    field = TREE_PURPOSE (tail), win = 1;
-	  else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
-	    error ("index value instead of field name in union initializer");
-	  else
-	    {
-	      tree temp;
-	      for (temp = TYPE_FIELDS (type);
-		   temp;
-		   temp = TREE_CHAIN (temp))
-		if (DECL_NAME (temp) == TREE_PURPOSE (tail))
-		  break;
-	      if (temp)
-		field = temp, win = 1;
-	      else
-		error ("no field `%s' in union being initialized",
-		       IDENTIFIER_POINTER (TREE_PURPOSE (tail)));
-	    }
-	  if (!win)
-	    TREE_VALUE (tail) = error_mark_node;
-	}
-
-      if (TREE_VALUE (tail) != 0)
-	{
-	  tree tail1 = tail;
-
-	  next1 = digest_init (TREE_TYPE (field),
-			       TREE_VALUE (tail), &tail1);
-	  if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
-	    abort ();
-	  tail = tail1;
-	}
-      else
-	{
-	  next1 = error_mark_node;
-	  tail = TREE_CHAIN (tail);
-	}
-
-      if (next1 == error_mark_node)
-	erroneous = 1;
-      else if (!TREE_CONSTANT (next1))
-	allconstant = 0;
-      else if (initializer_constant_valid_p (next1) == 0)
-	allsimple = 0;
-      members = tree_cons (field, next1, members);
-    }
-
-  /* If arguments were specified as a list, just remove the ones we used.  */
-  if (elts)
-    *elts = tail;
-  /* If arguments were specified as a constructor,
-     complain unless we used all the elements of the constructor.  */
-  else if (tail)
-    warning ("excess elements in aggregate initializer");
-
-  if (erroneous)
-    return error_mark_node;
-
-  result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
-  if (init)
-    TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);
-  if (allconstant) TREE_CONSTANT (result) = 1;
-  if (allconstant && allsimple) TREE_STATIC (result) = 1;
-  return result;
-}
-
-/* Given a structure or union value DATUM, construct and return
-   the structure or union component which results from narrowing
-   that value by the types specified in TYPES.  For example, given the
-   hierarchy
-
-   class L { int ii; };
-   class A : L { ... };
-   class B : L { ... };
-   class C : A, B { ... };
-
-   and the declaration
-
-   C x;
-
-   then the expression
-
-   x::C::A::L::ii refers to the ii member of the L part of
-   of A part of the C object named by X.  In this case,
-   DATUM would be x, and TYPES would be a SCOPE_REF consisting of
-
-	SCOPE_REF
-		SCOPE_REF
-			C	A
-		L
-
-   The last entry in the SCOPE_REF is always an IDENTIFIER_NODE.
-
-*/
-
-tree
-build_scoped_ref (datum, types)
-     tree datum;
-     tree types;
-{
-  tree ref;
-  tree type = TREE_TYPE (datum);
-
-  if (datum == error_mark_node)
-    return error_mark_node;
-  type = TYPE_MAIN_VARIANT (type);
-
-  if (TREE_CODE (types) == SCOPE_REF)
-    {
-      /* We have some work to do.  */
-      struct type_chain { tree type; struct type_chain *next; } *chain = 0, *head = 0, scratch;
-      ref = build_unary_op (ADDR_EXPR, datum, 0);
-      while (TREE_CODE (types) == SCOPE_REF)
-	{
-	  tree t = TREE_OPERAND (types, 1);
-	  if (is_aggr_typedef (t, 1))
-	    {
-	      head = (struct type_chain *)alloca (sizeof (struct type_chain));
-	      head->type = IDENTIFIER_TYPE_VALUE (t);
-	      head->next = chain;
-	      chain = head;
-	      types = TREE_OPERAND (types, 0);
-	    }
-	  else return error_mark_node;
-	}
-      if (! is_aggr_typedef (types, 1))
-	return error_mark_node;
-
-      head = &scratch;
-      head->type = IDENTIFIER_TYPE_VALUE (types);
-      head->next = chain;
-      chain = head;
-      while (chain)
-	{
-	  tree binfo = chain->type;
-	  type = TREE_TYPE (TREE_TYPE (ref));
-	  if (binfo != TYPE_BINFO (type))
-	    {
-	      binfo = get_binfo (binfo, type, 1);
-	      if (binfo == error_mark_node)
-		return error_mark_node;
-	      if (binfo == 0)
-		return error_not_base_type (chain->type, type);
-	      ref = convert_pointer_to (binfo, ref);
-	    }
-	  chain = chain->next;
-	}
-      return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
-    }
-
-  /* This is an easy conversion.  */
-  if (is_aggr_typedef (types, 1))
-    {
-      tree binfo = TYPE_BINFO (IDENTIFIER_TYPE_VALUE (types));
-      if (binfo != TYPE_BINFO (type))
-	{
-	  binfo = get_binfo (binfo, type, 1);
-	  if (binfo == error_mark_node)
-	    return error_mark_node;
-	  if (binfo == 0)
-	    return error_not_base_type (IDENTIFIER_TYPE_VALUE (types), type);
-	}
-
-      switch (TREE_CODE (datum))
-	{
-	case NOP_EXPR:
-	case CONVERT_EXPR:
-	case FLOAT_EXPR:
-	case FIX_TRUNC_EXPR:
-	case FIX_FLOOR_EXPR:
-	case FIX_ROUND_EXPR:
-	case FIX_CEIL_EXPR:
-	  ref = convert_pointer_to (binfo,
-				    build_unary_op (ADDR_EXPR, TREE_OPERAND (datum, 0), 0));
-	  break;
-	default:
-	  ref = convert_pointer_to (binfo,
-				    build_unary_op (ADDR_EXPR, datum, 0));
-	}
-      return build_indirect_ref (ref, "(compiler error in build_scoped_ref)");
-    }
-  return error_mark_node;
-}
-
-/* Build a reference to an object specified by the C++ `->' operator.
-   Usually this just involves dereferencing the object, but if the
-   `->' operator is overloaded, then such overloads must be
-   performed until an object which does not have the `->' operator
-   overloaded is found.  An error is reported when circular pointer
-   delegation is detected.  */
-tree
-build_x_arrow (datum)
-     tree datum;
-{
-  tree types_memoized = NULL_TREE;
-  register tree rval = datum;
-  tree type = TREE_TYPE (rval);
-  tree last_rval;
-
-  if (type == error_mark_node)
-    return error_mark_node;
-
-  if (TREE_CODE (type) == REFERENCE_TYPE)
-    {
-      rval = convert_from_reference (rval);
-      type = TREE_TYPE (rval);
-    }
-
-  if (IS_AGGR_TYPE (type) && TYPE_OVERLOADS_ARROW (type))
-    {
-      while (rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval, NULL_TREE, NULL_TREE))
-	{
-	  if (rval == error_mark_node)
-	    return error_mark_node;
-
-	  if (value_member (TREE_TYPE (rval), types_memoized))
-	    {
-	      error ("circular pointer delegation detected");
-	      return error_mark_node;
-	    }
-	  else
-	    {
-	      types_memoized = tree_cons (NULL_TREE, TREE_TYPE (rval),
-					  types_memoized);
-	    }
-	  last_rval = rval;
-	}     
-      if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
-	last_rval = convert_from_reference (last_rval);
-    }
-  else
-    last_rval = default_conversion (rval);
-
- more:
-  if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
-    return build_indirect_ref (last_rval, 0);
-
-  if (TREE_CODE (TREE_TYPE (last_rval)) == OFFSET_TYPE)
-    {
-      if (TREE_CODE (last_rval) == OFFSET_REF
-	  && TREE_STATIC (TREE_OPERAND (last_rval, 1)))
-	{
-	  last_rval = TREE_OPERAND (last_rval, 1);
-	  if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
-	    last_rval = convert_from_reference (last_rval);
-	  goto more;
-	}
-      compiler_error ("invalid member type in build_x_arrow");
-      return error_mark_node;
-    }
-
-  if (types_memoized)
-    error ("result of `operator->()' yields non-pointer result");
-  else
-    error ("base operand of `->' is not a pointer");
-  return error_mark_node;
-}
-
-/* Make an expression to refer to the COMPONENT field of
-   structure or union value DATUM.  COMPONENT is an arbitrary
-   expression.  DATUM has already been checked out to be of
-   aggregate type.
-
-   For C++, COMPONENT may be a TREE_LIST.  This happens when we must
-   return an object of member type to a method of the current class,
-   but there is not yet enough typing information to know which one.
-   As a special case, if there is only one method by that name,
-   it is returned.  Otherwise we return an expression which other
-   routines will have to know how to deal with later.  */
-tree
-build_m_component_ref (datum, component)
-     tree datum, component;
-{
-  tree type = TREE_TYPE (component);
-  tree objtype = TREE_TYPE (datum);
-
-  if (datum == error_mark_node || component == error_mark_node)
-    return error_mark_node;
-
-  if (TREE_CODE (type) != OFFSET_TYPE && TREE_CODE (type) != METHOD_TYPE)
-    {
-      error ("non-member type composed with object");
-      return error_mark_node;
-    }
-
-  if (TREE_CODE (objtype) == REFERENCE_TYPE)
-    objtype = TREE_TYPE (objtype);
-
-  if (! comptypes (TYPE_METHOD_BASETYPE (type), objtype, 0))
-    {
-      error ("member type `%s::' incompatible with object type `%s'",
-	     TYPE_NAME_STRING (TYPE_METHOD_BASETYPE (type)),
-	     TYPE_NAME_STRING (objtype));
-      return error_mark_node;
-    }
-
-  return build (OFFSET_REF, TREE_TYPE (TREE_TYPE (component)), datum, component);
-}
-
-/* Return a tree node for the expression TYPENAME '(' PARMS ')'.
-
-   Because we cannot tell whether this construct is really
-   a function call or a call to a constructor or a request for
-   a type conversion, we try all three, and report any ambiguities
-   we find.  */
-tree
-build_functional_cast (exp, parms)
-     tree exp;
-     tree parms;
-{
-  /* This is either a call to a constructor,
-     or a C cast in C++'s `functional' notation.  */
-  tree type, name = NULL_TREE;
-  tree expr_as_ctor = NULL_TREE;
-  tree expr_as_method = NULL_TREE;
-  tree expr_as_fncall = NULL_TREE;
-  tree expr_as_conversion = NULL_TREE;
-
-  if (exp == error_mark_node || parms == error_mark_node)
-    return error_mark_node;
-
-  if (TREE_CODE (exp) == IDENTIFIER_NODE)
-    {
-      name = exp;
-
-      if (IDENTIFIER_HAS_TYPE_VALUE (exp))
-	/* Either an enum or an aggregate type.  */
-	type = IDENTIFIER_TYPE_VALUE (exp);
-      else
-	{
-	  type = lookup_name (exp, 1);
-	  if (!type || TREE_CODE (type) != TYPE_DECL)
-	    {
-	      error ("`%s' fails to be a typedef or built-in type",
-		     IDENTIFIER_POINTER (name));
-	      return error_mark_node;
-	    }
-	  type = TREE_TYPE (type);
-	}
-    }
-  else type = exp;
-
-  /* Prepare to evaluate as a call to a constructor.  If this expression
-     is actually used, for example,
-	 
-     return X (arg1, arg2, ...);
-	 
-     then the slot being initialized will be filled in.  */
-
-  if (name == NULL_TREE)
-    {
-      name = TYPE_NAME (type);
-      if (TREE_CODE (name) == TYPE_DECL)
-	name = DECL_NAME (name);
-    }
-
-  /* Try evaluating as a call to a function.  */
-  if (IDENTIFIER_CLASS_VALUE (name))
-    expr_as_method = build_method_call (current_class_decl, name, parms,
-					NULL_TREE, LOOKUP_SPECULATIVELY);
-  if (IDENTIFIER_GLOBAL_VALUE (name)
-      && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TREE_LIST
-	  || TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == FUNCTION_DECL))
-    {
-      expr_as_fncall = build_overload_call (name, parms, 0,
-					    (struct candidate *)0);
-      if (expr_as_fncall == NULL_TREE)
-	expr_as_fncall = error_mark_node;
-    }
-
-  if (! IS_AGGR_TYPE (type))
-    {
-      /* this must build a C cast */
-      if (parms == NULL_TREE)
-	{
-	  if (expr_as_method || expr_as_fncall)
-	    goto return_function;
-
-	  error ("cannot cast null list to type `%s'",
-		 IDENTIFIER_POINTER (name));
-	  return error_mark_node;
-	}
-      if (expr_as_method
-	  || (expr_as_fncall && expr_as_fncall != error_mark_node))
-	{
-	  error ("ambiguity between cast to `%s' and function call",
-		 IDENTIFIER_POINTER (name));
-	  return error_mark_node;
-	}
-      return build_c_cast (type, build_compound_expr (parms));
-    }
-
-  if (TYPE_SIZE (type) == NULL_TREE)
-    {
-      if (expr_as_method || expr_as_fncall)
-	goto return_function;
-      error ("type `%s' is not yet defined", IDENTIFIER_POINTER (name));
-      return error_mark_node;
-    }
-
-  if (parms && TREE_CHAIN (parms) == NULL_TREE)
-    expr_as_conversion
-      = build_type_conversion (CONVERT_EXPR, type, TREE_VALUE (parms), 0);
-    
-  if (! TYPE_NEEDS_CONSTRUCTOR (type) && parms != NULL_TREE)
-    {
-      char *msg = 0;
-
-      if (parms == NULL_TREE)
-	msg = "argument missing in cast to `%s' type";
-      else if (TREE_CHAIN (parms) == NULL_TREE)
-	{
-	  if (expr_as_conversion == NULL_TREE)
-	    msg = "conversion to type `%s' failed";
-	}
-      else msg = "type `%s' does not have a constructor";
-
-      if ((expr_as_method || expr_as_fncall) && expr_as_conversion)
-	msg = "ambiguity between conversion to `%s' and function call";
-      else if (expr_as_method || expr_as_fncall)
-	goto return_function;
-      else if (expr_as_conversion)
-	return expr_as_conversion;
-
-      error (msg, IDENTIFIER_POINTER (name));
-      return error_mark_node;
-    }
-
-  if (! TYPE_HAS_CONSTRUCTOR (type))
-    {
-      if (expr_as_method || expr_as_fncall)
-	goto return_function;
-      if (expr_as_conversion)
-	return expr_as_conversion;
-
-      /* Look through this type until we find the
-	 base type which has a constructor.  */
-      do
-	{
-	  tree binfos = TYPE_BINFO_BASETYPES (type);
-	  int i, index = 0;
-
-	  while (binfos && TREE_VEC_LENGTH (binfos) == 1
-		 && ! TYPE_HAS_CONSTRUCTOR (type))
-	    {
-	      type = BINFO_TYPE (TREE_VEC_ELT (binfos, 0));
-	      binfos = TYPE_BINFO_BASETYPES (type);
-	    }
-	  if (TYPE_HAS_CONSTRUCTOR (type))
-	    break;
-	  /* Hack for MI.  */
-	  i = binfos ? TREE_VEC_LENGTH (binfos) : 0;
-	  if (i == 0) break;	    
-	  while (--i > 0)
-	    {
-	      if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (TREE_VEC_ELT (binfos, i))))
-		{
-		  if (index == 0)
-		    index = i;
-		  else
-		    {
-		      error ("multiple base classes with constructor, ambiguous");
-		      type = 0;
-		      break;
-		    }
-		}
-	    }
-	  if (type == 0)
-	    break;
-	} while (! TYPE_HAS_CONSTRUCTOR (type));
-      if (type == 0)
-	return error_mark_node;
-    }
-  name = TYPE_NAME (type);
-  if (TREE_CODE (name) == TYPE_DECL)
-    name = DECL_NAME (name);
-
-  my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 321);
-
-  {
-    int flags = LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN;
-
-    if (parms && TREE_CHAIN (parms) == NULL_TREE)
-      flags |= LOOKUP_NO_CONVERSION;
-
-  try_again:
-    expr_as_ctor = build_method_call (NULL_TREE, name, parms, NULL_TREE, flags);
-
-    if (expr_as_ctor && expr_as_ctor != error_mark_node)
-      {
-#if 0
-	/* mrs Mar 12, 1992 I claim that if it is a constructor, it is
-	   impossible to be an expr_as_method, without being a
-	   constructor call. */
-	if (expr_as_method
-	    || (expr_as_fncall && expr_as_fncall != error_mark_node))
-#else
-	if (expr_as_fncall && expr_as_fncall != error_mark_node)
-#endif
-	  {
-	    error ("ambiguity between constructor for `%s' and function call",
-		   IDENTIFIER_POINTER (name));
-	    return error_mark_node;
-	  }
-	else if (expr_as_conversion && expr_as_conversion != error_mark_node)
-	  {
-	    /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
-	    error ("ambiguity between conversion to `%s' and constructor",
-		   IDENTIFIER_POINTER (name));
-	    return error_mark_node;
-	  }
-
-	if (current_function_decl)
-	  return build_cplus_new (type, expr_as_ctor, 1);
-
-	{
-	  register tree parm = TREE_OPERAND (expr_as_ctor, 1);
-
-	  /* Initializers for static variables and parameters have
-	     to handle doing the initialization and cleanup themselves.  */
-	  my_friendly_assert (TREE_CODE (expr_as_ctor) == CALL_EXPR, 322);
-	  my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm)), 323);
-	  TREE_VALUE (parm) = NULL_TREE;
-	  expr_as_ctor = build_indirect_ref (expr_as_ctor, 0);
-	  TREE_HAS_CONSTRUCTOR (expr_as_ctor) = 1;
-	}
-	return expr_as_ctor;
-      }
-
-    /* If it didn't work going through constructor, try type conversion.  */
-    if (! (flags & LOOKUP_COMPLAIN))
-      {
-	if (expr_as_conversion)
-	  return expr_as_conversion;
-	if (flags & LOOKUP_NO_CONVERSION)
-	  {
-	    flags = LOOKUP_NORMAL;
-	    goto try_again;
-	  }
-      }
-
-    if (expr_as_conversion)
-      {
-	if (expr_as_method || expr_as_fncall)
-	  {
-	    error ("ambiguity between conversion to `%s' and function call",
-		   IDENTIFIER_POINTER (name));
-	    return error_mark_node;
-	  }
-	return expr_as_conversion;
-      }
-  return_function:
-    if (expr_as_method)
-      return build_method_call (current_class_decl, name, parms,
-				NULL_TREE, LOOKUP_NORMAL);
-    if (expr_as_fncall)
-      return expr_as_fncall == error_mark_node
-	? build_overload_call (name, parms, 1, (struct candidate *)0)
-	  : expr_as_fncall;
-    error ("invalid functional cast");
-    return error_mark_node;
-  }
-}
-
-/* Return the character string for the name that encodes the
-   enumeral value VALUE in the domain TYPE.  */
-char *
-enum_name_string (value, type)
-     tree value;
-     tree type;
-{
-  register tree values = TYPE_VALUES (type);
-  register HOST_WIDE_INT intval = TREE_INT_CST_LOW (value);
-
-  my_friendly_assert (TREE_CODE (type) == ENUMERAL_TYPE, 324);
-  while (values
-	 && TREE_INT_CST_LOW (TREE_VALUE (values)) != intval)
-    values = TREE_CHAIN (values);
-  if (values == NULL_TREE)
-    {
-      char *buf = (char *)oballoc (16 + TYPE_NAME_LENGTH (type));
-
-      /* Value must have been cast.  */
-      sprintf (buf, "(enum %s)%d",
-	       TYPE_NAME_STRING (type), intval);
-      return buf;
-    }
-  return IDENTIFIER_POINTER (TREE_PURPOSE (values));
-}
-
-/* Print out a language-specific error message for
-   (Pascal) case or (C) switch statements.
-   CODE tells what sort of message to print. 
-   TYPE is the type of the switch index expression.
-   NEW is the new value that we were trying to add.
-   OLD is the old value that stopped us from adding it.  */
-void
-report_case_error (code, type, new_value, old_value)
-     int code;
-     tree type;
-     tree new_value, old_value;
-{
-  if (code == 1)
-    {
-      if (new_value)
-	error ("case label not within a switch statement");
-      else
-	error ("default label not within a switch statement");
-    }
-  else if (code == 2)
-    {
-      if (new_value == 0)
-	{
-	  error ("multiple default labels in one switch");
-	  return;
-	}
-      if (TREE_CODE (new_value) == RANGE_EXPR)
-	if (TREE_CODE (old_value) == RANGE_EXPR)
-	  {
-	    char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
-	    if (TREE_CODE (type) == ENUMERAL_TYPE)
-	      sprintf (buf, "overlapping ranges [%s..%s], [%s..%s] in case expression",
-		       enum_name_string (TREE_OPERAND (new_value, 0), type),
-		       enum_name_string (TREE_OPERAND (new_value, 1), type),
-		       enum_name_string (TREE_OPERAND (old_value, 0), type),
-		       enum_name_string (TREE_OPERAND (old_value, 1), type));
-	    else
-	      sprintf (buf, "overlapping ranges [%d..%d], [%d..%d] in case expression",
-		       TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
-		       TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
-		       TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
-		       TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)));
-	    error (buf);
-	  }
-	else
-	  {
-	    char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
-	    if (TREE_CODE (type) == ENUMERAL_TYPE)
-	      sprintf (buf, "range [%s..%s] includes element `%s' in case expression",
-		       enum_name_string (TREE_OPERAND (new_value, 0), type),
-		       enum_name_string (TREE_OPERAND (new_value, 1), type),
-		       enum_name_string (old_value, type));
-	    else
-	      sprintf (buf, "range [%d..%d] includes (%d) in case expression",
-		       TREE_INT_CST_LOW (TREE_OPERAND (new_value, 0)),
-		       TREE_INT_CST_LOW (TREE_OPERAND (new_value, 1)),
-		       TREE_INT_CST_LOW (old_value));
-	    error (buf);
-	  }
-      else if (TREE_CODE (old_value) == RANGE_EXPR)
-	{
-	  char *buf = (char *)alloca (4 * (8 + TYPE_NAME_LENGTH (type)));
-	  if (TREE_CODE (type) == ENUMERAL_TYPE)
-	    sprintf (buf, "range [%s..%s] includes element `%s' in case expression",
-		     enum_name_string (TREE_OPERAND (old_value, 0), type),
-		     enum_name_string (TREE_OPERAND (old_value, 1), type),
-		     enum_name_string (new_value, type));
-	  else
-	    sprintf (buf, "range [%d..%d] includes (%d) in case expression",
-		     TREE_INT_CST_LOW (TREE_OPERAND (old_value, 0)),
-		     TREE_INT_CST_LOW (TREE_OPERAND (old_value, 1)),
-		     TREE_INT_CST_LOW (new_value));
-	  error (buf);
-	}
-      else
-	{
-	  if (TREE_CODE (type) == ENUMERAL_TYPE)
-	    error ("duplicate label `%s' in switch statement",
-		   enum_name_string (new_value, type));
-	  else
-	    error ("duplicate label (%d) in switch statement",
-		   TREE_INT_CST_LOW (new_value));
-	}
-    }
-  else if (code == 3)
-    {
-      if (TREE_CODE (type) == ENUMERAL_TYPE)
-	warning ("case value out of range for enum %s",
-		 TYPE_NAME_STRING (type));
-      else
-	warning ("case value out of range");
-    }
-  else if (code == 4)
-    {
-      if (TREE_CODE (type) == ENUMERAL_TYPE)
-	error ("range values `%s' and `%s' reversed",
-	       enum_name_string (new_value, type),
-	       enum_name_string (old_value, type));
-      else
-	error ("range values reversed");
-    }
-}
diff --git a/gnu/gcc2/cc1plus/cp-typeck.c b/gnu/gcc2/cc1plus/cp-typeck.c
deleted file mode 100644
index 362e17080993..000000000000
--- a/gnu/gcc2/cc1plus/cp-typeck.c
+++ /dev/null
@@ -1,6374 +0,0 @@
-/* Build expressions with type checking for C++ compiler.
-   Copyright (C) 1987, 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
-   Hacked 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-/* This file is part of the C++ front end.
-   It contains routines to build C++ expressions given their operands,
-   including computing the types of the result, C and C++ specific error
-   checks, and some optimization.
-
-   There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
-   and to process initializations in declarations (since they work
-   like a strange sort of assignment).  */
-
-extern void error ();
-extern void warning ();
-
-#include "config.h"
-#include <stdio.h>
-#include "tree.h"
-#include "rtl.h"
-#include "cp-tree.h"
-#include "flags.h"
-
-int mark_addressable ();
-static tree convert_for_assignment ();
-/* static */ tree convert_for_initialization ();
-int compparms ();
-static int self_promoting_args_p ();
-int comp_target_types ();
-extern tree shorten_compare ();
-void warn_for_assignment ();
-extern void binary_op_error ();
-static tree pointer_int_sum ();
-static tree pointer_diff ();
-static tree convert_sequence ();
-/* static */ tree unary_complex_lvalue ();
-static void pedantic_lvalue_warning ();
-tree truthvalue_conversion ();
-
-extern rtx original_result_rtx;
-
-/* Return the target type of TYPE, which meas return T for:
-   T*, T&, T[], T (...), and otherwise, just T.  */
-
-tree
-target_type (type)
-     tree type;
-{
-  if (TREE_CODE (type) == REFERENCE_TYPE)
-    type = TREE_TYPE (type);
-  while (TREE_CODE (type) == POINTER_TYPE
-	 || TREE_CODE (type) == ARRAY_TYPE
-	 || TREE_CODE (type) == FUNCTION_TYPE
-	 || TREE_CODE (type) == METHOD_TYPE
-	 || TREE_CODE (type) == OFFSET_TYPE)
-    type = TREE_TYPE (type);
-  return type;
-}
-
-/* Do `exp = require_complete_type (exp);' to make sure exp
-   does not have an incomplete type.  (That includes void types.)  */
-
-tree
-require_complete_type (value)
-     tree value;
-{
-  tree type = TREE_TYPE (value);
-
-  /* First, detect a valid value with a complete type.  */
-  if (TYPE_SIZE (type) != 0
-      && type != void_type_node)
-    return value;
-
-  /* If we see X::Y, we build an OFFSET_TYPE which has
-     not been laid out.  Try to avoid an error by interpreting
-     it as this->X::Y, if reasonable.  */
-  if (TREE_CODE (value) == OFFSET_REF
-      && C_C_D != 0
-      && TREE_OPERAND (value, 0) == C_C_D)
-    {
-      tree base, member = TREE_OPERAND (value, 1);
-      tree basetype = TYPE_OFFSET_BASETYPE (type);
-      my_friendly_assert (TREE_CODE (member) == FIELD_DECL, 305);
-      base = convert_pointer_to (basetype, current_class_decl);
-      value = build (COMPONENT_REF, TREE_TYPE (member),
-		     build_indirect_ref (base, NULL_PTR), member);
-      return require_complete_type (value);
-    }
-
-  incomplete_type_error (value, type);
-  return error_mark_node;
-}
-
-/* Return truthvalue of whether type of EXP is instantiated.  */
-int
-type_unknown_p (exp)
-     tree exp;
-{
-  return (TREE_CODE (exp) == TREE_LIST
-	  || TREE_TYPE (exp) == unknown_type_node
-	  || (TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE
-	      && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node));
-}
-
-/* Do `exp = require_instantiated_type (type, exp);' to make sure EXP
-   does not have an uninstantiated type.
-   TYPE is type to instantiate with, if uninstantiated.  */
-tree
-require_instantiated_type (type, exp, errval)
-     tree type, exp, errval;
-{
-  if (TREE_TYPE (exp) == unknown_type_node
-      || (TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE
-	  && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node))
-    {
-      exp = instantiate_type (type, exp, 1);
-      if (TREE_TYPE (exp) == error_mark_node)
-	return errval;
-    }
-  return exp;
-}
-
-/* Return a variant of TYPE which has all the type qualifiers of LIKE
-   as well as those of TYPE.  */
-
-static tree
-qualify_type (type, like)
-     tree type, like;
-{
-  int constflag = TYPE_READONLY (type) || TYPE_READONLY (like);
-  int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like);
-  /* @@ Must do member pointers here.  */
-  return build_type_variant (type, constflag, volflag);
-}
-
-/* Return the common type of two parameter lists.
-   We assume that comptypes has already been done and returned 1;
-   if that isn't so, this may crash.
-
-   As an optimization, free the space we allocate if the parameter
-   lists are already common.  */
-
-tree
-commonparms (p1, p2)
-     tree p1, p2;
-{
-  tree oldargs = p1, newargs, n;
-  int i, len;
-  int any_change = 0;
-  char *first_obj = (char *) oballoc (0);
-
-  len = list_length (p1);
-  newargs = tree_last (p1);
-
-  if (newargs == void_list_node)
-    i = 1;
-  else
-    {
-      i = 0;
-      newargs = 0;
-    }
-
-  for (; i < len; i++)
-    newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
-
-  n = newargs;
-
-  for (i = 0; p1;
-       p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
-    {
-      if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
-	{
-	  /* We used to give a warning here that advised about a default
-	     argument being given in the prototype but not in the function's
-	     declaration.  It's best not to bother.  */
-	  TREE_PURPOSE (n) = TREE_PURPOSE (p1);
-	  any_change = 1;
-	}
-      else if (! TREE_PURPOSE (p1))
-	{
-	  if (TREE_PURPOSE (p2))
-	    {
-	      TREE_PURPOSE (n) = TREE_PURPOSE (p2);
-	      any_change = 1;
-	    }
-	}
-      else
-	{
-	  int cmp = simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2));
-	  if (cmp < 0)
-	    my_friendly_abort (111);
-	  if (cmp == 0)
-	    {
-	      error ("redeclaration of default argument %d", i+1);
-	      any_change = 1;
-	    }
-	  TREE_PURPOSE (n) = TREE_PURPOSE (p2);
-	}
-      if (TREE_VALUE (p1) != TREE_VALUE (p2))
-	{
-	  any_change = 1;
-	  TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
-	}
-      else
-	TREE_VALUE (n) = TREE_VALUE (p1);
-    }
-  if (! any_change)
-    {
-      obfree (first_obj);
-      return oldargs;
-    }
-
-  return newargs;
-}
-
-/* Return the common type of two types.
-   We assume that comptypes has already been done and returned 1;
-   if that isn't so, this may crash.
-
-   This is the type for the result of most arithmetic operations
-   if the operands have the given two types.
-
-   We do not deal with enumeral types here because they have already been
-   converted to integer types.  */
-
-tree
-common_type (t1, t2)
-     tree t1, t2;
-{
-  register enum tree_code code1;
-  register enum tree_code code2;
-
-  /* Save time if the two types are the same.  */
-
-  if (t1 == t2) return t1;
-
-  /* If one type is nonsense, use the other.  */
-  if (t1 == error_mark_node)
-    return t2;
-  if (t2 == error_mark_node)
-    return t1;
-
-  /* Treat an enum type as the unsigned integer type of the same width.  */
-
-  if (TREE_CODE (t1) == ENUMERAL_TYPE)
-    t1 = type_for_size (TYPE_PRECISION (t1), 1);
-  if (TREE_CODE (t2) == ENUMERAL_TYPE)
-    t2 = type_for_size (TYPE_PRECISION (t2), 1);
-
-  code1 = TREE_CODE (t1);
-  code2 = TREE_CODE (t2);
-
-  switch (code1)
-    {
-    case INTEGER_TYPE:
-    case REAL_TYPE:
-      /* If only one is real, use it as the result.  */
-
-      if (code1 == REAL_TYPE && code2 != REAL_TYPE)
-	return t1;
-
-      if (code2 == REAL_TYPE && code1 != REAL_TYPE)
-	return t2;
-
-      /* Both real or both integers; use the one with greater precision.  */
-
-      if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
-	return t1;
-      else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
-	return t2;
-
-      /* Same precision.  Prefer longs to ints even when same size.  */
-
-      if (t1 == long_unsigned_type_node
-	  || t2 == long_unsigned_type_node)
-	return long_unsigned_type_node;
-
-      if (t1 == long_integer_type_node
-	  || t2 == long_integer_type_node)
-	{
-	  /* But preserve unsignedness from the other type,
-	     since long cannot hold all the values of an unsigned int.  */
-	  if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
-	    return long_unsigned_type_node;
-	  return long_integer_type_node;
-	}
-
-      /* Otherwise prefer the unsigned one.  */
-
-      if (TREE_UNSIGNED (t1))
-	return t1;
-      else return t2;
-
-    case POINTER_TYPE:
-    case REFERENCE_TYPE:
-      /* For two pointers, do this recursively on the target type,
-	 and combine the qualifiers of the two types' targets.  */
-      /* This code was turned off; I don't know why.
- 	 But ANSI C++ specifies doing this with the qualifiers.
- 	 So I turned it on again.  */
-      {
-	tree target = common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
-				   TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
-	int constp
-	  = TYPE_READONLY (TREE_TYPE (t1)) || TYPE_READONLY (TREE_TYPE (t2));
-	int volatilep
-	  = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2));
-	target = build_type_variant (target, constp, volatilep);
-	if (code1 == POINTER_TYPE)
-	  return build_pointer_type (target);
-	else
-	  return build_reference_type (target);
-      }
-#if 0
-    case POINTER_TYPE:
-      return build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
-
-    case REFERENCE_TYPE:
-      return build_reference_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
-#endif
-
-    case ARRAY_TYPE:
-      {
-	tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
-	/* Save space: see if the result is identical to one of the args.  */
-	if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
-	  return t1;
-	if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
-	  return t2;
-	/* Merge the element types, and have a size if either arg has one.  */
-	return build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
-      }
-
-    case FUNCTION_TYPE:
-      /* Function types: prefer the one that specified arg types.
-	 If both do, merge the arg types.  Also merge the return types.  */
-      {
-	tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
-	tree p1 = TYPE_ARG_TYPES (t1);
-	tree p2 = TYPE_ARG_TYPES (t2);
-	tree rval, raises;
-
-	/* Save space: see if the result is identical to one of the args.  */
-	if (valtype == TREE_TYPE (t1) && ! p2)
-	  return t1;
-	if (valtype == TREE_TYPE (t2) && ! p1)
-	  return t2;
-
-	/* Simple way if one arg fails to specify argument types.  */
-	if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
-	  {
-	    rval = build_function_type (valtype, p2);
-	    if (raises = TYPE_RAISES_EXCEPTIONS (t2))
-	      rval = build_exception_variant (NULL_TREE, rval, raises);
-	    return rval;
-	  }
-	raises = TYPE_RAISES_EXCEPTIONS (t1);
-	if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
-	  {
-	    rval = build_function_type (valtype, p1);
-	    if (raises)
-	      rval = build_exception_variant (NULL_TREE, rval, raises);
-	    return rval;
-	  }
-
-	rval = build_function_type (valtype, commonparms (p1, p2));
-	return build_exception_variant (NULL_TREE, rval, raises);
-      }
-
-    case RECORD_TYPE:
-    case UNION_TYPE:
-      my_friendly_assert (TYPE_MAIN_VARIANT (t1) == t1
-			  && TYPE_MAIN_VARIANT (t2) == t2, 306);
-
-      if (binfo_or_else (t1, t2))
-	return t1;
-      compiler_error ("common_type called with uncommon aggregate types");
-      return t1;
-
-    case METHOD_TYPE:
-      if (TYPE_METHOD_BASETYPE (t1) == TYPE_METHOD_BASETYPE (t2)
-	  && TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2)))
-	{
-	  /* Get this value the long way, since TYPE_METHOD_BASETYPE
-	     is just the main variant of this.  */
-	  tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1)));
-	  tree raises, t3;
-
-	  raises = TYPE_RAISES_EXCEPTIONS (t1);
-
-	  /* If this was a member function type, get back to the
-	     original type of type member function (i.e., without
-	     the class instance variable up front.  */
-	  t1 = build_function_type (TREE_TYPE (t1), TREE_CHAIN (TYPE_ARG_TYPES (t1)));
-	  t2 = build_function_type (TREE_TYPE (t2), TREE_CHAIN (TYPE_ARG_TYPES (t2)));
-	  t3 = common_type (t1, t2);
-	  t3 = build_cplus_method_type (basetype, TREE_TYPE (t3), TYPE_ARG_TYPES (t3));
-	  return build_exception_variant (basetype, t3, raises);
-	}
-      compiler_error ("common_type called with uncommon method types");
-      return t1;
-
-    case OFFSET_TYPE:
-      if (TYPE_OFFSET_BASETYPE (t1) == TYPE_OFFSET_BASETYPE (t2)
-	  && TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2)))
-	{
-	  tree basetype = TYPE_OFFSET_BASETYPE (t1);
-	  return build_offset_type (basetype,
-				    common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
-	}
-      compiler_error ("common_type called with uncommon member types");
-      return t1;
-
-    default:
-      return t1;
-    }
-}
-
-/* Return 1 if TYPE1 and TYPE2 raise the same exceptions.  */
-int
-compexcepttypes (t1, t2, strict)
-     tree t1, t2;
-     int strict;
-{
-  return TYPE_RAISES_EXCEPTIONS (t1) == TYPE_RAISES_EXCEPTIONS (t2);
-}
-
-static int
-comp_array_types (cmp, t1, t2, strict)
-     register int (*cmp)();
-     tree t1, t2;
-     int strict;
-{
-  tree d1 = TYPE_DOMAIN (t1);
-  tree d2 = TYPE_DOMAIN (t2);
-
-  /* Target types must match incl. qualifiers.  */
-  if (!(TREE_TYPE (t1) == TREE_TYPE (t2)
-	|| (*cmp) (TREE_TYPE (t1), TREE_TYPE (t2), strict)))
-    return 0;
-
-  /* Sizes must match unless one is missing or variable.  */
-  if (d1 == 0 || d2 == 0 || d1 == d2
-      || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
-      || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
-      || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
-      || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
-    return 1;
-
-  return ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
-	   == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
-	  && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
-	      == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
-	  && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
-	      == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
-	  && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
-	      == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2))));
-}
-
-/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
-   or various other operations.  This is what ANSI C++ speaks of as
-   "being the same".
-
-   For C++: argument STRICT says we should be strict about this
-   comparison:
-
-	1 : strict (compared according to ANSI C)
-	0 : <= (compared according to C++)
-	-1: <= or >= (relaxed)
-
-   Otherwise, pointers involving base classes and derived classes
-   can be mixed as legal: i.e. a pointer to a base class may be assigned
-   to a pointer to one of its derived classes, as per C++. A pointer to
-   a derived class may be passed as a parameter to a function expecting a
-   pointer to a base classes. These allowances do not commute. In this
-   case, TYPE1 is assumed to be the base class, and TYPE2 is assumed to
-   be the derived class.  */
-int
-comptypes (type1, type2, strict)
-     tree type1, type2;
-     int strict;
-{
-  register tree t1 = type1;
-  register tree t2 = type2;
-
-  /* Suppress errors caused by previously reported errors */
-
-  if (t1 == t2)
-    return 1;
-  /* This should never happen.  */
-  my_friendly_assert (t1 != error_mark_node, 307);
-
-  /* We don't want this to happen.  */
-  if (t2 == error_mark_node)
-    {
-      warning ("Internal error: t2 == error_mark_node in `comptypes'");
-      return 0;
-    }
-
-  if (strict < 0)
-    {
-      /* Treat an enum type as the unsigned integer type of the same width.  */
-
-      if (TREE_CODE (t1) == ENUMERAL_TYPE)
-	t1 = type_for_size (TYPE_PRECISION (t1), 1);
-      if (TREE_CODE (t2) == ENUMERAL_TYPE)
-	t2 = type_for_size (TYPE_PRECISION (t2), 1);
-    }
-
-  if (t1 == t2)
-    return 1;
-
-  /* Different classes of types can't be compatible.  */
-
-  if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
-
-  /* Qualifiers must match.  */
-
-  if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
-    return 0;
-  if (TREE_THIS_VOLATILE (t1) != TREE_THIS_VOLATILE (t2))
-    return 0;
-
-  switch (TREE_CODE (t1))
-    {
-    case RECORD_TYPE:
-    case UNION_TYPE:
-      if (t1 == t2)
-	return 1;
-      if (strict <= 0)
-	goto look_hard;
-      return 0;
-
-    case OFFSET_TYPE:
-      return (comptypes (TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t1)),
-			 TYPE_POINTER_TO (TYPE_OFFSET_BASETYPE (t2)), strict)
-	      && comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict));
-
-    case METHOD_TYPE:
-      if (! compexcepttypes (t1, t2, strict))
-	return 0;
-
-      /* This case is anti-symmetrical!
-	 One can pass a base member (or member function)
-	 to something expecting a derived member (or member function),
-	 but not vice-versa!  */
-
-      return (comptypes (TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t2)),
-			 TYPE_POINTER_TO (TYPE_METHOD_BASETYPE (t1)), strict)
-	      && comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict)
-	      && compparms (TREE_CHAIN (TYPE_ARG_TYPES (t1)),
-			    TREE_CHAIN (TYPE_ARG_TYPES(t2)), strict));
-    case POINTER_TYPE:
-    case REFERENCE_TYPE:
-      t1 = TREE_TYPE (t1);
-      t2 = TREE_TYPE (t2);
-      if (t1 == t2)
-	return 1;
-      if (strict <= 0)
-	{
-	  if (TREE_CODE (t1) == RECORD_TYPE && TREE_CODE (t2) == RECORD_TYPE)
-	    {
-	      int rval;
-	    look_hard:
-	      rval = t1 == t2 || UNIQUELY_DERIVED_FROM_P (t1, t2);
-
-	      if (rval)
-		return 1;
-	      if (strict < 0)
-		return UNIQUELY_DERIVED_FROM_P (t2, t1);
-	    }
-	  return 0;
-	}
-      else
-	return comptypes (t1, t2, strict);
-
-    case FUNCTION_TYPE:
-      if (! compexcepttypes (t1, t2, strict))
-	return 0;
-
-      return ((TREE_TYPE (t1) == TREE_TYPE (t2)
-	       || comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict))
-	      && compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2), strict));
-
-    case ARRAY_TYPE:
-      /* Target types must match incl. qualifiers.  */
-      return comp_array_types (comptypes, t1, t2, strict);
-
-    }
-  return 0;
-}
-
-/* Return 1 if TTL and TTR are pointers to types that are equivalent,
-   ignoring their qualifiers.
-
-   NPTRS is the number of pointers we can strip off and keep cool.
-   This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
-   but to not permit B** to convert to A**.  */
-
-int
-comp_target_types (ttl, ttr, nptrs)
-     tree ttl, ttr;
-     int nptrs;
-{
-  ttl = TYPE_MAIN_VARIANT (ttl);
-  ttr = TYPE_MAIN_VARIANT (ttr);
-  if (ttl == ttr)
-    return 1;
-
-  if (TREE_CODE (ttr) != TREE_CODE (ttl))
-    return 0;
-
-  if (TREE_CODE (ttr) == POINTER_TYPE)
-    return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs - 1);
-
-  if (TREE_CODE (ttr) == REFERENCE_TYPE)
-    return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs);
-  if (TREE_CODE (ttr) == ARRAY_TYPE)
-    return comp_array_types (comp_target_types, ttl, ttr, 0);
-  else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE)
-    if (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs))
-      switch (comp_target_parms (TYPE_ARG_TYPES (ttl), TYPE_ARG_TYPES (ttr), 0))
-	{
-	case 0:
-	  return 0;
-	case 1:
-	  return 1;
-	case 2:
-	  warning ("contravariance violation for method types ignored");
-	  return 1;
-	default:
-	  my_friendly_abort (112);
-	}
-    else
-      return 0;
-
-  /* for C++ */
-  else if (TREE_CODE (ttr) == OFFSET_TYPE)
-    {
-      /* Contravariance: we can assign a pointer to base member to a pointer
-	 to derived member.  Note difference from simple pointer case, where
-	 we can pass a pointer to derived to a pointer to base.  */
-      if (comptypes (TYPE_OFFSET_BASETYPE (ttr), TYPE_OFFSET_BASETYPE (ttl), 0))
-	return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs);
-      else if (comptypes (TYPE_OFFSET_BASETYPE (ttl), TYPE_OFFSET_BASETYPE (ttr), 0)
-	       && comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs))
-	{
-	  warning ("contravariance violation for member types ignored");
-	  return 1;
-	}
-    }
-  else if (IS_AGGR_TYPE (ttl))
-    {
-      if (nptrs < 0)
-	return 0;
-      return comptypes (TYPE_POINTER_TO (ttl), TYPE_POINTER_TO (ttr), 0);
-    }
-
-  return 0;
-}
-
-/* If two types share a common base type, return that basetype.
-   If there is not a unique most-derived base type, this function
-   returns ERROR_MARK_NODE.  */
-tree
-common_base_type (tt1, tt2)
-     tree tt1, tt2;
-{
-  tree best = NULL_TREE, tmp;
-  int i;
-
-  /* If one is a baseclass of another, that's good enough.  */
-  if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
-    return tt1;
-  if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
-    return tt2;
-
-  /* If they share a virtual baseclass, that's good enough.  */
-  for (tmp = CLASSTYPE_VBASECLASSES (tt1); tmp; tmp = TREE_CHAIN (tmp))
-    {
-      if (binfo_member (BINFO_TYPE (tmp), CLASSTYPE_VBASECLASSES (tt2)))
-	return BINFO_TYPE (tmp);
-    }
-
-  /* Otherwise, try to find a unique baseclass of TT1
-     that is shared by TT2, and follow that down.  */
-  for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--)
-    {
-      tree basetype = TYPE_BINFO_BASETYPE (tt1, i);
-      tree trial = common_base_type (basetype, tt2);
-      if (trial)
-	{
-	  if (trial == error_mark_node)
-	    return trial;
-	  if (best == NULL_TREE)
-	    best = trial;
-	  else if (best != trial)
-	    return error_mark_node;
-	}
-    }
-
-  /* Same for TT2.  */
-  for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--)
-    {
-      tree basetype = TYPE_BINFO_BASETYPE (tt2, i);
-      tree trial = common_base_type (tt1, basetype);
-      if (trial)
-	{
-	  if (trial == error_mark_node)
-	    return trial;
-	  if (best == NULL_TREE)
-	    best = trial;
-	  else if (best != trial)
-	    return error_mark_node;
-	}
-    }
-  return best;
-}
-
-/* Subroutines of `comptypes'.  */
-
-/* Return 1 if two parameter type lists PARMS1 and PARMS2
-   are equivalent in the sense that functions with those parameter types
-   can have equivalent types.
-   If either list is empty, we win.
-   Otherwise, the two lists must be equivalent, element by element.
-
-   C++: See comment above about TYPE1, TYPE2, STRICT.
-   If STRICT == 3, it means checking is strict, but do not compare
-   default parameter values.  */
-int
-compparms (parms1, parms2, strict)
-     tree parms1, parms2;
-     int strict;
-{
-  register tree t1 = parms1, t2 = parms2;
-
-  /* An unspecified parmlist matches any specified parmlist
-     whose argument types don't need default promotions.  */
-
-  if (t1 == 0)
-    return self_promoting_args_p (t2);
-  if (t2 == 0)
-    return self_promoting_args_p (t1);
-
-  while (1)
-    {
-      if (t1 == 0 && t2 == 0)
-	return 1;
-      /* If one parmlist is shorter than the other,
-	 they fail to match, unless STRICT is <= 0.  */
-      if (t1 == 0 || t2 == 0)
-	{
-	  if (strict > 0)
-	    return 0;
-	  if (strict < 0)
-	    return 1;
-	  if (strict == 0)
-	    return t1 && TREE_PURPOSE (t1);
-	}
-      if (! comptypes (TREE_VALUE (t2), TREE_VALUE (t1), strict))
-	{
-	  if (strict > 0)
-	    return 0;
-	  if (strict == 0)
-	    return t2 == void_list_node && TREE_PURPOSE (t1);
-	  return TREE_PURPOSE (t1) || TREE_PURPOSE (t2);
-	}
-      if (strict != 3 && TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
-	{
-	  int cmp = simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
-	  if (cmp < 0)
-	    my_friendly_abort (113);
-	  if (cmp == 0)
-	    return 0;
-	}
-
-      t1 = TREE_CHAIN (t1);
-      t2 = TREE_CHAIN (t2);
-    }
-}
-
-/* This really wants return whether or not parameter type lists
-   would make their owning functions assignment compatible or not.  */
-int
-comp_target_parms (parms1, parms2, strict)
-     tree parms1, parms2;
-     int strict;
-{
-  register tree t1 = parms1, t2 = parms2;
-  int warn_contravariance = 0;
-
-  /* An unspecified parmlist matches any specified parmlist
-     whose argument types don't need default promotions.  */
-
-  if (t1 == 0)
-    return self_promoting_args_p (t2);
-  if (t2 == 0)
-    return self_promoting_args_p (t1);
-
-  for (; t1 || t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
-    {
-      tree p1, p2;
-
-      /* If one parmlist is shorter than the other,
-	 they fail to match, unless STRICT is <= 0.  */
-      if (t1 == 0 || t2 == 0)
-	{
-	  if (strict > 0)
-	    return 0;
-	  if (strict < 0)
-	    return 1 + warn_contravariance;
-	  return ((t1 && TREE_PURPOSE (t1)) + warn_contravariance);
-	}
-      p1 = TREE_VALUE (t1);
-      p2 = TREE_VALUE (t2);
-      if (p1 == p2)
-	continue;
-      if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE)
-	  || (TREE_CODE (p1) == REFERENCE_TYPE && TREE_CODE (p2) == REFERENCE_TYPE))
-	{
-	  if (strict <= 0
-	      && (TYPE_MAIN_VARIANT (TREE_TYPE (p1))
-		  == TYPE_MAIN_VARIANT (TREE_TYPE (p2))))
-	    continue;
-
-	  /* The following is wrong for contravariance,
-	     but many programs depend on it.  */
-	  if (TREE_TYPE (p1) == void_type_node)
-	    continue;
-	  if (TREE_TYPE (p2) == void_type_node)
-	    {
-	      warn_contravariance = 1;
-	      continue;
-	    }
-	  if (IS_AGGR_TYPE (TREE_TYPE (p1)))
-	    {
-	      if (comptypes (p2, p1, 0) == 0)
-		{
-		  if (comptypes (p1, p2, 0) != 0)
-		    warn_contravariance = 1;
-		  else
-		    return 0;
-		}
-	      continue;
-	    }
-	}
-      /* Note backwards order due to contravariance.  */
-      if (comp_target_types (p2, p1, 1) == 0)
-	{
-	  if (comp_target_types (p1, p2, 1))
-	    {
-	      warn_contravariance = 1;
-	      continue;
-	    }
-	  if (strict > 0)
-	    return 0;
-#if 0
-	  /* What good do these cases do?  */
-	  if (strict == 0)
-	    return p2 == void_type_node && TREE_PURPOSE (t1);
-	  return TREE_PURPOSE (t1) || TREE_PURPOSE (t2);
-#endif
-	}
-      /* Target types are compatible--just make sure that if
-	 we use parameter lists, that they are ok as well.  */
-      if (TREE_CODE (p1) == FUNCTION_TYPE || TREE_CODE (p1) == METHOD_TYPE)
-	switch (comp_target_parms (TYPE_ARG_TYPES (p1),
-				   TYPE_ARG_TYPES (p2),
-				   strict))
-	  {
-	  case 0:
-	    return 0;
-	  case 1:
-	    break;
-	  case 2:
-	    warn_contravariance = 1;
-	  }
-
-      if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
-	{
-	  int cmp = simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
-	  if (cmp < 0)
-	    my_friendly_abort (114);
-	  if (cmp == 0)
-	    return 0;
-	}
-    }
-  return 1 + warn_contravariance;
-}
-
-/* Return 1 if PARMS specifies a fixed number of parameters
-   and none of their types is affected by default promotions.  */
-
-static int
-self_promoting_args_p (parms)
-     tree parms;
-{
-  register tree t;
-  for (t = parms; t; t = TREE_CHAIN (t))
-    {
-      register tree type = TREE_VALUE (t);
-
-      if (TREE_CHAIN (t) == 0 && type != void_type_node)
-	return 0;
-
-      if (TYPE_MAIN_VARIANT (type) == float_type_node)
-	return 0;
-
-      if (type == 0)
-	return 0;
-
-      if (C_PROMOTING_INTEGER_TYPE_P (type))
-	return 0;
-    }
-  return 1;
-}
-
-/* Return an unsigned type the same as TYPE in other respects.
-
-   C++: must make these work for type variants as well.  */
-
-tree
-unsigned_type (type)
-     tree type;
-{
-  tree type1 = TYPE_MAIN_VARIANT (type);
-  if (type1 == signed_char_type_node || type1 == char_type_node)
-    return unsigned_char_type_node;
-  if (type1 == integer_type_node)
-    return unsigned_type_node;
-  if (type1 == short_integer_type_node)
-    return short_unsigned_type_node;
-  if (type1 == long_integer_type_node)
-    return long_unsigned_type_node;
-  if (type1 == long_long_integer_type_node)
-    return long_long_unsigned_type_node;
-  return type;
-}
-
-/* Return a signed type the same as TYPE in other respects.  */
-
-tree
-signed_type (type)
-     tree type;
-{
-  tree type1 = TYPE_MAIN_VARIANT (type);
-  if (type1 == unsigned_char_type_node || type1 == char_type_node)
-    return signed_char_type_node;
-  if (type1 == unsigned_type_node)
-    return integer_type_node;
-  if (type1 == short_unsigned_type_node)
-    return short_integer_type_node;
-  if (type1 == long_unsigned_type_node)
-    return long_integer_type_node;
-  if (type1 == long_long_unsigned_type_node)
-    return long_long_integer_type_node;
-  return type;
-}
-
-/* Return a type the same as TYPE except unsigned or
-   signed according to UNSIGNEDP.  */
-
-tree
-signed_or_unsigned_type (unsignedp, type)
-     int unsignedp;
-     tree type;
-{
-  if (TREE_CODE (type) != INTEGER_TYPE)
-    return type;
-  if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
-    return unsignedp ? unsigned_char_type_node : signed_char_type_node;
-  if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 
-    return unsignedp ? unsigned_type_node : integer_type_node;
-  if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node)) 
-    return unsignedp ? short_unsigned_type_node : short_integer_type_node;
-  if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node)) 
-    return unsignedp ? long_unsigned_type_node : long_integer_type_node;
-  if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node)) 
-    return (unsignedp ? long_long_unsigned_type_node
-	    : long_long_integer_type_node);
-  return type;
-}
-
-tree
-c_sizeof (type)
-     tree type;
-{
-  enum tree_code code = TREE_CODE (type);
-  tree t;
-
-  if (code == FUNCTION_TYPE)
-    {
-      if (pedantic || warn_pointer_arith)
-	pedwarn ("ANSI C++ forbids taking the sizeof a function type");
-      return size_int (1);
-    }
-  if (code == METHOD_TYPE)
-    {
-      if (pedantic || warn_pointer_arith)
-	pedwarn ("ANSI C++ forbids taking the sizeof a method type");
-      return size_int (1);
-    }
-  if (code == VOID_TYPE)
-    {
-      if (pedantic || warn_pointer_arith)
-	pedwarn ("ANSI C++ forbids taking the sizeof a void type");
-      return size_int (1);
-    }
-  if (code == ERROR_MARK)
-    return size_int (1);
-
-  /* ARM $5.3.2: ``When applied to a reference, the result is the size of the
-     referenced object.'' */
-  if (code == REFERENCE_TYPE)
-    type = TREE_TYPE (type);
-
-  if (TYPE_SIZE (type) == 0)
-    {
-      error ("sizeof applied to an incomplete type");
-      return size_int (0);
-    }
-
-  /* Convert in case a char is more than one unit.  */
-  t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), 
-		  size_int (TYPE_PRECISION (char_type_node)));
-  force_fit_type (t, 0);
-  return t;
-}
-
-tree
-c_sizeof_nowarn (type)
-     tree type;
-{
-  enum tree_code code = TREE_CODE (type);
-  tree t;
-
-  if (code == FUNCTION_TYPE
-      || code == METHOD_TYPE
-      || code == VOID_TYPE
-      || code == ERROR_MARK)
-    return size_int (1);
-  if (code == REFERENCE_TYPE)
-    type = TREE_TYPE (type);
-
-  if (TYPE_SIZE (type) == 0)
-    {
-      /* ??? Tiemann, why have any diagnostic here?
-	 There is none in the corresponding function for C.  */
-      warning ("sizeof applied to an incomplete type");
-      return size_int (0);
-    }
-
-  /* Convert in case a char is more than one unit.  */
-  t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), 
-		     size_int (TYPE_PRECISION (char_type_node)));
-  force_fit_type (t, 0);
-  return t;
-}
-
-/* Implement the __alignof keyword: Return the minimum required
-   alignment of TYPE, measured in bytes.  */
-
-tree
-c_alignof (type)
-     tree type;
-{
-  enum tree_code code = TREE_CODE (type);
-  tree t;
-
-  if (code == FUNCTION_TYPE || code == METHOD_TYPE)
-    return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
-
-  if (code == VOID_TYPE || code == ERROR_MARK)
-    return size_int (1);
-
-  /* C++: this is really correct!  */
-  if (code == REFERENCE_TYPE)
-    type = TREE_TYPE (type);
-
-  t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
-  force_fit_type (t, 0);
-  return t;
-}
-
-/* Perform default promotions for C data used in expressions.
-   Arrays and functions are converted to pointers;
-   enumeral types or short or char, to int.
-   In addition, manifest constants symbols are replaced by their values.
-
-   C++: this will automatically bash references to their target type.  */
-
-tree
-default_conversion (exp)
-     tree exp;
-{
-  register tree type = TREE_TYPE (exp);
-  register enum tree_code code = TREE_CODE (type);
-
-  if (code == OFFSET_TYPE /* || TREE_CODE (exp) == OFFSET_REF */ )
-    {
-      if (TREE_CODE (exp) == OFFSET_REF)
-	return default_conversion (resolve_offset_ref (exp));
-
-      type = TREE_TYPE (type);
-      code = TREE_CODE (type);
-    }
-
-  if (code == REFERENCE_TYPE)
-    {
-      exp = convert_from_reference (exp);
-      type = TREE_TYPE (exp);
-      code = TREE_CODE (type);
-    }
-
-  /* Constants can be used directly unless they're not loadable.  */
-  if (TREE_CODE (exp) == CONST_DECL)
-    exp = DECL_INITIAL (exp);
-  /* Replace a nonvolatile const static variable with its value.  */
-  else if (TREE_READONLY_DECL_P (exp) && DECL_MODE (exp) != BLKmode)
-    {
-      exp = decl_constant_value (exp);
-      type = TREE_TYPE (exp);
-    }
-
-  /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
-     Strip such NOP_EXPRs, since EXP is being used in non-lvalue context.  */
-  if (TREE_CODE (exp) == NOP_EXPR
-      && TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0)))
-    exp = TREE_OPERAND (exp, 0);
-
-  /* Normally convert enums to int,
-     but convert wide enums to something wider.  */
-  if (code == ENUMERAL_TYPE)
-    {
-      type = type_for_size (MAX (TYPE_PRECISION (type),
-				 TYPE_PRECISION (integer_type_node)),
-			    (flag_traditional && TREE_UNSIGNED (type)));
-      return convert (type, exp);
-    }
-
-  if (C_PROMOTING_INTEGER_TYPE_P (type))
-    {
-      /* Traditionally, unsignedness is preserved in default promotions.
-         Otherwise, retain unsignedness if really not getting bigger.  */
-      if (TREE_UNSIGNED (type)
-	  && (flag_traditional
-	      || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
-	return convert (unsigned_type_node, exp);
-      return convert (integer_type_node, exp);
-    }
-  if (flag_traditional
-      && TYPE_MAIN_VARIANT (type) == float_type_node)
-    return convert (double_type_node, exp);
-  if (code == VOID_TYPE)
-    {
-      error ("void value not ignored as it ought to be");
-      return error_mark_node;
-    }
-  if (code == FUNCTION_TYPE)
-    {
-      return build_unary_op (ADDR_EXPR, exp, 0);
-    }
-  if (code == METHOD_TYPE)
-    {
-      if (TREE_CODE (exp) == OFFSET_REF)
-	{
-	  my_friendly_assert (TREE_CODE (TREE_OPERAND (exp, 1)) == FUNCTION_DECL,
-			      308);
-	  return build_unary_op (ADDR_EXPR, TREE_OPERAND (exp, 1), 0);
-	}
-      return build_unary_op (ADDR_EXPR, exp, 0);
-    }
-  if (code == ARRAY_TYPE)
-    {
-      register tree adr;
-      tree restype = TREE_TYPE (type);
-      tree ptrtype;
-
-      if (TREE_CODE (exp) == INDIRECT_REF)
-	{
-	  /* Stripping away the INDIRECT_REF is not the right
-	     thing to do for references...  */
-	  tree inner = TREE_OPERAND (exp, 0);
-	  if (TREE_CODE (TREE_TYPE (inner)) == REFERENCE_TYPE)
-	    {
-	      inner = build1 (CONVERT_EXPR,
-			      build_pointer_type (TREE_TYPE (TREE_TYPE (inner))),
-			      inner);
-	      TREE_REFERENCE_EXPR (inner) = 1;
-	    }
-	  return convert (TYPE_POINTER_TO (TREE_TYPE (type)), inner);
-	}
-
-      if (TREE_CODE (exp) == COMPOUND_EXPR)
-	{
-	  tree op1 = default_conversion (TREE_OPERAND (exp, 1));
-	  return build (COMPOUND_EXPR, TREE_TYPE (op1),
-			TREE_OPERAND (exp, 0), op1);
-	}
-
-      if (!lvalue_p (exp)
-	  && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
-	{
-	  error ("invalid use of non-lvalue array");
-	  return error_mark_node;
-	}
-
-      if (TYPE_READONLY (type) || TYPE_VOLATILE (type))
-	restype = build_type_variant (restype, TYPE_READONLY (type),
-				      TYPE_VOLATILE (type));
-
-      ptrtype = build_pointer_type (restype);
-
-      if (TREE_CODE (exp) == VAR_DECL)
-	{
-	  /* ??? This is not really quite correct
-	     in that the type of the operand of ADDR_EXPR
-	     is not the target type of the type of the ADDR_EXPR itself.
-	     Question is, can this lossage be avoided?  */
-	  adr = build1 (ADDR_EXPR, ptrtype, exp);
-	  if (mark_addressable (exp) == 0)
-	    return error_mark_node;
-	  TREE_CONSTANT (adr) = staticp (exp);
-	  TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
-	  return adr;
-	}
-      /* This way is better for a COMPONENT_REF since it can
-	 simplify the offset for a component.  */
-      adr = build_unary_op (ADDR_EXPR, exp, 1);
-      return convert (ptrtype, adr);
-    }
-  return exp;
-}
-
-/* Like `build_component_ref, but uses an already found field.
-   Must compute visibility for C_C_D.  Otherwise, ok.  */
-tree
-build_component_ref_1 (datum, field, protect)
-     tree datum, field;
-     int protect;
-{
-  register tree basetype = TREE_TYPE (datum);
-  register enum tree_code code = TREE_CODE (basetype);
-  register tree ref;
-
-  if (code == REFERENCE_TYPE)
-    {
-      datum = convert_from_reference (datum);
-      basetype = TREE_TYPE (datum);
-      code = TREE_CODE (basetype);
-    }
-
-  if (! IS_AGGR_TYPE_CODE (code))
-    {
-      if (code != ERROR_MARK)
-	error_with_decl (field, "request for member `%s' in something not a class, structure or union");
-      return error_mark_node;
-    }
-
-  if (TYPE_SIZE (basetype) == 0)
-    {
-      incomplete_type_error (0, basetype);
-      return error_mark_node;
-    }
-
-  /* Look up component name in the structure type definition.  */
-
-  if (field == error_mark_node)
-    my_friendly_abort (115);
-
-  if (TREE_STATIC (field))
-    return field;
-
-  if (datum == C_C_D && ! DECL_PUBLIC (field))
-    {
-      enum visibility_type visibility
-	= compute_visibility (TYPE_BINFO (current_class_type), field);
-
-    if (visibility == visibility_private)
-      {
-	error_with_decl (field, "field `%s' is private");
-	return error_mark_node;
-      }
-    else if (visibility == visibility_protected)
-      {
-	error_with_decl (field, "field `%s' is protected");
-	return error_mark_node;
-      }
-    }
-
-  ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
-
-  if (TREE_READONLY (datum) || TREE_READONLY (field))
-    TREE_READONLY (ref) = 1;
-  if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
-    TREE_THIS_VOLATILE (ref) = 1;
-
-  return ref;
-}
-
-tree
-build_component_ref (datum, component, basetype_path, protect)
-     tree datum, component, basetype_path;
-     int protect;
-{
-  register tree basetype = TREE_TYPE (datum);
-  register enum tree_code code = TREE_CODE (basetype);
-  register tree field = NULL;
-  register tree ref;
-
-  /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
-     unless we are not to support things not strictly ANSI.  */
-  switch (TREE_CODE (datum))
-    {
-    case COMPOUND_EXPR:
-      {
-	tree value = build_component_ref (TREE_OPERAND (datum, 1), component,
-					  basetype_path, protect);
-	return build (COMPOUND_EXPR, TREE_TYPE (value),
-		      TREE_OPERAND (datum, 0), value);
-      }
-    case COND_EXPR:
-      return build_conditional_expr
-	(TREE_OPERAND (datum, 0),
-	 build_component_ref (TREE_OPERAND (datum, 1), component,
-			      basetype_path, protect),
-	 build_component_ref (TREE_OPERAND (datum, 2), component,
-			      basetype_path, protect));
-    }
-
-  if (code == REFERENCE_TYPE)
-    {
-#if 0
-      /* TREE_REFERENCE_EXPRs are not converted by `convert_from_reference'.
-	 @@ Maybe that is not right.  */
-      if (TREE_REFERENCE_EXPR (datum))
-	datum = build1 (INDIRECT_REF, TREE_TYPE (basetype), datum);
-      else
-#endif
-	datum = convert_from_reference (datum);
-      basetype = TREE_TYPE (datum);
-      code = TREE_CODE (basetype);
-    }
-
-  /* First, see if there is a field or component with name COMPONENT. */
-  if (TREE_CODE (component) == TREE_LIST)
-    {
-      my_friendly_assert (!(TREE_CHAIN (component) == NULL_TREE
-		&& DECL_CHAIN (TREE_VALUE (component)) == NULL_TREE), 309);
-      return build (COMPONENT_REF, TREE_TYPE (component), datum, component);
-    }
-  if (TREE_CODE (component) == TYPE_EXPR)
-    return build_component_type_expr (datum, component, NULL_TREE, protect);
-
-  if (! IS_AGGR_TYPE_CODE (code))
-    {
-      if (code != ERROR_MARK)
-	error ("request for member `%s' in something not a class, structure or union",
-	       IDENTIFIER_POINTER (component));
-      return error_mark_node;
-    }
-
-  if (TYPE_SIZE (basetype) == 0)
-    {
-      incomplete_type_error (0, basetype);
-      return error_mark_node;
-    }
-
-  if (TREE_CODE (component) == BIT_NOT_EXPR)
-    {
-      if (TYPE_IDENTIFIER (basetype) != TREE_OPERAND (component, 0))
-	{
-	  error_with_aggr_type (basetype,
-				"destructor specifier `%s::~%s' must have matching names",
-				IDENTIFIER_POINTER (TREE_OPERAND (component, 0)));
-	  return error_mark_node;
-	}
-      if (! TYPE_HAS_DESTRUCTOR (basetype))
-	{
-	  error_with_aggr_type (basetype, "type `%s' has no destructor");
-	  return error_mark_node;
-	}
-      return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0);
-    }
-
-  /* Look up component name in the structure type definition.  */
-  if (CLASSTYPE_VFIELD (basetype)
-      && DECL_NAME (CLASSTYPE_VFIELD (basetype)) == component)
-    /* Special-case this because if we use normal lookups in an ambiguous
-       hierarchy, the compiler will abort (because vptr lookups are
-       not supposed to be ambiguous.  */
-    field = CLASSTYPE_VFIELD (basetype);
-  else
-    {
-      if (basetype_path == NULL_TREE)
-	basetype_path = TYPE_BINFO (basetype);
-      field = lookup_field (basetype_path, component,
-			    protect && ! VFIELD_NAME_P (component), 0);
-      if (field == error_mark_node)
-	return error_mark_node;
-
-      if (field == NULL_TREE)
-	{
-	  /* Not found as a data field, look for it as a method.  If found,
-	     then if this is the only possible one, return it, else
-	     report ambiguity error.  */
-	  tree fndecls = lookup_fnfields (basetype_path, component, 1);
-	  if (fndecls == error_mark_node)
-	    return error_mark_node;
-	  if (fndecls)
-	    {
-	      if (TREE_CHAIN (fndecls) == NULL_TREE
-		  && DECL_CHAIN (TREE_VALUE (fndecls)) == NULL_TREE)
-		{
-		  enum visibility_type visibility;
-		  tree fndecl;
-
-		  /* Unique, so use this one now.  */
-		  basetype = TREE_PURPOSE (fndecls);
-		  fndecl = TREE_VALUE (fndecls);
-		  visibility = compute_visibility (TREE_PURPOSE (fndecls), fndecl);
-		  if (visibility == visibility_public)
-		    {
-		      if (DECL_VINDEX (fndecl)
-			  && ! resolves_to_fixed_type_p (datum, 0))
-			{
-			  tree addr = build_unary_op (ADDR_EXPR, datum, 0);
-			  addr = convert_pointer_to (DECL_CONTEXT (fndecl), addr);
-			  datum = build_indirect_ref (addr, NULL_PTR);
-			  my_friendly_assert (datum != error_mark_node, 310);
-			  fndecl = build_vfn_ref (&addr, datum, DECL_VINDEX (fndecl));
-			}
-		      return fndecl;
-		    }
-		  if (visibility == visibility_protected)
-		    error_with_decl (fndecl, "member function `%s' is protected");
-		  else
-		    error_with_decl (fndecl, "member function `%s' is private");
-		  return error_mark_node;
-		}
-	      else
-		return build (COMPONENT_REF, unknown_type_node, datum, fndecls);
-	    }
-
-	  if (component == ansi_opname[(int) TYPE_EXPR])
-	    error ("%s has no such type conversion operator",
-		   code == RECORD_TYPE ? "structure" : "union");
-	  else
-	    error (code == RECORD_TYPE
-		   ? "structure has no member named `%s'"
-		   : "union has no member named `%s'",
-		   IDENTIFIER_POINTER (component));
-	  return error_mark_node;
-	}
-      else if (TREE_TYPE (field) == error_mark_node)
-	return error_mark_node;
-
-      if (TREE_CODE (field) != FIELD_DECL)
-	{
-	  if (TREE_CODE (field) == TYPE_DECL)
-	    {
-	      error ("invalid use of type decl `%s' as expression",
-		     IDENTIFIER_POINTER (DECL_NAME (field)));
-	      return error_mark_node;
-	    }
- 	  if (DECL_RTL (field) != 0)
-	    assemble_external (field);
-	  TREE_USED (field) = 1;
-	  return field;
-	}
-    }
-
-  if (DECL_FIELD_CONTEXT (field) != basetype
-      && TYPE_USES_COMPLEX_INHERITANCE (basetype))
-    {
-      tree addr = build_unary_op (ADDR_EXPR, datum, 0);
-      if (integer_zerop (addr))
-	{
-	  error ("invalid reference to NULL ptr, use ptr-to-member instead");
-	  return error_mark_node;
-	}
-      addr = convert_pointer_to (DECL_FIELD_CONTEXT (field), addr);
-      datum = build_indirect_ref (addr, NULL_PTR);
-      my_friendly_assert (datum != error_mark_node, 311);
-    }
-  ref = build (COMPONENT_REF, TREE_TYPE (field), break_out_cleanups (datum), field);
-
-  if (TREE_READONLY (datum) || TREE_READONLY (field))
-    TREE_READONLY (ref) = 1;
-  if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
-    TREE_THIS_VOLATILE (ref) = 1;
-
-  return ref;
-}
-
-/* Given an expression PTR for a pointer, return an expression
-   for the value pointed to.
-   ERRORSTRING is the name of the operator to appear in error messages.
-
-   This function may need to overload OPERATOR_FNNAME.
-   Must also handle REFERENCE_TYPEs for C++.  */
-
-tree
-build_x_indirect_ref (ptr, errorstring)
-     tree ptr;
-     char *errorstring;
-{
-  tree rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE, NULL_TREE);
-
-  if (rval) return rval;
-  return build_indirect_ref (ptr, errorstring);
-}
-
-tree
-build_indirect_ref (ptr, errorstring)
-     tree ptr;
-     char *errorstring;
-{
-  register tree pointer = default_conversion (ptr);
-  register tree type = TREE_TYPE (pointer);
-
-  if (ptr == current_class_decl)
-    return C_C_D;
-
-  if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
-    if (TREE_CODE (pointer) == ADDR_EXPR
-	&& (TREE_TYPE (TREE_OPERAND (pointer, 0))
-	    == TREE_TYPE (type)))
-      return TREE_OPERAND (pointer, 0);
-    else
-      {
-	tree t = TREE_TYPE (type);
-	register tree ref = build1 (INDIRECT_REF,
-				    TYPE_MAIN_VARIANT (t), pointer);
-
-	TREE_READONLY (ref) = TYPE_READONLY (t);
-	TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
-	TREE_SIDE_EFFECTS (ref)
-	  = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
-	return ref;
-      }
-  else if (pointer != error_mark_node)
-    {
-      if (errorstring)
-	error ("invalid type argument of `%s'", errorstring);
-      else
-	error ("invalid type argument");
-    }
-  return error_mark_node;
-}
-
-/* This handles expressions of the form "a[i]", which denotes
-   an array reference.
-
-   This is logically equivalent in C to *(a+i), but we may do it differently.
-   If A is a variable or a member, we generate a primitive ARRAY_REF.
-   This avoids forcing the array out of registers, and can work on
-   arrays that are not lvalues (for example, members of structures returned
-   by functions).
-
-   If INDEX is of some user-defined type, it must be converted to
-   integer type.  Otherwise, to make a compatible PLUS_EXPR, it
-   will inherit the type of the array, which will be some pointer type.  */
-
-tree
-build_x_array_ref (array, index)
-     tree array, index;
-{
-  tree rval;
-
-  rval = build_opfncall (ARRAY_REF, LOOKUP_NORMAL, array, index, NULL_TREE);
-  if (rval)
-    return rval;
-  return build_array_ref (array, index);
-}
-
-tree
-build_array_ref (array, index)
-     tree array, index;
-{
-  tree itype;
-
-  if (index == 0)
-    {
-      error ("subscript missing in array reference");
-      return error_mark_node;
-    }
-
-  if (TREE_TYPE (array) == error_mark_node
-      || TREE_TYPE (index) == error_mark_node)
-    return error_mark_node;
-
-  itype = TREE_TYPE (index);
-  /* We must check here for the reference, so we can do the possible
-     conversions immediately afterwards.  */
-  if (TREE_CODE (itype) == REFERENCE_TYPE)
-    {
-      index = convert_from_reference (index);
-      itype = TREE_TYPE (index);
-    }
-
-  if (IS_AGGR_TYPE (itype))
-    {
-      if (TYPE_HAS_INT_CONVERSION (itype))
-	index = build_type_conversion (CONVERT_EXPR,
-				       integer_type_node, index, 1);
-      else
-	{
-	  error_with_aggr_type (itype,
-				"type `%s' requires integer conversion for array indexing");
-	  return error_mark_node;
-	}
-    }
-
-  if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
-      && TREE_CODE (array) != INDIRECT_REF)
-    {
-      tree rval, type;
-
-      /* Subscripting with type char is likely to lose
-	 on a machine where chars are signed.
-	 So warn on any machine, but optionally.
-	 Don't warn for unsigned char since that type is safe.
-	 Don't warn for signed char because anyone who uses that
-	 must have done so deliberately.  */
-      if (warn_char_subscripts
-	  && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
-	warning ("array subscript has type `char'");
-
-      /* Apply default promotions *after* noticing character types.  */
-      index = default_conversion (index);
-
-      if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
-	{
-	  error ("array subscript is not an integer");
-	  return error_mark_node;
-	}
-
-      /* An array that is indexed by a non-constant
-	 cannot be stored in a register; we must be able to do
-	 address arithmetic on its address.
-	 Likewise an array of elements of variable size.  */
-      if (TREE_CODE (index) != INTEGER_CST
-	  || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
-	      && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
-	{
-	  if (mark_addressable (array) == 0)
-	    return error_mark_node;
-	}
-
-      /* Note in C++ we don't bother warning about subscripting a
-	 `register' array, since it's legal in C++ to take the address
-	 of something with that storage specification.  */
-      if (pedantic && !lvalue_p (array))
-	pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
-
-      if (pedantic)
-	{
-	  tree foo = array;
-	  while (TREE_CODE (foo) == COMPONENT_REF)
-	    foo = TREE_OPERAND (foo, 0);
-	  if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
-	    pedwarn ("ANSI C++ forbids subscripting non-lvalue array");
-	}
-
-      type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
-      rval = build (ARRAY_REF, type, array, index);
-      /* Array ref is const/volatile if the array elements are
-	 or if the array is..  */
-      TREE_READONLY (rval)
-	|= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
-	    | TREE_READONLY (array));
-      TREE_SIDE_EFFECTS (rval)
-	|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
-	    | TREE_SIDE_EFFECTS (array));
-      TREE_THIS_VOLATILE (rval)
-	|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
-	    /* This was added by rms on 16 Nov 91.
-	       It fixes  vol struct foo *a;  a->elts[1] 
-	       in an inline function.
-	       Hope it doesn't break something else.  */
-	    | TREE_THIS_VOLATILE (array));
-      return require_complete_type (fold (rval));
-    }
-
-  {
-    tree ar = default_conversion (array);
-    tree ind = default_conversion (index);
-
-    /* Put the integer in IND to simplify error checking.  */
-    if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
-      {
-	tree temp = ar;
-	ar = ind;
-	ind = temp;
-      }
-
-    if (ar == error_mark_node)
-      return ar;
-
-    if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
-      {
-	error ("subscripted value is neither array nor pointer");
-	return error_mark_node;
-      }
-    if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
-      {
-	error ("array subscript is not an integer");
-	return error_mark_node;
-      }
-
-    return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR, ar, ind, PLUS_EXPR),
-			       "array indexing");
-  }
-}
-
-/* Build a function call to function FUNCTION with parameters PARAMS.
-   PARAMS is a list--a chain of TREE_LIST nodes--in which the
-   TREE_VALUE of each node is a parameter-expression.
-   FUNCTION's data type may be a function type or a pointer-to-function.
-
-   For C++: If FUNCTION's data type is a TREE_LIST, then the tree list
-   is the list of possible methods that FUNCTION could conceivably
-   be.  If the list of methods comes from a class, then it will be
-   a list of lists (where each element is associated with the class
-   that produced it), otherwise it will be a simple list (for
-   functions overloaded in global scope).
-
-   In the first case, TREE_VALUE (function) is the head of one of those
-   lists, and TREE_PURPOSE is the name of the function.
-
-   In the second case, TREE_PURPOSE (function) is the function's
-   name directly.
-
-   DECL is the class instance variable, usually CURRENT_CLASS_DECL.  */
-
-/*
- * [eichin:19911015.1726EST] actually return a possibly incomplete
- * type
- */
-tree
-build_x_function_call (function, params, decl)
-     tree function, params, decl;
-{
-  tree type = TREE_TYPE (function);
-  int is_method = ((TREE_CODE (function) == TREE_LIST
-		    && current_class_type != NULL_TREE
-		    && IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function)) == function)
-		   || TREE_CODE (function) == IDENTIFIER_NODE
-		   || TREE_CODE (type) == METHOD_TYPE
-		   || (TREE_CODE (type) == POINTER_TYPE
-		       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE));
-
-  /* Handle methods, friends, and overloaded functions, respectively.  */
-  if (is_method)
-    {
-      if (TREE_CODE (function) == FUNCTION_DECL)
-	{
-	  if (DECL_NAME (function))
-	    function = DECL_NAME (function);
-	  else
-	    function = TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function));
-	}
-      else if (TREE_CODE (function) == TREE_LIST)
-	{
-#if 0
-	  if (TREE_CODE (TREE_VALUE (function)) == TREE_LIST)
-	    function = TREE_PURPOSE (TREE_VALUE (function));
-	  else
-	    function = TREE_PURPOSE (function);
-#else
-	  my_friendly_assert (TREE_CODE (TREE_VALUE (function)) == FUNCTION_DECL, 312);
-	  function = TREE_PURPOSE (function);
-#endif
-	}
-      else if (TREE_CODE (function) != IDENTIFIER_NODE)
-	{
-	  /* Call via a pointer to member function.  */
-	  if (decl == NULL_TREE)
-	    {
-	      error ("pointer to member function called, but not in class scope");
-	      return error_mark_node;
-	    }
-	  if (TREE_CODE (TREE_TYPE (function)) != POINTER_TYPE)
-	    function = build (OFFSET_REF, TREE_TYPE (type), NULL_TREE, function);
-	  goto do_x_function;
-	}
-
-      /* this is an abbreviated method call.
-         must go through here in case it is a virtual function.
-	 @@ Perhaps this could be optimized.  */
-
-      if (decl == NULL_TREE)
-	{
-	  if (current_class_type == NULL_TREE)
-	    {
-	      error ("object missing in call to method `%s'",
-		     IDENTIFIER_POINTER (function));
-	      return error_mark_node;
-	    }
-	  /* Yow: call from a static member function.  */
-	  decl = build1 (NOP_EXPR,
-			 TYPE_POINTER_TO (current_class_type),
-			 error_mark_node);
-	}
-
-      return build_method_call (decl, function, params,
-				NULL_TREE, LOOKUP_NORMAL);
-    }
-  else if (TREE_CODE (function) == COMPONENT_REF
-	   && type == unknown_type_node)
-    {
-      function = TREE_PURPOSE (TREE_OPERAND (function, 1));
-      return build_method_call (decl, function, params,
-				NULL_TREE, LOOKUP_NORMAL);
-    }
-  else if (TREE_CODE (function) == TREE_LIST)
-    {
-      if (TREE_CHAIN (function) != NULL_TREE)
-        {
-          if (TREE_CODE (TREE_VALUE (function)) == TEMPLATE_DECL)
-            return build_overload_call_maybe (TREE_PURPOSE (function),
-					      params, 1, (struct candidate *)0);
-          else
-            return build_overload_call (TREE_PURPOSE (function), params, 1,
-					(struct candidate *)0);
-        }
-      else if (TREE_VALUE (function) == NULL_TREE)
-	{
-	  error ("function `%s' declared overloaded, but no definitions appear with which to resolve it",
-		 IDENTIFIER_POINTER (TREE_PURPOSE (function)));
-	  return error_mark_node;
-	}
-      else if (TREE_CODE (TREE_VALUE (function)) == TEMPLATE_DECL)
-	return build_overload_call_maybe (TREE_PURPOSE (function),
-					  params, 1, (struct candidate *)0);
-      else
-	function = TREE_VALUE (function);
-    }
-  else if (TREE_CODE (type) == POINTER_TYPE
-	   && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
-	   && (TREE_CODE (function) == VAR_DECL
-	       || TREE_CODE (function) == PARM_DECL
-	       || TREE_CODE (function) == FIELD_DECL))
-    {
-      error_with_decl (function, "call via pointer-to-member-function `%s' must be composed with object");
-      return error_mark_node;
-    }
-
- do_x_function:
-  if (TREE_CODE (function) == OFFSET_REF)
-    {
-      /* If the component is a data element (or a virtual function), we play
-	 games here to make things work.  */
-      tree decl_addr;
-
-      if (TREE_OPERAND (function, 0))
-	decl = TREE_OPERAND (function, 0);
-      else
-	decl = C_C_D;
-
-      decl_addr = build_unary_op (ADDR_EXPR, decl, 0);
-      function = get_member_function (&decl_addr, decl,
-				      TREE_OPERAND (function, 1));
-      params = tree_cons (NULL_TREE, decl_addr, params);
-      return build_function_call (function, params);
-    }
-
-  type = TREE_TYPE (function);
-  if (type != error_mark_node)
-    {
-      if (TREE_CODE (type) == REFERENCE_TYPE)
-	type = TREE_TYPE (type);
-
-      if (TYPE_LANG_SPECIFIC (type) && TYPE_OVERLOADS_CALL_EXPR (type))
-	return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, function, params, NULL_TREE);
-    }
-
-  if (is_method)
-    {
-      tree fntype = TREE_TYPE (function);
-      tree ctypeptr;
-      /* Explicitly named method?  */
-      if (TREE_CODE (function) == FUNCTION_DECL)
-	ctypeptr = TYPE_POINTER_TO (DECL_CLASS_CONTEXT (function));
-      /* Expression with ptr-to-method type?  It could either be a plain
-	 usage, or it might be a case where the ptr-to-method is being
-	 passed in as an argument.  */
-      else if (TREE_CODE (fntype) == POINTER_TYPE
-	       && (TREE_CODE_CLASS (TREE_CODE (function)) == 'e'
-		   || ((TREE_CODE_CLASS (TREE_CODE (function)) == 'd'
-			|| TREE_CODE_CLASS (TREE_CODE (function)) == 'r')
-		       && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE)))
-	{
-	  tree rec = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
-	  ctypeptr = TYPE_POINTER_TO (rec);
-	}
-      /* Unexpected node type?  */
-      else
-	my_friendly_abort (116);
-      if (decl == NULL_TREE)
-	{
-	  if (current_function_decl
-	      && DECL_STATIC_FUNCTION_P (current_function_decl))
-	    error ("invalid call to member function needing `this' in static member function scope");
-	  else
-	    error ("pointer to member function called, but not in class scope");
-	  return error_mark_node;
-	}
-      if (TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE)
-	{
-	  decl = build_unary_op (ADDR_EXPR, decl, 0);
-	  decl = convert_pointer_to (TREE_TYPE (ctypeptr), decl);
-	}
-      else
-	decl = build_c_cast (ctypeptr, decl);
-      params = tree_cons (NULL_TREE, decl, params);
-    }
-
-  return build_function_call (function, params);
-}
-
-tree
-build_function_call_real (function, params, require_complete)
-     tree function, params;
-     int require_complete;
-{
-  register tree fntype, fndecl;
-  register tree value_type;
-  register tree coerced_params;
-  int is_method;
-
-  /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
-     Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
-  if (TREE_CODE (function) == NOP_EXPR
-      && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
-    function = TREE_OPERAND (function, 0);
-
-  if (TREE_CODE (function) == FUNCTION_DECL)
-    {
-      GNU_xref_call (current_function_decl,
-		     IDENTIFIER_POINTER (DECL_NAME (function)
-					 ? DECL_NAME (function)
-					 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function))));
-      assemble_external (function);
-      fndecl = function;
-
-      /* Convert anything with function type to a pointer-to-function.  */
-      if (pedantic
-	  && DECL_NAME (function)
-	  && IDENTIFIER_LENGTH (DECL_NAME (function)) == 4
-	  && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (function)), "main")
-	  && DECL_CONTEXT (function) == NULL_TREE)
-	{
-	  pedwarn ("ANSI C++ forbids calling `main' from within program");
-	}
-
-      /* Differs from default_conversion by not setting TREE_ADDRESSABLE
-	 (because calling an inline function does not mean the function
-	 needs to be separately compiled).  */
-
-      if (! DECL_INLINE (function))
-	{
-	  assemble_external (function);
-	  TREE_USED (function) = 1;
-	}
-
-      fntype = build_type_variant (TREE_TYPE (function),
-				   TREE_READONLY (function),
-				   TREE_THIS_VOLATILE (function));
-      function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
-    }
-  else
-    {
-      fndecl = NULL_TREE;
-
-      /* Convert anything with function type to a pointer-to-function.  */
-      if (function == error_mark_node)
-	return error_mark_node;
-      function = default_conversion (function);
-    }
-
-  fntype = TREE_TYPE (function);
-
-  is_method = (TREE_CODE (fntype) == POINTER_TYPE
-	       && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
-
-  if (!(TREE_CODE (fntype) == POINTER_TYPE
-	&& (TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE || is_method)))
-    {
-      error ("called object is not a function");
-      return error_mark_node;
-    }
-
-  /* fntype now gets the type of function pointed to.  */
-  fntype = TREE_TYPE (fntype);
-
-  /* Convert the parameters to the types declared in the
-     function prototype, or apply default promotions.  */
-
-  coerced_params = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
-				      params, fndecl, LOOKUP_NORMAL);
-
-  /* Recognize certain built-in functions so we can make tree-codes
-     other than CALL_EXPR.  We do this when it enables fold-const.c
-     to do something useful.  */
-
-  if (TREE_CODE (function) == ADDR_EXPR
-      && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
-      && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
-    switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
-      {
-      case BUILT_IN_ABS:
-      case BUILT_IN_LABS:
-      case BUILT_IN_FABS:
-	if (coerced_params == 0)
-	  return integer_zero_node;
-	return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
-      }
-
-  /* C++ */
-  value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node;
-  {
-    register tree result = 
-      build (CALL_EXPR, value_type,
-	     function, coerced_params, NULL_TREE);
-
-    TREE_SIDE_EFFECTS (result) = 1;
-    TREE_RAISES (result) |= !! TYPE_RAISES_EXCEPTIONS (fntype);
-    if (! require_complete)
-      return result;
-    if (value_type == void_type_node)
-      return result;
-    return require_complete_type (result);
-  }
-}
-
-tree
-build_function_call (function, params)
-     tree function, params;
-{
-  return build_function_call_real (function, params, 1);
-}
-     
-tree
-build_function_call_maybe (function, params)
-     tree function, params;
-{
-  return build_function_call_real (function, params, 0);
-}
-
-
-/* Convert the actual parameter expressions in the list VALUES
-   to the types in the list TYPELIST.
-   If parmdecls is exhausted, or when an element has NULL as its type,
-   perform the default conversions.
-
-   RETURN_LOC is the location of the return value, if known, NULL_TREE
-   otherwise.  This is useful in the case where we can avoid creating
-   a temporary variable in the case where we can initialize the return
-   value directly.  If we are not eliding constructors, then we set this
-   to NULL_TREE to avoid this avoidance.
-
-   NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
-
-   This is also where warnings about wrong number of args are generated.
-   
-   Return a list of expressions for the parameters as converted.
-
-   Both VALUES and the returned value are chains of TREE_LIST nodes
-   with the elements of the list in the TREE_VALUE slots of those nodes.
-
-   In C++, unspecified trailing parameters can be filled in with their
-   default arguments, if such were specified.  Do so here.  */
-
-tree
-convert_arguments (return_loc, typelist, values, fndecl, flags)
-     tree return_loc, typelist, values, fndecl;
-     int flags;
-{
-  extern tree gc_protect_fndecl;
-  register tree typetail, valtail;
-  register tree result = NULL_TREE;
-  char *called_thing;
-  int maybe_raises = 0;
-  int i = 0;
-
-  if (! flag_elide_constructors)
-    return_loc = 0;
-
-  if (fndecl)
-    {
-      if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
-	{
-	  if (DECL_NAME (fndecl) == NULL_TREE
-	      || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
-	    called_thing = "constructor";
-	  else
-	    called_thing = "member function";
-	  i -= 1;
-	}
-      else
-	{
-	  called_thing = "function";
-	}
-    }
-
-  for (valtail = values, typetail = typelist;
-       valtail;
-       valtail = TREE_CHAIN (valtail), i++)
-    {
-      register tree type = typetail ? TREE_VALUE (typetail) : 0;
-      register tree val = TREE_VALUE (valtail);
-
-      if (type == void_type_node)
-	{
-	  if (fndecl)
-	    {
-	      char *buf = (char *)alloca (40 + strlen (called_thing));
-	      sprintf (buf, "too many arguments to %s `%%s'", called_thing);
-	      error_with_decl (fndecl, buf);
-	      error ("at this point in file");
-	    }
-	  else
-	    error ("too many arguments to function");
-	  /* In case anybody wants to know if this argument
-	     list is valid.  */
-	  if (result)
-	    TREE_TYPE (tree_last (result)) = error_mark_node;
-	  break;
-	}
-
-      /* The tree type of the parameter being passed may not yet be
-	 known.  In this case, its type is TYPE_UNKNOWN, and will
-	 be instantiated by the type given by TYPE.  If TYPE
-	 is also NULL, the tree type of VAL is ERROR_MARK_NODE.  */
-      if (type && type_unknown_p (val))
-	val = require_instantiated_type (type, val, integer_zero_node);
-      else if (type_unknown_p (val))
-	{
-	  /* Strip the `&' from an overloaded FUNCTION_DECL.  */
-	  if (TREE_CODE (val) == ADDR_EXPR)
-	    val = TREE_OPERAND (val, 0);
-	  if (TREE_CODE (val) == TREE_LIST
-	      && TREE_CHAIN (val) == NULL_TREE
-	      && TREE_TYPE (TREE_VALUE (val)) != NULL_TREE
-	      && (TREE_TYPE (val) == unknown_type_node
-		  || DECL_CHAIN (TREE_VALUE (val)) == NULL_TREE))
-	    /* Instantiates automatically.  */
-	    val = TREE_VALUE (val);
-	  else
-	    {
-	      error ("insufficient type information in parameter list");
-	      val = integer_zero_node;
-	    }
-	}
-      else if (TREE_CODE (val) == OFFSET_REF)
-	val = resolve_offset_ref (val);
-
-      {
-#if 0
-	/* This code forces the assumption that if we have a ptr-to-func
-	   type in an arglist, that every routine that wants to check
-	   its validity has done so, and thus we need not do any
-	   more conversion.  I don't remember why this is necessary.  */
-	else if (TREE_CODE (ttype) == FUNCTION_TYPE
-		 && (type == NULL
-		     || TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
-		     || TREE_CODE (TREE_TYPE (type)) == VOID_TYPE))
-	  {
-	    type = build_pointer_type (ttype);
-	  }
-#endif
-      }
-
-      /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
-	 Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
-      if (TREE_CODE (val) == NOP_EXPR
-	  && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
-	val = TREE_OPERAND (val, 0);
-
-      if ((type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
-	  && (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
-	      || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
-	      || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE))
-	val = default_conversion (val);
-
-      val = require_complete_type (val);
-
-      if (val == error_mark_node)
-	continue;
-
-      maybe_raises |= TREE_RAISES (val);
-
-      if (type != 0)
-	{
-	  /* Formal parm type is specified by a function prototype.  */
-	  tree parmval;
-
-	  if (TYPE_SIZE (type) == 0)
-	    {
-	      error ("parameter type of called function is incomplete");
-	      parmval = val;
-	    }
-	  else
-	    {
-#ifdef PROMOTE_PROTOTYPES
-	      /* Rather than truncating and then reextending,
-		 convert directly to int, if that's the type we will want.  */
-	      if (! flag_traditional
-		  && TREE_CODE (type) == INTEGER_TYPE
-		  && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
-		type = integer_type_node;
-#endif
-	      parmval = convert_for_initialization (return_loc, type, val, flags,
-						    "argument passing", fndecl, i);
-#ifdef PROMOTE_PROTOTYPES
-	      if (TREE_CODE (type) == INTEGER_TYPE
-		  && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
-		parmval = default_conversion (parmval);
-#endif
-	    }
-	  result = tree_cons (NULL_TREE, parmval, result);
-	}
-      else
-	{
-	  if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
-	    val = convert_from_reference (val);
-
-	  if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
-	      && (TYPE_PRECISION (TREE_TYPE (val))
-		  < TYPE_PRECISION (double_type_node)))
-	    /* Convert `float' to `double'.  */
-	    result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
-	  else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val))
-		   && (TYPE_GETS_INIT_REF (TREE_TYPE (val))
-		       || TYPE_GETS_ASSIGN_REF (TREE_TYPE (val))))
-	    {
-	      if (pedantic)
-		pedwarn ("ANSI C++ forbids passing objects of type `%s' through `...'",
-			 TYPE_NAME_STRING (TREE_TYPE (val)));
-	      else
-		warning ("cannot pass objects of type `%s' through `...'",
-			 TYPE_NAME_STRING (TREE_TYPE (val)));
-	      result = tree_cons (NULL_TREE, val, result);
-	    }
-	  else
-	    /* Convert `short' and `char' to full-size `int'.  */
-	    result = tree_cons (NULL_TREE, default_conversion (val), result);
-	}
-
-      if (flag_gc
-	  /* There are certain functions for which we don't need
-	     to protect our arguments.  GC_PROTECT_FNDECL is one.  */
-	  && fndecl != gc_protect_fndecl
-	  && type_needs_gc_entry (TREE_TYPE (TREE_VALUE (result)))
-	  && ! value_safe_from_gc (NULL_TREE, TREE_VALUE (result)))
-	/* This will build a temporary variable whose cleanup is
-	   to clear the obstack entry.  */
-	TREE_VALUE (result) = protect_value_from_gc (NULL_TREE,
-						     TREE_VALUE (result));
-
-      if (typetail)
-	typetail = TREE_CHAIN (typetail);
-    }
-
-  if (typetail != 0 && typetail != void_list_node)
-    {
-      /* See if there are default arguments that can be used */
-      if (TREE_PURPOSE (typetail))
-	{
-	  while (typetail != void_list_node)
-	    {
-	      tree type = TREE_VALUE (typetail);
-	      tree val = TREE_PURPOSE (typetail);
-	      tree parmval;
-
-	      if (val == NULL_TREE)
-		parmval = error_mark_node;
-	      else if (TREE_CODE (val) == CONSTRUCTOR)
-		{
-		  parmval = digest_init (type, val, (tree *)0);
-		  parmval = convert_for_initialization (return_loc, type, parmval, flags,
-							"default constructor", fndecl, i);
-		}
-	      else
-		{
-		  /* This could get clobbered by the following call.  */
-		  if (TREE_HAS_CONSTRUCTOR (val))
-		    val = copy_node (val);
-
-		  parmval = convert_for_initialization (return_loc, type, val, flags,
-							"default argument", fndecl, i);
-#ifdef PROMOTE_PROTOTYPES
-		  if (TREE_CODE (type) == INTEGER_TYPE
-		      && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
-		    parmval = default_conversion (parmval);
-#endif
-		}
-	      maybe_raises |= TREE_RAISES (parmval);
-
-	      if (flag_gc
-		  && type_needs_gc_entry (TREE_TYPE (parmval))
-		  && ! value_safe_from_gc (NULL_TREE, parmval))
-		parmval = protect_value_from_gc (NULL_TREE, parmval);
-
-	      result = tree_cons (0, parmval, result);
-	      typetail = TREE_CHAIN (typetail);
-	      /* ends with `...'.  */
-	      if (typetail == NULL_TREE)
-		break;
-	    }
-	}
-      else
-	{
-	  if (fndecl)
-	    {
-	      char *buf = (char *)alloca (32 + strlen (called_thing));
-	      sprintf (buf, "too few arguments to %s `%%s'", called_thing);
-	      error_with_decl (fndecl, buf);
-	      error ("at this point in file");
-	    }
-	  else
-	    error ("too few arguments to function");
-	  return error_mark_list;
-	}
-    }
-  if (result)
-    TREE_RAISES (result) = maybe_raises;
-
-  return nreverse (result);
-}
-
-/* Build a binary-operation expression, after performing default
-   conversions on the operands.  CODE is the kind of expression to build.  */
-
-tree
-build_x_binary_op (code, arg1, arg2)
-     enum tree_code code;
-     tree arg1, arg2;
-{
-  tree rval;
-
-  /* If there's any way we can call this function, do so.  */
-  if (rval = build_opfncall (code, 0, arg1, arg2, NULL_TREE))
-    {
-      /* If it's accessible, we win.  */
-      if (rval = build_opfncall (code, LOOKUP_PROTECT, arg1, arg2, NULL_TREE))
-	return rval;
-      /* Else, report an error.  */
-      build_opfncall (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE);
-      return error_mark_node;
-    }
-  if (code == MEMBER_REF)
-    return build_m_component_ref (build_indirect_ref (arg1, NULL_PTR),
-				  build_indirect_ref (arg2, NULL_PTR));
-  return build_binary_op (code, arg1, arg2, 1);
-}
-
-tree
-build_binary_op (code, arg1, arg2, convert_p)
-     enum tree_code code;
-     tree arg1, arg2;
-     int convert_p;
-{
-  tree type1, type2;
-  tree args[2];
-
-  args[0] = arg1;
-  args[1] = arg2;
-
-  if (convert_p)
-    {
-      args[0] = default_conversion (args[0]);
-      args[1] = default_conversion (args[1]);
-
-      if (type_unknown_p (args[0]))
-	{
-	  args[0] = instantiate_type (TREE_TYPE (args[1]), args[0], 1);
-	  args[0] = default_conversion (args[0]);
-	}
-      else if (type_unknown_p (args[1]))
-	{
-	  args[1] = require_instantiated_type (TREE_TYPE (args[0]),
-					       args[1],
-					       error_mark_node);
-	  args[1] = default_conversion (args[1]);
-	}
-
-      type1 = TREE_TYPE (args[0]);
-      type2 = TREE_TYPE (args[1]);
-
-      if (IS_AGGR_TYPE_2 (type1, type2))
-	{
-	  /* Try to convert this to something reasonable.  */
-	  if (! build_default_binary_type_conversion(code, &args[0], &args[1]))
-	    return error_mark_node;
-	}
-      else if (IS_AGGR_TYPE (type1) || IS_AGGR_TYPE (type2))
-	{
-	  int convert_index = IS_AGGR_TYPE (type2);
-	  /* Avoid being tripped up by things like (ARG1 != 0).  */
-	  tree types[2], try;
-	  
-	  types[0] = type1; types[1] = type2;
-	  try = build_type_conversion (code, types[convert_index ^ 1],
-				       args[convert_index], 1);
-	  
-	  if (try == 0
-	      && args[1] == integer_zero_node
-	      && (code == NE_EXPR || code == EQ_EXPR))
-	    try = build_type_conversion (code, ptr_type_node,
-					 args[convert_index], 1);
-	  if (try == 0)
-	    {
-	      error_with_aggr_type (types[convert_index],
-				    "no member function `%s::operator %s'",
-				    opname_tab[(int) code]
-				    ? opname_tab[(int) code]
-				    : "<unknown>");
-	      return error_mark_node;
-	    }
-	  if (try == error_mark_node)
-	    error ("ambiguous pointer conversion");
-	  args[convert_index] = try;
-	}
-    }
-  return build_binary_op_nodefault (code, args[0], args[1], code);
-}
-
-/* Build a binary-operation expression without default conversions.
-   CODE is the kind of expression to build.
-   This function differs from `build' in several ways:
-   the data type of the result is computed and recorded in it,
-   warnings are generated if arg data types are invalid,
-   special handling for addition and subtraction of pointers is known,
-   and some optimization is done (operations on narrow ints
-   are done in the narrower type when that gives the same result).
-   Constant folding is also done before the result is returned.
-
-   ERROR_CODE is the code that determines what to say in error messages.
-   It is usually, but not always, the same as CODE.
-
-   Note that the operands will never have enumeral types
-   because either they have just had the default conversions performed
-   or they have both just been converted to some other type in which
-   the arithmetic is to be done.
-
-   C++: must do special pointer arithmetic when implementing
-   multiple inheritance.  */
-
-tree
-build_binary_op_nodefault (code, op0, op1, error_code)
-     enum tree_code code;
-     tree op0, op1;
-     enum tree_code error_code;
-{
-  tree type0 = TREE_TYPE (op0), type1 = TREE_TYPE (op1);
-
-  /* The expression codes of the data types of the arguments tell us
-     whether the arguments are integers, floating, pointers, etc.  */
-  register enum tree_code code0 = TREE_CODE (type0);
-  register enum tree_code code1 = TREE_CODE (type1);
-
-  /* Expression code to give to the expression when it is built.
-     Normally this is CODE, which is what the caller asked for,
-     but in some special cases we change it.  */
-  register enum tree_code resultcode = code;
-
-  /* Data type in which the computation is to be performed.
-     In the simplest cases this is the common type of the arguments.  */
-  register tree result_type = NULL;
-
-  /* Nonzero means operands have already been type-converted
-     in whatever way is necessary.
-     Zero means they need to be converted to RESULT_TYPE.  */
-  int converted = 0;
-
-  /* Nonzero means after finally constructing the expression
-     give it this type.  Otherwise, give it type RESULT_TYPE.  */
-  tree final_type = 0;
-
-  /* Nonzero if this is an operation like MIN or MAX which can
-     safely be computed in short if both args are promoted shorts.
-     Also implies COMMON.
-     -1 indicates a bitwise operation; this makes a difference
-     in the exact conditions for when it is safe to do the operation
-     in a narrower mode.  */
-  int shorten = 0;
-
-  /* Nonzero if this is a comparison operation;
-     if both args are promoted shorts, compare the original shorts.
-     Also implies COMMON.  */
-  int short_compare = 0;
-
-  /* Nonzero if this is a right-shift operation, which can be computed on the
-     original short and then promoted if the operand is a promoted short.  */
-  int short_shift = 0;
-
-  /* Nonzero means set RESULT_TYPE to the common type of the args.  */
-  int common = 0;
-
-  /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
-  STRIP_TYPE_NOPS (op0);
-  STRIP_TYPE_NOPS (op1);
-
-  /* If an error was already reported for one of the arguments,
-     avoid reporting another error.  */
-
-  if (code0 == ERROR_MARK || code1 == ERROR_MARK)
-    return error_mark_node;
-
-  switch (code)
-    {
-    case PLUS_EXPR:
-      /* Handle the pointer + int case.  */
-      if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
-	return pointer_int_sum (PLUS_EXPR, op0, op1);
-      else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
-	return pointer_int_sum (PLUS_EXPR, op1, op0);
-      else
-	common = 1;
-      break;
-
-    case MINUS_EXPR:
-      /* Subtraction of two similar pointers.
-	 We must subtract them as integers, then divide by object size.  */
-      if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
-	  && comp_target_types (type0, type1, 1))
-	return pointer_diff (op0, op1);
-      /* Handle pointer minus int.  Just like pointer plus int.  */
-      else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
-	return pointer_int_sum (MINUS_EXPR, op0, op1);
-      else
-	common = 1;
-      break;
-
-    case MULT_EXPR:
-      common = 1;
-      break;
-
-    case TRUNC_DIV_EXPR:
-    case CEIL_DIV_EXPR:
-    case FLOOR_DIV_EXPR:
-    case ROUND_DIV_EXPR:
-    case EXACT_DIV_EXPR:
-      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
-	  && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
-	{
-	  if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
-	    resultcode = RDIV_EXPR;
-	  else
-	    shorten = 1;
-	  common = 1;
-	}
-      break;
-
-    case BIT_AND_EXPR:
-    case BIT_ANDTC_EXPR:
-    case BIT_IOR_EXPR:
-    case BIT_XOR_EXPR:
-      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
-	shorten = -1;
-      /* If one operand is a constant, and the other is a short type
-	 that has been converted to an int,
-	 really do the work in the short type and then convert the
-	 result to int.  If we are lucky, the constant will be 0 or 1
-	 in the short type, making the entire operation go away.  */
-      if (TREE_CODE (op0) == INTEGER_CST
-	  && TREE_CODE (op1) == NOP_EXPR
-	  && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
-	  && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
-	{
-	  final_type = result_type;
-	  op1 = TREE_OPERAND (op1, 0);
-	  result_type = TREE_TYPE (op1);
-	}
-      if (TREE_CODE (op1) == INTEGER_CST
-	  && TREE_CODE (op0) == NOP_EXPR
-	  && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
-	  && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
-	{
-	  final_type = result_type;
-	  op0 = TREE_OPERAND (op0, 0);
-	  result_type = TREE_TYPE (op0);
-	}
-      break;
-
-    case TRUNC_MOD_EXPR:
-    case FLOOR_MOD_EXPR:
-      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
-	shorten = 1;
-      break;
-
-    case TRUTH_ANDIF_EXPR:
-    case TRUTH_ORIF_EXPR:
-    case TRUTH_AND_EXPR:
-    case TRUTH_OR_EXPR:
-      if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE || code0 == REAL_TYPE)
-	  && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE || code1 == REAL_TYPE))
-	{
-	  /* Result of these operations is always an int,
-	     but that does not mean the operands should be
-	     converted to ints!  */
-	  result_type = integer_type_node;
-	  op0 = truthvalue_conversion (op0);
-	  op1 = truthvalue_conversion (op1);
-	  converted = 1;
-	}
-      break;
-
-      /* Shift operations: result has same type as first operand;
-	 always convert second operand to int.
-	 Also set SHORT_SHIFT if shifting rightward.  */
-
-    case RSHIFT_EXPR:
-      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
-	{
-	  result_type = type0;
-	  if (TREE_CODE (op1) == INTEGER_CST)
-	    {
-	      if (tree_int_cst_lt (op1, integer_zero_node))
-		warning ("shift count is negative");
-	      else
-		{
-		  if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
-		    short_shift = 1;
-		  if (TREE_INT_CST_HIGH (op1) != 0
-		      || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
-			  >= TYPE_PRECISION (type0)))
-		    warning ("shift count >= width of type");
-		}
-	    }
-	  /* Convert the shift-count to an integer, regardless of
-	     size of value being shifted.  */
-	  if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
-	    op1 = convert (integer_type_node, op1);
-	  /* Avoid converting op1 to result_type later.  */
-	  converted = 1;
-	}
-      break;
-
-    case LSHIFT_EXPR:
-      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
-	{
-	  result_type = type0;
-	  if (TREE_CODE (op1) == INTEGER_CST)
-	    {
-	      if (tree_int_cst_lt (op1, integer_zero_node))
-		warning ("shift count is negative");
-	      else if (TREE_INT_CST_HIGH (op1) != 0
-		       || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
-			   >= TYPE_PRECISION (type0)))
-		warning ("shift count >= width of type");
-	    }
-	  /* Convert the shift-count to an integer, regardless of
-	     size of value being shifted.  */
-	  if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
-	    op1 = convert (integer_type_node, op1);
-	  /* Avoid converting op1 to result_type later.  */
-	  converted = 1;
-	}
-      break;
-
-    case RROTATE_EXPR:
-    case LROTATE_EXPR:
-      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
-	{
-	  result_type = type0;
-	  if (TREE_CODE (op1) == INTEGER_CST)
-	    {
-	      if (tree_int_cst_lt (op1, integer_zero_node))
-		warning ("shift count is negative");
-	      else if (TREE_INT_CST_HIGH (op1) != 0
-		       || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
-			   >= TYPE_PRECISION (type0)))
-		warning ("shift count >= width of type");
-	    }
-	  /* Convert the shift-count to an integer, regardless of
-	     size of value being shifted.  */
-	  if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
-	    op1 = convert (integer_type_node, op1);
-	}
-      break;
-
-    case EQ_EXPR:
-    case NE_EXPR:
-      /* Result of comparison is always int,
-	 but don't convert the args to int!  */
-      result_type = integer_type_node;
-      converted = 1;
-      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
-	  && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
-	short_compare = 1;
-      else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
-	{
-	  register tree tt0 = TYPE_MAIN_VARIANT (TREE_TYPE (type0));
-	  register tree tt1 = TYPE_MAIN_VARIANT (TREE_TYPE (type1));
-	  /* Anything compares with void *.  void * compares with anything.
-	     Otherwise, the targets must be the same.  */
-	  if (tt0 != tt1 && TREE_CODE (tt0) == RECORD_TYPE
-	      && TREE_CODE (tt1) == RECORD_TYPE)
-	    {
-	      tree base = common_base_type (tt0, tt1);
-	      if (base == NULL_TREE)
-		warning ("comparison of distinct object pointer types");
-	      else if (base == error_mark_node)
-		{
-		  message_2_types (error, "comparison of pointer types `%s*' and `%s*' requires conversion to ambiguous supertype", tt0, tt1);
-		  return error_mark_node;
-		}
-	      else
-		{
-		  if (integer_zerop (op0))
-		    op0 = null_pointer_node;
-		  else
-		    op0 = convert_pointer_to (base, op0);
-		  if (integer_zerop (op1))
-		    op1 = null_pointer_node;
-		  else
-		    op1 = convert_pointer_to (base, op1);
-		}
-	    }
-	  else if (comp_target_types (type0, type1, 1))
-	    ;
-	  else if (tt0 == void_type_node)
-	    {
-	      if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
-		pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
-	    }
-	  else if (tt1 == void_type_node)
-	    {
-	      if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
-		pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer");
-	    }
-	  else
-	    warning ("comparison of distinct pointer types lacks a cast");
-	}
-      else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
-	       && integer_zerop (op1))
-	op1 = null_pointer_node;
-      else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
-	       && integer_zerop (op0))
-	op0 = null_pointer_node;
-      else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
-	{
-	  error ("ANSI C++ forbids comparison between pointer and integer");
-	  op1 = convert (TREE_TYPE (op0), op1);
-	}
-      else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
-	{
-	  error ("ANSI C++ forbids comparison between pointer and integer");
-	  op0 = convert (TREE_TYPE (op1), op0);
-	}
-      else
-	/* If args are not valid, clear out RESULT_TYPE
-	   to cause an error message later.  */
-	result_type = 0;
-      break;
-
-    case MAX_EXPR:
-    case MIN_EXPR:
-      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
-	   && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
-	shorten = 1;
-      else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
-	{
-	  if (! comp_target_types (type0, type1, 1))
-	    warning ("comparison of distinct pointer types lacks a cast");
-	  else if (pedantic
-		   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
-	    pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
-	  result_type = common_type (type0, type1);
-	}
-      break;
-
-    case LE_EXPR:
-    case GE_EXPR:
-    case LT_EXPR:
-    case GT_EXPR:
-      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
-	   && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
-	short_compare = 1;
-      else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
-	{
-	  if (! comp_target_types (type0, type1, 1))
-	    warning ("comparison of distinct pointer types lacks a cast");
-	  else if (pedantic 
-		   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
-	    pedwarn ("ANSI C++ forbids ordered comparisons of pointers to functions");
-	  result_type = integer_type_node;
-	}
-      else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
-	       && integer_zerop (op1))
-	{
-	  result_type = integer_type_node;
-	  op1 = null_pointer_node;
-	  if (! flag_traditional)
-	    warning ("ordered comparison of pointer with integer zero");
-	}
-      else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
-	       && integer_zerop (op0))
-	{
-	  result_type = integer_type_node;
-	  op0 = null_pointer_node;
-	  if (pedantic)
-	    pedwarn ("ANSI C++ forbids ordered comparison of pointer with integer zero");
-	}
-      else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
-	{
-	  result_type = integer_type_node;
-	  if (pedantic)
-	    pedwarn ("ANSI C++ forbids comparison between pointer and integer");
-	  else if (! flag_traditional)
-	    warning ("comparison between pointer and integer");
-	  op1 = convert (TREE_TYPE (op0), op1);
-	}
-      else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
-	{
-	  result_type = integer_type_node;
-	  if (pedantic)
-	    pedwarn ("ANSI C++ forbids comparison between pointer and integer");
-	  else if (! flag_traditional)
-	    warning ("comparison between pointer and integer");
-	  op0 = convert (TREE_TYPE (op1), op0);
-	}
-      converted = 1;
-      break;
-    }
-
-  if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
-      && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
-    {
-      if (shorten || common || short_compare)
-	result_type = common_type (type0, type1);
-
-      /* For certain operations (which identify themselves by shorten != 0)
-	 if both args were extended from the same smaller type,
-	 do the arithmetic in that type and then extend.
-
-	 shorten !=0 and !=1 indicates a bitwise operation.
-	 For them, this optimization is safe only if
-	 both args are zero-extended or both are sign-extended.
-	 Otherwise, we might change the result.
-	 Eg, (short)-1 | (unsigned short)-1 is (int)-1
-	 but calculated in (unsigned short) it would be (unsigned short)-1.  */
-
-      if (shorten)
-	{
-	  int unsigned0, unsigned1;
-	  tree arg0 = get_narrower (op0, &unsigned0);
-	  tree arg1 = get_narrower (op1, &unsigned1);
-	  /* UNS is 1 if the operation to be done is an unsigned one.  */
-	  int uns = TREE_UNSIGNED (result_type);
-	  tree type;
-
-	  final_type = result_type;
-
-	  /* Handle the case that OP0 does not *contain* a conversion
-	     but it *requires* conversion to FINAL_TYPE.  */
-
-	  if (op0 == arg0 && TREE_TYPE (op0) != final_type)
-	    unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
-	  if (op1 == arg1 && TREE_TYPE (op1) != final_type)
-	    unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
-
-	  /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
-
-	  /* For bitwise operations, signedness of nominal type
-	     does not matter.  Consider only how operands were extended.  */
-	  if (shorten == -1)
-	    uns = unsigned0;
-
-	  /* Note that in all three cases below we refrain from optimizing
-	     an unsigned operation on sign-extended args.
-	     That would not be valid.  */
-
-	  /* Both args variable: if both extended in same way
-	     from same width, do it in that width.
-	     Do it unsigned if args were zero-extended.  */
-	  if ((TYPE_PRECISION (TREE_TYPE (arg0))
-	       < TYPE_PRECISION (result_type))
-	      && (TYPE_PRECISION (TREE_TYPE (arg1))
-		  == TYPE_PRECISION (TREE_TYPE (arg0)))
-	      && unsigned0 == unsigned1
-	      && (unsigned0 || !uns))
-	    result_type
-	      = signed_or_unsigned_type (unsigned0,
-					 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
-	  else if (TREE_CODE (arg0) == INTEGER_CST
-		   && (unsigned1 || !uns)
-		   && (TYPE_PRECISION (TREE_TYPE (arg1))
-		       < TYPE_PRECISION (result_type))
-		   && (type = signed_or_unsigned_type (unsigned1,
-						       TREE_TYPE (arg1)),
-		       int_fits_type_p (arg0, type)))
-	    result_type = type;
-	  else if (TREE_CODE (arg1) == INTEGER_CST
-		   && (unsigned0 || !uns)
-		   && (TYPE_PRECISION (TREE_TYPE (arg0))
-		       < TYPE_PRECISION (result_type))
-		   && (type = signed_or_unsigned_type (unsigned0,
-						       TREE_TYPE (arg0)),
-		       int_fits_type_p (arg1, type)))
-	    result_type = type;
-	}
-
-      /* Shifts can be shortened if shifting right.  */
-
-      if (short_shift)
-	{
-	  int unsigned_arg;
-	  tree arg0 = get_narrower (op0, &unsigned_arg);
-
-	  final_type = result_type;
-
-	  if (arg0 == op0 && final_type == TREE_TYPE (op0))
-	    unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
-
-	  if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
-	      /* If arg is sign-extended and then unsigned-shifted,
-		 we can simulate this with a signed shift in arg's type
-		 only if the extended result is at least twice as wide
-		 as the arg.  Otherwise, the shift could use up all the
-		 ones made by sign-extension and bring in zeros.
-		 We can't optimize that case at all, but in most machines
-		 it never happens because available widths are 2**N.  */
-	      && (!TREE_UNSIGNED (final_type)
-		  || unsigned_arg
-		  || ((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0))
-		      <= TYPE_PRECISION (result_type))))
-	    {
-	      /* Do an unsigned shift if the operand was zero-extended.  */
-	      result_type
-		= signed_or_unsigned_type (unsigned_arg,
-					   TREE_TYPE (arg0));
-	      /* Convert value-to-be-shifted to that type.  */
-	      if (TREE_TYPE (op0) != result_type)
-		op0 = convert (result_type, op0);
-	      converted = 1;
-	    }
-	}
-
-      /* Comparison operations are shortened too but differently.
-	 They identify themselves by setting short_compare = 1.  */
-
-      if (short_compare)
-	{
-	  /* Don't write &op0, etc., because that would prevent op0
-	     from being kept in a register.
-	     Instead, make copies of the our local variables and
-	     pass the copies by reference, then copy them back afterward.  */
-	  tree xop0 = op0, xop1 = op1, xresult_type = result_type;
-	  enum tree_code xresultcode = resultcode;
-	  tree val 
-	    = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
-	  if (val != 0)
-	    return val;
-	  op0 = xop0, op1 = xop1, result_type = xresult_type;
-	  resultcode = xresultcode;
-	}
-
-      if (short_compare && extra_warnings)
-	{
-	  int unsignedp0, unsignedp1;
-	  tree primop0 = get_narrower (op0, &unsignedp0);
-	  tree primop1 = get_narrower (op1, &unsignedp1);
-
-	  /* Warn if signed and unsigned are being compared in a size larger
-	     than their original size, as this will always fail.  */
-
-	  if (unsignedp0 != unsignedp1
-	      && (TYPE_PRECISION (TREE_TYPE (primop0))
-		  < TYPE_PRECISION (result_type))
-	      && (TYPE_PRECISION (TREE_TYPE (primop1))
-		  < TYPE_PRECISION (result_type)))
-	    warning ("comparison between promoted unsigned and signed");
-
-	  /* Warn if two unsigned values are being compared in a size
-	     larger than their original size, and one (and only one) is the
-	     result of a `~' operator.  This comparison will always fail.
-
-	     Also warn if one operand is a constant, and the constant does not
-	     have all bits set that are set in the ~ operand when it is
-	     extended.  */
-
-	  else if (TREE_CODE (primop0) == BIT_NOT_EXPR
-		   ^ TREE_CODE (primop1) == BIT_NOT_EXPR)
-	    {
-	      if (TREE_CODE (primop0) == BIT_NOT_EXPR)
-		primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
-	      if (TREE_CODE (primop1) == BIT_NOT_EXPR)
-		primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
-	      
-	      if (TREE_CODE (primop0) == INTEGER_CST
-		  || TREE_CODE (primop1) == INTEGER_CST)
-		{
-		  tree primop;
-		  HOST_WIDE_INT constant, mask;
-		  int unsignedp;
-		  unsigned bits;
-
-		  if (TREE_CODE (primop0) == INTEGER_CST)
-		    {
-		      primop = primop1;
-		      unsignedp = unsignedp1;
-		      constant = TREE_INT_CST_LOW (primop0);
-		    }
-		  else
-		    {
-		      primop = primop0;
-		      unsignedp = unsignedp0;
-		      constant = TREE_INT_CST_LOW (primop1);
-		    }
-
-		  bits = TYPE_PRECISION (TREE_TYPE (primop));
-		  if (bits < TYPE_PRECISION (result_type)
-		      && bits < HOST_BITS_PER_LONG && unsignedp)
-		    {
-		      mask = (~ (HOST_WIDE_INT) 0) << bits;
-		      if ((mask & constant) != mask)
-			warning ("comparison of promoted ~unsigned with constant");
-		    }
-		}
-	      else if (unsignedp0 && unsignedp1
-		       && (TYPE_PRECISION (TREE_TYPE (primop0))
-			   < TYPE_PRECISION (result_type))
-		       && (TYPE_PRECISION (TREE_TYPE (primop1))
-			   < TYPE_PRECISION (result_type)))
-		warning ("comparison of promoted ~unsigned with unsigned");
-	    }
-	}
-    }
-
-  /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
-     If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
-     Then the expression will be built.
-     It will be given type FINAL_TYPE if that is nonzero;
-     otherwise, it will be given type RESULT_TYPE.  */
-
-  if (!result_type)
-    {
-      binary_op_error (error_code);
-      return error_mark_node;
-    }
-
-  if (! converted)
-    {
-      if (TREE_TYPE (op0) != result_type)
-	op0 = convert (result_type, op0); 
-      if (TREE_TYPE (op1) != result_type)
-	op1 = convert (result_type, op1); 
-    }
-
-  {
-    register tree result = build (resultcode, result_type, op0, op1);
-    register tree folded;
-
-    folded = fold (result);
-    if (folded == result)
-      TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
-    if (final_type != 0)
-      return convert (final_type, folded);
-    return folded;
-  }
-}
-
-/* Return a tree for the sum or difference (RESULTCODE says which)
-   of pointer PTROP and integer INTOP.  */
-
-static tree
-pointer_int_sum (resultcode, ptrop, intop)
-     enum tree_code resultcode;
-     register tree ptrop, intop;
-{
-  tree size_exp;
-
-  register tree result;
-  register tree folded = fold (intop);
-
-  /* The result is a pointer of the same type that is being added.  */
-
-  register tree result_type = TREE_TYPE (ptrop);
-
-  /* Needed to make OOPS V2R3 work.  */
-  intop = folded;
-  if (TREE_CODE (intop) == INTEGER_CST
-      && TREE_INT_CST_LOW (intop) == 0
-      && TREE_INT_CST_HIGH (intop) == 0)
-    return ptrop;
-
-  if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
-    {
-      if (pedantic || warn_pointer_arith)
-	pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic");
-      size_exp = integer_one_node;
-    }
-  else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
-    {
-      if (pedantic || warn_pointer_arith)
-	pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic");
-      size_exp = integer_one_node;
-    }
-  else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
-    {
-      if (pedantic || warn_pointer_arith)
-	pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic");
-      size_exp = integer_one_node;
-    }
-  else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
-    {
-      if (pedantic)
-	pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic");
-      size_exp = integer_one_node;
-    }
-  else
-    size_exp = size_in_bytes (TREE_TYPE (result_type));
-
-  /* If what we are about to multiply by the size of the elements
-     contains a constant term, apply distributive law
-     and multiply that constant term separately.
-     This helps produce common subexpressions.  */
-
-  if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
-      && ! TREE_CONSTANT (intop)
-      && TREE_CONSTANT (TREE_OPERAND (intop, 1))
-      && TREE_CONSTANT (size_exp))
-    {
-      enum tree_code subcode = resultcode;
-      if (TREE_CODE (intop) == MINUS_EXPR)
-	subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
-      ptrop = build_binary_op (subcode, ptrop, TREE_OPERAND (intop, 1), 1);
-      intop = TREE_OPERAND (intop, 0);
-    }
-
-  /* Convert the integer argument to a type the same size as a pointer
-     so the multiply won't overflow spuriously.  */
-
-  if (TYPE_PRECISION (TREE_TYPE (intop)) != POINTER_SIZE)
-    intop = convert (type_for_size (POINTER_SIZE, 0), intop);
-
-  /* Replace the integer argument
-     with a suitable product by the object size.  */
-
-  intop = build_binary_op (MULT_EXPR, intop, size_exp, 1);
-
-  /* Create the sum or difference.  */
-
-  result = build (resultcode, result_type, ptrop, intop);
-
-  folded = fold (result);
-  if (folded == result)
-    TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
-  return folded;
-}
-
-/* Return a tree for the difference of pointers OP0 and OP1.
-   The resulting tree has type int.  */
-
-static tree
-pointer_diff (op0, op1)
-     register tree op0, op1;
-{
-  register tree result, folded;
-  tree restype = ptrdiff_type_node;
-  tree target_type = TREE_TYPE (TREE_TYPE (op0));
-
-  if (pedantic)
-    {
-      if (TREE_CODE (target_type) == VOID_TYPE)
-	pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction");
-      if (TREE_CODE (target_type) == FUNCTION_TYPE)
-	pedwarn ("ANSI C++ forbids using pointer to a function in subtraction");
-      if (TREE_CODE (target_type) == METHOD_TYPE)
-	pedwarn ("ANSI C++ forbids using pointer to a method in subtraction");
-      if (TREE_CODE (target_type) == OFFSET_TYPE)
-	pedwarn ("ANSI C++ forbids using pointer to a member in subtraction");
-    }
-
-  /* First do the subtraction as integers;
-     then drop through to build the divide operator.  */
-
-  op0 = build_binary_op (MINUS_EXPR,
-			 convert (restype, op0), convert (restype, op1), 1);
-  op1 = ((TREE_CODE (target_type) == VOID_TYPE
-	  || TREE_CODE (target_type) == FUNCTION_TYPE
-	  || TREE_CODE (target_type) == METHOD_TYPE
-	  || TREE_CODE (target_type) == OFFSET_TYPE)
-	 ? integer_one_node
-	 : size_in_bytes (target_type));
-
-  /* Do the division.  */
-
-  result = build (EXACT_DIV_EXPR, restype, op0, op1);
-
-  folded = fold (result);
-  if (folded == result)
-    TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
-  return folded;
-}
-
-/* Handle the case of taking the address of a COMPONENT_REF.
-   Called by `build_unary_op' and `build_up_reference'.
-
-   ARG is the COMPONENT_REF whose address we want.
-   ARGTYPE is the pointer type that this address should have.
-   MSG is an error message to print if this COMPONENT_REF is not
-   addressable (such as a bitfield).  */
-
-tree
-build_component_addr (arg, argtype, msg)
-     tree arg, argtype;
-     char *msg;
-{
-  tree field = TREE_OPERAND (arg, 1);
-  tree basetype = decl_type_context (field);
-  tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
-
-  if (DECL_BIT_FIELD (field))
-    {
-      error (msg, IDENTIFIER_POINTER (DECL_NAME (field)));
-      return error_mark_node;
-    }
-
-  if (flag_gc)
-    warning ("address of `%s::%s' taken", TYPE_NAME_STRING (basetype),
-	     IDENTIFIER_POINTER (DECL_NAME (field)));
-
-  if (TREE_CODE (field) == FIELD_DECL
-      && TYPE_USES_COMPLEX_INHERITANCE (basetype))
-    /* Can't convert directly to ARGTYPE, since that
-       may have the same pointer type as one of our
-       baseclasses.  */
-    rval = build1 (NOP_EXPR, argtype,
-		   convert_pointer_to (basetype, rval));
-  else
-    /* This conversion is harmless.  */
-    rval = convert (argtype, rval);
-
-  if (! integer_zerop (DECL_FIELD_BITPOS (field)))
-    {
-      tree offset = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
-				size_int (BITS_PER_UNIT));
-      int flag = TREE_CONSTANT (rval);
-      rval = fold (build (PLUS_EXPR, argtype,
-			  rval, convert (argtype, offset)));
-      TREE_CONSTANT (rval) = flag;
-    }
-  return rval;
-}
-   
-/* Construct and perhaps optimize a tree representation
-   for a unary operation.  CODE, a tree_code, specifies the operation
-   and XARG is the operand.  */
-
-tree
-build_x_unary_op (code, xarg)
-     enum tree_code code;
-     tree xarg;
-{
-  tree rval;
-
-  /* See comments in `build_x_unary_op'.  */
-  if (rval = build_opfncall (code, 0, xarg, NULL_TREE, NULL_TREE))
-    {
-      if (rval = build_opfncall (code, LOOKUP_PROTECT, xarg, NULL_TREE, NULL_TREE))
-	return rval;
-      build_opfncall (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE);
-      return error_mark_node;
-    }
-  return build_unary_op (code, xarg, 0);
-}
-
-/* C++: Must handle pointers to members.
-
-   Perhaps type instantiation should be extended to handle conversion
-   from aggregates to types we don't yet know we want?  (Or are those
-   cases typically errors which should be reported?)
-
-   NOCONVERT nonzero suppresses the default promotions
-   (such as from short to int).  */
-tree
-build_unary_op (code, xarg, noconvert)
-     enum tree_code code;
-     tree xarg;
-     int noconvert;
-{
-  /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
-  register tree arg = xarg;
-  register tree argtype = 0;
-  register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
-  char *errstring = NULL;
-  tree val;
-  int isaggrtype;
-
-  if (typecode == ERROR_MARK)
-    return error_mark_node;
-
-  if (typecode == REFERENCE_TYPE && code != ADDR_EXPR && ! noconvert)
-    {
-      arg = convert_from_reference (arg);
-      typecode = TREE_CODE (TREE_TYPE (arg));
-    }
-
-  if (typecode == ENUMERAL_TYPE)
-    typecode = INTEGER_TYPE;
-
-  isaggrtype = IS_AGGR_TYPE_CODE (typecode);
-
-  switch (code)
-    {
-    case CONVERT_EXPR:
-      /* This is used for unary plus, because a CONVERT_EXPR
-	 is enough to prevent anybody from looking inside for
-	 associativity, but won't generate any code.  */
-      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
-        errstring = "wrong type argument to unary plus";
-      else if (!noconvert)
-	arg = default_conversion (arg);
-      break;
-
-    case NEGATE_EXPR:
-      if (isaggrtype)
-	{
-	  if (!noconvert)
-	    arg = default_conversion (arg);
-	  else
-	    {
-	      error_with_aggr_type (TREE_TYPE (arg), "type conversion for type `%s' not allowed");
-	      return error_mark_node;
-	    }
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  noconvert = 1;
-	}
-
-      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
-        errstring = "wrong type argument to unary minus";
-      else if (!noconvert)
-	arg = default_conversion (arg);
-      break;
-
-    case BIT_NOT_EXPR:
-      if (isaggrtype)
-	{
-	  if (!noconvert)
-	    arg = default_conversion (arg);
-	  else
-	    {
-	      error_with_aggr_type (TREE_TYPE (arg), "type conversion for type `%s' not allowed");
-	      return error_mark_node;
-	    }
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  noconvert = 1;
-	}
-
-      if (typecode != INTEGER_TYPE)
-        errstring = "wrong type argument to bit-complement";
-      else if (!noconvert)
-	arg = default_conversion (arg);
-      break;
-
-    case ABS_EXPR:
-      if (isaggrtype)
-	{
-	  if (!noconvert)
-	    arg = default_conversion (arg);
-	  else
-	    {
-	      error_with_aggr_type (TREE_TYPE (arg), "type conversion for type `%s' not allowed");
-	      return error_mark_node;
-	    }
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	  noconvert = 1;
-	}
-
-      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
-        errstring = "wrong type argument to abs";
-      else if (!noconvert)
-	arg = default_conversion (arg);
-      break;
-
-    case TRUTH_NOT_EXPR:
-      if (isaggrtype)
-	{
-	  arg = truthvalue_conversion (arg);
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	}
-
-      if (typecode != INTEGER_TYPE
-	  && typecode != REAL_TYPE && typecode != POINTER_TYPE
-	  /* These will convert to a pointer.  */
-	  && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
-	{
-	  errstring = "wrong type argument to unary exclamation mark";
-	  break;
-	}
-      arg = truthvalue_conversion (arg);
-      val = invert_truthvalue (arg);
-      if (val) return val;
-      break;
-
-    case NOP_EXPR:
-      break;
-      
-    case PREINCREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
-    case PREDECREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-      /* Handle complex lvalues (when permitted)
-	 by reduction to simpler cases.  */
-
-      val = unary_complex_lvalue (code, arg);
-      if (val != 0)
-	return val;
-
-      /* Report invalid types.  */
-
-      if (isaggrtype)
-	{
-	  arg = default_conversion (arg);
-	  typecode = TREE_CODE (TREE_TYPE (arg));
-	}
-
-      if (typecode != POINTER_TYPE
-	  && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
-	{
-	  if (code == PREINCREMENT_EXPR)
-	    errstring ="no pre-increment operator for type";
-	  else if (code == POSTINCREMENT_EXPR)
-	    errstring ="no post-increment operator for type";
-	  else if (code == PREDECREMENT_EXPR)
-	    errstring ="no pre-decrement operator for type";
-	  else
-	    errstring ="no post-decrement operator for type";
-	  break;
-	}
-
-      /* Report something read-only.  */
-
-      if (TYPE_READONLY (TREE_TYPE (arg))
-	  || TREE_READONLY (arg))
-	readonly_error (arg, ((code == PREINCREMENT_EXPR
-			       || code == POSTINCREMENT_EXPR)
-			      ? "increment" : "decrement"),
-			0);
-
-      {
-	register tree inc;
-	tree result_type = TREE_TYPE (arg);
-
-	arg = get_unwidened (arg, 0);
-	argtype = TREE_TYPE (arg);
-
-	/* ARM $5.2.5 last annotation says this should be forbidden.  */
-	if (TREE_CODE (argtype) == ENUMERAL_TYPE)
-	  pedwarn ("ANSI C++ forbids %sing an enum",
-		   (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
-		   ? "increment" : "decrement");
-	    
-	/* Compute the increment.  */
-
-	if (typecode == POINTER_TYPE)
-	  {
-	    enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype));
-	    if (tmp == FUNCTION_TYPE || tmp == METHOD_TYPE
-		|| tmp == VOID_TYPE || tmp == OFFSET_TYPE)
-	      pedwarn ("ANSI C++ forbids %sing a pointer of type `%s'",
-		       ((code == PREINCREMENT_EXPR
-			 || code == POSTINCREMENT_EXPR)
-			? "increment" : "decrement"),
-		       type_as_string (argtype));
-	    inc = c_sizeof_nowarn (TREE_TYPE (argtype));
-	  }
-	else
-	  inc = integer_one_node;
-
-	inc = convert (argtype, inc);
-
-	/* Handle incrementing a cast-expression.  */
-
-	switch (TREE_CODE (arg))
-	  {
-	  case NOP_EXPR:
-	  case CONVERT_EXPR:
-	  case FLOAT_EXPR:
-	  case FIX_TRUNC_EXPR:
-	  case FIX_FLOOR_EXPR:
-	  case FIX_ROUND_EXPR:
-	  case FIX_CEIL_EXPR:
-	    {
-	      tree incremented, modify, value;
-	      pedantic_lvalue_warning (CONVERT_EXPR);
-	      arg = stabilize_reference (arg);
-	      if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
-		value = arg;
-	      else
-		value = save_expr (arg);
-	      incremented = build (((code == PREINCREMENT_EXPR
-				     || code == POSTINCREMENT_EXPR)
-				    ? PLUS_EXPR : MINUS_EXPR),
-				   argtype, value, inc);
-	      TREE_SIDE_EFFECTS (incremented) = 1;
-	      modify = build_modify_expr (arg, NOP_EXPR, incremented);
-	      return build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
-	    }
-	  }
-
-	if (TREE_CODE (arg) == OFFSET_REF)
-	  arg = resolve_offset_ref (arg);
-
-	/* Complain about anything else that is not a true lvalue.  */
-	if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
-				    || code == POSTINCREMENT_EXPR)
-				   ? "increment" : "decrement")))
-	  return error_mark_node;
-
-	val = build (code, TREE_TYPE (arg), arg, inc);
-	TREE_SIDE_EFFECTS (val) = 1;
-	return convert (result_type, val);
-      }
-
-    case ADDR_EXPR:
-      /* Note that this operation never does default_conversion
-	 regardless of NOCONVERT.  */
-
-      if (TREE_REFERENCE_EXPR (arg))
-	{
-	  error ("references are not lvalues");
-	  return error_mark_node;
-	}
-      else if (typecode == REFERENCE_TYPE)
-	{
-	  arg = build1 (CONVERT_EXPR, build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
-	  TREE_REFERENCE_EXPR (arg) = 1;
-	  return arg;
-	}
-      else if (TREE_CODE (arg) == FUNCTION_DECL
-	       && DECL_NAME (arg)
-	       && DECL_CONTEXT (arg) == NULL_TREE
-	       && IDENTIFIER_LENGTH (DECL_NAME (arg)) == 4
-	       && IDENTIFIER_POINTER (DECL_NAME (arg))[0] == 'm'
-	       && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (arg)), "main"))
-	{
-	  /* ARM $3.4 */
-	  error ("attempt to take address of function `main'");
-	  return error_mark_node;
-	}
-
-      /* Let &* cancel out to simplify resulting code.  */
-      if (TREE_CODE (arg) == INDIRECT_REF)
-	{
-	  /* We don't need to have `current_class_decl' wrapped in a
-	     NON_LVALUE_EXPR node.  */
-	  if (arg == C_C_D)
-	    return current_class_decl;
-
-	  /* Keep `default_conversion' from converting if
-	     ARG is of REFERENCE_TYPE.  */
-	  arg = TREE_OPERAND (arg, 0);
-	  if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
-	    {
-	      if (TREE_CODE (arg) == VAR_DECL && DECL_INITIAL (arg)
-		  && !TREE_SIDE_EFFECTS (DECL_INITIAL (arg)))
-		arg = DECL_INITIAL (arg);
-	      arg = build1 (CONVERT_EXPR, build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
-	      TREE_REFERENCE_EXPR (arg) = 1;
-	      TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
-	    }
-	  else if (lvalue_p (arg))
-	    /* Don't let this be an lvalue.  */
-	    return non_lvalue (arg);
-	  return arg;
-	}
-
-      /* For &x[y], return x+y */
-      if (TREE_CODE (arg) == ARRAY_REF)
-	{
-	  if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
-	    return error_mark_node;
-	  return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
-				  TREE_OPERAND (arg, 1), 1);
-	}
-
-      /* Uninstantiated types are all functions.  Taking the
-	 address of a function is a no-op, so just return the
-	 argument.  */
-
-      if (TREE_CODE (arg) == IDENTIFIER_NODE
-	  && IDENTIFIER_OPNAME_P (arg))
-	{
-	  my_friendly_abort (117);
-	  /* We don't know the type yet, so just work around the problem.
-	     We know that this will resolve to an lvalue.  */
-	  return build1 (ADDR_EXPR, unknown_type_node, arg);
-	}
-
-      if (TREE_CODE (arg) == TREE_LIST)
-	{
-	  /* Look at methods with only this name.  */
-	  if (TREE_CODE (TREE_VALUE (arg)) == FUNCTION_DECL)
-	    {
-	      tree targ = TREE_VALUE (arg);
-
-	      /* If this function is unique, or it is a unique
-		 constructor, we can takes its address easily.  */
-	      if (DECL_CHAIN (targ) == NULL_TREE
-		  || (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (targ))
-		      && DECL_CHAIN (DECL_CHAIN (targ)) == NULL_TREE))
-		{
-		  if (DECL_CHAIN (targ))
-		    targ = DECL_CHAIN (targ);
-		  if (DECL_CLASS_CONTEXT (targ))
-		    targ = build (OFFSET_REF, TREE_TYPE (targ), C_C_D, targ);
-
-		  val = unary_complex_lvalue (ADDR_EXPR, targ);
-		  if (val)
-		    return val;
-		}
-
-	      /* This possible setting of TREE_CONSTANT is what makes it possible
-		 with an initializer list to emit the entire thing in the data
-		 section, rather than a run-time initialization.  */
-	      arg = build1 (ADDR_EXPR, unknown_type_node, arg);
-	      if (staticp (targ))
-		TREE_CONSTANT (arg) = 1;
-	      return arg;
-	    }
-	  if (TREE_CHAIN (arg) == NULL_TREE
-	      && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg))) == NULL_TREE)
-	    {
-	      /* Unique overloaded member function.  */
-	      return build_unary_op (ADDR_EXPR, TREE_VALUE (TREE_VALUE (arg)), 0);
-	    }
-	  return build1 (ADDR_EXPR, unknown_type_node, arg);
-	}
-
-      /* Handle complex lvalues (when permitted)
-	 by reduction to simpler cases.  */
-      val = unary_complex_lvalue (code, arg);
-      if (val != 0)
-	return val;
-
-#if 0 /* Turned off because inconsistent;
-	 float f; *&(int)f = 3.4 stores in int format
-	 whereas (int)f = 3.4 stores in float format.  */
-      /* Address of a cast is just a cast of the address
-	 of the operand of the cast.  */
-      switch (TREE_CODE (arg))
-	{
-	case NOP_EXPR:
-	case CONVERT_EXPR:
-	case FLOAT_EXPR:
-	case FIX_TRUNC_EXPR:
-	case FIX_FLOOR_EXPR:
-	case FIX_ROUND_EXPR:
-	case FIX_CEIL_EXPR:
-	  if (pedantic)
-	    pedwarn ("ANSI C++ forbids taking the address of a cast expression");
-	  return convert (build_pointer_type (TREE_TYPE (arg)),
-			  build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0));
-	}
-#endif
-
-      /* Allow the address of a constructor if all the elements
-	 are constant.  */
-      if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
-	;
-      /* Anything not already handled and not a true memory reference
-	 is an error.  */
-      else if (typecode != FUNCTION_TYPE
-	       && typecode != METHOD_TYPE
-	       && !lvalue_or_else (arg, "unary `&'"))
-	return error_mark_node;
-
-      /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
-      argtype = TREE_TYPE (arg);
-      /* If the lvalue is const or volatile,
-	 merge that into the type that the address will point to.  */
-      if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
-	  || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
-	{
-	  if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
-	    argtype = build_type_variant (argtype,
-					  TREE_READONLY (arg),
-					  TREE_THIS_VOLATILE (arg));
-	}
-
-      argtype = build_pointer_type (argtype);
-
-      if (mark_addressable (arg) == 0)
-	return error_mark_node;
-
-      {
-	tree addr;
-
-	if (TREE_CODE (arg) == COMPONENT_REF)
-	  addr = build_component_addr (arg, argtype,
-				       "attempt to take address of bit-field structure member `%s'");
-	else
-	  addr = build1 (code, argtype, arg);
-
-	/* Address of a static or external variable or
-	   function counts as a constant */
-	if (staticp (arg))
-	  TREE_CONSTANT (addr) = 1;
-	return addr;
-      }
-    }
-
-  if (!errstring)
-    {
-      if (argtype == 0)
-	argtype = TREE_TYPE (arg);
-      return fold (build1 (code, argtype, arg));
-    }
-
-  error (errstring);
-  return error_mark_node;
-}
-
-/* If CONVERSIONS is a conversion expression or a nested sequence of such,
-   convert ARG with the same conversions in the same order
-   and return the result.  */
-
-static tree
-convert_sequence (conversions, arg)
-     tree conversions;
-     tree arg;
-{
-  switch (TREE_CODE (conversions))
-    {
-    case NOP_EXPR:
-    case CONVERT_EXPR:
-    case FLOAT_EXPR:
-    case FIX_TRUNC_EXPR:
-    case FIX_FLOOR_EXPR:
-    case FIX_ROUND_EXPR:
-    case FIX_CEIL_EXPR:
-      return convert (TREE_TYPE (conversions),
-		      convert_sequence (TREE_OPERAND (conversions, 0),
-					arg));
-
-    default:
-      return arg;
-    }
-}
-
-/* Apply unary lvalue-demanding operator CODE to the expression ARG
-   for certain kinds of expressions which are not really lvalues
-   but which we can accept as lvalues.
-
-   If ARG is not a kind of expression we can handle, return zero.  */
-   
-tree
-unary_complex_lvalue (code, arg)
-     enum tree_code code;
-     tree arg;
-{
-  /* Handle (a, b) used as an "lvalue".  */
-  if (TREE_CODE (arg) == COMPOUND_EXPR)
-    {
-      tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
-      pedantic_lvalue_warning (COMPOUND_EXPR);
-      return build (COMPOUND_EXPR, TREE_TYPE (real_result),
-		    TREE_OPERAND (arg, 0), real_result);
-    }
-
-  /* Handle (a ? b : c) used as an "lvalue".  */
-  if (TREE_CODE (arg) == COND_EXPR)
-    {
-      pedantic_lvalue_warning (COND_EXPR);
-      return (build_conditional_expr
-	      (TREE_OPERAND (arg, 0),
-	       build_unary_op (code, TREE_OPERAND (arg, 1), 0),
-	       build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
-    }
-
-  if (code != ADDR_EXPR)
-    return 0;
-
-  /* Handle (a = b) used as an "lvalue" for `&'.  */
-  if (TREE_CODE (arg) == MODIFY_EXPR
-      || TREE_CODE (arg) == INIT_EXPR)
-    {
-      tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
-      return build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result);
-    }
-
-  if (TREE_CODE (arg) == WITH_CLEANUP_EXPR)
-    {
-      tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
-      real_result = build (WITH_CLEANUP_EXPR, TREE_TYPE (real_result),
-			   real_result, 0, TREE_OPERAND (arg, 2));
-      return real_result;
-    }
-
-  if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
-      || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
-      || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
-    {
-      /* The representation of something of type OFFSET_TYPE
-	 is really the representation of a pointer to it.
-	 Here give the representation its true type.  */
-      tree t;
-      tree offset;
-
-      my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
-
-      if (TREE_CODE (arg) != OFFSET_REF)
-	return 0;
-
-      t = TREE_OPERAND (arg, 1);
-
-      if (TREE_CODE (t) == FUNCTION_DECL)
-	{
-	  tree context = NULL_TREE;
-
-	  if (DECL_VINDEX (t)
-	      || (flag_all_virtual == 1
-		  && ((context = decl_type_context (t))
-		      && TYPE_OVERLOADS_METHOD_CALL_EXPR (context)
-		      && ! DECL_CONSTRUCTOR_P (t))))
-	    {
-	      offset = copy_node (DECL_VINDEX (t));
-	      TREE_TYPE (offset) = build_pointer_type (TREE_TYPE (arg));
-	    }
-	  else
-	    offset = build_unary_op (ADDR_EXPR, t, 0);
-
-	  return offset;
-	}
-      if (TREE_CODE (t) == VAR_DECL)
-	return build_unary_op (ADDR_EXPR, t, 0);
-      else
-	{
-	  /* Can't build a pointer to member if the member must
-	     go through virtual base classes.  */
-	  if (virtual_member (DECL_FIELD_CONTEXT (t),
-			      CLASSTYPE_VBASECLASSES (TREE_TYPE (TREE_OPERAND (arg, 0)))))
-	    {
-	      sorry ("pointer to member via virtual baseclass");
-	      return error_mark_node;
-	    }
-
-	  if (TREE_OPERAND (arg, 0)
-	      && (TREE_CODE (TREE_OPERAND (arg, 0)) != NOP_EXPR
-		  || TREE_OPERAND (TREE_OPERAND (arg, 0), 0) != error_mark_node))
-	    {
-	      /* Don't know if this should return address to just
-		 _DECL, or actual address resolved in this expression.  */
-	      sorry ("address of bound pointer-to-member expression");
-	      return error_mark_node;
-	    }
-
-	  return convert (build_pointer_type (TREE_TYPE (arg)),
-			  size_binop (EASY_DIV_EXPR, 
-				      DECL_FIELD_BITPOS (t),
-				      size_int (BITS_PER_UNIT)));
-	}
-    }
-
-  if (TREE_CODE (arg) == OFFSET_REF)
-    {
-      tree left = TREE_OPERAND (arg, 0), left_addr;
-      tree right_addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 1), 0);
-
-      if (left == 0)
-	if (current_class_decl)
-	  left_addr = current_class_decl;
-	else
-	  {
-	    error ("no `this' for pointer to member");
-	    return error_mark_node;
-	  }
-      else
-	left_addr = build_unary_op (ADDR_EXPR, left, 0);
-
-      return build (PLUS_EXPR, build_pointer_type (TREE_TYPE (arg)),
-		    build1 (NOP_EXPR, integer_type_node, left_addr),
-		    build1 (NOP_EXPR, integer_type_node, right_addr));
-    }
-
-  /* We permit compiler to make function calls returning
-     objects of aggregate type look like lvalues.  */
-  {
-    tree targ = arg;
-
-    if (TREE_CODE (targ) == SAVE_EXPR)
-      targ = TREE_OPERAND (targ, 0);
-
-    if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
-      {
-	if (TREE_CODE (arg) == SAVE_EXPR)
-	  targ = arg;
-	else
-	  targ = build_cplus_new (TREE_TYPE (arg), arg, 1);
-	return build1 (ADDR_EXPR, TYPE_POINTER_TO (TREE_TYPE (arg)), targ);
-      }
-
-    if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
-      return build (SAVE_EXPR, TYPE_POINTER_TO (TREE_TYPE (arg)),
-		     TREE_OPERAND (targ, 0), current_function_decl, NULL);
-
-    /* We shouldn't wrap WITH_CLEANUP_EXPRs inside of SAVE_EXPRs, but in case
-       we do, here's how to handle it.  */
-    if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == WITH_CLEANUP_EXPR)
-      {
-#if 0
-	/* Not really a bug, but something to turn on when testing.  */
-	compiler_error ("WITH_CLEANUP_EXPR wrapped in SAVE_EXPR");
-#endif
-	return unary_complex_lvalue (ADDR_EXPR, targ);
-      }
-  }
-
-  /* Don't let anything else be handled specially.  */
-  return 0;
-}
-
-/* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
-   COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
-
-static void
-pedantic_lvalue_warning (code)
-     enum tree_code code;
-{
-  if (pedantic)
-    pedwarn ("ANSI C++ forbids use of %s expressions as lvalues",
-	     code == COND_EXPR ? "conditional"
-	     : code == COMPOUND_EXPR ? "compound" : "cast");
-}
-
-/* Mark EXP saying that we need to be able to take the
-   address of it; it should not be allocated in a register.
-   Value is 1 if successful.
-
-   C++: we do not allow `current_class_decl' to be addressable.  */
-
-int
-mark_addressable (exp)
-     tree exp;
-{
-  register tree x = exp;
-
-  if (TREE_ADDRESSABLE (x) == 1)
-    return 1;
-
-  while (1)
-    switch (TREE_CODE (x))
-      {
-      case ADDR_EXPR:
-      case COMPONENT_REF:
-      case ARRAY_REF:
-	x = TREE_OPERAND (x, 0);
-	break;
-
-      case PARM_DECL:
-	if (x == current_class_decl)
-	  {
-	    error ("address of `this' not available");
-	    TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later */
-	    put_var_into_stack (x);
-	    return 1;
-	  }
-      case VAR_DECL:
-	if (TREE_STATIC (x)
-	    && TREE_READONLY (x)
-	    && DECL_RTL (x) != 0
-	    && ! decl_in_memory_p (x))
-	  {
-	    /* We thought this would make a good constant variable,
-	       but we were wrong.  */
-	    push_obstacks_nochange ();
-	    end_temporary_allocation ();
-
-	    TREE_ASM_WRITTEN (x) = 0;
-	    DECL_RTL (x) = 0;
-	    rest_of_decl_compilation (x, 0, IDENTIFIER_LOCAL_VALUE (x) == 0, 0);
-	    TREE_ADDRESSABLE (x) = 1;
-
-	    pop_obstacks ();
-
-	    return 1;
-	  }
-	/* Caller should not be trying to mark initialized
-	   constant fields addressable.  */
-	my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0
-			    || DECL_IN_AGGR_P (x) == 0
-			    || TREE_STATIC (x)
-			    || DECL_EXTERNAL (x), 314);
-
-      case CONST_DECL:
-	if (DECL_REGISTER (x))
-	  {
-	    if (TREE_PUBLIC (x))
-	      {
-		error ("address of global register variable `%s' requested",
-		       IDENTIFIER_POINTER (DECL_NAME (x)));
-		return 0;
-	      }
-	    warning ("address requested for `%s', which is declared `register'",
-		     IDENTIFIER_POINTER (DECL_NAME (x)));
-	  }
-	put_var_into_stack (x);
-	TREE_ADDRESSABLE (x) = 1;
-	return 1;
-
-      case RESULT_DECL:
-	put_var_into_stack (x);
-	TREE_ADDRESSABLE (x) = 1;
-	return 1;
-
-      case FUNCTION_DECL:
-	/* We have to test both conditions here.  The first may
-	   be non-zero in the case of processing a default function.
-	   The second may be non-zero in the case of a template function.  */
-	x = DECL_MAIN_VARIANT (x);
-	if ((DECL_INLINE (x) || DECL_PENDING_INLINE_INFO (x))
-	    && (DECL_CONTEXT (x) == NULL_TREE
-		|| TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (x))) != 't'
-		|| ! CLASSTYPE_INTERFACE_ONLY (DECL_CONTEXT (x))))
-	  {
-	    mark_inline_for_output (x);
-	    if (x == current_function_decl)
-	      DECL_EXTERNAL (x) = 0;
-	  }
-	TREE_ADDRESSABLE (x) = 1;
-	TREE_USED (x) = 1;
-	TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
-	return 1;
-
-      default:
-	return 1;
-    }
-}
-
-/* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
-
-tree
-build_x_conditional_expr (ifexp, op1, op2)
-     tree ifexp, op1, op2;
-{
-  tree rval;
-
-  /* See comments in `build_x_binary_op'.  */
-  if (op1 != 0 && (rval = build_opfncall (COND_EXPR, 0, ifexp, op1, op2)))
-    {
-      if (rval = build_opfncall (COND_EXPR, LOOKUP_PROTECT, ifexp, op1, op2))
-	return rval;
-      build_opfncall (COND_EXPR, LOOKUP_NORMAL, ifexp, op1, op2);
-      return error_mark_node;
-    }
-  return build_conditional_expr (ifexp, op1, op2);
-}
-
-tree
-build_conditional_expr (ifexp, op1, op2)
-     tree ifexp, op1, op2;
-{
-  register tree type1;
-  register tree type2;
-  register enum tree_code code1;
-  register enum tree_code code2;
-  register tree result_type = NULL_TREE;
-
-  /* If second operand is omitted, it is the same as the first one;
-     make sure it is calculated only once.  */
-  if (op1 == 0)
-    {
-      if (pedantic)
-	pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression");
-      ifexp = op1 = save_expr (ifexp);
-    }
-
-  ifexp = truthvalue_conversion (default_conversion (ifexp));
-
-  if (TREE_CODE (ifexp) == ERROR_MARK)
-    return error_mark_node;
-
-  op1 = require_instantiated_type (TREE_TYPE (op2), op1, error_mark_node);
-  if (op1 == error_mark_node)
-    return error_mark_node;
-  op2 = require_instantiated_type (TREE_TYPE (op1), op2, error_mark_node);
-  if (op2 == error_mark_node)
-    return error_mark_node;
-
-  /* C++: REFERENCE_TYPES must be dereferenced.  */
-  type1 = TREE_TYPE (op1);
-  code1 = TREE_CODE (type1);
-  type2 = TREE_TYPE (op2);
-  code2 = TREE_CODE (type2);
-
-  if (code1 == REFERENCE_TYPE)
-    {
-      op1 = convert_from_reference (op1);
-      type1 = TREE_TYPE (op1);
-      code1 = TREE_CODE (type1);
-    }
-  if (code2 == REFERENCE_TYPE)
-    {
-      op2 = convert_from_reference (op2);
-      type2 = TREE_TYPE (op2);
-      code2 = TREE_CODE (type2);
-    }
-
-#if 1 /* Produces wrong result if within sizeof.  Sorry.  */
-  /* Don't promote the operands separately if they promote
-     the same way.  Return the unpromoted type and let the combined
-     value get promoted if necessary.  */
-
-  if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)
-      && code2 != ARRAY_TYPE
-#if 0
-      /* For C++, let the enumeral type come through.  */
-      && code2 != ENUMERAL_TYPE
-#endif
-      && code2 != FUNCTION_TYPE
-      && code2 != METHOD_TYPE)
-    {
-      tree result;
-
-      if (TREE_CONSTANT (ifexp)
-	  && (TREE_CODE (ifexp) == INTEGER_CST
-	      || TREE_CODE (ifexp) == ADDR_EXPR))
-	return (integer_zerop (ifexp) ? op2 : op1);
-
-      if (TREE_CODE (op1) == CONST_DECL)
-	op1 = DECL_INITIAL (op1);
-      else if (TREE_READONLY_DECL_P (op1))
-	op1 = decl_constant_value (op1);
-      if (TREE_CODE (op2) == CONST_DECL)
-	op2 = DECL_INITIAL (op2);
-      else if (TREE_READONLY_DECL_P (op2))
-	op2 = decl_constant_value (op2);
-      if (type1 != type2)
-	type1 = build_type_variant
-			(type1,
-			 TREE_READONLY (op1) || TREE_READONLY (op2),
-			 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
-      /* ??? This is a kludge to deal with the fact that
-	 we don't sort out integers and enums properly, yet.  */
-      result = fold (build (COND_EXPR, type1, ifexp, op1, op2));
-      if (TREE_TYPE (result) != type1)
-	result = build1 (NOP_EXPR, type1, result);
-      return result;
-    }
-#endif
-
-  /* They don't match; promote them both and then try to reconcile them.
-     But don't permit mismatching enum types.  */
-  if (code1 == ENUMERAL_TYPE)
-    {
-      if (code2 == ENUMERAL_TYPE)
-	{
-	  message_2_types (error, "enumeral mismatch in conditional expression: `%s' vs `%s'", type1, type2);
-	  return error_mark_node;
-	}
-      else if (extra_warnings && ! IS_AGGR_TYPE_CODE (code2))
-	warning ("enumeral and non-enumeral type in conditional expression");
-    }
-  else if (extra_warnings
-	   && code2 == ENUMERAL_TYPE && ! IS_AGGR_TYPE_CODE (code1))
-    warning ("enumeral and non-enumeral type in conditional expression");
-
-  if (code1 != VOID_TYPE)
-    {
-      op1 = default_conversion (op1);
-      type1 = TREE_TYPE (op1);
-      code1 = TREE_CODE (type1);
-    }
-  if (code2 != VOID_TYPE)
-    {
-      op2 = default_conversion (op2);
-      type2 = TREE_TYPE (op2);
-      code2 = TREE_CODE (type2);
-    }
-
-  /* Quickly detect the usual case where op1 and op2 have the same type
-     after promotion.  */
-  if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
-    {
-      if (type1 == type2)
-	result_type = type1;
-      else
-	result_type = build_type_variant
-			(type1,
-			 TREE_READONLY (op1) || TREE_READONLY (op2),
-			 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
-    }
-  else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
-           && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
-    {
-      result_type = common_type (type1, type2);
-    }
-  else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
-    {
-      if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
-	pedwarn ("ANSI C++ forbids conditional expr with only one void side");
-      result_type = void_type_node;
-    }
-  else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
-    {
-      if (comp_target_types (type1, type2, 1))
-	result_type = common_type (type1, type2);
-      else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node)
-	result_type = qualify_type (type2, type1);
-      else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node)
-	result_type = qualify_type (type1, type2);
-      else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
-	{
-	  if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
-	    pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
-	  result_type = qualify_type (type1, type2);
-	}
-      else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
-	{
-	  if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
-	    pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer");
-	  result_type = qualify_type (type2, type1);
-	}
-      /* C++ */
-      else if (comptypes (type2, type1, 0))
-	result_type = type2;
-      else if (IS_AGGR_TYPE (TREE_TYPE (type1))
-	       && IS_AGGR_TYPE (TREE_TYPE (type2))
-	       && (result_type = common_base_type (TREE_TYPE (type1), TREE_TYPE (type2))))
-	{
-	  if (result_type == error_mark_node)
-	    {
-	      message_2_types (error, "common base type of types `%s' and `%s' is ambiguous",
-			       TREE_TYPE (type1), TREE_TYPE (type2));
-	      result_type = ptr_type_node;
-	    }
-	  else result_type = TYPE_POINTER_TO (result_type);
-	}
-      else
-	{
-	  warning ("pointer type mismatch in conditional expression");
-	  result_type = ptr_type_node;
-	}
-    }
-  else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
-    {
-      if (!integer_zerop (op2))
-	warning ("pointer/integer type mismatch in conditional expression");
-      else
-	{
-	  op2 = null_pointer_node;
-	  if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
-	    pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
-	}
-      result_type = type1;
-    }
-  else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
-    {
-      if (!integer_zerop (op1))
-	warning ("pointer/integer type mismatch in conditional expression");
-      else
-	{
-	  op1 = null_pointer_node;
-	  if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
-	    pedwarn ("ANSI C++ forbids conditional expr between 0 and function pointer");
-	}
-      result_type = type2;
-      op1 = null_pointer_node;
-    }
-
-  if (!result_type)
-    {
-      /* The match does not look good.  If either is
-	 an aggregate value, try converting to a scalar type.  */
-      if (code1 == RECORD_TYPE && code2 == RECORD_TYPE)
-	{
-	  message_2_types (error, "aggregate mismatch in conditional expression: `%s' vs `%s'", type1, type2);
-	  return error_mark_node;
-	}
-      if (code1 == RECORD_TYPE && TYPE_HAS_CONVERSION (type1))
-	{
-	  tree tmp = build_type_conversion (CONVERT_EXPR, type2, op1, 0);
-	  if (tmp == NULL_TREE)
-	    {
-	      error_with_aggr_type (type1, "aggregate type `%s' could not convert on lhs of `:'");
-	      return error_mark_node;
-	    }
-	  if (tmp == error_mark_node)
-	    error ("ambiguous pointer conversion");
-	  result_type = type2;
-	  op1 = tmp;
-	}
-      else if (code2 == RECORD_TYPE && TYPE_HAS_CONVERSION (type2))
-	{
-	  tree tmp = build_type_conversion (CONVERT_EXPR, type1, op2, 0);
-	  if (tmp == NULL_TREE)
-	    {
-	      error_with_aggr_type (type2, "aggregate type `%s' could not convert on rhs of `:'");
-	      return error_mark_node;
-	    }
-	  if (tmp == error_mark_node)
-	    error ("ambiguous pointer conversion");
-	  result_type = type1;
-	  op2 = tmp;
-	}
-      else if (flag_cond_mismatch)
-	result_type = void_type_node;
-      else
-	{
-	  error ("type mismatch in conditional expression");
-	  return error_mark_node;
-	}
-    }
-
-  if (result_type != TREE_TYPE (op1))
-    op1 = convert (result_type, op1);
-  if (result_type != TREE_TYPE (op2))
-    op2 = convert (result_type, op2);
-
-#if 0
-  /* XXX delete me, I've been here for years.  */
-  if (IS_AGGR_TYPE_CODE (code1))
-    {
-      result_type = TREE_TYPE (op1);
-      if (TREE_CONSTANT (ifexp))
-	return (integer_zerop (ifexp) ? op2 : op1);
-
-      if (TYPE_MODE (result_type) == BLKmode)
-	{
-	  register tree tempvar
-	    = build_decl (VAR_DECL, NULL_TREE, result_type);
-	  register tree xop1 = build_modify_expr (tempvar, NOP_EXPR, op1);
-	  register tree xop2 = build_modify_expr (tempvar, NOP_EXPR, op2);
-	  register tree result = fold (build (COND_EXPR, result_type,
-					      ifexp, xop1, xop2));
-
-	  layout_decl (tempvar, 0);
-	  /* No way to handle variable-sized objects here.
-	     I fear that the entire handling of BLKmode conditional exprs
-	     needs to be redone.  */
-	  my_friendly_assert (TREE_CONSTANT (DECL_SIZE (tempvar)), 315);
-	  DECL_RTL (tempvar)
-	    = assign_stack_local (DECL_MODE (tempvar),
-				  (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
-				   + BITS_PER_UNIT - 1)
-				  / BITS_PER_UNIT,
-				  0);
-
-	  TREE_SIDE_EFFECTS (result)
-	    = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
-	      | TREE_SIDE_EFFECTS (op2);
-	  return build (COMPOUND_EXPR, result_type, result, tempvar);
-	}
-    }
-#endif /* 0 */
-
-  if (TREE_CONSTANT (ifexp))
-    return (integer_zerop (ifexp) ? op2 : op1);
-
-  return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
-}
-
-/* Handle overloading of the ',' operator when needed.  Otherwise,
-   this function just builds an expression list.  */
-tree
-build_x_compound_expr (list)
-     tree list;
-{
-  tree rest = TREE_CHAIN (list);
-  tree result;
-
-  if (rest == NULL_TREE)
-    return build_compound_expr (list);
-
-  result = build_opfncall (COMPOUND_EXPR, LOOKUP_NORMAL,
-			   TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
-  if (result)
-    return build_x_compound_expr (tree_cons (NULL_TREE, result, TREE_CHAIN (rest)));
-  else
-    return build_compound_expr (tree_cons (NULL_TREE, TREE_VALUE (list),
-					   build_tree_list (NULL_TREE, build_x_compound_expr (rest))));
-}
-
-/* Given a list of expressions, return a compound expression
-   that performs them all and returns the value of the last of them.  */
-
-tree
-build_compound_expr (list)
-     tree list;
-{
-  register tree rest;
-
-  if (TREE_READONLY_DECL_P (TREE_VALUE (list)))
-    TREE_VALUE (list) = decl_constant_value (TREE_VALUE (list));
-
-  if (TREE_CHAIN (list) == 0)
-    {
-      /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
-	 Strip such NOP_EXPRs, since LIST is used in non-lvalue context.  */
-      if (TREE_CODE (list) == NOP_EXPR
-	  && TREE_TYPE (list) == TREE_TYPE (TREE_OPERAND (list, 0)))
-	list = TREE_OPERAND (list, 0);
-
-      /* Convert arrays to pointers.  */
-      if (TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE)
-	return default_conversion (TREE_VALUE (list));
-      else
-	return TREE_VALUE (list);
-    }
-
-  rest = build_compound_expr (TREE_CHAIN (list));
-
-  if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
-    return rest;
-
-  return build (COMPOUND_EXPR, TREE_TYPE (rest),
-		break_out_cleanups (TREE_VALUE (list)), rest);
-}
-
-/* Build an expression representing a cast to type TYPE of expression EXPR.  */
-
-tree
-build_c_cast (type, expr)
-     register tree type;
-     tree expr;
-{
-  register tree value = expr;
-
-  if (type == error_mark_node || expr == error_mark_node)
-    return error_mark_node;
-
-  /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
-     Strip such NOP_EXPRs, since VALUE is being used in non-lvalue context.  */
-  if (TREE_CODE (value) == NOP_EXPR
-      && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
-    value = TREE_OPERAND (value, 0);
-
-  if (TREE_TYPE (expr)
-      && TREE_CODE (TREE_TYPE (expr)) == OFFSET_TYPE
-      && TREE_CODE (type) != OFFSET_TYPE)
-    value = resolve_offset_ref (value);
-
-  if (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      /* Allow casting from T1* to T2[] because Cfront allows it.
-	 NIHCL uses it. It is not valid ANSI C however, and hence, not
-	 valid ANSI C++.  */
-      if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
-	{
-	  if (pedantic)
-	    pedwarn ("ANSI C++ forbids casting to an array type");
-	  type = build_pointer_type (TREE_TYPE (type));
-	}
-      else
-	{
-	  error ("ANSI C++ forbids casting to an array type");
-	  return error_mark_node;
-	}
-    }
-
-  /* When converting into a reference type, just convert into a pointer
-     to the new type and deference it.  While this is not exactly what ARM 5.4
-     calls for, it is pretty close for now.  (int &)ri  --->  *(int*)&ri  */
-  if (TREE_CODE (type) == REFERENCE_TYPE)
-    {
-      value = build_unary_op (ADDR_EXPR, value, 0);
-      if (value != error_mark_node)
-	value = convert (build_pointer_type (TREE_TYPE (type)), value);
-      if (value != error_mark_node)
-	value = build_indirect_ref (value, "reference conversion");
-      return value;
-    }
-
-  if (TREE_TYPE (value)
-      && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
-    {
-      /* For C++, we must copy the constness of TYPE into VALUE.  */
-      if (TREE_READONLY (value) != TYPE_READONLY (type))
-	{
-	  value = copy_node (value);
-	  TREE_READONLY (value) = TYPE_READONLY (type);
-	}
-      else if (pedantic)
-	{
-	  if (TREE_CODE (type) == RECORD_TYPE
-	      || TREE_CODE (type) == UNION_TYPE)
-	    pedwarn ("ANSI C++ forbids casting nonscalar to the same type");
-	}
-      return value;
-    }
-
-  /* If there's only one function in the overloaded space,
-     just take it.  */
-  if (TREE_CODE (value) == TREE_LIST
-      && TREE_CHAIN (value) == NULL_TREE)
-    value = TREE_VALUE (value);
-
-  /* Make up for the fact that we do not always perform
-     `default_conversion' anymore.  */
-  if (TREE_READONLY_DECL_P (value))
-    value = decl_constant_value (value);
-
-  if (TREE_TYPE (value) == NULL_TREE
-      || type_unknown_p (value))
-    {
-      value = instantiate_type (type, value, 1);
-      /* Did we lose?  */
-      if (value == error_mark_node)
-	return error_mark_node;
-    }
-  else
-    {
-      tree otype;
-      /* Convert functions and arrays to pointers and
-	 convert references to their expanded types,
-	 but don't convert any other types.  */
-      if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
-	  || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
-	  || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
-	value = default_conversion (value);
-      otype = TREE_TYPE (value);
-
-      /* Optionally warn about potentially worrisome casts.  */
-
-      if (warn_cast_qual
-	  && TREE_CODE (type) == POINTER_TYPE
-	  && TREE_CODE (otype) == POINTER_TYPE)
-	{
-	  /* For C++ we make these regular warnings, rather than
-	     softening them into pedwarns.  */
-	  if (TYPE_VOLATILE (TREE_TYPE (otype))
-	      && ! TYPE_VOLATILE (TREE_TYPE (type)))
-	    warning ("cast discards `volatile' from pointer target type");
-	  if (TYPE_READONLY (TREE_TYPE (otype))
-	      && ! TYPE_READONLY (TREE_TYPE (type)))
-	    warning ("cast discards `const' from pointer target type");
-	}
-
-      /* Warn about possible alignment problems.  */
-      if (STRICT_ALIGNMENT && warn_cast_align
-	  && TREE_CODE (type) == POINTER_TYPE
-	  && TREE_CODE (otype) == POINTER_TYPE
-	  && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
-	  && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
-	  && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
-	warning ("cast increases required alignment of target type");
-
-#if 0
-      if (TREE_CODE (type) == INTEGER_TYPE
-	  && TREE_CODE (otype) == POINTER_TYPE
-	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
-	warning ("cast from pointer to integer of different size");
-
-      if (TREE_CODE (type) == POINTER_TYPE
-	  && TREE_CODE (otype) == INTEGER_TYPE
-	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
-	  /* Don't warn about converting 0 to pointer,
-	     provided the 0 was explicit--not cast or made by folding.  */
-	  && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value)))
-	warning ("cast to pointer from integer of different size");
-#endif
-
-      value = convert_force (type, value);
-    }
-  if (value == expr)
-    /* Always produce some operator for an explicit cast,
-       so we can tell (for -pedantic) that the cast is no lvalue.  */
-    {
-      tree nvalue = build1 (NOP_EXPR, type, value);
-      TREE_CONSTANT (nvalue) = TREE_CONSTANT (value);
-      return nvalue;
-    }
-
-  return value;
-}
-
-/* Build an assignment expression of lvalue LHS from value RHS.
-
-   In C++, if the left hand side of the assignment is a REFERENCE_TYPE,
-   that reference becomes deferenced down to it base type. */
-
-/* Return a reference to the BASE_INDEX part of EXPR.  TYPE is
-   the type to which BASE_INDEX applies.  */
-static tree
-get_base_ref (type, base_index, expr)
-     tree type;
-     int base_index;
-     tree expr;
-{
-  tree binfos = TYPE_BINFO_BASETYPES (type);
-  tree base_binfo = TREE_VEC_ELT (binfos, base_index);
-  tree ref;
-
-  if (TREE_CODE (expr) == ARRAY_REF
-      || ! BINFO_OFFSET_ZEROP (base_binfo)
-      || TREE_VIA_VIRTUAL (base_binfo)
-      || TYPE_MODE (type) != TYPE_MODE (BINFO_TYPE (base_binfo)))
-    {
-      tree addr = build_unary_op (ADDR_EXPR, expr, 0);
-      ref = build_indirect_ref (convert_pointer_to (base_binfo, addr),
-				NULL_PTR);
-    }
-  else
-    {
-      ref = copy_node (expr);
-      TREE_TYPE (ref) = BINFO_TYPE (base_binfo);
-    }
-  return ref;
-}
-
-/* Build an assignment expression of lvalue LHS from value RHS.
-   MODIFYCODE is the code for a binary operator that we use
-   to combine the old value of LHS with RHS to get the new value.
-   Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
-
-   C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.
-
-   `build_modify_expr_1' implements recursive part of memberwise
-   assignment operation.  */
-static tree
-build_modify_expr_1 (lhs, modifycode, rhs, basetype_path)
-     tree lhs, rhs;
-     enum tree_code modifycode;
-     tree basetype_path;
-{
-  register tree result;
-  tree newrhs = rhs;
-  tree lhstype = TREE_TYPE (lhs);
-  tree olhstype = lhstype;
-
-  /* Avoid duplicate error messages from operands that had errors.  */
-  if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
-    return error_mark_node;
-
-  /* If a binary op has been requested, combine the old LHS value with the RHS
-     producing the value we should actually store into the LHS.  */
-
-  if (modifycode == INIT_EXPR)
-    ;
-  else if (modifycode == NOP_EXPR)
-    {
-      /* must deal with overloading of `operator=' here.  */
-      if (TREE_CODE (lhstype) == REFERENCE_TYPE)
-	lhstype = TREE_TYPE (lhstype);
-      else
-	lhstype = olhstype;
-    }
-  else
-    {
-      lhs = stabilize_reference (lhs);
-      newrhs = build_binary_op (modifycode, lhs, rhs, 1);
-      modifycode = NOP_EXPR;
-    }
-
-  /* If storing into a structure or union member,
-     it has probably been given type `int'.
-     Compute the type that would go with
-     the actual amount of storage the member occupies.  */
-
-  if (TREE_CODE (lhs) == COMPONENT_REF
-      && (TREE_CODE (lhstype) == INTEGER_TYPE
-	  || TREE_CODE (lhstype) == REAL_TYPE
-	  || TREE_CODE (lhstype) == ENUMERAL_TYPE))
-    lhstype = TREE_TYPE (get_unwidened (lhs, 0));
-
-  /* C++: The semantics of C++ differ from those of C when an
-     assignment of an aggregate is desired.  Assignment in C++ is
-     now defined as memberwise assignment of non-static members
-     and base class objects.  This rule applies recursively
-     until a member of a built-in type is found.
-
-     Also, we cannot do a bit-wise copy of aggregates which
-     contain virtual function table pointers.  Those
-     pointer values must be preserved through the copy.
-     However, this is handled in expand_expr, and not here.
-     This is because much better code can be generated at
-     that stage than this one.  */
-  if (TREE_CODE (lhstype) == RECORD_TYPE
-      && TYPE_LANG_SPECIFIC (lhstype)
-      && TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs)))
-    {
-      register tree elt;
-      int i;
-
-      /* Perform operation on object.  */
-      if (modifycode == INIT_EXPR && TYPE_HAS_INIT_REF (lhstype))
-	{
-	  result = build_method_call (lhs, constructor_name (lhstype),
-				      build_tree_list (NULL_TREE, rhs),
-				      basetype_path, LOOKUP_NORMAL);
-	  return build_indirect_ref (result, NULL_PTR);
-	}
-      else if (modifycode == NOP_EXPR)
-	{
-	  /* `operator=' is not an inheritable operator.  */
-	  if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_ASSIGNMENT (lhstype))
-	    {
-	      result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
-				       lhs, rhs, make_node (NOP_EXPR));
-	      if (result == NULL_TREE)
-		return error_mark_node;
-	      return result;
-	    }
-	}
-
-      if (TYPE_USES_VIRTUAL_BASECLASSES (lhstype)
-	  || (modifycode == NOP_EXPR && TYPE_GETS_ASSIGNMENT (lhstype))
-	  || (modifycode == INIT_EXPR && TYPE_GETS_INIT_REF (lhstype)))
-	{
-	  tree binfos = BINFO_BASETYPES (TYPE_BINFO (lhstype));
-	  result = NULL_TREE;
-
-	  if (binfos != NULL_TREE)
-	    /* Perform operation on each member, depth-first, left-right.  */
-	    for (i = 0; i <= TREE_VEC_LENGTH (binfos)-1; i++)
-	      {
-		tree base_binfo = TREE_VEC_ELT (binfos, i);
-		tree base_lhs, base_rhs;
-		tree new_result;
-
-		/* Assignments from virtual baseclasses handled elsewhere.  */
-		if (TREE_VIA_VIRTUAL (base_binfo))
-		  continue;
-
-		base_lhs = get_base_ref (lhstype, i, lhs);
-		base_rhs = get_base_ref (lhstype, i, newrhs);
-
-		BINFO_INHERITANCE_CHAIN (base_binfo) = basetype_path;
-		new_result
-		  = build_modify_expr_1 (base_lhs, modifycode, base_rhs,
-					 base_binfo);
-
-		/* We either get back a compound stmt, or a simple one.  */
-		if (new_result && TREE_CODE (new_result) == TREE_LIST)
-		  new_result = build_compound_expr (new_result);
-		result = tree_cons (NULL_TREE, new_result, result);
-	      }
-
-	  for (elt = TYPE_FIELDS (lhstype); elt; elt = TREE_CHAIN (elt))
-	    {
-	      tree vbases = NULL_TREE;
-	      tree elt_lhs, elt_rhs;
-
-	      if (TREE_CODE (elt) != FIELD_DECL)
-		continue;
-	      if (DECL_NAME (elt)
-		  && (VFIELD_NAME_P (DECL_NAME (elt))
-		      || VBASE_NAME_P (DECL_NAME (elt))))
-		continue;
-
-	      if (IS_AGGR_TYPE (TREE_TYPE (elt))
-		  && TYPE_LANG_SPECIFIC (TREE_TYPE (elt)))
-		vbases = CLASSTYPE_VBASECLASSES (TREE_TYPE (elt));
-
-	      elt_lhs = build (COMPONENT_REF, TREE_TYPE (elt), lhs, elt);
-	      elt_rhs = build (COMPONENT_REF, TREE_TYPE (elt), newrhs, elt);
-	      /* It is not always safe to go through `build_modify_expr_1'
-		 when performing element-wise copying.  This is because
-		 an element may be of ARRAY_TYPE, which will not
-		 be properly copied as a naked element.  */
-	      if (TREE_CODE (TREE_TYPE (elt)) == RECORD_TYPE
-		  && TYPE_LANG_SPECIFIC (TREE_TYPE (elt)))
-		basetype_path = TYPE_BINFO (TREE_TYPE (elt));
-
-	      while (vbases)
-		{
-		  tree elt_lhs_addr = build_unary_op (ADDR_EXPR, elt_lhs, 0);
-		  tree elt_rhs_addr = build_unary_op (ADDR_EXPR, elt_rhs, 0);
-
-		  elt_lhs_addr = convert_pointer_to (vbases, elt_lhs_addr);
-		  elt_rhs_addr = convert_pointer_to (vbases, elt_rhs_addr);
-		  result
-		    = tree_cons (NULL_TREE,
-				 build_modify_expr_1
-				 (build_indirect_ref (elt_lhs_addr, NULL_PTR),
-				  modifycode,
-				  build_indirect_ref (elt_rhs_addr, NULL_PTR),
-				  basetype_path),
-				 result);
-		  if (TREE_VALUE (result) == error_mark_node)
-		    return error_mark_node;
-		  vbases = TREE_CHAIN (vbases);
-		}
-	      elt_lhs = build_modify_expr_1 (elt_lhs, modifycode, elt_rhs,
-					     basetype_path);
-	      result = tree_cons (NULL_TREE, elt_lhs, result);
-	    }
-
-	  if (result)
-	    return build_compound_expr (result);
-	  /* No fields to move.  */
-	  return integer_zero_node;
-	}
-      else
-	{
-	  result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
-			  void_type_node, lhs, rhs);
-	  TREE_SIDE_EFFECTS (result) = 1;
-	  return result;
-	}
-    }
-
-  result = build_modify_expr (lhs, modifycode, newrhs);
-  /* ARRAY_TYPEs cannot be converted to anything meaningful,
-     and leaving it there screws up `build_compound_expr' when
-     it tries to defaultly convert everything.  */
-  if (TREE_CODE (TREE_TYPE (result)) == ARRAY_TYPE)
-    TREE_TYPE (result) = void_type_node;
-  return result;
-}
-
-tree
-build_modify_expr (lhs, modifycode, rhs)
-     tree lhs;
-     enum tree_code modifycode;
-     tree rhs;
-{
-  register tree result;
-  tree newrhs = rhs;
-  tree lhstype = TREE_TYPE (lhs);
-  tree olhstype = lhstype;
-
-  /* Types that aren't fully specified cannot be used in assignments.  */
-  lhs = require_complete_type (lhs);
-
-  /* Avoid duplicate error messages from operands that had errors.  */
-  if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
-    return error_mark_node;
-
-  /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
-     Strip such NOP_EXPRs, since RHS is being used in non-lvalue context.  */
-  if (TREE_CODE (rhs) == NOP_EXPR
-      && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0)))
-    rhs = TREE_OPERAND (rhs, 0);
-
-  /* Decide early if we are going to protect RHS from GC
-     before assigning it to LHS.  */
-  if (type_needs_gc_entry (TREE_TYPE (rhs))
-      && ! value_safe_from_gc (lhs, rhs))
-    rhs = protect_value_from_gc (lhs, rhs);
-
-  newrhs = rhs;
-
-  /* Handle control structure constructs used as "lvalues".  */
-
-  switch (TREE_CODE (lhs))
-    {
-      /* Handle --foo = 5; as these are valid constructs in C++ */
-    case PREDECREMENT_EXPR:
-    case PREINCREMENT_EXPR:
-      if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
-	lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
-		     stabilize_reference (TREE_OPERAND (lhs, 0)));
-      return build (COMPOUND_EXPR, lhstype,
-		    lhs,
-		    build_modify_expr (TREE_OPERAND (lhs, 0),
-				       modifycode, rhs));
-
-      /* Handle (a, b) used as an "lvalue".  */
-    case COMPOUND_EXPR:
-      pedantic_lvalue_warning (COMPOUND_EXPR);
-      return build (COMPOUND_EXPR, lhstype,
-		    TREE_OPERAND (lhs, 0),
-		    build_modify_expr (TREE_OPERAND (lhs, 1),
-				       modifycode, rhs));
-
-      /* Handle (a ? b : c) used as an "lvalue".  */
-    case COND_EXPR:
-      pedantic_lvalue_warning (COND_EXPR);
-      rhs = save_expr (rhs);
-      {
-	/* Produce (a ? (b = rhs) : (c = rhs))
-	   except that the RHS goes through a save-expr
-	   so the code to compute it is only emitted once.  */
-	tree cond
-	  = build_conditional_expr (TREE_OPERAND (lhs, 0),
-				    build_modify_expr (TREE_OPERAND (lhs, 1),
-						       modifycode, rhs),
-				    build_modify_expr (TREE_OPERAND (lhs, 2),
-						       modifycode, rhs));
-	/* Make sure the code to compute the rhs comes out
-	   before the split.  */
-	return build (COMPOUND_EXPR, TREE_TYPE (lhs),
-		      /* Case to void to suppress warning
-			 from warn_if_unused_value.  */
-		      convert (void_type_node, rhs), cond);
-      }
-    }
-
-  /* If a binary op has been requested, combine the old LHS value with the RHS
-     producing the value we should actually store into the LHS.  */
-
-  if (modifycode == INIT_EXPR)
-    ;
-  else if (modifycode == NOP_EXPR)
-    {
-      /* must deal with overloading of `operator=' here.  */
-      if (TREE_CODE (lhstype) == REFERENCE_TYPE)
-	lhstype = TREE_TYPE (lhstype);
-#if 1
-      /* `operator=' is not an inheritable operator.  */
-      if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_ASSIGNMENT (lhstype))
-	{
-	  result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
-				   lhs, rhs, make_node (NOP_EXPR));
-	  if (result == NULL_TREE)
-	    return error_mark_node;
-	  return result;
-	}
-#else
-      /* Treat `operator=' as an inheritable operator.  */
-      if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_GETS_ASSIGNMENT (lhstype))
-	{
-	  tree orig_lhstype = lhstype;
-	  while (! TYPE_HAS_ASSIGNMENT (lhstype))
-	    {
-	      int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (lhstype);
-	      tree basetype = NULL_TREE;
-	      for (i = 0; i < n_baseclasses; i++)
-		if (TYPE_GETS_ASSIGNMENT (TYPE_BINFO_BASETYPE (lhstype, i)))
-		  {
-		    if (basetype != NULL_TREE)
-		      {
-			message_2_types (error, "base classes `%s' and `%s' both have operator ='",
-					 basetype,
-					 TYPE_BINFO_BASETYPE (lhstype, i));
-			return error_mark_node;
-		      }
-		    basetype = TYPE_BINFO_BASETYPE (lhstype, i);
-		  }
-	      lhstype = basetype;
-	    }
-	  if (orig_lhstype != lhstype)
-	    {
-	      lhs = build_indirect_ref (convert_pointer_to (lhstype,
-							    build_unary_op (ADDR_EXPR, lhs, 0)), NULL);
-	      if (lhs == error_mark_node)
-		{
-		  error_with_aggr_type (lhstype, "conversion to private basetype `%s'");
-		  return error_mark_node;
-		}
-	    }
-	  result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL,
-				   lhs, rhs, make_node (NOP_EXPR));
-	  if (result == NULL_TREE)
-	    return error_mark_node;
-	  return result;
-	}
-#endif
-      lhstype = olhstype;
-    }
-  else if (PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE))
-    {
-      /* This case must convert to some sort of lvalue that
-	 can participate in an op= operation.  */
-      tree lhs_tmp = lhs;
-      tree rhs_tmp = rhs;
-      if (build_default_binary_type_conversion (modifycode, &lhs_tmp, &rhs_tmp))
-	{
-	  lhs = stabilize_reference (lhs_tmp);
-	  /* Forget is was ever anything else.  */
-	  olhstype = lhstype = TREE_TYPE (lhs);
-	  newrhs = build_binary_op (modifycode, lhs, rhs_tmp, 1);
-	}
-      else
-	return error_mark_node;
-    }
-  else
-    {
-      lhs = stabilize_reference (lhs);
-      newrhs = build_binary_op (modifycode, lhs, rhs, 1);
-    }
-
-  /* Handle a cast used as an "lvalue".
-     We have already performed any binary operator using the value as cast.
-     Now convert the result to the cast type of the lhs,
-     and then true type of the lhs and store it there;
-     then convert result back to the cast type to be the value
-     of the assignment.  */
-
-  switch (TREE_CODE (lhs))
-    {
-    case NOP_EXPR:
-    case CONVERT_EXPR:
-    case FLOAT_EXPR:
-    case FIX_TRUNC_EXPR:
-    case FIX_FLOOR_EXPR:
-    case FIX_ROUND_EXPR:
-    case FIX_CEIL_EXPR:
-      if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
-	  || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE
-	  || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE
-	  || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE)
-	newrhs = default_conversion (newrhs);
-      {
-	tree inner_lhs = TREE_OPERAND (lhs, 0);
-	tree result;
-	result = build_modify_expr (inner_lhs, NOP_EXPR,
-				    convert (TREE_TYPE (inner_lhs),
-					     convert (lhstype, newrhs)));
-	return convert (TREE_TYPE (lhs), result);
-      }
-    }
-
-  if (TREE_CODE (lhs) == OFFSET_REF)
-    if (TREE_OPERAND (lhs, 0) == NULL_TREE)
-      {
-	/* Static class member?  */
-	tree member = TREE_OPERAND (lhs, 1);
-	if (TREE_CODE (member) == VAR_DECL)
-	  lhs = member;
-	else
-	  {
-	    compiler_error ("invalid static class member");
-	    return error_mark_node;
-	  }
-      }
-    else
-      lhs = resolve_offset_ref (lhs);
-
-  /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
-     Reject anything strange now.  */
-
-  if (!lvalue_or_else (lhs, "assignment"))
-    return error_mark_node;
-
-  GNU_xref_assign (lhs);
-
-  /* Warn about storing in something that is `const'.  */
-  /* For C++, don't warn if this is initialization.  */
-  if (modifycode != INIT_EXPR
-      && (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
-	  || ((TREE_CODE (lhstype) == RECORD_TYPE
-	       || TREE_CODE (lhstype) == UNION_TYPE)
-	      && C_TYPE_FIELDS_READONLY (lhstype))
-	  || (TREE_CODE (lhstype) == REFERENCE_TYPE
-	      && TYPE_READONLY (TREE_TYPE (lhstype)))))
-    readonly_error (lhs, "assignment", 0);
-
-  /* If storing into a structure or union member,
-     it has probably been given type `int'.
-     Compute the type that would go with
-     the actual amount of storage the member occupies.  */
-
-  if (TREE_CODE (lhs) == COMPONENT_REF
-      && (TREE_CODE (lhstype) == INTEGER_TYPE
-	  || TREE_CODE (lhstype) == REAL_TYPE
-	  || TREE_CODE (lhstype) == ENUMERAL_TYPE))
-    lhstype = TREE_TYPE (get_unwidened (lhs, 0));
-
-  /* check to see if there is an assignment to `this' */
-  if (lhs == current_class_decl)
-    {
-      if (flag_this_is_variable > 0
-	  && DECL_NAME (current_function_decl) != NULL_TREE
-	  && current_class_name != DECL_NAME (current_function_decl))
-	warning ("assignment to `this' not in constructor or destructor");
-      current_function_just_assigned_this = 1;
-    }
-
-  /* The TREE_TYPE of RHS may be TYPE_UNKNOWN.  This can happen
-     when the type of RHS is not yet known, i.e. its type
-     is inherited from LHS.  */
-  rhs = require_instantiated_type (lhstype, newrhs, error_mark_node);
-  if (rhs == error_mark_node)
-    return error_mark_node;
-  newrhs = rhs;
-
-  if (modifycode != INIT_EXPR)
-    {
-      /* Make modifycode now either a NOP_EXPR or an INIT_EXPR.  */
-      modifycode = NOP_EXPR;
-      /* Reference-bashing */
-      if (TREE_CODE (lhstype) == REFERENCE_TYPE)
-	{
-	  tree tmp = convert_from_reference (lhs);
-	  lhstype = TREE_TYPE (tmp);
-	  if (TYPE_SIZE (lhstype) == 0)
-	    {
-	      incomplete_type_error (lhs, lhstype);
-	      return error_mark_node;
-	    }
-	  lhs = tmp;
-	  olhstype = lhstype;
-	}
-      if (TREE_CODE (TREE_TYPE (newrhs)) == REFERENCE_TYPE)
-	{
-	  tree tmp = convert_from_reference (newrhs);
-	  if (TYPE_SIZE (TREE_TYPE (tmp)) == 0)
-	    {
-	      incomplete_type_error (newrhs, TREE_TYPE (tmp));
-	      return error_mark_node;
-	    }
-	  newrhs = tmp;
-	}
-    }
-
-  if (TREE_SIDE_EFFECTS (lhs))
-    lhs = stabilize_reference (lhs);
-  if (TREE_SIDE_EFFECTS (newrhs))
-    newrhs = stabilize_reference (newrhs);
-
-  /* C++: The semantics of C++ differ from those of C when an
-     assignment of an aggregate is desired.  Assignment in C++ is
-     now defined as memberwise assignment of non-static members
-     and base class objects.  This rule applies recursively
-     until a member of a built-in type is found.
-
-     Also, we cannot do a bit-wise copy of aggregates which
-     contain virtual function table pointers.  Those
-     pointer values must be preserved through the copy.
-     However, this is handled in expand_expr, and not here.
-     This is because much better code can be generated at
-     that stage than this one.  */
-  if (TREE_CODE (lhstype) == RECORD_TYPE
-      && (TYPE_USES_VIRTUAL_BASECLASSES (lhstype)
-	  || (modifycode != INIT_EXPR && TYPE_GETS_ASSIGNMENT (lhstype))
-	  || (modifycode == INIT_EXPR && TYPE_GETS_INIT_REF (lhstype)))
-      && (TYPE_MAIN_VARIANT (lhstype) == TYPE_MAIN_VARIANT (TREE_TYPE (newrhs))
-	  || (TREE_CODE (TREE_TYPE (newrhs)) == RECORD_TYPE
-	      && UNIQUELY_DERIVED_FROM_P (lhstype, TREE_TYPE (newrhs)))))
-    {
-      tree vbases = CLASSTYPE_VBASECLASSES (lhstype);
-      tree lhs_addr = build_unary_op (ADDR_EXPR, lhs, 0);
-      tree rhs_addr;
-
-      /* Memberwise assignment would cause NEWRHS to be
-	 evaluated for every member that gets assigned.
-	 By wrapping side-effecting exprs in a SAVE_EXPR,
-	 NEWRHS will only be evaluated once.  */
-      if (IS_AGGR_TYPE (TREE_TYPE (newrhs))
-	  && TREE_SIDE_EFFECTS (newrhs)
-	  /* This are things we don't have to save.  */
-	  && TREE_CODE (newrhs) != TARGET_EXPR
-	  && TREE_CODE (newrhs) != WITH_CLEANUP_EXPR)
-	/* Call `break_out_cleanups' on NEWRHS in case there are cleanups.
-	   If NEWRHS is a CALL_EXPR that needs a cleanup, failure to do so
-	   will result in expand_expr expanding the call without knowing
-	   that it should run the cleanup.  */
-	newrhs = save_expr (break_out_cleanups (newrhs));
-
-      rhs_addr = build_unary_op (ADDR_EXPR, newrhs, 0);
-      result = NULL_TREE;
-
-      if (! comptypes (TREE_TYPE (lhs_addr), TREE_TYPE (rhs_addr), 1))
-	rhs_addr = convert_pointer_to (TREE_TYPE (TREE_TYPE (lhs_addr)), rhs_addr);
-      /* Once we have our hands on an address, we must change NEWRHS
-	 to work from there.  Otherwise we can get multiple evaluations
-	 of NEWRHS.  */
-      if (TREE_CODE (newrhs) != SAVE_EXPR)
-	newrhs = build_indirect_ref (rhs_addr, NULL);
-
-      while (vbases)
-	{
-	  tree elt_lhs = convert_pointer_to (vbases, lhs_addr);
-	  tree elt_rhs = convert_pointer_to (vbases, rhs_addr);
-	  result
-	    = tree_cons (NULL_TREE,
-			 build_modify_expr_1 (build_indirect_ref (elt_lhs, NULL),
-					      modifycode,
-					      build_indirect_ref (elt_rhs, NULL),
-					      TYPE_BINFO (lhstype)),
-			 result);
-	  if (TREE_VALUE (result) == error_mark_node)
-	    return error_mark_node;
-	  vbases = TREE_CHAIN (vbases);
-	}
-      result = tree_cons (NULL_TREE,
-			  build_modify_expr_1 (lhs,
-					       modifycode,
-					       newrhs,
-					       TYPE_BINFO (lhstype)),
-			  result);
-      return build_compound_expr (result);
-    }
-
-  /* It is now illegal to assign unions which contain members that
-     have non-default assignment operators.  */
-  if (! flag_traditional && TREE_CODE (lhstype) == UNION_TYPE)
-    {
-      if (modifycode == INIT_EXPR && TYPE_GETS_INIT_REF (lhstype))
-	{
-	  error ("invalid initialization of union containing members with X(X&) constructor");
-	  return error_mark_node;
-	}
-      else if (modifycode == NOP_EXPR && TYPE_GETS_ASSIGNMENT (lhstype))
-	{
-	  error ("invalid assignment of union containing members with non-default operator=");
-	  return error_mark_node;
-	}
-    }
-
-  /* If storing in a field that is in actuality a short or narrower than one,
-     we must store in the field in its actual type.  */
-
-  if (lhstype != TREE_TYPE (lhs))
-    {
-      lhs = copy_node (lhs);
-      TREE_TYPE (lhs) = lhstype;
-    }
-
-  /* Convert new value to destination type.  */
-
-  if (TREE_CODE (lhstype) == ARRAY_TYPE)
-    {
-      /* Have to wrap this in RTL_EXPR for two cases:
-	 in base or member initialization and if we
-	 are a branch of a ?: operator.  Since we
-	 can't easily know the latter, just do it always.  */
-
-      result = make_node (RTL_EXPR);
-
-      TREE_TYPE (result) = void_type_node;
-      do_pending_stack_adjust ();
-      start_sequence ();
-
-      /* As a matter of principle, `start_sequence' should do this.  */
-      emit_note (0, -1);
-
-      expand_vec_init (lhs, lhs, array_type_nelts (lhstype), newrhs,
-		       1 + (modifycode != INIT_EXPR));
-
-      do_pending_stack_adjust ();
-
-      TREE_SIDE_EFFECTS (result) = 1;
-      RTL_EXPR_SEQUENCE (result) = get_insns ();
-      RTL_EXPR_RTL (result) = const0_rtx;
-      end_sequence ();
-      return result;
-    }
-
-  if (modifycode == INIT_EXPR)
-    {
-      newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
-					   "assignment", NULL_TREE, 0);
-      if (lhs == DECL_RESULT (current_function_decl))
-	{
-	  if (DECL_INITIAL (lhs))
-	    warning ("return value from function receives multiple initializations");
-	  DECL_INITIAL (lhs) = newrhs;
-	}
-    }
-  else
-    {
-      if (IS_AGGR_TYPE (lhstype))
-	{
-	  if (TYPE_GETS_ASSIGNMENT (lhstype)
-	      && ! TYPE_HAS_ASSIGNMENT (lhstype))
-	    {
-	      error_with_aggr_type (lhstype, "assignment not defined for type `%s'");
-	      return error_mark_node;
-	    }
-	  if (result = build_opfncall (MODIFY_EXPR,
-				       LOOKUP_NORMAL, lhs, newrhs,
-				       make_node (NOP_EXPR)))
-	    return result;
-	}
-      newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
-				       NULL_TREE, 0);
-      if (flag_elide_constructors == 0
-	  && TREE_CODE (newrhs) == CALL_EXPR
-	  && TREE_ADDRESSABLE (lhstype))
-	{
-	  /* Can't initialized directly from a CALL_EXPR, since
-	     we don't know about what doesn't alias what.  */
-
-	  tree temp = get_temp_name (lhstype, 0);
-	  newrhs = build (COMPOUND_EXPR, lhstype,
-			  build_modify_expr (temp, INIT_EXPR, newrhs),
-			  temp);
-	}
-    }
-
-  if (TREE_CODE (newrhs) == ERROR_MARK)
-    return error_mark_node;
-
-  if (TREE_CODE (newrhs) == COND_EXPR)
-    {
-      tree lhs1;
-      tree cond = TREE_OPERAND (newrhs, 0);
-
-      if (TREE_SIDE_EFFECTS (lhs))
-	cond = build_compound_expr (tree_cons
-				    (NULL_TREE, lhs,
-				     build_tree_list (NULL_TREE, cond)));
-
-      /* Cannot have two identical lhs on this one tree (result) as preexpand
-	 calls will rip them out and fill in RTL for them, but when the
-	 rtl is generated, the calls will only be in the first side of the
-	 condition, not on both, or before the conditional jump! (mrs) */
-      lhs1 = break_out_calls (lhs);
-
-      if (lhs == lhs1)
-	/* If there's no change, the COND_EXPR behaves like any other rhs.  */
-	result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
-			lhstype, lhs, newrhs);
-      else
-	{
-	  tree result_type = TREE_TYPE (newrhs);
-	  /* We have to convert each arm to the proper type because the
-	     types may have been munged by constant folding.  */
-	  result
-	    = build (COND_EXPR, result_type, cond,
-		     build_modify_expr (lhs, modifycode,
-					convert (result_type,
-						 TREE_OPERAND (newrhs, 1))),
-		     build_modify_expr (lhs1, modifycode,
-					convert (result_type,
-						 TREE_OPERAND (newrhs, 2))));
-	}
-    }
-  else if (modifycode != INIT_EXPR && TREE_CODE (newrhs) == WITH_CLEANUP_EXPR)
-    {
-      tree cleanup = TREE_OPERAND (newrhs, 2);
-      tree slot;
-
-      /* Finish up by running cleanups and having the "value" of the lhs.  */
-      tree exprlist = tree_cons (NULL_TREE, cleanup,
-				 build_tree_list (NULL_TREE, lhs));
-      newrhs = TREE_OPERAND (newrhs, 0);
-      if (TREE_CODE (newrhs) == TARGET_EXPR)
-	  slot = TREE_OPERAND (newrhs, 0);
-      else if (TREE_CODE (newrhs) == ADDR_EXPR)
-	{
-	  /* Bad but legal.  */
-	  slot = newrhs;
-	  warning ("address taken of temporary object");
-	}
-      else
-	my_friendly_abort (118);
-
-      /* Copy the value computed in SLOT into LHS.  */
-      exprlist = tree_cons (NULL_TREE,
-			    build_modify_expr (lhs, modifycode, slot),
-			    exprlist);
-      /* Evaluate the expression that needs CLEANUP.  This will
-	 compute the value into SLOT.  */
-      exprlist = tree_cons (NULL_TREE, newrhs, exprlist);
-      result = convert (lhstype, build_compound_expr (exprlist));
-    }
-  else
-    result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
-		    lhstype, lhs, newrhs);
-  TREE_SIDE_EFFECTS (result) = 1;
-
-  /* If we got the LHS in a different type for storing in,
-     convert the result back to the nominal type of LHS
-     so that the value we return always has the same type
-     as the LHS argument.  */
-
-  if (olhstype == TREE_TYPE (result))
-    return result;
-  return convert_for_assignment (olhstype, result, "assignment",
-				 NULL_TREE, 0);
-}
-
-
-/* Return 0 if EXP is not a valid lvalue in this language
-   even though `lvalue_or_else' would accept it.  */
-
-int
-language_lvalue_valid (exp)
-     tree exp;
-{
-  return 1;
-}
-
-/* Convert value RHS to type TYPE as preparation for an assignment
-   to an lvalue of type TYPE.
-   The real work of conversion is done by `convert'.
-   The purpose of this function is to generate error messages
-   for assignments that are not allowed in C.
-   ERRTYPE is a string to use in error messages:
-   "assignment", "return", etc.
-
-   C++: attempts to allow `convert' to find conversions involving
-   implicit type conversion between aggregate and scalar types
-   as per 8.5.6 of C++ manual.  Does not randomly dereference
-   pointers to aggregates!  */
-
-static tree
-convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
-     tree type, rhs;
-     char *errtype;
-     tree fndecl;
-     int parmnum;
-{
-  register enum tree_code codel = TREE_CODE (type);
-  register tree rhstype;
-  register enum tree_code coder = TREE_CODE (TREE_TYPE (rhs));
-
-  if (coder == UNKNOWN_TYPE)
-    rhs = instantiate_type (type, rhs, 1);
-
-  if (coder == ERROR_MARK)
-    return error_mark_node;
-
-  if (codel == OFFSET_TYPE)
-    {
-      type = TREE_TYPE (type);
-      codel = TREE_CODE (type);
-    }
-
-  /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
-  if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
-    rhs = TREE_OPERAND (rhs, 0);
-
-  if (rhs == error_mark_node)
-    return error_mark_node;
-
-  if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
-    {
-      rhs = resolve_offset_ref (rhs);
-      if (rhs == error_mark_node)
-	return error_mark_node;
-      rhstype = TREE_TYPE (rhs);
-      coder = TREE_CODE (rhstype);
-    }
-
-  if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
-      || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
-      || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
-    rhs = default_conversion (rhs);
-  else if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
-    rhs = convert_from_reference (rhs);
-
-  rhstype = TREE_TYPE (rhs);
-  coder = TREE_CODE (rhstype);
-
-  /* This should no longer change types on us.  */
-  if (TREE_CODE (rhs) == CONST_DECL)
-    rhs = DECL_INITIAL (rhs);
-  else if (TREE_READONLY_DECL_P (rhs))
-    rhs = decl_constant_value (rhs);
-
-  if (type == rhstype)
-    return rhs;
-
-  if (coder == VOID_TYPE)
-    {
-      error ("void value not ignored as it ought to be");
-      return error_mark_node;
-    }
-  /* Arithmetic types all interconvert.  */
-  if ((codel == INTEGER_TYPE || codel == REAL_TYPE)
-       && (coder == INTEGER_TYPE || coder == REAL_TYPE))
-    {
-      /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE.  */
-      if (coder == REAL_TYPE && codel == INTEGER_TYPE)
-	warn_for_assignment ("float or double assigned to integer data type",
-			     "float or double used for argument %d of `%s'",
-			     errtype, fndecl, parmnum, 0);
-      /* And we should warn if assigning a negative value to
-	 an unsigned variable.  */
-      else if (TREE_UNSIGNED (type))
-	{
-	  if (TREE_CODE (rhs) == INTEGER_CST
-	      && TREE_NEGATED_INT (rhs))
-	    warn_for_assignment ("negative value assigned to unsigned quantity",
-				 "negative value passed as argument %d of `%s'",
-				 errtype, fndecl, parmnum, 0);
-	  if (TREE_CONSTANT (rhs))
-	    rhs = fold (rhs);
-	}
-
-      return convert (type, rhs);
-    }
-  /* Conversions involving enums.  */
-  else if ((codel == ENUMERAL_TYPE
-	    && (coder == ENUMERAL_TYPE || coder == INTEGER_TYPE || coder == REAL_TYPE))
-	   || (coder == ENUMERAL_TYPE
-	       && (codel == ENUMERAL_TYPE || codel == INTEGER_TYPE || codel == REAL_TYPE)))
-    {
-      extern int warn_enum_clash;
-
-      if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
-	return convert (type, rhs);
-      if (warn_enum_clash)
-	{
-	  if (codel == ENUMERAL_TYPE && coder == ENUMERAL_TYPE)
-	    message_2_types (warning, "conversion between incompatible enumeral types `%s' and `%s'",
-			     type, rhstype);
-	  else if (coder == REAL_TYPE)
-	    warn_for_assignment ("float or double assigned to enumeral data type",
-				 "float or double passed as enumeral data type for argument %d of `%s'",
-				 errtype, fndecl, parmnum, pedantic);
-	  else if (codel == REAL_TYPE)
-	    warn_for_assignment ("enumeral value assigned to real data type",
-				 "enumeral value passed as real data type for argument %d of `%s'",
-				 errtype, fndecl, parmnum, pedantic);
-	  else if (coder == INTEGER_TYPE)
-	    warn_for_assignment ("assignment of integer to enumeral data type",
-				 "passing integer as enumeral data type for argument %d of `%s'",
-				 errtype, fndecl, parmnum, pedantic);
-	}
-      return convert (type, rhs);
-    }
-  /* Conversions among pointers */
-  else if (codel == POINTER_TYPE && coder == POINTER_TYPE)
-    {
-      register tree ttl = TREE_TYPE (type);
-      register tree ttr = TREE_TYPE (rhstype);
-
-      /* If both pointers are of aggregate type, then we
-	 can give better error messages, and save some work
-	 as well.  */
-      if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
-	{
-	  tree binfo;
-
-	  if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr)
-	      || type == class_star_type_node
-	      || rhstype == class_star_type_node)
-	    binfo = TYPE_BINFO (ttl);
-	  else
-	    binfo = get_binfo (ttl, ttr, 1);
-
-	  if (binfo == error_mark_node)
-	    return error_mark_node;
-	  if (binfo == 0)
-	    return (tree) error_not_base_type (ttl, ttr);
-
-	  if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
-	    warn_for_assignment ("%s of non-`const *' pointer from `const *'",
-				 "pointer to const given for argument %d of `%s'",
-				 errtype, fndecl, parmnum, 0);
-	  if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
-	    warn_for_assignment ("%s of non-`volatile *' pointer from `volatile *'",
-				 "pointer to volatile given for argument %d of `%s'",
-				 errtype, fndecl, parmnum, 0);
-	}
-
-      /* Any non-function converts to a [const][volatile] void *
-	 and vice versa; otherwise, targets must be the same.
-	 Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
-      else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
-	       || TYPE_MAIN_VARIANT (ttr) == void_type_node
-	       || comp_target_types (type, rhstype, 1))
-	{
-	  if (TYPE_MAIN_VARIANT (ttl) != void_type_node
-	      && TYPE_MAIN_VARIANT (ttr) == void_type_node
-	      && rhs != null_pointer_node)
-	    pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s",
-		     errtype);
-	  else if (pedantic
-	      && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
-		   && (TREE_CODE (ttr) == FUNCTION_TYPE
-		       || TREE_CODE (ttr) == METHOD_TYPE))
-		  ||
-		  (TYPE_MAIN_VARIANT (ttr) == void_type_node
-		   && (TREE_CODE (ttl) == FUNCTION_TYPE
-		       || TREE_CODE (ttl) == METHOD_TYPE))))
-	    warn_for_assignment ("%s between function pointer and `void *'",
-				 "function pointer and `void *' incompatible; argument %d of `%s'",
-				 errtype, fndecl, parmnum, flag_pedantic_errors);
-	  /* Const and volatile mean something different for function types,
-	     so the usual warnings are not appropriate.  */
-	  else if ((TREE_CODE (ttr) != FUNCTION_TYPE && TREE_CODE (ttr) != METHOD_TYPE)
-		   || (TREE_CODE (ttl) != FUNCTION_TYPE && TREE_CODE (ttl) != METHOD_TYPE))
-	    {
-	      if (TREE_CODE (ttl) == OFFSET_TYPE
-		  && binfo_member (TYPE_OFFSET_BASETYPE (ttr),
-				   CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl))))
-		{
-		  sorry ("%s between pointer to members converting across virtual baseclasses", errtype);
-		  return error_mark_node;
-		}
-	      if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
-		warn_for_assignment ("%s of non-`const *' pointer from `const *'",
-				     "pointer to const given for argument %d of `%s'",
-				     errtype, fndecl, parmnum, flag_pedantic_errors);
-	      if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
-		warn_for_assignment ("%s of non-`volatile *' pointer from `volatile *'",
-				     "pointer to volatile given for argument %d of `%s'",
-				     errtype, fndecl, parmnum, flag_pedantic_errors);
-	    }
-	}
-      else if (TREE_CODE (ttr) == OFFSET_TYPE
-	       && TREE_CODE (ttl) != OFFSET_TYPE)
-	{
-	  /* Normally, pointers to different type codes (other
-	     than void) are not compatible, but we perform
-	     some type instantiation if that resolves the
-	     ambiguity of (X Y::*) and (X *).  */
-
-	  if (current_class_decl)
-	    {
-	      if (TREE_CODE (rhs) == INTEGER_CST)
-		{
-		  rhs = build (PLUS_EXPR, build_pointer_type (TREE_TYPE (ttr)),
-			       current_class_decl, rhs);
-		  return convert_for_assignment (type, rhs,
-						 errtype, fndecl, parmnum);
-		}
-	    }
-	  if (TREE_CODE (ttl) == METHOD_TYPE)
-	    error ("%s between pointer-to-method and pointer-to-member types",
-		   errtype);
-	  else
-	    error ("%s between pointer and pointer-to-member types", errtype);
-	  return error_mark_node;
-	}
-      else
-	{
-	  int const_parity = TYPE_READONLY (type) ^ TYPE_READONLY (rhstype);
-	  int volatile_parity = TYPE_VOLATILE (type) ^ TYPE_VOLATILE (rhstype);
-	  int unsigned_parity;
-	  int nptrs = 0;
-
-	  while (TREE_CODE (ttl) == POINTER_TYPE
-		 && TREE_CODE (ttr) == POINTER_TYPE)
-	    {
-	      nptrs -= 1;
-	      const_parity |= TYPE_READONLY (ttl) ^ TYPE_READONLY (ttr);
-	      volatile_parity |= TYPE_VOLATILE (ttl) ^ TYPE_VOLATILE (ttr);
-	      ttl = TREE_TYPE (ttl);
-	      ttr = TREE_TYPE (ttr);
-	    }
-	  unsigned_parity = TREE_UNSIGNED (ttl) - TREE_UNSIGNED (ttr);
-	  if (unsigned_parity)
-	    if (TREE_UNSIGNED (ttl))
-	      ttr = unsigned_type (ttr);
-	    else
-	      ttl = unsigned_type (ttl);
-
-	  if (comp_target_types (ttl, ttr, nptrs))
-	    {
-	      if (const_parity)
-		warn_for_assignment ("%s of non-`const *' pointer from `const *'",
-				     "pointer to const given for argument %d of `%s'",
-				     errtype, fndecl, parmnum, 0);
-	      if (volatile_parity)
-		warn_for_assignment ("%s of non-`volatile *' pointer from volatile *",
-				     "pointer to volatile given for argument %d of `%s'",
-				     errtype, fndecl, parmnum, 0);
-	      if (unsigned_parity > 0)
-		warn_for_assignment ("%s of unsigned pointer from signed pointer",
-				     "passing signed pointer to unsigned pointer argument %d of `%s'",
-				     errtype, fndecl, parmnum, flag_pedantic_errors);
-	      else if (unsigned_parity < 0)
-		warn_for_assignment ("%s of signed pointer from unsigned pointer",
-				     "passing unsigned pointer to signed pointer argument %d of `%s'",
-				     errtype, fndecl, parmnum, flag_pedantic_errors);
-
-	      /* C++ is not so friendly about converting function and
-		 member function pointers as C.  Emit warnings here.  */
-	      if (TREE_CODE (ttl) == FUNCTION_TYPE
-		  || TREE_CODE (ttl) == METHOD_TYPE)
-		if (! comptypes (ttl, ttr, 0))
-		  {
-		    char *tmpbuf, *lhsbuf;
-		    char *rhsbuf;
-		    tree null_name = get_identifier ("");
-		    tree lhs = build_decl (FUNCTION_DECL, null_name, ttl);
-		    tree rhs = build_decl (FUNCTION_DECL, null_name, ttr);
-		    tmpbuf = fndecl_as_string (0, lhs, 1);
-		    lhsbuf = (char *) alloca (strlen (tmpbuf));
-		    strcpy (lhsbuf, tmpbuf);
-		    rhsbuf = fndecl_as_string (0, rhs, 1);
-		    warning ("conflicting function types in %s:", errtype);
-		    warning ("\t`%s' != `%s'", lhsbuf, rhsbuf);
-		  }
-	    }
-	  else if (TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
-	    {
-	      /* When does this happen?  */
-	      my_friendly_abort (119);
-	      /* Conversion of a pointer-to-member type to void *.  */
-	      rhs = build_unary_op (ADDR_EXPR, rhs, 0);
-	      TREE_TYPE (rhs) = type;
-	      return rhs;
-	    }
-	  else if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
-	    {
-	      /* When does this happen?  */
-	      my_friendly_abort (120);
-	      /* Conversion of a pointer-to-member type to void *.  */
-	      rhs = build_unary_op (ADDR_EXPR, rhs, 0);
-	      TREE_TYPE (rhs) = type;
-	      return rhs;
-	    }
-	  else
-	    {
-	      if (fndecl)
-		error ("incompatible pointer types for argument %d of `%s'",
-		       parmnum + 1, lang_printable_name (fndecl));
-	      else
-		error ("%s between incompatible pointer types", errtype);
-	      return error_mark_node;
-	    }
-	}
-      return convert (type, rhs);
-    }
-  else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
-    {
-      if (! integer_zerop (rhs))
-	{
-	  warn_for_assignment ("%s of pointer from integer lacks a cast",
-			       "passing integer to pointer argument %d of `%s' lacks a cast",
-			       errtype, fndecl, parmnum, flag_pedantic_errors);
-	  return convert (type, rhs);
-	}
-      return null_pointer_node;
-    }
-  else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
-    {
-      warn_for_assignment ("%s of integer from pointer lacks a cast",
-			   "passing pointer to integer argument %d of `%s' lacks a cast",
-			   errtype, fndecl, parmnum, flag_pedantic_errors);
-      return convert (type, rhs);
-    }
-
-  /* C++ */
-  else if (codel == ERROR_MARK || coder == ERROR_MARK)
-    return error_mark_node;
-
-  /* This should no longer happen.  References are initialized via
-     `convert_for_initialization'.  They should otherwise be
-     bashed before coming here.  */
-  else if (codel == REFERENCE_TYPE)
-    /* Force an abort.  */
-    my_friendly_assert (codel != REFERENCE_TYPE, 317);
-  else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))
-    return build1 (NOP_EXPR, type, rhs);
-  else if (TYPE_HAS_CONSTRUCTOR (type) || IS_AGGR_TYPE (TREE_TYPE (rhs)))
-    return convert (type, rhs);
-
-  error ("incompatible types in %s", errtype);
-  return error_mark_node;
-}
-
-/* Print a warning using either ANON_MSG or NAMED_MSG.
-   ANON_MSG is used if DECL and FUNCTION are 0; it gets one parameter, OPNAME.
-   NAMED_MSG is used if DECL is non-0;
-   it gets two parameters, the name of DECL and that of FUNCTION.
-   FUNCTION_MSG is used if DECL is 0 and FUNCTION is non-0;
-   it gets one parameter, the name FUNCTION.
-
-   If SEVERE is non-0, the report an error instead of a warning.
-
-   If FNDECL is nonzero, the message concerns an argument in a call
-   to that function.  ARGNUM is the number of the argument, origin 0.  */
-
-void
-warn_for_assignment (anon_msg, arg_msg, opname, fndecl, argnum, severe)
-     char *anon_msg;
-     char *arg_msg;
-     char *opname;
-     tree fndecl;
-     int argnum;
-     int severe;
-{
-  if (fndecl)
-    {
-      if (argnum < 0)
-	{
-	  char *buf = (char *)alloca (strlen (arg_msg) + 1);
-	  char *p;
-	  strcpy (buf, arg_msg);
-	  for (p = buf; *p; p++)
-	    if (p[0] == '%' && p[1] == 'd')
-	      {
-		p[1] = 's';
-		if (severe)
-		  error (buf, "`this'", lang_printable_name (fndecl));
-		else
-		  warning (buf, "`this'", lang_printable_name (fndecl));
-		break;
-	      }
-	}
-      else if (severe)
-	error (arg_msg, argnum + 1, lang_printable_name (fndecl));
-      else
-	warning (arg_msg, argnum + 1, lang_printable_name (fndecl));
-    }
-  else if (severe)
-    error (anon_msg, opname);
-  else
-    warning (anon_msg, opname);
-}
-
-/* Convert RHS to be of type TYPE.  If EXP is non-zero,
-   it is the target of the initialization.
-   ERRTYPE is a string to use in error messages.
-
-   Two major differences between the behavior of
-   `convert_for_assignment' and `convert_for_initialization'
-   are that references are bashed in the former, while
-   copied in the latter, and aggregates are assigned in
-   the former (operator=) while initialized in the
-   latter (X(X&)).
-
-   If using constructor make sure no conversion operator exists, if one does
-   exist, an ambiguity exists.  */
-tree
-convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum)
-     tree exp, type, rhs;
-     int flags;
-     char *errtype;
-     tree fndecl;
-     int parmnum;
-{
-  register enum tree_code codel = TREE_CODE (type);
-  register tree rhstype;
-  register enum tree_code coder;
-
-  /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
-     Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
-  if (TREE_CODE (rhs) == NOP_EXPR
-      && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0)))
-    rhs = TREE_OPERAND (rhs, 0);
-
-  if (rhs == error_mark_node
-      || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
-    return error_mark_node;
-
-  if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE)
-    {
-      rhs = resolve_offset_ref (rhs);
-      if (rhs == error_mark_node)
-	return error_mark_node;
-      rhstype = TREE_TYPE (rhs);
-      coder = TREE_CODE (rhstype);
-    }
-
-  if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
-       && TREE_CODE (type) != ARRAY_TYPE && TREE_CODE (type) != REFERENCE_TYPE)
-      || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
-      || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
-    rhs = default_conversion (rhs);
-
-  rhstype = TREE_TYPE (rhs);
-  coder = TREE_CODE (rhstype);
-
-  if (coder == UNKNOWN_TYPE)
-    {
-      rhs = instantiate_type (type, rhs, 1);
-      rhstype = TREE_TYPE (rhs);
-      coder = TREE_CODE (rhstype);
-    }
-
-  if (coder == ERROR_MARK)
-    return error_mark_node;
-
-#if 0
-  /* This is *not* the quick way out!  It is the way to disaster.  */
-  if (type == rhstype)
-    goto converted;
-#endif
-
-  /* We accept references to incomplete types, so we can
-     return here before checking if RHS is of complete type.  */
-     
-  if (codel == REFERENCE_TYPE)
-    return convert_to_reference ((exp ? exp : error_mark_node),
-		 		 type, rhs, fndecl, parmnum, errtype,
-				 0, flags);
-
-  rhs = require_complete_type (rhs);
-  if (rhs == error_mark_node)
-    return error_mark_node;
-
-  if (exp != 0) exp = require_complete_type (exp);
-  if (exp == error_mark_node)
-    return error_mark_node;
-
-  if (TREE_CODE (rhstype) == REFERENCE_TYPE)
-    rhstype = TREE_TYPE (rhstype);
-
-  if (IS_AGGR_TYPE (type) && TYPE_NEEDS_CONSTRUCTOR (type))
-    {
-      if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
-	{
-	  /* This is sufficient to perform initialization.  No need, apparently,
-	     to go through X(X&) to do first-cut initialization.  Return through
-	     a TARGET_EXPR so that we get cleanups if it is used.  */
-	  if (TREE_CODE (rhs) == CALL_EXPR)
-	    {
-	      rhs = build_cplus_new (type, rhs, 0);
-	      return rhs;
-	    }
-	  /* Handle the case of default parameter initialization and
-	     initialization of static variables.  */
-	  else if (TREE_CODE (rhs) == INDIRECT_REF && TREE_HAS_CONSTRUCTOR (rhs))
-	    {
-	      my_friendly_assert (TREE_CODE (TREE_OPERAND (rhs, 0)) == CALL_EXPR, 318);
-	      if (exp)
-		{
-		  my_friendly_assert (TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 1)) == NULL_TREE, 316);
-		  TREE_VALUE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 1))
-		    = build_unary_op (ADDR_EXPR, exp, 0);
-		}
-	      else
-		rhs = build_cplus_new (type, TREE_OPERAND (rhs, 0), 0);
-	      return rhs;
-	    }
-	}
-      if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)
-	  || (IS_AGGR_TYPE (rhstype) && UNIQUELY_DERIVED_FROM_P (type, rhstype)))
-	{
-	  if (TYPE_HAS_INIT_REF (type))
-	    {
-	      /* We have to check for template classes here, or else
-		 build_method_call won't be able to see the constructor.  */
-	      tree id = TYPE_IDENTIFIER (type);
-	      tree name
-		= IDENTIFIER_TEMPLATE (id) ? id : constructor_name (type);
-	      tree init = build_method_call (exp, name,
-					     build_tree_list (NULL_TREE, rhs),
-					     NULL_TREE, LOOKUP_NORMAL);
-
-	      if (init == error_mark_node)
-		return error_mark_node;
-
-	      if (exp == 0)
-		{
-		  exp = build_cplus_new (type, init, 0);
-		  return exp;
-		}
-
-	      return build (COMPOUND_EXPR, type, init, exp);
-	    }
-
-#if 0
-	  /* ??? The following warnings are turned off because
-	     this is another place where the default X(X&) constructor
-	     is implemented.  */
-	  if (TYPE_HAS_ASSIGNMENT (type))
-	    warning ("bitwise copy: `%s' defines operator=()",
-		     TYPE_NAME_STRING (type));
-	  else if (TYPE_GETS_ASSIGNMENT (type))
-	    warning ("bitwise copy: `%s' has a member with operator=()",
-		     TYPE_NAME_STRING (type));
-#endif
-
-	  if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
-	    rhs = convert_from_reference (rhs);
-	  if (type != rhstype)
-	    return build1 (NOP_EXPR, type, rhs);
-	  return rhs;
-	}
-
-      return convert (type, rhs);
-    }
-#if 0
-  /* ??? The following warnings are turned off because
-     this is another place where the default X(X&) constructor
-     is implemented.  */
-  if (TYPE_LANG_SPECIFIC (type))
-    {
-      if (TYPE_HAS_ASSIGNMENT (type))
-	warning ("bitwise copy: `%s' defines operator=()",
-		 TYPE_NAME_STRING (type));
-      else if (TYPE_GETS_ASSIGNMENT (type))
-	warning ("bitwise copy: `%s' has a member with operator=()",
-		 TYPE_NAME_STRING (type));
-    }
-#endif
-
-  if (type == TREE_TYPE (rhs))
-    {
-      if (TREE_READONLY_DECL_P (rhs))
-	rhs = decl_constant_value (rhs);
-      return rhs;
-    }
-
-  return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
-}
-
-/* Expand an ASM statement with operands, handling output operands
-   that are not variables or INDIRECT_REFS by transforming such
-   cases into cases that expand_asm_operands can handle.
-
-   Arguments are same as for expand_asm_operands.
-
-   We don't do default conversions on all inputs, because it can screw
-   up operands that are expected to be in memory.  */
-
-void
-c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
-     tree string, outputs, inputs, clobbers;
-     int vol;
-     char *filename;
-     int line;
-{
-  int noutputs = list_length (outputs);
-  register int i;
-  /* o[I] is the place that output number I should be written.  */
-  register tree *o = (tree *) alloca (noutputs * sizeof (tree));
-  register tree tail;
-
-  /* Record the contents of OUTPUTS before it is modified.  */
-  for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
-    o[i] = TREE_VALUE (tail);
-
-  /* Generate the ASM_OPERANDS insn;
-     store into the TREE_VALUEs of OUTPUTS some trees for
-     where the values were actually stored.  */
-  expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
-
-  /* Copy all the intermediate outputs into the specified outputs.  */
-  for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
-    {
-      if (o[i] != TREE_VALUE (tail))
-	{
-	  expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
-		       const0_rtx, VOIDmode, 0);
-	  free_temp_slots ();
-	}
-      /* Detect modification of read-only values.
-	 (Otherwise done by build_modify_expr.)  */
-      else
-	{
-	  tree type = TREE_TYPE (o[i]);
-	  if (TYPE_READONLY (type)
-	      || ((TREE_CODE (type) == RECORD_TYPE
-		   || TREE_CODE (type) == UNION_TYPE)
-		  && C_TYPE_FIELDS_READONLY (type)))
-	    readonly_error (o[i], "modification by `asm'", 1);
-	}
-    }
-
-  /* Those MODIFY_EXPRs could do autoincrements.  */
-  emit_queue ();
-}
-
-/* Expand a C `return' statement.
-   RETVAL is the expression for what to return,
-   or a null pointer for `return;' with no value.
-
-   C++: upon seeing a `return', we must call destructors on all
-   variables in scope which had constructors called on them.
-   This means that if in a destructor, the base class destructors
-   must be called before returning.
-
-   The RETURN statement in C++ has initialization semantics.  */
-
-void
-c_expand_return (retval)
-     tree retval;
-{
-  extern struct nesting *cond_stack, *loop_stack, *case_stack;
-  extern tree dtor_label, ctor_label;
-  tree result = DECL_RESULT (current_function_decl);
-  tree valtype = TREE_TYPE (result);
-  register int use_temp = 0;
-
-  if (TREE_THIS_VOLATILE (current_function_decl))
-    warning ("function declared `volatile' has a `return' statement");
-
-  if (retval == error_mark_node)
-    {
-      current_function_returns_null = 1;
-      return;
-    }
-
-  if (retval == NULL_TREE)
-    {
-      /* A non-named return value does not count.  */
-
-      /* Can't just return from a destructor.  */
-      if (dtor_label)
-	{
-	  expand_goto (dtor_label);
-	  return;
-	}
-
-      if (DECL_CONSTRUCTOR_P (current_function_decl))
-	retval = current_class_decl;
-      else if (DECL_NAME (result) != 0 && TREE_CODE (valtype) != VOID_TYPE)
-	retval = result;
-      else
-	{
-	  current_function_returns_null = 1;
-	  if (valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
-	    {
-	      if (DECL_NAME (DECL_RESULT (current_function_decl)) == 0)
-		warning ("`return' with no value, in function returning non-void");
-	    }
-
-	  expand_null_return ();
-	  return;
-	}
-    }
-  else if (DECL_CONSTRUCTOR_P (current_function_decl)
-	   && retval != current_class_decl)
-    {
-      error ("return from a constructor: use `this = ...' instead");
-      retval = current_class_decl;
-    }
-
-  if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
-    {
-      current_function_returns_null = 1;
-      if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
-	pedwarn ("ANSI C++ forbids `return' with a value, in function returning void");
-      expand_return (retval);
-    }
-  /* Add some useful error checking for C++.  */
-  else if (TREE_CODE (valtype) == REFERENCE_TYPE)
-    {
-      tree whats_returned;
-      tree tmp_result = result;
-
-      /* Don't initialize directly into a non-BLKmode retval, since that
-	 could lose when being inlined by another caller.  (GCC can't
-	 read the function return register in an inline function when
-	 the return value is being ignored).  */
-      if (result && TYPE_MODE (TREE_TYPE (tmp_result)) != BLKmode)
-	tmp_result = 0;
-
-      /* convert to reference now, so we can give error if we
-	 return an reference to a non-lvalue.  */
-      retval = convert_for_initialization (tmp_result, valtype, retval,
-					   LOOKUP_NORMAL, "return",
-					   NULL_TREE, 0);
-
-      /* Sort through common things to see what it is
-	 we are returning.  */
-      whats_returned = retval;
-      if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
-	{
-	  whats_returned = TREE_OPERAND (whats_returned, 1);
-	  if (TREE_CODE (whats_returned) == ADDR_EXPR)
-	    whats_returned = TREE_OPERAND (whats_returned, 0);
-	}
-      if (TREE_CODE (whats_returned) == ADDR_EXPR)
-	{
-	  whats_returned = TREE_OPERAND (whats_returned, 0);
-	  while (TREE_CODE (whats_returned) == NEW_EXPR
-		 || TREE_CODE (whats_returned) == TARGET_EXPR
-		 || TREE_CODE (whats_returned) == WITH_CLEANUP_EXPR)
-	    /* Get the target.  */
-	    whats_returned = TREE_OPERAND (whats_returned, 0);
-	}
-
-      if (TREE_CODE (whats_returned) == VAR_DECL && DECL_NAME (whats_returned))
-	{
-	  if (TEMP_NAME_P (DECL_NAME (whats_returned)))
-	    warning ("reference to non-lvalue returned");
-	  else if (! TREE_STATIC (whats_returned)
-		   && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned)))
-	    warning_with_decl (whats_returned,
-			       "reference to local variable `%s' returned");
-	}
-    }
-  else if (TREE_CODE (retval) == ADDR_EXPR)
-    {
-      tree whats_returned = TREE_OPERAND (retval, 0);
-
-      if (TREE_CODE (whats_returned) == TREE_LIST)
-	whats_returned = TREE_VALUE (whats_returned);
-
-      if (DECL_NAME (whats_returned)
-	  && IDENTIFIER_LOCAL_VALUE (DECL_NAME (whats_returned))
-	  && !TREE_STATIC (whats_returned))
-	warning_with_decl (whats_returned,
-			   "address of local variable `%s' returned");
-    }
-  
-  /* Now deal with possible C++ hair:
-     (1) Compute the return value.
-     (2) If there are aggregate values with destructors which
-     must be cleaned up, clean them (taking care
-     not to clobber the return value).
-     (3) If an X(X&) constructor is defined, the return
-     value must be returned via that.  */
-
-  if (retval == result
-      /* Watch out for constructors, which "return" aggregates
-	 via initialization, but which otherwise "return" a pointer.  */
-      || DECL_CONSTRUCTOR_P (current_function_decl))
-    {
-      /* This is just an error--it's already been reported.  */
-      if (TYPE_SIZE (valtype) == NULL_TREE)
-	return;
-
-      if (TYPE_MODE (valtype) != BLKmode
-	  && any_pending_cleanups (1))
-	{
-	  retval = get_temp_regvar (valtype, retval);
-	  use_temp = obey_regdecls;
-	}
-    }
-  else if (IS_AGGR_TYPE (valtype) && TYPE_NEEDS_CONSTRUCTOR (valtype))
-    {
-      /* Throw away the cleanup that `build_functional_cast' gave us.  */
-      if (TREE_CODE (retval) == WITH_CLEANUP_EXPR
-	  && TREE_CODE (TREE_OPERAND (retval, 0)) == TARGET_EXPR)
-	retval = TREE_OPERAND (retval, 0);
-      expand_aggr_init (result, retval, 0);
-      DECL_INITIAL (result) = NULL_TREE;
-      retval = 0;
-    }
-  else
-    {
-      if (TYPE_MODE (valtype) == VOIDmode)
-	{
-	  if (TYPE_MODE (TREE_TYPE (result)) != VOIDmode
-	      && warn_return_type)
-	    warning ("return of void value in function returning non-void");
-	  expand_expr_stmt (retval);
-	  retval = 0;
-	  result = 0;
-	}
-      else if (TYPE_MODE (valtype) != BLKmode
-	       && any_pending_cleanups (1))
-	{
-	  retval = get_temp_regvar (valtype, retval);
-	  use_temp = obey_regdecls;
-	  result = 0;
-	}
-      else
-	{
-	  retval = convert_for_initialization (result, valtype, retval,
-					       LOOKUP_NORMAL,
-					       "return", NULL_TREE, 0);
-	  DECL_INITIAL (result) = NULL_TREE;
-	}
-      if (retval == error_mark_node)
-	return;
-    }
-
-  emit_queue ();
-
-  if (retval != NULL_TREE
-      && TREE_CODE_CLASS (TREE_CODE (retval)) == 'd'
-      && cond_stack == 0 && loop_stack == 0 && case_stack == 0)
-    current_function_return_value = retval;
-
-  if (result)
-    {
-      /* Everything's great--RETVAL is in RESULT.  */
-      if (original_result_rtx)
-	store_expr (result, original_result_rtx, 0);
-      else if (retval && retval != result)
-	{
-	  /* Clear this out so the later call to decl_function_context
-	     won't end up bombing on us.  */
-	  if (DECL_CONTEXT (result) == error_mark_node)
-	    DECL_CONTEXT (result) = NULL_TREE;
-	  /* Here is where we finally get RETVAL into RESULT.
-	     `expand_return' does the magic of protecting
-	     RESULT from cleanups.  */
-	  retval = build (INIT_EXPR, TREE_TYPE (result), result, retval);
-	  TREE_SIDE_EFFECTS (retval) = 1;
-	  expand_return (retval);
-	}
-      else
-	expand_return (result);
-
-      use_variable (DECL_RTL (result));
-      if (ctor_label  && TREE_CODE (ctor_label) != ERROR_MARK)
-	expand_goto (ctor_label);
-      else
-	expand_null_return ();
-    }
-  else
-    {
-      /* We may still need to put RETVAL into RESULT.  */
-      result = DECL_RESULT (current_function_decl);
-      if (original_result_rtx)
-	{
-	  /* Here we have a named return value that went
-	     into memory.  We can compute RETVAL into that.  */
-	  if (retval)
-	    expand_assignment (result, retval, 0, 0);
-	  else
-	    store_expr (result, original_result_rtx, 0);
-	  result = make_tree (TREE_TYPE (result), original_result_rtx);
-	}
-      else if (ctor_label && TREE_CODE (ctor_label) != ERROR_MARK)
-	{
-	  /* Here RETVAL is CURRENT_CLASS_DECL, so there's nothing to do.  */
-	  expand_goto (ctor_label);
-	}
-      else if (retval)
-	{
-	  /* Here is where we finally get RETVAL into RESULT.
-	     `expand_return' does the magic of protecting
-	     RESULT from cleanups.  */
-	  result = build (INIT_EXPR, TREE_TYPE (result), result, retval);
-	  TREE_SIDE_EFFECTS (result) = 1;
-	  expand_return (result);
-	}
-      else if (TYPE_MODE (TREE_TYPE (result)) != VOIDmode)
-	expand_return (result);
-    }
-
-  current_function_returns_value = 1;
-  if (original_result_rtx)
-    use_variable (original_result_rtx);
-  if (use_temp)
-    use_variable (DECL_RTL (DECL_RESULT (current_function_decl)));
-
-  /* One way to clear out cleanups that EXPR might
-     generate.  Note that this code will really be
-     dead code, but that is ok--cleanups that were
-     needed were handled by the magic of `return'.  */
-  expand_cleanups_to (NULL_TREE);
-}
-
-/* Start a C switch statement, testing expression EXP.
-   Return EXP if it is valid, an error node otherwise.  */
-
-tree
-c_expand_start_case (exp)
-     tree exp;
-{
-  tree type = TREE_TYPE (exp);
-  register enum tree_code code = TREE_CODE (type);
-
-  if (IS_AGGR_TYPE_CODE (code))
-    exp = build_type_conversion (CONVERT_EXPR, integer_type_node, exp, 1);
-  else
-    exp = default_conversion (exp);
-  if (exp == NULL_TREE)
-    {
-      error ("switch quantity not an integer");
-      exp = error_mark_node;
-    }
-  type = TREE_TYPE (exp);
-  code = TREE_CODE (type);
-
-  if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
-    {
-      error ("switch quantity not an integer");
-      exp = error_mark_node;
-    }
-  else
-    {
-      tree index;
-
-      exp = default_conversion (exp);
-      type = TREE_TYPE (exp);
-      index = get_unwidened (exp, 0);
-      /* We can't strip a conversion from a signed type to an unsigned,
-	 because if we did, int_fits_type_p would do the wrong thing
-	 when checking case values for being in range,
-	 and it's too hard to do the right thing.  */
-      if (TREE_UNSIGNED (TREE_TYPE (exp))
-	  == TREE_UNSIGNED (TREE_TYPE (index)))
-	exp = index;
-    }
-
-  expand_start_case (1, exp, type, "switch statement");
-
-  return exp;
-}
-
-/* C++ does not yet support type checking of format strings.  */
-
-void
-record_format_info (function_ident, is_scan, format_num, first_arg_num)
-      tree function_ident;
-      int is_scan;
-      int format_num;
-      int first_arg_num;
-{}
diff --git a/gnu/gcc2/cc1plus/cp-xref.c b/gnu/gcc2/cc1plus/cp-xref.c
deleted file mode 100644
index 0d4ce96bfc2e..000000000000
--- a/gnu/gcc2/cc1plus/cp-xref.c
+++ /dev/null
@@ -1,825 +0,0 @@
-/* Code for handling XREF output from GNU C++.
-   Copyright (C) 1992, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-#include "config.h"
-#include "tree.h"
-#include <stdio.h>
-#include "cp-tree.h"
-#include "input.h"
-
-#include <ctype.h>
-
-extern char *getpwd ();
-
-extern char *index ();
-extern char *rindex ();
-
-/* The character(s) used to join a directory specification (obtained with
-   getwd or equivalent) with a non-absolute file name.  */
-
-#ifndef FILE_NAME_JOINER
-#define FILE_NAME_JOINER "/"
-#endif
-
-/* Nonzero if NAME as a file name is absolute.  */
-#ifndef FILE_NAME_ABSOLUTE_P
-#define FILE_NAME_ABSOLUTE_P(NAME) (NAME[0] == '/')
-#endif
-
-/* For cross referencing.  */
-
-int flag_gnu_xref;
-
-/************************************************************************/
-/*									*/
-/*	Common definitions						*/
-/*									*/
-/************************************************************************/
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef NULL
-#define NULL 0
-#endif
-
-#define PALLOC(typ) ((typ *) calloc(1,sizeof(typ)))
-
-
-/* Return a malloc'd copy of STR.  */
-#define SALLOC(str) \
- ((char *) ((str) == NULL ? NULL	\
-	    : (char *) strcpy ((char *) malloc (strlen ((str)) + 1), (str))))
-#define SFREE(str) (str != NULL && (free(str),0))
-
-#define STREQL(s1,s2) (strcmp((s1),(s2)) == 0)
-#define STRNEQ(s1,s2) (strcmp((s1),(s2)) != 0)
-#define STRLSS(s1,s2) (strcmp((s1),(s2)) < 0)
-#define STRLEQ(s1,s2) (strcmp((s1),(s2)) <= 0)
-#define STRGTR(s1,s2) (strcmp((s1),(s2)) > 0)
-#define STRGEQ(s1,s2) (strcmp((s1),(s2)) >= 0)
-
-/************************************************************************/
-/*									*/
-/*	Type definitions						*/
-/*									*/
-/************************************************************************/
-
-
-typedef struct _XREF_FILE *	XREF_FILE;
-typedef struct _XREF_SCOPE *	XREF_SCOPE;
-
-typedef struct _XREF_FILE
-{
-  char *name;
-  char *outname;
-  XREF_FILE next;
-} XREF_FILE_INFO;
-
-typedef struct _XREF_SCOPE
-{
-  int gid;
-  int lid;
-  XREF_FILE file;
-  int start;
-  XREF_SCOPE outer;
-} XREF_SCOPE_INFO;
-
-/************************************************************************/
-/*									*/
-/*	Local storage							*/
-/*									*/
-/************************************************************************/
-
-static	char		doing_xref = 0;
-static	FILE *		xref_file = NULL;
-static	char		xref_name[1024];
-static	XREF_FILE	all_files = NULL;
-static	char *		wd_name = NULL;
-static	XREF_SCOPE	cur_scope = NULL;
-static	int 	scope_ctr = 0;
-static	XREF_FILE	last_file = NULL;
-static	tree		last_fndecl = NULL;
-
-/************************************************************************/
-/*									*/
-/*	Forward definitions						*/
-/*									*/
-/************************************************************************/
-
-extern	void		GNU_xref_begin();
-extern	void		GNU_xref_end();
-extern	void		GNU_xref_file();
-extern	void		GNU_xref_start_scope();
-extern	void		GNU_xref_end_scope();
-extern	void		GNU_xref_ref();
-extern	void		GNU_xref_decl();
-extern	void		GNU_xref_call();
-extern	void		GNU_xref_function();
-extern	void		GNU_xref_assign();
-extern	void		GNU_xref_hier();
-extern	void		GNU_xref_member();
-
-static	void		gen_assign();
-static	XREF_FILE	find_file();
-static	char *		filename();
-static	char *		fctname();
-static	char *		declname();
-static	void		simplify_type();
-static	char *		fixname();
-static	void		open_xref_file();
-
-extern	char *		type_as_string();
-
-/* Start cross referencing.  FILE is the name of the file we xref.  */
-
-void
-GNU_xref_begin (file)
-   char *file;
-{
-  doing_xref = 1;
-
-  if (file != NULL && STRNEQ (file,"-"))
-    {
-      open_xref_file(file);
-      GNU_xref_file(file);
-    }
-}
-
-/* Finish cross-referencing.  ERRCNT is the number of errors
-   we encountered.  */
-
-void
-GNU_xref_end (ect)
-   int ect;
-{
-  XREF_FILE xf;
-
-  if (!doing_xref) return;
-
-  xf = find_file (input_filename);
-  if (xf == NULL) return;
-
-  while (cur_scope != NULL)
-    GNU_xref_end_scope(cur_scope->gid,0,0,0,0);
-
-  doing_xref = 0;
-
-  if (xref_file == NULL) return;
-
-  fclose (xref_file);
-
-  xref_file = NULL;
-  all_files = NULL;
-
-  if (ect > 0) unlink (xref_name);
-}
-
-/* Write out xref for file named NAME.  */
-
-void
-GNU_xref_file (name)
-   char *name;
-{
-  XREF_FILE xf;
-
-  if (!doing_xref || name == NULL) return;
-
-  if (xref_file == NULL)
-    {
-      open_xref_file (name);
-      if (!doing_xref) return;
-    }
-
-  if (all_files == NULL)
-    fprintf(xref_file,"SCP * 0 0 0 0 RESET\n");
-
-  xf = find_file (name);
-  if (xf != NULL) return;
-
-  xf = PALLOC (XREF_FILE_INFO);
-  xf->name = SALLOC (name);
-  xf->next = all_files;
-  all_files = xf;
-
-  if (wd_name == NULL)
-    wd_name = getpwd ();
-
-  if (FILE_NAME_ABSOLUTE_P (name) || ! wd_name)
-    xf->outname = xf->name;
-  else
-    {
-      char *nmbuf
-	= (char *) malloc (strlen (wd_name) + strlen (FILE_NAME_JOINER)
-			   + strlen (name) + 1);
-      sprintf (nmbuf, "%s%s%s", wd_name, FILE_NAME_JOINER, name);
-      name = nmbuf;
-      xf->outname = nmbuf;
-    }
-
-  fprintf (xref_file, "FIL %s %s 0\n", name, wd_name);
-
-  filename (xf);
-  fctname (NULL);
-}
-
-/* Start a scope identified at level ID.  */
-
-void
-GNU_xref_start_scope (id)
-   HOST_WIDE_INT id;
-{
-  XREF_SCOPE xs;
-  XREF_FILE xf;
-
-  if (!doing_xref) return;
-  xf = find_file (input_filename);
-
-  xs = PALLOC (XREF_SCOPE_INFO);
-  xs->file = xf;
-  xs->start = lineno;
-  if (xs->start <= 0) xs->start = 1;
-  xs->gid = id;
-  xs->lid = ++scope_ctr;
-  xs->outer = cur_scope;
-  cur_scope = xs;
-}
-
-/* Finish a scope at level ID.
-   INID is ???
-   PRM is ???
-   KEEP is nonzero iff this scope is retained (nonzero if it's
-   a compiler-generated invisible scope).
-   TRNS is ???  */
-
-void
-GNU_xref_end_scope (id,inid,prm,keep,trns)
-   HOST_WIDE_INT id;
-   HOST_WIDE_INT inid;
-   int prm,keep,trns;
-{
-  XREF_FILE xf;
-  XREF_SCOPE xs,lxs,oxs;
-  char *stype;
-
-  if (!doing_xref) return;
-  xf = find_file (input_filename);
-  if (xf == NULL) return;
-
-  lxs = NULL;
-  for (xs = cur_scope; xs != NULL; xs = xs->outer)
-    {
-      if (xs->gid == id) break;
-      lxs = xs;
-    }
-  if (xs == NULL) return;
-
-  if (inid != 0) {
-    for (oxs = cur_scope; oxs != NULL; oxs = oxs->outer) {
-      if (oxs->gid == inid) break;
-    }
-    if (oxs == NULL) return;
-    inid = oxs->lid;
-  }
-
-  if (prm == 2) stype = "SUE";
-  else if (prm != 0) stype = "ARGS";
-  else if (keep == 2 || inid != 0) stype = "INTERN";
-  else stype = "EXTERN";
-
-  fprintf (xref_file,"SCP %s %d %d %d %d %s\n",
-	   filename (xf), xs->start, lineno,xs->lid, inid, stype);
-
-  if (lxs == NULL) cur_scope = xs->outer;
-  else lxs->outer = xs->outer;
-
-  free (xs);
-}
-
-/* Output a reference to NAME in FNDECL.  */
-
-void
-GNU_xref_ref (fndecl,name)
-   tree fndecl;
-   char *name;
-{
-  XREF_FILE xf;
-
-  if (!doing_xref) return;
-  xf = find_file (input_filename);
-  if (xf == NULL) return;
-
-  fprintf (xref_file, "REF %s %d %s %s\n",
-	   filename (xf), lineno, fctname (fndecl), name);
-}
-
-/* Output a reference to DECL in FNDECL.  */
-
-void
-GNU_xref_decl (fndecl,decl)
-   tree fndecl;
-   tree decl;
-{
-  XREF_FILE xf,xf1;
-  char *cls;
-  char *name;
-  char buf[10240];
-  int uselin;
-
-  if (!doing_xref) return;
-  xf = find_file (input_filename);
-  if (xf == NULL) return;
-
-  uselin = FALSE;
-
-  if (TREE_CODE (decl) == TYPE_DECL) cls = "TYPEDEF";
-  else if (TREE_CODE (decl) == FIELD_DECL) cls = "FIELD";
-  else if (TREE_CODE (decl) == VAR_DECL)
-    {
-      if (fndecl == NULL && TREE_STATIC(decl)
-	  && TREE_READONLY(decl) && DECL_INITIAL(decl) != 0
-	  && !TREE_PUBLIC(decl) && !DECL_EXTERNAL(decl)
-	  && DECL_MODE(decl) != BLKmode) cls = "CONST";
-      else if (DECL_EXTERNAL(decl)) cls = "EXTERN";
-      else if (TREE_PUBLIC(decl)) cls = "EXTDEF";
-      else if (TREE_STATIC(decl)) cls = "STATIC";
-      else if (DECL_REGISTER(decl)) cls = "REGISTER";
-      else cls = "AUTO";
-    }
-  else if (TREE_CODE (decl) == PARM_DECL) cls = "PARAM";
-  else if (TREE_CODE (decl) == FIELD_DECL) cls = "FIELD";
-  else if (TREE_CODE (decl) == CONST_DECL) cls = "CONST";
-  else if (TREE_CODE (decl) == FUNCTION_DECL)
-    {
-      if (DECL_EXTERNAL (decl)) cls = "EXTERN";
-      else if (TREE_PUBLIC (decl)) cls = "EFUNCTION";
-      else cls = "SFUNCTION";
-    }
-  else if (TREE_CODE (decl) == LABEL_DECL) cls = "LABEL";
-  else if (TREE_CODE (decl) == UNION_TYPE)
-    {
-      cls = "UNIONID";
-      decl = TYPE_NAME (decl);
-      uselin = TRUE;
-    }
-  else if (TREE_CODE (decl) == RECORD_TYPE)
-    {
-      if (CLASSTYPE_DECLARED_CLASS (decl)) cls = "CLASSID";
-      else cls = "STRUCTID";
-      decl = TYPE_NAME (decl);
-      uselin = TRUE;
-    }
-  else if (TREE_CODE (decl) == ENUMERAL_TYPE)
-    {
-      cls = "ENUMID";
-      decl = TYPE_NAME (decl);
-      uselin = TRUE;
-    }
-  else cls = "UNKNOWN";
-
-  if (decl == NULL || DECL_NAME (decl) == NULL) return;
-
-  if (uselin && decl->decl.linenum > 0 && decl->decl.filename != NULL)
-    {
-      xf1 = find_file (decl->decl.filename);
-      if (xf1 != NULL)
-	{
-	  lineno = decl->decl.linenum;
-	  xf = xf1;
-	}
-    }
-
-  if (DECL_ASSEMBLER_NAME (decl))
-    name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
-  else
-    name = IDENTIFIER_POINTER (DECL_NAME (decl));
-
-  strcpy (buf, type_as_string (TREE_TYPE (decl)));
-  simplify_type (buf);
-
-  fprintf (xref_file, "DCL %s %d %s %d %s %s %s\n",
-	   filename(xf), lineno, name,
-	   (cur_scope != NULL ? cur_scope->lid : 0),
-	   cls, fctname(fndecl), buf);
-
-  if (STREQL (cls, "STRUCTID") || STREQL (cls, "UNIONID"))
-    {
-      cls = "CLASSID";
-      fprintf (xref_file, "DCL %s %d %s %d %s %s %s\n",
-	       filename(xf), lineno,name,
-	       (cur_scope != NULL ? cur_scope->lid : 0),
-	       cls, fctname(fndecl), buf);
-    }
-}
-
-/* Output a reference to a call to NAME in FNDECL.  */
-
-void
-GNU_xref_call (fndecl, name)
-   tree fndecl;
-   char *name;
-{
-  XREF_FILE xf;
-  char buf[1024];
-  char *s;
-
-  if (!doing_xref) return;
-  xf = find_file (input_filename);
-  if (xf == NULL) return;
-  name = fixname (name, buf);
-
-  for (s = name; *s != 0; ++s)
-    if (*s == '_' && s[1] == '_') break;
-  if (*s != 0) GNU_xref_ref (fndecl, name);
-
-  fprintf (xref_file, "CAL %s %d %s %s\n",
-	   filename (xf), lineno, name, fctname (fndecl));
-}
-
-/* Output cross-reference info about FNDECL.  If non-NULL,
-   ARGS are the arguments for the function (i.e., before the FUNCTION_DECL
-   has been fully built).  */
-
-void
-GNU_xref_function (fndecl, args)
-   tree fndecl;
-   tree args;
-{
-  XREF_FILE xf;
-  int ct;
-  char buf[1024];
-
-  if (!doing_xref) return;
-  xf = find_file (input_filename);
-  if (xf == NULL) return;
-
-  ct = 0;
-  buf[0] = 0;
-  if (args == NULL) args = DECL_ARGUMENTS (fndecl);
-
-  GNU_xref_decl (NULL, fndecl);
-
-  for ( ; args != NULL; args = TREE_CHAIN (args))
-    {
-      GNU_xref_decl (fndecl,args);
-      if (ct != 0) strcat (buf,",");
-      strcat (buf, declname (args));
-      ++ct;
-    }
-
-  fprintf (xref_file, "PRC %s %d %s %d %d %s\n",
-	   filename(xf), lineno, declname(fndecl),
-	   (cur_scope != NULL ? cur_scope->lid : 0),
-	   ct, buf);
-}
-
-/* Output cross-reference info about an assignment to NAME.  */
-
-void
-GNU_xref_assign(name)
-   tree name;
-{
-  XREF_FILE xf;
-
-  if (!doing_xref) return;
-  xf = find_file(input_filename);
-  if (xf == NULL) return;
-
-  gen_assign(xf, name);
-}
-
-static void
-gen_assign(xf, name)
-   XREF_FILE xf;
-   tree name;
-{
-  char *s;
-
-  s = NULL;
-
-  switch (TREE_CODE (name))
-    {
-    case IDENTIFIER_NODE :
-      s = IDENTIFIER_POINTER(name);
-      break;
-    case VAR_DECL :
-      s = declname(name);
-      break;
-    case COMPONENT_REF :
-      gen_assign(xf, TREE_OPERAND(name, 0));
-      gen_assign(xf, TREE_OPERAND(name, 1));
-      break;
-    case INDIRECT_REF :
-    case OFFSET_REF :
-    case ARRAY_REF :
-    case BUFFER_REF :
-      gen_assign(xf, TREE_OPERAND(name, 0));
-      break;
-    case COMPOUND_EXPR :
-      gen_assign(xf, TREE_OPERAND(name, 1));
-      break;
-      default :
-      break;
-    }
-
-  if (s != NULL)
-    fprintf(xref_file, "ASG %s %d %s\n", filename(xf), lineno, s);
-}
-
-/* Output cross-reference info about a class hierarchy.
-   CLS is the class type of interest.  BASE is a baseclass
-   for CLS.  PUB and VIRT give the visibility info about
-   the class derivation.  FRND is nonzero iff BASE is a friend
-   of CLS.
-
-   ??? Needs to handle nested classes.  */
-void
-GNU_xref_hier(cls, base, pub, virt, frnd)
-   char *cls;
-   char *base;
-   int pub;
-   int virt;
-   int frnd;
-{
-  XREF_FILE xf;
-
-  if (!doing_xref) return;
-  xf = find_file(input_filename);
-  if (xf == NULL) return;
-
-  fprintf(xref_file, "HIE %s %d %s %s %d %d %d\n",
-	  filename(xf), lineno, cls, base, pub, virt, frnd);
-}
-
-/* Output cross-reference info about class members.  CLS
-   is the containing type; FLD is the class member.  */
-
-void
-GNU_xref_member(cls, fld)
-   tree cls;
-   tree fld;
-{
-  XREF_FILE xf;
-  char *prot;
-  int confg, pure;
-  char *d;
-  int i;
-  char buf[1024], bufa[1024];
-
-  if (!doing_xref) return;
-  xf = find_file(fld->decl.filename);
-  if (xf == NULL) return;
-
-  if (TREE_PRIVATE (fld)) prot = "PRIVATE";
-  else if (TREE_PROTECTED(fld)) prot = "PROTECTED";
-  else prot = "PUBLIC";
-
-  confg = 0;
-  if (TREE_CODE (fld) == FUNCTION_DECL && DECL_CONST_MEMFUNC_P(fld))
-    confg = 1;
-  else if (TREE_CODE (fld) == CONST_DECL)
-    confg = 1;
-
-  pure = 0;
-  if (TREE_CODE (fld) == FUNCTION_DECL && DECL_ABSTRACT_VIRTUAL_P(fld))
-    pure = 1;
-
-  d = IDENTIFIER_POINTER(cls);
-  sprintf(buf, "%d%s", strlen(d), d);
-  i = strlen(buf);
-  strcpy(bufa, declname(fld));
-
-#ifdef XREF_SHORT_MEMBER_NAMES
-  for (p = &bufa[1]; *p != 0; ++p)
-    {
-      if (p[0] == '_' && p[1] == '_' && p[2] >= '0' && p[2] <= '9') {
-	if (strncmp(&p[2], buf, i) == 0) *p = 0;
-	break;
-      }
-      else if (p[0] == '_' && p[1] == '_' && p[2] == 'C' && p[3] >= '0' && p[3] <= '9') {
-	if (strncmp(&p[3], buf, i) == 0) *p = 0;
-	break;
-      }
-    }
-#endif
-
-  fprintf(xref_file, "MEM %s %d %s %s %s %d %d %d %d %d %d %d\n",
-	  filename(xf), fld->decl.linenum, d,  bufa,  prot,
-	  (TREE_CODE (fld) == FUNCTION_DECL ? 0 : 1),
-	  (DECL_INLINE (fld) ? 1 : 0),
-	  (DECL_FRIEND_P(fld) ? 1 : 0),
-	  (DECL_VINDEX(fld) ? 1 : 0),
-	  (TREE_STATIC(fld) ? 1 : 0),
-	  pure, confg);
-}
-
-/* Find file entry given name.  */
-
-static XREF_FILE
-find_file(name)
-   char *name;
-{
-  XREF_FILE xf;
-
-  for (xf = all_files; xf != NULL; xf = xf->next) {
-    if (STREQL(name, xf->name)) break;
-  }
-
-  return xf;
-}
-
-/* Return filename for output purposes.  */
-
-static char *
-filename(xf)
-   XREF_FILE xf;
-{
-  if (xf == NULL) {
-    last_file = NULL;
-    return "*";
-  }
-
-  if (last_file == xf) return "*";
-
-  last_file = xf;
-
-  return xf->outname;
-}
-
-/* Return function name for output purposes.  */
-
-static char *
-fctname(fndecl)
-   tree fndecl;
-{
-  static char fctbuf[1024];
-  char *s;
-
-  if (fndecl == NULL && last_fndecl == NULL) return "*";
-
-  if (fndecl == NULL)
-    {
-      last_fndecl = NULL;
-      return "*TOP*";
-    }
-
-  if (fndecl == last_fndecl) return "*";
-
-  last_fndecl = fndecl;
-
-  s = declname(fndecl);
-  s = fixname(s, fctbuf);
-
-  return s;
-}
-
-/* Return decl name for output purposes.  */
-
-static char *
-declname(dcl)
-   tree dcl;
-{
-  if (DECL_NAME (dcl) == NULL) return "?";
-
-  if (DECL_ASSEMBLER_NAME (dcl))
-    return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (dcl));
-  else
-    return IDENTIFIER_POINTER (DECL_NAME (dcl));
-}
-
-/* Simplify a type string by removing unneeded parenthesis.  */
-
-static void
-simplify_type(typ)
-   char *typ;
-{
-  char *s;
-  int lvl, i;
-
-  i = strlen(typ);
-  while (i > 0 && isspace(typ[i-1])) typ[--i] = 0;
-
-  if (i > 7 && STREQL(&typ[i-5], "const"))
-    {
-      typ[i-5] = 0;
-      i -= 5;
-    }
-
-  if (typ[i-1] != ')') return;
-
-  s = &typ[i-2];
-  lvl = 1;
-  while (*s != 0) {
-    if (*s == ')') ++lvl;
-    else if (*s == '(')
-      {
-	--lvl;
-	if (lvl == 0)
-	  {
-	    s[1] = ')';
-	    s[2] = 0;
-	    break;
-	  }
-      }
-    --s;
-  }
-
-  if (*s != 0 && s[-1] == ')')
-    {
-      --s;
-      --s;
-      if (*s == '(') s[2] = 0;
-      else if (*s == ':') {
-	while (*s != '(') --s;
-	s[1] = ')';
-	s[2] = 0;
-      }
-    }
-}
-
-/* Fixup a function name (take care of embedded spaces).  */
-
-static char *
-fixname(nam, buf)
-   char *nam;
-   char *buf;
-{
-  char *s, *t;
-  int fg;
-
-  s = nam;
-  t = buf;
-  fg = 0;
-
-  while (*s != 0)
-    {
-      if (*s == ' ')
-	{
-	  *t++ = '\36';
-	  ++fg;
-	}
-      else *t++ = *s;
-      ++s;
-    }
-  *t = 0;
-
-  if (fg == 0) return nam;
-
-  return buf;
-}
-
-/* Open file for xrefing.  */
-
-static void
-open_xref_file(file)
-   char *file;
-{
-  char *s, *t;
-
-#ifdef XREF_FILE_NAME
-  XREF_FILE_NAME (xref_name, file);
-#else
-  s = rindex (file, '/');
-  if (s == NULL)
-    sprintf (xref_name, ".%s.gxref", file);
-  else
-    {
-      ++s;
-      strcpy (xref_name, file);
-      t = rindex (xref_name, '/');
-      ++t;
-      *t++ = '.';
-      strcpy (t, s);
-      strcat (t, ".gxref");
-    }
-#endif /* no XREF_FILE_NAME */
-
-  xref_file = fopen(xref_name, "w");
-
-  if (xref_file == NULL)
-    {
-      error("Can't create cross-reference file `%s'", xref_name);
-      doing_xref = 0;
-    }
-}
diff --git a/gnu/gcc2/cc1plus/stack.h b/gnu/gcc2/cc1plus/stack.h
deleted file mode 100644
index c5d9a2512a91..000000000000
--- a/gnu/gcc2/cc1plus/stack.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/* stack.h - structed access to object stacks
-   Copyright (C) 1988 Free Software Foundation, Inc.
-   Contributed by Michael Tiemann (tiemann@cygnus.com).
-
-This program 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.
-
-This program 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 this program; if not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* Summary: this file contains additional structures that layer
-   on top of obstacks for GNU C++.  */
-
-/* Stack of data placed on obstacks.  */
-   
-struct stack_level
-{
-  /* Pointer back to previous such level.  */
-  struct stack_level *prev;
-
-  /* Point to obstack we should return to.  */
-  struct obstack *obstack;
-
-  /* First place we start putting data.  */
-  tree *first;
-
-  /* Number of entries we can have from `first'.
-     Right now we are dumb: if we overflow, abort.  */
-  int limit;
-};
-
-struct stack_level *push_stack_level PROTO((struct obstack *, char *, int));
-struct stack_level *pop_stack_level PROTO((struct stack_level *));