--- /dev/null
+# Makefile for GNU C++ compiler.
+# Copyright (C) 1987, 88, 90, 91, 92, 93, 1994 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 targets for external use include:
+# all, doc, TAGS, mostlyclean, clean, distclean, realclean,
+
+# Suppress smart makes who think they know how to automake Yacc files
+.y.c:
+
+# Variables that exist for you to override.
+# See below for how to change them for certain systems.
+
+INCLUDES = -I. -I.. -I$(srcdir) -I$(srcdir)/.. -I$(srcdir)/../config
+
+# Various ways of specifying flags for compilations:
+# CFLAGS is for the user to override to, e.g., do a bootstrap with -O2.
+# BOOT_CFLAGS is the value of CFLAGS to pass
+# to the stage2 and stage3 compilations
+# XCFLAGS is used for most compilations but not when using the GCC just built.
+XCFLAGS =
+CFLAGS = -g
+BOOT_CFLAGS = -O $(CFLAGS)
+# These exists to be overridden by the x-* and t-* files, respectively.
+X_CFLAGS =
+T_CFLAGS =
+
+X_CPPFLAGS =
+T_CPPFLAGS =
+
+CC = cc
+# CYGNUS LOCAL: we use byacc instead of bison, DO NOT SEND TO RMS
+BISON = `if [ -f ../../byacc/byacc ] ; then echo ../../byacc/byacc ; else echo byacc ; fi`
+BISONFLAGS =
+LEX = `if [ -f ../../flex/flex ] ; then echo ../../flex/flex ; else echo flex ; fi`
+LEXFLAGS=
+AR = ar
+OLDAR_FLAGS = qc
+AR_FLAGS = rc
+SHELL = /bin/sh
+MAKEINFO = makeinfo
+TEXI2DVI = texi2dvi
+
+# Define this as & to perform parallel make on a Sequent.
+# Note that this has some bugs, and it seems currently necessary
+# to compile all the gen* files first by hand to avoid erroneous results.
+P =
+
+# This is used instead of ALL_CFLAGS when compiling with GCC_FOR_TARGET.
+# It omits XCFLAGS, and specifies -B./.
+# It also specifies -B$(tooldir)/ to find as and ld for a cross compiler.
+GCC_CFLAGS=$(INTERNAL_CFLAGS) $(X_CFLAGS) $(T_CFLAGS) $(CFLAGS)
+
+# Tools to use when building a cross-compiler.
+# These are used because `configure' appends `cross-make'
+# to the makefile when making a cross-compiler.
+
+# CYGNUS LOCAL: we don't use cross-make. Instead we use the tools
+# from the build tree, if they are available.
+# program_transform_name and objdir are set by configure.in.
+program_transform_name =
+objdir = .
+
+target= ... `configure' substitutes actual target name here.
+xmake_file= ... `configure' substitutes actual x- file name here.
+tmake_file= ... `configure' substitutes actual t- file name here.
+#version=`sed -e 's/.*\"\([^ \"]*\)[ \"].*/\1/' < $(srcdir)/version.c`
+#mainversion=`sed -e 's/.*\"\([0-9]*\.[0-9]*\).*/\1/' < $(srcdir)/version.c`
+
+# Directory where sources are, from where we are.
+srcdir = .
+
+# Change this to a null string if obstacks are installed in the
+# system library.
+OBSTACK=obstack.o
+
+# Directory to link to, when using the target `maketest'.
+DIR = ../gcc
+
+# Choose the real default target.
+ALL=all
+
+# End of variables for you to override.
+
+# Definition of `all' is here so that new rules inserted by sed
+# do not specify the default target.
+all: all.indirect
+
+# This tells GNU Make version 3 not to put all variables in the environment.
+.NOEXPORT:
+
+# sed inserts variable overrides after the following line.
+####target overrides
+####host overrides
+####cross overrides
+####build overrides
+####site overrides
+\f
+# Now figure out from those variables how to compile and link.
+
+all.indirect: Makefile ../cc1plus
+
+# IN_GCC tells obstack.h to use gstddef.h.
+INTERNAL_CFLAGS = $(CROSS) -DIN_GCC
+
+# This is the variable actually used when we compile.
+ALL_CFLAGS = $(INTERNAL_CFLAGS) $(X_CFLAGS) $(T_CFLAGS) $(CFLAGS) $(XCFLAGS)
+
+# Likewise.
+ALL_CPPFLAGS = $(CPPFLAGS) $(X_CPPFLAGS) $(T_CPPFLAGS)
+
+SUBDIR_OBSTACK = `if [ x$(OBSTACK) != x ]; then echo ../$(OBSTACK); else true; fi`
+SUBDIR_USE_ALLOCA = `if [ x$(USE_ALLOCA) != x ]; then echo ../$(USE_ALLOCA); else true; fi`
+SUBDIR_MALLOC = `if [ x$(MALLOC) != x ]; then echo ../$(MALLOC); else true; fi`
+
+# How to link with both our special library facilities
+# and the system's installed libraries.
+LIBS = $(SUBDIR_OBSTACK) $(SUBDIR_USE_ALLOCA) $(SUBDIR_MALLOC) $(CLIB)
+
+# Always use -I$(srcdir)/config when compiling.
+.c.o:
+ $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $<
+
+# This tells GNU make version 3 not to export all the variables
+# defined in this file into the environment.
+.NOEXPORT:
+\f
+# Lists of files for various purposes.
+
+# Language-specific object files for g++
+
+CXX_OBJS = call.o decl.o errfn.o expr.o pt.o sig.o typeck2.o \
+ class.o decl2.o error.o gc.o lex.o parse.o ptree.o spew.o typeck.o cvt.o \
+ edsel.o except.o init.o method.o search.o tree.o xref.o
+
+# Files specific to the C interpreter bytecode compiler(s).
+BC_OBJS = ../bc-emit.o ../bc-optab.o
+
+# Language-independent object files.
+OBJS = ../toplev.o ../version.o ../tree.o ../print-tree.o ../stor-layout.o ../fold-const.o \
+ ../function.o ../stmt.o ../expr.o ../calls.o ../expmed.o ../explow.o ../optabs.o ../varasm.o \
+ ../rtl.o ../print-rtl.o ../rtlanal.o ../emit-rtl.o ../real.o \
+ ../dbxout.o ../sdbout.o ../dwarfout.o ../xcoffout.o \
+ ../integrate.o ../jump.o ../cse.o ../loop.o ../unroll.o ../flow.o ../stupid.o ../combine.o \
+ ../regclass.o ../local-alloc.o ../global.o ../reload.o ../reload1.o ../caller-save.o \
+ ../insn-peep.o ../reorg.o ../sched.o ../final.o ../recog.o ../reg-stack.o \
+ ../insn-opinit.o ../insn-recog.o ../insn-extract.o ../insn-output.o ../insn-emit.o \
+ ../insn-attrtab.o ../aux-output.o ../getpwd.o ../convert.o \
+ ../c-common.o
+
+compiler: ../cc1plus
+../cc1plus: $(P) $(CXX_OBJS) $(OBJS) $(BC_OBJS) $(LIBDEPS)
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o ../cc1plus \
+ $(CXX_OBJS) $(OBJS) $(BC_OBJS) $(LIBS)
+
+\f
+Makefile: $(srcdir)/Makefile.in $(srcdir)/../configure
+ cd ..; $(SHELL) config.status
+
+native: config.status ../cc1plus
+
+# Really, really stupid make features, such as SUN's KEEP_STATE, may force
+# a target to build even if it is up-to-date. So we must verify that
+# config.status does not exist before failing.
+config.status:
+ @if [ ! -f config.status ] ; then \
+ echo You must configure gcc. Look at the ../INSTALL file for details.; \
+ false; \
+ else \
+ true; \
+ fi
+
+\f
+# Compiling object files from source files.
+
+# Note that dependencies on obstack.h are not written
+# because that file is not part of GCC.
+# Dependencies on gvarargs.h are not written
+# because all that file does, when not compiling with GCC,
+# is include the system varargs.h.
+
+# C++ language specific files.
+
+TREE_H = ../tree.h ../real.h ../tree.def ../machmode.h ../machmode.def
+CXX_TREE_H = $(TREE_H) cp-tree.h tree.def
+
+parse.o : $(srcdir)/parse.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h lex.h
+ $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(BIG_SWITCHFLAG) \
+ `echo $(srcdir)/parse.c | sed 's,^\./,,'`
+
+$(srcdir)/parse.c $(srcdir)/parse.h : $(srcdir)/parse.y
+ @echo expect 28 shift/reduce conflicts, 14 reduce/reduce conflicts.
+ cd $(srcdir); $(BISON) $(BISONFLAGS) -d -o parse.c parse.y
+ cd $(srcdir); grep '^#define[ ]*YYEMPTY' parse.c >>parse.h
+
+# hash.h really depends on $(srcdir)/gxx.gperf.
+# But this would screw things for people that don't have gperf,
+# if gxx.gpref got touched, say.
+# Thus you have to remove hash.h to force it to be re-made.
+$(srcdir)/hash.h:
+ gperf -p -j1 -g -o -t -N is_reserved_word '-k1,4,7,$$' \
+ $(srcdir)/gxx.gperf >$(srcdir)/hash.h
+
+spew.o : spew.c $(CONFIG_H) $(CXX_TREE_H) \
+ parse.h ../flags.h lex.h
+lex.o : lex.c $(CONFIG_H) $(CXX_TREE_H) \
+ parse.h input.c ../flags.h hash.h lex.h
+decl.o : decl.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h \
+ lex.h decl.h ../stack.h
+decl2.o : decl2.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h \
+ lex.h decl.h
+typeck2.o : typeck2.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h
+typeck.o : typeck.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h $(RTL_H)
+class.o : class.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h
+call.o : call.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h class.h
+init.o : init.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h $(RTL_H)
+method.o : method.c $(CONFIG_H) $(CXX_TREE_H) class.h
+cvt.o : cvt.c $(CONFIG_H) $(CXX_TREE_H) class.h
+search.o : search.c $(CONFIG_H) $(CXX_TREE_H) ../stack.h ../flags.h
+tree.o : tree.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h
+ptree.o : ptree.c $(CONFIG_H) $(CXX_TREE_H)
+gc.o : gc.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h
+except.o : except.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h $(RTL_H)
+expr.o : expr.c $(CONFIG_H) $(CXX_TREE_H) $(RTL_H) ../flags.h \
+ ../expr.h ../insn-codes.h
+edsel.o : edsel.c $(CONFIG_H) $(CXX_TREE_H) ../stack.h ../flags.h
+xref.o : xref.c $(CONFIG_H) $(CXX_TREE_H) ../input.h
+pt.o : pt.c $(CONFIG_H) $(CXX_TREE_H) decl.h parse.h
+error.o : error.c $(CONFIG_H) $(CXX_TREE_H)
+errfn.o : errfn.c $(CONFIG_H) $(CXX_TREE_H)
+sig.o : sig.c $(CONFIG_H) $(CXX_TREE_H) ../flags.h
+
+doc: info
+info:
+
+dvi:
+
+\f
+# Deletion of files made during compilation.
+# There are four levels of this:
+# `mostlyclean', `clean', `distclean' and `realclean'.
+# `mostlyclean' is useful while working on a particular type of machine.
+# It deletes most, but not all, of the files made by compilation.
+# It does not delete libgcc.a or its parts, so it won't have to be recompiled.
+# `clean' deletes everything made by running `make all'.
+# `distclean' also deletes the files made by config.
+# `realclean' also deletes everything that could be regenerated automatically.
+
+
+mostlyclean:
+# Delete the stamp files.
+ -rm -f stamp-* tmp-*
+# Delete debugging dump files.
+ -rm -f *.greg *.lreg *.combine *.flow *.cse *.jump *.rtl *.tree *.loop
+ -rm -f *.dbr *.jump2 *.sched *.cse2 *.sched2 *.stack
+# Delete unwanted output files from TeX.
+ -rm -f *.toc *.log *.vr *.fn *.cp *.tp *.ky *.pg
+# Delete sorted indices we don't actually use.
+ -rm -f gcc.vrs gcc.kys gcc.tps gcc.pgs gcc.fns
+ -rm -f *.o ../cc1plus
+
+# Delete all files made by compilation
+# that don't exist in the distribution.
+clean: mostlyclean
+ -rm -f *.dvi
+
+# Delete all files that users would normally create
+# while building and installing GCC.
+distclean: clean
+ -rm -f config.status Makefile *.oaux
+ -rm -f parse.output
+
+# Delete anything likely to be found in the source directory
+# that shouldn't be in the distribution.
+extraclean: distclean
+ -rm -rf =* ./"#"* *~*
+ -rm -f patch* *.orig *.rej
+ -rm -f *.dvi *.oaux *.d *.[zZ] *.gz
+ -rm -f *.s *.s[0-9] *.i
+
+# Get rid of every file that's generated from some other file.
+# Most of these files ARE PRESENT in the GCC distribution.
+realclean: distclean
+ -rm -f TAGS
+ -rm -f parse.c parse.h parse.output
+\f
+# These exist for maintenance purposes.
+
+# This target creates the files that can be rebuilt, but go in the
+# distribution anyway.
+distdir: parse.c hash.h
+
+# Update the tags table.
+TAGS: force
+ cd $(srcdir) ; \
+ etags *.c *.h ; \
+ echo 'l' | tr 'l' '\f' >> TAGS ; \
+ echo 'parse.y,0' >> TAGS ; \
+ etags -a ../*.h ../*.c;
+
+.PHONY: clean realclean TAGS
+
+force:
--- /dev/null
+/* Functions related to invoking methods and overloaded functions.
+ Copyright (C) 1987, 1992, 1993 Free Software Foundation, Inc.
+ Contributed by Michael Tiemann (tiemann@cygnus.com) and
+ hacked by Brendan Kehoe (brendan@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 "class.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_old ();
+static struct harshness_code convert_harshness_ansi ();
+
+/* OLD METHOD */
+/* Note the old method also uses USER_HARSHNESS, BASE_DERIVED_HARSHNESS,
+ CONST_HARSHNESS. */
+#define EVIL 1
+#define TRIVIAL 0
+#define EVIL_HARSHNESS(ARG) ((ARG) & 1)
+#define ELLIPSIS_HARSHNESS(ARG) ((ARG) & 2)
+#define CONTRAVARIANT_HARSHNESS(ARG) ((ARG) & 8)
+#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)
+
+
+/* NEW METHOD */
+#define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG))
+#define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG))
+#define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG))
+#define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG))
+
+#define USER_HARSHNESS(ARG) ((ARG) & 4)
+#define BASE_DERIVED_HARSHNESS(ARG) ((ARG) & 16)
+#define CONST_HARSHNESS(ARG) ((ARG) & 2048)
+
+/* Ordering function for overload resolution. Compare two candidates
+ by gross quality. */
+int
+rank_for_overload_ansi (x, y)
+ struct candidate *x, *y;
+{
+ if (y->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE))
+ return y->h.code - x->h.code;
+ if (x->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE))
+ return -1;
+
+ /* This is set by compute_conversion_costs, for calling a non-const
+ member function from a const member function. */
+ if ((y->v.ansi_harshness[0].code & CONST_CODE) ^ (x->v.ansi_harshness[0].code & CONST_CODE))
+ return y->v.ansi_harshness[0].code - x->v.ansi_harshness[0].code;
+
+ if (y->h.code & STD_CODE)
+ {
+ if (x->h.code & STD_CODE)
+ return y->h.distance - x->h.distance;
+ return 1;
+ }
+ if (x->h.code & STD_CODE)
+ return -1;
+
+ return y->h.code - x->h.code;
+}
+
+int
+rank_for_overload_old (x, y)
+ struct candidate *x, *y;
+{
+ if (y->evil - x->evil)
+ return y->evil - x->evil;
+ if (CONST_HARSHNESS (y->v.old_harshness[0]) ^ CONST_HARSHNESS (x->v.old_harshness[0]))
+ return y->v.old_harshness[0] - x->v.old_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;
+}
+
+int
+rank_for_overload (x, y)
+ struct candidate *x, *y;
+{
+ if (flag_ansi_overloading)
+ return rank_for_overload_ansi (x, y);
+ else
+ return rank_for_overload_old (x, y);
+}
+
+/* Compare two candidates, argument by argument. */
+int
+rank_for_ideal (x, y)
+ struct candidate *x, *y;
+{
+ int i;
+
+ if (x->h_len != y->h_len)
+ abort ();
+
+ for (i = 0; i < x->h_len; i++)
+ {
+ if (y->v.ansi_harshness[i].code - x->v.ansi_harshness[i].code)
+ return y->v.ansi_harshness[i].code - x->v.ansi_harshness[i].code;
+ if ((y->v.ansi_harshness[i].code & STD_CODE)
+ && (y->v.ansi_harshness[i].distance - x->v.ansi_harshness[i].distance))
+ return y->v.ansi_harshness[i].distance - x->v.ansi_harshness[i].distance;
+
+ /* They're both the same code. Now see if we're dealing with an
+ integral promotion that needs a finer grain of accuracy. */
+ if (y->v.ansi_harshness[0].code & PROMO_CODE
+ && (y->v.ansi_harshness[i].int_penalty ^ x->v.ansi_harshness[i].int_penalty))
+ return y->v.ansi_harshness[i].int_penalty - x->v.ansi_harshness[i].int_penalty;
+ }
+ return 0;
+}
+
+/* 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 struct harshness_code
+convert_harshness_ansi (type, parmtype, parm)
+ register tree type, parmtype;
+ tree parm;
+{
+ struct harshness_code h;
+ register enum tree_code codel;
+ register enum tree_code coder;
+
+ h.code = 0;
+ h.distance = 0;
+ h.int_penalty = 0;
+
+#ifdef GATHER_STATISTICS
+ n_convert_harshness++;
+#endif
+
+ if (TYPE_PTRMEMFUNC_P (type))
+ type = TYPE_PTRMEMFUNC_FN_TYPE (type);
+ if (TYPE_PTRMEMFUNC_P (parmtype))
+ parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
+
+ codel = TREE_CODE (type);
+ coder = TREE_CODE (parmtype);
+
+ if (TYPE_MAIN_VARIANT (parmtype) == TYPE_MAIN_VARIANT (type))
+ return ZERO_RETURN (h);
+
+ if (coder == ERROR_MARK)
+ return EVIL_RETURN (h);
+
+ if (codel == POINTER_TYPE && fntype_p (parmtype))
+ {
+ tree p1, p2;
+ struct harshness_code h1, h2;
+
+ /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */
+ type = TREE_TYPE (type);
+
+ if (coder == POINTER_TYPE)
+ {
+ parmtype = TREE_TYPE (parmtype);
+ coder = TREE_CODE (parmtype);
+ }
+
+ if (coder != TREE_CODE (type))
+ return EVIL_RETURN (h);
+
+ /* We allow the default conversion between function type
+ and pointer-to-function type for free. */
+ if (type == parmtype)
+ return ZERO_RETURN (h);
+
+ /* Compare return types. */
+ p1 = TREE_TYPE (type);
+ p2 = TREE_TYPE (parmtype);
+ h2 = convert_harshness_ansi (p1, p2, NULL_TREE);
+ if (h2.code & EVIL_CODE)
+ return h2;
+
+ h1.code = TRIVIAL_CODE;
+ h1.distance = 0;
+
+ if (h2.distance != 0)
+ {
+ tree binfo;
+
+ /* This only works for pointers. */
+ if (TREE_CODE (p1) != POINTER_TYPE
+ && TREE_CODE (p1) != REFERENCE_TYPE)
+ return EVIL_RETURN (h);
+
+ p1 = TREE_TYPE (p1);
+ p2 = TREE_TYPE (p2);
+ /* Don't die if we happen to be dealing with void*. */
+ if (!IS_AGGR_TYPE (p1) || !IS_AGGR_TYPE (p2))
+ return EVIL_RETURN (h);
+ if (h2.distance < 0)
+ binfo = get_binfo (p2, p1, 0);
+ else
+ binfo = get_binfo (p1, p2, 0);
+
+ if (! BINFO_OFFSET_ZEROP (binfo))
+ {
+ static int explained = 0;
+ if (h2.distance < 0)
+ 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 EVIL_RETURN (h);
+ }
+ }
+
+ h1.code |= h2.code;
+ if (h2.distance > h1.distance)
+ h1.distance = h2.distance;
+
+ 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)
+ {
+ h2 = convert_harshness_ansi (TREE_VALUE (p1), TREE_VALUE (p2),
+ NULL_TREE);
+ if (h2.code & EVIL_CODE)
+ return h2;
+
+ if (h2.distance)
+ {
+ /* This only works for pointers and references. */
+ if (TREE_CODE (TREE_VALUE (p1)) != POINTER_TYPE
+ && TREE_CODE (TREE_VALUE (p1)) != REFERENCE_TYPE)
+ return EVIL_RETURN (h);
+ h2.distance = - h2.distance;
+ }
+
+ h1.code |= h2.code;
+ if (h2.distance > h1.distance)
+ h1.distance = h2.distance;
+ p1 = TREE_CHAIN (p1);
+ p2 = TREE_CHAIN (p2);
+ }
+ if (p1 == p2)
+ return h1;
+ if (p2)
+ {
+ if (p1)
+ return EVIL_RETURN (h);
+ h1.code |= ELLIPSIS_CODE;
+ return h1;
+ }
+ if (p1)
+ {
+ if (TREE_PURPOSE (p1) == NULL_TREE)
+ h1.code |= EVIL_CODE;
+ return h1;
+ }
+ }
+ else if (codel == POINTER_TYPE && coder == OFFSET_TYPE)
+ {
+ /* Get to the OFFSET_TYPE that this might be. */
+ type = TREE_TYPE (type);
+
+ if (coder != TREE_CODE (type))
+ return EVIL_RETURN (h);
+
+ if (TYPE_OFFSET_BASETYPE (type) == TYPE_OFFSET_BASETYPE (parmtype))
+ h.code = 0;
+ else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (type),
+ TYPE_OFFSET_BASETYPE (parmtype)))
+ {
+ h.code = STD_CODE;
+ h.distance = 1;
+ }
+ else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (parmtype),
+ TYPE_OFFSET_BASETYPE (type)))
+ {
+ h.code = STD_CODE;
+ h.distance = -1;
+ }
+ else
+ return EVIL_RETURN (h);
+ /* 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 TRIVIAL_RETURN (h);
+ return EVIL_RETURN (h);
+ }
+
+ if (coder == VOID_TYPE)
+ return EVIL_RETURN (h);
+
+ 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 EVIL_RETURN (h);
+ }
+
+ /* else enums and ints (almost) freely interconvert. */
+
+ if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
+ {
+ if ((TREE_UNSIGNED (type) ^ TREE_UNSIGNED (parmtype))
+ || codel != coder
+ || TYPE_MODE (type) != TYPE_MODE (parmtype))
+ {
+ /* Make sure a value-preserving condition [from a smaller type to
+ a larger type] is preferred to a possibly value-destroying
+ standard conversion [from a larger type to a smaller type]. */
+ if (TYPE_PRECISION (type) >= TYPE_PRECISION (parmtype))
+ {
+ h.code = PROMO_CODE;
+ /* A char, short, wchar_t, etc., should promote to an int if
+ it can handle it, otherwise to an unsigned. So we'll make
+ an unsigned. */
+ if (type != integer_type_node)
+ h.int_penalty = 1;
+ }
+ else
+ h.code = STD_CODE;
+ }
+
+ /* If the three above conditions didn't trigger, we have found two
+ very similar types. On systems where they're the same size, we
+ can end up here with TYPE as `long' and PARMTYPE as `int'. Make
+ sure we realize that, even though they're the same mode, we will
+ have to do some sort of integral promotion on the type, since
+ they're not the same. */
+ if (! comptypes (type, parmtype, 1) && h.code == 0)
+ {
+ /* This call to common_type will return the best type for the
+ combination. If it matches TYPE, that means we'll be converting
+ from a so-called smaller type (in PARMTYPE) to the larger in TYPE,
+ thus an integral promotion. Otherwise, it must be going from a
+ larger type in PARMTYPE to a smaller expected type in TYPE, so we
+ make it a standard conversion instead. */
+ if (common_type (type, parmtype) == type)
+ h.code = PROMO_CODE;
+ else
+ h.code = STD_CODE;
+ }
+
+ return h;
+ }
+ else if (coder == REAL_TYPE)
+ {
+ h.code = STD_CODE;
+ h.distance = 0;
+ return h;
+ }
+ }
+
+ if (codel == REAL_TYPE)
+ {
+ if (coder == REAL_TYPE)
+ {
+ /* Shun converting among float, double, and long double if a
+ choice exists. */
+ h.code = PROMO_CODE;
+ return h;
+ }
+ else if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
+ {
+ h.code = STD_CODE;
+ h.distance = 0;
+ return h;
+ }
+ }
+
+ /* 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
+ unsigned pointer types. */
+
+ if ((TREE_CODE (ttl) == METHOD_TYPE
+ || TREE_CODE (ttl) == FUNCTION_TYPE)
+ && TREE_CODE (ttl) == TREE_CODE (ttr))
+ {
+ if (comptypes (ttl, ttr, -1))
+ {
+ h.code = penalty ? STD_CODE : 0;
+ h.distance = 0;
+ }
+ else
+ h.code = EVIL_CODE;
+ return h;
+ }
+
+#if 1
+ if (TREE_CODE (ttl) != VOID_TYPE && TREE_CODE (ttr) != VOID_TYPE)
+ {
+ if (TREE_UNSIGNED (ttl) != TREE_UNSIGNED (ttr))
+ {
+ ttl = unsigned_type (ttl);
+ ttr = unsigned_type (ttr);
+ penalty = 10;
+ }
+ if (! comp_target_types (ttl, ttr, 0))
+ return EVIL_RETURN (h);
+ }
+#else
+ 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 EVIL_RETURN (h);
+#endif
+
+ if (penalty == 10 || ttr == ttl)
+ {
+ tree tmp1 = TREE_TYPE (type), tmp2 = TREE_TYPE (parmtype);
+
+ /* If one was unsigned but the other wasn't, then we need to
+ do a standard conversion from T to unsigned T. */
+ if (penalty == 10)
+ h.code = PROMO_CODE; /* was STD_CODE */
+ else
+ h.code = 0;
+
+ /* Note conversion from `T*' to `const T*',
+ or `T*' to `volatile T*'. */
+ if (ttl == ttr
+ && ((TYPE_READONLY (tmp1) != TREE_READONLY (tmp2))
+ || (TYPE_VOLATILE (tmp1) != TYPE_VOLATILE (tmp2))))
+ h.code |= QUAL_CODE;
+
+ h.distance = 0;
+ return h;
+ }
+
+
+ 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 EVIL_RETURN (h);
+ h.distance = -b_or_d;
+ }
+ else
+ h.distance = b_or_d;
+ h.code = STD_CODE;
+ return h;
+ }
+
+ /* 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))
+ {
+ h.code = STD_CODE;
+ h.distance = CLASSTYPE_MAX_DEPTH (ttr)+1;
+ return h;
+ }
+ h.code = penalty ? STD_CODE : PROMO_CODE;
+ return h;
+ }
+
+ 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))
+ {
+ h.code = STD_CODE;
+ h.distance = 0;
+ return h;
+ }
+ }
+
+ /* 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 ZERO_RETURN (h);
+ penalty = 2;
+ }
+ else
+ {
+ /* Can reference be built up? */
+ if (ttl == intype && penalty == 0) {
+ /* Because the READONLY and VIRTUAL 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 ZERO_RETURN (h);
+ }
+ 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 ZERO_RETURN (h);
+ 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))
+ {
+ h = convert_harshness_ansi (ttl, ttr, NULL_TREE);
+ if (penalty > 2 || h.code != 0)
+ h.code |= STD_CODE;
+ else
+ h.code |= TRIVIAL_CODE;
+ h.distance = 0;
+ return h;
+ }
+
+ if (ttl == ttr)
+ {
+ if (penalty > 2)
+ {
+ h.code = STD_CODE;
+ h.distance = 0;
+ }
+ else
+ {
+ h.code = TRIVIAL_CODE;
+ /* We set this here so that build_overload_call_real will be
+ able to see the penalty we found, rather than just looking
+ at a TRIVIAL_CODE with no other information. */
+ h.int_penalty = penalty;
+ }
+ return h;
+ }
+
+ /* 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)
+ {
+ h.code = STD_CODE;
+ h.distance = 0;
+ return h;
+ }
+ }
+
+ if (parm && codel != REFERENCE_TYPE)
+ {
+ h = convert_harshness_ansi (ttl, ttr, NULL_TREE);
+ if (penalty)
+ h.code |= STD_CODE;
+ h.distance = 0;
+ return h;
+ }
+
+ /* 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 EVIL_RETURN (h);
+ h.distance = -b_or_d;
+ }
+ /* 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. */
+ else
+ h.distance = b_or_d;
+ h.code = STD_CODE;
+ return h;
+ }
+
+ if (comp_target_types (ttl, intype, 1))
+ {
+ if (penalty)
+ h.code = STD_CODE;
+ h.distance = 0;
+ return h;
+ }
+ }
+ }
+ 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 EVIL_RETURN (h);
+ h.distance = -b_or_d;
+ }
+ else
+ h.distance = b_or_d;
+ h.code = STD_CODE;
+ return h;
+ }
+ return EVIL_RETURN (h);
+}
+
+/* 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_old (type, parmtype, parm)
+ register tree type, parmtype;
+ tree parm;
+{
+ register enum tree_code codel;
+ register enum tree_code coder;
+
+#ifdef GATHER_STATISTICS
+ n_convert_harshness++;
+#endif
+
+ if (TYPE_PTRMEMFUNC_P (type))
+ type = TYPE_PTRMEMFUNC_FN_TYPE (type);
+ if (TYPE_PTRMEMFUNC_P (parmtype))
+ parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
+
+ codel = TREE_CODE (type);
+ coder = TREE_CODE (parmtype);
+
+ if (TYPE_MAIN_VARIANT (parmtype) == TYPE_MAIN_VARIANT (type))
+ return TRIVIAL;
+
+ if (coder == ERROR_MARK)
+ return EVIL;
+
+ if (codel == POINTER_TYPE && fntype_p (parmtype))
+ {
+ 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 == POINTER_TYPE)
+ {
+ parmtype = TREE_TYPE (parmtype);
+ coder = TREE_CODE (parmtype);
+ }
+
+ if (coder != TREE_CODE (type))
+ return EVIL;
+
+ harshness = 0;
+
+ /* We allow the default conversion between function type
+ and pointer-to-function type for free. */
+ if (type == parmtype)
+ return TRIVIAL;
+
+ /* Compare return types. */
+ p1 = TREE_TYPE (type);
+ p2 = TREE_TYPE (parmtype);
+ new_harshness = convert_harshness_old (p1, p2, NULL_TREE);
+ if (EVIL_HARSHNESS (new_harshness))
+ return EVIL;
+
+ 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 EVIL;
+
+ p1 = TREE_TYPE (p1);
+ p2 = TREE_TYPE (p2);
+ /* Don't die if we happen to be dealing with void*. */
+ if (!IS_AGGR_TYPE (p1) || !IS_AGGR_TYPE (p2))
+ return EVIL;
+ 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 EVIL;
+ }
+ }
+
+ 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_old (TREE_VALUE (p1),
+ TREE_VALUE (p2), NULL_TREE);
+ if (EVIL_HARSHNESS (new_harshness))
+ return EVIL;
+
+ 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 EVIL;
+ 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 ? EVIL : (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 EVIL;
+
+ 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 EVIL;
+ /* 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 TRIVIAL;
+ return EVIL;
+ }
+
+ if (coder == VOID_TYPE)
+ return EVIL;
+
+ 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 EVIL;
+ }
+
+ /* 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 TRIVIAL;
+ }
+ 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 EVIL;
+ }
+
+ 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 EVIL;
+
+ 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 EVIL;
+ 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++: Since the `this' parameter of a signature member function
+ is represented as a signature pointer to handle default implementations
+ correctly, we can have the case that `type' is a signature pointer
+ while `parmtype' is a pointer to a signature table. We don't really
+ do any conversions in this case, so just return 0. */
+
+ if (codel == RECORD_TYPE && coder == POINTER_TYPE
+ && IS_SIGNATURE_POINTER (type) && IS_SIGNATURE (TREE_TYPE (parmtype)))
+ return 0;
+
+ /* 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 TRIVIAL;
+ penalty = 2;
+ }
+ else
+ {
+ /* Can reference be built up? */
+ if (ttl == intype && penalty == 0) {
+ /* Because the READONLY bits and VIRTUAL 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 TRIVIAL;
+ }
+ 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 TRIVIAL;
+ 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_old (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_old (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 EVIL;
+ 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 EVIL;
+ return CONTRAVARIANT_HARSHNESS (-1);
+ }
+ return INT_TO_BD_HARSHNESS (b_or_d);
+ }
+ return EVIL;
+}
+
+#ifdef DEBUG_MATCHING
+static char *
+print_harshness (h)
+ struct harshness_code *h;
+{
+ static char buf[1024];
+ char tmp[1024];
+
+ bzero (buf, 1024 * sizeof (char));
+ strcat (buf, "codes=[");
+ if (h->code & EVIL_CODE)
+ strcat (buf, "EVIL");
+ if (h->code & CONST_CODE)
+ strcat (buf, " CONST");
+ if (h->code & ELLIPSIS_CODE)
+ strcat (buf, " ELLIPSIS");
+ if (h->code & USER_CODE)
+ strcat (buf, " USER");
+ if (h->code & STD_CODE)
+ strcat (buf, " STD");
+ if (h->code & PROMO_CODE)
+ strcat (buf, " PROMO");
+ if (h->code & QUAL_CODE)
+ strcat (buf, " QUAL");
+ if (h->code & TRIVIAL_CODE)
+ strcat (buf, " TRIVIAL");
+ if (buf[0] == '\0')
+ strcat (buf, "0");
+
+ sprintf (tmp, "] distance=%d int_penalty=%d", h->distance, h->int_penalty);
+
+ strcat (buf, tmp);
+
+ return buf;
+}
+#endif
+
+/* Algorithm: For each argument, calculate how difficult it is to
+ make FUNCTION accept that argument. If we can easily tell that
+ FUNCTION won't be acceptable to one of the arguments, then we
+ don't need to compute the ease of converting the other arguments,
+ since it will never show up in the intersection of all arguments'
+ favorite functions.
+
+ 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_ansi (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;
+ struct harshness_code 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! */
+
+ cp->h.code = 0;
+ cp->h.distance = 0;
+ cp->h.int_penalty = 0;
+ bzero (cp->v.ansi_harshness,
+ (cp->h_len + 1) * sizeof (struct harshness_code));
+
+ while (ttf && tta)
+ {
+ struct harshness_code h;
+
+ 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)
+ h.code = EVIL_CODE;
+ else
+ h = convert_harshness_ansi (lhstype, TREE_TYPE (rhs), rhs);
+ }
+ else
+ {
+#ifdef DEBUG_MATCHING
+ static tree old_function = NULL_TREE;
+
+ if (!old_function || function != old_function)
+ {
+ cp_error ("trying %D", function);
+ old_function = function;
+ }
+
+ cp_error (" doing (%T) %E against arg %T",
+ TREE_TYPE (TREE_VALUE (tta)), TREE_VALUE (tta),
+ TREE_VALUE (ttf));
+#endif
+
+ h = convert_harshness_ansi (TREE_VALUE (ttf),
+ TREE_TYPE (TREE_VALUE (tta)),
+ TREE_VALUE (tta));
+
+#ifdef DEBUG_MATCHING
+ cp_error (" evaluated %s", print_harshness (&h));
+#endif
+ }
+
+ cp->v.ansi_harshness[strike_index] = h;
+ if ((h.code & EVIL_CODE)
+ || ((h.code & STD_CODE) && h.distance < 0))
+ {
+ cp->u.bad_arg = strike_index;
+ evil_strikes = 1;
+ }
+ else if (h.code & ELLIPSIS_CODE)
+ ellipsis_strikes += 1;
+#if 0
+ /* This is never set by `convert_harshness_ansi'. */
+ else if (h.code & USER_CODE)
+ {
+ user_strikes += 1;
+ }
+#endif
+ else
+ {
+ if ((h.code & STD_CODE) && h.distance)
+ {
+ if (h.distance > b_or_d_strikes)
+ b_or_d_strikes = h.distance;
+ }
+ else
+ easy_strikes += (h.code & (STD_CODE|PROMO_CODE|TRIVIAL_CODE));
+ cp->h.code |= h.code;
+ /* Make sure we communicate this. */
+ cp->h.int_penalty += h.int_penalty;
+ }
+
+ 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->h.code = EVIL_CODE;
+ cp->u.bad_arg = -1;
+ return;
+ }
+ else
+ {
+ struct harshness_code h;
+ int l = list_length (tta);
+ ellipsis_strikes += l;
+ h.code = ELLIPSIS_CODE;
+ h.distance = 0;
+ h.int_penalty = 0;
+ for (; l; --l)
+ cp->v.ansi_harshness[strike_index++] = h;
+ }
+ }
+ else if (ttf && ttf != void_list_node)
+ {
+ /* ran out of actuals, and no defaults. */
+ if (TREE_PURPOSE (ttf) == NULL_TREE)
+ {
+ cp->h.code = EVIL_CODE;
+ cp->u.bad_arg = -2;
+ return;
+ }
+ /* Store index of first default. */
+ cp->v.ansi_harshness[arglen].distance = strike_index+1;
+ }
+ else
+ cp->v.ansi_harshness[arglen].distance = 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->h.code = EVIL_CODE;
+ 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->v.ansi_harshness[strike_index];
+ if ((lose.code & EVIL_CODE)
+ || ((lose.code & STD_CODE) && lose.distance < 0))
+ {
+ 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. */
+ /* @@ There is no way to save this result yet, so
+ success is a NULL_TREE for now. */
+ if (convert_to_aggr (formal_type, TREE_VALUE (tta), 0, 1)
+ != error_mark_node)
+ 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;
+ /* Don't issue warnings since we're only groping
+ around for the right answer, we haven't yet
+ committed to going with this solution. */
+ int old_inhibit_warnings = inhibit_warnings;
+
+ inhibit_warnings = 1;
+ conv = build_type_conversion (CALL_EXPR, TREE_VALUE (ttf), TREE_VALUE (tta), 0);
+ inhibit_warnings = old_inhibit_warnings;
+
+ 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->v.ansi_harshness[strike_index].code = USER_CODE;
+ 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)
+ {
+ tree this_parm = TREE_VALUE (ttf_in);
+
+ if (TREE_CODE (this_parm) == RECORD_TYPE /* Is `this' a sig ptr? */
+ ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm))))
+ : TYPE_READONLY (TREE_TYPE (this_parm)))
+ {
+ cp->v.ansi_harshness[0].code |= TRIVIAL_CODE;
+ ++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->v.ansi_harshness[0].code |= CONST_CODE;
+ }
+ }
+
+ if (evil_strikes)
+ cp->h.code = EVIL_CODE;
+ if (ellipsis_strikes)
+ cp->h.code |= ELLIPSIS_CODE;
+ if (user_strikes)
+ cp->h.code |= USER_CODE;
+#ifdef DEBUG_MATCHING
+ cp_error ("final eval %s", print_harshness (&cp->h));
+#endif
+}
+
+void
+compute_conversion_costs_old (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->v.old_harshness, (cp->h_len + 1) * sizeof (unsigned 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_old (lhstype, TREE_TYPE (rhs),
+ rhs);
+ /* harshness |= 2; */
+ }
+ }
+ else
+ harshness = convert_harshness_old (TREE_VALUE (ttf),
+ TREE_TYPE (TREE_VALUE (tta)),
+ TREE_VALUE (tta));
+
+ cp->v.old_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_old'. */
+ 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 ellipsis_strikes += list_length (tta);
+ }
+ 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->v.old_harshness[arglen] = strike_index+1;
+ }
+ else
+ cp->v.old_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->v.old_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->v.old_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)
+ {
+ tree this_parm = TREE_VALUE (ttf_in);
+
+ if (TREE_CODE (this_parm) == RECORD_TYPE /* Is `this' a sig ptr? */
+ ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm))))
+ : TYPE_READONLY (TREE_TYPE (this_parm)))
+ {
+ cp->v.old_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->v.old_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;
+}
+
+void
+compute_conversion_costs (function, tta_in, cp, arglen)
+ tree function;
+ tree tta_in;
+ struct candidate *cp;
+ int arglen;
+{
+ if (flag_ansi_overloading)
+ compute_conversion_costs_ansi (function, tta_in, cp, arglen);
+ else
+ compute_conversion_costs_old (function, tta_in, cp, arglen);
+}
+
+/* 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_old (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; index++)
+ {
+ if (USER_HARSHNESS (cp[i].v.old_harshness[index]))
+ {
+ /* If our "best" candidate also needs a conversion,
+ it must be the same one. */
+ if (USER_HARSHNESS (cp[-1].v.old_harshness[index])
+ && TREE_VALUE (ttf) != TREE_VALUE (ttf0))
+ goto non_subset;
+ }
+ ttf = TREE_CHAIN (ttf);
+ ttf0 = TREE_CHAIN (ttf0);
+ /* Handle `...' gracefully. */
+ if (ttf == NULL_TREE || ttf0 == NULL_TREE)
+ break;
+ }
+ 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 this is a varargs function, there's no conversion to do,
+ but don't accept an arg that needs a copy ctor. */
+ if (ttf == NULL_TREE)
+ {
+ /* FIXME: verify that we cannot get here with an
+ arg that needs a ctor. */
+ break;
+ }
+
+ if (USER_HARSHNESS (cp[i].v.old_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].v.old_harshness[0])
+ && cp[best].v.old_harshness[0] < cp[i].v.old_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].v.old_harshness[index])
+ != USER_HARSHNESS (cp[i].v.old_harshness[index]))
+ goto ret0;
+ /* If there's anything we like better about the
+ other function, consider it ambiguous. */
+ if (cp[i].v.old_harshness[index] < cp[best].v.old_harshness[index])
+ goto ret0;
+ /* If any single one it diffent, then the whole is
+ not identical. */
+ if (cp[i].v.old_harshness[index] != cp[best].v.old_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].v.old_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].v.old_harshness[len] != 0 && cp[-2].v.old_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].v.old_harshness[len];
+
+ if (cp[-2].v.old_harshness[len] < i)
+ i = cp[-2].v.old_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))
+ {
+ cp_error ("ambiguous request for function from distinct base classes of type `%T'", basetype);
+ cp_error_at (" first candidate is `%#D'",
+ candidates[best].function);
+ cp_error_at (" second candidate is `%#D'",
+ candidates[i].function);
+ 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 NULL;
+ p1 = TREE_CHAIN (p1);
+ p2 = TREE_CHAIN (p2);
+ }
+ if (p1 || p2)
+ return NULL;
+ }
+
+ 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 NULL;
+}
+
+/* Subroutine of ideal_candidate. See if X or Y is a better match
+ than the other. */
+static int
+strictly_better (x, y)
+ unsigned short x, y;
+{
+ unsigned short xor;
+
+ if (x == y)
+ return 0;
+
+ xor = x ^ y;
+ if (xor >= x || xor >= y)
+ return 1;
+ return 0;
+}
+
+static struct candidate *
+ideal_candidate_ansi (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 i, j = -1, best_code;
+
+ /* For each argument, sort the functions from best to worst for the arg.
+ For each function that's not best for this arg, set its overall
+ harshness to EVIL so that other args won't like it. The candidate
+ list for the last argument is the intersection of all the best-liked
+ functions. */
+
+#if 0
+ for (i = 0; i < len; i++)
+ {
+ qsort (candidates, n_candidates, sizeof (struct candidate),
+ rank_for_overload);
+ best_code = cp[-1].h.code;
+
+ /* To find out functions that are worse than that represented
+ by BEST_CODE, we can't just do a comparison like h.code>best_code.
+ The total harshness for the "best" fn may be 8|8 for two args, and
+ the harshness for the next-best may be 8|2. If we just compared,
+ that would be checking 8>10, which would lead to the next-best
+ being disqualified. What we actually want to do is get rid
+ of functions that are definitely worse than that represented
+ by best_code, i.e. those which have bits set higher than the
+ highest in best_code. Sooooo, what we do is clear out everything
+ represented by best_code, and see if we still come up with something
+ higher. If so (e.g., 8|8 vs 8|16), it'll disqualify it properly. */
+ for (j = n_candidates-2; j >= 0; j--)
+ if ((candidates[j].h.code & ~best_code) > best_code)
+ candidates[j].h.code = EVIL_CODE;
+ }
+
+ if (cp[-1].h.code & EVIL_CODE)
+ return NULL;
+#else
+ qsort (candidates, n_candidates, sizeof (struct candidate),
+ rank_for_overload);
+ best_code = cp[-1].h.code;
+#endif
+
+ /* If they're at least as good as each other, do an arg-by-arg check. */
+ if (! strictly_better (cp[-1].h.code, cp[-2].h.code))
+ {
+ int better = 0;
+ int worse = 0;
+
+ for (j = 0; j < n_candidates; j++)
+ if (! strictly_better (candidates[j].h.code, best_code))
+ break;
+
+ qsort (candidates+j, n_candidates-j, sizeof (struct candidate),
+ rank_for_ideal);
+ for (i = 0; i < len; i++)
+ {
+ if (cp[-1].v.ansi_harshness[i].code < cp[-2].v.ansi_harshness[i].code)
+ better = 1;
+ else if (cp[-1].v.ansi_harshness[i].code > cp[-2].v.ansi_harshness[i].code)
+ worse = 1;
+ else if (cp[-1].v.ansi_harshness[i].code & STD_CODE)
+ {
+ /* If it involves a standard conversion, let the
+ inheritance lattice be the final arbiter. */
+ if (cp[-1].v.ansi_harshness[i].distance > cp[-2].v.ansi_harshness[i].distance)
+ worse = 1;
+ else if (cp[-1].v.ansi_harshness[i].distance < cp[-2].v.ansi_harshness[i].distance)
+ better = 1;
+ }
+ else if (cp[-1].v.ansi_harshness[i].code & PROMO_CODE)
+ {
+ /* For integral promotions, take into account a finer
+ granularity for determining which types should be favored
+ over others in such promotions. */
+ if (cp[-1].v.ansi_harshness[i].int_penalty > cp[-2].v.ansi_harshness[i].int_penalty)
+ worse = 1;
+ else if (cp[-1].v.ansi_harshness[i].int_penalty < cp[-2].v.ansi_harshness[i].int_penalty)
+ better = 1;
+ }
+ }
+
+ if (! better || worse)
+ return NULL;
+ }
+ return cp-1;
+}
+
+static struct candidate *
+ideal_candidate (basetype, candidates, n_candidates, parms, len)
+ tree basetype;
+ struct candidate *candidates;
+ int n_candidates;
+ tree parms;
+ int len;
+{
+ if (flag_ansi_overloading)
+ return ideal_candidate_ansi (basetype, candidates, n_candidates, parms,
+ len);
+ else
+ return ideal_candidate_old (basetype, candidates, n_candidates, parms,
+ len);
+}
+
+/* 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)
+ tree basetype_path, instance_ptr, name, parms;
+{
+ 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)
+ {
+ cp_error ("`this' has no member named `%D'", 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 access
+ violations. */
+ if (field == error_mark_node)
+ return error_mark_node;
+
+ if (field)
+ {
+ tree basetype;
+ tree ftype = TREE_TYPE (field);
+
+ if (TREE_CODE (ftype) == REFERENCE_TYPE)
+ ftype = TREE_TYPE (ftype);
+
+ 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_PTR);
+ 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_PTR),
+ 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);
+ }
+
+#if 0
+ /* XXX This needs to be fixed better. */
+ if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
+ {
+ sorry ("nested class lookup in template type");
+ return NULL_TREE;
+ }
+#endif
+
+ /* 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_stuff)
+ tree outer_type, inner_stuff;
+{
+ register tree tmp;
+ tree inner_name, inner_type;
+
+ 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_stuff);
+
+ if (rval != NULL_TREE)
+ return rval;
+ type = DECL_CONTEXT (TYPE_NAME (type));
+ }
+ }
+
+ if (TREE_CODE (inner_stuff) == SCOPE_REF)
+ {
+ inner_name = TREE_OPERAND (inner_stuff, 0);
+ inner_type = TREE_OPERAND (inner_stuff, 1);
+ }
+ else
+ {
+ inner_name = inner_stuff;
+ inner_type = 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_type)
+ return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name),
+ inner_type);
+ 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_type);
+
+ /* 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 = resolve_scope_to_name (BINFO_TYPE (base_binfo), inner_stuff);
+ 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, scopes, name, 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 access 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)
+ return error_mark_node;
+
+ basetype = IDENTIFIER_TYPE_VALUE (basename);
+
+ if (TREE_CODE (type) == REFERENCE_TYPE)
+ type = TREE_TYPE (type);
+
+ /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
+ that explicit ~int is caught in the parser; this deals with typedefs
+ and template parms. */
+ if (TREE_CODE (name) == BIT_NOT_EXPR && ! is_aggr_typedef (basename, 0))
+ {
+ if (type != basetype)
+ cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
+ exp, basetype, type);
+ name = IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name, 0));
+ if (basetype != name)
+ cp_error ("qualified type `%T' does not match destructor type `%T'",
+ basetype, name);
+ return void_zero_node;
+ }
+
+ if (! is_aggr_typedef (basename, 1))
+ return error_mark_node;
+
+ if (! IS_AGGR_TYPE (type))
+ {
+ cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
+ exp, type);
+ return error_mark_node;
+ }
+
+ 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_PTR);
+ 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 (TREE_TYPE (decl) !=
+ (IDENTIFIER_CLASS_VALUE (name)
+ ? IDENTIFIER_CLASS_TYPE_VALUE (name)
+ : IDENTIFIER_TYPE_VALUE (name)))
+ {
+ cp_error
+ ("qualified type `%T' does not match destructor type `%T'",
+ TREE_TYPE (decl), name);
+ return error_mark_node;
+ }
+ if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl)))
+ return void_zero_node;
+
+ return build_delete (TREE_TYPE (decl), decl, integer_two_node,
+ LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR,
+ 0);
+ }
+
+ /* Call to a method. */
+ return build_method_call (decl, name, parms, NULL_TREE,
+ LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
+ }
+ return error_mark_node;
+}
+
+static void
+print_candidates (candidates)
+ tree candidates;
+{
+ cp_error_at ("candidates are: %D", TREE_VALUE (candidates));
+ candidates = TREE_CHAIN (candidates);
+
+ while (candidates)
+ {
+ cp_error_at (" %D", TREE_VALUE (candidates));
+ candidates = TREE_CHAIN (candidates);
+ }
+}
+
+static void
+print_n_candidates (candidates, n)
+ struct candidate *candidates;
+ int n;
+{
+ int i;
+
+ cp_error_at ("candidates are: %D", candidates[0].function);
+ for (i = 1; i < n; i++)
+ cp_error_at (" %D", candidates[i].function);
+}
+
+/* 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 of the method desired, usually an IDENTIFIER_NODE.
+
+ PARMS help to figure out what that NAME really refers to.
+
+ BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
+ down to the real instance type to use for access checking. We need this
+ information to get protected accesses correct. This parameter is used
+ by build_member_call.
+
+ 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 access_type access = access_public;
+
+ /* Range of cases for vtable optimization. */
+ enum vtable_needs { not_needed, maybe_needed, unneeded, needed };
+ enum vtable_needs need_vtbl = not_needed;
+
+ char *name_kind;
+ int ever_seen = 0;
+ tree instance_ptr = NULL_TREE;
+ int all_virtual = flag_all_virtual;
+ int static_call_context = 0;
+ tree found_fns = 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 (TREE_CODE (name) == BIT_NOT_EXPR)
+ {
+ flags |= LOOKUP_DESTRUCTOR;
+ name = TREE_OPERAND (name, 0);
+ if (parms)
+ error ("destructors take no parameters");
+ basetype = get_type_value (name);
+ if (basetype == NULL_TREE)
+ {
+ cp_error ("call to destructor for non-type `%D'", name);
+ return void_zero_node;
+ }
+ if (! TYPE_HAS_DESTRUCTOR (basetype))
+ return void_zero_node;
+ instance = default_conversion (instance);
+ 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);
+ }
+
+ {
+ char *xref_name;
+
+ /* Initialize name for error reporting. */
+ if (IDENTIFIER_OPNAME_P (name) && ! IDENTIFIER_TYPENAME_P (name))
+ {
+ char *p = operator_name_string (name);
+ xref_name = (char *)alloca (strlen (p) + 10);
+ sprintf (xref_name, "operator %s", p);
+ }
+ else if (TREE_CODE (name) == SCOPE_REF)
+ xref_name = IDENTIFIER_POINTER (TREE_OPERAND (name, 1));
+ else
+ xref_name = IDENTIFIER_POINTER (name);
+
+ GNU_xref_call (current_function_decl, xref_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_full (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
+ {
+ cp_error ("no constructor named `%T' in scope",
+ name);
+ return error_mark_node;
+ }
+ }
+
+ if (! IS_AGGR_TYPE (basetype))
+ {
+ non_aggr_error:
+ if ((flags & LOOKUP_COMPLAIN) && TREE_CODE (basetype) != ERROR_MARK)
+ cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
+ name, instance, basetype);
+
+ 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);
+
+ 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);
+ if (result)
+ return result;
+ cp_error ("exception member `%D' cannot be invoked", 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) == INDIRECT_REF
+ && TREE_CODE (TREE_OPERAND (instance, 0)) == NOP_EXPR
+ && TREE_OPERAND (TREE_OPERAND (instance, 0), 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 (! IS_AGGR_TYPE (basetype))
+ goto non_aggr_error;
+
+ if (IS_SIGNATURE_POINTER (basetype)
+ || IS_SIGNATURE_REFERENCE (basetype))
+ basetype = SIGNATURE_TYPE (basetype);
+
+ if ((IS_SIGNATURE (basetype)
+ && (instance_ptr = build_optr_ref (instance)))
+ || (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_CONSTRUCTING (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;
+ }
+ }
+
+ /* After converting `instance_ptr' above, `inst_ptr_basetype' was
+ not updated, so we use `basetype' instead. */
+ if (basetype_path == NULL_TREE
+ && IS_SIGNATURE (basetype))
+ basetype_path = TYPE_BINFO (basetype);
+ else if (basetype_path == NULL_TREE ||
+ BINFO_TYPE (basetype_path) != TYPE_MAIN_VARIANT (inst_ptr_basetype))
+ basetype_path = TYPE_BINFO (inst_ptr_basetype);
+
+ result = build_field_call (basetype_path, instance_ptr, name, parms);
+ 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_PTR);
+ }
+ else if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
+ {
+ /* This happens when called for operator new (). */
+ instance = build_indirect_ref (instance, NULL_PTR);
+ }
+
+ need_vtbl = maybe_needed;
+ }
+ }
+
+ if (TYPE_SIZE (basetype) == 0)
+ {
+ /* This is worth complaining about, I think. */
+ cp_error ("cannot lookup method in incomplete type `%T'", basetype);
+ 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_PTR);
+
+ /* 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))
+ && TREE_CODE(IDENTIFIER_TYPE_VALUE (name)) != UNINSTANTIATED_P_TYPE)
+ || 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
+ || BINFO_TYPE (basetype_path) != TYPE_MAIN_VARIANT (basetype))
+ 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)
+ || name == constructor_name_full (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));
+ bzero (candidates, (ever_seen + 1) * sizeof (struct candidate));
+ cp = candidates;
+ len = list_length (parms);
+ ever_seen = 0;
+
+ /* 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->h_len = len;
+ if (flag_ansi_overloading)
+ cp->v.ansi_harshness = (struct harshness_code *)
+ alloca ((len + 1) * sizeof (struct harshness_code));
+ else
+ cp->v.old_harshness = (unsigned short *)
+ alloca ((len + 1) * sizeof (unsigned 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;
+
+ if (flag_ansi_overloading)
+ while ((cp->h.code & EVIL_CODE) == 0)
+ {
+ /* non-standard uses: set the field to 0 to indicate
+ we are using a non-member function. */
+ cp->u.field = 0;
+ if (cp->v.ansi_harshness[len].distance == 0
+ && cp->h.code < best)
+ best = cp->h.code;
+ cp += 1;
+ }
+ else
+ 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->v.old_harshness[len] == 0
+ && cp->v.old_harshness[len] == 0
+ && cp->ellipsis == 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. */
+ basetype_path = TREE_PURPOSE (baselink);
+
+ function = TREE_VALUE (baselink);
+ if (TREE_CODE (basetype_path) == TREE_LIST)
+ basetype_path = TREE_VALUE (basetype_path);
+ basetype = BINFO_TYPE (basetype_path);
+
+ /* Cast the instance variable to the appropriate type. */
+ TREE_VALUE (parms) = convert_force (TYPE_POINTER_TO (basetype),
+ instance_ptr);
+ /* FIXME: this is the wrong place to get an error. Hopefully
+ the access-control rewrite will make this change more cleanly. */
+ if (TREE_VALUE (parms) == error_mark_node)
+ return error_mark_node;
+
+ 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++;
+ if (pass > 0)
+ found_fns = tree_cons (NULL_TREE, function, found_fns);
+
+ /* 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)
+ goto found;
+
+ if (pass > 0)
+ {
+ tree these_parms = parms;
+
+#ifdef GATHER_STATISTICS
+ n_inner_fields_searched++;
+#endif
+ cp->h_len = len;
+ if (flag_ansi_overloading)
+ cp->v.ansi_harshness = (struct harshness_code *)
+ alloca ((len + 1) * sizeof (struct harshness_code));
+ else
+ cp->v.old_harshness = (unsigned short *)
+ alloca ((len + 1) * sizeof (unsigned short));
+
+ if (DECL_STATIC_FUNCTION_P (function))
+ these_parms = TREE_CHAIN (these_parms);
+ compute_conversion_costs (function, these_parms, cp, len);
+
+ if (!flag_ansi_overloading)
+ cp->b_or_d += b_or_d;
+
+ if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE) == 0)
+ || (!flag_ansi_overloading && cp->evil == 0))
+ {
+ cp->u.field = function;
+ cp->function = function;
+ cp->basetypes = basetype_path;
+
+ /* No "two-level" conversions. */
+ if (flags & LOOKUP_NO_CONVERSION
+ && ((flag_ansi_overloading
+ && (cp->h.code & USER_CODE))
+ || (!flag_ansi_overloading
+ && 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)
+ && ((flag_ansi_overloading
+ && cp->v.ansi_harshness[len].distance == 0
+ && cp->h.code < best)
+ || (!flag_ansi_overloading
+ && cp->v.old_harshness[len] == 0
+ && CONST_HARSHNESS (cp->v.old_harshness[0]) == 0
+ && cp->ellipsis == 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;
+ /* Don't grab functions from base classes. lookup_fnfield will
+ do the work to get us down into the right place. */
+ baselink = NULL_TREE;
+ }
+ if (pass == 0)
+ {
+ tree igv = IDENTIFIER_GLOBAL_VALUE (name);
+
+ /* No exact match could be found. Now try to find match
+ using default conversions. */
+ if ((flags & LOOKUP_GLOBAL) && igv)
+ {
+ if (TREE_CODE (igv) == FUNCTION_DECL)
+ ever_seen += 1;
+ else if (TREE_CODE (igv) == TREE_LIST)
+ ever_seen += count_functions (igv);
+ }
+
+ if (ever_seen == 0)
+ {
+ if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
+ == LOOKUP_SPECULATIVELY)
+ return NULL_TREE;
+
+ TREE_CHAIN (last) = void_list_node;
+ if (flags & LOOKUP_GLOBAL)
+ cp_error ("no global or member function `%D(%A)' defined",
+ name, parmtypes);
+ else
+ cp_error ("no member function `%T::%D(%A)' defined",
+ save_basetype, name, TREE_CHAIN (parmtypes));
+ 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)
+ {
+ cp_error ("ambiguous type conversion requested for %s `%D'",
+ name_kind, name);
+ return error_mark_node;
+ }
+ if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE))
+ || (!flag_ansi_overloading && cp->evil))
+ return error_mark_node;
+ }
+ else if ((flag_ansi_overloading && (cp[-1].h.code & EVIL_CODE))
+ || (!flag_ansi_overloading && cp[-1].evil == 2))
+ {
+ cp_error ("ambiguous type conversion requested for %s `%D'",
+ name_kind, 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;
+ basetype_path = cp->basetypes;
+ if (! DECL_STATIC_FUNCTION_P (function))
+ TREE_VALUE (parms) = cp->arg;
+ goto found_and_maybe_warn;
+ }
+
+ if ((flags & ~LOOKUP_GLOBAL) & (LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY))
+ {
+ 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 (flags & LOOKUP_SPECULATIVELY)
+ return NULL_TREE;
+ if (static_call_context
+ && TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
+ cp_error ("object missing in call to `%D'", cp->function);
+ else if (ever_seen > 1)
+ {
+ TREE_CHAIN (last) = void_list_node;
+ cp_error ("no matching function for call to `%T::%D (%A)'",
+ TREE_TYPE (TREE_TYPE (instance_ptr)),
+ name, TREE_CHAIN (parmtypes));
+ TREE_CHAIN (last) = NULL_TREE;
+ print_candidates (found_fns);
+ }
+ else
+ report_type_mismatch (cp, parms, name_kind);
+ return error_mark_node;
+ }
+
+ if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
+ == LOOKUP_COMPLAIN)
+ {
+ cp_error ("%T has no method named %D", save_basetype, name);
+ return error_mark_node;
+ }
+ return NULL_TREE;
+ }
+ continue;
+
+ found_and_maybe_warn:
+ if ((flag_ansi_overloading
+ && (cp->v.ansi_harshness[0].code & CONST_CODE))
+ || (!flag_ansi_overloading
+ && CONST_HARSHNESS (cp->v.old_harshness[0])))
+ {
+ if (flags & LOOKUP_COMPLAIN)
+ {
+ cp_error_at ("non-const member function `%D'", cp->function);
+ error ("called for const object at this point in file");
+ }
+ /* Not good enough for a match. */
+ else
+ return error_mark_node;
+ }
+ goto found;
+ }
+ /* Silently return error_mark_node. */
+ return error_mark_node;
+
+ found:
+ if (flags & LOOKUP_PROTECT)
+ access = compute_access (basetype_path, function);
+
+ if (access == access_private)
+ {
+ if (flags & LOOKUP_COMPLAIN)
+ {
+ cp_error_at ("%s `%+#D' is %s", name_kind, function,
+ TREE_PRIVATE (function) ? "private"
+ : "from private base class");
+ error ("within this context");
+ }
+ return error_mark_node;
+ }
+ else if (access == access_protected)
+ {
+ if (flags & LOOKUP_COMPLAIN)
+ {
+ cp_error_at ("%s `%+#D' %s", name_kind, function,
+ TREE_PROTECTED (function) ? "is protected"
+ : "has protected accessibility");
+ error ("within this context");
+ }
+ return error_mark_node;
+ }
+
+ /* From here on down, BASETYPE is the type that INSTANCE_PTR's
+ type (if it exists) is a pointer to. */
+
+ if (IS_SIGNATURE (basetype) && static_call_context)
+ {
+ cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
+ basetype, name);
+ return error_mark_node;
+ }
+ else if (IS_SIGNATURE (basetype))
+ return build_signature_method_call (basetype, instance, function, parms);
+
+ 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;
+ }
+ }
+ /* Only allow a static member function to call another static member
+ function. */
+ else if (DECL_LANG_SPECIFIC (function)
+ && !DECL_STATIC_FUNCTION_P (function))
+ {
+ cp_error ("cannot call member function `%D' without object",
+ function);
+ 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_PTR);
+ }
+ 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)))
+ {
+ /* Since we can't have inheritance with a union, doing get_binfo
+ on it won't work. We do all the convert_pointer_to_real
+ stuff to handle MI correctly...for unions, that's not
+ an issue, so we must short-circuit that extra work here. */
+ tree tmp = TREE_TYPE (TREE_TYPE (TREE_VALUE (parms)));
+ if (tmp != NULL_TREE && TREE_CODE (tmp) == UNION_TYPE)
+ instance_ptr = TREE_VALUE (parms);
+ else
+ {
+ tree binfo = get_binfo (basetype,
+ TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))),
+ 0);
+ instance_ptr = convert_pointer_to_real (binfo, TREE_VALUE (parms));
+ }
+ instance_ptr
+ = convert_pointer_to (build_type_variant (basetype,
+ constp, volatilep),
+ instance_ptr);
+
+ if (TREE_CODE (instance_ptr) == COND_EXPR)
+ {
+ instance_ptr = save_expr (instance_ptr);
+ instance = build_indirect_ref (instance_ptr, NULL_PTR);
+ }
+ 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_PTR);
+ }
+ 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))
+ && (may_be_remote (basetype) || instance != C_C_D))
+ {
+ 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)));
+
+ {
+ int is_constructor;
+
+ if (TREE_CODE (function) == FUNCTION_DECL)
+ {
+ is_constructor = DECL_CONSTRUCTOR_P (function);
+ 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
+ {
+ is_constructor = 0;
+ 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));
+ TREE_HAS_CONSTRUCTOR (result) = is_constructor;
+ 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, flags, final_cp, buildxxx)
+ tree fnname, parms;
+ int flags;
+ 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)
+ {
+ if (flag_ansi_overloading)
+ {
+ final_cp[0].h.code = 0;
+ final_cp[0].h.distance = 0;
+ final_cp[0].function = 0;
+ /* end marker. */
+ final_cp[1].h.code = EVIL_CODE;
+ }
+ else
+ {
+ 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)
+ {
+ if (flag_ansi_overloading)
+ final_cp->h.code = EVIL_CODE;
+ else
+ 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;
+
+ if (! flag_ansi_overloading)
+ {
+ /* This is a speed improvement that ends up not working properly in
+ the situation of fns with and without default parameters. I turned
+ this off in the new method so it'll go through the argument matching
+ code to properly diagnose a match/failure. (bpk) */
+ 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 (flags & LOOKUP_SPECULATIVELY)
+ return NULL_TREE;
+ if (flags & LOOKUP_COMPLAIN)
+ error ("only member functions apply");
+ if (final_cp)
+ {
+ if (flag_ansi_overloading)
+ final_cp->h.code = EVIL_CODE;
+ else
+ final_cp->evil = 1;
+ }
+ return error_mark_node;
+ }
+
+ if (! TREE_OVERLOADED (fnname))
+ {
+ 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_real (functions, parms, 1, flags);
+ }
+
+ if (TREE_CODE (functions) == TREE_LIST
+ && TREE_VALUE (functions) == NULL_TREE)
+ {
+ if (flags & LOOKUP_SPECULATIVELY)
+ return NULL_TREE;
+
+ if (flags & LOOKUP_COMPLAIN)
+ cp_error ("function `%D' declared overloaded, but no instances of that function declared",
+ TREE_PURPOSE (functions));
+ if (final_cp)
+ {
+ if (flag_ansi_overloading)
+ final_cp->h.code = EVIL_CODE;
+ else
+ final_cp->evil = 1;
+ }
+ return error_mark_node;
+ }
+
+ length = count_functions (functions);
+
+ if (final_cp)
+ candidates = final_cp;
+ else
+ {
+ candidates
+ = (struct candidate *)alloca ((length+1) * sizeof (struct candidate));
+ bzero (candidates, (length + 1) * sizeof (struct candidate));
+ }
+
+ cp = candidates;
+
+ my_friendly_assert (is_overloaded_fn (functions), 169);
+
+ functions = get_first_fn (functions);
+
+ /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */
+ for (outer = functions; outer; outer = DECL_CHAIN (outer))
+ {
+ int template_cost = 0;
+ function = 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)
+ cp_error_at
+ ("enumeral value `%D' conflicts with function of same name",
+ function);
+ else if (code == VAR_DECL)
+ {
+ if (TREE_STATIC (function))
+ cp_error_at
+ ("variable `%D' conflicts with function of same name",
+ function);
+ else
+ cp_error_at
+ ("constant field `%D' conflicts with function of same name",
+ function);
+ }
+ 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, 0);
+ if (i == 0)
+ {
+ struct candidate *cp2;
+
+ function = instantiate_template (function, targs);
+ /* Now check that the template instantiated for this is not
+ the same as a function that's in the list due to some
+ previous instantiation. */
+ cp2 = candidates;
+ while (cp2 != cp)
+ if (cp2->function == function)
+ break;
+ else
+ cp2 += 1;
+ if (cp2->function == function)
+ continue;
+ }
+ }
+
+ if (TREE_CODE (function) == TEMPLATE_DECL)
+ {
+ /* Unconverted template -- failed match. */
+ cp->function = function;
+ cp->u.bad_arg = -4;
+ if (flag_ansi_overloading)
+ cp->h.code = EVIL_CODE;
+ else
+ cp->evil = 1;
+ }
+ else
+ {
+ function = DECL_MAIN_VARIANT (function);
+
+ /* Can't use alloca here, since result might be
+ passed to calling function. */
+ cp->h_len = parmlength;
+ if (flag_ansi_overloading)
+ cp->v.ansi_harshness = (struct harshness_code *)
+ oballoc ((parmlength + 1) * sizeof (struct harshness_code));
+ else
+ cp->v.old_harshness = (unsigned short *)
+ oballoc ((parmlength + 1) * sizeof (unsigned short));
+
+ compute_conversion_costs (function, parms, cp, parmlength);
+
+ if (flag_ansi_overloading)
+ /* Make sure this is clear as well. */
+ cp->h.int_penalty += template_cost;
+ else
+ /* Should really add another field... */
+ cp->easy = cp->easy * 128 + template_cost;
+
+ /* It seemed easier to have both if stmts in here, rather
+ than excluding the hell out of it with flag_ansi_overloading
+ everywhere. (bpk) */
+ if (flag_ansi_overloading)
+ {
+ if ((cp[0].h.code & EVIL_CODE) == 0)
+ {
+ cp[1].h.code = EVIL_CODE;
+
+ /* int_penalty is set by convert_harshness_ansi for cases
+ where we need to know about any penalties that would
+ otherwise make a TRIVIAL_CODE pass. */
+ if (final_cp
+ && template_cost == 0
+ && cp[0].h.code <= TRIVIAL_CODE
+ && cp[0].h.int_penalty == 0)
+ {
+ final_cp[0].h = cp[0].h;
+ return function;
+ }
+ cp++;
+ }
+ }
+ else
+ {
+ 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. */
+ if (flag_ansi_overloading)
+ cp[0].h.code = EVIL_CODE;
+ else
+ 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 (flags & LOOKUP_COMPLAIN)
+ {
+ cp_error ("call of overloaded `%D' is ambiguous", fnname);
+ print_n_candidates (candidates, cp - candidates);
+ }
+ return error_mark_node;
+ }
+ else
+ rval = best_cp->function;
+ }
+ else
+ {
+ cp -= 1;
+ if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE))
+ || (!flag_ansi_overloading && cp->evil > 1))
+ {
+ if (flags & LOOKUP_COMPLAIN)
+ error ("type conversion ambiguous");
+ }
+ else
+ rval = cp->function;
+ }
+
+ if (final_cp)
+ return rval;
+
+ return buildxxx ? build_function_call_real (rval, parms, 0, flags)
+ : build_function_call_real (rval, parms, 1, flags);
+ }
+
+ if (flags & LOOKUP_SPECULATIVELY)
+ return NULL_TREE;
+
+ if (flags & LOOKUP_COMPLAIN)
+ report_type_mismatch (cp, parms, "function",
+ decl_as_string (cp->function, 1));
+
+ return error_mark_node;
+}
+
+tree
+build_overload_call (fnname, parms, flags, final_cp)
+ tree fnname, parms;
+ int flags;
+ struct candidate *final_cp;
+{
+ return build_overload_call_real (fnname, parms, flags, final_cp, 0);
+}
+
+tree
+build_overload_call_maybe (fnname, parms, flags, final_cp)
+ tree fnname, parms;
+ int flags;
+ struct candidate *final_cp;
+{
+ return build_overload_call_real (fnname, parms, flags, final_cp, 1);
+}
--- /dev/null
+/* Functions related to building classes and their related objects.
+ Copyright (C) 1987, 1992, 1993, 1994 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 struct obstack permanent_obstack;
+
+/* This is how we tell when two virtual member functions are really the
+ same. */
+#define SAME_FN(FN1DECL, FN2DECL) (DECL_ASSEMBLER_NAME (FN1DECL) == DECL_ASSEMBLER_NAME (FN2DECL))
+
+extern void set_class_shadows PROTO ((tree));
+
+/* 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 */
+tree previous_class_type; /* _TYPE: the previous type that was a class */
+tree previous_class_values; /* TREE_LIST: copy of the class_shadowed list
+ when leaving an outermost class scope. */
+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);
+}
+
+/* Is the type of the EXPR, the complete type of the object?
+ If we are going to be wrong, we must be conservative, and return 0. */
+int
+complete_type_p (expr)
+ tree expr;
+{
+ tree type = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
+ while (1)
+ {
+ switch (TREE_CODE (expr))
+ {
+ case SAVE_EXPR:
+ case INDIRECT_REF:
+ case ADDR_EXPR:
+ case NOP_EXPR:
+ case CONVERT_EXPR:
+ expr = TREE_OPERAND (expr, 0);
+ continue;
+
+ case CALL_EXPR:
+ if (! TREE_HAS_CONSTRUCTOR (expr))
+ break;
+ /* fall through... */
+ case VAR_DECL:
+ case FIELD_DECL:
+ if (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
+ && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (expr)))
+ && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
+ return 1;
+ /* fall through... */
+ case TARGET_EXPR:
+ case PARM_DECL:
+ if (IS_AGGR_TYPE (TREE_TYPE (expr))
+ && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
+ return 1;
+ /* fall through... */
+ case PLUS_EXPR:
+ default:
+ break;
+ }
+ break;
+ }
+ return 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;
+
+ /* We need additional logic to convert back to the unconverted type
+ (the static type of the complete object), and then convert back
+ to the type we want. Until that is done, or until we can
+ recognize when that is, we cannot do the short cut logic. (mrs) */
+ /* Do this, until we can undo any previous convertions. See net35.C
+ for a testcase. */
+ fixed_type_p = complete_type_p (expr);
+
+ 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;
+
+ /* We already check for ambiguous things in the caller, just
+ find a path. */
+ if (last)
+ {
+ tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (nonnull_expr))), 0);
+ nonnull_expr = convert_pointer_to_real (binfo, nonnull_expr);
+ }
+ ind = build_indirect_ref (nonnull_expr, NULL_PTR);
+ 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
+ {
+ cp_error ("cannot cast up from virtual baseclass `%T'",
+ last_virtual);
+ 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 (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;
+
+/* 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;
+{
+ extern int flag_huge_objects;
+ 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 (delta_type_node))
+ < TREE_INT_CST_LOW (delta))
+ || (TREE_INT_CST_LOW (delta)
+ < TREE_INT_CST_LOW (TYPE_MIN_VALUE (delta_type_node))))
+ if (flag_huge_objects)
+ sorry ("object size exceeds built-in limit for virtual function table implementation");
+ else
+ sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
+
+ 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, idx)
+ tree *ptr_to_instptr, instance;
+ tree idx;
+{
+ 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_PTR);
+ 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))
+ && !IS_SIGNATURE_POINTER (TREE_TYPE (instance))
+ && !IS_SIGNATURE_REFERENCE (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_PTR);
+ }
+ assemble_external (vtbl);
+ aref = build_array_ref (vtbl, idx);
+
+ /* Save the intermediate result in a SAVE_EXPR so we don't have to
+ compute each component of the virtual function pointer twice. */
+ 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 (ptrdiff_type_node,
+ build_component_ref (aref, delta_identifier, 0, 0)));
+ return build_component_ref (aref, pfn_identifier, 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_KNOWN (type))
+ {
+ 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++) ;
+#if 0
+ /* We don't take off the numbers; prepare_fresh_vtable uses the
+ DECL_ASSEMBLER_NAME for the type, which includes the number
+ in `3foo'. If we were to pull them off here, we'd end up with
+ something like `_vt.foo.3bar', instead of a uniform definition. */
+ while (ptr[i] >= '0' && ptr[i] <= '9')
+ i += 1;
+#endif
+ 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;
+#ifndef WRITABLE_VTABLES
+ /* Make them READONLY by default. (mrs) */
+ TREE_READONLY (decl) = 1;
+#endif
+ /* At one time the vtable info was grabbed 2 words at a time. This
+ fails on sparc unless you have 8-byte alignment. (tiemann) */
+ DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
+ DECL_ALIGN (decl));
+
+ /* Why is this conditional? (mrs) */
+ 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;
+}
+
+/* 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.
+ */
+static 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;
+}
+
+/* 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;
+#ifndef WRITABLE_VTABLES
+ /* Make them READONLY by default. (mrs) */
+ TREE_READONLY (new_decl) = 1;
+#endif
+ 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.
+
+ Also update DECL_VINDEX (FNDECL). */
+
+static void
+modify_vtable_entry (old_entry_in_list, new_entry, fndecl)
+ tree old_entry_in_list, new_entry, fndecl;
+{
+ tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (old_entry_in_list));
+ tree vindex;
+
+#ifdef NOTQUITE
+ cp_warning ("replaced %D with %D", DECL_ASSEMBLER_NAME (TREE_OPERAND (base_pfn, 0)), DECL_ASSEMBLER_NAME (fndecl));
+#endif
+ /* 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);
+
+ 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;
+ }
+ }
+ }
+}
+
+/* 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);
+ }
+ /* Make sure that:
+
+ RRB
+ |
+ RL RR
+ \ /
+ L R
+ \ /
+ C
+
+ returns 0. VF_BASETYPE_VALUE is RL, base_context is RRB, type is C,
+ and the vfield we are checking is R. */
+ if (VF_BASETYPE_VALUE (vfields)
+ && get_base_distance (base_context, VF_BASETYPE_VALUE (vfields), 0, &path) == -1
+ && get_base_distance (VF_BASETYPE_VALUE (vfields), base_context, 0, &path) == -1)
+ return 0;
+ return 1;
+ }
+ return 0;
+}
+
+static void modify_vtable_entries ();
+
+/* Access the virtual function table entry i. VIRTUALS is the virtual
+ function table's initializer. */
+static tree
+get_vtable_entry_n (virtuals, i)
+ tree virtuals;
+ unsigned HOST_WIDE_INT i;
+{
+ while (i > 0)
+ {
+ virtuals = TREE_CHAIN (virtuals);
+ i -= 1;
+ }
+ return virtuals;
+}
+
+#if 0
+/* Find the vfield (in the CLASSTYPE_VFIELDS chain) of the given binfo. */
+static tree
+find_associated_vfield (binfo, t)
+ tree t, binfo;
+{
+ tree vfields;
+ tree save_vfields = 0;
+ for (vfields = CLASSTYPE_VFIELDS (t); vfields; vfields = TREE_CHAIN (vfields))
+ {
+ if (VF_BINFO_VALUE (vfields) == binfo)
+ return vfields;
+ }
+ for (vfields = CLASSTYPE_VFIELDS (t); vfields; vfields = TREE_CHAIN (vfields))
+ {
+ tree path;
+ get_base_distance (VF_BASETYPE_VALUE (vfields), t, 0, &path);
+ while (path)
+ {
+ if (path == binfo)
+ return vfields;
+ path = BINFO_INHERITANCE_CHAIN (path);
+ }
+ }
+ /* This is from a virtual base class's vtable, hopefully. */
+ return 0;
+}
+#endif
+
+
+/* Returns != 0 is the BINFO is the normal one for the main vfield, 0
+ otherwise. We don't have to worry about the finding BINFO in
+ CLASSTYPE_VBASECLASSES, if it is virtual, as we never inherit
+ vtables from virtual base classes. */
+static int
+is_normal (binfo, t)
+ tree t, binfo;
+{
+ tree binfo2;
+ int i = CLASSTYPE_VFIELD_PARENT (t);
+ if (i != -1)
+ {
+ tree base_binfo = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (t)), i);
+ if (base_binfo == binfo)
+ return 1;
+ }
+ return 0;
+}
+
+/* Modify virtual function tables in lattice topped by T to place
+ FNDECL in tables which previously held BASE_FNDECL. This marches
+ through the vtables directly, looking for exact mactes to
+ modify. */
+static void
+modify_other_vtable_entries (t, binfo, fndecl, base_fndecl, pfn)
+ tree t, binfo;
+ tree fndecl, base_fndecl, pfn;
+{
+ tree vfields, virtuals;
+ tree binfos;
+ int i, n_baselinks;
+ unsigned HOST_WIDE_INT n;
+
+ virtuals = BINFO_VIRTUALS (binfo);
+ n = 0;
+ while (virtuals)
+ {
+ tree current_fndecl = TREE_VALUE (virtuals);
+ tree *binfo2_ptr;
+ current_fndecl = FNADDR_FROM_VTABLE_ENTRY (current_fndecl);
+ current_fndecl = TREE_OPERAND (current_fndecl, 0);
+ if (current_fndecl && SAME_FN (current_fndecl, base_fndecl))
+ {
+ /* Most of the below was copied from
+ modify_vtable_entries (t, fndecl, base_fndecl, pfn); */
+ tree base_offset, offset;
+ tree context = DECL_CLASS_CONTEXT (fndecl);
+ tree vfield = CLASSTYPE_VFIELD (t);
+ int normal = 1;
+ tree binfo2, this_offset;
+ tree base, path;
+
+ 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 = get_binfo (context, t, 0);
+ offset = BINFO_OFFSET (binfo);
+ }
+ }
+
+ /* Get the path starting from the deepest base class CONTEXT
+ of T (i.e., first defn of BASE_FNDECL). */
+ get_base_distance (binfo, t, 0, &path);
+ binfo2_ptr = 0;
+
+ /* 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;
+ binfo2 = binfo_member (BINFO_TYPE (base), CLASSTYPE_VBASECLASSES (t));
+ /* This should never have TREE_USED set. */
+ binfo2_ptr = 0;
+ 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;
+ binfo2 = base;
+ binfo2_ptr = 0;
+ break;
+ }
+ path = BINFO_INHERITANCE_CHAIN (path);
+ binfo2_ptr = &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 (binfo2);
+ this_offset = size_binop (MINUS_EXPR, offset, base_offset);
+
+ /* Make sure we can modify the derived association with immunity. */
+ if (TREE_USED (binfo2)) {
+ my_friendly_assert (*binfo2_ptr == binfo2, 999);
+ *binfo2_ptr = copy_binfo (binfo2);
+ }
+
+#if 0
+ vfields = find_associated_vfield (binfo2, 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 = (vfields && 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));
+#else
+ normal = is_normal (binfo2, t);
+#endif
+
+ 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. */
+ binfo2 = TYPE_BINFO (t);
+ if (! BINFO_NEW_VTABLE_MARKED (binfo2))
+ 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 (binfo2))
+ prepare_fresh_vtable (binfo2, base, t);
+ }
+
+#ifdef NOTQUITE
+ cp_warning ("in %D", DECL_NAME (BINFO_VTABLE (binfo2)));
+#endif
+ modify_vtable_entry (get_vtable_entry_n (BINFO_VIRTUALS (binfo2), n),
+ build_vtable_entry (this_offset, pfn),
+ fndecl);
+ } else if (current_fndecl && DECL_NAME (current_fndecl) == DECL_NAME (base_fndecl))
+ {
+#ifdef NOTQUITE
+ cp_warning ("%D not replaced (looking for %D) in %D", DECL_ASSEMBLER_NAME (current_fndecl), DECL_ASSEMBLER_NAME (base_fndecl), DECL_NAME (BINFO_VTABLE (binfo)));
+#endif
+ }
+ ++n;
+ virtuals = TREE_CHAIN (virtuals);
+ }
+ binfos = BINFO_BASETYPES (binfo);
+ n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
+ for (i = 0; i < n_baselinks; i++)
+ {
+ tree base_binfo = TREE_VEC_ELT (binfos, i);
+ /* Don't modify virtual bases, as we share them down this way. */
+ /* We hope that other places will get things down this direction. */
+ if (TREE_VIA_VIRTUAL (base_binfo))
+ continue;
+ modify_other_vtable_entries (t, base_binfo, fndecl, base_fndecl, pfn);
+ }
+}
+
+/* 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_CONTEXT (base_fndecl);
+ tree context = DECL_CLASS_CONTEXT (fndecl);
+ tree vfield = CLASSTYPE_VFIELD (t);
+ tree vfields, vbases;
+ tree saved_pfn;
+
+#ifdef NOTQUITE
+ cp_warning ("modifing all %D into %D for %T", base_fndecl, fndecl, t);
+ if (DECL_CONTEXT (fndecl) != DECL_CONTEXT (base_fndecl))
+ {
+ cp_warning ("switching contexts from %T to %T for %x",
+ DECL_CONTEXT (fndecl),
+ DECL_CONTEXT (base_fndecl), fndecl);
+ cp_warning ("base was %D, new is %D", DECL_ASSEMBLER_NAME (base_fndecl),
+ DECL_ASSEMBLER_NAME(fndecl));
+ }
+#endif
+ 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 = get_binfo (context, t, 0);
+ 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;
+
+ if (!related_vslot (base_fndecl, vfields, t))
+ continue;
+
+ /* Find the right base class for this derived class, call it BASE. */
+ base = VF_BASETYPE_VALUE (vfields);
+
+ /* Get the path starting from the deepest base class CONTEXT
+ of T (i.e., first defn of BASE_FNDECL). */
+ get_base_distance (DECL_CONTEXT (base_fndecl), 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);
+ }
+
+ saved_pfn = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (get_vtable_entry (BINFO_VIRTUALS (binfo), base_fndecl))), 0);
+#ifdef NOTQUITE
+ cp_warning ("in %D", DECL_NAME (BINFO_VTABLE (binfo)));
+#endif
+ /* The this_offset can be wrong, if we try and modify an entry
+ that had been modified once before. */
+ if (! SAME_FN (saved_pfn, fndecl))
+ {
+ modify_vtable_entry (get_vtable_entry (BINFO_VIRTUALS (binfo), base_fndecl),
+ build_vtable_entry (this_offset, pfn),
+ fndecl);
+ modify_other_vtable_entries (t, TYPE_BINFO (t), fndecl, saved_pfn, pfn);
+ }
+ }
+ 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);
+ }
+ saved_pfn = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (get_vtable_entry (BINFO_VIRTUALS (vbases), base_fndecl))), 0);
+#ifdef NOTQUITE
+ cp_warning ("in %D", DECL_NAME (BINFO_VTABLE (vbases)));
+#endif
+ /* The this_offset can be wrong, if we try and modify an entry
+ that had been modified once before. */
+ if (! SAME_FN (saved_pfn, fndecl))
+ {
+ modify_vtable_entry (get_vtable_entry (BINFO_VIRTUALS (vbases),
+ base_fndecl),
+ build_vtable_entry (this_offset, pfn),
+ fndecl);
+ modify_other_vtable_entries (t, TYPE_BINFO (t), fndecl, saved_pfn, pfn);
+ }
+ 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 (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;
+}
+\f
+/* 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)
+ cp_error_at ("duplicate enum value `%D'", x);
+ else if (TREE_CODE (field) == CONST_DECL
+ || TREE_CODE (x) == CONST_DECL)
+ cp_error_at ("duplicate field `%D' (as enum and non-enum)",
+ x);
+ else if (TREE_CODE (field) == TYPE_DECL
+ && TREE_CODE (x) == TYPE_DECL)
+ cp_error_at ("duplicate class scope type `%D'", x);
+ else if (TREE_CODE (field) == TYPE_DECL
+ || TREE_CODE (x) == TYPE_DECL)
+ cp_error_at ("duplicate field `%D' (as type and non-type)",
+ x);
+ else
+ cp_error_at ("duplicate member `%D'", x);
+ 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 access of FDECL to ACCESS in T.
+ Return 1 if change was legit, otherwise return 0. */
+static int
+alter_access (t, fdecl, access)
+ tree t;
+ tree fdecl;
+ enum access_type access;
+{
+ tree elem = purpose_member (t, DECL_ACCESS (fdecl));
+ if (elem && TREE_VALUE (elem) != (tree)access)
+ {
+ if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
+ {
+ cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
+ }
+ else
+ error ("conflicting access specifications for field `%s', ignored",
+ IDENTIFIER_POINTER (DECL_NAME (fdecl)));
+ }
+ else if (TREE_PRIVATE (fdecl) && access != access_private)
+ cp_error_at ("cannot make private `%D' non-private", fdecl);
+ else if (TREE_PROTECTED (fdecl))
+ {
+ if (access == access_public)
+ cp_error_at ("cannot make protected `%D' public", fdecl);
+ goto alter;
+ }
+ /* 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)
+ && (access == access_private
+ || access == access_protected))
+ cp_error_at ("cannot reduce access of public member `%D'", fdecl);
+ else if (elem == NULL_TREE)
+ {
+ alter:
+ DECL_ACCESS (fdecl) = tree_cons (t, (tree)access,
+ DECL_ACCESS (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 basetype = VF_NORMAL_VALUE (vfields)
+ ? TYPE_MAIN_VARIANT (VF_NORMAL_VALUE (vfields))
+ : VF_BASETYPE_VALUE (vfields);
+
+ tree base_binfo = get_binfo (basetype, for_type, 0);
+ /* Punt until this is implemented. */
+ if (1 /* BINFO_MODIFIED (base_binfo) */)
+ {
+ 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;
+}
+\f
+struct base_info
+{
+ int has_virtual;
+ int max_has_virtual;
+ int n_ancestors;
+ tree vfield;
+ tree vfields;
+ char cant_have_default_ctor;
+ char cant_have_const_ctor;
+ char cant_synth_copy_ctor;
+ char cant_synth_asn_ref;
+ char no_const_asn_ref;
+ 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 -1 if no such base class.
+
+ Note that at this point TYPE_BINFO (t) != t_binfo. */
+
+static int
+finish_base_struct (t, b, t_binfo)
+ tree t;
+ struct base_info *b;
+ tree t_binfo;
+{
+ tree binfos = BINFO_BASETYPES (t_binfo);
+ 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_HAS_INIT_REF (basetype)
+ && !TYPE_HAS_CONST_INIT_REF (basetype))
+ b->cant_have_const_ctor = 1;
+ if (! TYPE_HAS_INIT_REF (basetype)
+ || (TYPE_HAS_NONPUBLIC_CTOR (basetype) == 2
+ && ! is_friend_type (t, basetype)))
+ b->cant_synth_copy_ctor = 1;
+
+ if (TYPE_HAS_CONSTRUCTOR (basetype)
+ && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
+ {
+ b->cant_have_default_ctor = 1;
+ if (! TYPE_HAS_CONSTRUCTOR (t))
+ {
+ cp_pedwarn ("base `%T' with only non-default constructor",
+ basetype);
+ cp_pedwarn ("in class without a constructor");
+ }
+ }
+
+ if (TYPE_HAS_ASSIGN_REF (basetype)
+ && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
+ b->no_const_asn_ref = 1;
+ if (! TYPE_HAS_ASSIGN_REF (basetype)
+ || (TYPE_HAS_NONPUBLIC_ASSIGN_REF (basetype) == 2
+ && ! is_friend_type (t, basetype)))
+ b->cant_synth_asn_ref = 1;
+
+ b->n_ancestors += CLASSTYPE_N_SUPERCLASSES (basetype);
+ TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
+ TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (basetype);
+ TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
+ TYPE_HAS_COMPLEX_INIT_REF (t) |= (TYPE_HAS_COMPLEX_INIT_REF (basetype)
+ || TYPE_NEEDS_CONSTRUCTING (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)
+ {
+ tree vfields;
+ first_vfn_base_index = i;
+
+ b->has_virtual = CLASSTYPE_VSIZE (basetype);
+ b->vfield = CLASSTYPE_VFIELD (basetype);
+ b->vfields = copy_list (CLASSTYPE_VFIELDS (basetype));
+ vfields = b->vfields;
+ while (vfields)
+ {
+ if (VF_BINFO_VALUE (vfields) == NULL_TREE
+ || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
+ {
+ tree value = VF_BASETYPE_VALUE (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);
+ }
+ 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;
+ /* When we install the first one, set the VF_NORMAL_VALUE
+ to be the current class, as this it is the most derived
+ class. Hopefully, this is not set to something else
+ later. (mrs) */
+ vfields = b->vfields;
+ while (vfields)
+ {
+ if (DECL_NAME (CLASSTYPE_VFIELD (t))
+ == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
+ {
+ VF_NORMAL_VALUE (vfields) = t;
+ /* There should only be one of them! And it should
+ always be found, if we get into here. (mrs) */
+ break;
+ }
+ vfields = TREE_CHAIN (vfields);
+ }
+ }
+ }
+ }
+ }
+
+ /* Must come after offsets are fixed for all bases. */
+ for (i = 0; i < n_baseclasses; i++)
+ {
+ tree base_binfo = TREE_VEC_ELT (binfos, i);
+ tree basetype = BINFO_TYPE (base_binfo);
+
+ if (get_base_distance (basetype, t_binfo, 0, (tree*)0) == -2)
+ {
+ cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
+ basetype, t);
+ b->cant_synth_asn_ref = 1;
+ b->cant_synth_copy_ctor = 1;
+ }
+ }
+
+ {
+ 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));
+}
+\f
+/* 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_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. */
+ tree binfo = TYPE_BINFO (t);
+ tree binfos = BINFO_BASETYPES (binfo);
+ tree basetype;
+
+ 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;
+ }
+ }
+
+ /* 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;
+
+ /* Clear out this flag.
+
+ @@ Doug may figure out how to break
+ @@ this with nested classes and friends. */
+ DECL_IN_AGGR_P (fn_fields) = 0;
+
+ /* Note here that a copy ctor is private, so we don't dare generate
+ a default copy constructor for a class that has a member
+ of this type without making sure they have access to it. */
+ if (fn_name == name)
+ {
+ tree parmtypes = FUNCTION_ARG_CHAIN (fn_fields);
+ tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
+
+ if (TREE_CODE (parmtype) == REFERENCE_TYPE
+ && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == t)
+ {
+ if (TREE_CHAIN (parmtypes) == NULL_TREE
+ || TREE_CHAIN (parmtypes) == void_list_node
+ || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
+ {
+ if (TREE_PROTECTED (fn_fields))
+ TYPE_HAS_NONPUBLIC_CTOR (t) = 1;
+ else if (TREE_PRIVATE (fn_fields))
+ TYPE_HAS_NONPUBLIC_CTOR (t) = 2;
+ }
+ }
+ }
+ else if (fn_name == ansi_opname[(int) MODIFY_EXPR])
+ {
+ tree parmtype = TREE_VALUE (FUNCTION_ARG_CHAIN (fn_fields));
+
+ if (TREE_CODE (parmtype) == REFERENCE_TYPE
+ && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == t)
+ {
+ if (TREE_PROTECTED (fn_fields))
+ TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 1;
+ else if (TREE_PRIVATE (fn_fields))
+ TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 2;
+ }
+ }
+
+ /* 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 */
+ cp_error_at ("`%D' overloaded", fn_fields);
+ cp_error_at ("previous declaration as `%D' here", x);
+ }
+ 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)))
+ cp_error_at ("ambiguous method `%#D' in structure",
+ 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)
+ cp_warning ("all member functions in class `%T' are private", 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
+ && warn_ctor_dtor_privacy)
+ warning ("class `%s' only defines a private destructor and has no friends",
+ TYPE_NAME_STRING (t));
+ 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;
+{
+ cp_error ("redefinition of `%#T'", t);
+
+ /* 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;
+ SET_CLASSTYPE_INTERFACE_UNKNOWN_X (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 access
+ 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;
+ extern tree EHS_type;
+
+ int old;
+ int round_up_size = 1;
+
+ enum tree_code code = TREE_CODE (t);
+ register tree x, last_x, method_vec;
+ int needs_virtual_dtor;
+ tree name = TYPE_NAME (t), fields, fn_fields, tail;
+ enum access_type access;
+ 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 cant_have_default_ctor;
+ int cant_have_const_ctor;
+ int cant_synth_copy_ctor;
+ int cant_synth_asn_ref;
+ int no_const_asn_ref;
+
+ /* 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;
+ int const_sans_init = 0;
+ int ref_sans_init = 0;
+ int do_mem_init = 0;
+ int nonprivate_method = 0;
+ tree t_binfo = TYPE_BINFO (t);
+ tree access_decls = 0;
+
+ if (TREE_CODE (name) == TYPE_DECL)
+ {
+#if 0 /* Maybe later. -jason */
+ struct tinst_level *til = tinst_for_decl();
+
+ if (til)
+ {
+ DECL_SOURCE_FILE (name) = til->file;
+ if (DECL_SOURCE_LINE (name))
+ DECL_SOURCE_LINE (name) = til->line;
+ }
+ else
+#endif
+ {
+ 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);
+ }
+
+ if (warn_anon && code != UNION_TYPE && ANON_AGGRNAME_P (name))
+ warning ("anonymous class type not used to declare any objects");
+
+#if 0
+ /* This is set here, but it's never actually used anywhere. (bpk) */
+ leftmost_baseclasses = NULL_TREE;
+#endif
+ if (TYPE_SIZE (t))
+ {
+ if (IS_AGGR_TYPE (t))
+ cp_error ("redefinition of `%#T'", t);
+ else
+ my_friendly_abort (172);
+ popclass (0);
+ return t;
+ }
+
+ /* Append the fields we need for constructing signature tables. */
+ if (IS_SIGNATURE (t))
+ append_signature_fields (list_of_fieldlists);
+
+ 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;
+
+ /* A signature type will contain the fields of the signature table.
+ Therefore, it's not only an interface. */
+ if (IS_SIGNATURE (t))
+ {
+ CLASSTYPE_INTERFACE_ONLY (t) = 0;
+ SET_CLASSTYPE_INTERFACE_KNOWN (t);
+ }
+ else
+ {
+ CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
+ SET_CLASSTYPE_INTERFACE_UNKNOWN_X (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, t_binfo);
+ /* Remember where we got our vfield from */
+ CLASSTYPE_VFIELD_PARENT (t) = first_vfn_base_index;
+ 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;
+ cant_have_default_ctor = base_info.cant_have_default_ctor;
+ cant_have_const_ctor = base_info.cant_have_const_ctor;
+ cant_synth_copy_ctor = base_info.cant_synth_copy_ctor;
+ cant_synth_asn_ref = base_info.cant_synth_asn_ref;
+ no_const_asn_ref = base_info.no_const_asn_ref;
+ 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;
+ cant_have_default_ctor = 0;
+ cant_have_const_ctor = 0;
+ cant_synth_copy_ctor = 0;
+ cant_synth_asn_ref = 0;
+ no_const_asn_ref = 0;
+ needs_virtual_dtor = 0;
+ }
+
+ if (write_virtuals == 3 && CLASSTYPE_INTERFACE_KNOWN (t)
+ && current_lang_name == lang_name_cplusplus && ! IS_SIGNATURE (t))
+ {
+ CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
+ CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! interface_only;
+ }
+ else if (IS_SIGNATURE (t))
+ CLASSTYPE_VTABLE_NEEDS_WRITING (t) = 0;
+
+ /* 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 (IS_SIGNATURE (t))
+ all_virtual = 0;
+ else if (flag_all_virtual == 1 && TYPE_OVERLOADS_METHOD_CALL_EXPR (t))
+ all_virtual = 1;
+ else
+ all_virtual = 0;
+
+ /* For signatures, we made all methods `public' in the parser and
+ reported an error if a access specifier was used. */
+ if (CLASSTYPE_DECLARED_CLASS (t) == 0)
+ {
+ nonprivate_method = 1;
+ if (list_of_fieldlists
+ && TREE_PURPOSE (list_of_fieldlists) == (tree)access_default)
+ TREE_PURPOSE (list_of_fieldlists) = (tree)access_public;
+ }
+ else if (list_of_fieldlists
+ && TREE_PURPOSE (list_of_fieldlists) == (tree)access_default)
+ TREE_PURPOSE (list_of_fieldlists) = (tree)access_private;
+
+ while (list_of_fieldlists)
+ {
+ access = (enum access_type)TREE_PURPOSE (list_of_fieldlists);
+
+ for (x = TREE_VALUE (list_of_fieldlists); x; x = TREE_CHAIN (x))
+ {
+ TREE_PRIVATE (x) = access == access_private;
+ TREE_PROTECTED (x) = access == access_protected;
+ GNU_xref_member (current_class_name, x);
+
+ if (TREE_CODE (x) == TYPE_DECL)
+ {
+ /* Make sure we set this up. In find_scoped_type, it explicitly
+ looks for a TYPE_DECL in the TYPE_FIELDS list. If we don't
+ do this here, we'll miss including this TYPE_DECL in the
+ list. */
+ if (! fields)
+ fields = x;
+ last_x = x;
+ DECL_CONTEXT (x) = t;
+ continue;
+ }
+
+
+ if (TREE_CODE (x) == FUNCTION_DECL)
+ {
+ 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 access 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);
+ access_decls = tree_cons ((tree) access, fdecl, access_decls);
+ continue;
+ }
+
+ /* If we've gotten this far, it's a data member, possibly static,
+ or an enumerator. */
+
+ DECL_FIELD_CONTEXT (x) = t;
+
+ /* ``A local class cannot have static data members.'' ARM 9.4 */
+ if (current_function_decl && TREE_STATIC (x))
+ cp_error_at ("field `%D' in local class cannot be static", x);
+
+ /* Perform error checking that did not get done in
+ grokdeclarator. */
+ if (TREE_CODE (TREE_TYPE (x)) == FUNCTION_TYPE)
+ {
+ cp_error_at ("field `%D' invalidly declared function type",
+ x);
+ TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
+ }
+ else if (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE)
+ {
+ cp_error_at ("field `%D' invalidly declared method type", x);
+ TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
+ }
+ else if (TREE_CODE (TREE_TYPE (x)) == OFFSET_TYPE)
+ {
+ cp_error_at ("field `%D' invalidly declared offset type", x);
+ TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
+ }
+
+ if (TREE_TYPE (x) == error_mark_node)
+ continue;
+
+ if (! fields)
+ fields = x;
+ last_x = x;
+
+ DECL_FIELD_SIZE (x) = 0;
+
+ /* When this goes into scope, it will be a non-local reference. */
+ DECL_NONLOCAL (x) = 1;
+
+ if (TREE_CODE (x) == CONST_DECL)
+ continue;
+
+ if (TREE_CODE (x) == VAR_DECL)
+ {
+ if (TREE_CODE (t) == UNION_TYPE)
+ /* Unions cannot have static members. */
+ cp_error_at ("field `%D' declared static in union", x);
+
+ continue;
+ }
+
+ /* Now it can only be a FIELD_DECL. */
+
+ /* If this is of reference type, check if it needs an init.
+ Also do a little ANSI jig if necessary. */
+ if (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE)
+ {
+ if (DECL_INITIAL (x) == NULL_TREE)
+ ref_sans_init = 1;
+
+ /* ARM $12.6.2: [A member initializer list] is the only
+ way to initialize a nonstatic const and reference
+ [member]. */
+ cant_synth_asn_ref = 1;
+ cant_have_default_ctor = 1;
+ TYPE_HAS_COMPLEX_INIT_REF (t) = 1;
+
+ if (! TYPE_HAS_CONSTRUCTOR (t))
+ {
+ if (DECL_NAME (x))
+ cp_pedwarn_at ("non-static reference `%#D' in class without a constructor", x);
+ else
+ cp_pedwarn_at ("non-static reference in class without a constructor", x);
+ }
+ }
+
+ /* 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) == NULL_TREE)
+ const_sans_init = 1;
+
+ /* ARM $12.6.2: [A member initializer list] is the only
+ way to initialize a nonstatic const and reference
+ [member]. */
+ cant_synth_asn_ref = 1;
+ cant_have_default_ctor = 1;
+ TYPE_HAS_COMPLEX_INIT_REF (t) = 1;
+
+ if (! TYPE_HAS_CONSTRUCTOR (t) && !IS_SIGNATURE (t))
+ {
+ if (DECL_NAME (x))
+ cp_pedwarn_at ("non-static const member `%#D' in class without a constructor", x);
+ else
+ cp_pedwarn_at ("non-static const member in class without a constructor", x);
+ }
+ }
+ 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;
+ }
+ }
+
+ /* 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)
+ {
+ cp_error_at ("bit-field `%D' has invalid type", x);
+ DECL_INITIAL (x) = NULL;
+ }
+
+ /* 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;
+ cp_error_at ("negative width in bit-field `%D'", x);
+ }
+ else if (width == 0 && DECL_NAME (x) != 0)
+ {
+ DECL_INITIAL (x) = NULL;
+ cp_error_at ("zero width for bit-field `%D'", x);
+ }
+ else if ((unsigned)width > TYPE_PRECISION (TREE_TYPE (x)))
+ {
+ DECL_INITIAL (x) = NULL;
+ cp_error_at ("width of `%D' exceeds its type", x);
+ }
+ }
+
+ /* 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
+ {
+ tree type = TREE_TYPE (x);
+
+ if (TREE_CODE (type) == ARRAY_TYPE)
+ type = TREE_TYPE (type);
+
+ if (TYPE_LANG_SPECIFIC (type) && ! ANON_UNION_P (x))
+ {
+ /* Never let anything with uninheritable virtuals
+ make it through without complaint. */
+ if (CLASSTYPE_ABSTRACT_VIRTUALS (type))
+ abstract_virtuals_error (x, type);
+
+ /* Don't let signatures make it through either. */
+ if (IS_SIGNATURE (type))
+ signature_error (x, type);
+
+ if (code == UNION_TYPE)
+ {
+ char * fie = 0;
+ if (TYPE_NEEDS_CONSTRUCTING (type))
+ fie = "constructor";
+ else if (TYPE_NEEDS_DESTRUCTOR (type))
+ fie = "destructor";
+ else if (TYPE_HAS_REAL_ASSIGNMENT (type))
+ fie = "assignment operator";
+ if (fie)
+ cp_error_at ("member `%#D' with %s not allowed in union", x,
+ fie);
+ }
+ else
+ {
+ TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
+ TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (type);
+ TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
+ TYPE_HAS_COMPLEX_INIT_REF (t)
+ |= (TYPE_HAS_COMPLEX_INIT_REF (type)
+ || TYPE_NEEDS_CONSTRUCTING (type));
+ }
+
+ if (! TYPE_HAS_INIT_REF (type)
+ || (TYPE_HAS_NONPUBLIC_CTOR (type)
+ && ! is_friend (t, type)))
+ cant_synth_copy_ctor = 1;
+ else if (!TYPE_HAS_CONST_INIT_REF (type))
+ cant_have_const_ctor = 1;
+
+ if (! TYPE_HAS_ASSIGN_REF (type)
+ || (TYPE_HAS_NONPUBLIC_ASSIGN_REF (type)
+ && ! is_friend (t, type)))
+ cant_synth_asn_ref = 1;
+ else if (!TYPE_HAS_CONST_ASSIGN_REF (type))
+ no_const_asn_ref = 1;
+
+ if (TYPE_HAS_CONSTRUCTOR (type)
+ && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
+ {
+ cant_have_default_ctor = 1;
+ if (! TYPE_HAS_CONSTRUCTOR (t))
+ {
+ if (DECL_NAME (x))
+ cp_pedwarn_at ("member `%#D' with only non-default constructor", x);
+ else
+ cp_pedwarn_at ("member with only non-default constructor", x);
+ cp_pedwarn_at ("in class without a constructor",
+ x);
+ }
+ }
+ }
+ if (DECL_INITIAL (x) != NULL_TREE)
+ {
+ /* `build_class_init_list' does not recognize
+ non-FIELD_DECLs. */
+ if (code == UNION_TYPE && any_default_members != 0)
+ cp_error_at ("multiple fields in union `%T' initialized");
+ any_default_members = 1;
+ }
+ }
+ }
+ 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 (TYPE_NEEDS_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t)
+ && !IS_SIGNATURE (t))
+ {
+ /* Here we must cons up a destructor on the fly. */
+ tree dtor = cons_up_default_function (t, name, fields,
+ 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_NEEDS_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
+
+ /* Synthesize any needed methods. Note that methods will be synthesized
+ for anonymous unions; grok_x_components undoes that. */
+
+ if (! fn_fields)
+ nonprivate_method = 1;
+
+ TYPE_HAS_COMPLEX_INIT_REF (t)
+ |= (TYPE_HAS_INIT_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
+ || has_virtual || any_default_members || first_vfn_base_index >= 0);
+ TYPE_NEEDS_CONSTRUCTING (t)
+ |= (TYPE_HAS_CONSTRUCTOR (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
+ || has_virtual || any_default_members || first_vfn_base_index >= 0);
+
+ /* ARM $12.1: A default constructor will be generated for a class X
+ only if no constructor has been declared for class X. So we
+ check TYPE_HAS_CONSTRUCTOR also, to make sure we don't generate
+ one if they declared a constructor in this class. */
+ if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor)
+ {
+ tree default_fn = cons_up_default_function (t, name, fields, 2);
+ TREE_CHAIN (default_fn) = fn_fields;
+ fn_fields = default_fn;
+ }
+
+ /* Create default copy constructor, if needed. Don't do it for
+ the exception handler. */
+ if (! TYPE_HAS_INIT_REF (t) && ! cant_synth_copy_ctor && t != EHS_type)
+ {
+ /* ARM 12.18: You get either X(X&) or X(const X&), but
+ not both. --Chip */
+ tree default_fn =
+ cons_up_default_function (t, name, fields,
+ cant_have_const_ctor ? 4 : 3);
+ TREE_CHAIN (default_fn) = fn_fields;
+ fn_fields = default_fn;
+ }
+
+ TYPE_HAS_REAL_ASSIGNMENT (t) |= TYPE_HAS_ASSIGNMENT (t);
+ TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t);
+ TYPE_HAS_COMPLEX_ASSIGN_REF (t)
+ |= (TYPE_HAS_ASSIGN_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
+ || has_virtual || first_vfn_base_index >= 0);
+
+ if (! TYPE_HAS_ASSIGN_REF (t) && ! cant_synth_asn_ref)
+ {
+ tree default_fn =
+ cons_up_default_function (t, name, fields,
+ no_const_asn_ref ? 6 : 5);
+ TREE_CHAIN (default_fn) = fn_fields;
+ fn_fields = default_fn;
+ }
+
+ 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 && warn_ctor_dtor_privacy)
+ cp_warning ("`%#T' only defines private constructors and has no friends",
+ t);
+ }
+ }
+ 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;
+ }
+
+ {
+ int n_methods = TREE_VEC_LENGTH (method_vec);
+
+ for (access_decls = nreverse (access_decls); access_decls;
+ access_decls = TREE_CHAIN (access_decls))
+ {
+ tree fdecl = TREE_VALUE (access_decls);
+ tree flist = NULL_TREE;
+ tree name;
+ enum access_type access = (enum access_type)TREE_PURPOSE(access_decls);
+ int i = 0;
+ tree tmp;
+
+ if (TREE_CODE (fdecl) == TREE_LIST)
+ {
+ flist = fdecl;
+ fdecl = TREE_VALUE (flist);
+ }
+
+ name = DECL_NAME (fdecl);
+
+ for (; i < n_methods; i++)
+ if (DECL_NAME (TREE_VEC_ELT (method_vec, i)) == name)
+ {
+ cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
+ cp_error_at ("because of local method `%#D' with same name",
+ TREE_VEC_ELT (method_vec, i));
+ fdecl = 0;
+ break;
+ }
+
+ if (! fdecl)
+ continue;
+
+ for (tmp = fields; tmp; tmp = TREE_CHAIN (tmp))
+ if (DECL_NAME (tmp) == name)
+ {
+ cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
+ cp_error_at ("because of local field `%#D' with same name", tmp);
+ fdecl = 0;
+ break;
+ }
+
+ if (!fdecl)
+ continue;
+
+ /* Make type T see field decl FDECL with access ACCESS.*/
+ if (flist)
+ {
+ fdecl = TREE_VALUE (flist);
+ while (fdecl)
+ {
+ if (alter_access (t, fdecl, access) == 0)
+ break;
+ fdecl = DECL_CHAIN (fdecl);
+ }
+ }
+ else
+ alter_access (t, fdecl, access);
+ }
+
+ }
+
+ 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. */
+
+ {
+ tree field;
+ for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
+ {
+ if (TREE_STATIC (field))
+ continue;
+ if (TREE_CODE (field) != FIELD_DECL)
+ continue;
+
+ /* If this field is an anonymous union,
+ give each union-member the same position as the union has.
+
+ ??? This is a real kludge because it makes the structure
+ of the types look strange. This feature is only used by
+ C++, which should have build_component_ref build two
+ COMPONENT_REF operations, one for the union and one for
+ the inner field. We set the offset of this field to zero
+ so that either the old or the correct method will work.
+ Setting DECL_FIELD_CONTEXT is wrong unless the inner fields are
+ moved into the type of this field, but nothing seems to break
+ by doing this. */
+
+ if (DECL_NAME (field) == 0
+ && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
+ {
+ tree uelt = TYPE_FIELDS (TREE_TYPE (field));
+ for (; uelt; uelt = TREE_CHAIN (uelt))
+ {
+ DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field);
+ DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field);
+ }
+
+ DECL_FIELD_BITPOS (field) = integer_zero_node;
+ }
+ }
+ }
+
+ 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);
+ /* Don't re-use old size. */
+ DECL_SIZE (base_layout_decl) = 0;
+ }
+
+ layout_type (t);
+
+ {
+ tree field;
+ for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
+ {
+ if (TREE_STATIC (field))
+ continue;
+ if (TREE_CODE (field) != FIELD_DECL)
+ continue;
+
+ /* If this field is an anonymous union,
+ give each union-member the same position as the union has.
+
+ ??? This is a real kludge because it makes the structure
+ of the types look strange. This feature is only used by
+ C++, which should have build_component_ref build two
+ COMPONENT_REF operations, one for the union and one for
+ the inner field. We set the offset of this field to zero
+ so that either the old or the correct method will work.
+ Setting DECL_FIELD_CONTEXT is wrong unless the inner fields are
+ moved into the type of this field, but nothing seems to break
+ by doing this. */
+
+ if (DECL_NAME (field) == 0
+ && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
+ {
+ tree uelt = TYPE_FIELDS (TREE_TYPE (field));
+ for (; uelt; uelt = TREE_CHAIN (uelt))
+ {
+ DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field);
+ DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field);
+ }
+
+ DECL_FIELD_BITPOS (field) = integer_zero_node;
+ }
+ }
+ }
+
+ 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);
+
+ while (vbases)
+ {
+ /* 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);
+ }
+ }
+
+#ifdef NOTQUITE
+ cp_warning ("Doing hard virtuals for %T...", t);
+#endif
+ 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));
+ /* Only do this, if it was missed before. */
+ if (TREE_CODE (base_fndecls) != INTEGER_CST)
+ {
+ 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));
+ modify_other_vtable_entries (t, TYPE_BINFO (t),
+ TREE_PURPOSE (pending_hard_virtuals),
+ TREE_VALUE (base_fndecls),
+ TREE_VALUE (pending_hard_virtuals));
+ base_fndecls = TREE_CHAIN (base_fndecls);
+ }
+ } else {
+#ifdef NOTQUITE
+ cp_warning ("missed bases for `%D'", TREE_PURPOSE (pending_hard_virtuals));
+#endif
+ }
+ }
+ pending_hard_virtuals = TREE_CHAIN (pending_hard_virtuals);
+ }
+
+ if (TYPE_USES_VIRTUAL_BASECLASSES (t))
+ {
+ tree vbases;
+
+ 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 (! SAME_FN (decl, base_fndecl))
+ {
+ 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
+ pfn = build1 (ADDR_EXPR, ptr_type_node, decl);
+ TREE_CONSTANT (pfn) = 1;
+ modify_vtable_entries (t, decl, base_fndecl, pfn);
+ }
+ }
+ virtuals = TREE_CHAIN (virtuals);
+ }
+
+ vbases = TREE_CHAIN (vbases);
+ }
+ }
+ 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 (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index), 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 = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index);
+#if 0
+ /* For testing. */
+ tree binfo1 = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
+ if (binfo != binfo1)
+ warning ("binfos are different in vtable creation");
+#endif
+
+ /* 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)
+ {
+ cp_error ("too many virtual functions for `%#T' (VINDEX_MAX < %d)",
+ t, 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);
+ /* At one time the vtable info was grabbed 2 words at a time. This
+ fails on sparc unless you have 8-byte alignment. (tiemann) */
+ 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;
+
+ 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))
+ || DECL_FIELD_SIZE (x) < TYPE_PRECISION (integer_type_node)))
+ {
+ tree type = TREE_TYPE (x);
+
+ /* Preserve unsignedness if traditional or if not really getting
+ any wider. */
+ if (TREE_UNSIGNED (type)
+ && (flag_traditional
+ ||
+ (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
+ && DECL_FIELD_SIZE (x) == TYPE_PRECISION (integer_type_node))))
+ TREE_TYPE (x) = unsigned_type_node;
+ else
+ TREE_TYPE (x) = 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));
+#ifdef DWARF_DEBUGGING_INFO
+ if (write_symbols == DWARF_DEBUG)
+ {
+ /* Notify dwarfout.c that this TYPE_DECL node represent a
+ gratuitous typedef. */
+ DECL_IGNORED_P (tag) = 1;
+ }
+#endif /* DWARF_DEBUGGING_INFO */
+ 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)
+ && ! IS_SIGNATURE (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 ((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 = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
+ 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;
+ }
+
+ /* In addition to this one, all the other vfields should be listed. */
+ /* Before that can be done, we have to have FIELD_DECLs for them, and
+ a place to find them. */
+ TYPE_NONCOPIED_PARTS (t) = build_tree_list (default_conversion (TYPE_BINFO_VTABLE (t)), vfield);
+
+ if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (t)
+ && DECL_VINDEX (TREE_VEC_ELT (method_vec, 0)) == NULL_TREE)
+ cp_warning ("`%#T' has virtual functions but non-virtual destructor",
+ t);
+ }
+
+ /* 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. */
+ if (write_symbols != DWARF_DEBUG)
+ {
+ /* 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 (write_symbols != DWARF_DEBUG)
+ {
+ /* 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;
+}
+\f
+/* 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;
+ }
+}
+\f
+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;
+
+ /* 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;") */
+
+/* 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;
+{
+ 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 (previous_class_type != NULL_TREE
+ && (type != previous_class_type || TYPE_SIZE (previous_class_type) == NULL_TREE)
+ && current_class_depth == 1)
+ {
+ /* Forcibly remove any old class remnants. */
+ popclass (-1);
+ previous_class_type = NULL_TREE;
+ }
+
+ 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 != previous_class_type || current_class_depth > 1)
+ {
+ build_mi_matrix (type);
+ push_class_decls (type);
+ free_mi_matrix ();
+ if (current_class_depth == 1)
+ previous_class_type = type;
+ }
+ else
+ {
+ tree item;
+
+ /* Hooray, our cacheing was successful, let's just install the
+ cached class_shadowed list, and walk through it to get the
+ IDENTIFIER_TYPE_VALUEs correct. */
+ set_class_shadows (previous_class_values);
+ for (item = previous_class_values; item; item = TREE_CHAIN (item))
+ {
+ tree id = TREE_PURPOSE (item);
+ tree decl = IDENTIFIER_CLASS_VALUE (id);
+
+ if (TREE_CODE (decl) == TYPE_DECL)
+ set_identifier_type_value (id, TREE_TYPE (decl));
+ }
+ 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), 0);
+ }
+
+ current_function_decl = this_fndecl;
+ }
+
+ if (flag_cadillac)
+ cadillac_push_class (type);
+}
+
+/* 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;
+{
+ if (flag_cadillac)
+ cadillac_pop_class ();
+
+ if (modify < 0)
+ {
+ /* Back this old class out completely. */
+ tree tags = CLASSTYPE_TAGS (previous_class_type);
+ tree t;
+
+ /* This code can be seen as a cache miss. When we've cached a
+ class' scope's bindings and we can't use them, we need to reset
+ them. This is it! */
+ for (t = previous_class_values; t; t = TREE_CHAIN(t))
+ IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
+ while (tags)
+ {
+ TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
+ 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;
+ tags = TREE_CHAIN (tags);
+ }
+ }
+ if (TREE_CODE (current_class_type) == UNINSTANTIATED_P_TYPE)
+ undo_template_name_overload (current_class_name, 0);
+
+ poplevel_class ();
+
+ /* Since poplevel_class does the popping of class decls nowadays,
+ this really only frees the obstack used for these decls.
+ That's why it had to be moved down here. */
+ if (modify)
+ pop_class_decls (current_class_type);
+
+ 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_PTR);
+ }
+ current_class_decl = lookup_name (this_identifier, 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:
+ ;
+}
+
+/* When entering a class scope, all enclosing class scopes' names with
+ static meaning (static variables, static functions, types and enumerators)
+ have to be visible. This recursive function calls pushclass for all
+ enclosing class contexts until global or a local scope is reached.
+ TYPE is the enclosed class and MODIFY is equivalent with the pushclass
+ formal of the same name. */
+
+void
+push_nested_class (type, modify)
+ tree type;
+ int modify;
+{
+ tree context = DECL_CONTEXT (TYPE_NAME (type));
+
+ if (context && TREE_CODE (context) == RECORD_TYPE)
+ push_nested_class (context, 2);
+ pushclass (type, modify);
+}
+
+/* Undoes a push_nested_class call. MODIFY is passed on to popclass. */
+
+void
+pop_nested_class (modify)
+ int modify;
+{
+ tree context = DECL_CONTEXT (TYPE_NAME (current_class_type));
+
+ popclass (modify);
+ if (context && TREE_CODE (context) == RECORD_TYPE)
+ pop_nested_class (modify);
+}
+
+/* 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;
+}
+\f
+/* 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 0 /* obsolete */
+ /* If there's only one function we know about, return that. */
+ if (globals > 0 && TREE_CHAIN (rhs) == NULL_TREE)
+ return TREE_VALUE (rhs);
+#endif
+
+ /* 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)
+ cp_error ("cannot resolve overloaded function `%D' based on non-function type",
+ TREE_PURPOSE (rhs));
+ return error_mark_node;
+ }
+
+ if (globals > 0)
+ {
+ elem = get_first_fn (rhs);
+ while (elem)
+ if (TREE_TYPE (elem) != lhstype)
+ elem = DECL_CHAIN (elem);
+ else
+ return elem;
+ /* No exact match found, look for a compatible function. */
+ elem = get_first_fn (rhs);
+ while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem), 1))
+ elem = DECL_CHAIN (elem);
+ if (elem)
+ {
+ tree save_elem = elem;
+ elem = DECL_CHAIN (elem);
+ while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem),
+ 0))
+ elem = DECL_CHAIN (elem);
+ if (elem)
+ {
+ if (complain)
+ {
+ cp_error ("cannot resolve overload to target type `%#T';", lhstype);
+ cp_error_at ("ambiguity between `%#D'", save_elem);
+ cp_error_at ("and `%#D', at least", elem);
+ }
+ return error_mark_node;
+ }
+ if (TREE_CODE (save_elem) == TEMPLATE_DECL)
+ {
+ int ntparms = TREE_VEC_LENGTH
+ (DECL_TEMPLATE_PARMS (save_elem));
+ tree *targs = (tree *) alloca (sizeof (tree) * ntparms);
+ int i, dummy;
+ i = type_unification
+ (DECL_TEMPLATE_PARMS (save_elem), targs,
+ TYPE_ARG_TYPES (TREE_TYPE (save_elem)),
+ TYPE_ARG_TYPES (lhstype), &dummy, 0);
+ save_elem = instantiate_template (save_elem, targs);
+ }
+ return save_elem;
+ }
+ if (complain)
+ {
+ cp_error ("cannot resolve overload to target type `%#T';",
+ lhstype);
+ cp_error ("no suitable overload of function `%D' exists",
+ 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;
+ }
+}
+\f
+/* 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
+}
+
+/* Push an obstack which is sufficiently long-lived to hold such class
+ decls that may be cached in the previous_class_values list. For now, let's
+ use the permanent obstack, later we may create a dedicated obstack just
+ for this purpose. The effect is undone by pop_obstacks. */
+void
+maybe_push_cache_obstack ()
+{
+ push_obstacks_nochange ();
+ if (current_class_depth == 1)
+ current_obstack = &permanent_obstack;
+}
--- /dev/null
+/* 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. */
+
+/* These macros and harshness_code are used by the NEW METHOD. */
+#define EVIL_CODE (1<<7)
+#define CONST_CODE (1<<6)
+#define ELLIPSIS_CODE (1<<5)
+#define USER_CODE (1<<4)
+#define STD_CODE (1<<3)
+#define PROMO_CODE (1<<2)
+#define QUAL_CODE (1<<1)
+#define TRIVIAL_CODE (1<<0)
+
+struct harshness_code
+{
+ /* What kind of conversion is involved. */
+ unsigned short code;
+
+ /* The inheritance distance. */
+ short distance;
+
+ /* For a PROMO_CODE, Any special penalties involved in integral conversions.
+ This exists because $4.1 of the ARM states that something like
+ `short unsigned int' should promote to `int', not `unsigned int'.
+ If, for example, it tries to match two fns, f(int) and f(unsigned),
+ f(int) should be a better match than f(unsigned) by this rule. Without
+ this extra metric, they both only appear as "integral promotions", which
+ will lead to an ambiguity.
+ For a TRIVIAL_CODE, This is also used by build_overload_call_real and
+ convert_harshness to keep track of other information we need. */
+ unsigned short int_penalty;
+};
+
+struct candidate
+{
+ /* OLD METHOD */
+ 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. */
+
+ /* NEW METHOD */
+ struct harshness_code h; /* Used for single-argument conversions. */
+
+ int h_len; /* The length of the harshness vector. */
+
+ /* Both methods. */
+ tree function; /* A FUNCTION_DECL */
+ tree basetypes; /* The path to function. */
+ tree arg; /* first parm to function. */
+
+ /* This union is only here while we maintain both the old and new
+ argument matching schemes. When it goes away, all v.ansi_harshness
+ references will be just `harshness'. */
+ union
+ {
+ /* 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. */
+ struct harshness_code *ansi_harshness; /* NEW METHOD */
+ unsigned short *old_harshness; /* OLD METHOD */
+ } v;
+
+ 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;
--- /dev/null
+/* 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. */
+
+
+/* Reference to the contents of an offset
+ (a value whose type is an OFFSET_TYPE).
+ Operand 0 is the object within which the offset is taken.
+ Operand 1 is the offset. The language independent OFFSET_REF
+ just won't work for us. */
+DEFTREECODE (CP_OFFSET_REF, "cp_offset_ref", "r", 2)
+
+/* 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)
--- /dev/null
+/* 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. */
+
+#ifndef _CP_TREE_H
+#define _CP_TREE_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 STDIO_PROTO
+#ifdef BUFSIZ
+#define STDIO_PROTO(ARGS) PROTO(ARGS)
+#else
+#define STDIO_PROTO(ARGS) ()
+#endif
+#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. */
+
+#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)
+
+#define IDENTIFIER_TYPE_VALUE(NODE) (TREE_TYPE (NODE))
+#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = TYPE)
+#define IDENTIFIER_HAS_TYPE_VALUE(NODE) (TREE_TYPE (NODE) ? 1 : 0)
+#define IDENTIFIER_HAS_CLASS_TYPE_VALUE(NODE) \
+ (IDENTIFIER_CLASS_VALUE (NODE) && TREE_TYPE (IDENTIFIER_CLASS_VALUE (NODE)))
+#define IDENTIFIER_CLASS_TYPE_VALUE(NODE) \
+ TREE_TYPE (IDENTIFIER_CLASS_VALUE (NODE))
+
+#define LANG_ID_FIELD(NAME,NODE) \
+ (((struct lang_identifier *)(NODE))->x \
+ ? ((struct lang_identifier *)(NODE))->x->NAME : 0)
+#define SET_LANG_ID(NODE,VALUE,NAME) \
+ (((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->NAME = (VALUE))
+
+#define IDENTIFIER_LABEL_VALUE(NODE) LANG_ID_FIELD(label_value, NODE)
+#define SET_IDENTIFIER_LABEL_VALUE(NODE,VALUE) \
+ SET_LANG_ID(NODE, VALUE, label_value)
+
+#define IDENTIFIER_IMPLICIT_DECL(NODE) LANG_ID_FIELD(implicit_decl, NODE)
+#define SET_IDENTIFIER_IMPLICIT_DECL(NODE,VALUE) \
+ SET_LANG_ID(NODE, VALUE, implicit_decl)
+
+#define IDENTIFIER_AS_DESC(NODE) LANG_ID_FIELD(type_desc, NODE)
+#define SET_IDENTIFIER_AS_DESC(NODE,DESC) \
+ SET_LANG_ID(NODE, DESC, type_desc)
+
+#define IDENTIFIER_AS_LIST(NODE) LANG_ID_FIELD(as_list, NODE)
+#define SET_IDENTIFIER_AS_LIST(NODE,LIST) \
+ SET_LANG_ID(NODE, LIST, as_list)
+
+#define IDENTIFIER_ERROR_LOCUS(NODE) LANG_ID_FIELD(error_locus, NODE)
+#define SET_IDENTIFIER_ERROR_LOCUS(NODE,VALUE) \
+ SET_LANG_ID(NODE, VALUE, error_locus)
+
+
+#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)
+\f
+/* 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 when all ctors or dtors are private, and the class
+ has no friends. */
+
+extern int warn_ctor_dtor_privacy;
+
+/* 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;
+
+/* 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;
+
+/* Nonzero means warn about multiple (redundant) decls for the same single
+ variable or function. */
+
+extern int warn_redundant_decls;
+
+/* Warn if initializer is not completely bracketed. */
+
+extern int warn_missing_braces;
+
+/* 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;
+
+/* Warn about *printf or *scanf format/argument anomalies. */
+
+extern int warn_format;
+
+/* Nonzero means warn about non virtual destructors in classes that have
+ virtual functions. */
+
+extern int warn_nonvdtor;
+
+/* Non-zero means warn when a function is declared extern and later inline. */
+extern int warn_extern_inline;
+
+/* 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 access.
+ 1 means write out virtual function tables and give them
+ (C) public access.
+ 0 means write out virtual function tables and give them
+ (C) static access (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 do argument matching for overloading according to the
+ ANSI rules, rather than what g++ used to believe to be correct. */
+
+extern int flag_ansi_overloading;
+
+/* Nonzero means recognize and handle signature language constructs. */
+
+extern int flag_handle_signatures;
+
+/* 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;
+\f
+/* C++ language-specific tree codes. */
+#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
+enum cplus_tree_code {
+ __DUMMY = LAST_AND_UNUSED_TREE_CODE,
+#include "tree.def"
+ LAST_CPLUS_TREE_CODE
+};
+#undef DEFTREECODE
+
+/* Override OFFSET_REFs from the back-end, as we want our very own. */
+/* Allow complex pointer to members to work correctly. */
+#define OFFSET_REF CP_OFFSET_REF
+
+enum languages { lang_c, lang_cplusplus };
+
+/* Macros to make error reporting functions' lives easier. */
+#define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE)))
+#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(t) (TYPE_LANG_FLAG_5 (t))
+#define IS_AGGR_TYPE_CODE(t) (t == RECORD_TYPE || t == UNION_TYPE)
+#define IS_AGGR_TYPE_2(TYPE1,TYPE2) \
+ (TREE_CODE (TYPE1) == TREE_CODE (TYPE2) \
+ && IS_AGGR_TYPE (TYPE1)&IS_AGGR_TYPE (TYPE2))
+
+/* In a *_TYPE, nonzero means a built-in type. */
+#define TYPE_BUILT_IN(NODE) TYPE_LANG_FLAG_6(NODE)
+
+/* 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)
+#define ACCESSIBLY_DERIVED_FROM_P(PARENT, TYPE) (get_base_distance (PARENT, TYPE, -1, (tree *)0) >= 0)
+#define ACCESSIBLY_UNIQUELY_DERIVED_P(PARENT, TYPE) (get_base_distance (PARENT, TYPE, 1, (tree *)0) >= 0)
+\f
+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_aggr : 1;
+ unsigned has_assignment : 1;
+ unsigned has_default_ctor : 1;
+ unsigned uses_multiple_inheritance : 1;
+
+ unsigned has_nonpublic_ctor : 2;
+ unsigned has_nonpublic_assign_ref : 2;
+ unsigned const_needs_init : 1;
+ unsigned ref_needs_init : 1;
+ unsigned has_const_assign_ref : 1;
+ unsigned vtable_needs_writing : 1;
+
+ unsigned has_assign_ref : 1;
+ unsigned gets_new : 1;
+ unsigned gets_placed_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 no_globalize : 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 has_method_call_overloaded : 1;
+ unsigned private_attr : 1;
+ unsigned got_semicolon : 1;
+ unsigned ptrmemfunc_flag : 1;
+ unsigned is_signature : 1;
+ unsigned is_signature_pointer : 1;
+ unsigned is_signature_reference : 1;
+
+ unsigned has_default_implementation : 1;
+ unsigned grokking_typedef : 1;
+ unsigned has_opaque_typedecls : 1;
+ unsigned sigtable_has_been_generated : 1;
+ unsigned was_anonymous : 1;
+ unsigned has_real_assignment : 1;
+ unsigned has_real_assign_ref : 1;
+ unsigned has_const_init_ref : 1;
+
+ unsigned has_complex_init_ref : 1;
+ unsigned has_complex_assign_ref : 1;
+
+ /* The MIPS compiler gets it wrong if this struct also
+ does not fill out to a multiple of 4 bytes. Add a
+ member `dummy' with new bits if you go over the edge. */
+ unsigned dummy : 22;
+
+ unsigned n_vancestors : 16;
+ } type_flags;
+
+ int cid;
+ int n_ancestors;
+ int vsize;
+ int max_depth;
+ int vfield_parent;
+
+ 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;
+
+ union tree_node *signature;
+ union tree_node *signature_pointer_to;
+ union tree_node *signature_reference_to;
+};
+
+/* 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_HAS_REAL_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_real_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_PLACED_NEW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_placed_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_HAS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_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_HAS_CONST_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_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)
+
+/* Nonzero means that this type is a signature. */
+# define IS_SIGNATURE(NODE) (TYPE_LANG_SPECIFIC(NODE)?TYPE_LANG_SPECIFIC(NODE)->type_flags.is_signature:0)
+# define SET_SIGNATURE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.is_signature=1)
+# define CLEAR_SIGNATURE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.is_signature=0)
+
+/* Nonzero means that this type is a signature pointer type. */
+# define IS_SIGNATURE_POINTER(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.is_signature_pointer)
+
+/* Nonzero means that this type is a signature reference type. */
+# define IS_SIGNATURE_REFERENCE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.is_signature_reference)
+
+/* Nonzero means that this signature type has a default implementation. */
+# define HAS_DEFAULT_IMPLEMENTATION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_default_implementation)
+
+/* Nonzero means that grokdeclarator works on a signature-local typedef. */
+#define SIGNATURE_GROKKING_TYPEDEF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.grokking_typedef)
+
+/* Nonzero means that this signature contains opaque type declarations. */
+#define SIGNATURE_HAS_OPAQUE_TYPEDECLS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_opaque_typedecls)
+
+/* Nonzero means that a signature table has been generated
+ for this signature. */
+#define SIGTABLE_HAS_BEEN_GENERATED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.sigtable_has_been_generated)
+
+/* If NODE is a class, this is the signature type that contains NODE's
+ signature after it has been computed using sigof(). */
+#define CLASSTYPE_SIGNATURE(NODE) (TYPE_LANG_SPECIFIC(NODE)->signature)
+
+/* If NODE is a signature pointer or signature reference, this is the
+ signature type the pointer/reference points to. */
+#define SIGNATURE_TYPE(NODE) (TYPE_LANG_SPECIFIC(NODE)->signature)
+
+/* If NODE is a signature, this is a vector of all methods defined
+ in the signature or in its base types together with their default
+ implementations. */
+#define SIGNATURE_METHOD_VEC(NODE) (TYPE_LANG_SPECIFIC(NODE)->signature)
+
+/* If NODE is a signature, this is the _TYPE node that contains NODE's
+ signature pointer type. */
+#define SIGNATURE_POINTER_TO(NODE) (TYPE_LANG_SPECIFIC(NODE)->signature_pointer_to)
+
+/* If NODE is a signature, this is the _TYPE node that contains NODE's
+ signature reference type. */
+#define SIGNATURE_REFERENCE_TO(NODE) (TYPE_LANG_SPECIFIC(NODE)->signature_reference_to)
+
+/* 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. */
+#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)
+
+#define CLASSTYPE_TAGS(NODE) (TYPE_LANG_SPECIFIC(NODE)->tags)
+
+/* If this class has any bases, this is the number of the base class from
+ which our VFIELD is based, -1 otherwise. If this class has no base
+ classes, this is not used.
+ In D : B1, B2, PARENT would be 0, if D's vtable came from B1,
+ 1, if D's vtable came from B2. */
+#define CLASSTYPE_VFIELD_PARENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->vfield_parent)
+
+/* 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)
+
+/* 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)
+
+/* Nonzero means the type declared a ctor as private or protected. We
+ use this to make sure we don't try to generate a copy ctor for a
+ class that has a member of type NODE. */
+#define TYPE_HAS_NONPUBLIC_CTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_nonpublic_ctor)
+
+/* Ditto, for operator=. */
+#define TYPE_HAS_NONPUBLIC_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_nonpublic_assign_ref)
+
+/* Many routines need to cons up a list of basetypes for access
+ 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)
+/* whether this can be globalized. */
+#define CLASSTYPE_NO_GLOBALIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.no_globalize)
+
+/* 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)
+#define CLASSTYPE_INTERFACE_KNOWN(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_unknown == 0)
+#define SET_CLASSTYPE_INTERFACE_UNKNOWN_X(NODE,X) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_unknown = !!(X))
+#define SET_CLASSTYPE_INTERFACE_UNKNOWN(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_unknown = 1)
+#define SET_CLASSTYPE_INTERFACE_KNOWN(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_unknown = 0)
+
+/* 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)
+\f
+/* 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))
+\f
+/* 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)
+\f
+/* 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! */
+
+/* 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)
+\f
+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 mutable_flag : 1;
+ unsigned is_default_implementation : 1;
+ unsigned synthesized : 1;
+ unsigned dummy : 10;
+
+ tree access;
+ tree context;
+ tree memfunc_pointer_to;
+};
+
+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 this function is a default
+ implementation of a signature method. */
+#define IS_DEFAULT_IMPLEMENTATION(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.is_default_implementation)
+
+/* 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 _DECL means that this member object type
+ is mutable. */
+#define DECL_MUTABLE_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.mutable_flag)
+
+/* 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 access 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)
+
+/* For a FUNCTION_DECL: if this function was declared inside a signature
+ declaration, this is the corresponding member function pointer that was
+ created for it. */
+#define DECL_MEMFUNC_POINTER_TO(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.memfunc_pointer_to)
+
+/* For a FIELD_DECL: this points to the signature member function from
+ which this signature member function pointer was created. */
+#define DECL_MEMFUNC_POINTING_TO(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.memfunc_pointer_to)
+
+/* 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))
+
+#if 0
+/* 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))
+#endif
+
+/* This method was synthesized by cons_up_default_function. */
+#define DECL_SYNTHESIZED(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.synthesized)
+
+/* 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))
+
+/* Nonzero if there is a user-defined X::op=(x&) for this class. */
+#define TYPE_HAS_REAL_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_real_assign_ref)
+#define TYPE_HAS_COMPLEX_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_complex_assign_ref)
+#define TYPE_HAS_COMPLEX_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_complex_init_ref)
+
+/* 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 _TYPE node means that this type is a pointer to member
+ function type. */
+#define TYPE_PTRMEMFUNC_P(NODE) (TREE_CODE(NODE) == RECORD_TYPE && TYPE_LANG_SPECIFIC(NODE)->type_flags.ptrmemfunc_flag)
+#define TYPE_PTRMEMFUNC_FLAG(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.ptrmemfunc_flag)
+/* Get the POINTER_TYPE to the METHOD_TYPE associated with this
+ pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true,
+ before using this macro. */
+#define TYPE_PTRMEMFUNC_FN_TYPE(NODE) (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (NODE)))))))
+/* These are use to manipulate the the canonical RECORD_TYPE from the
+ hashed POINTER_TYPE, and can only be used on the POINTER_TYPE. */
+#define TYPE_GET_PTRMEMFUNC_TYPE(NODE) ((tree)TYPE_LANG_SPECIFIC(NODE))
+#define TYPE_SET_PTRMEMFUNC_TYPE(NODE, VALUE) (TYPE_LANG_SPECIFIC(NODE) = ((struct lang_type *)(void*)(VALUE)))
+/* These are to get the delta2 and pfn fields from a TYPE_PTRMEMFUNC_P. */
+#define DELTA2_FROM_PTRMEMFUNC(NODE) (build_component_ref (build_component_ref ((NODE), pfn_or_delta2_identifier, 0, 0), delta2_identifier, 0, 0))
+#define PFN_FROM_PTRMEMFUNC(NODE) (build_component_ref (build_component_ref ((NODE), pfn_or_delta2_identifier, 0, 0), pfn_identifier, 0, 0))
+
+/* 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 ANON_UNION_P(NODE) (DECL_NAME (NODE) == 0)
+
+#define UNKNOWN_TYPE LANG_TYPE
+
+/* 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. */
+#define DECL_NESTED_TYPENAME(NODE) ((NODE)->decl.arguments)
+#define TYPE_NESTED_NAME(NODE) (DECL_NESTED_TYPENAME (TYPE_NAME (NODE)))
+
+#define TYPE_WAS_ANONYMOUS(NODE) (TYPE_LANG_SPECIFIC (NODE)->type_flags.was_anonymous)
+
+/* C++: all of these are overloaded! These apply only to TYPE_DECLs. */
+#define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE))
+#if 0
+#define DECL_UNDEFINED_FRIENDS(NODE) ((NODE)->decl.result)
+#endif
+#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_ACCESS is used to record under which context
+ special access rules apply. */
+#define DECL_ACCESS(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.access)
+
+/* 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, signature_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 c-common.c */
+extern void declare_function_name PROTO((void));
+extern void decl_attributes PROTO((tree, tree));
+extern void init_function_format_info PROTO((void));
+extern void record_function_format PROTO((tree, tree, int, int, int));
+extern void check_function_format PROTO((tree, tree, tree));
+/* Print an error message for invalid operands to arith operation CODE.
+ NOP_EXPR is used as a special case (see truthvalue_conversion). */
+extern void binary_op_error PROTO((enum tree_code));
+extern void c_expand_expr_stmt PROTO((tree));
+/* Validate the expression after `case' and apply default promotions. */
+extern tree check_case_value PROTO((tree));
+/* Concatenate a list of STRING_CST nodes into one STRING_CST. */
+extern tree combine_strings PROTO((tree));
+extern void constant_expression_warning PROTO((tree));
+extern tree convert_and_check PROTO((tree, tree));
+extern void overflow_warning PROTO((tree));
+extern void unsigned_conversion_warning PROTO((tree, tree));
+/* Read the rest of the current #-directive line. */
+extern char *get_directive_line STDIO_PROTO((FILE *));
+/* Subroutine of build_binary_op, used for comparison operations.
+ See if the operands have both been converted from subword integer types
+ and, if so, perhaps change them both back to their original type. */
+extern tree shorten_compare PROTO((tree *, tree *, tree *, enum tree_code *));
+/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
+ or validate its data type for an `if' or `while' statement or ?..: exp. */
+extern tree truthvalue_conversion PROTO((tree));
+extern tree type_for_mode PROTO((enum machine_mode, int));
+extern tree type_for_size PROTO((unsigned, int));
+
+/* 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 sigtable_entry_type;
+extern tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node;
+extern tree Type_info_type_node;
+extern tree class_star_type_node;
+extern tree this_identifier;
+extern tree pfn_identifier;
+extern tree index_identifier;
+extern tree delta_identifier;
+extern tree delta2_identifier;
+extern tree pfn_or_delta2_identifier;
+
+/* A node that is a list (length 1) of error_mark_nodes. */
+extern tree error_mark_list;
+
+extern tree ptr_type_node, const_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;
+extern tree opaque_type_node, signature_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 delta_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;
+
+/* The template currently being instantiated, and where the instantiation
+ was triggered. */
+struct tinst_level
+{
+ tree classname;
+ int line;
+ char *file;
+ struct tinst_level *next;
+};
+
+extern struct tinst_level *current_tinst_level;
+
+/* in cp-class.c */
+extern tree current_class_name;
+extern tree current_class_type;
+extern tree previous_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;
+
+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;
+\f
+/* 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"
+#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')
+
+
+/* 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 AUTO_VTABLE_NAME "__vtbl$me__"
+#define AUTO_TEMP_NAME "_$tmp_"
+#define AUTO_TEMP_FORMAT "_$tmp_%d"
+#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 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 AUTO_VTABLE_NAME "__vtbl.me__"
+#define AUTO_TEMP_NAME "_.tmp_"
+#define AUTO_TEMP_FORMAT "_.tmp_%d"
+#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 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 VTABLE_BASE "__vtb"
+#define VTABLE_NAME "__vt_"
+#define VTABLE_NAME_FORMAT "__vt_%s"
+#define VTABLE_NAME_P(ID_NODE) \
+ (!strncmp (IDENTIFIER_POINTER (ID_NODE), VTABLE_NAME, \
+ sizeof (VTABLE_NAME) - 1))
+#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 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 IN_CHARGE_NAME "__in_chrg"
+
+#define VTBL_PTR_TYPE "__vtbl_ptr_type"
+#define VTABLE_DELTA_NAME "__delta"
+#define VTABLE_INDEX_NAME "__index"
+#define VTABLE_PFN_NAME "__pfn"
+#define VTABLE_DELTA2_NAME "__delta2"
+
+#define SIGNATURE_FIELD_NAME "__s_"
+#define SIGNATURE_FIELD_NAME_FORMAT "__s_%s"
+#define SIGNATURE_OPTR_NAME "__optr"
+#define SIGNATURE_SPTR_NAME "__sptr"
+#define SIGNATURE_VPTR_NAME "__vptr"
+#define SIGNATURE_POINTER_NAME "__sp_"
+#define SIGNATURE_POINTER_NAME_FORMAT "__%s%ssp_%s"
+#define SIGNATURE_REFERENCE_NAME "__sr_"
+#define SIGNATURE_REFERENCE_NAME_FORMAT "__%s%ssr_%s"
+
+#define SIGTABLE_PTR_TYPE "__sigtbl_ptr_type"
+#define SIGTABLE_NAME_FORMAT "__st_%s_%s"
+#define SIGTABLE_NAME_FORMAT_LONG "__st_%s_%s_%d"
+#define SIGTABLE_CODE_NAME "__code"
+#define SIGTABLE_OFFSET_NAME "__offset"
+#define SIGTABLE_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 \
+ && IDENTIFIER_POINTER (ID_NODE)[2] == '_')
+
+#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 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) */
+\f
+/* 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 access_type {
+ access_default,
+ access_public,
+ access_protected,
+ access_private,
+ access_default_virtual,
+ access_public_virtual,
+ access_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;
+
+/* Nonzero means templates obey #pragma interface and implementation. */
+
+extern int flag_external_templates;
+
+/* Nonzero means templates are emitted where they are instantiated. */
+
+extern int flag_alt_external_templates;
+
+/* 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 access 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,
+ as well as the space of member functions.
+ LOOKUP_HAS_IN_CHARGE means that the "in charge" variable is already
+ in the parameter list.
+ 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)
+/* 128 & 256 are 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;
+\f
+/* in c-common.c */
+extern tree convert_and_check PROTO((tree, tree));
+extern void overflow_warning PROTO((tree));
+extern void unsigned_conversion_warning PROTO((tree, tree));
+
+/* in cp-call.c */
+extern struct candidate *ansi_c_bullshit;
+
+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_nested_class PROTO((tree, int));
+extern void pop_nested_class 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));
+extern void maybe_push_cache_obstack 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_real 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 */
+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 tree make_type_decl PROTO((tree, tree));
+extern void pushtag PROTO((tree, tree, int));
+extern tree make_anon_name PROTO((void));
+extern void clear_anon_tags PROTO((void));
+extern tree pushdecl PROTO((tree));
+extern tree pushdecl_top_level PROTO((tree));
+extern void push_class_level_binding PROTO((tree, 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 void expand_static_init PROTO((tree, tree));
+extern int complete_array_type PROTO((tree, tree, int));
+extern tree build_ptrmemfunc_type PROTO((tree));
+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, int));
+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 tree grok_alignof PROTO((tree));
+extern tree grok_array_decl PROTO((tree, tree));
+extern tree delete_sanity PROTO((tree, tree, 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_full PROTO((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));
+extern void warn_if_unknown_interface PROTO((void));
+extern tree grok_x_components PROTO((tree, tree));
+
+/* 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));
+extern tree build_typeid PROTO((tree));
+extern tree get_typeid PROTO((tree));
+extern tree build_dynamic_cast PROTO((tree, tree));
+
+/* 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 init_vtbl_ptrs PROTO((tree, int, int));
+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 get_aggr_from_typedef PROTO((tree, int));
+extern tree get_type_value PROTO((tree));
+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 get_member_function_from_ptrfunc PROTO((tree *, tree, tree));
+extern tree resolve_offset_ref PROTO((tree));
+extern tree decl_constant_value PROTO((tree));
+extern int is_friend_type PROTO((tree, tree));
+extern int is_friend PROTO((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));
+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));
+/* 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, 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-error.c */
+extern void init_error PROTO((void));
+extern char *fndecl_as_string PROTO((tree, tree, int));
+extern char *type_as_string PROTO((tree, int));
+extern char *args_as_string PROTO((tree, int));
+extern char *decl_as_string PROTO((tree, int));
+extern char *expr_as_string PROTO((tree, int));
+extern char *code_as_string PROTO((enum tree_code, int));
+extern char *language_as_string PROTO((enum languages, int));
+extern char *parm_as_string PROTO((int, int));
+extern char *op_as_string PROTO((enum tree_code, int));
+
+/* 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 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));
+extern void reinit_parse_for_template PROTO((int, tree, tree));
+extern int type_unification PROTO((tree, tree *, tree, tree, int *, int));
+extern int do_pending_expansions PROTO((void));
+extern void do_pending_templates PROTO((void));
+struct tinst_level *tinst_for_decl PROTO((void));
+extern void do_function_instantiation PROTO((tree, tree));
+
+/* 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 access_type check_access 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 void unuse_fields PROTO((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));
+extern tree current_scope PROTO((void));
+
+/* in cp-sig.c */
+extern tree build_signature_pointer_type PROTO((tree, int, int));
+extern tree build_signature_reference_type PROTO((tree, int, int));
+extern tree build_signature_pointer_constructor PROTO((tree, tree));
+extern tree build_signature_method_call PROTO((tree, tree, tree, tree));
+extern tree build_optr_ref PROTO((tree));
+extern tree build_sptr_ref PROTO((tree));
+extern tree build_vptr_ref PROTO((tree));
+
+/* 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 decl_value_member PROTO((tree, tree));
+extern int is_overloaded_fn PROTO((tree));
+extern tree get_first_fn 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 int fntype_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_object_ref PROTO((tree, tree, 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, 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 tree build_component_ref PROTO((tree, tree, tree, int));
+extern tree build_ptrmemfunc PROTO((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++ */
+
+#endif /* not _CP_TREE_H */
--- /dev/null
+/* 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 "class.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 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. */
+\f
+/* Subroutines of `convert'. */
+
+/* Build a thunk. What it is, is an entry point that when called will
+ adjust the this pointer (the first argument) by offset, and then
+ goto the real address of the function given by REAL_ADDR that we
+ would like called. What we return is the address of the thunk. */
+static tree
+build_thunk (offset, real_addr)
+ tree offset, real_addr;
+{
+ if (TREE_CODE (real_addr) != ADDR_EXPR
+ || TREE_CODE (TREE_OPERAND (real_addr, 0)) != FUNCTION_DECL)
+ {
+ sorry ("MI pointer to member conversion too complex");
+ return error_mark_node;
+ }
+ sorry ("MI pointer to member conversion too complex");
+ return error_mark_node;
+}
+
+/* Convert a `pointer to member' (POINTER_TYPE to METHOD_TYPE) into
+ another `pointer to method'. This may involved the creation of
+ a thunk to handle the this offset calculation. */
+static tree
+convert_fn_ptr (type, expr)
+ tree type, expr;
+{
+ tree binfo = get_binfo (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (expr))),
+ TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
+ 1);
+ if (binfo == error_mark_node)
+ {
+ error (" in pointer to member conversion");
+ return error_mark_node;
+ }
+ if (binfo == NULL_TREE)
+ {
+ /* ARM 4.8 restriction. */
+ error ("invalid pointer to member conversion");
+ return error_mark_node;
+ }
+ if (BINFO_OFFSET_ZEROP (binfo))
+ return build1 (NOP_EXPR, type, expr);
+ return build1 (NOP_EXPR, type, build_thunk (BINFO_OFFSET (binfo), expr));
+}
+
+/* if converting pointer to pointer
+ if dealing with classes, check for derived->base or vice versa
+ else if dealing with method pointers, delegate
+ else convert blindly
+ else if converting class, pass off to build_type_conversion
+ else try C-style pointer conversion */
+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);
+ }
+ }
+ }
+ if (TYPE_MAIN_VARIANT (type) != intype
+ && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
+ && TREE_CODE (type) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE)
+ return convert_fn_ptr (type, expr);
+
+ return build1 (NOP_EXPR, type, expr);
+ }
+
+ my_friendly_assert (form != OFFSET_TYPE, 186);
+
+ if (TYPE_LANG_SPECIFIC (intype)
+ && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
+ return convert_to_pointer (type, build_optr_ref (expr));
+
+ if (IS_AGGR_TYPE (intype))
+ {
+ tree rval;
+ rval = build_type_conversion (CONVERT_EXPR, type, expr, 1);
+ if (rval)
+ {
+ if (rval == error_mark_node)
+ cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
+ expr, intype, type);
+ return rval;
+ }
+ }
+
+ 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 == INTEGER_TYPE || form == ENUMERAL_TYPE)
+ {
+ if (type_precision (intype) == POINTER_SIZE)
+ return build1 (CONVERT_EXPR, type, expr);
+ expr = convert (type_for_size (POINTER_SIZE, 0), expr);
+ /* Modes may be different but sizes should be the same. */
+ if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
+ != GET_MODE_SIZE (TYPE_MODE (type)))
+ /* There is supposed to be some integral type
+ that is the same width as a pointer. */
+ abort ();
+ return convert_to_pointer (type, expr);
+ }
+
+ cp_error ("cannot convert `%E' from type `%T' to type `%T'",
+ expr, intype, type);
+ return error_mark_node;
+}
+
+/* Like convert, except permit conversions to take place which
+ are not normally allowed due to access 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;
+ }
+
+ /* Convert signature pointer/reference to `void *' first. */
+ if (form == RECORD_TYPE
+ && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
+ {
+ expr = build_optr_ref (expr);
+ intype = TREE_TYPE (expr);
+ 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 path;
+ int distance = get_base_distance (TREE_TYPE (type),
+ TREE_TYPE (intype), 0, &path);
+ if (distance == -2)
+ {
+ ambig:
+ cp_error ("type `%T' is ambiguous baseclass of `%s'", TREE_TYPE (type),
+ 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 access 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, 1);
+ if ((flags & LOOKUP_PROTECT) && binfo == error_mark_node)
+ return error_mark_node;
+ if (binfo == NULL_TREE)
+ return 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);
+ TREE_TYPE (rval) = type;
+ literal_flag = TREE_CONSTANT (rval);
+ goto done;
+ }
+ else
+ {
+ rval = build_unary_op (ADDR_EXPR, temp, 0);
+ if (binfo && !BINFO_OFFSET_ZEROP (binfo))
+ rval = convert_pointer_to (target_type, rval);
+ else
+ TREE_TYPE (rval) = type;
+
+ temp = build (MODIFY_EXPR, argtype, temp, arg);
+ TREE_SIDE_EFFECTS (temp) = 1;
+ return build (COMPOUND_EXPR, type, temp, rval);
+ }
+ }
+ }
+ else
+ 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 (TREE_CODE(type) == ARRAY_TYPE)
+ type = build_pointer_type (TREE_TYPE(type));
+ if (form == REFERENCE_TYPE)
+ intype = TREE_TYPE (intype);
+ intype = TYPE_MAIN_VARIANT (intype);
+
+ if (IS_AGGR_TYPE (intype)
+ && (rval = build_type_conversion (CONVERT_EXPR, reftype, expr, 1)))
+ {
+ if (rval == error_mark_node)
+ cp_error ("conversion from `%T' to `%T' is ambiguous",
+ intype, reftype);
+ return rval;
+ }
+
+ if (comptypes (type, intype, strict))
+ {
+ /* Section 13. */
+ if (flags & LOOKUP_COMPLAIN)
+ {
+ /* Since convert_for_initialization didn't call convert_for_assignment,
+ we have to do this checking here. FIXME: 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))
+ {
+ if (fndecl)
+ cp_pedwarn ("passing `%T' as argument %P of `%D' discards const",
+ TREE_TYPE (expr), parmnum, fndecl);
+ else
+ cp_pedwarn ("%s to `%T' from `%T' discards const",
+ errtype, reftype, TREE_TYPE (expr));
+ }
+ if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
+ {
+ if (fndecl)
+ cp_pedwarn ("passing `%T' as argument %P of `%D' discards volatile",
+ TREE_TYPE (expr), parmnum, fndecl);
+ else
+ cp_pedwarn ("%s to `%T' from `%T' discards volatile",
+ errtype, reftype, TREE_TYPE (expr));
+ }
+ } else if (TREE_CODE (reftype) == REFERENCE_TYPE
+ && ! TREE_READONLY (TREE_TYPE (reftype))
+ && ! lvalue_p (expr))
+ {
+ /* Ensure semantics of 8.4.3 */
+ if (fndecl)
+ cp_pedwarn ("ANSI C++ forbids passing non-lvalue `%T' as argument %P of `%D' into non-const &",
+ TREE_TYPE (expr), parmnum, fndecl);
+ else
+ cp_pedwarn ("ANSI C++ forbids %s to `%T' from non-lvalue `%T'",
+ errtype, reftype, TREE_TYPE (expr));
+ }
+ }
+
+ /* 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;
+ }
+ return build_up_reference (reftype, expr, flags, decl!=NULL_TREE);
+ }
+
+ if (decl == error_mark_node)
+ {
+ tree rval_as_conversion = NULL_TREE;
+ tree rval_as_ctor = NULL_TREE;
+
+ if (IS_AGGR_TYPE (intype)
+ && (rval = build_type_conversion (CONVERT_EXPR, type, expr, 1)))
+ {
+ if (rval == error_mark_node)
+ return rval;
+
+ rval_as_conversion = build_up_reference (reftype, rval, flags, 1);
+ }
+
+ /* Definitely need to go through a constructor here. */
+ if (TYPE_HAS_CONSTRUCTOR (type)
+ && (rval = build_method_call
+ (NULL_TREE, constructor_name_full (type),
+ build_tree_list (NULL_TREE, expr), TYPE_BINFO (type),
+ LOOKUP_NO_CONVERSION|LOOKUP_SPECULATIVELY)))
+ {
+ tree init;
+
+ if (global_bindings_p ())
+ {
+ extern tree static_aggregates;
+ decl = get_temp_name (type, global_bindings_p ());
+ init = build_method_call (decl, constructor_name_full (type),
+ build_tree_list (NULL_TREE, expr),
+ TYPE_BINFO (type), LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
+
+ if (init == error_mark_node)
+ return error_mark_node;
+
+ make_decl_rtl (decl, NULL_PTR, 1);
+ static_aggregates = perm_tree_cons (expr, decl, static_aggregates);
+ rval = build_unary_op (ADDR_EXPR, decl, 0);
+ }
+ else
+ {
+ init = build_method_call (NULL_TREE, constructor_name_full (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);
+ rval = build_up_reference (reftype, rval, flags, 1);
+ }
+ rval_as_ctor = rval;
+ }
+
+ if (rval_as_ctor && rval_as_conversion)
+ {
+ cp_error ("ambiguous conversion from `%T' to `%T'; both user-defined conversion and constructor apply",
+ intype, reftype);
+ return error_mark_node;
+ }
+ else if (rval_as_ctor)
+ rval = rval_as_ctor;
+ else if (rval_as_conversion)
+ rval = rval_as_conversion;
+ else if (! IS_AGGR_TYPE (type) && ! IS_AGGR_TYPE (intype))
+ {
+ rval = convert (type, expr);
+ if (rval == error_mark_node)
+ return error_mark_node;
+
+ rval = build_up_reference (reftype, rval, flags, 1);
+ }
+
+ if (rval && ! TYPE_READONLY (TREE_TYPE (reftype)))
+ cp_pedwarn ("converting `%T' to non-const `%T' will use a temporary",
+ intype, reftype);
+ }
+
+ if (rval)
+ {
+ /* If we found a way to convert earlier, then use it. */
+ return rval;
+ }
+
+ my_friendly_assert (form != OFFSET_TYPE, 189);
+
+ if ((flags & (LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY)) == LOOKUP_COMPLAIN)
+ cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
+
+ if (flags & LOOKUP_SPECULATIVELY)
+ return NULL_TREE;
+
+ 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, NULL_PTR);
+ /* 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;
+}
+\f
+/* 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 access_type access;
+ 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;
+ }
+
+ access = access_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_ACCESS (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->h_len = 2;
+ if (flag_ansi_overloading)
+ cp->v.ansi_harshness = (struct harshness_code *)
+ alloca (3 * sizeof (struct harshness_code));
+ else
+ cp->v.old_harshness = (unsigned short *)
+ alloca (3 * sizeof (short));
+
+ compute_conversion_costs (fndecl, parmlist, cp, 2);
+ if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE) == 0)
+ || (!flag_ansi_overloading && cp->evil == 0))
+ {
+ cp->u.field = fndecl;
+ if (protect)
+ {
+ if (TREE_PRIVATE (fndecl))
+ access = access_private;
+ else if (TREE_PROTECTED (fndecl))
+ access = access_protected;
+ else
+ access = access_public;
+ }
+ else
+ access = access_public;
+
+ if (access == access_private
+ ? (basetype == current_class_type
+ || is_friend (basetype, cp->function)
+ || purpose_member (basetype, DECL_ACCESS (fndecl)))
+ : access == access_protected
+ ? (can_be_protected
+ || purpose_member (basetype, DECL_ACCESS (fndecl)))
+ : 1)
+ {
+ if ((flag_ansi_overloading && cp->h.code <= TRIVIAL_CODE)
+ || (!flag_ansi_overloading
+ && cp->user == 0 && cp->b_or_d == 0
+ && cp->easy <= 1))
+ goto found_and_ok;
+ cp++;
+ }
+ else
+ {
+ if (access == access_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 ((flag_ansi_overloading && (cp->h.code & EVIL_CODE))
+ || (!flag_ansi_overloading && 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 (access == access_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 (access == access_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. This routine is like convert_pointer_to, but it pays
+ attention to which specific instance of what type we want to
+ convert to. This routine should eventually become
+ convert_to_pointer after all references to convert_to_pointer
+ are removed. */
+tree
+convert_pointer_to_real (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;
+ }
+ 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 (binfo, 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)
+ {
+ cp_error ("cannot convert a pointer of type `%T'",
+ TREE_TYPE (intype));
+ cp_error ("to a pointer of type `%T'", type);
+
+ if (distance == -2)
+ cp_error ("because `%T' is an ambiguous base class", type);
+ 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;
+}
+
+/* Call this when we know (for any reason) that expr is
+ not, in fact, zero. This routine gets a type out of the first
+ argument and uses it to search for the type to convert to. If there
+ is more than one instance of that type in the expr, the conversion is
+ ambiguous. This routine should eventually go away, and all
+ callers should use convert_to_pointer_real. */
+tree
+convert_pointer_to (binfo, expr)
+ tree binfo, expr;
+{
+ tree type;
+
+ if (TREE_CODE (binfo) == TREE_VEC)
+ type = BINFO_TYPE (binfo);
+ else if (IS_AGGR_TYPE (binfo))
+ type = binfo;
+ else
+ type = binfo;
+ return convert_pointer_to_real (type, expr);
+}
+
+/* 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;
+}
+\f
+/* 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)
+ {
+ /* We're converting to a void type; see if they have an
+ `operator void'. */
+ 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, "conversion", -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);
+ /* enum = enum, enum = int, enum = float are all errors. */
+ if (flag_int_enum_equivalence == 0
+ && TREE_CODE (type) == ENUMERAL_TYPE
+ && (form == INTEGER_TYPE || form == REAL_TYPE
+ || form == ENUMERAL_TYPE))
+ {
+ cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
+
+ if (flag_pedantic_errors)
+ return error_mark_node;
+ }
+ if (form == OFFSET_TYPE)
+ cp_error_at ("pointer-to-member expression object not composed with type `%D' object",
+ TYPE_NAME (TYPE_OFFSET_BASETYPE (intype)));
+ else if (IS_AGGR_TYPE (intype))
+ {
+ tree rval;
+ rval = build_type_conversion (CONVERT_EXPR, type, expr, 1);
+ if (rval) return rval;
+ cp_error ("`%#T' used where an `int' was expected", intype);
+ 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
+ cp_error ("`%#T' used where a floating point value was expected",
+ TREE_TYPE (e));
+ }
+ 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 of object pointers or signature pointers/references
+ to signature pointers/references. */
+
+ if (TYPE_LANG_SPECIFIC (type)
+ && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
+ {
+ tree constructor = build_signature_pointer_constructor (type, expr);
+ tree sig_ty = SIGNATURE_TYPE (type);
+ tree sig_ptr;
+
+ if (constructor == error_mark_node)
+ return error_mark_node;
+
+ sig_ptr = get_temp_name (type, 1);
+ DECL_INITIAL (sig_ptr) = constructor;
+ CLEAR_SIGNATURE (sig_ty);
+ finish_decl (sig_ptr, constructor, 0, 0);
+ SET_SIGNATURE (sig_ty);
+ TREE_READONLY (sig_ptr) = 1;
+
+ return sig_ptr;
+ }
+
+ /* 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. */
+
+ else 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_full (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_full (type),
+ build_tree_list (NULL_TREE, e),
+ TYPE_BINFO (type), LOOKUP_NORMAL);
+ if (init == error_mark_node)
+ {
+ cp_error ("in conversion to type `%T'", type);
+ 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;
+
+ cp_error ("conversion from `%T' to non-scalar type `%T' requested",
+ TREE_TYPE (expr), type);
+ return error_mark_node;
+}
+
+/* Like convert, except permit conversions to take place which
+ are not normally allowed due to access 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,
+ 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));
+
+ /* From cp-typeck.c convert_for_assignment */
+ if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
+ && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
+ || integer_zerop (e))
+ && TYPE_PTRMEMFUNC_P (type))
+ {
+ /* compatible pointer to member functions. */
+ e = build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
+ if (e == 0)
+ return error_mark_node;
+ return digest_init (type, e, (tree *)0);
+ }
+ {
+ 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_full (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 (warn_cast_qual
+ && TREE_TYPE (xtype)
+ && (TREE_READONLY (TREE_TYPE (TREE_TYPE (rval)))
+ > TREE_READONLY (TREE_TYPE (xtype))))
+ warning ("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 NULL_TREE;
+
+ 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_full (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_full (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 0 /* This is wrong; there is no standard conversion from void* to
+ anything. -jason */
+ if (code == CONVERT_EXPR && TREE_CODE (type) == POINTER_TYPE)
+ type_default = ptr_type_node;
+ else
+#endif
+ 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)
+ {
+ /* Only accept using an operator double() if there isn't a conflicting
+ operator int(). */
+ if (flag_ansi_overloading && TYPE_HAS_INT_CONVERSION (basetype))
+ {
+ error ("two possible conversions for type `%s'",
+ TYPE_NAME_STRING (type));
+ return 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);
+
+ if (TREE_CODE (type1) == REFERENCE_TYPE
+ || TREE_CODE (type1) == POINTER_TYPE)
+ type1 = TREE_TYPE (type1);
+ if (TREE_CODE (type2) == REFERENCE_TYPE
+ || TREE_CODE (type2) == POINTER_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;
+ }
+
+ if (!IS_AGGR_TYPE (type1) || !TYPE_HAS_CONVERSION (type1))
+ {
+ if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
+ cp_error ("no conversion from `%T' and `%T' to types with default `%O' ",
+ type1, type2, code);
+ else
+ cp_error ("no conversion from `%T' to type with default `%O'",
+ type1, code);
+ return 0;
+ }
+ else if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2))
+ {
+ cp_error ("no conversion from `%T' to type with default `%O'",
+ type2, code);
+ return 0;
+ }
+
+ if (TYPE_HAS_INT_CONVERSION (type1) && TYPE_HAS_REAL_CONVERSION (type1))
+ cp_warning ("ambiguous type conversion for type `%T', defaulting to int",
+ type1);
+ 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)
+ cp_error ("default type conversion for types `%T' and `%T' failed",
+ type1, type2);
+ else
+ cp_error ("default type conversion for type `%T' failed", type1);
+ return 0;
+ }
+ else if (*arg2 == 0)
+ {
+ cp_error ("default type conversion for type `%T' failed", type2);
+ 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 == NULL_TREE)
+ {
+ error ("default type conversion for type `%s' failed", name);
+ return 0;
+ }
+ return 1;
+}
--- /dev/null
+/* Process declarations and variables for C compiler.
+ Copyright (C) 1988, 1992, 1993, 1994 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 "decl.h"
+#include "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;
+
+extern int current_class_depth;
+
+/* 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;
+
+#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 void grok_op_properties PROTO((tree, int, int));
+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 delta_type_node;
+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 opaque_type_node, signature_type_node;
+tree sigtable_entry_type;
+tree maybe_gc_cleanup;
+
+/* Used for virtual function tables. */
+tree vtbl_mask;
+
+/* Array type `vtable_entry_type[]' */
+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;
+/* Used in pointer to member functions, and in vtables. */
+tree pfn_identifier, index_identifier, delta_identifier, delta2_identifier;
+tree pfn_or_delta2_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;
+
+/* 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;
+
+/* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
+ objects. */
+extern int flag_huge_objects;
+
+/* Nonzero if we want to conserve space in the .o files. We do this
+ by putting uninitialized data and runtime initialized data into
+ .common instead of .data at the expense of not flaging multiple
+ definitions. */
+extern int flag_conserve_space;
+
+/* Pointers to the base and current top of the language name stack. */
+
+extern tree *current_lang_base, *current_lang_stack;
+\f
+/* 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;
+
+/* This is a copy of the class_shadowed list of the previous class binding
+ contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
+ when entering another class scope (i.e. a cache miss). */
+extern tree previous_class_values;
+
+\f
+/* 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));
+}
+\f
+/* 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 defined(DEBUG_CP_BINDING_LEVELS)
+ /* Binding depth at which this level began. */
+ unsigned binding_depth;
+#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
+ };
+
+#define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
+
+/* The (non-class) 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;
+
+/* The current (class or non-class) binding level currently in effect. */
+
+#define inner_binding_level \
+ (class_binding_level ? class_binding_level : current_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 defined(DEBUG_CP_BINDING_LEVELS)
+static int binding_depth = 0;
+static int is_class_level = 0;
+
+static void
+indent ()
+{
+ register unsigned i;
+
+ for (i = 0; i < binding_depth*2; i++)
+ putc (' ', stderr);
+}
+#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
+
+static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
+
+static void
+push_binding_level (newlevel, tag_transparent, keep)
+ struct binding_level *newlevel;
+ int tag_transparent, keep;
+{
+ /* Add this level to the front of the chain (stack) of levels that
+ are active. */
+ *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 defined(DEBUG_CP_BINDING_LEVELS)
+ newlevel->binding_depth = binding_depth;
+ indent ();
+ fprintf (stderr, "push %s level 0x%08x line %d\n",
+ (is_class_level) ? "class" : "block", newlevel, lineno);
+ is_class_level = 0;
+ binding_depth++;
+#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
+}
+
+static void
+pop_binding_level ()
+{
+ if (class_binding_level)
+ current_binding_level = class_binding_level;
+
+ 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. */
+#if defined(DEBUG_CP_BINDING_LEVELS)
+ binding_depth--;
+ indent ();
+ fprintf (stderr, "pop %s level 0x%08x line %d\n",
+ (is_class_level) ? "class" : "block",
+ current_binding_level, lineno);
+ if (is_class_level != (current_binding_level == class_binding_level))
+#if 0 /* XXX Don't abort when we're watching how things are being managed. */
+ abort ();
+#else
+ {
+ indent ();
+ fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
+ }
+#endif
+ is_class_level = 0;
+#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
+ {
+ register struct binding_level *level = current_binding_level;
+ current_binding_level = current_binding_level->level_chain;
+ level->level_chain = free_binding_level;
+#if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
+ if (level->binding_depth != binding_depth)
+ abort ();
+#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
+ free_binding_level = level;
+
+ class_binding_level = current_binding_level;
+ if (class_binding_level->parm_flag != 2)
+ class_binding_level = 0;
+ while (current_binding_level->parm_flag == 2)
+ current_binding_level = current_binding_level->level_chain;
+ }
+}
+\f
+/* 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;
+}
+
+void
+set_class_shadows (shadows)
+ tree shadows;
+{
+ class_binding_level->class_shadowed = shadows;
+}
+
+/* Enter a new binding level.
+ If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
+ not for that of tags. */
+
+void
+pushlevel (tag_transparent)
+ int tag_transparent;
+{
+ register struct binding_level *newlevel = NULL_BINDING_LEVEL;
+
+ /* 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 defined(DEBUG_CP_BINDING_LEVELS)
+ if (0)
+#else /* !defined(DEBUG_CP_BINDING_LEVELS) */
+ if (free_binding_level)
+#endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
+ {
+ 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 ((HOST_WIDE_INT) newlevel);
+ keep_next_level_flag = 0;
+}
+
+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;
+
+ 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
+ {
+ push_function_context ();
+ output_inline_function (decl);
+ pop_function_context ();
+ }
+ }
+
+ /* 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;
+ /* If we created the block earlier on, and we are just diddling it now,
+ then it already should have a proper BLOCK_END_NOTE value associated
+ with it, so avoid trashing that. Otherwise, for a new block, install
+ a new BLOCK_END_NOTE value. */
+ if (! block_previously_created)
+ 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)
+ {
+ cp_error_at ("label `%D' used but not defined", label);
+ /* Avoid crashing later. */
+ define_label (input_filename, 1, DECL_NAME (label));
+ }
+ else if (warn_unused && !TREE_USED (label))
+ cp_warning_at ("label `%D' defined but not used", label);
+ SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), NULL_TREE);
+
+ /* 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);
+ /* Each and every BLOCK node created here in `poplevel' is important
+ (e.g. for proper debugging information) so if we created one
+ earlier, mark it as "used". */
+ if (block)
+ TREE_USED (block) = 1;
+ block = poplevel (keep, reverse, real_functionbody);
+ }
+
+ /* Each and every BLOCK node created here in `poplevel' is important
+ (e.g. for proper debugging information) so if we created one
+ earlier, mark it as "used". */
+ if (block)
+ TREE_USED (block) = 1;
+ 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 ()
+{
+ register struct binding_level *newlevel;
+
+ /* Reuse or create a struct for this binding level. */
+#if defined(DEBUG_CP_BINDING_LEVELS)
+ if (0)
+#else /* !defined(DEBUG_CP_BINDING_LEVELS) */
+ if (free_binding_level)
+#endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
+ {
+ 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));
+ }
+
+#if defined(DEBUG_CP_BINDING_LEVELS)
+ is_class_level = 1;
+#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
+
+ push_binding_level (newlevel, 0, 0);
+
+ decl_stack = push_decl_level (decl_stack, &decl_obstack);
+ class_binding_level = current_binding_level;
+ class_binding_level->parm_flag = 2;
+ /* We have just pushed into a new binding level. Now, fake out the rest
+ of the compiler. Set the `current_binding_level' back to point to
+ the most closely containing non-class binding level. */
+ do
+ {
+ current_binding_level = current_binding_level->level_chain;
+ }
+ while (current_binding_level->parm_flag == 2);
+}
+
+/* ...and a poplevel for class declarations. */
+tree
+poplevel_class ()
+{
+ register struct binding_level *level = class_binding_level;
+ tree block = NULL_TREE;
+ tree shadowed;
+
+ my_friendly_assert (level != 0, 354);
+
+ decl_stack = pop_stack_level (decl_stack);
+ for (shadowed = level->shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
+ IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
+ /* If we're leaving a toplevel class, don't bother to do the setting
+ of IDENTIFER_CLASS_VALUE to NULL_TREE, since first of all this slot
+ shouldn't even be used when current_class_type isn't set, and second,
+ if we don't touch it here, we're able to use the caching effect if the
+ next time we're entering a class scope, it is the same class. */
+ if (current_class_depth != 1)
+ for (shadowed = level->class_shadowed;
+ shadowed;
+ shadowed = TREE_CHAIN (shadowed))
+ IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
+ else
+ /* Remember to save what IDENTIFIER's were bound in this scope so we
+ can recover from cache misses. */
+ previous_class_values = class_binding_level->class_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);
+
+ if (class_binding_level->parm_flag != 2)
+ class_binding_level = (struct binding_level *)0;
+
+ /* Now, pop out of the the binding level which we created up in the
+ `pushlevel_class' routine. */
+#if defined(DEBUG_CP_BINDING_LEVELS)
+ is_class_level = 1;
+#endif /* defined(DEBUG_CP_BINDING_LEVELS) */
+
+ pop_binding_level ();
+
+ return block;
+}
+\f
+/* 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);
+}
+\f
+/* 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;
+ tree previous_class_type;
+};
+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;
+
+ /* Have to include global_binding_level, because class-level decls
+ aren't listed anywhere useful. */
+ for (; b; b = b->level_chain)
+ {
+ tree t;
+
+ if (b == global_binding_level)
+ continue;
+
+ for (t = b->names; t; t = TREE_CHAIN (t))
+ {
+ 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;
+ }
+ TREE_CHAIN (binding) = old_bindings;
+ old_bindings = binding;
+ skip_it:
+ ;
+ }
+ /* Unwind type-value slots back to top level. */
+ for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
+ SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
+ }
+ /* Clear out class-level bindings cache. */
+ if (current_binding_level == global_binding_level
+ && previous_class_type != NULL_TREE)
+ {
+ popclass (-1);
+ previous_class_type = NULL_TREE;
+ }
+
+ 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;
+ s->previous_class_type = previous_class_type;
+ current_class_name = current_class_type = current_class_decl = NULL_TREE;
+ current_function_decl = NULL_TREE;
+ class_binding_level = (struct binding_level *)0;
+ previous_class_type = NULL_TREE;
+
+ s->prev = current_saved_scope;
+ s->old_bindings = old_bindings;
+ current_saved_scope = s;
+}
+
+void
+pop_from_top_level ()
+{
+ struct saved_scope *s = current_saved_scope;
+ tree t;
+
+ if (previous_class_type)
+ previous_class_type = NULL_TREE;
+
+ 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;
+ previous_class_type = s->previous_class_type;
+ free (s);
+}
+\f
+/* Push a definition of struct, union or enum tag "name".
+ into binding_level "b". "type" should be the type node,
+ We assume that the tag "name" is not already defined.
+
+ Note that the definition may really be just a forward reference.
+ In that case, the TYPE_SIZE will be a NULL_TREE.
+
+ C++ gratuitously puts all these tags in the name space. */
+
+/* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
+ record the shadowed value for this binding contour. TYPE is
+ the type that ID maps to. */
+
+static void
+set_identifier_type_value_with_scope (id, type, b)
+ tree id;
+ tree type;
+ struct binding_level *b;
+{
+ if (b != global_binding_level)
+ {
+ tree old_type_value = IDENTIFIER_TYPE_VALUE (id);
+ b->type_shadowed
+ = tree_cons (id, old_type_value, b->type_shadowed);
+ }
+ SET_IDENTIFIER_TYPE_VALUE (id, type);
+}
+
+/* As set_identifier_type_value_with_scope, but using inner_binding_level. */
+
+void
+set_identifier_type_value (id, type)
+ tree id;
+ tree type;
+{
+ set_identifier_type_value_with_scope (id, type, inner_binding_level);
+}
+
+/* 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);
+
+ /* This is a special usage of IDENTIFIER_TYPE_VALUE which have no
+ correspondence in any binding_level. This is ok since the
+ DECL_NESTED_TYPENAME is just a convenience identifier whose
+ IDENTIFIER_TYPE_VALUE will remain constant from now on. */
+ 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
+ {
+ /* XXX: Typedef for unnamed struct; some other situations.
+ TYPE_NAME is null; what's right here? */
+ }
+ return decl;
+}
+#endif
+
+/* Push a tag name NAME for struct/class/union/enum type TYPE.
+ Normally put into into the inner-most non-tag-tranparent scope,
+ but if GLOBALIZE is true, put it in the inner-most non-class scope.
+ The latter is needed for implicit declarations. */
+
+void
+pushtag (name, type, globalize)
+ tree name, type;
+ int globalize;
+{
+ register struct binding_level *b;
+ tree t_context = 0;
+
+ b = inner_binding_level;
+ while (b->tag_transparent
+ || (globalize && b->parm_flag == 2))
+ 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)
+ {
+ t_context = type ? TYPE_CONTEXT(type) : NULL_TREE;
+ if (!t_context && !globalize)
+ t_context = current_class_type;
+
+ /* 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
+ || b->parm_flag != 2
+ || !CLASSTYPE_DECLARED_EXCEPTION (type)))
+ {
+ register tree d;
+ int newdecl = 0;
+
+ if (b->parm_flag != 2
+ || TYPE_SIZE (current_class_type) != NULL_TREE)
+ {
+ if (current_lang_name == lang_name_cplusplus)
+ d = lookup_nested_type (type,
+ t_context ? TYPE_NAME (t_context) : NULL_TREE);
+ else
+ d = NULL_TREE;
+
+ if (d == NULL_TREE)
+ {
+ newdecl = 1;
+#if 0 /* not yet, should get fixed properly later */
+ d = make_type_decl (name, type);
+#else
+ d = build_decl (TYPE_DECL, name, type);
+#endif
+#ifdef DWARF_DEBUGGING_INFO
+ if (write_symbols == DWARF_DEBUG)
+ {
+ /* Mark the TYPE_DECL node we created just above as an
+ gratuitous one. We need to do this so that dwarfout.c
+ will understand that it is not supposed to output a
+ TAG_typedef DIE for it. */
+ DECL_IGNORED_P (d) = 1;
+ }
+#endif /* DWARF_DEBUGGING_INFO */
+ set_identifier_type_value_with_scope (name, type, b);
+ }
+ 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 (b->parm_flag == 2)
+ d = pushdecl_class_level (d);
+ else
+ d = pushdecl_with_scope (d, b);
+ }
+ }
+ else
+ {
+ /* Make nested declarations go into class-level scope. */
+ newdecl = 1;
+ d = build_lang_field_decl (TYPE_DECL, name, type);
+#ifdef DWARF_DEBUGGING_INFO
+ if (write_symbols == DWARF_DEBUG)
+ {
+ /* Mark the TYPE_DECL node we created just above as an
+ gratuitous one. We need to do this so that dwarfout.c
+ will understand that it is not supposed to output a
+ TAG_typedef DIE for it. */
+ DECL_IGNORED_P (d) = 1;
+ }
+#endif /* DWARF_DEBUGGING_INFO */
+ /* Make sure we're in this type's scope when we push the
+ decl for a template, otherwise class_binding_level will
+ be NULL and we'll end up dying inside of
+ push_class_level_binding. */
+ if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
+ pushclass (type, 0);
+ d = pushdecl_class_level (d);
+ if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
+ popclass (0);
+ }
+ if (write_symbols != DWARF_DEBUG)
+ {
+ if (ANON_AGGRNAME_P (name))
+ DECL_IGNORED_P (d) = 1;
+ }
+ TYPE_NAME (type) = d;
+
+ if ((t_context == 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)
+*/
+ else if (t_context && TREE_CODE (t_context) == RECORD_TYPE)
+ {
+ /* Class-nested class. */
+ set_nested_typename (d,
+ DECL_NESTED_TYPENAME (TYPE_NAME (t_context)), name, type);
+ /* This builds the links for classes nested in type scope. */
+ DECL_CONTEXT (d) = t_context;
+ DECL_CLASS_CONTEXT (d) = t_context;
+ }
+ TYPE_CONTEXT (type) = DECL_CONTEXT (d);
+ if (newdecl)
+ DECL_ASSEMBLER_NAME (d)
+ = get_identifier (build_overload_name (type, 1, 1));
+ }
+ if (b->parm_flag == 2)
+ {
+ TREE_NONLOCAL_FLAG (type) = 1;
+ 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 */
+ tree d = make_type_decl (NULL_TREE, type);
+#else
+ tree d = build_decl (TYPE_DECL, NULL_TREE, type);
+#endif
+ TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
+ }
+}
+
+/* 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;
+}
+\f
+/* Subroutine of duplicate_decls: return truthvalue of whether
+ or not types of these decls match.
+
+ For C++, we must compare the parameter list so that `int' can match
+ `int&' in a parameter position, but `int&' is not confused with
+ `const int&'. */
+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)
+ cp_compiler_error ("`%D' redeclared as member function", newdecl);
+ else
+ cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
+ return 0;
+ }
+
+ if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (f1)),
+ TYPE_MAIN_VARIANT (TREE_TYPE (f2)), 2))
+ types_match = compparms (p1, p2, 2);
+ 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;
+}
+
+/* If NEWDECL is `static' and an `extern' was seen previously,
+ warn about it. (OLDDECL may be NULL_TREE; NAME contains
+ information about previous usage as an `extern'.)
+
+ Note that this does not apply to the C++ case of declaring
+ a variable `extern const' and then later `const'.
+
+ Don't complain if -traditional, since traditional compilers
+ don't complain.
+
+ Don't complain about built-in functions, since they are beyond
+ the user's control. */
+
+static void
+warn_extern_redeclared_static (newdecl, olddecl)
+ tree newdecl, olddecl;
+{
+ tree name;
+
+ static char *explicit_extern_static_warning
+ = "`%D' was declared `extern' and later `static'";
+ static char *implicit_extern_static_warning
+ = "`%D' was declared implicitly `extern' and later `static'";
+
+ if (flag_traditional
+ || TREE_CODE (newdecl) == TYPE_DECL
+ || (! warn_extern_inline
+ && DECL_INLINE (newdecl)))
+ return;
+
+ name = DECL_ASSEMBLER_NAME (newdecl);
+ if (TREE_PUBLIC (name) && ! TREE_PUBLIC (newdecl))
+ {
+ /* It's okay to redeclare an ANSI built-in function as static,
+ or to declare a non-ANSI built-in function as anything. */
+ if (! (TREE_CODE (newdecl) == FUNCTION_DECL
+ && olddecl != NULL_TREE
+ && TREE_CODE (olddecl) == FUNCTION_DECL
+ && (DECL_BUILT_IN (olddecl)
+ || DECL_BUILT_IN_NONANSI (olddecl))))
+ {
+ cp_warning (IDENTIFIER_IMPLICIT_DECL (name)
+ ? implicit_extern_static_warning
+ : explicit_extern_static_warning, newdecl);
+ if (olddecl != NULL_TREE)
+ cp_warning_at ("previous declaration of `%D'", olddecl);
+ }
+ }
+}
+
+/* Handle when a new declaration NEWDECL has the same name as an old
+ one OLDDECL in the same binding contour. Prints an error message
+ if appropriate.
+
+ If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
+ Otherwise, return 0. */
+
+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 = 0;
+ int new_defines_function;
+ tree previous_c_decl = NULL_TREE;
+
+ if (TREE_CODE (newdecl) == FUNCTION_DECL
+ && is_overloaded_fn (olddecl))
+ {
+ olddecl = get_first_fn (olddecl);
+
+ while (olddecl)
+ {
+ if (DECL_LANGUAGE (olddecl) == lang_c)
+ previous_c_decl = olddecl;
+
+ /* Redeclaration. */
+ if (decls_match (newdecl, olddecl))
+ {
+ types_match = 1;
+ break;
+ }
+ /* Ambiguous overload. */
+ else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
+ TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 2))
+ break;
+
+ /* Attempt to define multiple C-binding fns. */
+ if (previous_c_decl)
+ break;
+
+ olddecl = DECL_CHAIN (olddecl);
+ }
+ if (!olddecl)
+ {
+ /* If we found no match, make this join the other
+ overloaded decls. */
+ DECL_OVERLOADED (newdecl) = 1;
+ return 1;
+ }
+ }
+ else
+ types_match = decls_match (newdecl, olddecl);
+
+ if (TREE_CODE (olddecl) != TREE_LIST)
+ olddecl_friend = DECL_LANG_SPECIFIC (olddecl) && DECL_FRIEND_P (olddecl);
+
+ /* If either the type of the new decl or the type of the old decl is an
+ error_mark_node, then that implies that we have already issued an
+ error (earlier) for some bogus type specification, and in that case,
+ it is rather pointless to harass the user with yet more error message
+ about the same declaration, so well just pretent the types match here. */
+ if ((TREE_TYPE (newdecl)
+ && TREE_CODE (TREE_TYPE (newdecl)) == ERROR_MARK)
+ || (TREE_TYPE (olddecl)
+ && TREE_CODE (TREE_TYPE (olddecl)) == ERROR_MARK))
+ types_match = 1;
+
+ if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
+ {
+ cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
+ if (TREE_CODE (olddecl) == TREE_LIST)
+ olddecl = TREE_VALUE (olddecl);
+ cp_error_at ("previous declaration of `%#D'", olddecl);
+
+ /* New decl is completely inconsistent with the old one =>
+ tell caller to replace the old one. */
+
+ return 0;
+ }
+
+ 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)
+ || DECL_BUILT_IN_NONANSI (olddecl)))
+ {
+ /* If you declare a built-in or predefined function name as static,
+ the old definition is overridden,
+ but optionally warn this was a bad choice of name. */
+ if (! TREE_PUBLIC (newdecl))
+ {
+ if (warn_shadow)
+ cp_warning ("shadowing %s function `%#D'",
+ DECL_BUILT_IN (olddecl) ? "built-in" : "library",
+ newdecl);
+ /* Discard the old built-in function. */
+ return 0;
+ }
+ /* Likewise, if the built-in is not ansi, then programs can
+ override it even globally without an error. */
+ else if (! DECL_BUILT_IN (olddecl))
+ cp_warning ("library function `%#D' declared as non-function",
+ newdecl);
+
+ if (!types_match)
+ {
+ cp_warning ("declaration of `%#D'", newdecl);
+ cp_warning ("conflicts with built-in declaration `%#D'",
+ olddecl);
+ return 0;
+ }
+ }
+ else if (!types_match && previous_c_decl
+ && DECL_LANGUAGE (newdecl) == lang_c)
+ {
+ cp_error ("declaration of C function `%#D' conflicts with", newdecl);
+ cp_error_at ("previous declaration `%#D' here", previous_c_decl);
+ }
+ 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;
+
+ /* Since we're doing this before finish_struct can set the
+ line number on NEWDECL, we just do a regular error here. */
+ if (DECL_SOURCE_LINE (newdecl) == 0)
+ cp_error ("conflicting types for `%#D'", newdecl);
+ else
+ cp_error_at ("conflicting types for `%#D'", newdecl);
+ }
+
+ /* 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)
+ {
+ give_error = 1;
+ 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))
+ {
+ give_error = 1;
+ error ("An argument type that has a default promotion");
+ error ("can't match an empty parameter name list declaration.");
+ break;
+ }
+ }
+ }
+ if (give_error)
+ cp_error_at ("previous declaration as `%#D'", olddecl);
+
+ /* 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)
+ cp_error_at ((DECL_INITIAL (olddecl)
+ && current_binding_level == global_binding_level)
+ ? "`%#D' previously defined here"
+ : "`%#D' previously declared here", olddecl);
+ }
+ else if (TREE_CODE (olddecl) == FUNCTION_DECL
+ && DECL_INITIAL (olddecl) != NULL_TREE
+ && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
+ && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
+ {
+ /* Prototype decl follows defn w/o prototype. */
+ cp_warning_at ("prototype for `%#D'", newdecl);
+ cp_warning_at ("follows non-prototype definition here", olddecl);
+ }
+ else if (TREE_CODE (olddecl) == FUNCTION_DECL
+ && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
+ /* extern "C" int foo ();
+ int foo () { bar (); }
+ is OK. */
+ if (current_lang_stack == current_lang_base)
+ DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
+ else
+ {
+ cp_error_at ("previous declaration of `%#D' with %L linkage",
+ olddecl, DECL_LANGUAGE (olddecl));
+ cp_error ("conflicts with new declaration with %L linkage",
+ DECL_LANGUAGE (newdecl));
+ }
+
+ /* These bits are logically part of the type. */
+ if (pedantic
+ && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
+ || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
+ cp_error_at ("type qualifiers for `%D' conflict with previous decl", newdecl);
+ }
+
+ /* If new decl is `static' and an `extern' was seen previously,
+ warn about it. */
+ warn_extern_redeclared_static (newdecl, olddecl);
+
+ /* We have committed to returning 1 at this point. */
+ if (TREE_CODE (newdecl) == FUNCTION_DECL)
+ {
+ /* Now that functions must hold information normally held
+ by field decls, there is extra work to do so that
+ declaration information does not get destroyed during
+ definition. */
+ if (DECL_VINDEX (olddecl))
+ DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
+ if (DECL_CONTEXT (olddecl))
+ DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
+ 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);
+ }
+
+ /* Deal with C++: must preserve virtual function table size. */
+ if (TREE_CODE (olddecl) == TYPE_DECL)
+ {
+ register tree newtype = TREE_TYPE (newdecl);
+ register tree oldtype = TREE_TYPE (olddecl);
+
+ if (newtype != error_mark_node && oldtype != error_mark_node
+ && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
+ {
+ CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
+ CLASSTYPE_FRIEND_CLASSES (newtype)
+ = CLASSTYPE_FRIEND_CLASSES (oldtype);
+ }
+ /* 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)
+ /* Don't warn about extern decl followed by (tentative) definition. */
+ && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
+ {
+ cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
+ cp_warning ("previous declaration of `%D'", olddecl);
+ }
+
+ /* 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))
+ {
+ cp_error ("declaration of `%D' raises different exceptions...", newdecl);
+ cp_error_at ("...from previous declaration here", olddecl);
+ }
+ }
+ 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);
+ DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
+
+ /* Don't really know how much of the language-specific
+ values we should copy from old to new. */
+ if (DECL_LANG_SPECIFIC (olddecl))
+ {
+ DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
+ DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
+ }
+
+ 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));
+
+ /* Can we safely free the storage used by newdecl? */
+
+#define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
+ & ~ obstack_alignment_mask (&permanent_obstack))
+
+ if ((char *)newdecl + ROUND (function_size)
+ + ROUND (sizeof (struct lang_decl))
+ == 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;
+
+ return 1;
+}
+
+/* Record a decl-node X as belonging to the current lexical scope.
+ Check for errors (such as an incompatible declaration for the same
+ name already seen in the same scope).
+
+ Returns either X or an old decl for the same name.
+ If an old decl is returned, it may have been smashed
+ to agree with what X says. */
+
+tree
+pushdecl (x)
+ tree x;
+{
+ register tree t;
+#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))
+ 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;
+ cp_error_at ("`%#D' used prior to declaration", x);
+ }
+
+ 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) || is_overloaded_fn (t)))
+ {
+ 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 0
+ /* This is turned off until I have time to do it right (bpk). */
+
+ /* Also warn if they did a prototype with `static' on it, but
+ then later left the `static' off. */
+ else if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
+ {
+ if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
+ return t;
+
+ if (extra_warnings)
+ {
+ cp_warning ("`static' missing from declaration of `%D'", t);
+ warning_with_file_and_line (file, line,
+ "previous declaration of `%s'",
+ decl_as_string (t, 0));
+ }
+
+ /* Now fix things so it'll do what they expect. */
+ if (current_function_decl)
+ TREE_PUBLIC (current_function_decl) = 0;
+ }
+#endif
+
+ /* 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;
+
+ 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. */
+ if (TREE_CODE (x) == TYPE_DECL)
+ {
+ tree type = TREE_TYPE (x);
+ tree name = (type != error_mark_node) ? TYPE_NAME (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 (type) = 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), 0);
+ }
+ }
+ 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), type);
+
+ if (type != error_mark_node
+ && TYPE_NAME (type)
+ && TYPE_IDENTIFIER (type))
+ set_identifier_type_value_with_scope (DECL_NAME (x), type, b);
+ }
+
+ /* Multiple external decls of the same identifier ought to match.
+
+ We get warnings about inline functions where they are defined.
+ Avoid duplicate warnings where they are used. */
+ if (TREE_PUBLIC (x) && !DECL_INLINE (x))
+ {
+ tree decl;
+
+ if (IDENTIFIER_GLOBAL_VALUE (name) != NULL_TREE
+ && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
+ || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
+ decl = IDENTIFIER_GLOBAL_VALUE (name);
+ else
+ decl = NULL_TREE;
+
+ if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl), 1)
+ /* If different sort of thing, we already gave an error. */
+ && TREE_CODE (decl) == TREE_CODE (x)
+ /* If old decl is built-in, we already warned if we should. */
+ && !DECL_BUILT_IN (decl))
+ {
+ cp_pedwarn ("type mismatch with previous external decl", x);
+ cp_pedwarn_at ("previous external decl of `%D'", decl);
+ }
+ }
+
+ /* 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)
+ IDENTIFIER_GLOBAL_VALUE (name) = x;
+
+ /* Don't forget if the function was used via an implicit decl. */
+ if (IDENTIFIER_IMPLICIT_DECL (name)
+ && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
+ TREE_USED (x) = 1;
+
+ /* Don't forget if its address was taken in that way. */
+ if (IDENTIFIER_IMPLICIT_DECL (name)
+ && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
+ TREE_ADDRESSABLE (x) = 1;
+
+ /* Warn about mismatches against previous implicit decl. */
+ if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
+ /* If this real decl matches the implicit, don't complain. */
+ && ! (TREE_CODE (x) == FUNCTION_DECL
+ && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
+ cp_warning
+ ("`%D' was previously implicitly declared to return `int'", x);
+
+ /* If new decl is `static' and an `extern' was seen previously,
+ warn about it. */
+ warn_extern_redeclared_static (x, t);
+ }
+ else
+ {
+ /* Here to install a non-global value. */
+ tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
+ tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
+
+ b->shadowed = tree_cons (name, oldlocal, b->shadowed);
+ IDENTIFIER_LOCAL_VALUE (name) = x;
+
+ /* If this is a TYPE_DECL, push it into the type value slot. */
+ if (TREE_CODE (x) == TYPE_DECL)
+ set_identifier_type_value_with_scope (name, TREE_TYPE (x), b);
+
+ /* 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))
+ {
+ cp_warning ("extern declaration of `%#D' doesn't match", x);
+ cp_warning_at ("global declaration `%#D'", oldglobal);
+ }
+ 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_FRAME_SIZE (x) = DECL_FRAME_SIZE (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)
+ cp_error ("declaration of `%#D' shadows a parameter", 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
+ && !TREE_STATIC (name))
+ 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)
+ {
+ if (current_class_name)
+ {
+ if (!DECL_NESTED_TYPENAME (x))
+ set_nested_typename (x, current_class_name, DECL_NAME (x),
+ TREE_TYPE (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;
+}
+
+/* Same as pushdecl, but define X in binding-level LEVEL. */
+
+static tree
+pushdecl_with_scope (x, level)
+ tree x;
+ struct binding_level *level;
+{
+ register struct binding_level *b = current_binding_level;
+
+ current_binding_level = level;
+ x = pushdecl (x);
+ current_binding_level = b;
+ return x;
+}
+
+/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
+ if appropriate. */
+tree
+pushdecl_top_level (x)
+ tree x;
+{
+ register struct binding_level *b = inner_binding_level;
+ register tree t = pushdecl_with_scope (x, global_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)
+ {
+ push_class_level_binding (name, x);
+ if (TREE_CODE (x) == TYPE_DECL)
+ {
+ set_identifier_type_value (name, TREE_TYPE (x));
+ if (!DECL_NESTED_TYPENAME (x))
+ set_nested_typename (x, current_class_name, name, TREE_TYPE (x));
+ }
+ }
+ return x;
+}
+
+/* Make the declaration(s) of X appear in CLASS scope
+ under the name NAME. */
+void
+push_class_level_binding (name, x)
+ tree name;
+ tree x;
+{
+ maybe_push_cache_obstack ();
+ class_binding_level->class_shadowed
+ = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
+ class_binding_level->class_shadowed);
+ pop_obstacks ();
+ IDENTIFIER_CLASS_VALUE (name) = x;
+ obstack_ptr_grow (&decl_obstack, 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 (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);
+
+ if (glob)
+ {
+ if (DECL_LANGUAGE (decl) == lang_c)
+ {
+ tree decls = get_first_fn (glob);
+ while (decls && DECL_LANGUAGE (decls) == lang_cplusplus)
+ decls = DECL_CHAIN (decls);
+ if (decls)
+ {
+ cp_error_at ("C-language function `%#D'", decls);
+ cp_error ("overloaded as `%#D'", decl);
+ }
+ }
+
+ /* 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);
+
+ else if (TREE_CODE (decl) == TEMPLATE_DECL)
+ {
+ tree tmp;
+
+ for (tmp = get_first_fn (glob); tmp; tmp = DECL_CHAIN (tmp))
+ if (decl == tmp)
+ return decl;
+ }
+ else if (TREE_CODE (glob) == VAR_DECL)
+ {
+ cp_error_at ("previous non-function declaration `%#D'", glob);
+ cp_error ("conflicts with function declaration `%#D'", decl);
+ return error_mark_node;
+ }
+ else if (is_overloaded_fn (glob))
+ {
+ tree name = DECL_ASSEMBLER_NAME (decl);
+ tree tmp;
+
+ for (tmp = get_first_fn (glob); tmp; tmp = DECL_CHAIN (tmp))
+ {
+ if (TREE_CODE (tmp) == FUNCTION_DECL
+ && comptypes (TREE_TYPE (tmp), TREE_TYPE (decl), 2))
+ {
+ if (DECL_LANGUAGE (tmp) != DECL_LANGUAGE (decl))
+ {
+ if (current_lang_stack == current_lang_base)
+ {
+ DECL_LANGUAGE (decl) = DECL_LANGUAGE (tmp);
+ return tmp;
+ }
+ cp_error_at ("previous declaration of `%#D' with %L linkage",
+ tmp, DECL_LANGUAGE (tmp));
+ cp_error ("conflicts with new %L-language declaration",
+ DECL_LANGUAGE (decl));
+ }
+ else if (TREE_CODE (tmp) != TEMPLATE_DECL
+ && DECL_ASSEMBLER_NAME (tmp) != name)
+ {
+ cp_error ("new declaration `%#D'", decl);
+ cp_error_at ("ambiguates old declaration `%#D'", tmp);
+ }
+ }
+ /* If we really have seen this before, then if it ambiguates
+ something, we've already given an error before. */
+ if (TREE_CODE (tmp) != TEMPLATE_DECL
+ && DECL_ASSEMBLER_NAME (tmp) == name)
+ return decl;
+ }
+ }
+ }
+ if (glob || TREE_CODE (decl) == TEMPLATE_DECL)
+ {
+ if (glob && is_overloaded_fn (glob))
+ DECL_CHAIN (decl) = get_first_fn (glob);
+ else
+ DECL_CHAIN (decl) = NULL_TREE;
+ glob = tree_cons (orig_name, decl, NULL_TREE);
+ TREE_TYPE (glob) = unknown_type_node;
+ }
+ else
+ /* orig_name is not ambiguous. */
+ glob = decl;
+
+ IDENTIFIER_GLOBAL_VALUE (orig_name) = glob;
+ return decl;
+}
+\f
+/* 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)
+ {
+ cp_pedwarn ("implicit declaration of function `%#D'", decl);
+ }
+
+ 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 (comptypes (newdecl, olddecl, 0))
+ 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;
+ }
+}
+\f
+/* 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 (current_function_decl == NULL_TREE)
+ {
+ error ("label `%s' referenced outside of any function",
+ IDENTIFIER_POINTER (id));
+ return NULL_TREE;
+ }
+
+ if ((decl == NULL_TREE
+ || DECL_SOURCE_LINE (decl) == 0)
+ && (named_label_uses == NULL_TREE
+ || 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, NULL_TREE);
+ SET_IDENTIFIER_LABEL_VALUE (decl, NULL_TREE);
+ }
+
+ 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, NULL_TREE);
+ decl = lookup_label (name);
+ }
+
+ if (DECL_INITIAL (decl) != NULL_TREE)
+ {
+ cp_error ("duplicate label `%D'", decl);
+ 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)
+ cp_error ("invalid jump to label `%D'", decl);
+ SET_IDENTIFIER_ERROR_LOCUS (decl, current_function_decl);
+ cp_error ("crosses initialization of `%D'", new_decls);
+ }
+ 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;
+ cp_error_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
+ 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;
+}
+\f
+/* 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;
+}
+\f
+/* 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. */
+ cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
+ form);
+ }
+ 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)))
+ {
+ tree these_tags;
+ case 't':
+ 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)
+ {
+ cp_error ("`%#D' redeclared as %C in class scope",
+ TREE_VALUE (tail), form);
+ }
+ 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;
+}
+\f
+/* 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 = NULL_TREE;
+
+ if (current_binding_level == global_binding_level)
+ {
+ t = IDENTIFIER_GLOBAL_VALUE (name);
+
+ /* extern "C" function() */
+ if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
+ t = TREE_VALUE (t);
+ }
+ else if (IDENTIFIER_LOCAL_VALUE (name) != NULL_TREE)
+ {
+ for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
+ if (DECL_NAME (t) == name)
+ break;
+ }
+
+ return t;
+}
+\f
+/* 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
+signal_catch (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
+#ifdef SIGBUS
+ signal (SIGBUS, 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);
+
+ TYPE_BUILT_IN (type) = 1;
+
+ 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;
+#if 0 /* Not yet. */
+ /* Data type of strncpy. */
+ tree strncpy_ftype;
+#endif
+ int wchar_type_size;
+ tree temp;
+ tree array_domain_type;
+
+ /* 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, signal_catch);
+
+ /* We will also catch aborts in the back-end through signal_catch 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, signal_catch);
+#endif
+#ifdef SIGILL
+ signal (SIGILL, signal_catch);
+#endif
+#ifdef SIGABRT
+ signal (SIGABRT, signal_catch);
+#endif
+#ifdef SIGBUS
+ signal (SIGBUS, signal_catch);
+#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);
+ pfn_identifier = get_identifier (VTABLE_PFN_NAME);
+ index_identifier = get_identifier (VTABLE_INDEX_NAME);
+ delta_identifier = get_identifier (VTABLE_DELTA_NAME);
+ delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
+ pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
+
+ /* 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);
+
+ 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);
+
+ 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);
+
+ /* `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. */
+ sizetype
+ = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
+ if (flag_traditional && TREE_UNSIGNED (sizetype))
+ sizetype = signed_type (sizetype);
+
+ 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;
+ TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype;
+ TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype;
+
+ short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
+ record_builtin_type (RID_SHORT, "short int", short_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);
+
+ /* 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_PTR, 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_PTR, 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_PTR, 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_PTR, string_type_node);
+
+ /* Make a type to be the domain of a few array types
+ whose domains don't really matter.
+ 200 is small enough that it always fits in size_t
+ and large enough that it can hold most function names for the
+ initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
+ array_domain_type = build_index_type (build_int_2 (200, 0));
+
+ /* make a type for arrays of characters.
+ With luck nothing will ever really depend on the length of this
+ array type. */
+ char_array_type_node
+ = build_array_type (char_type_node, array_domain_type);
+ /* Likewise for arrays of ints. */
+ int_array_type_node
+ = build_array_type (integer_type_node, array_domain_type);
+
+ /* 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, 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)));
+
+#if 0
+ /* Not yet. */
+ strncpy_ftype /* strncpy prototype */
+ = build_function_type (string_type_node,
+ tree_cons (NULL_TREE, string_type_node,
+ tree_cons (NULL_TREE, const_string_type_node,
+ tree_cons (NULL_TREE,
+ sizetype,
+ endlink))));
+#endif
+
+ 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))));
+
+ if (flag_huge_objects)
+ delta_type_node = long_integer_type_node;
+ else
+ delta_type_node = short_integer_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);
+
+ /* Untyped call and return. */
+ builtin_function ("__builtin_apply_args",
+ build_function_type (ptr_type_node, NULL_TREE),
+ BUILT_IN_APPLY_ARGS, NULL_PTR);
+
+ temp = tree_cons (NULL_TREE,
+ build_pointer_type (build_function_type (void_type_node,
+ NULL_TREE)),
+ tree_cons (NULL_TREE,
+ ptr_type_node,
+ tree_cons (NULL_TREE,
+ sizetype,
+ endlink)));
+ builtin_function ("__builtin_apply",
+ build_function_type (ptr_type_node, temp),
+ BUILT_IN_APPLY, NULL_PTR);
+ builtin_function ("__builtin_return",
+ build_function_type (void_type_node,
+ tree_cons (NULL_TREE,
+ ptr_type_node,
+ endlink)),
+ BUILT_IN_RETURN, 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");
+#if 0
+ /* Not yet. */
+ builtin_function ("__builtin_strncpy", strncpy_ftype,
+ BUILT_IN_STRNCPY, "strncpy");
+#endif
+ 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);
+#if 0
+ /* Not yet. */
+ builtin_function ("strncpy", strncpy_ftype, BUILT_IN_STRNCPY, NULL_PTR);
+#endif
+ 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 for handling opaque types in signatures. */
+ opaque_type_node = copy_node (ptr_type_node);
+ TYPE_MAIN_VARIANT (opaque_type_node) = opaque_type_node;
+ record_builtin_type (RID_MAX, 0, opaque_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, array_domain_type);
+
+ /* 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, delta_identifier, delta_type_node);
+ fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier, delta_type_node);
+ fields[2] = build_lang_field_decl (FIELD_DECL, pfn_identifier, 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]) = delta_type_node;
+ DECL_NAME (fields[3]) = delta2_identifier;
+ DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
+ DECL_SIZE (fields[3]) = TYPE_SIZE (delta_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);
+
+#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 (vtable_entry_type, NULL_TREE);
+ layout_type (vtbl_type_node);
+ vtbl_type_node = build_type_variant (vtbl_type_node, 1, 0);
+ record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
+
+ /* Simplify life by making a "sigtable_entry_type". Give its
+ fields names so that the debugger can use them. */
+
+ if (flag_handle_signatures)
+ {
+ sigtable_entry_type = make_lang_type (RECORD_TYPE);
+ fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier (SIGTABLE_CODE_NAME), short_integer_type_node);
+ fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier (SIGTABLE_OFFSET_NAME), short_integer_type_node);
+ fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier (SIGTABLE_PFN_NAME), ptr_type_node);
+ finish_builtin_type (sigtable_entry_type, SIGTABLE_PTR_TYPE, fields, 2,
+ double_type_node);
+ sigtable_entry_type = build_type_variant (sigtable_entry_type, 1, 0);
+ record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_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;
+#if 0
+ /* This causes uneccessary emission of inline functions. */
+ flag_default_inline = 0;
+#endif
+ }
+ if (flag_cadillac)
+ init_cadillac ();
+
+ /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
+ declare_function_name ();
+
+ /* Prepare to check format strings against argument lists. */
+ init_function_format_info ();
+}
+
+/* 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;
+}
+\f
+/* 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;
+ int static_or_extern = 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);
+
+ t = lookup_tag (code, name, inner_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, 0);
+ 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;
+ }
+ }
+ else if (value == ridpointers[(int) RID_STATIC]
+ || value == ridpointers[(int) RID_EXTERN])
+ static_or_extern = 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
+ {
+ /* Anonymous unions are objects, that's why we only check for
+ static/extern specifiers in this branch. */
+ if (static_or_extern)
+ error ("static/extern can only be specified for objects and functions");
+
+ if (ok_code == RECORD_TYPE
+ && found_tag == 1
+ && TYPE_LANG_SPECIFIC (t)
+ && CLASSTYPE_DECLARED_EXCEPTION (t))
+ {
+ if (TYPE_SIZE (t))
+ cp_error ("redeclaration of exception `%T'", t);
+ 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");
+ }
+}
+\f
+/* 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 declarator, declspecs;
+ 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);
+
+ 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));
+ if (interface_unknown && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
+ warn_if_unknown_interface ();
+ TREE_PUBLIC (d) = TREE_PUBLIC (decl) = flag_external_templates && !interface_unknown;
+ 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)
+ {
+ cp_error ("typedef `%D' is initialized", decl);
+ initialized = 0;
+ }
+ break;
+
+ case FUNCTION_DECL:
+ cp_error ("function `%#D' is initialized like a variable", 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)
+ {
+ cp_error ("variable `%#D' has initializer but incomplete type",
+ decl);
+ initialized = 0;
+ }
+ else if (TYPE_SIZE (TREE_TYPE (type)) == NULL_TREE)
+ {
+ cp_error ("elements of array `%#D' have incomplete type", 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)
+ {
+ cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
+ 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))
+ cp_warning ("declaration of `%#D' has `extern' and is initialized",
+ 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 (is_overloaded_fn (tem))
+ {
+ tree tem2;
+ tem = get_first_fn (tem);
+ tem2 = decl_value_member (decl, tem);
+
+ if (tem2 != NULL_TREE)
+ tem = tem2;
+ else
+ {
+ while (tem && ! decls_match (decl, tem))
+ tem = DECL_CHAIN (tem);
+ if (tem == NULL_TREE)
+ tem = decl;
+ }
+ }
+ }
+
+ /* Tell the back-end to use or not use .common as appropriate. */
+ DECL_COMMON (tem) = flag_conserve_space;
+
+#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);
+
+ if (TREE_CODE (type) != UNINSTANTIATED_P_TYPE)
+ {
+ cp_error ("declaration of `%D' in non-template type `%T'",
+ decl, type);
+ return NULL_TREE;
+ }
+
+ 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)
+ {
+ cp_error ("invalid template `%#D'", 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_full (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 = NULL_TREE;
+
+ if (init == NULL_TREE)
+ {
+ if (DECL_LANG_SPECIFIC (decl) == 0
+ || DECL_IN_AGGR_P (decl) == 0)
+ {
+ cp_error ("`%D' declared as reference but not initialized", decl);
+ if (TREE_CODE (decl) == VAR_DECL)
+ SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
+ }
+ return;
+ }
+
+ if (init == error_mark_node)
+ return;
+
+ if (TREE_CODE (type) == REFERENCE_TYPE
+ && TREE_CODE (init) == CONSTRUCTOR)
+ {
+ cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
+ 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 (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);
+ }
+
+ /* Can we just enreference this lvalue? */
+ if ((is_reference || lvalue_p (init)
+ || (actual_init = unary_complex_lvalue (ADDR_EXPR, init)))
+ && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
+ TYPE_MAIN_VARIANT (TREE_TYPE (tmp)), 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'";
+ }
+ if (errstr)
+ {
+ cp_error (errstr, TREE_TYPE (type), TREE_TYPE (tmp));
+ goto fail;
+ }
+ }
+ /* OK, can we generate a reference then? */
+ else if ((actual_init = convert_to_reference
+ (decl, type, init, 0, 0, "initialization", 0,
+ LOOKUP_SPECULATIVELY|LOOKUP_NORMAL)))
+ {
+ if (actual_init == error_mark_node)
+ goto fail;
+
+ init = actual_init;
+ is_reference = 1;
+ }
+ /* OK, try going through a temporary. */
+ else if ((actual_init = convert_to_reference
+ (error_mark_node, type, init, 0, 0, "initialization",
+ 0, LOOKUP_NORMAL)))
+ {
+ if (actual_init == error_mark_node)
+ goto fail;
+
+ init = actual_init;
+ is_reference = 1;
+
+ if (TREE_CODE (init) == WITH_CLEANUP_EXPR)
+ {
+ /* Associate the cleanup with the reference so that we
+ don't get burned by "aggressive" cleanup policy. */
+ *cleanupp = TREE_OPERAND (init, 2);
+ TREE_OPERAND (init, 2) = error_mark_node;
+ }
+ }
+ else
+ {
+ cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
+ goto fail;
+ }
+
+ /* 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)
+ {
+ if (*cleanupp) my_friendly_abort (1);
+ *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;
+ }
+ /* If actual_init is set here, it is set from the first check above. */
+ else if (actual_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
+ my_friendly_abort (1);
+
+ 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;
+ }
+ return;
+
+ fail:
+ if (TREE_CODE (decl) == VAR_DECL)
+ SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
+ return;
+}
+
+/* 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)
+ cp_warning ("shadowing previous type declaration of `%#D'", 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
+ || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_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_HAS_CONSTRUCTOR (type) || 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)
+ {
+ if (TYPE_NEEDS_CONSTRUCTING (type))
+ {
+ cp_error ("`%D' must be initialized by constructor, not by `{...}'", decl);
+ init = error_mark_node;
+ }
+ else
+ goto dont_use_constructor;
+ }
+#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;
+ if (flag_conserve_space)
+ /* If we say -fconserve-space, we want this to save
+ space, at the expense of wrong semantics. */
+ /* Should this be a NULL_TREE? */
+ value = error_mark_node;
+ else
+ /* If we say -fno-conserve-space, we want this to
+ produce errors about redefs, to do this we make it
+ go in the data space */
+ value = digest_init (type, empty_init_node, (tree *) 0);
+ DECL_INITIAL (decl) = value;
+ }
+ else
+ DECL_INITIAL (decl) = error_mark_node;
+ }
+ else
+ {
+ dont_use_constructor:
+ 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_CONSTRUCTING (ctype))
+ {
+ if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
+ cp_error ("structure `%D' with uninitialized const members", decl);
+ if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
+ cp_error ("structure `%D' with uninitialized reference members", decl);
+ }
+
+ if (TREE_CODE (decl) == VAR_DECL
+ && !DECL_INITIAL (decl)
+ && !TYPE_NEEDS_CONSTRUCTING (type)
+ && (TYPE_READONLY (type) || TREE_READONLY (decl)))
+ cp_error ("uninitialized const `%D'", decl);
+
+ /* 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)
+ /* If we say -fconserve-space, we want this to save space,
+ at the expense of wrong semantics. */
+ && ! flag_conserve_space)
+ {
+ 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.
+ We deliberately don't complain about arrays, because they're
+ supposed to be initialized by a constructor. */
+ if (! DECL_INITIAL (decl)
+ && TREE_CODE (type) != ARRAY_TYPE
+ && (!pedantic || !current_class_type))
+ cp_error ("uninitialized const `%#D'", decl);
+ }
+
+ /* 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)
+ cp_error ("initializer fails to determine size of `%D'", decl);
+
+ if (failure == 2)
+ {
+ if (do_default)
+ cp_error ("array size missing in `%D'", decl);
+ /* If a `static' var's size isn't known, make it extern as
+ well as static, so it does not get allocated. If it's not
+ `static', then don't mark it extern; finish_incomplete_decl
+ will give it a default size and it will get allocated. */
+ else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (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))
+ cp_error ("zero-size array `%D'", decl);
+
+ layout_decl (decl, 0);
+ }
+
+ if (TREE_CODE (decl) == VAR_DECL)
+ {
+ if (DECL_SIZE (decl) == NULL_TREE
+ && TYPE_SIZE (TREE_TYPE (decl)) != NULL_TREE)
+ layout_decl (decl, 0);
+
+ if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
+ {
+ /* A static variable with an incomplete type:
+ that is an error if it is initialized.
+ Otherwise, let it through, but if it is not `extern'
+ then it may cause an error message later. */
+ if (DECL_INITIAL (decl) != NULL_TREE)
+ cp_error ("storage size of `%D' isn't known", decl);
+ 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. */
+ cp_error ("storage size of `%D' isn't known", decl);
+ 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)))
+ {
+ if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
+ constant_expression_warning (DECL_SIZE (decl));
+ else
+ cp_error ("storage size of `%D' isn't constant", decl);
+ }
+
+ 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)
+ {
+ /* ??? FIXME: What about nested classes? */
+ int toplev = (current_binding_level == global_binding_level
+ || pseudo_global_level_p ());
+ 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 (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
+ signature_error (decl, type);
+ else if ((TREE_CODE (type) == FUNCTION_TYPE
+ || TREE_CODE (type) == METHOD_TYPE)
+ && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
+ && IS_SIGNATURE (TREE_TYPE (type)))
+ signature_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)
+ {
+ /* The default value for the parameter in parmtypes is
+ stored in the TREE_PURPOSE of the TREE_LIST. */
+ if (TREE_PURPOSE (parmtypes))
+ {
+ tree fnname, fndecl;
+ tree *argp;
+
+ 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 (! toplev)
+ {
+ /* 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))
+ cp_error ("parser lost in parsing declaration of `%D'", decl);
+ }
+ }
+ }
+ 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
+ */
+ && context == current_class_type
+ )))
+ 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);
+}
+
+void
+expand_static_init (decl, init)
+ tree decl;
+ tree init;
+{
+ tree oldstatic = value_member (decl, static_aggregates);
+ if (oldstatic)
+ {
+ if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
+ cp_error ("multiple initializations given for `%D'", decl);
+ }
+ 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);
+ }
+}
+\f
+/* 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, - (nelts == 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 (0, 0);
+ }
+ }
+
+ if (!maxindex)
+ {
+ if (do_default)
+ maxindex = build_int_2 (0, 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;
+}
+\f
+/* 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;
+}
+\f
+/* Subroutine of `grokdeclarator'. */
+
+/* Generate errors possibly applicable for a given set of specifiers.
+ This is for ARM $7.1.2. */
+static void
+bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
+ tree object;
+ char *type;
+ int virtualp, quals, friendp, raises, inlinep;
+{
+ if (virtualp)
+ cp_error ("`%D' declared as a `virtual' %s", object, type);
+ if (inlinep)
+ cp_error ("`%D' declared as an `inline' %s", object, type);
+ if (quals)
+ cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration", object, type);
+ if (friendp)
+ cp_error_at ("invalid friend declaration", object);
+ if (raises)
+ cp_error_at ("invalid raises declaration", object);
+}
+
+/* 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)
+ {
+ cp_error ("%smember function `%D' cannot have `%T' method qualifier",
+ (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
+ quals = NULL_TREE;
+ }
+
+ if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
+ grok_op_properties (decl, virtualp, check < 0);
+
+ /* 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))
+ cp_error ("inconsistent declarations for `%D'", decl);
+ 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 (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))
+ cp_error ("inconsistent declarations for `%D'", decl);
+ 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)
+ {
+ /* If this function overrides some virtual in some base
+ class, then the function itself is also necessarily
+ virtual, even if the user didn't explicitly say so. */
+ DECL_VIRTUAL_P (decl) = 1;
+
+ /* 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)
+ {
+ cp_error ("method `%D' may not be declared static", decl);
+ cp_error_at ("(since `%D' declared virtual in base class.)", tmp);
+ break;
+ }
+ virtualp = 1;
+
+#if 0
+ /* Disable this as we want the most recent fndecl, not the most
+ base fndecl. */
+ 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);
+#endif
+ 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_KNOWN (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;
+
+ 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 (RIDBIT_SETP (RID_EXTERN, specbits))
+ {
+ DECL_THIS_EXTERN (decl) = 1;
+ DECL_EXTERNAL (decl) = !initialized;
+ }
+
+ /* In class context, static means one per class,
+ public access, 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) = RIDBIT_NOTSETP (RID_STATIC, specbits);
+ TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
+ }
+ /* Not at top level, only `static' makes a static definition. */
+ else
+ {
+ TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
+ TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
+ }
+ return decl;
+}
+
+/* Create a canonical pointer to member function type. */
+
+tree
+build_ptrmemfunc_type (type)
+ tree type;
+{
+ tree fields[4];
+ tree t;
+ tree u;
+
+ /* If a canonical type already exists for this type, use it. We use
+ this method instead of type_hash_canon, because it only does a
+ simple equality check on the list of field members. */
+
+ if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
+ return t;
+
+ push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
+
+ u = make_lang_type (UNION_TYPE);
+ fields[0] = build_lang_field_decl (FIELD_DECL, pfn_identifier, type);
+ fields[1] = build_lang_field_decl (FIELD_DECL, delta2_identifier, delta_type_node);
+ finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
+ TYPE_NAME (u) = NULL_TREE;
+
+ t = make_lang_type (RECORD_TYPE);
+
+ /* Let the front-end know this is a pointer to member function. */
+ TYPE_PTRMEMFUNC_FLAG(t) = 1;
+
+ fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier, delta_type_node);
+ fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier, delta_type_node);
+ fields[2] = build_lang_field_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
+ finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
+
+ pop_obstacks ();
+
+ /* Zap out the name so that the back-end will give us the debugging
+ information for this anonymous RECORD_TYPE. */
+ TYPE_NAME (t) = NULL_TREE;
+
+ TYPE_SET_PTRMEMFUNC_TYPE (type, t);
+
+ /* Seems to be wanted. */
+ CLASSTYPE_GOT_SEMICOLON (t) = 1;
+ return t;
+}
+
+/* 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;
+{
+ RID_BIT_TYPE specbits;
+ 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;
+ int opaque_typedef = 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;
+
+ RIDBIT_RESET_ALL (specbits);
+ 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;
+
+ 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);
+ last = decl;
+ decl = TREE_OPERAND (decl, 0);
+ break;
+
+ case CALL_EXPR:
+ if (parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
+ {
+ /* This is actually a variable declaration using constructor
+ syntax. We need to call start_decl and finish_decl so we
+ can get the variable initialized... */
+
+ if (last)
+ /* We need to insinuate ourselves into the declarator in place
+ of the CALL_EXPR. */
+ TREE_OPERAND (last, 0) = TREE_OPERAND (decl, 0);
+ else
+ declarator = TREE_OPERAND (decl, 0);
+
+ init = TREE_OPERAND (decl, 1);
+
+ decl = start_decl (declarator, declspecs, 1, NULL_TREE);
+ finish_decl (decl, init, NULL_TREE, 1);
+ return 0;
+ }
+ 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:
+ my_friendly_assert (flags == NO_SPECIAL, 154);
+ flags = TYPENAME_FLAG;
+ name = "operator <typename>"; /* We don't know the type yet. */
+ /* 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))
+ {
+ cp_error ("type `%T' is not derived from type `%T'",
+ IDENTIFIER_TYPE_VALUE (cname), 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:
+ return 0; /* We used to do a 155 abort here. */
+ }
+ 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;
+
+ /* 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;
+
+ id = TREE_VALUE (spec);
+
+ 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)
+ cp_error ("multiple declarations `%T' and `%T'", type, 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 && RIDBIT_SETP (i, specbits))
+ {
+#if 0
+ if (pedantic)
+ pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
+ else
+#endif
+ if (longlong)
+ error ("`long long long' is too long for GCC");
+ else
+ longlong = 1;
+ }
+ else if (RIDBIT_SETP (i, specbits))
+ warning ("duplicate `%s'", IDENTIFIER_POINTER (id));
+ RIDBIT_SET (i, specbits);
+ 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.
+ Except when we have a `typedef' inside a signature, in
+ which case the type defaults to `unknown type' and is
+ instantiated when assigning to a signature pointer or ref. */
+
+ 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 (current_class_type
+ && IS_SIGNATURE (current_class_type)
+ && (RIDBIT_SETP (RID_TYPEDEF, specbits)
+ || SIGNATURE_GROKKING_TYPEDEF (current_class_type))
+ && (decl_context == FIELD || decl_context == NORMAL))
+ {
+ explicit_int = 0;
+ opaque_typedef = 1;
+ type = copy_node (opaque_type_node);
+ }
+ else
+ {
+ if (funcdef_flag && warn_return_type
+ && return_type == return_normal
+ && ! (RIDBIT_SETP (RID_SIGNED, specbits)
+ || RIDBIT_SETP (RID_UNSIGNED, specbits)
+ || RIDBIT_SETP (RID_LONG, specbits)
+ || RIDBIT_SETP (RID_SHORT, specbits)))
+ 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);
+ }
+
+ ctype = NULL_TREE;
+
+ /* Now process the modifiers that were specified
+ and check for invalid combinations. */
+
+ /* Long double is a special combination. */
+
+ if (RIDBIT_SETP (RID_LONG, specbits)
+ && TYPE_MAIN_VARIANT (type) == double_type_node)
+ {
+ RIDBIT_RESET (RID_LONG, specbits);
+ type = build_type_variant (long_double_type_node, TYPE_READONLY (type),
+ TYPE_VOLATILE (type));
+ }
+
+ /* Check all other uses of type modifiers. */
+
+ if (RIDBIT_SETP (RID_UNSIGNED, specbits)
+ || RIDBIT_SETP (RID_SIGNED, specbits)
+ || RIDBIT_SETP (RID_LONG, specbits)
+ || RIDBIT_SETP (RID_SHORT, specbits))
+ {
+ 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 (RIDBIT_SETP (RID_LONG, specbits)
+ && RIDBIT_SETP (RID_SHORT, specbits))
+ error ("long and short specified together for `%s'", name);
+ else if ((RIDBIT_SETP (RID_LONG, specbits)
+ || RIDBIT_SETP (RID_SHORT, specbits))
+ && explicit_char)
+ error ("long or short specified with char for `%s'", name);
+ else if ((RIDBIT_SETP (RID_LONG, specbits)
+ || RIDBIT_SETP (RID_SHORT, specbits))
+ && TREE_CODE (type) == REAL_TYPE)
+ error ("long or short specified with floating type for `%s'", name);
+ else if (RIDBIT_SETP (RID_SIGNED, specbits)
+ && RIDBIT_SETP (RID_UNSIGNED, specbits))
+ 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)
+ {
+ RIDBIT_RESET (RID_UNSIGNED, specbits);
+ RIDBIT_RESET (RID_SIGNED, specbits);
+ RIDBIT_RESET (RID_LONG, specbits);
+ RIDBIT_RESET (RID_SHORT, specbits);
+ longlong = 0;
+ }
+ }
+
+ /* Decide whether an integer type is signed or not.
+ Optionally treat bitfields as signed by default. */
+ if (RIDBIT_SETP (RID_UNSIGNED, specbits)
+ /* 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
+ && RIDBIT_NOTSETP (RID_SIGNED, specbits)))
+ {
+ if (longlong)
+ type = long_long_unsigned_type_node;
+ else if (RIDBIT_SETP (RID_LONG, specbits))
+ type = long_unsigned_type_node;
+ else if (RIDBIT_SETP (RID_SHORT, specbits))
+ 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 (RIDBIT_SETP (RID_SIGNED, specbits)
+ && type == char_type_node)
+ type = signed_char_type_node;
+ else if (longlong)
+ type = long_long_integer_type_node;
+ else if (RIDBIT_SETP (RID_LONG, specbits))
+ type = long_integer_type_node;
+ else if (RIDBIT_SETP (RID_SHORT, specbits))
+ type = short_integer_type_node;
+
+ /* Set CONSTP if this declaration is `const', whether by
+ explicit specification or via a typedef.
+ Likewise for VOLATILEP. */
+
+ constp = !! RIDBIT_SETP (RID_CONST, specbits) + TYPE_READONLY (type);
+ volatilep = !! RIDBIT_SETP (RID_VOLATILE, specbits) + TYPE_VOLATILE (type);
+ staticp = 0;
+ inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
+ if (constp > 1)
+ warning ("duplicate `const'");
+ if (volatilep > 1)
+ warning ("duplicate `volatile'");
+ virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
+
+ /* operators new and delete are implicitly static. */
+ if (RIDBIT_SETP (RID_STATIC, specbits))
+ staticp = 1 + (decl_context == FIELD);
+
+ if (virtualp && staticp == 2)
+ {
+ cp_error ("member `%D' cannot be declared both virtual and static",
+ dname);
+ staticp = 0;
+ }
+ friendp = RIDBIT_SETP (RID_FRIEND, specbits);
+ RIDBIT_RESET (RID_VIRTUAL, specbits);
+ RIDBIT_RESET (RID_FRIEND, specbits);
+
+ if (RIDBIT_SETP (RID_MUTABLE, specbits))
+ {
+ if (decl_context == PARM)
+ {
+ error ("non-member `%s' cannot be declared mutable", name);
+ RIDBIT_RESET (RID_MUTABLE, specbits);
+ }
+ else if (friendp || decl_context == TYPENAME)
+ {
+ error ("non-object member `%s' cannot be declared mutable", name);
+ RIDBIT_RESET (RID_MUTABLE, specbits);
+ }
+ else if (staticp)
+ {
+ error ("static `%s' cannot be declared mutable", name);
+ RIDBIT_RESET (RID_MUTABLE, specbits);
+ }
+#if 0
+ if (RIDBIT_SETP (RID_TYPEDEF, specbits))
+ {
+ error ("non-object member `%s' cannot be declared mutable", name);
+ RIDBIT_RESET (RID_MUTABLE, specbits);
+ }
+ /* Because local typedefs are parsed twice, we don't want this
+ message here. */
+ else if (decl_context != FIELD)
+ {
+ error ("non-member `%s' cannot be declared mutable", name);
+ RIDBIT_RESET (RID_MUTABLE, specbits);
+ }
+#endif
+ }
+
+ /* Warn if two storage classes are given. Default to `auto'. */
+
+ if (RIDBIT_ANY_SET (specbits))
+ {
+ if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
+ if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
+ if (decl_context == PARM && nclasses > 0)
+ error ("storage class specifiers invalid in parameter declarations");
+ if (RIDBIT_SETP (RID_TYPEDEF, specbits))
+ {
+ if (decl_context == PARM)
+ error ("typedef declaration invalid in parameter declaration");
+ nclasses++;
+ }
+ if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
+ if (RIDBIT_SETP (RID_REGISTER, specbits)) 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;
+ }
+ if (current_class_name == NULL_TREE && RIDBIT_SETP (RID_MUTABLE, specbits))
+ {
+ error ("only members can be declared mutable");
+ RIDBIT_RESET (RID_MUTABLE, specbits);
+ }
+
+ /* Static anonymous unions are dealt with here. */
+ if (staticp && decl_context == TYPENAME
+ && TREE_CODE (declspecs) == TREE_LIST
+ && TREE_CODE (TREE_VALUE (declspecs)) == UNION_TYPE
+ && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_VALUE (declspecs))))
+ decl_context = FIELD;
+
+ /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
+ is used in a signature member function declaration. */
+ if (decl_context == FIELD
+ && IS_SIGNATURE (current_class_type)
+ && RIDBIT_NOTSETP(RID_TYPEDEF, specbits)
+ && !SIGNATURE_GROKKING_TYPEDEF (current_class_type))
+ {
+ if (constp)
+ {
+ error ("`const' specified for signature member function `%s'", name);
+ constp = 0;
+ }
+ if (volatilep)
+ {
+ error ("`volatile' specified for signature member function `%s'", name);
+ volatilep = 0;
+ }
+ if (inlinep)
+ {
+ error ("`inline' specified for signature member function `%s'", name);
+ /* Later, we'll make signature member functions inline. */
+ inlinep = 0;
+ }
+ if (friendp)
+ {
+ error ("`friend' declaration in signature definition");
+ friendp = 0;
+ }
+ if (virtualp)
+ {
+ error ("`virtual' specified for signature member function `%s'", name);
+ /* Later, we'll make signature member functions virtual. */
+ 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
+ && (RIDBIT_SETP (RID_REGISTER, specbits)
+ || RIDBIT_SETP (RID_AUTO, specbits)))
+ ;
+ else if (decl_context == FIELD
+ && RIDBIT_SETP (RID_TYPEDEF, specbits))
+ {
+ /* Processing a typedef declaration nested within a class type
+ definition. */
+ register tree scanner;
+ register tree previous_declspec;
+ tree loc_typedecl;
+
+ if (initialized)
+ error ("typedef declaration includes an initializer");
+
+ /* To process a class-local typedef declaration, we descend down
+ the chain of declspecs looking for the `typedef' spec. When we
+ find it, we splice it out of the chain of declspecs, and then
+ recursively call `grokdeclarator' with the original declarator
+ and with the newly adjusted declspecs. This call should return
+ a FIELD_DECL node with the TREE_TYPE (and other parts) set
+ appropriately. We can then just change the TREE_CODE on that
+ from FIELD_DECL to TYPE_DECL and we're done. */
+
+ for (previous_declspec = NULL_TREE, scanner = declspecs;
+ scanner;
+ previous_declspec = scanner, scanner = TREE_CHAIN (scanner))
+ {
+ if (TREE_VALUE (scanner) == ridpointers[(int) RID_TYPEDEF])
+ break;
+ }
+ if (previous_declspec)
+ TREE_CHAIN (previous_declspec) = TREE_CHAIN (scanner);
+ else
+ declspecs = TREE_CHAIN (scanner);
+
+ /* In the recursive call to grokdeclarator we need to know
+ whether we are working on a signature-local typedef. */
+ if (IS_SIGNATURE (current_class_type))
+ SIGNATURE_GROKKING_TYPEDEF (current_class_type) = 1;
+
+ loc_typedecl =
+ grokdeclarator (declarator, declspecs, FIELD, 0, NULL_TREE);
+
+ if (loc_typedecl != error_mark_node)
+ {
+ register int i = sizeof (struct lang_decl_flags) / sizeof (int);
+ register int *pi;
+
+ TREE_SET_CODE (loc_typedecl, TYPE_DECL);
+
+ pi = (int *) permalloc (sizeof (struct lang_decl_flags));
+ while (i > 0)
+ pi[--i] = 0;
+ DECL_LANG_SPECIFIC (loc_typedecl) = (struct lang_decl *) pi;
+ }
+
+ if (IS_SIGNATURE (current_class_type))
+ {
+ SIGNATURE_GROKKING_TYPEDEF (current_class_type) = 0;
+ if (loc_typedecl != error_mark_node && opaque_typedef)
+ SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
+ }
+
+ return loc_typedecl;
+ }
+ else if (decl_context == FIELD
+ && (! IS_SIGNATURE (current_class_type))
+ /* C++ allows static class elements */
+ && RIDBIT_SETP (RID_STATIC, specbits))
+ /* 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'",
+ IS_SIGNATURE (current_class_type)
+ ? (op
+ ? "signature member operator"
+ : "signature member function")
+ : (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);
+ RIDBIT_RESET (RID_REGISTER, specbits);
+ RIDBIT_RESET (RID_AUTO, specbits);
+ RIDBIT_RESET (RID_EXTERN, specbits);
+
+ if (decl_context == FIELD && IS_SIGNATURE (current_class_type))
+ {
+ RIDBIT_RESET (RID_STATIC, specbits);
+ staticp = 0;
+ }
+ }
+ }
+ else if (RIDBIT_SETP (RID_EXTERN, specbits) && 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 (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
+ && current_binding_level != global_binding_level)
+ error ("nested function `%s' declared `extern'", name);
+ else if (current_binding_level == global_binding_level)
+ {
+ if (RIDBIT_SETP (RID_AUTO, specbits))
+ error ("top-level declaration of `%s' specifies `auto'", name);
+#if 0
+ if (RIDBIT_SETP (RID_REGISTER, specbits))
+ 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
+ && RIDBIT_NOSETP (RID_EXTERN, specbits)
+ && ! root_lang_context_p ())
+ {
+ RIDBIT_SET (RID_EXTERN, specbits);
+ }
+#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:
+ {
+ 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)
+ {
+ cp_error ("declaration of `%D' as array of voids", dname);
+ type = error_mark_node;
+ }
+
+ if (TREE_CODE (type) == FUNCTION_TYPE)
+ {
+ cp_error ("declaration of `%D' as array of functions", dname);
+ 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)
+ {
+ if (decl_context == TYPENAME)
+ cp_error ("cannot make arrays of references");
+ else
+ cp_error ("declaration of `%D' as array of references",
+ dname);
+ type = error_mark_node;
+ }
+
+ if (TREE_CODE (type) == OFFSET_TYPE)
+ {
+ cp_error ("declaration of `%D' as array of data members",
+ dname);
+ type = error_mark_node;
+ }
+
+ if (TREE_CODE (type) == METHOD_TYPE)
+ {
+ cp_error ("declaration of `%D' as array of function members",
+ dname);
+ type = error_mark_node;
+ }
+
+ 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)
+ {
+ cp_error ("size of array `%D' has non-integer type",
+ dname);
+ size = integer_one_node;
+ }
+ if (TREE_READONLY_DECL_P (size))
+ size = decl_constant_value (size);
+ if (pedantic && integer_zerop (size))
+ cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname);
+ if (TREE_CONSTANT (size))
+ {
+ constant_expression_warning (size);
+ if (INT_CST_LT (size, integer_zero_node))
+ {
+ cp_error ("size of array `%D' is negative", dname);
+ size = integer_one_node;
+ }
+ itype = build_index_type (size_binop (MINUS_EXPR, size,
+ integer_one_node));
+ }
+ else
+ {
+ if (pedantic)
+ cp_pedwarn ("ANSI C++ forbids variable-size array `%D'", dname);
+ 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, then merge any constancy or
+ volatility into the target type. We must do it in this order
+ to ensure that the TYPE_MAIN_VARIANT field of the array type
+ is set correctly. */
+
+ type = build_cplus_array_type (type, itype);
+ if (constp || volatilep)
+ /* Should this be c_build_type_variant? -jason */
+ type = build_type_variant (type, constp, volatilep);
+
+ ctype = NULL_TREE;
+ }
+ break;
+
+ case CALL_EXPR:
+ {
+ 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;
+ }
+ {
+ int inlinep, staticp;
+ inlinep = RIDBIT_SETP (RID_INLINE, specbits);
+ staticp = RIDBIT_SETP (RID_STATIC, specbits);
+ RIDBIT_RESET (RID_INLINE, specbits);
+ RIDBIT_RESET (RID_STATIC, specbits);
+ if (RIDBIT_ANY_SET (specbits))
+ error ("return value type specifier for constructor ignored");
+ if (inlinep)
+ RIDBIT_SET (RID_INLINE, specbits);
+ if (staticp)
+ RIDBIT_SET (RID_STATIC, specbits);
+ }
+ type = TYPE_POINTER_TO (ctype);
+ if (decl_context == FIELD &&
+ IS_SIGNATURE (current_class_type))
+ {
+ error ("constructor not allowed in signature");
+ return void_type_node;
+ }
+ else 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");
+ RIDBIT_RESET (RID_FRIEND, specbits);
+ friendp = 0;
+ }
+
+ 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;
+
+ /* FIXME: This is where default args should be fully
+ processed. */
+
+ 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;
+ }
+ }
+ }
+
+ /* ANSI seems to say that `const int foo ();'
+ does not make the function foo const. */
+ type = build_function_type (type,
+ flag_traditional ? 0 : arg_types);
+ }
+ break;
+
+ case ADDR_EXPR:
+ case INDIRECT_REF:
+ /* 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)
+ {
+ /* A const or volatile signature pointer/reference is
+ pointing to a const or volatile object, i.e., the
+ `optr' is const or volatile, respectively, not the
+ signature pointer/reference itself. */
+ if (! IS_SIGNATURE (type))
+ {
+ type = build_type_variant (type, constp, volatilep);
+ if (IS_AGGR_TYPE (type))
+ build_pointer_type (type);
+ constp = 0;
+ volatilep = 0;
+ }
+ }
+
+ if (IS_SIGNATURE (type))
+ {
+ if (TREE_CODE (declarator) == ADDR_EXPR)
+ {
+ if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE)
+ warning ("empty signature `%s' used in signature reference declaration",
+ TYPE_NAME_STRING(type));
+#if 0
+ type = build_signature_reference_type (type,
+ constp, volatilep);
+#else
+ sorry ("signature reference");
+ return NULL_TREE;
+#endif
+ }
+ else
+ {
+ if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE)
+ warning ("empty signature `%s' used in signature pointer declaration",
+ TYPE_NAME_STRING(type));
+ type = build_signature_pointer_type (type,
+ constp, volatilep);
+ }
+ constp = 0;
+ volatilep = 0;
+ }
+ else 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 if (TREE_CODE (type) == METHOD_TYPE)
+ {
+ type = build_ptrmemfunc_type (build_pointer_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)
+ {
+ /* I'm not really sure what pushclass calls this popclass
+ corresponds to. One is in build_push_scope and that has
+ been changed to a push_nested_class call, that's why I
+ try to use pop_nested_class here instead.
+ -niklas@appli.se */
+ pop_nested_class (1);
+ TREE_COMPLEXITY (declarator) = current_class_depth;
+ }
+ 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 (TREE_CODE (type) == FUNCTION_TYPE)
+ {
+ if (current_class_type == NULL_TREE
+ || TYPE_MAIN_VARIANT (ctype) == current_class_type
+ || friendp)
+ type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
+ TREE_TYPE (type), TYPE_ARG_TYPES (type));
+ else
+ {
+ error ("cannot declare member function `%s::%s' within this class",
+ TYPE_NAME_STRING (ctype), name);
+ return void_type_node;
+ }
+ }
+ else if (TYPE_MAIN_VARIANT (ctype) == current_class_type)
+ {
+ 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
+ || (RIDBIT_SETP (RID_TYPEDEF, specbits)))
+ {
+ 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 access 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)
+ cp_error ("type conversion is not a member of structure `%T'", ctype);
+ else
+ cp_error
+ ("field `%D' is not a member of structure `%T'",
+ sname, ctype);
+ }
+
+ if (current_class_type)
+ {
+ if (TYPE_MAIN_VARIANT (ctype) != current_class_type)
+ {
+ cp_error ("cannot declare member `%T::%s' within `%T'",
+ ctype, name, current_class_type);
+ return void_type_node;
+ }
+ else if (extra_warnings)
+ cp_warning ("extra qualification `%T' on member `%s' ignored",
+ 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
+ {
+ cp_error ("structure `%T' not yet defined", ctype);
+ return error_mark_node;
+ }
+
+ 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)
+ {
+ tree stype = TREE_TYPE (TREE_OPERAND (declarator, 0));
+ if (comp_target_types (type, stype, 1) == 0)
+ cp_error ("`operator %T' declared to return `%T'", stype,
+ type);
+ else
+ cp_pedwarn ("return type specified for `operator %T'", type);
+ }
+ dname = declarator;
+ type = TREE_TYPE (TREE_OPERAND (declarator, 0));
+ 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 (RIDBIT_SETP (RID_TYPEDEF, specbits))
+ {
+ 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 != error_mark_node
+ && 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 (TYPE_LANG_SPECIFIC (type))
+ TYPE_WAS_ANONYMOUS (type) = 1;
+
+ {
+ tree d = TYPE_NAME (type), c = DECL_CONTEXT (d);
+
+ if (!c)
+ set_nested_typename (d, 0, declarator, type);
+ else if (TREE_CODE (c) == FUNCTION_DECL)
+ set_nested_typename (d, DECL_ASSEMBLER_NAME (c),
+ declarator, type);
+ else
+ set_nested_typename (d, TYPE_NESTED_NAME (c), declarator, type);
+ }
+ }
+
+#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 (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
+ {
+ cp_error_at ("typedef name may not be class-qualified", decl);
+ TREE_TYPE (decl) = error_mark_node;
+ }
+ else if (quals)
+ {
+ if (ctype == NULL_TREE)
+ {
+ if (TREE_CODE (type) != METHOD_TYPE)
+ cp_error_at ("invalid type qualifier for non-method type", decl);
+ else
+ ctype = TYPE_METHOD_BASETYPE (type);
+ }
+ if (ctype != NULL_TREE)
+ grok_method_quals (ctype, decl, quals);
+ }
+
+ if (RIDBIT_SETP (RID_SIGNED, specbits)
+ || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
+ C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
+
+ if (RIDBIT_SETP (RID_MUTABLE, specbits))
+ {
+ error ("non-object member `%s' cannot be declared mutable", name);
+ }
+
+ 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)
+ if (IS_SIGNATURE (type))
+ error ("`const' or `volatile' specified with signature type");
+ else
+ 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;
+ }
+ else if (declarator == NULL_TREE && decl_context != PARM
+ && TREE_CODE (type) != UNION_TYPE
+ && ! bitfield)
+ {
+ cp_error ("abstract declarator `%T' used as declaration", type);
+ declarator = make_anon_name ();
+ }
+
+ /* `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 (TREE_CODE (declarator) == IDENTIFIER_NODE)
+ {
+ if (IDENTIFIER_OPNAME_P (declarator))
+#if 0 /* How could this happen? */
+ error ("operator `%s' declared void",
+ operator_name_string (declarator));
+#else
+ my_friendly_abort (356);
+#endif
+ 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");
+
+ /* 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);
+
+ bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
+ inlinep, friendp, raises != NULL_TREE);
+ if (current_class_type
+ && IS_SIGNATURE (current_class_type))
+ {
+ if (inlinep)
+ error ("parameter of signature member function declared `inline'");
+ if (RIDBIT_SETP (RID_AUTO, specbits))
+ error ("parameter of signature member function declared `auto'");
+ if (RIDBIT_SETP (RID_REGISTER, specbits))
+ error ("parameter of signature member function declared `register'");
+ }
+
+ /* 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)
+ {
+ cp_error ("can't make `%D' into a method -- not in a class",
+ declarator);
+ return void_type_node;
+ }
+
+ /* ``A union may [ ... ] not [ have ] virtual functions.''
+ ARM 9.5 */
+ if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
+ {
+ cp_error ("function `%D' declared virtual inside a union",
+ declarator);
+ return void_type_node;
+ }
+
+ if (declarator == ansi_opname[(int) NEW_EXPR]
+ || declarator == ansi_opname[(int) DELETE_EXPR])
+ {
+ if (virtualp)
+ {
+ cp_error ("`%D' cannot be declared virtual, since it is always static",
+ declarator);
+ virtualp = 0;
+ }
+ }
+ else if (staticp < 2)
+ 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 = (RIDBIT_SETP (RID_EXTERN, specbits)
+ || (ctype != NULL_TREE && funcdef_flag >= 0)
+ || (friendp
+ && ! funcdef_flag
+ && RIDBIT_NOTSETP (RID_STATIC, specbits)
+ && RIDBIT_NOTSETP (RID_INLINE, specbits)));
+ 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))
+ {
+ error ("field `%s' has incomplete type",
+ IDENTIFIER_POINTER (declarator));
+
+ /* If we're instantiating a template, tell them which
+ instantiation made the field's type be incomplete. */
+ if (current_class_type
+ && TYPE_NAME (current_class_type)
+ && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (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)
+ {
+ error ("`%s' is neither function nor method; cannot be declared friend",
+ IDENTIFIER_POINTER (declarator));
+ friendp = 0;
+ }
+ decl = NULL_TREE;
+ }
+
+ if (friendp)
+ {
+ /* Friends are treated specially. */
+ if (ctype == current_class_type)
+ warning ("member functions are implicitly friends of their class");
+ else
+ {
+ tree t = NULL_TREE;
+ if (decl && DECL_NAME (decl))
+ t = do_friend (ctype, declarator, decl,
+ last_function_parms, flags, quals);
+ if (t && funcdef_flag)
+ return t;
+
+ return void_type_node;
+ }
+ }
+
+ /* Structure field. It may not be a function, except for C++ */
+
+ if (decl == 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 prohibited
+ by the draft ANSI standard, though it appears to be in
+ common practice. 12.6.2: The argument list is used to
+ initialize the named nonstatic member.... This (or an
+ aggregate) is the only way to initialize nonstatic const
+ and reference members. */
+ else
+ pedwarn ("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 access. */
+ TREE_PUBLIC (decl) = 1;
+ DECL_EXTERNAL (decl) = !initialized;
+ }
+ else
+ {
+ decl = build_lang_field_decl (FIELD_DECL, declarator, type);
+ if (RIDBIT_SETP (RID_MUTABLE, specbits))
+ {
+ DECL_MUTABLE_P (decl) = 1;
+ RIDBIT_RESET (RID_MUTABLE, specbits);
+ }
+ }
+
+ bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
+ inlinep, friendp, raises != NULL_TREE);
+ }
+ }
+ 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 (RIDBIT_SETP (RID_AUTO, specbits)
+ || RIDBIT_SETP (RID_REGISTER, specbits))
+ 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
+ && (RIDBIT_SETP (RID_STATIC, specbits) || RIDBIT_SETP (RID_INLINE, specbits))
+ && pedantic)
+ pedwarn ("invalid storage class for function `%s'", name);
+
+ if (ctype == NULL_TREE)
+ {
+ if (virtualp)
+ {
+ error ("virtual non-class function `%s'", name);
+ virtualp = 0;
+ }
+
+ 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_KNOWN (ctype)
+ && ! CLASSTYPE_INTERFACE_ONLY (ctype))
+ || !(RIDBIT_SETP (RID_STATIC, specbits)
+ || RIDBIT_SETP (RID_INLINE, specbits)));
+
+ decl = grokfndecl (ctype, type, original_name,
+ virtualp, flags, quals,
+ raises,
+ processing_template_decl ? 0 : friendp ? 2 : 1,
+ publicp);
+
+ if (ctype == NULL_TREE && DECL_LANGUAGE (decl) != lang_c)
+ 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)
+ {
+ cp_error_at ("cannot declare member function `%D' to have static linkage", decl);
+ 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;
+ }
+ else if (current_function_decl)
+ {
+ /* FIXME need arm citation */
+ error ("cannot declare static function inside another function");
+ illegal_static = 1;
+ }
+
+ if (illegal_static)
+ {
+ staticp = 0;
+ RIDBIT_RESET (RID_STATIC, specbits);
+ }
+ }
+
+ /* 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"))
+ error ("cannot inline function `main'");
+ else if (last && last != void_list_node)
+ cp_warning ("cannot inline function `%D' which takes `...'", original_name);
+ else
+ /* Assume that otherwise the function can be inlined. */
+ DECL_INLINE (decl) = 1;
+
+ if (RIDBIT_SETP (RID_EXTERN, specbits))
+ {
+ current_extern_inline = 1;
+ if (flag_ansi || pedantic || flag_pedantic_errors)
+ pedwarn ("ANSI C++ does not permit `extern inline'");
+ }
+ }
+ if (was_overloaded)
+ DECL_OVERLOADED (decl) = 1;
+ }
+ else
+ {
+ /* It's a variable. */
+
+ /* An uninitialized decl with `extern' is a reference. */
+ decl = grokvardecl (type, declarator, specbits, initialized);
+ bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
+ inlinep, friendp, raises != NULL_TREE);
+
+ if (ctype)
+ {
+ if (staticp == 1)
+ {
+ cp_error ("static member `%D' re-declared as static",
+ decl);
+ staticp = 0;
+ RIDBIT_RESET (RID_STATIC, specbits);
+ }
+ if (RIDBIT_SETP (RID_EXTERN, specbits))
+ {
+ cp_error ("cannot explicitly declare member `%#D' to have extern linkage",
+ decl);
+ RIDBIT_RESET (RID_EXTERN, specbits);
+ }
+ }
+ }
+
+ if (RIDBIT_SETP (RID_MUTABLE, specbits))
+ {
+ error ("`%s' cannot be declared mutable", name);
+ }
+
+ /* Record `register' declaration for warnings on &
+ and in case doing stupid register allocation. */
+
+ if (RIDBIT_SETP (RID_REGISTER, specbits))
+ 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;
+ }
+}
+\f
+/* 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;
+}
+
+/* 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)
+ pedwarn ("parameter names (without types) in function declaration");
+ last_function_parms = first_parm;
+ return NULL_TREE;
+ }
+ else if (first_parm != NULL_TREE
+ && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
+ && TREE_VALUE (first_parm) != void_type_node)
+ my_friendly_abort (145);
+ 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 */
+ }
+ else if (TREE_CODE (type) == RECORD_TYPE
+ && TYPE_LANG_SPECIFIC (type)
+ && IS_SIGNATURE (type))
+ {
+ signature_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 ((TREE_CODE (type) == INTEGER_TYPE
+ || TREE_CODE (type) == ENUMERAL_TYPE)
+ && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
+ 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. */
+ cp_error ("local variable `%D' may not be used as a default argument", init);
+ 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;
+}
+\f
+/* 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 form 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;
+
+ /* When a type has virtual baseclasses, a magical first int argument is
+ added to any ctor so we can tell if the class has been initialized
+ yet. This could screw things up in this function, so we deliberately
+ ignore the leading int if we're in that situation. */
+ if (parmtypes
+ && TREE_VALUE (parmtypes) == integer_type_node
+ && TYPE_USES_VIRTUAL_BASECLASSES (ctype))
+ {
+ 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;
+ if (TYPE_READONLY (TREE_TYPE (parmtype)))
+ TYPE_HAS_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)
+ cp_error ("invalid constructor; you probably meant `%T (%T&)'",
+ ctype, 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;
+}
+
+/* An operator with this name can be either unary or binary. */
+int ambi_op_p (name)
+ tree name;
+{
+ return (name == ansi_opname [(int) INDIRECT_REF]
+ || name == ansi_opname [(int) ADDR_EXPR]
+ || name == ansi_opname [(int) NEGATE_EXPR]
+ || name == ansi_opname[(int) POSTINCREMENT_EXPR]
+ || name == ansi_opname[(int) POSTDECREMENT_EXPR]
+ || name == ansi_opname [(int) CONVERT_EXPR]);
+}
+
+/* An operator with this name can only be unary. */
+int unary_op_p (name)
+ tree name;
+{
+ return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
+ || name == ansi_opname [(int) BIT_NOT_EXPR]
+ || name == ansi_opname [(int) COMPONENT_REF]
+ || OPERATOR_TYPENAME_P (name));
+}
+
+/* Do a little sanity-checking on how they declared their operator. */
+static void
+grok_op_properties (decl, virtualp, friendp)
+ tree decl;
+ int virtualp, friendp;
+{
+ tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
+ int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
+ tree name = DECL_NAME (decl);
+ tree t;
+
+ if (! friendp)
+ for (t = current_class_type; t; t = TYPE_NEXT_VARIANT (t))
+ {
+ if (name == ansi_opname[(int) MODIFY_EXPR])
+ TYPE_HAS_ASSIGNMENT (t) = 1;
+ else if (name == ansi_opname[(int) CALL_EXPR])
+ TYPE_OVERLOADS_CALL_EXPR (t) = 1;
+ else if (name == ansi_opname[(int) ARRAY_REF])
+ TYPE_OVERLOADS_ARRAY_REF (t) = 1;
+ else if (name == ansi_opname[(int) COMPONENT_REF]
+ || name == ansi_opname[(int) MEMBER_REF])
+ TYPE_OVERLOADS_ARROW (t) = 1;
+ else if (name == ansi_opname[(int) NEW_EXPR])
+ {
+ if (TREE_CHAIN (argtypes) == void_list_node)
+ TREE_GETS_NEW (t) = 1;
+ else
+ TREE_GETS_PLACED_NEW (t) = 1;
+ }
+ else if (name == ansi_opname[(int) DELETE_EXPR])
+ TREE_GETS_DELETE (t) = 1;
+#if 0
+ else if (name == ansi_opname[(int) VEC_NEW_EXPR])
+ TREE_GETS_NEW (t) = 1;
+ else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
+ TREE_GETS_DELETE (t) = 1;
+#endif
+ }
+
+ if (name == ansi_opname[(int) NEW_EXPR])
+ {
+#if 0
+ /* When the compiler encounters the definition of A::operator new, it
+ doesn't look at the class declaration to find out if it's static. */
+ my_friendly_assert (!methodp, 355);
+#endif
+
+ /* 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));
+ }
+#if 0
+ else if (name == ansi_opname[(int) VEC_NEW_EXPR])
+ {
+ }
+#endif
+ else if (name == ansi_opname[(int) DELETE_EXPR])
+ {
+#if 0
+ my_friendly_assert (!methodp, 355);
+#endif
+
+ 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));
+ }
+#if 0
+ else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
+ {
+ }
+#endif
+ else
+ {
+ /* An operator function must either be a non-static member function
+ or have at least one parameter of a class, a reference to a class,
+ an enumeration, or a reference to an enumeration. 13.4.0.6 */
+ if (! methodp)
+ {
+ if (OPERATOR_TYPENAME_P (name)
+ || name == ansi_opname[(int) CALL_EXPR]
+ || name == ansi_opname[(int) MODIFY_EXPR]
+ || name == ansi_opname[(int) COMPONENT_REF]
+ || name == ansi_opname[(int) ARRAY_REF])
+ cp_error ("`%D' must be a nonstatic member function", decl);
+ else
+ {
+ tree p = argtypes;
+
+ if (p)
+ for (; TREE_VALUE (p) != void_type_node ; p = TREE_CHAIN (p))
+ {
+ tree arg = TREE_VALUE (p);
+ if (TREE_CODE (arg) == REFERENCE_TYPE)
+ arg = TREE_TYPE (arg);
+
+ /* This lets bad template code slip through. */
+ if (IS_AGGR_TYPE (arg)
+ || TREE_CODE (arg) == ENUMERAL_TYPE
+ || TREE_CODE (arg) == TEMPLATE_TYPE_PARM)
+ goto foundaggr;
+ }
+ cp_error
+ ("`%D' must have an argument of class or enumerated type",
+ decl);
+ foundaggr:
+ ;
+ }
+ }
+
+ if (name == ansi_opname[(int) CALL_EXPR]
+ || name == ansi_opname[(int) METHOD_CALL_EXPR])
+ return; /* no restrictions on args */
+
+ if (name == ansi_opname[(int) MODIFY_EXPR])
+ {
+ tree parmtype;
+
+ if (list_length (argtypes) != 3 && methodp)
+ {
+ cp_error ("`%D' must take exactly one argument", decl);
+ return;
+ }
+ parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
+
+ if (TREE_CODE (parmtype) == REFERENCE_TYPE
+ && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype))
+ == current_class_type)
+ {
+ TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
+ if (TYPE_READONLY (TREE_TYPE (parmtype)))
+ TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
+ }
+ }
+ else if (name == ansi_opname[(int) COND_EXPR])
+ {
+ /* 13.4.0.3 */
+ pedwarn ("ANSI C++ prohibits overloading operator ?:");
+ if (list_length (argtypes) != 4)
+ cp_error ("`%D' must take exactly three arguments", decl);
+ }
+ else if (ambi_op_p (name))
+ {
+ if (list_length (argtypes) == 2)
+ /* prefix */;
+ else if (list_length (argtypes) == 3)
+ {
+ if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
+ || name == ansi_opname[(int) POSTDECREMENT_EXPR])
+ && TREE_VALUE (TREE_CHAIN (argtypes)) != integer_type_node)
+ {
+ if (methodp)
+ cp_error ("postfix `%D' must take `int' as its argument",
+ decl);
+ else
+ cp_error
+ ("postfix `%D' must take `int' as its second argument",
+ decl);
+ }
+ }
+ else
+ {
+ if (methodp)
+ cp_error ("`%D' must take either zero or one argument", decl);
+ else
+ cp_error ("`%D' must take either one or two arguments", decl);
+ }
+ }
+ else if (unary_op_p (name))
+ {
+ if (list_length (argtypes) != 2)
+ {
+ if (methodp)
+ cp_error ("`%D' must take `void'", decl);
+ else
+ cp_error ("`%D' must take exactly one argument", decl);
+ }
+ }
+ else /* if (binary_op_p (name)) */
+ {
+ if (list_length (argtypes) != 3)
+ {
+ if (methodp)
+ cp_error ("`%D' must take exactly one argument", decl);
+ else
+ cp_error ("`%D' must take exactly two arguments", decl);
+ }
+ }
+
+ /* 13.4.0.8 */
+ if (argtypes)
+ for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
+ if (TREE_PURPOSE (argtypes))
+ {
+ TREE_PURPOSE (argtypes) = NULL_TREE;
+ if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
+ || name == ansi_opname[(int) POSTDECREMENT_EXPR])
+ {
+ if (pedantic)
+ cp_pedwarn ("`%D' cannot have default arguments", decl);
+ }
+ else
+ cp_error ("`%D' cannot have default arguments", decl);
+ }
+ }
+}
+\f
+/* 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;
+*/
+ n1 = TYPE_NAME(current_class_type);
+ if (n1)
+ n1 = DECL_NESTED_TYPENAME(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, 0);
+ if (! ANON_AGGRNAME_P (name))
+ {
+ register tree type_decl = build_lang_decl (TYPE_DECL, ncp, rv);
+#ifdef DWARF_DEBUGGING_INFO
+ /* Mark the TYPE_DECL node created just above as a gratuitous one
+ so that dwarfout.c will know not to generate a TAG_typedef DIE
+ for it. */
+ if (write_symbols == DWARF_DEBUG)
+ DECL_IGNORED_P (type_decl) = 1;
+#endif /* DWARF_DEBUGGING_INFO */
+ pushdecl_top_level (type_decl);
+ }
+ }
+ else
+ {
+ rv = xref_tag (code_type_node, name, binfo, 0);
+ }
+ xref_next_defn = 0;
+ return rv;
+}
+
+tree
+xref_tag (code_type_node, name, binfo, globalize)
+ tree code_type_node;
+ tree name, binfo;
+ int globalize;
+{
+ enum tag_types tag_code;
+ enum tree_code code;
+ int temp = 0;
+ int i, len;
+ register tree ref, t;
+ struct binding_level *b = inner_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:
+ case signature_type:
+ code = RECORD_TYPE;
+ len = list_length (binfo);
+ break;
+ case union_type:
+ code = UNION_TYPE;
+ if (binfo)
+ {
+ cp_error ("derived union `%T' invalid", 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 (t = IDENTIFIER_TYPE_VALUE(name))
+ {
+ if (TREE_CODE(t) != code) t = NULL_TREE;
+ }
+ 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;
+ if (t && TYPE_CONTEXT(t) && strstr(IDENTIFIER_POINTER(name), "::"))
+ ref = t;
+ else
+ ref = lookup_tag (code, name, b, 1);
+ }
+ else
+ {
+ if (t)
+ ref = t;
+ 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, globalize);
+ 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, globalize);
+ 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);
+
+ /* A signature type will contain the fields of the signature
+ table. Therefore, it's not only an interface. */
+ if (tag_code == signature_type)
+ {
+ SET_SIGNATURE (ref);
+ CLASSTYPE_INTERFACE_ONLY (ref) = 0;
+ CLASSTYPE_INTERFACE_UNKNOWN (ref) = 0;
+ }
+
+ /* Record how to set the access 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_KNOWN (ref);
+ break;
+ default:
+ needs_writing = 0;
+ }
+
+ /* Signatures don't have a vtable. As long as we don't have default
+ implementations, they behave as if `write_virtuals' were 3. */
+ if (tag_code == signature_type)
+ CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0;
+ else
+ 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, globalize);
+ 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)))
+ {
+ cp_error ("type `%T' is both exception and aggregate type", ref);
+ 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))))
+ {
+ cp_error ("redeclaration of derivation chain of type `%#T'",
+ ref);
+ 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 by default. */
+ int via_public
+ = (TREE_PURPOSE (binfo) == (tree)access_public
+ || TREE_PURPOSE (binfo) == (tree)access_public_virtual
+ || (tag_code != class_type
+ && (TREE_PURPOSE (binfo) == (tree)access_default
+ || TREE_PURPOSE (binfo) == (tree)access_default_virtual)));
+ int via_protected = TREE_PURPOSE (binfo) == (tree)access_protected;
+ int via_virtual
+ = (TREE_PURPOSE (binfo) == (tree)access_private_virtual
+ || TREE_PURPOSE (binfo) == (tree)access_public_virtual
+ || TREE_PURPOSE (binfo) == (tree)access_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)
+ {
+ cp_error ("base class `%T' has incomplete type", basetype);
+ continue;
+ }
+#endif
+ else
+ {
+ if (CLASSTYPE_MARKED (basetype))
+ {
+ if (basetype == ref)
+ cp_error ("recursive type `%T' undefined", basetype);
+ else
+ cp_error ("duplicate base type `%T' invalid", basetype);
+ 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_OVERLOADS_METHOD_CALL_EXPR (ref) |= TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype);
+ TREE_GETS_NEW (ref) |= TREE_GETS_NEW (basetype);
+ TREE_GETS_PLACED_NEW (ref) |= TREE_GETS_PLACED_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 || tag_code == signature_type)
+ CLASSTYPE_DECLARED_CLASS (ref) = 0;
+ }
+
+ pop_obstacks ();
+
+ return ref;
+}
+\f
+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 = inner_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)
+ cp_error ("multiple definition of enum `%T'", enumtype);
+ else
+ {
+ enumtype = make_node (ENUMERAL_TYPE);
+ pushtag (name, enumtype, 0);
+ }
+
+ if (current_class_type)
+ TREE_ADDRESSABLE (b->tags) = 1;
+ current_local_enum = NULL_TREE;
+
+ if (TYPE_VALUES (enumtype) != NULL_TREE)
+ /* 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, tem;
+ 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);
+
+ /* Fix up all variant types of this enum type. */
+ for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
+ {
+ TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
+ TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
+ TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
+ TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
+ TYPE_MODE (tem) = TYPE_MODE (enumtype);
+ TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
+ TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
+ TREE_UNSIGNED (tem) = TREE_UNSIGNED (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)
+ {
+ value = default_conversion (value);
+ constant_expression_warning (value);
+ }
+ else
+ {
+ 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. */
+
+ /* There are a number of cases we need to be aware of here:
+ current_class_type current_function_decl
+ * global enums NULL NULL
+ * fn-local enum NULL SET
+ * class-local enum SET NULL
+ * class->fn->enum SET SET
+ * fn->class->enum SET SET
+
+ Those last two make life interesting. If it's a fn-local enum which is
+ itself inside a class, we need the enum to go into the fn's decls (our
+ second case below). But if it's a class-local enum and the class itself
+ is inside a function, we need that enum to go into the decls for the
+ class. To achieve this last goal, we must see if, when both
+ current_class_decl and current_function_decl are set, the class was
+ declared inside that function. If so, we know to put the enum into
+ the class's scope. */
+
+ if ((current_class_type && ! current_function_decl)
+ || (current_class_type && current_function_decl
+ && TYPE_CONTEXT (current_class_type) == current_function_decl))
+ {
+ /* This enum declaration is local to the class, so we must put
+ it in that class's list of decls. */
+ 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;
+ }
+ else
+ {
+ /* It's a global enum, or it's local to a function. (Note local to
+ a function could mean local to a class method. */
+ decl = build_decl (CONST_DECL, name, integer_type_node);
+ DECL_INITIAL (decl) = value;
+
+ pushdecl (decl);
+ GNU_xref_decl (current_function_decl, 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;
+}
+\f
+/* 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;
+
+ if (! DECL_ARGUMENTS (decl1)
+ && !DECL_STATIC_FUNCTION_P (decl1)
+ && DECL_CONTEXT (decl1)
+ && DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))
+ && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))))
+ {
+ cp_error ("redeclaration of `%#D'", decl1);
+ if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
+ cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)));
+ else if (IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1)))
+ cp_error_at ("previous declaration here", IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1)));
+ }
+
+ 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 = DECL_CLASS_CONTEXT (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) && ! TYPE_PTRMEMFUNC_P (restype)
+ && ! CLASSTYPE_GOT_SEMICOLON (restype))
+ {
+ cp_error ("semicolon missing after declaration of `%#T'", restype);
+ 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)
+ cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
+
+ 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 declared function. */
+ 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_BUILT_IN (olddecl) && DECL_INITIAL (olddecl))
+ redeclaration_error_message (decl1, olddecl);
+ if (duplicate_decls (decl1, olddecl))
+ decl1 = olddecl;
+ else
+ olddecl = NULL_TREE;
+ }
+ 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)
+ {
+ push_nested_class (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))
+ push_nested_class (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;
+}
+\f
+/* 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
+ cp_error_at ("parameter name omitted", parm);
+#else
+ /* for C++, this is not an error. */
+ pushdecl (parm);
+#endif
+ }
+ else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
+ cp_error ("parameter `%D' declared void", parm);
+ 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);
+ }
+}
+
+#if 0
+/* Generate code for default 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_HAS_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);
+ init = build_tree_list (NULL_TREE, init);
+
+ current_member_init_list
+ = tree_cons (DECL_NAME (fields), init, current_member_init_list);
+ }
+}
+#endif
+\f
+/* 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;
+ tree decls = 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);
+ expand_start_bindings (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);
+ else
+ exprstmt = build_delete (current_class_type, C_C_D, in_charge_node,
+ LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 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));
+ }
+ 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
+ (build_indirect_ref
+ (build1 (NOP_EXPR, TYPE_POINTER_TO (current_class_type),
+ error_mark_node),
+ NULL_PTR),
+ 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. */
+ expand_end_bindings (NULL_TREE, getdecls() != NULL_TREE, 0);
+ poplevel (2, 0, 0); /* XXX change to 1 */
+
+ /* 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 in non-virtual base
+ classes point to CURRENT_CLASS_TYPE's virtual function
+ tables. */
+ init_vtbl_ptrs (binfo, 1, 0);
+ 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)
+ {
+ 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);
+ 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));
+ }
+ }
+
+ 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 0
+ if (DECL_NAME (fndecl) == NULL_TREE
+ && TREE_CHAIN (DECL_ARGUMENTS (fndecl)) != NULL_TREE)
+ build_default_constructor (fndecl);
+#endif
+
+ /* 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 (decls = getdecls (), decls != NULL_TREE, 0);
+ poplevel (decls != NULL_TREE, 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 ();
+ }
+
+ /* 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;
+ pop_nested_class (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, 1);
+
+ /* 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)
+ cp_warning ("`noreturn' function `%D' does return", fndecl);
+ else if ((warn_return_type || pedantic)
+ && 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. */
+ cp_pedwarn ("control reaches end of non-void function `%D'", fndecl);
+ }
+ /* 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;
+}
+\f
+/* 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 return type and the name of the function,
+ 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 (IS_SIGNATURE (current_class_type))
+ {
+ IS_DEFAULT_IMPLEMENTATION (fndecl) = 1;
+ /* In case we need this info later. */
+ HAS_DEFAULT_IMPLEMENTATION (current_class_type) = 1;
+ }
+
+ if (DECL_IN_AGGR_P (fndecl))
+ {
+ if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
+ {
+ if (DECL_CONTEXT (fndecl))
+ cp_error ("`%D' is already defined in class %s", fndecl,
+ 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), 0);
+ }
+
+ 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;
+
+ 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);
+
+ poplevel (0, 0, 0);
+
+ DECL_INITIAL (fndecl) = old_initial;
+
+ /* We used to check if the context of FNDECL was different from
+ current_class_type as another way to get inside here. This didn't work
+ for String.cc in libg++. */
+ if (DECL_FRIEND_P (fndecl))
+ {
+ CLASSTYPE_INLINE_FRIENDS (current_class_type)
+ = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
+ decl = void_type_node;
+ }
+
+ return decl;
+}
+\f
+/* 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);
+
+ 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;
+}
+\f
+/* 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)
+ {
+ cp_warning ("reference, not call, to function `%D'", exp);
+ 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),
+ 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;
+}
--- /dev/null
+/* 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
--- /dev/null
+/* 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 "decl.h"
+#include "lex.h"
+
+extern tree grokdeclarator ();
+extern tree get_file_function_name ();
+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;
+
+/* Flag used when debugging cp-spew.c */
+
+extern int spew_debug;
+\f
+/* 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 argument matching for overloading according to the
+ ANSI rules, rather than what g++ used to believe to be correct. */
+
+int flag_ansi_overloading = 1;
+
+/* Nonzero means do emit exported implementations of functions even if
+ they can be inlined. */
+
+int flag_implement_inlines = 1;
+
+/* Nonzero means do emit exported implementations of templates, instead of
+ multiple static copies in each file that needs a definition. */
+
+int flag_external_templates = 0;
+
+/* Nonzero means that the decision to emit or not emit the implementation of a
+ template depends on where the template is instantiated, rather than where
+ it is defined. */
+
+int flag_alt_external_templates = 0;
+
+/* Nonzero means warn about implicit declarations. */
+
+int warn_implicit = 1;
+
+/* Nonzero means warn when all ctors or dtors are private, and the class
+ has no friends. */
+
+int warn_ctor_dtor_privacy = 1;
+
+/* 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 if initializer is not completely bracketed. */
+
+int warn_missing_braces;
+
+/* Warn about *printf or *scanf format/argument anomalies. */
+
+int warn_format;
+
+/* Warn about a subscript that has type char. */
+
+int warn_char_subscripts;
+
+/* 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 declaring a class that has a non virtual
+ destructor, when it really ought to have a virtual one. */
+int warn_nonvdtor = 1;
+
+/* Non-zero means warn when a function is declared extern and later inline. */
+int warn_extern_inline;
+
+/* 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 access.
+ 1 means write out virtual function tables and give them
+ (C) public access.
+ 0 means write out virtual function tables and give them
+ (C) static access (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;
+
+/* 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 recognize and handle signature language constructs. */
+
+int flag_handle_signatures;
+
+/* 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;
+
+/* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
+ objects. */
+int flag_huge_objects;
+
+/* Nonzero if we want to conserve space in the .o files. We do this
+ by putting uninitialized data and runtime initialized data into
+ .common instead of .data at the expense of not flaging multiple
+ definitions. */
+int flag_conserve_space;
+
+/* 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},
+ {"handle-exceptions", &flag_handle_exceptions, 1},
+ {"ansi-exceptions", &flag_ansi_exceptions, 1},
+ {"handle-signatures", &flag_handle_signatures, 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},
+ {"external-templates", &flag_external_templates, 1},
+ {"ansi-overloading", &flag_ansi_overloading, 1},
+ {"huge-objects", &flag_huge_objects, 1},
+ {"conserve-space", &flag_conserve_space, 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 if (! strcmp (p, "alt-external-templates"))
+ {
+ flag_external_templates = 1;
+ flag_alt_external_templates = 1;
+ found = 1;
+ }
+ else if (! strcmp (p, "no-alt-external-templates"))
+ {
+ flag_alt_external_templates = 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"))
+ warn_return_type = setting;
+ else if (!strcmp (p, "ctor-dtor-privacy"))
+ warn_ctor_dtor_privacy = 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, "missing-braces"))
+ warn_missing_braces = 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, "extern-inline"))
+ warn_extern_inline = 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;
+ warn_return_type = setting;
+ warn_unused = setting;
+ warn_implicit = setting;
+ warn_ctor_dtor_privacy = setting;
+ warn_switch = setting;
+ warn_format = setting;
+ warn_missing_braces = setting;
+ warn_extern_inline = 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;
+ }
+
+ else if (!strcmp (p, "overloaded-virtual"))
+ warn_overloaded_virtual = 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;
+}
+\f
+/* 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), 1);
+ if (n[strlen (n) - 1] == ' ')
+ n[strlen (n) - 1] = 0;
+ DECL_NAME (decl) = get_identifier (n);
+ }
+}
+
+/* Warn when -fexternal-templates is used and #pragma
+ interface/implementation is not used all the times it should be,
+ inform the user. */
+void
+warn_if_unknown_interface ()
+{
+ static int already_warned = 0;
+ if (++already_warned == 1)
+ warning ("templates that are built with -fexternal-templates should be in files that have #pragma interface/implementation");
+}
+
+/* A subroutine of the parser, to handle a component list. */
+tree
+grok_x_components (specs, components)
+ tree specs, components;
+{
+ register tree t, x, tcode;
+
+ /* We just got some friends. They have been recorded elsewhere. */
+ if (components == void_type_node)
+ return NULL_TREE;
+
+ if (components == NULL_TREE)
+ {
+ t = groktypename (build_decl_list (specs, NULL_TREE));
+
+ if (t == NULL_TREE)
+ {
+ error ("error in component specification");
+ return NULL_TREE;
+ }
+
+ switch (TREE_CODE (t))
+ {
+ case VAR_DECL:
+ /* Static anonymous unions come out as VAR_DECLs. */
+ if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE
+ && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_TYPE (t))))
+ return t;
+
+ /* We return SPECS here, because in the parser it was ending
+ up with not doing anything to $$, which is what SPECS
+ represents. */
+ return specs;
+ break;
+
+ case RECORD_TYPE:
+ /* This code may be needed for UNION_TYPEs as
+ well. */
+ tcode = record_type_node;
+ if (CLASSTYPE_DECLARED_CLASS(t))
+ tcode = class_type_node;
+ else if (IS_SIGNATURE(t))
+ tcode = signature_type_node;
+ else if (CLASSTYPE_DECLARED_EXCEPTION(t))
+ tcode = exception_type_node;
+
+ t = xref_defn_tag(tcode, TYPE_IDENTIFIER(t), NULL_TREE);
+ if (TYPE_CONTEXT(t))
+ CLASSTYPE_NO_GLOBALIZE(t) = 1;
+ if (TYPE_LANG_SPECIFIC (t)
+ && CLASSTYPE_DECLARED_EXCEPTION (t))
+ shadow_tag (specs);
+ return NULL_TREE;
+ break;
+
+ case UNION_TYPE:
+ case ENUMERAL_TYPE:
+ if (TREE_CODE(t) == UNION_TYPE)
+ tcode = union_type_node;
+ else
+ tcode = enum_type_node;
+
+ t = xref_defn_tag(tcode, TYPE_IDENTIFIER(t), NULL_TREE);
+ if (TREE_CODE(t) == UNION_TYPE && TYPE_CONTEXT(t))
+ CLASSTYPE_NO_GLOBALIZE(t) = 1;
+ if (TREE_CODE (t) == UNION_TYPE
+ && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
+ {
+ struct pending_inline **p;
+ x = build_lang_field_decl (FIELD_DECL, NULL_TREE, t);
+
+ /* Wipe out memory of synthesized methods */
+ TYPE_HAS_CONSTRUCTOR (t) = 0;
+ TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
+ TYPE_HAS_INIT_REF (t) = 0;
+ TYPE_HAS_CONST_INIT_REF (t) = 0;
+ TYPE_HAS_ASSIGN_REF (t) = 0;
+ TYPE_HAS_ASSIGNMENT (t) = 0;
+ TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
+
+ p = &pending_inlines;
+ for (; *p; *p = (*p)->next)
+ if (DECL_CONTEXT ((*p)->fndecl) != t)
+ break;
+ }
+ else if (TREE_CODE (t) == ENUMERAL_TYPE)
+ x = grok_enum_decls (t, NULL_TREE);
+ else
+ x = NULL_TREE;
+ return x;
+ break;
+
+ default:
+ if (t != void_type_node)
+ error ("empty component declaration");
+ return NULL_TREE;
+ }
+ }
+ else
+ {
+ t = TREE_TYPE (components);
+ if (TREE_CODE (t) == ENUMERAL_TYPE && TREE_NONLOCAL_FLAG (t))
+ return grok_enum_decls (t, components);
+ else
+ return components;
+ }
+}
+
+/* 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);
+ /* Mark the artificial `__in_chrg' parameter as "artificial". */
+ DECL_SOURCE_LINE (parm) = 0;
+ 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);
+ TREE_SIDE_EFFECTS (arg_types) = 1;
+ /* Build the overload name. It will look like `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
+ /* 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. This used to be internal error 346. */
+ dbuf = build_overload_name (ctype, 1, 1);
+ 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);
+ /* Mark the artificial `__in_chrg' parameter as "artificial". */
+ DECL_SOURCE_LINE (parm) = 0;
+ TREE_USED (parm) = 1;
+#if 0
+ /* We don't need to mark the __in_chrg parameter itself as `const'
+ since its type is already `const int'. In fact we MUST NOT mark
+ it as `const' cuz that will screw up the debug info (causing it
+ to say that the type of __in_chrg is `const const int'). */
+ TREE_READONLY (parm) = 1;
+#endif
+ 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
+ }
+
+ DECL_ARGUMENTS (function) = last_function_parms;
+ /* First approximations. */
+ DECL_CONTEXT (function) = ctype;
+ DECL_CLASS_CONTEXT (function) = ctype;
+}
+
+/* Work on the expr used by alignof (this is only called by the parser). */
+tree
+grok_alignof (expr)
+ tree expr;
+{
+ tree best, t;
+ int bestalign;
+
+ if (TREE_CODE (expr) == COMPONENT_REF
+ && DECL_BIT_FIELD (TREE_OPERAND (expr, 1)))
+ error ("`__alignof__' applied to a bit-field");
+
+ if (TREE_CODE (expr) == INDIRECT_REF)
+ {
+ best = t = TREE_OPERAND (expr, 0);
+ 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;
+ }
+ return 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 (expr) == COMPOUND_EXPR
+ && (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
+ || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE))
+ expr = default_conversion (expr);
+ return c_alignof (TREE_TYPE (expr));
+ }
+}
+
+/* Create an ARRAY_REF, checking for the user doing things backwards
+ along the way. */
+tree
+grok_array_decl (array_expr, index_exp)
+ tree array_expr, index_exp;
+{
+ tree type = TREE_TYPE (array_expr);
+
+ if (type == error_mark_node || index_exp == error_mark_node)
+ return error_mark_node;
+ 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?");
+ return NULL_TREE;
+ }
+
+ if (TREE_CODE (type) == OFFSET_TYPE
+ || TREE_CODE (type) == REFERENCE_TYPE)
+ type = TREE_TYPE (type);
+
+ /* If they have an `operator[]', use that. */
+ if (TYPE_LANG_SPECIFIC (type)
+ && TYPE_OVERLOADS_ARRAY_REF (type))
+ return build_opfncall (ARRAY_REF, LOOKUP_NORMAL,
+ array_expr, index_exp, NULL_TREE);
+
+ /* Otherwise, create an ARRAY_REF for a pointer or array type. */
+ if (TREE_CODE (type) == POINTER_TYPE
+ || TREE_CODE (type) == ARRAY_TYPE)
+ return build_array_ref (array_expr, index_exp);
+
+ /* Woops, looks like they did something like `5[a]' instead of `a[5]'.
+ We don't emit a warning or error for this, since it's allowed
+ by ARM $8.2.4. */
+
+ type = TREE_TYPE (index_exp);
+
+ if (TREE_CODE (type) == OFFSET_TYPE
+ || 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)
+ return build_array_ref (index_exp, array_expr);
+ else
+ error("`[]' applied to non-pointer type");
+
+ /* We gave an error, so give an error. Huh? */
+ return error_mark_node;
+}
+
+/* Given the cast expression EXP, checking out its validity. Either return
+ an error_mark_node if there was an unavoidable error, return a cast to
+ void for trying to delete a pointer w/ the value 0, or return the
+ call to delete. If DOING_VEC is 1, we handle things differently
+ for doing an array delete. If DOING_VEC is 2, they gave us the
+ array size as an argument to delete.
+ Implements ARM $5.3.4. This is called from the parser. */
+tree
+delete_sanity (exp, size, doing_vec, use_global_delete)
+ tree exp, size;
+ int doing_vec, use_global_delete;
+{
+ tree t = stabilize_reference (convert_from_reference (exp));
+ tree type = TREE_TYPE (t);
+ enum tree_code code = TREE_CODE (type);
+ /* For a regular vector delete (aka, no size argument) we will pass
+ this down as a NULL_TREE into build_vec_delete. */
+ tree maxindex = NULL_TREE;
+ /* This is used for deleting arrays. */
+ tree elt_size;
+
+ switch (doing_vec)
+ {
+ case 2:
+ maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
+ if (! flag_traditional)
+ pedwarn ("ANSI C++ forbids array size in vector delete");
+ /* Fall through. */
+ case 1:
+ elt_size = c_sizeof (type);
+ break;
+ default:
+ if (code != POINTER_TYPE)
+ {
+ cp_error ("type `%#T' argument given to `delete', expected pointer",
+ type);
+ return error_mark_node;
+ }
+
+ /* Deleting a pointer with the value zero is legal and has no effect. */
+ if (integer_zerop (t))
+ return build1 (NOP_EXPR, void_type_node, t);
+ }
+
+ /* You can't delete a pointer to constant. */
+ if (code == POINTER_TYPE && TREE_READONLY (TREE_TYPE (type)))
+ {
+ error ("`const *' cannot be deleted");
+ return error_mark_node;
+ }
+
+ /* If the type has no destructor, then we should build a regular
+ delete, instead of a vector delete. Otherwise, we would end
+ up passing a bogus offset into __builtin_delete, which is
+ not expecting it. */
+ if (doing_vec
+ && TREE_CODE (type) == POINTER_TYPE
+ && !TYPE_HAS_DESTRUCTOR (TREE_TYPE (type)))
+ doing_vec = 0;
+
+ if (doing_vec)
+ return build_vec_delete (t, maxindex, elt_size, NULL_TREE,
+ integer_one_node, integer_two_node);
+ else
+ return build_delete (type, t, integer_three_node,
+ LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE,
+ use_global_delete
+ || TYPE_HAS_DESTRUCTOR (TREE_TYPE (type)));
+}
+
+/* Sanity check: report error if this function FUNCTION is not
+ really a member of the class (CTYPE) it is supposed to belong to.
+ CNAME is the same here as it is 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;
+ 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 (methods != end)
+ cp_error ("argument list for `%D' does not match any in class `%T'",
+ fn_name, ctype);
+ else
+ {
+ methods = 0;
+ cp_error ("no `%D' member function declared in class `%T'",
+ fn_name, ctype);
+ }
+
+ /* 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"))
+ cp_error ("member `%D' conflicts with virtual function table field name", value);
+
+ /* Stash away type declarations. */
+ if (TREE_CODE (value) == TYPE_DECL)
+ {
+ DECL_NONLOCAL (value) = 1;
+ CLASSTYPE_LOCAL_TYPEDECLS (current_class_type) = 1;
+ pushdecl_class_level (value);
+ return value;
+ }
+
+ if (IS_SIGNATURE (current_class_type)
+ && TREE_CODE (value) != FUNCTION_DECL)
+ {
+ error ("field declaration not allowed in signature");
+ return void_type_node;
+ }
+
+ if (DECL_IN_AGGR_P (value))
+ {
+ cp_error ("`%D' is already defined in the class %T", value,
+ 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)
+ {
+ if (IS_SIGNATURE (current_class_type)
+ && TREE_CODE (value) == FUNCTION_DECL)
+ {
+ error ("function declarations cannot have initializers in signature");
+ init = NULL_TREE;
+ }
+ else if (TREE_CODE (value) == FUNCTION_DECL)
+ {
+ grok_function_init (value, init);
+ init = NULL_TREE;
+ }
+ else if (pedantic)
+ {
+ if (DECL_NAME (value))
+ pedwarn ("ANSI C++ forbids initialization of member `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (value)));
+ else
+ pedwarn ("ANSI C++ forbids initialization of fields");
+
+ 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)
+ {
+ cp_error ("cannot declare `%D' to be a bitfield type", value);
+ return NULL_TREE;
+ }
+
+ if (IS_SIGNATURE (current_class_type))
+ {
+ error ("field declaration not allowed in signature");
+ return void_type_node;
+ }
+
+ if (DECL_IN_AGGR_P (value))
+ {
+ cp_error ("`%D' is already defined in the class %T", value,
+ DECL_CONTEXT (value));
+ return void_type_node;
+ }
+
+ GNU_xref_member (current_class_name, value);
+
+ if (TREE_STATIC (value))
+ {
+ cp_error ("static member `%D' cannot be a bitfield", value);
+ 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)
+ {
+ cp_error ("structure field `%D' width not an integer constant",
+ value);
+ DECL_INITIAL (value) = NULL_TREE;
+ }
+ else
+ {
+ constant_expression_warning (width);
+ 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))
+ {
+ cp_error ("`%D' already defined in the class ", decl);
+ 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))
+ {
+ cp_error ("function `%D' declared twice in class %T", decl,
+ 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);
+
+ 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;
+
+ 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)
+ cp_error ("`operator %T' requires empty parameter list",
+ last);
+ else
+ /* Canonicalize parameter lists. */
+ TREE_OPERAND (tmp, 1) = void_list_node;
+ }
+
+ 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);
+ }
+
+ last = grokdeclarator (TREE_OPERAND (decl, 0),
+ TREE_TYPE (decl),
+ TYPENAME, 0, NULL_TREE);
+
+ if (call_required)
+ cp_error ("`operator %T' construct requires parameter list", last);
+
+ 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)
+ cp_error ("initializer specified for non-member function `%D'", decl);
+ else if (DECL_VINDEX (decl) == NULL_TREE)
+ cp_error ("initializer specified for non-virtual method `%D'", decl);
+ 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)
+ cp_error ("non-method initializer invalid for method `%D'", decl);
+ 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
+ cp_error ("invalid initializer for virtual method `%D'", decl);
+}
+\f
+/* 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;
+ int is_ttp = 0;
+
+ if (cname == error_mark_node)
+ return error_mark_node;
+
+ ctype = IDENTIFIER_TYPE_VALUE (cname);
+
+ if (TREE_CODE (ctype) == TEMPLATE_TYPE_PARM)
+ is_ttp = 1;
+ else if (ctype == NULL_TREE || ! IS_AGGR_TYPE (ctype))
+ {
+ cp_error ("`%T' not defined as aggregate type", cname);
+ return name;
+ }
+ else if (IS_SIGNATURE (ctype))
+ {
+ error ("cannot push into signature scope, scope resolution operator ignored");
+ return name;
+ }
+
+ rval = build_parse_node (SCOPE_REF, cname, name);
+
+ /* Don't need to push the scope if we're already in it.
+ We also don't need to push the scope for a ptr-to-member/method. */
+
+ if (ctype == current_class_type || TREE_CODE (name) != IDENTIFIER_NODE
+ || is_ttp)
+ return rval;
+
+ /* We do need to push the scope in this case, since CTYPE helps
+ determine subsequent intializers (i.e., Foo::Bar x = foo_enum_1;). */
+
+ push_nested_class (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);
+}
+\f
+/* CONSTRUCTOR_NAME:
+ Return the name for the constructor (or destructor) for the
+ specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
+ IDENTIFIER_NODE. When given a template, this routine doesn't
+ lose the specialization. */
+tree
+constructor_name_full (thing)
+ tree thing;
+{
+ tree t;
+ if (TREE_CODE (thing) == UNINSTANTIATED_P_TYPE)
+ return DECL_NAME (UPT_TEMPLATE (thing));
+ if (IS_AGGR_TYPE_CODE (TREE_CODE (thing)))
+ {
+ if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing))
+ thing = DECL_NAME (TREE_VEC_ELT (TYPE_METHODS (thing), 0));
+ else
+ 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);
+ return thing;
+}
+
+/* CONSTRUCTOR_NAME:
+ Return the name for the constructor (or destructor) for the
+ specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
+ IDENTIFIER_NODE. When given a template, return the plain
+ unspecialized name. */
+tree
+constructor_name (thing)
+ tree thing;
+{
+ tree t;
+ thing = constructor_name_full (thing);
+ t = IDENTIFIER_TEMPLATE (thing);
+ if (!t)
+ return thing;
+ t = TREE_PURPOSE (t);
+ return DECL_NAME (t);
+}
+\f
+/* 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, NULL_PTR);
+ }
+ 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)
+ {
+ error ("global anonymous unions must be declared static");
+ return;
+ }
+
+ 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
+ && simple_cst_equal (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 access. */
+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 minus one, or put another way, it is the maximum subscript
+ used 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);
+}
+\f
+/* 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;
+}
+\f
+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;
+ temporary_allocation ();
+ output_inline_function (fn);
+ permanent_allocation ();
+ }
+ 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));
+
+#ifdef DWARF_DEBUGGING_INFO
+ if (write_symbols == DWARF_DEBUG)
+ {
+ /* Mark the VAR_DECL node representing the vtable itself as a
+ "gratuitous" one, thereby forcing dwarfout.c to ignore it.
+ It is rather important that such things be ignored because
+ any effort to actually generate DWARF for them will run
+ into trouble when/if we encounter code like:
+
+ #pragma interface
+ struct S { virtual void member (); };
+
+ because the artificial declaration of the vtable itself (as
+ manufactured by the g++ front end) will say that the vtable
+ is a static member of `S' but only *after* the debug output
+ for the definition of `S' has already been output. This causes
+ grief because the DWARF entry for the definition of the vtable
+ will try to refer back to an earlier *declaration* of the
+ vtable as a static member of `S' and there won't be one.
+ We might be able to arrange to have the "vtable static member"
+ attached to the member list for `S' before the debug info for
+ `S' get written (which would solve the problem) but that would
+ require more intrusive changes to the g++ front end. */
+
+ DECL_IGNORED_P (vars) = 1;
+ }
+#endif /* DWARF_DEBUGGING_INFO */
+
+ 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))
+ {
+ register tree type = TREE_TYPE (vars);
+
+ if (TREE_CODE (vars) == TYPE_DECL
+ && type != error_mark_node
+ && TYPE_LANG_SPECIFIC (type)
+ && CLASSTYPE_VSIZE (type))
+ {
+ 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;
+
+ tree fnname;
+ tree vars = static_aggregates;
+ int needs_cleaning = 0, needs_messing_up = 0;
+
+ 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. */
+
+ /* 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_file_function_name ('D');
+ 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);
+ 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)
+ {
+ fnname = get_file_function_name ('I');
+ 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)
+ {
+#if 0
+ /* 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 && IS_AGGR_TYPE (TREE_TYPE (decl)))
+ DECL_CLASS_CONTEXT (current_function_decl) = TREE_TYPE (decl);
+ expand_aggr_init (decl, init, 0);
+ DECL_CLASS_CONTEXT (current_function_decl) = old_dcc;
+#else
+ expand_aggr_init (decl, init, 0);
+#endif
+ }
+ 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, NULL_PTR), 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))
+ {
+ temporary_allocation ();
+ output_inline_function (decl);
+ permanent_allocation ();
+ }
+ 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 ();
+}
--- /dev/null
+/* Provide a call-back mechanism for handling error output.
+ Copyright (C) 1993 Free Software Foundation, Inc.
+ Contributed by Jason Merrill (jason@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 <ctype.h>
+
+/* cp_printer is the type of a function which converts an argument into
+ a string for digestion by printf. The cp_printer function should deal
+ with all memory management; the functions in this file will not free
+ the char*s returned. See cp-error.c for an example use of this code. */
+
+typedef char* cp_printer PROTO((HOST_WIDE_INT, int));
+extern cp_printer * cp_printers[256];
+
+typedef void errorfn (); /* deliberately vague */
+
+extern char* cp_file_of PROTO((tree));
+extern int cp_line_of PROTO((tree));
+
+#define STRDUP(f) (ap = (char *) alloca (strlen (f) +1), strcpy (ap, (f)), ap)
+
+#define NARGS 3
+#define arglist a1, a2, a3
+#define arglist_dcl HOST_WIDE_INT a1, a2, a3;
+#define ARGSINIT args[0] = a1; args[1] = a2; args[2] = a3;
+#define ARGSLIST args[0], args[1], args[2]
+
+static void
+cp_thing (errfn, atarg1, format, arglist)
+ errorfn *errfn;
+ int atarg1;
+ char *format;
+ arglist_dcl
+{
+ char *fmt;
+ char *f;
+ char *ap;
+ int arg;
+ HOST_WIDE_INT atarg = atarg1 ? a1 : 0;
+ HOST_WIDE_INT args[NARGS];
+ ARGSINIT
+
+ fmt = STRDUP(format);
+
+ for (f = fmt, arg = 0; *f; ++f)
+ {
+ cp_printer * function;
+ int alternate;
+ int maybe_here;
+
+ /* ignore text */
+ if (*f != '%') continue;
+
+ ++f;
+
+ alternate = 0;
+ maybe_here = 0;
+
+ /* ignore most flags */
+ while (*f == ' ' || *f == '-' || *f == '+' || *f == '#')
+ {
+ if (*f == '+')
+ maybe_here = 1;
+ else if (*f == '#')
+ alternate = 1;
+ ++f;
+ }
+
+ /* ignore field width */
+ if (*f == '*')
+ {
+ ++f;
+ ++arg;
+ }
+ else
+ while (isdigit (*f))
+ ++f;
+
+ /* ignore precision */
+ if (*f == '.')
+ {
+ ++f;
+ if (*f == '*')
+ {
+ ++f;
+ ++arg;
+ }
+ else
+ while (isdigit (*f))
+ ++f;
+ }
+
+ /* ignore "long" */
+ if (*f == 'l')
+ ++f;
+
+ function = cp_printers[*f];
+
+ if (function)
+ {
+ char *p;
+
+ if (arg >= NARGS) abort ();
+
+ if (maybe_here && atarg)
+ atarg = args[arg];
+
+ /* Must use a temporary to avoid calling *function twice */
+ p = (*function) (args[arg], alternate);
+ args[arg] = (HOST_WIDE_INT) STRDUP(p);
+ *f = 's';
+ }
+
+ ++arg; /* Assume valid format string */
+
+ }
+
+ if (atarg)
+ {
+ char *file = cp_file_of ((tree) atarg);
+ int line = cp_line_of ((tree) atarg);
+ (*errfn) (file, line, fmt, ARGSLIST);
+ }
+ else
+ (*errfn) (fmt, ARGSLIST);
+
+}
+
+void
+cp_error (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn error;
+ cp_thing (error, 0, format, arglist);
+}
+
+void
+cp_warning (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn warning;
+ cp_thing (warning, 0, format, arglist);
+}
+
+void
+cp_pedwarn (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn pedwarn;
+ cp_thing (pedwarn, 0, format, arglist);
+}
+
+void
+cp_compiler_error (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn compiler_error;
+ cp_thing (compiler_error, 0, format, arglist);
+}
+
+void
+cp_sprintf (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn sprintf;
+ cp_thing (sprintf, 0, format, arglist);
+}
+
+void
+cp_error_at (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn error_with_file_and_line;
+ cp_thing (error_with_file_and_line, 1, format, arglist);
+}
+
+void
+cp_warning_at (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn warning_with_file_and_line;
+ cp_thing (warning_with_file_and_line, 1, format, arglist);
+}
+
+void
+cp_pedwarn_at (format, arglist)
+ char *format;
+ arglist_dcl
+{
+ extern errorfn pedwarn_with_file_and_line;
+ cp_thing (pedwarn_with_file_and_line, 1, format, arglist);
+}
--- /dev/null
+/* Call-backs for C++ error reporting.
+ This code is non-reentrant.
+ 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. */
+
+#include "config.h"
+#include "tree.h"
+#include "cp-tree.h"
+#include "obstack.h"
+#include <ctype.h>
+
+typedef char* cp_printer ();
+
+#define A args_as_string
+#define C code_as_string
+#define D decl_as_string
+#define E expr_as_string
+#define L language_as_string
+#define O op_as_string
+#define P parm_as_string
+#define T type_as_string
+
+#define _ (cp_printer *) 0
+cp_printer * cp_printers[256] =
+{
+/*0 1 2 3 4 5 6 7 8 9 A B C D E F */
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x00 */
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x10 */
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x20 */
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x30 */
+ _, A, _, C, D, E, _, _, _, _, _, _, L, _, _, O, /* 0x40 */
+ P, _, _, _, T, _, _, _, _, _, _, _, _, _, _, _, /* 0x50 */
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x60 */
+ _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /* 0x70 */
+};
+#undef C
+#undef D
+#undef E
+#undef L
+#undef O
+#undef P
+#undef T
+#undef _
+
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+
+/* 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'))
+# define OB_PUTI(CST) do { sprintf (digit_buffer, "%d", (CST)); \
+ OB_PUTCP (digit_buffer); } while (0)
+
+# define NEXT_CODE(t) (TREE_CODE (TREE_TYPE (t)))
+
+static void dump_type (), dump_decl (), dump_function_decl ();
+static void dump_expr (), dump_unary_op (), dump_binary_op ();
+static void dump_aggr_type (), dump_type_prefix (), dump_type_suffix ();
+static void dump_function_name ();
+
+void
+init_error ()
+{
+ gcc_obstack_init (&scratch_obstack);
+ scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
+}
+
+/* Counter to help build parameter names in case they were omitted. */
+static int dummy_name;
+
+enum pad { none, before, after };
+
+static void
+dump_readonly_or_volatile (t, p)
+ tree t;
+ enum pad p;
+{
+ if (TYPE_READONLY (t) || TYPE_VOLATILE (t))
+ {
+ if (p == before) OB_PUTC (' ');
+ if (TYPE_READONLY (t))
+ OB_PUTS ("const");
+ if (TYPE_VOLATILE (t))
+ OB_PUTS ("volatile");
+ if (p == after) OB_PUTC (' ');
+ }
+}
+
+/* This must be large enough to hold any printed integer or floating-point
+ value. */
+static char digit_buffer[128];
+
+/* Dump into the obstack a human-readable equivalent of TYPE. */
+static void
+dump_type (t, v)
+ tree t;
+ int v; /* verbose? */
+{
+ if (t == NULL_TREE)
+ return;
+
+ if (TYPE_PTRMEMFUNC_P (t))
+ goto offset_type;
+
+ switch (TREE_CODE (t))
+ {
+ case ERROR_MARK:
+ OB_PUTS ("<error>");
+ break;
+
+ case UNKNOWN_TYPE:
+ OB_PUTS ("<unknown type>");
+ break;
+
+ case TREE_LIST:
+ /* i.e. function taking no arguments */
+ if (t != void_list_node)
+ {
+ dump_type (TREE_VALUE (t), v);
+ /* Can this happen other than for default arguments? */
+ if (TREE_PURPOSE (t) && v)
+ {
+ OB_PUTS (" = ");
+ dump_expr (TREE_PURPOSE (t));
+ }
+ if (TREE_CHAIN (t))
+ {
+ if (TREE_CHAIN (t) != void_list_node)
+ {
+ OB_PUTC2 (',', ' ');
+ dump_type (TREE_CHAIN (t), v);
+ }
+ }
+ else OB_PUTS (" ...");
+ }
+ break;
+
+ case IDENTIFIER_NODE:
+ OB_PUTID (t);
+ break;
+
+ case TREE_VEC:
+ dump_type (BINFO_TYPE (t), v);
+ break;
+
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ case ENUMERAL_TYPE:
+ if (TYPE_LANG_SPECIFIC (t)
+ && (IS_SIGNATURE_POINTER (t) || IS_SIGNATURE_REFERENCE (t)))
+ {
+ if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
+ dump_readonly_or_volatile (t);
+ dump_type (SIGNATURE_TYPE (t), v);
+ if (IS_SIGNATURE_POINTER (t))
+ OB_PUTC ('*');
+ else
+ OB_PUTC ('&');
+ }
+ else
+ dump_aggr_type (t, v);
+ break;
+
+ case TYPE_DECL:
+ dump_readonly_or_volatile (t, after);
+ OB_PUTID (DECL_NAME (t));
+ break;
+
+ case INTEGER_TYPE:
+ if (!TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && TREE_UNSIGNED (t))
+ OB_PUTS ("unsigned ");
+ else if (TREE_UNSIGNED (TYPE_MAIN_VARIANT (t)) && !TREE_UNSIGNED (t))
+ OB_PUTS ("signed ");
+
+ /* fall through. */
+ case REAL_TYPE:
+ case VOID_TYPE:
+ dump_readonly_or_volatile (t, after);
+ OB_PUTID (TYPE_IDENTIFIER (t));
+ 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;
+
+ /* This is not always necessary for pointers and such, but doing this
+ reduces code size. */
+ case ARRAY_TYPE:
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ case OFFSET_TYPE:
+ offset_type:
+ case FUNCTION_TYPE:
+ case METHOD_TYPE:
+ dump_type_prefix (t, v);
+ dump_type_suffix (t, v);
+ break;
+
+ default:
+ my_friendly_abort (68);
+
+ }
+}
+
+/* Print out a class declaration, in the form `class foo'. */
+static void
+dump_aggr_type (t, v)
+ tree t;
+ int v; /* verbose? */
+{
+ tree name;
+ char *variety;
+
+ if (TREE_CODE (t) == ENUMERAL_TYPE)
+ variety = "enum";
+ else if (TREE_CODE (t) == UNION_TYPE)
+ variety = "union";
+ else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
+ variety = "class";
+ else if (TYPE_LANG_SPECIFIC (t) && IS_SIGNATURE (t))
+ variety = "signature";
+ else
+ variety = "struct";
+
+ dump_readonly_or_volatile (t, after);
+
+ if (v > 0)
+ {
+ OB_PUTCP (variety);
+ OB_PUTC (' ');
+ }
+
+ name = TYPE_NAME (t);
+
+ if (DECL_CONTEXT (name))
+ {
+ /* FUNCTION_DECL or RECORD_TYPE */
+ dump_decl (DECL_CONTEXT (name), 0);
+ OB_PUTC2 (':', ':');
+ }
+
+ /* kludge around wierd behavior on g++.brendan/line1.C */
+ if (TREE_CODE (name) != IDENTIFIER_NODE)
+ name = DECL_NAME (name);
+
+ if (ANON_AGGRNAME_P (name))
+ {
+ OB_PUTS ("<anonymous");
+ if (!v)
+ {
+ OB_PUTC (' ');
+ OB_PUTCP (variety);
+ }
+ OB_PUTC ('>');
+ }
+ else
+ OB_PUTID (name);
+}
+
+/* Dump into the obstack the initial part of the output for a given type.
+ This is necessary when dealing with things like functions returning
+ functions. Examples:
+
+ return type of `int (* fee ())()': pointer -> function -> int. Both
+ pointer (and reference and offset) and function (and member) types must
+ deal with prefix and suffix.
+
+ Arrays must also do this for DECL nodes, like int a[], and for things like
+ int *[]&. */
+
+static void
+dump_type_prefix (t, v)
+ tree t;
+ int v; /* verbosity */
+{
+ if (TYPE_PTRMEMFUNC_P (t))
+ {
+ t = TYPE_PTRMEMFUNC_FN_TYPE (t);
+ goto offset_type;
+ }
+
+ switch (TREE_CODE (t))
+ {
+ case POINTER_TYPE:
+ {
+ tree sub = TREE_TYPE (t);
+
+ dump_type_prefix (sub, v);
+ /* A tree for a member pointer looks like pointer to offset,
+ so let the OFFSET_TYPE case handle it. */
+ if (TREE_CODE (sub) != OFFSET_TYPE)
+ {
+ switch (TREE_CODE (sub))
+ {
+ /* We don't want int ( *)() */
+ case FUNCTION_TYPE:
+ case METHOD_TYPE:
+ break;
+
+ case POINTER_TYPE:
+ /* We don't want "char * *" */
+ if (! (TYPE_READONLY (sub) || TYPE_VOLATILE (sub)))
+ break;
+ /* But we do want "char *const *" */
+
+ default:
+ OB_PUTC (' ');
+ }
+ OB_PUTC ('*');
+ dump_readonly_or_volatile (t, none);
+ }
+ }
+ break;
+
+ case REFERENCE_TYPE:
+ {
+ tree sub = TREE_TYPE (t);
+ dump_type_prefix (sub, v);
+
+ switch (TREE_CODE (sub))
+ {
+ case POINTER_TYPE:
+ /* We don't want "char * &" */
+ if (! (TYPE_READONLY (sub) || TYPE_VOLATILE (sub)))
+ break;
+ /* But we do want "char *const &" */
+
+ default:
+ OB_PUTC (' ');
+ }
+ }
+ OB_PUTC ('&');
+ dump_readonly_or_volatile (t, none);
+ break;
+
+ case OFFSET_TYPE:
+ offset_type:
+ dump_type_prefix (TREE_TYPE (t), v);
+ if (NEXT_CODE (t) != FUNCTION_TYPE && NEXT_CODE (t) != METHOD_TYPE)
+ OB_PUTC (' ');
+ if (TREE_CODE (t) == OFFSET_TYPE)
+ dump_type (TYPE_OFFSET_BASETYPE (t), 0);
+ else /* pointer to member function */
+ dump_type (TYPE_METHOD_BASETYPE (TREE_TYPE (t)), 0);
+ OB_PUTC2 (':', ':');
+ OB_PUTC ('*');
+ dump_readonly_or_volatile (t, none);
+ break;
+
+ /* Can only be reached through function pointer -- this would not be
+ correct if FUNCTION_DECLs used it. */
+ case FUNCTION_TYPE:
+ dump_type_prefix (TREE_TYPE (t), v);
+ OB_PUTC2 (' ', '(');
+ break;
+
+ case METHOD_TYPE:
+ dump_type_prefix (TREE_TYPE (t), v);
+ OB_PUTC2 (' ', '(');
+ dump_aggr_type (TYPE_METHOD_BASETYPE (t), 0);
+ OB_PUTC2 (':', ':');
+ break;
+
+ case ARRAY_TYPE:
+ dump_type_prefix (TREE_TYPE (t), v);
+ break;
+
+ case ENUMERAL_TYPE:
+ case ERROR_MARK:
+ case IDENTIFIER_NODE:
+ case INTEGER_TYPE:
+ case REAL_TYPE:
+ case RECORD_TYPE:
+ case TEMPLATE_TYPE_PARM:
+ case TREE_LIST:
+ case TYPE_DECL:
+ case TREE_VEC:
+ case UNINSTANTIATED_P_TYPE:
+ case UNION_TYPE:
+ case UNKNOWN_TYPE:
+ case VOID_TYPE:
+ dump_type (t, v);
+ break;
+
+ default:
+ my_friendly_abort (65);
+ }
+}
+
+static void
+dump_type_suffix (t, v)
+ tree t;
+ int v; /* verbose? */
+{
+ if (TYPE_PTRMEMFUNC_P (t))
+ t = TYPE_PTRMEMFUNC_FN_TYPE (t);
+
+ switch (TREE_CODE (t))
+ {
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ case OFFSET_TYPE:
+ dump_type_suffix (TREE_TYPE (t), v);
+ break;
+
+ /* Can only be reached through function pointer */
+ case FUNCTION_TYPE:
+ case METHOD_TYPE:
+ {
+ tree arg;
+ OB_PUTC2 (')', '(');
+ arg = TYPE_ARG_TYPES (t);
+ if (TREE_CODE (t) == METHOD_TYPE)
+ arg = TREE_CHAIN (arg);
+
+ if (arg)
+ dump_type (arg, v);
+ else
+ OB_PUTS ("...");
+ OB_PUTC (')');
+ if (TREE_CODE (t) == METHOD_TYPE)
+ dump_readonly_or_volatile
+ (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), before);
+ dump_type_suffix (TREE_TYPE (t), v);
+ break;
+ }
+
+ case ARRAY_TYPE:
+ OB_PUTC ('[');
+ if (TYPE_DOMAIN (t))
+ OB_PUTI (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) + 1);
+ OB_PUTC (']');
+ dump_type_suffix (TREE_TYPE (t), v);
+ break;
+
+ case ENUMERAL_TYPE:
+ case ERROR_MARK:
+ case IDENTIFIER_NODE:
+ case INTEGER_TYPE:
+ case REAL_TYPE:
+ case RECORD_TYPE:
+ case TEMPLATE_TYPE_PARM:
+ case TREE_LIST:
+ case TYPE_DECL:
+ case TREE_VEC:
+ case UNINSTANTIATED_P_TYPE:
+ case UNION_TYPE:
+ case UNKNOWN_TYPE:
+ case VOID_TYPE:
+ break;
+
+ default:
+ my_friendly_abort (67);
+ }
+}
+
+/* Return a function declaration which corresponds to the IDENTIFIER_NODE
+ argument. */
+tree
+ident_fndecl (t)
+ tree t;
+{
+ tree n = IDENTIFIER_GLOBAL_VALUE (t);
+
+ if (TREE_CODE (n) == FUNCTION_DECL)
+ return n;
+ else if (TREE_CODE (n) == TREE_LIST
+ && TREE_CODE (TREE_VALUE (n)) == FUNCTION_DECL)
+ return TREE_VALUE (n);
+ else
+ my_friendly_abort (66);
+}
+
+#ifndef NO_DOLLAR_IN_LABEL
+# define GLOBAL_THING "_GLOBAL_$"
+#else
+# ifndef NO_DOT_IN_LABEL
+# define GLOBAL_THING "_GLOBAL_."
+# else
+# define GLOBAL_THING "_GLOBAL__"
+# endif
+#endif
+
+#define GLOBAL_IORD_P(NODE) \
+ !strncmp(IDENTIFIER_POINTER(NODE),GLOBAL_THING,sizeof(GLOBAL_THING)-1)
+
+void
+dump_global_iord (t)
+ tree t;
+{
+ char *name = IDENTIFIER_POINTER (t);
+
+ OB_PUTS ("(static ");
+ if (name [sizeof (GLOBAL_THING) - 1] == 'I')
+ OB_PUTS ("initializers");
+ else if (name [sizeof (GLOBAL_THING) - 1] == 'D')
+ OB_PUTS ("destructors");
+ else
+ my_friendly_abort (352);
+
+ OB_PUTS (" for ");
+ OB_PUTCP (input_filename);
+ OB_PUTC (')');
+}
+
+static void
+dump_decl (t, v)
+ tree t;
+ int v; /* verbosity */
+{
+ if (t == NULL_TREE)
+ return;
+
+ switch (TREE_CODE (t))
+ {
+ case ERROR_MARK:
+ OB_PUTS (" /* decl error */ ");
+ break;
+
+ case VAR_DECL:
+ if (VTABLE_NAME_P (DECL_NAME (t)))
+ {
+ OB_PUTS ("vtable for ");
+ dump_type (DECL_CONTEXT (t), v);
+ break;
+ }
+ /* else fall through */
+ case FIELD_DECL:
+ case PARM_DECL:
+ if (v > 0)
+ {
+ dump_type_prefix (TREE_TYPE (t), v);
+ OB_PUTC(' ');
+ }
+ /* DECL_CLASS_CONTEXT isn't being set in some cases. Hmm... */
+ if (TREE_CODE (t) == FIELD_DECL
+ || (TREE_CODE (t) == VAR_DECL && DECL_CONTEXT (t)
+ && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't'))
+ {
+ dump_type (DECL_CONTEXT (t), 0);
+ OB_PUTC2(':', ':');
+ }
+ if (DECL_NAME (t))
+ dump_decl (DECL_NAME (t), v);
+ else
+ OB_PUTS ("<anon>");
+ if (v > 0) dump_type_suffix (TREE_TYPE (t), v);
+ break;
+
+ case ARRAY_REF:
+ dump_decl (TREE_OPERAND (t, 0), v);
+ OB_PUTC ('[');
+ dump_decl (TREE_OPERAND (t, 1), v);
+ OB_PUTC (']');
+ break;
+
+ /* So that we can do dump_decl in dump_aggr_type and have it work for
+ both class and function scope. */
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ case ENUMERAL_TYPE:
+ dump_type (t, v);
+ break;
+
+ case TYPE_DECL:
+ dump_type (TREE_TYPE (t), v);
+ break;
+
+ case TYPE_EXPR:
+ my_friendly_abort (69);
+ break;
+
+ /* These special cases are duplicated here so that other functions
+ can feed identifiers to cp_error and get them demangled properly. */
+ case IDENTIFIER_NODE:
+ if (DESTRUCTOR_NAME_P (t))
+ {
+ OB_PUTC ('~');
+ dump_decl (DECL_NAME (ident_fndecl (t)), 0);
+ }
+ else if (IDENTIFIER_TYPENAME_P (t))
+ {
+ OB_PUTS ("operator ");
+ /* Not exactly IDENTIFIER_TYPE_VALUE. */
+ dump_type (TREE_TYPE (t), 0);
+ break;
+ }
+ else if (IDENTIFIER_OPNAME_P (t))
+ {
+ char *name_string = operator_name_string (t);
+ OB_PUTS ("operator ");
+ OB_PUTCP (name_string);
+ }
+ else
+ OB_PUTID (t);
+ break;
+
+ case FUNCTION_DECL:
+ if (GLOBAL_IORD_P (DECL_ASSEMBLER_NAME (t)))
+ dump_global_iord (DECL_ASSEMBLER_NAME (t));
+ else
+ dump_function_decl (t, v);
+ break;
+
+ case TEMPLATE_DECL:
+ switch (NEXT_CODE (t))
+ {
+ case METHOD_TYPE:
+ case FUNCTION_TYPE:
+ dump_function_decl (t, v);
+ break;
+
+ default:
+ my_friendly_abort (353);
+ }
+ break;
+
+ case LABEL_DECL:
+ OB_PUTID (DECL_NAME (t));
+ break;
+
+ case CONST_DECL:
+ if (NEXT_CODE (t) == ENUMERAL_TYPE)
+ {
+ if (DECL_CONTEXT (t))
+ {
+ dump_decl (DECL_CONTEXT (t), 0);
+ OB_PUTC2 (':', ':');
+ }
+ OB_PUTID (DECL_NAME (t));
+ }
+ else
+ dump_expr (DECL_INITIAL (t), 0);
+ break;
+
+ default:
+ my_friendly_abort (70);
+ }
+}
+
+/* Pretty printing for announce_function. T is the declaration of the
+ function we are interested in seeing. V is non-zero if we should print
+ the type that this function returns. */
+
+static void
+dump_function_decl (t, v)
+ tree t;
+ int v;
+{
+ tree name = DECL_ASSEMBLER_NAME (t);
+ tree fntype = TREE_TYPE (t);
+ tree parmtypes = TYPE_ARG_TYPES (fntype);
+ tree cname = NULL_TREE;
+ int spaces = 0;
+
+ /* Friends have DECL_CLASS_CONTEXT set, but not DECL_CONTEXT. */
+ if (DECL_CONTEXT (t))
+ cname = DECL_CLASS_CONTEXT (t);
+ /* this is for partially instantiated template methods */
+ else if (TREE_CODE (fntype) == METHOD_TYPE)
+ cname = TREE_TYPE (TREE_VALUE (parmtypes));
+
+ v = (v > 0);
+
+ if (v)
+ {
+ if (DECL_STATIC_FUNCTION_P (t))
+ OB_PUTS ("static ");
+
+ if (! IDENTIFIER_TYPENAME_P (name)
+ && ! DECL_CONSTRUCTOR_P (t)
+ && ! DESTRUCTOR_NAME_P (name))
+ {
+ dump_type_prefix (TREE_TYPE (fntype), 1);
+ OB_PUTC (' ');
+ }
+ }
+
+ if (cname)
+ {
+ dump_type (cname, 0);
+ OB_PUTC2 (':', ':');
+ if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes)
+ parmtypes = TREE_CHAIN (parmtypes);
+ if (DECL_CONSTRUCTOR_FOR_VBASE_P (t))
+ /* Skip past "in_charge" identifier. */
+ parmtypes = TREE_CHAIN (parmtypes);
+ }
+
+ if (DESTRUCTOR_NAME_P (name))
+ parmtypes = TREE_CHAIN (parmtypes);
+
+ dump_function_name (t);
+
+ OB_PUTC ('(');
+
+ if (parmtypes)
+ dump_type (parmtypes, v);
+ else
+ OB_PUTS ("...");
+
+ OB_PUTC (')');
+
+ if (v && ! IDENTIFIER_TYPENAME_P (name))
+ dump_type_suffix (TREE_TYPE (fntype), 1);
+
+ if (TREE_CODE (fntype) == METHOD_TYPE)
+ {
+ if (IS_SIGNATURE (cname))
+ /* We look at the type pointed to by the `optr' field of `this.' */
+ dump_readonly_or_volatile
+ (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (TYPE_ARG_TYPES (fntype))))), before);
+ else
+ dump_readonly_or_volatile
+ (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))), before);
+ }
+}
+
+/* Handle the function name for a FUNCTION_DECL node, grokking operators
+ and destructors properly. */
+static void
+dump_function_name (t)
+ tree t;
+{
+ tree name = DECL_NAME (t);
+
+ /* There ought to be a better way to find out whether or not something is
+ a destructor. */
+ if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (t)))
+ {
+ OB_PUTC ('~');
+ dump_decl (name, 0);
+ }
+ 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 (t)), 0);
+ }
+ else if (IDENTIFIER_OPNAME_P (name))
+ {
+ char *name_string = operator_name_string (name);
+ OB_PUTS ("operator ");
+ OB_PUTCP (name_string);
+ }
+ else
+ dump_decl (name, 0);
+}
+
+static void
+dump_char (c)
+ char c;
+{
+ switch (c)
+ {
+ case '\n':
+ OB_PUTS ("\\n");
+ break;
+ case '\t':
+ OB_PUTS ("\\t");
+ break;
+ case '\v':
+ OB_PUTS ("\\v");
+ break;
+ case '\b':
+ OB_PUTS ("\\b");
+ break;
+ case '\r':
+ OB_PUTS ("\\r");
+ break;
+ case '\f':
+ OB_PUTS ("\\f");
+ break;
+ case '\a':
+ OB_PUTS ("\\a");
+ break;
+ case '\\':
+ OB_PUTS ("\\\\");
+ break;
+ case '\'':
+ OB_PUTS ("\\'");
+ break;
+ case '\"':
+ OB_PUTS ("\\\"");
+ break;
+ default:
+ if (isprint (c))
+ OB_PUTC (c);
+ else
+ {
+ sprintf (digit_buffer, "\\%03o", (int) c);
+ OB_PUTCP (digit_buffer);
+ }
+ }
+}
+
+/* Print out a list of initializers (subr of dump_expr) */
+static void
+dump_expr_list (l)
+ tree l;
+{
+ while (l)
+ {
+ dump_expr (TREE_VALUE (l), 0);
+ if (TREE_CHAIN (l))
+ OB_PUTC2 (',', ' ');
+ l = TREE_CHAIN (l);
+ }
+}
+
+/* Print out an expression */
+static void
+dump_expr (t, nop)
+ tree t;
+ int nop; /* suppress parens */
+{
+ switch (TREE_CODE (t))
+ {
+ case VAR_DECL:
+ case PARM_DECL:
+ case FIELD_DECL:
+ case CONST_DECL:
+ case FUNCTION_DECL:
+ dump_decl (t, -1);
+ break;
+
+ case INTEGER_CST:
+ {
+ tree type = TREE_TYPE (t);
+ my_friendly_assert (type != 0, 81);
+
+ /* If it's an enum, output its tag, rather than its value. */
+ if (TREE_CODE (type) == ENUMERAL_TYPE)
+ {
+ char *p = enum_name_string (t, type);
+ OB_PUTCP (p);
+ }
+ else if (type == char_type_node
+ || type == signed_char_type_node
+ || type == unsigned_char_type_node)
+ {
+ OB_PUTC ('\'');
+ dump_char (TREE_INT_CST_LOW (t));
+ OB_PUTC ('\'');
+ }
+ else if (TREE_INT_CST_HIGH (t)
+ != (TREE_INT_CST_LOW (t) >> (HOST_BITS_PER_WIDE_INT - 1)))
+ {
+ tree val = t;
+ if (TREE_INT_CST_HIGH (val) < 0)
+ {
+ OB_PUTC ('-');
+ 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 (digit_buffer, format, TREE_INT_CST_HIGH (val),
+ TREE_INT_CST_LOW (val));
+ OB_PUTCP (digit_buffer);
+ }
+ }
+ else
+ OB_PUTI (TREE_INT_CST_LOW (t));
+ }
+ break;
+
+ case REAL_CST:
+#ifndef REAL_IS_NOT_DOUBLE
+ sprintf (digit_buffer, "%g", TREE_REAL_CST (t));
+#else
+ {
+ unsigned char *p = (unsigned char *) &TREE_REAL_CST (t);
+ int i;
+ strcpy (digit_buffer, "0x");
+ for (i = 0; i < sizeof TREE_REAL_CST (t); i++)
+ sprintf (digit_buffer + 2 + 2*i, "%02x", *p++);
+ }
+#endif
+ 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++)
+ dump_char (p[i]);
+ OB_PUTC ('\"');
+ }
+ break;
+
+ case COMPOUND_EXPR:
+ dump_binary_op (",", t);
+ break;
+
+ case COND_EXPR:
+ OB_PUTC ('(');
+ dump_expr (TREE_OPERAND (t, 0), 0);
+ OB_PUTS (" ? ");
+ dump_expr (TREE_OPERAND (t, 1), 0);
+ OB_PUTS (" : ");
+ dump_expr (TREE_OPERAND (t, 2), 0);
+ OB_PUTC (')');
+ break;
+
+ case SAVE_EXPR:
+ if (TREE_HAS_CONSTRUCTOR (t))
+ {
+ OB_PUTS ("new ");
+ dump_type (TREE_TYPE (TREE_TYPE (t)), 0);
+ PARM_DECL_EXPR (t) = 1;
+ }
+ else
+ {
+ sorry ("operand of SAVE_EXPR not understood");
+ goto error;
+ }
+ break;
+
+ case NEW_EXPR:
+ OB_PUTID (TYPE_IDENTIFIER (TREE_TYPE (t)));
+ OB_PUTC ('(');
+ dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
+ OB_PUTC (')');
+ break;
+
+ case CALL_EXPR:
+ {
+ tree fn = TREE_OPERAND (t, 0);
+ tree args = TREE_OPERAND (t, 1);
+
+ if (TREE_CODE (fn) == ADDR_EXPR)
+ fn = TREE_OPERAND (fn, 0);
+
+ if (NEXT_CODE (fn) == METHOD_TYPE)
+ {
+ tree ob = TREE_VALUE (args);
+ if (TREE_CODE (ob) == ADDR_EXPR)
+ {
+ dump_expr (TREE_OPERAND (ob, 0), 0);
+ OB_PUTC ('.');
+ }
+ else if (TREE_CODE (ob) != PARM_DECL
+ || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
+ {
+ dump_expr (ob, 0);
+ OB_PUTC2 ('-', '>');
+ }
+ args = TREE_CHAIN (args);
+ }
+ dump_expr (fn, 0);
+ OB_PUTC('(');
+ dump_expr_list (args);
+ OB_PUTC (')');
+ }
+ break;
+
+ 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_expr (TREE_OPERAND (t, 0), 0);
+ break;
+
+ 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_expr (TREE_OPERAND (t, 1), 0);
+ break;
+
+ 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);
+ break;
+
+ case CEIL_DIV_EXPR:
+ case FLOOR_DIV_EXPR:
+ case ROUND_DIV_EXPR:
+ dump_binary_op ("/", t);
+ break;
+
+ case CEIL_MOD_EXPR:
+ case FLOOR_MOD_EXPR:
+ case ROUND_MOD_EXPR:
+ dump_binary_op ("%", t);
+ break;
+
+ case COMPONENT_REF:
+ {
+ tree ob = TREE_OPERAND (t, 0);
+ if (TREE_CODE (ob) == INDIRECT_REF)
+ {
+ ob = TREE_OPERAND (ob, 0);
+ if (TREE_CODE (ob) != PARM_DECL
+ || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
+ {
+ dump_expr (ob, 0);
+ OB_PUTC2 ('-', '>');
+ }
+ }
+ else
+ {
+ dump_expr (ob, 0);
+ OB_PUTC ('.');
+ }
+ dump_expr (TREE_OPERAND (t, 1), 1);
+ }
+ break;
+
+ case CONVERT_EXPR:
+ dump_unary_op ("+", t, nop);
+ break;
+
+ case ADDR_EXPR:
+ if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
+ || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
+ dump_expr (TREE_OPERAND (t, 0), 0);
+ else
+ dump_unary_op ("&", t, nop);
+ break;
+
+ case INDIRECT_REF:
+ if (TREE_HAS_CONSTRUCTOR (t))
+ {
+ t = TREE_OPERAND (t, 0);
+ my_friendly_assert (TREE_CODE (t) == CALL_EXPR, 237);
+ dump_expr (TREE_OPERAND (t, 0), 0);
+ OB_PUTC ('(');
+ dump_expr_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
+ OB_PUTC (')');
+ }
+ else
+ {
+ if (NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
+ dump_expr (TREE_OPERAND (t, 0), nop);
+ else
+ dump_unary_op ("*", t, nop);
+ }
+ break;
+
+ 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, nop);
+ break;
+
+ case POSTDECREMENT_EXPR:
+ case POSTINCREMENT_EXPR:
+ OB_PUTC ('(');
+ dump_expr (TREE_OPERAND (t, 0), 0);
+ OB_PUTCP (opname_tab[(int)TREE_CODE (t)]);
+ OB_PUTC (')');
+ break;
+
+ case NON_LVALUE_EXPR:
+ /* FIXME: This is a KLUDGE workaround for a parsing problem. There
+ should be another level of INDIRECT_REF so that I don't have to do
+ this. */
+ if (NEXT_CODE (t) == POINTER_TYPE)
+ {
+ tree next = TREE_TYPE (TREE_TYPE (t));
+
+ while (TREE_CODE (next) == POINTER_TYPE)
+ next = TREE_TYPE (next);
+
+ if (TREE_CODE (next) == FUNCTION_TYPE)
+ {
+ if (!nop) OB_PUTC ('(');
+ OB_PUTC ('*');
+ dump_expr (TREE_OPERAND (t, 0), 1);
+ if (!nop) OB_PUTC (')');
+ break;
+ }
+ /* else FALLTHRU */
+ }
+ dump_expr (TREE_OPERAND (t, 0), 0);
+ break;
+
+ case NOP_EXPR:
+ dump_expr (TREE_OPERAND (t, 0), nop);
+ break;
+
+ case CONSTRUCTOR:
+ OB_PUTC ('{');
+ dump_expr_list (CONSTRUCTOR_ELTS (t), 0);
+ OB_PUTC ('}');
+ break;
+
+ /* 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 by dump_expr",
+ tree_code_name[(int) TREE_CODE (t)]);
+
+ /* fall through to ERROR_MARK... */
+ case ERROR_MARK:
+ error:
+ OB_PUTCP ("/* error */");
+ break;
+ }
+}
+
+static void
+dump_binary_op (opstring, t)
+ char *opstring;
+ tree t;
+{
+ OB_PUTC ('(');
+ dump_expr (TREE_OPERAND (t, 0), 1);
+ OB_PUTC (' ');
+ OB_PUTCP (opstring);
+ OB_PUTC (' ');
+ dump_expr (TREE_OPERAND (t, 1), 1);
+ OB_PUTC (')');
+}
+
+static void
+dump_unary_op (opstring, t, nop)
+ char *opstring;
+ tree t;
+ int nop;
+{
+ if (!nop) OB_PUTC ('(');
+ OB_PUTCP (opstring);
+ dump_expr (TREE_OPERAND (t, 0), 1);
+ if (!nop) OB_PUTC (')');
+}
+
+char *
+fndecl_as_string (cname, fndecl, print_ret_type_p)
+ tree cname, fndecl;
+ int print_ret_type_p;
+{
+ return decl_as_string (fndecl, print_ret_type_p);
+}
+
+/* Same, but handtype a _TYPE.
+ Called from convert_to_reference, mangle_class_name_for_template,
+ build_unary_op, and GNU_xref_decl. */
+char *
+type_as_string (typ, v)
+ tree typ;
+ int v;
+{
+ OB_INIT ();
+
+ dump_type (typ, v);
+
+ OB_FINISH ();
+
+ return (char *)obstack_base (&scratch_obstack);
+}
+
+char *
+expr_as_string (decl, v)
+ tree decl;
+ int v;
+{
+ OB_INIT ();
+
+ dump_expr (decl, 1);
+
+ OB_FINISH ();
+
+ return (char *)obstack_base (&scratch_obstack);
+}
+
+/* A cross between type_as_string and fndecl_as_string.
+ Only called from substitute_nice_name. */
+char *
+decl_as_string (decl, v)
+ tree decl;
+ int v;
+{
+ OB_INIT ();
+
+ dump_decl (decl, v);
+
+ OB_FINISH ();
+
+ return (char *)obstack_base (&scratch_obstack);
+}
+
+char *
+cp_file_of (t)
+ tree t;
+{
+ if (TREE_CODE (t) == PARM_DECL)
+ return DECL_SOURCE_FILE (DECL_CONTEXT (t));
+ else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
+ return DECL_SOURCE_FILE (TYPE_NAME (t));
+ else
+ return DECL_SOURCE_FILE (t);
+}
+
+int
+cp_line_of (t)
+ tree t;
+{
+ if (TREE_CODE (t) == PARM_DECL)
+ return DECL_SOURCE_LINE (DECL_CONTEXT (t));
+ else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
+ return DECL_SOURCE_LINE (TYPE_NAME (t));
+ else
+ return DECL_SOURCE_LINE (t);
+}
+
+char *
+code_as_string (c, v)
+ enum tree_code c;
+ int v;
+{
+ return tree_code_name [c];
+}
+
+char *
+language_as_string (c, v)
+ enum languages c;
+{
+ switch (c)
+ {
+ case lang_c:
+ return "C";
+
+ case lang_cplusplus:
+ return "C++";
+
+ default:
+ my_friendly_abort (355);
+ }
+}
+
+/* Return the proper printed version of a parameter to a C++ function. */
+char *
+parm_as_string (p, v)
+ int p;
+{
+ if (p < 0)
+ return "`this'";
+
+ sprintf (digit_buffer, "%d", p+1);
+ return digit_buffer;
+}
+
+char *
+op_as_string (p, v)
+ enum tree_code p;
+{
+ static char buf[] = "operator ";
+
+ if (p == 0)
+ return "<unknown>";
+
+ strcpy (buf + 9, opname_tab [p]);
+ return buf;
+}
+
+char *
+args_as_string (p, v)
+ tree p;
+ int v;
+{
+ if (p == NULL_TREE)
+ return "...";
+
+ return type_as_string (p, v);
+}
--- /dev/null
+/* 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. */
+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))
+ cp_error ("exception name `%T' must follow body declaration", e);
+ if (list_of_fieldlists)
+ {
+ tree prev, field;
+
+ /* Note: no public, private, or protected allowed. */
+ if (TREE_CHAIN (list_of_fieldlists))
+ error ("access declarations invalid in exception declaration");
+ else if (TREE_PURPOSE (list_of_fieldlists) != (tree)access_default)
+ error ("access declarations invalid in exception declaration");
+ TREE_PURPOSE (list_of_fieldlists) = (tree)access_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:
+ cp_error ("declaration of function `%D' in exception invalid",
+ field);
+ break;
+ case VAR_DECL:
+ if (TREE_STATIC (field))
+ cp_error ("declaration of static variable `%D' in exception invalid", field);
+ else
+ cp_error ("declaration of constant field `%D' in exception invalid", field);
+ break;
+ case CONST_DECL:
+ cp_error ("declaration of enum value `%D' in exception invalid", field);
+ 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, 0);
+
+ /* 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
+ || TREE_CODE (TREE_TYPE (fields)) == ENUMERAL_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;
+}
+\f
+/* 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)
+ {
+ cp_error ("exception `%D' raised but not declared raisable",
+ TREE_VALUE (raised));
+ 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)
+ cp_error ("invalid raise of `%D' outside of functions", decl);
+ else
+ cp_error ("invalid reraise of `%D' outside of functions", decl);
+ }
+ 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 ();
+}
+\f
+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, 0);
+ 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);
+ }
+}
--- /dev/null
+/* 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);
+ tree call_exp;
+ rtx call_target, return_target;
+ int pcc_struct_return = 0;
+
+ /* 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
+ {
+#ifdef PCC_STATIC_STRUCT_RETURN
+ pcc_struct_return = 1;
+ call_target = 0;
+#else
+ call_target = target;
+#endif
+ }
+ if (call_target)
+ {
+ preserve_temp_slots (call_target);
+
+ /* Make this a valid memory address now. The code below assumes
+ that it can compare rtx and make assumptions based on the
+ result. The assumptions are true only if the address was
+ valid to begin with. */
+ call_target = validize_mem (call_target);
+ }
+
+ preserve_temp_slots (DECL_RTL (slot));
+ call_exp = build (CALL_EXPR, type, func, args, 0);
+ TREE_SIDE_EFFECTS (call_exp) = 1;
+ return_target = expand_expr (call_exp, call_target, mode, 0);
+ free_temp_slots ();
+ if (call_target == 0)
+ {
+ if (pcc_struct_return)
+ {
+ tree init = build (RTL_EXPR, type, 0, return_target);
+ TREE_ADDRESSABLE (init) = 1;
+ expand_aggr_init (slot, init, 0);
+ if (TYPE_NEEDS_DESTRUCTOR (type))
+ {
+ init = build (RTL_EXPR, build_reference_type (type), 0,
+ XEXP (return_target, 0));
+ init = maybe_build_cleanup (convert_from_reference (init));
+ if (init != NULL_TREE)
+ expand_expr (init, 0, 0, 0);
+ }
+ call_target = return_target = DECL_RTL (slot);
+ }
+ else
+ call_target = return_target;
+ }
+
+ if (call_target != return_target)
+ {
+ my_friendly_assert (! TYPE_NEEDS_CONSTRUCTING (type), 317);
+ 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:
+ {
+#if 1
+ return expand_expr (default_conversion (resolve_offset_ref (exp)),
+ target, tmode, EXPAND_NORMAL);
+#else
+ /* This is old crusty code, and does not handle all that the
+ resolve_offset_ref function does. (mrs) */
+ 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);
+#endif
+ }
+
+ 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;
+}
--- /dev/null
+%{
+/* 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;};
+%%
+__alignof, ALIGNOF, NORID
+__alignof__, ALIGNOF, NORID
+__asm, GCC_ASM_KEYWORD, NORID
+__asm__, GCC_ASM_KEYWORD, NORID
+__attribute, ATTRIBUTE, NORID
+__attribute__, ATTRIBUTE, NORID
+__classof, CLASSOF, NORID
+__classof__, CLASSOF, NORID
+__const, TYPE_QUAL, RID_CONST
+__const__, TYPE_QUAL, RID_CONST
+__extension__, EXTENSION, NORID
+__headof, HEADOF, NORID
+__headof__, HEADOF, NORID
+__inline, SCSPEC, RID_INLINE
+__inline__, SCSPEC, RID_INLINE
+__label__, LABEL, NORID
+__signed, TYPESPEC, RID_SIGNED
+__signed__, TYPESPEC, RID_SIGNED
+__typeof, TYPEOF, NORID
+__typeof__, TYPEOF, NORID
+__volatile, TYPE_QUAL, RID_VOLATILE
+__volatile__, TYPE_QUAL, RID_VOLATILE
+__wchar_t, TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,
+all, ALL, NORID /* Extension */,
+except, EXCEPT, NORID /* Extension */,
+exception, AGGR, RID_EXCEPTION /* Extension */,
+raise, RAISE, NORID /* Extension */,
+raises, RAISES, NORID /* Extension */,
+reraise, RERAISE, NORID /* Extension */,
+throw, THROW, NORID /* Extension */,
+try, TRY, NORID /* Extension */,
+asm, ASM_KEYWORD, NORID,
+auto, SCSPEC, RID_AUTO,
+break, BREAK, NORID,
+case, CASE, NORID,
+catch, CATCH, NORID,
+char, TYPESPEC, RID_CHAR,
+class, AGGR, RID_CLASS,
+classof, CLASSOF, NORID,
+const, TYPE_QUAL, RID_CONST,
+continue, CONTINUE, NORID,
+default, DEFAULT, NORID,
+delete, DELETE, NORID,
+do, DO, NORID,
+double, TYPESPEC, RID_DOUBLE,
+dynamic_cast, DYNAMIC_CAST, NORID,
+else, ELSE, NORID,
+enum, ENUM, NORID,
+extern, SCSPEC, RID_EXTERN,
+float, TYPESPEC, RID_FLOAT,
+for, FOR, NORID,
+friend, SCSPEC, RID_FRIEND,
+goto, GOTO, NORID,
+headof, HEADOF, NORID,
+if, IF, NORID,
+inline, SCSPEC, RID_INLINE,
+int, TYPESPEC, RID_INT,
+long, TYPESPEC, RID_LONG,
+mutable, SCSPEC, RID_MUTABLE,
+new, NEW, NORID,
+operator, OPERATOR, NORID,
+overload, OVERLOAD, NORID,
+private, VISSPEC, RID_PRIVATE,
+protected, VISSPEC, RID_PROTECTED,
+public, VISSPEC, RID_PUBLIC,
+register, SCSPEC, RID_REGISTER,
+return, RETURN, NORID,
+short, TYPESPEC, RID_SHORT,
+signature, AGGR, RID_SIGNATURE /* Extension */,
+signed, TYPESPEC, RID_SIGNED,
+sigof, SIGOF, NORID /* Extension */,
+sizeof, SIZEOF, NORID,
+static, SCSPEC, RID_STATIC,
+struct, AGGR, RID_RECORD,
+switch, SWITCH, NORID,
+this, THIS, NORID,
+template, TEMPLATE, NORID,
+typedef, SCSPEC, RID_TYPEDEF,
+typeof, TYPEOF, NORID,
+typeid, TYPEID, NORID,
+union, AGGR, RID_UNION,
+unsigned, TYPESPEC, RID_UNSIGNED,
+virtual, SCSPEC, RID_VIRTUAL,
+void, TYPESPEC, RID_VOID,
+volatile, TYPE_QUAL, RID_VOLATILE,
+while, WHILE, NORID,
--- /dev/null
+\input texinfo @c -*-texinfo-*-
+@c %**start of header
+@setfilename g++int.info
+@settitle G++ internals
+@setchapternewpage odd
+@c %**end of header
+
+@node Top, Limitations of g++, (dir), (dir)
+@chapter Internal Architecture of the Compiler
+
+This is meant to describe the C++ frontend for gcc in detail.
+Questions and comments to mrs@@cygnus.com.
+
+@menu
+* Limitations of g++::
+* Routines::
+* Implementation Specifics::
+* Glossary::
+* Macros::
+* Typical Behavior::
+* Coding Conventions::
+* Templates::
+* Access Control::
+* Error Reporting::
+* Concept Index::
+@end menu
+
+@node Limitations of g++, Routines, Top, Top
+@section Limitations of g++
+
+@itemize @bullet
+@item
+Limitations on input source code: 240 nesting levels with the parser
+stacksize (YYSTACKSIZE) set to 500 (the default), and requires around
+16.4k swap space per nesting level. The parser needs about 2.09 *
+number of nesting levels worth of stackspace.
+
+@cindex pushdecl_class_level
+@item
+I suspect there are other uses of pushdecl_class_level that do not call
+set_identifier_type_value in tandem with the call to
+pushdecl_class_level. It would seem to be an omission.
+
+@cindex delete, two argument
+@item
+For two argument delete, the second argument is always calculated by
+``virtual_size ='' in the source. It currently has a problem, in that
+object size is not calculated by the virtual destructor and passed back
+for the second parameter to delete. Destructors need to return a value
+just like constructors. ANSI C++ Jun 5 92 wp 12.5.6
+
+The second argument is magically deleted in build_method_call, if it is
+not used. It needs to be deleted for global operator delete also.
+
+@cindex access checking
+@item
+Access checking in general is unimplemented, there are a few cases
+where it is implemented. grok_enum_decls should be used in more places
+to do access checking, but this is only the tip of a bigger problem.
+
+@cindex @code{volatile}
+@item
+@code{volatile} is not implemented in general.
+
+@cindex pointers to members
+@item
+Pointers to members are only minimally supported, and there are places
+where the grammar doesn't even properly accept them yet.
+
+@cindex multiple inheritance
+@item
+@code{this} will be wrong in virtual members functions defined in a
+virtual base class, when they are overridden in a derived class, when
+called via a non-left most object.
+
+An example would be:
+
+@example
+extern "C" int printf(const char*, ...);
+struct A { virtual void f() { } };
+struct B : virtual A { int b; B() : b(0) {} void f() { b++; } };
+struct C : B {};
+struct D : B {};
+struct E : C, D {};
+int main()
+{
+ E e;
+ C& c = e; D& d = e;
+ c.f(); d.f();
+ printf ("C::b = %d, D::b = %d\n", e.C::b, e.D::b);
+ return 0;
+}
+@end example
+
+This will print out 2, 0, instead of 1,1.
+
+@end itemize
+
+@node Routines, Implementation Specifics, Limitations of g++, Top
+@section Routines
+
+This section describes some of the routines used in the C++ front-end.
+
+@code{build_vtable} and @code{prepare_fresh_vtable} is used only within
+the @file{cp-class.c} file, and only in @code{finish_struct} and
+@code{modify_vtable_entries}.
+
+@code{build_vtable}, @code{prepare_fresh_vtable}, and
+@code{finish_struct} are the only routines that set @code{DECL_VPARENT}.
+
+@code{finish_struct} can steal the virtual function table from parents,
+this prohibits related_vslot from working. When finish_struct steals,
+we know that
+
+@example
+get_binfo (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (t)), t, 0)
+@end example
+
+@noindent
+will get the related binfo.
+
+@code{layout_basetypes} does something with the VIRTUALS.
+
+Supposedly (according to Tiemann) most of the breadth first searching
+done, like in @code{get_base_distance} and in @code{get_binfo} was not
+because of any design decision. I have since found out the at least one
+part of the compiler needs the notion of depth first binfo searching, I
+am going to try and convert the whole thing, it should just work. The
+term left-most refers to the depth first left-most node. It uses
+@code{MAIN_VARIANT == type} as the condition to get left-most, because
+the things that have @code{BINFO_OFFSET}s of zero are shared and will
+have themselves as their own @code{MAIN_VARIANT}s. The non-shared right
+ones, are copies of the left-most one, hence if it is its own
+@code{MAIN_VARIENT}, we know it IS a left-most one, if it is not, it is
+a non-left-most one.
+
+@code{get_base_distance}'s path and distance matters in its use in:
+
+@itemize @bullet
+@item
+@code{prepare_fresh_vtable} (the code is probably wrong)
+@item
+@code{init_vfields} Depends upon distance probably in a safe way,
+build_offset_ref might use partial paths to do further lookups,
+hack_identifier is probably not properly checking access.
+
+@item
+@code{get_first_matching_virtual} probably should check for
+@code{get_base_distance} returning -2.
+
+@item
+@code{resolve_offset_ref} should be called in a more deterministic
+manner. Right now, it is called in some random contexts, like for
+arguments at @code{build_method_call} time, @code{default_conversion}
+time, @code{convert_arguments} time, @code{build_unary_op} time,
+@code{build_c_cast} time, @code{build_modify_expr} time,
+@code{convert_for_assignment} time, and
+@code{convert_for_initialization} time.
+
+But, there are still more contexts it needs to be called in, one was the
+ever simple:
+
+@example
+if (obj.*pmi != 7)
+ @dots{}
+@end example
+
+Seems that the problems were due to the fact that @code{TREE_TYPE} of
+the @code{OFFSET_REF} was not a @code{OFFSET_TYPE}, but rather the type
+of the referent (like @code{INTEGER_TYPE}). This problem was fixed by
+changing @code{default_conversion} to check @code{TREE_CODE (x)},
+instead of only checking @code{TREE_CODE (TREE_TYPE (x))} to see if it
+was @code{OFFSET_TYPE}.
+
+@end itemize
+
+@node Implementation Specifics, Glossary, Routines, Top
+@section Implementation Specifics
+
+@itemize @bullet
+@item Explicit Initialization
+
+The global list @code{current_member_init_list} contains the list of
+mem-initializers specified in a constructor declaration. For example:
+
+@example
+foo::foo() : a(1), b(2) @{@}
+@end example
+
+@noindent
+will initialize @samp{a} with 1 and @samp{b} with 2.
+@code{expand_member_init} places each initialization (a with 1) on the
+global list. Then, when the fndecl is being processed,
+@code{emit_base_init} runs down the list, initializing them. It used to
+be the case that g++ first ran down @code{current_member_init_list},
+then ran down the list of members initializing the ones that weren't
+explicitly initialized. Things were rewritten to perform the
+initializations in order of declaration in the class. So, for the above
+example, @samp{a} and @samp{b} will be initialized in the order that
+they were declared:
+
+@example
+class foo @{ public: int b; int a; foo (); @};
+@end example
+
+@noindent
+Thus, @samp{b} will be initialized with 2 first, then @samp{a} will be
+initialized with 1, regardless of how they're listed in the mem-initializer.
+
+@item Argument Matching
+
+In early 1993, the argument matching scheme in @sc{gnu} C++ changed
+significantly. The original code was completely replaced with a new
+method that will, hopefully, be easier to understand and make fixing
+specific cases much easier.
+
+The @samp{-fansi-overloading} option is used to enable the new code; at
+some point in the future, it will become the default behavior of the
+compiler.
+
+The file @file{cp-call.c} contains all of the new work, in the functions
+@code{rank_for_overload}, @code{compute_harshness},
+@code{compute_conversion_costs}, and @code{ideal_candidate}.
+
+Instead of using obscure numerical values, the quality of an argument
+match is now represented by clear, individual codes. The new data
+structure @code{struct harshness} (it used to be an @code{unsigned}
+number) contains:
+
+@enumerate a
+@item the @samp{code} field, to signify what was involved in matching two
+arguments;
+@item the @samp{distance} field, used in situations where inheritance
+decides which function should be called (one is ``closer'' than
+another);
+@item and the @samp{int_penalty} field, used by some codes as a tie-breaker.
+@end enumerate
+
+The @samp{code} field is a number with a given bit set for each type of
+code, OR'd together. The new codes are:
+
+@itemize @bullet
+@item @code{EVIL_CODE}
+The argument was not a permissible match.
+
+@item @code{CONST_CODE}
+Currently, this is only used by @code{compute_conversion_costs}, to
+distinguish when a non-@code{const} member function is called from a
+@code{const} member function.
+
+@item @code{ELLIPSIS_CODE}
+A match against an ellipsis @samp{...} is considered worse than all others.
+
+@item @code{USER_CODE}
+Used for a match involving a user-defined conversion.
+
+@item @code{STD_CODE}
+A match involving a standard conversion.
+
+@item @code{PROMO_CODE}
+A match involving an integral promotion. For these, the
+@code{int_penalty} field is used to handle the ARM's rule (XXX cite)
+that a smaller @code{unsigned} type should promote to a @code{int}, not
+to an @code{unsigned int}.
+
+@item @code{QUAL_CODE}
+Used to mark use of qualifiers like @code{const} and @code{volatile}.
+
+@item @code{TRIVIAL_CODE}
+Used for trivial conversions. The @samp{int_penalty} field is used by
+@code{convert_harshness} to communicate further penalty information back
+to @code{build_overload_call_real} when deciding which function should
+be call.
+@end itemize
+
+The functions @code{convert_to_aggr} and @code{build_method_call} use
+@code{compute_conversion_costs} to rate each argument's suitability for
+a given candidate function (that's how we get the list of candidates for
+@code{ideal_candidate}).
+
+@end itemize
+
+@node Glossary, Macros, Implementation Specifics, Top
+@section Glossary
+
+@table @r
+@item binfo
+The main data structure in the compiler used to represent the
+inheritance relationships between classes. The data in the binfo can be
+accessed by the BINFO_ accessor macros.
+
+@item vtable
+@itemx virtual function table
+
+The virtual function table holds information used in virtual function
+dispatching. In the compiler, they are usually referred to as vtables,
+or vtbls. The first index is not used in the normal way, I believe it
+is probably used for the virtual destructor.
+
+@item vfield
+
+vfields can be thought of as the base information needed to build
+vtables. For every vtable that exists for a class, there is a vfield.
+See also vtable and virtual function table pointer. When a type is used
+as a base class to another type, the virtual function table for the
+derived class can be based upon the vtable for the base class, just
+extended to include the additional virtual methods declared in the
+derived class. The virtual function table from a virtual base class is
+never reused in a derived class. @code{is_normal} depends upon this.
+
+@item virtual function table pointer
+
+These are @code{FIELD_DECL}s that are pointer types that point to
+vtables. See also vtable and vfield.
+@end table
+
+@node Macros, Typical Behavior, Glossary, Top
+@section Macros
+
+This section describes some of the macros used on trees. The list
+should be alphabetical. Eventually all macros should be documented
+here. There are some postscript drawings that can be used to better
+understnad from of the more complex data structures, contact Mike Stump
+(@code{mrs@@cygnus.com}) for information about them.
+
+@table @code
+@item BINFO_BASETYPES
+A vector of additional binfos for the types inherited by this basetype.
+The binfos are fully unshared (except for virtual bases, in which
+case the binfo structure is shared).
+
+ If this basetype describes type D as inherited in C,
+ and if the basetypes of D are E anf F,
+ then this vector contains binfos for inheritance of E and F by C.
+
+Has values of:
+
+ TREE_VECs
+
+
+@item BINFO_INHERITANCE_CHAIN
+Temporarily used to represent specific inheritances. It usually points
+to the binfo associated with the lesser derived type, but it can be
+reversed by reverse_path. For example:
+
+@example
+ Z ZbY least derived
+ |
+ Y YbX
+ |
+ X Xb most derived
+
+TYPE_BINFO (X) == Xb
+BINFO_INHERITANCE_CHAIN (Xb) == YbX
+BINFO_INHERITANCE_CHAIN (Yb) == ZbY
+BINFO_INHERITANCE_CHAIN (Zb) == 0
+@end example
+
+Not sure is the above is really true, get_base_distance has is point
+towards the most derived type, opposite from above.
+
+Set by build_vbase_path, recursive_bounded_basetype_p,
+get_base_distance, lookup_field, lookup_fnfields, and reverse_path.
+
+What things can this be used on:
+
+ TREE_VECs that are binfos
+
+
+@item BINFO_OFFSET
+The offset where this basetype appears in its containing type.
+BINFO_OFFSET slot holds the offset (in bytes) from the base of the
+complete object to the base of the part of the object that is allocated
+on behalf of this `type'. This is always 0 except when there is
+multiple inheritance.
+
+Used on TREE_VEC_ELTs of the binfos BINFO_BASETYPES (...) for example.
+
+
+@item BINFO_VIRTUALS
+A unique list of functions for the virtual function table. See also
+TYPE_BINFO_VIRTUALS.
+
+What things can this be used on:
+
+ TREE_VECs that are binfos
+
+
+@item BINFO_VTABLE
+Used to find the VAR_DECL that is the virtual function table associated
+with this binfo. See also TYPE_BINFO_VTABLE. To get the virtual
+function table pointer, see CLASSTYPE_VFIELD.
+
+What things can this be used on:
+
+ TREE_VECs that are binfos
+
+Has values of:
+
+ VAR_DECLs that are virtual function tables
+
+
+@item BLOCK_SUPERCONTEXT
+In the outermost scope of each function, it points to the FUNCTION_DECL
+node. It aids in better DWARF support of inline functions.
+
+
+@item CLASSTYPE_TAGS
+CLASSTYPE_TAGS is a linked (via TREE_CHAIN) list of member classes of a
+class. TREE_PURPOSE is the name, TREE_VALUE is the type (pushclass scans
+these and calls pushtag on them.)
+
+finish_struct scans these to produce TYPE_DECLs to add to the
+TYPE_FIELDS of the type.
+
+It is expected that name found in the TREE_PURPOSE slot is unique,
+resolve_scope_to_name is one such place that depends upon this
+uniqueness.
+
+
+@item CLASSTYPE_METHOD_VEC
+The following is true after finish_struct has been called (on the
+class?) but not before. Before finish_struct is called, things are
+different to some extent. Contains a TREE_VEC of methods of the class.
+The TREE_VEC_LENGTH is the number of differently named methods plus one
+for the 0th entry. The 0th entry is always allocated, and reserved for
+ctors and dtors. If there are none, TREE_VEC_ELT(N,0) == NULL_TREE.
+Each entry of the TREE_VEC is a FUNCTION_DECL. For each FUNCTION_DECL,
+there is a DECL_CHAIN slot. If the FUNCTION_DECL is the last one with a
+given name, the DECL_CHAIN slot is NULL_TREE. Otherwise it is the next
+method that has the same name (but a different signature). It would
+seem that it is not true that because the DECL_CHAIN slot is used in
+this way, we cannot call pushdecl to put the method in the global scope
+(cause that would overwrite the TREE_CHAIN slot), because they use
+different _CHAINs. finish_struct_methods setups up one version of the
+TREE_CHAIN slots on the FUNCTION_DECLs.
+
+friends are kept in TREE_LISTs, so that there's no need to use their
+TREE_CHAIN slot for anything.
+
+Has values of:
+
+ TREE_VECs
+
+
+@item CLASSTYPE_VFIELD
+Seems to be in the process of being renamed TYPE_VFIELD. Use on types
+to get the main virtual function table pointer. To get the virtual
+function table use BINFO_VTABLE (TYPE_BINFO ()).
+
+Has values of:
+
+ FIELD_DECLs that are virtual function table pointers
+
+What things can this be used on:
+
+ RECORD_TYPEs
+
+
+@item DECL_CLASS_CONTEXT
+Identifies the context that the _DECL was found in. For virtual function
+tables, it points to the type associated with the virtual function
+table. See also DECL_CONTEXT, DECL_FIELD_CONTEXT and DECL_FCONTEXT.
+
+The difference between this and DECL_CONTEXT, is that for virtuals
+functions like:
+
+@example
+struct A
+@{
+ virtual int f ();
+@};
+
+struct B : A
+@{
+ int f ();
+@};
+
+DECL_CONTEXT (A::f) == A
+DECL_CLASS_CONTEXT (A::f) == A
+
+DECL_CONTEXT (B::f) == A
+DECL_CLASS_CONTEXT (B::f) == B
+@end example
+
+Has values of:
+
+ RECORD_TYPEs, or UNION_TYPEs
+
+What things can this be used on:
+
+ TYPE_DECLs, _DECLs
+
+
+@item DECL_CONTEXT
+Identifies the context that the _DECL was found in. Can be used on
+virtual function tables to find the type associated with the virtual
+function table, but since they are FIELD_DECLs, DECL_FIELD_CONTEXT is a
+better access method. Internally the same as DECL_FIELD_CONTEXT, so
+don't us both. See also DECL_FIELD_CONTEXT, DECL_FCONTEXT and
+DECL_CLASS_CONTEXT.
+
+Has values of:
+
+ RECORD_TYPEs
+
+
+What things can this be used on:
+
+@display
+VAR_DECLs that are virtual function tables
+_DECLs
+@end display
+
+
+@item DECL_FIELD_CONTEXT
+Identifies the context that the FIELD_DECL was found in. Internally the
+same as DECL_CONTEXT, so don't us both. See also DECL_CONTEXT,
+DECL_FCONTEXT and DECL_CLASS_CONTEXT.
+
+Has values of:
+
+ RECORD_TYPEs
+
+What things can this be used on:
+
+@display
+FIELD_DECLs that are virtual function pointers
+FIELD_DECLs
+@end display
+
+
+@item DECL_NESTED_TYPENAME
+Holds the fully qualified type name. Example, Base::Derived.
+
+Has values of:
+
+ IDENTIFIER_NODEs
+
+What things can this be used on:
+
+ TYPE_DECLs
+
+
+@item DECL_NAME
+
+Has values of:
+
+@display
+0 for things that don't have names
+IDENTIFIER_NODEs for TYPE_DECLs
+@end display
+
+@item DECL_IGNORED_P
+A bit that can be set to inform the debug information output routines in
+the backend that a certain _DECL node should be totally ignored.
+
+Used in cases where it is known that the debugging information will be
+output in another file, or where a sub-type is known not to be needed
+because the enclosing type is not needed.
+
+A compiler constructed virtual destructor in derived classes that do not
+define an exlicit destructor that was defined exlicit in a base class
+has this bit set as well. Also used on __FUNCTION__ and
+__PRETTY_FUNCTION__ to mark they are ``compiler generated.'' c-decl and
+c-lex.c both want DECL_IGNORED_P set for ``internally generated vars,''
+and ``user-invisible variable.''
+
+Functions built by the C++ front-end such as default destructors,
+virtual desctructors and default constructors want to be marked that
+they are compiler generated, but unsure why.
+
+Currently, it is used in an absolute way in the C++ front-end, as an
+optimization, to tell the debug information output routines to not
+generate debugging information that will be output by another separately
+compiled file.
+
+
+@item DECL_VIRTUAL_P
+A flag used on FIELD_DECLs and VAR_DECLs. (Documentation in tree.h is
+wrong.) Used in VAR_DECLs to indicate that the variable is a vtable.
+It is also used in FIELD_DECLs for vtable pointers.
+
+What things can this be used on:
+
+ FIELD_DECLs and VAR_DECLs
+
+
+@item DECL_VPARENT
+Used to point to the parent type of the vtable if there is one, else it
+is just the type associated with the vtable. Because of the sharing of
+virtual function tables that goes on, this slot is not very useful, and
+is in fact, not used in the compiler at all. It can be removed.
+
+What things can this be used on:
+
+ VAR_DECLs that are virtual function tables
+
+Has values of:
+
+ RECORD_TYPEs maybe UNION_TYPEs
+
+
+@item DECL_FCONTEXT
+Used to find the first baseclass in which this FIELD_DECL is defined.
+See also DECL_CONTEXT, DECL_FIELD_CONTEXT and DECL_CLASS_CONTEXT.
+
+How it is used:
+
+ Used when writing out debugging information about vfield and
+ vbase decls.
+
+What things can this be used on:
+
+ FIELD_DECLs that are virtual function pointers
+ FIELD_DECLs
+
+
+@item DECL_REFERENCE_SLOT
+Used to hold the initialize for the reference.
+
+What things can this be used on:
+
+ PARM_DECLs and VAR_DECLs that have a reference type
+
+
+@item DECL_VINDEX
+Used for FUNCTION_DECLs in two different ways. Before the structure
+containing the FUNCTION_DECL is laid out, DECL_VINDEX may point to a
+FUNCTION_DECL in a base class which is the FUNCTION_DECL which this
+FUNCTION_DECL will replace as a virtual function. When the class is
+laid out, this pointer is changed to an INTEGER_CST node which is
+suitable to find an index into the virtual function table. See
+get_vtable_entry as to how one can find the right index into the virtual
+function table. The first index 0, of a virtual function table it not
+used in the normal way, so the first real index is 1.
+
+DECL_VINDEX may be a TREE_LIST, that would seem to be a list of
+overridden FUNCTION_DECLs. add_virtual_function has code to deal with
+this when it uses the variable base_fndecl_list, but it would seem that
+somehow, it is possible for the TREE_LIST to pursist until method_call,
+and it should not.
+
+
+What things can this be used on:
+
+ FUNCTION_DECLs
+
+
+@item DECL_SOURCE_FILE
+Identifies what source file a particular declaration was found in.
+
+Has values of:
+
+ "<built-in>" on TYPE_DECLs to mean the typedef is built in
+
+
+@item DECL_SOURCE_LINE
+Identifies what source line number in the source file the declaration
+was found at.
+
+Has values of:
+
+@display
+0 for an undefined label
+
+0 for TYPE_DECLs that are internally generated
+
+0 for FUNCTION_DECLs for functions generated by the compiler
+ (not yet, but should be)
+
+0 for ``magic'' arguments to functions, that the user has no
+ control over
+@end display
+
+
+@item TREE_USED
+
+Has values of:
+
+ 0 for unused labels
+
+
+@item TREE_ADDRESSABLE
+A flag that is set for any type that has a constructor.
+
+
+@item TREE_COMPLEXITY
+They seem a kludge way to track recursion, poping, and pushing. They only
+appear in cp-decl.c and cp-decl2.c, so the are a good candidate for
+proper fixing, and removal.
+
+
+@item TREE_PRIVATE
+Set for FIELD_DECLs by finish_struct. But not uniformly set.
+
+The following routines do something with PRIVATE access:
+build_method_call, alter_access, finish_struct_methods,
+finish_struct, convert_to_aggr, CWriteLanguageDecl, CWriteLanguageType,
+CWriteUseObject, compute_access, lookup_field, dfs_pushdecl,
+GNU_xref_member, dbxout_type_fields, dbxout_type_method_1
+
+
+@item TREE_PROTECTED
+The following routines do something with PROTECTED access:
+build_method_call, alter_access, finish_struct, convert_to_aggr,
+CWriteLanguageDecl, CWriteLanguageType, CWriteUseObject,
+compute_access, lookup_field, GNU_xref_member, dbxout_type_fields,
+dbxout_type_method_1
+
+
+@item TYPE_BINFO
+Used to get the binfo for the type.
+
+Has values of:
+
+ TREE_VECs that are binfos
+
+What things can this be used on:
+
+ RECORD_TYPEs
+
+
+@item TYPE_BINFO_BASETYPES
+See also BINFO_BASETYPES.
+
+@item TYPE_BINFO_VIRTUALS
+A unique list of functions for the virtual function table. See also
+BINFO_VIRTUALS.
+
+What things can this be used on:
+
+ RECORD_TYPEs
+
+
+@item TYPE_BINFO_VTABLE
+Points to the virtual function table associated with the given type.
+See also BINFO_VTABLE.
+
+What things can this be used on:
+
+ RECORD_TYPEs
+
+Has values of:
+
+ VAR_DECLs that are virtual function tables
+
+
+@item TYPE_NAME
+Names the type.
+
+Has values of:
+
+@display
+0 for things that don't have names.
+should be IDENTIFIER_NODE for RECORD_TYPEs UNION_TYPEs and
+ ENUM_TYPEs.
+TYPE_DECL for RECORD_TYPEs, UNION_TYPEs and ENUM_TYPEs, but
+ shouldn't be.
+TYPE_DECL for typedefs, unsure why.
+@end display
+
+What things can one use this on:
+
+@display
+TYPE_DECLs
+RECORD_TYPEs
+UNION_TYPEs
+ENUM_TYPEs
+@end display
+
+History:
+
+ It currently points to the TYPE_DECL for RECORD_TYPEs,
+ UNION_TYPEs and ENUM_TYPEs, but it should be history soon.
+
+
+@item TYPE_METHODS
+Synonym for @code{CLASSTYPE_METHOD_VEC}. Chained together with
+@code{TREE_CHAIN}. @file{dbxout.c} uses this to get at the methods of a
+class.
+
+
+@item TYPE_DECL
+Used to represent typedefs, and used to represent bindings layers.
+
+Components:
+
+ DECL_NAME is the name of the typedef. For example, foo would
+ be found in the DECL_NAME slot when @code{typedef int foo;} is
+ seen.
+
+ DECL_SOURCE_LINE identifies what source line number in the
+ source file the declaration was found at. A value of 0
+ indicates that this TYPE_DECL is just an internal binding layer
+ marker, and does not correspond to a user suppiled typedef.
+
+ DECL_SOURCE_FILE
+
+@item TYPE_FIELDS
+A linked list (via @code{TREE_CHAIN}) of member types of a class. The
+list can contain @code{TYPE_DECL}s, but there can also be other things
+in the list apparently. See also @code{CLASSTYPE_TAGS}.
+
+
+@item TYPE_VIRTUAL_P
+A flag used on a @code{FIELD_DECL} or a @code{VAR_DECL}, indicates it is
+a virtual function table or a pointer to one. When used on a
+@code{FUNCTION_DECL}, indicates that it is a virtual function. When
+used on an @code{IDENTIFIER_NODE}, indicates that a function with this
+same name exists and has been declared virtual.
+
+When used on types, it indicates that the type has virtual functions, or
+is derived from one that does.
+
+Not sure if the above about virtual function tables is still true. See
+also info on @code{DECL_VIRTUAL_P}.
+
+What things can this be used on:
+
+ FIELD_DECLs, VAR_DECLs, FUNCTION_DECLs, IDENTIFIER_NODEs
+
+
+@item VF_BASETYPE_VALUE
+Get the associated type from the binfo that caused the given vfield to
+exist. This is the least derived class (the most parent class) that
+needed a virtual function table. It is probably the case that all uses
+of this field are misguided, but they need to be examined on a
+case-by-case basis. See history for more information on why the
+previous statement was made.
+
+Set at @code{finish_base_struct} time.
+
+What things can this be used on:
+
+ TREE_LISTs that are vfields
+
+History:
+
+ This field was used to determine if a virtual function table's
+ slot should be filled in with a certain virtual function, by
+ checking to see if the type returned by VF_BASETYPE_VALUE was a
+ parent of the context in which the old virtual function existed.
+ This incorrectly assumes that a given type _could_ not appear as
+ a parent twice in a given inheritance lattice. For single
+ inheritance, this would in fact work, because a type could not
+ possibly appear more than once in an inheritance lattice, but
+ with multiple inheritance, a type can appear more than once.
+
+
+@item VF_BINFO_VALUE
+Identifies the binfo that caused this vfield to exist. If this vfield
+is from the first direct base class that has a virtual function table,
+then VF_BINFO_VALUE is NULL_TREE, otherwise it will be the binfo of the
+direct base where the vfield came from. Can use @code{TREE_VIA_VIRTUAL}
+on result to find out if it is a virtual base class. Related to the
+binfo found by
+
+@example
+get_binfo (VF_BASETYPE_VALUE (vfield), t, 0)
+@end example
+
+@noindent
+where @samp{t} is the type that has the given vfield.
+
+@example
+get_binfo (VF_BASETYPE_VALUE (vfield), t, 0)
+@end example
+
+@noindent
+will return the binfo for the the given vfield.
+
+May or may not be set at @code{modify_vtable_entries} time. Set at
+@code{finish_base_struct} time.
+
+What things can this be used on:
+
+ TREE_LISTs that are vfields
+
+
+@item VF_DERIVED_VALUE
+Identifies the type of the most derived class of the vfield, excluding
+the the class this vfield is for.
+
+Set at @code{finish_base_struct} time.
+
+What things can this be used on:
+
+ TREE_LISTs that are vfields
+
+
+@item VF_NORMAL_VALUE
+Identifies the type of the most derived class of the vfield, including
+the class this vfield is for.
+
+Set at @code{finish_base_struct} time.
+
+What things can this be used on:
+
+ TREE_LISTs that are vfields
+
+
+@item WRITABLE_VTABLES
+This is a option that can be defined when building the compiler, that
+will cause the compiler to output vtables into the data segment so that
+the vtables maybe written. This is undefined by default, because
+normally the vtables should be unwritable. People that implement object
+I/O facilities may, or people that want to change the dynamic type of
+objects may want to have the vtables writable. Another way of achieving
+this would be to make a copy of the vtable into writable memory, but the
+drawback there is that that method only changes the type for one object.
+
+@end table
+
+@node Typical Behavior, Coding Conventions, Macros, Top
+@section Typical Behavior
+
+@cindex parse errors
+
+Whenever seemingly normal code fails with errors like
+@code{syntax error at `\@{'}, it's highly likely that grokdeclarator is
+returning a NULL_TREE for whatever reason.
+
+@node Coding Conventions, Templates, Typical Behavior, Top
+@section Coding Conventions
+
+It should never be that case that trees are modified in-place by the
+back-end, @emph{unless} it is guaranteed that the semantics are the same
+no matter how shared the tree structure is. @file{fold-const.c} still
+has some cases where this is not true, but rms hypothesizes that this
+will never be a problem.
+
+@node Templates, Access Control, Coding Conventions, Top
+@section Templates
+
+g++ uses the simple approach to instantiating templates: it blindly
+generates the code for each instantiation as needed. For class
+templates, g++ pushes the template parameters into the namespace for the
+duration of the instantiation; for function templates, it's a simple
+search and replace.
+
+This approach does not support any of the template definition-time error
+checking that is being bandied about by X3J16. It makes no attempt to deal
+with name binding in a consistent way.
+
+Instantiation of a class template is triggered by the use of a template
+class anywhere but in a straight declaration like @code{class A<int>}.
+This is wrong; in fact, it should not be triggered by typedefs or
+declarations of pointers. Now that explicit instantiation is supported,
+this misfeature is not necessary.
+
+Important functions:
+
+@table @code
+@item instantiate_class_template
+This function
+@end table
+
+@node Access Control, Error Reporting, Templates, Top
+@section Access Control
+The function compute_access returns one of three values:
+
+@table @code
+@item access_public
+means that the field can be accessed by the current lexical scope.
+
+@item access_protected
+means that the field cannot be accessed by the current lexical scope
+because it is protected.
+
+@item access_private
+means that the field cannot be accessed by the current lexical scope
+because it is private.
+@end table
+
+DECL_ACCESS is used for access declarations; alter_access creates a list
+of types and accesses for a given decl.
+
+Formerly, DECL_@{PUBLIC,PROTECTED,PRIVATE@} corresponded to the return
+codes of compute_access and were used as a cache for compute_access.
+Now they are not used at all.
+
+TREE_PROTECTED and TREE_PRIVATE are used to record the access levels
+granted by the containing class. BEWARE: TREE_PUBLIC means something
+completely unrelated to access control!
+
+@node Error Reporting, Concept Index, Access Control, Top
+@section Error Reporting
+
+The C++ frontend uses a call-back mechanism to allow functions to print
+out reasonable strings for types and functions without putting extra
+logic in the functions where errors are found. The interface is through
+the @code{cp_error} function (or @code{cp_warning}, etc.). The
+syntax is exactly like that of @code{error}, except that a few more
+conversions are supported:
+
+@itemize @bullet
+@item
+%C indicates a value of `enum tree_code'.
+@item
+%D indicates a *_DECL node.
+@item
+%E indicates a *_EXPR node.
+@item
+%L indicates a value of `enum languages'.
+@item
+%P indicates the name of a parameter (i.e. "this", "1", "2", ...)
+@item
+%T indicates a *_TYPE node.
+@item
+%O indicates the name of an operator (MODIFY_EXPR -> "operator =").
+
+@end itemize
+
+There is some overlap between these; for instance, any of the node
+options can be used for printing an identifier (though only @code{%D}
+tries to decipher function names).
+
+For a more verbose message (@code{class foo} as opposed to just @code{foo},
+including the return type for functions), use @code{%#c}.
+To have the line number on the error message indicate the line of the
+DECL, use @code{cp_error_at} and its ilk; to indicate which argument you want,
+use @code{%+D}, or it will default to the first.
+
+@node Concept Index, , Error Reporting, Top
+@section Concept Index
+
+@printindex cp
+
+@bye
--- /dev/null
+/* 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,$ ../../../devo/gcc/cp/gxx.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 86
+#define MIN_WORD_LENGTH 2
+#define MAX_WORD_LENGTH 13
+#define MIN_HASH_VALUE 4
+#define MAX_HASH_VALUE 196
+/* maximum key range = 193, duplicates = 0 */
+
+#ifdef __GNUC__
+inline
+#endif
+static unsigned int
+hash (str, len)
+ register char *str;
+ register int unsigned len;
+{
+ static unsigned char asso_values[] =
+ {
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
+ 197, 197, 197, 197, 197, 0, 197, 93, 3, 35,
+ 3, 0, 71, 8, 4, 78, 197, 3, 30, 6,
+ 29, 18, 37, 197, 55, 0, 4, 11, 7, 20,
+ 0, 8, 197, 197, 197, 197, 197, 197,
+ };
+ 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},
+ {"this", THIS, NORID,},
+ {"delete", DELETE, NORID,},
+ {"except", EXCEPT, NORID /* Extension */,},
+ {"__asm", GCC_ASM_KEYWORD, NORID},
+ {"double", TYPESPEC, RID_DOUBLE,},
+ {"typeid", TYPEID, NORID,},
+ {"switch", SWITCH, NORID,},
+ {"try", TRY, NORID /* Extension */,},
+ {"enum", ENUM, NORID,},
+ {"void", TYPESPEC, RID_VOID,},
+ {"",}, {"",}, {"",},
+ {"struct", AGGR, RID_RECORD,},
+ {"",},
+ {"do", DO, NORID,},
+ {"",}, {"",}, {"",}, {"",},
+ {"__headof__", HEADOF, NORID},
+ {"",}, {"",},
+ {"__const__", TYPE_QUAL, RID_CONST},
+ {"__volatile", TYPE_QUAL, RID_VOLATILE},
+ {"__const", TYPE_QUAL, RID_CONST},
+ {"__volatile__", TYPE_QUAL, RID_VOLATILE},
+ {"extern", SCSPEC, RID_EXTERN,},
+ {"__typeof__", TYPEOF, NORID},
+ {"",},
+ {"signed", TYPESPEC, RID_SIGNED,},
+ {"case", CASE, NORID,},
+ {"class", AGGR, RID_CLASS,},
+ {"__classof__", CLASSOF, NORID},
+ {"__extension__", EXTENSION, NORID},
+ {"",},
+ {"const", TYPE_QUAL, RID_CONST,},
+ {"static", SCSPEC, RID_STATIC,},
+ {"",},
+ {"throw", THROW, NORID /* Extension */,},
+ {"goto", GOTO, NORID,},
+ {"signature", AGGR, RID_SIGNATURE /* Extension */,},
+ {"long", TYPESPEC, RID_LONG,},
+ {"private", VISSPEC, RID_PRIVATE,},
+ {"new", NEW, NORID,},
+ {"template", TEMPLATE, NORID,},
+ {"",},
+ {"while", WHILE, NORID,},
+ {"",},
+ {"protected", VISSPEC, RID_PROTECTED,},
+ {"continue", CONTINUE, NORID,},
+ {"",},
+ {"raise", RAISE, NORID /* Extension */,},
+ {"raises", RAISES, NORID /* Extension */,},
+ {"",},
+ {"union", AGGR, RID_UNION,},
+ {"short", TYPESPEC, RID_SHORT,},
+ {"",},
+ {"__inline", SCSPEC, RID_INLINE},
+ {"",},
+ {"__inline__", SCSPEC, RID_INLINE},
+ {"",},
+ {"__alignof__", ALIGNOF, NORID},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"sizeof", SIZEOF, NORID,},
+ {"virtual", SCSPEC, RID_VIRTUAL,},
+ {"catch", CATCH, NORID,},
+ {"friend", SCSPEC, RID_FRIEND,},
+ {"typeof", TYPEOF, NORID,},
+ {"",}, {"",},
+ {"headof", HEADOF, NORID,},
+ {"int", TYPESPEC, RID_INT,},
+ {"",}, {"",},
+ {"__signed__", TYPESPEC, RID_SIGNED},
+ {"__signed", TYPESPEC, RID_SIGNED},
+ {"",}, {"",}, {"",},
+ {"__attribute", ATTRIBUTE, NORID},
+ {"sigof", SIGOF, NORID /* Extension */,},
+ {"__attribute__", ATTRIBUTE, NORID},
+ {"",},
+ {"__headof", HEADOF, NORID},
+ {"",}, {"",},
+ {"unsigned", TYPESPEC, RID_UNSIGNED,},
+ {"return", RETURN, NORID,},
+ {"asm", ASM_KEYWORD, NORID,},
+ {"__wchar_t", TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,},
+ {"break", BREAK, NORID,},
+ {"__typeof", TYPEOF, NORID},
+ {"mutable", SCSPEC, RID_MUTABLE,},
+ {"",},
+ {"public", VISSPEC, RID_PUBLIC,},
+ {"",},
+ {"__classof", CLASSOF, NORID},
+ {"default", DEFAULT, NORID,},
+ {"",}, {"",}, {"",}, {"",},
+ {"exception", AGGR, RID_EXCEPTION /* Extension */,},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"all", ALL, NORID /* Extension */,},
+ {"",}, {"",},
+ {"for", FOR, NORID,},
+ {"",}, {"",},
+ {"__label__", LABEL, NORID},
+ {"auto", SCSPEC, RID_AUTO,},
+ {"",}, {"",}, {"",}, {"",},
+ {"volatile", TYPE_QUAL, RID_VOLATILE,},
+ {"__alignof", ALIGNOF, NORID},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"dynamic_cast", DYNAMIC_CAST, NORID,},
+ {"",},
+ {"char", TYPESPEC, RID_CHAR,},
+ {"",},
+ {"if", IF, NORID,},
+ {"",},
+ {"typedef", SCSPEC, RID_TYPEDEF,},
+ {"operator", OPERATOR, NORID,},
+ {"reraise", RERAISE, NORID /* Extension */,},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"inline", SCSPEC, RID_INLINE,},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"",},
+ {"float", TYPESPEC, RID_FLOAT,},
+ {"",}, {"",}, {"",},
+ {"overload", OVERLOAD, NORID,},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"classof", CLASSOF, NORID,},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"",}, {"",},
+ {"register", SCSPEC, RID_REGISTER,},
+ };
+
+ 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;
+}
--- /dev/null
+/* Handle initialization things in C++.
+ Copyright (C) 1987, 1989, 1992, 1993, 1994 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;
+
+/* Cache the identifier nodes for the two magic field of a new cookie. */
+static tree nc_nelts_field_id;
+static tree nc_ptr_2comp_field_id;
+
+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 fields[1];
+
+ /* Define implicit `operator new' and `operator delete' functions. */
+ BIN = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) NEW_EXPR])));
+ TREE_USED (TREE_OPERAND (BIN, 0)) = 0;
+ BID = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) DELETE_EXPR])));
+ TREE_USED (TREE_OPERAND (BID, 0)) = 0;
+ minus_one = build_int_2 (-1, -1);
+
+ /* Define the structure that holds header information for
+ arrays allocated via operator new. */
+ BI_header_type = make_lang_type (RECORD_TYPE);
+ nc_nelts_field_id = get_identifier ("nelts");
+ fields[0] = build_lang_field_decl (FIELD_DECL, nc_nelts_field_id, sizetype);
+ finish_builtin_type (BI_header_type, "__new_cookie", fields,
+ 0, double_type_node);
+ BI_header_size = size_in_bytes (BI_header_type);
+}
+
+/* Subroutine of emit_base_init. For BINFO, initialize all the
+ virtual function table pointers, except those that come from
+ virtual base classes. Initialize binfo's vtable pointer, if
+ INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
+ function table pointers in all bases have been initialized already,
+ probably because their constructors have just be run. */
+void
+init_vtbl_ptrs (binfo, init_self, can_elide)
+ tree binfo;
+ int init_self, can_elide;
+{
+ tree vfields;
+ 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);
+ int is_not_base_vtable =
+ i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
+ if (! TREE_VIA_VIRTUAL (base_binfo))
+ init_vtbl_ptrs (base_binfo, is_not_base_vtable, can_elide);
+ }
+#if 0
+ /* Before turning this on, make sure it is correct. */
+ if (can_elide && ! BINFO_MODIFIED (binfo))
+ return;
+#endif
+ /* Should we use something besides CLASSTYPE_VFIELDS? */
+ if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
+ {
+ tree base_ptr = convert_pointer_to_real (binfo, current_class_decl);
+ expand_expr_stmt (build_virtual_init (binfo, binfo, base_ptr));
+ }
+}
+\f
+/* 348 - 351 */
+/* Subroutine of emit_base_init. */
+static void
+perform_member_init (member, name, init, explicit)
+ tree member, name, init;
+ int explicit;
+{
+ tree decl;
+ tree type = TREE_TYPE (member);
+
+ if (TYPE_NEEDS_CONSTRUCTING (type)
+ || (init && TYPE_HAS_CONSTRUCTOR (type)))
+ {
+ /* Since `init' is already a TREE_LIST on the current_member_init_list,
+ only build it into one if we aren't already a list. */
+ if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST)
+ init = build_tree_list (NULL_TREE, init);
+
+ decl = build_component_ref (C_C_D, name, 0, explicit);
+
+ if (explicit
+ && 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)
+ {
+ if (explicit)
+ {
+ cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor",
+ member, current_class_type);
+ init = error_mark_node;
+ }
+ /* member traversal: note it leaves init NULL */
+ else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE)
+ cp_pedwarn ("uninitialized reference member `%D'", member);
+ }
+ else if (TREE_CODE (init) == TREE_LIST)
+ {
+ /* There was an explicit member initialization. Do some
+ work in that case. */
+ if (TREE_CHAIN (init))
+ {
+ warning ("initializer list treated as compound expression");
+ init = build_compound_expr (init);
+ }
+ else
+ init = TREE_VALUE (init);
+ }
+
+ /* We only build this with a null init if we got it from the
+ current_member_init_list. */
+ if (init || explicit)
+ {
+ decl = build_component_ref (C_C_D, name, 0, explicit);
+ 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));
+ }
+}
+
+/* Subroutine of emit_member_init. */
+static tree
+sort_member_init (t)
+ tree t;
+{
+ tree x, member, name, field, init;
+ tree init_list = NULL_TREE;
+ tree fields_to_unmark = NULL_TREE;
+ int found;
+
+ for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member))
+ {
+ found = 0;
+ for (x = current_member_init_list ; x ; x = TREE_CHAIN (x))
+ {
+ /* If we cleared this out, then pay no attention to it. */
+ if (TREE_PURPOSE (x) == NULL_TREE)
+ continue;
+ name = TREE_PURPOSE (x);
+
+#if 0
+ field = (TREE_CODE (name) == COMPONENT_REF
+ ? TREE_OPERAND (name, 1) : IDENTIFIER_CLASS_VALUE (name));
+#else
+ /* Let's find out when this happens. */
+ my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 348);
+ field = IDENTIFIER_CLASS_VALUE (name);
+#endif
+
+ /* If one member shadows another, get the outermost one. */
+ if (TREE_CODE (field) == TREE_LIST)
+ field = TREE_VALUE (field);
+
+ if (field == member)
+ {
+ /* See if we already found an initializer for this field. */
+ if (found)
+ {
+ if (DECL_NAME (field))
+ cp_error ("multiple initializations given for member `%D'",
+ field);
+ continue;
+ }
+
+ init_list = chainon (init_list,
+ build_tree_list (name, TREE_VALUE (x)));
+ /* Make sure we won't try to work on this init again. */
+ TREE_PURPOSE (x) = NULL_TREE;
+ found = 1;
+ break;
+ }
+ }
+
+ /* If we didn't find MEMBER in the list, create a dummy entry
+ so the two lists (INIT_LIST and the list of members) will be
+ symmetrical. */
+ if (! found)
+ init_list = chainon (init_list, build_tree_list (NULL_TREE, NULL_TREE));
+ }
+
+ for (x = current_member_init_list ; x ; x = TREE_CHAIN (x))
+ {
+ if (TREE_PURPOSE (x))
+ {
+ name = TREE_PURPOSE (x);
+ init = TREE_VALUE (x);
+ /* XXX: this may need the COMPONENT_REF operand 0 check if
+ it turns out we actually get them. */
+ field = IDENTIFIER_CLASS_VALUE (name);
+
+ /* 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)
+ cp_error ("field `%D' not in immediate context", field);
+ }
+
+#if 0
+ /* It turns out if you have an anonymous union in the
+ class, a member from it can end up not being on the
+ list of fields (rather, the type is), and therefore
+ won't be seen by the for loop above. */
+
+ /* The code in this for loop is derived from a general loop
+ which had this check in it. Theoretically, we've hit
+ every initialization for the list of members in T, so
+ we shouldn't have anything but these left in this list. */
+ my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351);
+#endif
+
+ if (TREE_HAS_CONSTRUCTOR (field))
+ {
+ if (DECL_NAME (field))
+ error ("multiple initializations given for member `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (field)));
+ continue;
+ }
+
+ TREE_HAS_CONSTRUCTOR (field) = 1;
+ fields_to_unmark = tree_cons (NULL_TREE, field, fields_to_unmark);
+
+ perform_member_init (field, name, init, 1);
+ TREE_PURPOSE (x) = NULL_TREE;
+ }
+ }
+
+ /* Unmark fields which are initialized for the base class. */
+ while (fields_to_unmark)
+ {
+ TREE_HAS_CONSTRUCTOR (TREE_VALUE (fields_to_unmark)) = 0;
+ /* XXX is this a memory leak? */
+ fields_to_unmark = TREE_CHAIN (fields_to_unmark);
+ }
+
+ return init_list;
+}
+
+/* Perform whatever initializations 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, member_init;
+ 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;
+ int have_init_list = 0, from_init_list;
+
+ 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);
+ }
+
+ /* We used to give an error if this wasn't true, saying that
+ there's no constructor for the initialization of basename.
+ This turned out to be incorrect---it should use the
+ default constructor, since a user could try to initialize
+ the class in a derived class's base initializer list. */
+ if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo)))
+ {
+ if (msgp)
+ {
+ if (pedantic)
+ error_with_aggr_type (binfo, msgp);
+ else
+ msgp = NULL;
+ }
+ }
+
+ 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, NULL_PTR), init,
+ BINFO_OFFSET_ZEROP (binfo), 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_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, NULL_PTR);
+ expand_aggr_init_1 (t_binfo, 0, ref, NULL_TREE,
+ BINFO_OFFSET_ZEROP (base_binfo),
+ 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);
+
+ if (! TYPE_USES_VIRTUAL_BASECLASSES (t))
+ {
+ while (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo))
+ && BINFO_BASETYPES (base_binfo) != NULL_TREE
+ && TREE_VEC_LENGTH (BINFO_BASETYPES (base_binfo)) == 1)
+ {
+ /* ?? This should be fixed in RENO by forcing
+ default constructors to exist. It is needed for symmetry
+ with code above. */
+ base_binfo = BINFO_BASETYPE (base_binfo, 0);
+ CLEAR_BINFO_BASEINIT_MARKED (base_binfo);
+ }
+ }
+ }
+
+ /* Initialize all the virtual function table fields that
+ do come from virtual base classes. */
+ if (TYPE_USES_VIRTUAL_BASECLASSES (t))
+ expand_expr_stmt (build_vbase_vtables_init (t_binfo, t_binfo,
+ C_C_D, current_class_decl, 0));
+ 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_vtbl_ptrs (t_binfo, 0, 1);
+
+ if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (t))
+ expand_expr_stmt (build_virtual_init (TYPE_BINFO (t), t,
+ current_class_decl));
+
+ if (current_member_init_list)
+ {
+ init_list = sort_member_init (t);
+ have_init_list = 1;
+ }
+
+ for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
+ {
+ tree init, name;
+ from_init_list = 0;
+
+ /* See if we had a user-specified member initialization. */
+ if (have_init_list)
+ {
+ if (TREE_PURPOSE (init_list))
+ {
+ name = TREE_PURPOSE (init_list);
+ init = TREE_VALUE (init_list);
+ from_init_list = 1;
+
+ if (TREE_STATIC (member))
+ {
+ error_with_aggr_type (DECL_FIELD_CONTEXT (member),
+ "field `%s::%s' is static; only point of initialization is its declaration",
+ IDENTIFIER_POINTER (TREE_PURPOSE (init_list)));
+ continue;
+ }
+
+ /* Also see if it's ever a COMPONENT_REF here. If it is, we
+ need to do `expand_assignment (name, init, 0, 0);' and
+ a continue. */
+ my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 349);
+ }
+
+ init_list = TREE_CHAIN (init_list);
+ }
+
+ if (! from_init_list)
+ {
+ /* member could be, for example, a CONST_DECL for an enumerated
+ tag; we don't want to try to initialize that, since it already
+ has a value. */
+ if (TREE_CODE (member) != FIELD_DECL)
+ continue;
+
+ name = DECL_NAME (member);
+ init = DECL_INITIAL (member);
+ }
+
+ perform_member_init (member, name, init, from_init_list);
+ }
+
+ current_member_init_list = NULL_TREE;
+
+ /* 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))
+ cp_error ("field `%D' used before initialized (after assignment to `this')",
+ 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, vtype_binfo;
+
+ 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));
+ vtype_binfo = get_binfo (vtype, TREE_TYPE (TREE_TYPE (decl)), 0);
+#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, NULL_PTR), 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_real (vtype_binfo, decl);
+ vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL_PTR), 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, NULL_PTR);
+ if (init)
+ init = TREE_PURPOSE (init);
+ /* Call constructors, but don't set up vtables. */
+ expand_aggr_init_1 (binfo, exp, ref, init, 0,
+ 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)
+ {
+ cp_error ("class `%T' does not have any field named `%s'", type,
+ member_name);
+ return 0;
+ }
+ if (DECL_CONTEXT (field) != type
+ && TYPE_NEEDS_CONSTRUCTING (DECL_CONTEXT (field)))
+ {
+ cp_error ("member `%D' comes from base class needing constructor",
+ field);
+ 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");
+ cp_error ("(type `%T' uses multiple inheritance)", type);
+ 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;
+ }
+ if (init && TREE_TYPE (init) == NULL_TREE)
+ {
+ /* Handle bad initializers like:
+ class COMPLEX {
+ public:
+ double re, im;
+ COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
+ ~COMPLEX() {};
+ };
+
+ int main(int argc, char **argv) {
+ COMPLEX zees(1.0, 0.0)[10];
+ }
+ */
+ error ("bad array initializer");
+ return;
+ }
+ 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 0
+ /* 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);
+#endif
+ 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_full (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_full (type), parms,
+ binfo, flags);
+ }
+
+ /* Private, protected, or otherwise unavailable. */
+ if (rval == error_mark_node && (flags&LOOKUP_COMPLAIN))
+ cp_error ("in base initialization for class `%T'", binfo);
+ /* 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 access 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
+ {
+ cp_error ("in base initialization for class `%T',", binfo);
+ cp_error ("invalid initializer to constructor for type `%T'", type);
+ return;
+ }
+ }
+ else
+ {
+ if (init == NULL_TREE)
+ my_friendly_assert (parms == NULL_TREE, 210);
+ if (parms == NULL_TREE && TREE_VIA_VIRTUAL (binfo))
+ cp_error ("virtual baseclass `%T' does not have default initializer", binfo);
+ else
+ {
+ cp_error ("in base initialization for class `%T',", binfo);
+ /* This will make an error message for us. */
+ build_method_call (exp, constructor_name_full (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;
+ TREE_SIDE_EFFECTS (init) = 1;
+ 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;
+ }
+ }
+
+ if (TREE_CODE (exp) == VAR_DECL
+ && TREE_CODE (init) == CONSTRUCTOR
+ && TREE_HAS_CONSTRUCTOR (init))
+ {
+ tree t = store_init_value (exp, init);
+ if (!t)
+ {
+ expand_decl_init (exp);
+ return;
+ }
+ t = build (INIT_EXPR, type, exp, init);
+ TREE_SIDE_EFFECTS (t) = 1;
+ expand_expr_stmt (t);
+ return;
+ }
+
+ /* Handle this case: when calling a constructor: xyzzy foo(bar);
+ which really means: xyzzy foo = bar; Ugh!
+
+ More useful for this case: xyzzy *foo = new xyzzy (bar); */
+
+ if (! TYPE_NEEDS_CONSTRUCTING (type) && ! IS_AGGR_TYPE (type))
+ {
+ if (init_list && TREE_CHAIN (init_list))
+ {
+ warning ("initializer list being treated as compound expression");
+ init = convert (type, build_compound_expr (init_list));
+ if (init == error_mark_node)
+ return;
+ }
+
+ expand_assignment (exp, init, 0, 0);
+
+ 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_full (type),
+ parms, binfo,
+ LOOKUP_SPECULATIVELY|LOOKUP_NO_CONVERSION);
+ if (as_cons != NULL_TREE && as_cons != error_mark_node)
+ /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
+ cp_error ("ambiguity between conversion to `%T' and constructor",
+ type);
+ 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), NULL_PTR);
+ 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), NULL_PTR);
+ expand_aggr_init_1 (binfo, true_exp, subexp, *init_ptr,
+ alias_this && BINFO_OFFSET_ZEROP (TREE_VALUE (init_list)),
+ 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))
+ cp_error ("unexpected argument to constructor `%T'", type);
+ 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))
+ type = IDENTIFIER_TYPE_VALUE (name);
+ else if (IDENTIFIER_HAS_CLASS_TYPE_VALUE (name))
+ type = IDENTIFIER_CLASS_TYPE_VALUE (name);
+ else
+ {
+ if (or_else)
+ cp_error ("`%T' fails to be an aggregate typedef", name);
+ return 0;
+ }
+
+ if (! IS_AGGR_TYPE (type)
+ && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
+ {
+ if (or_else)
+ cp_error ("type `%T' is of non-aggregate type", type);
+ return 0;
+ }
+ return 1;
+}
+
+/* Like is_aggr_typedef, but returns typedef if successful. */
+tree
+get_aggr_from_typedef (name, or_else)
+ tree name;
+ int or_else;
+{
+ tree type;
+
+ if (name == error_mark_node)
+ return NULL_TREE;
+
+ if (IDENTIFIER_HAS_TYPE_VALUE (name))
+ type = IDENTIFIER_TYPE_VALUE (name);
+ else if (IDENTIFIER_HAS_CLASS_TYPE_VALUE (name))
+ type = IDENTIFIER_CLASS_TYPE_VALUE (name);
+ else
+ {
+ if (or_else)
+ cp_error ("`%T' fails to be an aggregate typedef", name);
+ return NULL_TREE;
+ }
+
+ if (! IS_AGGR_TYPE (type)
+ && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
+ {
+ if (or_else)
+ cp_error ("type `%T' is of non-aggregate type", type);
+ return NULL_TREE;
+ }
+ return type;
+}
+
+tree
+get_type_value (name)
+ tree name;
+{
+ tree type;
+
+ if (name == error_mark_node)
+ return NULL_TREE;
+
+ if (IDENTIFIER_HAS_TYPE_VALUE (name))
+ return IDENTIFIER_TYPE_VALUE (name);
+ else if (IDENTIFIER_CLASS_VALUE (name))
+ return IDENTIFIER_CLASS_TYPE_VALUE (name);
+ else
+ return NULL_TREE;
+}
+
+\f
+/* 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 || ! (type = get_aggr_from_typedef (cname, 1)))
+ return error_mark_node;
+
+ /* An operator we did not like. */
+ if (name == NULL_TREE)
+ return error_mark_node;
+
+ if (dtor)
+ {
+#if 0
+ /* Everything can explicitly call a destructor; see 12.4 */
+ if (! TYPE_HAS_DESTRUCTOR (type))
+ cp_error ("type `%#T' does not have a destructor", type);
+ else
+#endif
+ cp_error ("cannot call destructor `%T::~%T' without object", type,
+ method_name);
+ return error_mark_node;
+ }
+
+ /* 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
+ {
+ tree olddecl = current_class_decl;
+ tree oldtype = TREE_TYPE (TREE_TYPE (olddecl));
+ if (oldtype != type)
+ {
+ tree newtype = build_type_variant (type, TYPE_READONLY (oldtype),
+ TYPE_VOLATILE (oldtype));
+ decl = convert_force (TYPE_POINTER_TO (newtype), olddecl);
+ }
+ else
+ decl = olddecl;
+ }
+
+ decl = build_indirect_ref (decl, NULL_PTR);
+
+ 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)
+ {
+ cp_error ("invalid use of non-static field `%D'", t);
+ return error_mark_node;
+ }
+ decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t);
+ }
+ else if (TREE_CODE (t) == VAR_DECL)
+ decl = t;
+ else
+ {
+ cp_error ("invalid use of member `%D'", t);
+ 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
+ {
+ cp_error ("no method `%T::%D'", type, 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)
+ {
+ cp_error ("incomplete type `%T' does not have member `%D'", type,
+ name);
+ return error_mark_node;
+ }
+ if (TREE_CODE (t) == TYPE_DECL)
+ {
+ cp_error ("member `%D' is just a type declaration", t);
+ 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 access checking yet. */
+ if (DECL_CHAIN (t) == NULL_TREE || dtor)
+ {
+ enum access_type access;
+
+ /* unique functions are handled easily. */
+ unique:
+ access = compute_access (basetypes, t);
+ if (access == access_protected)
+ {
+ cp_error_at ("member function `%#D' is protected", t);
+ error ("in this context");
+ return error_mark_node;
+ }
+ if (access == access_private)
+ {
+ cp_error_at ("member function `%#D' is private", t);
+ 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)
+ {
+ cp_error ("`%D' is not a member of type `%T'", name,
+ IDENTIFIER_TYPE_VALUE (cname));
+ return error_mark_node;
+ }
+
+ if (TREE_CODE (t) == TYPE_DECL)
+ {
+ cp_error ("member `%D' is just a type declaration", t);
+ 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, NULL_PTR);
+ *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, NULL_PTR);
+}
+
+/* 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
+ && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
+ || 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)
+ {
+ cp_error_at ("member `%D' is non-static in static member function context", member);
+ 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 access_type access;
+
+ if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE)
+ {
+ basetype = TYPE_OFFSET_BASETYPE (type);
+ base = convert_pointer_to (basetype, current_class_decl);
+ }
+ else
+ base = current_class_decl;
+ basetype = DECL_CONTEXT (member);
+
+ if (get_base_distance (basetype, TREE_TYPE (TREE_TYPE (base)), 0, &basetype_path) < 0)
+ {
+ error_not_base_type (basetype, TREE_TYPE (TREE_TYPE (base)));
+ return error_mark_node;
+ }
+ addr = convert_pointer_to (basetype, base);
+ access = compute_access (basetype_path, member);
+ if (access == access_public)
+ return build (COMPONENT_REF, TREE_TYPE (member),
+ build_indirect_ref (addr, NULL_PTR), member);
+ if (access == access_protected)
+ {
+ cp_error_at ("member `%D' is protected", member);
+ error ("in this context");
+ return error_mark_node;
+ }
+ if (access == access_private)
+ {
+ cp_error_at ("member `%D' is private", member);
+ 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, NULL_PTR), 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));
+ }
+ else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
+ {
+ return get_member_function_from_ptrfunc (&addr, base, 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;
+}
+\f
+/* Friend handling routines. */
+/* Friend data structures:
+
+ Lists of friend functions come from TYPE_DECL nodes. Since all
+ aggregate types are automatically typedef'd, these nodes are guaranteed
+ to exist.
+
+ The TREE_PURPOSE of a friend list is the name of the friend,
+ and its TREE_VALUE is another list.
+
+ For each element of that list, either the TREE_VALUE or the TREE_PURPOSE
+ will be filled in, but not both. The TREE_VALUE of that list is an
+ individual function which is a friend. The TREE_PURPOSE of that list
+ indicates a type in which all functions by that name are friends.
+
+ Lists of friend classes come from _TYPE nodes. Love that consistency
+ thang. */
+
+int
+is_friend_type (type1, type2)
+ tree type1, type2;
+{
+ return is_friend (type1, type2);
+}
+
+int
+is_friend (type, supplicant)
+ tree type, supplicant;
+{
+ int declp;
+ register tree list;
+
+ if (supplicant == NULL_TREE || type == NULL_TREE)
+ return 0;
+
+ declp = (TREE_CODE_CLASS (TREE_CODE (supplicant)) == 'd');
+
+ if (declp)
+ /* It's a function decl. */
+ {
+ tree list = DECL_FRIENDLIST (TYPE_NAME (type));
+ tree name = DECL_NAME (supplicant);
+ tree ctype = DECL_CLASS_CONTEXT (supplicant);
+ for (; list ; list = TREE_CHAIN (list))
+ {
+ if (name == TREE_PURPOSE (list))
+ {
+ tree friends = TREE_VALUE (list);
+ name = DECL_ASSEMBLER_NAME (supplicant);
+ for (; friends ; friends = TREE_CHAIN (friends))
+ {
+ if (ctype == TREE_PURPOSE (friends))
+ return 1;
+ if (name == DECL_ASSEMBLER_NAME (TREE_VALUE (friends)))
+ return 1;
+ }
+ break;
+ }
+ }
+ }
+ else
+ /* It's a type. */
+ {
+ if (type == supplicant)
+ return 1;
+
+ list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_NAME (type)));
+ for (; list ; list = TREE_CHAIN (list))
+ if (supplicant == TREE_VALUE (list))
+ return 1;
+ }
+
+ {
+ tree context = declp ? DECL_CLASS_CONTEXT (supplicant)
+ : DECL_CONTEXT (TYPE_NAME (supplicant));
+
+ if (context)
+ return is_friend (type, context);
+ }
+
+ 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);
+
+ while (list)
+ {
+ if (name == TREE_PURPOSE (list))
+ {
+ tree friends = TREE_VALUE (list);
+ for (; friends ; friends = TREE_CHAIN (friends))
+ {
+ if (decl == TREE_VALUE (friends))
+ {
+ cp_pedwarn_at ("`%D' is already a friend of class `%T'",
+ decl, type);
+ return;
+ }
+ }
+ TREE_VALUE (list) = tree_cons (error_mark_node, 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;
+ 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;
+ }
+ }
+}
+
+/* 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;
+ 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. For more than
+ one, set up a cross reference so that functions with the name DECL
+ and type CTYPE know that they are friends of TYPE. */
+static void
+xref_friend (type, decl, ctype)
+ tree type, decl, ctype;
+{
+ tree typedecl = TYPE_NAME (type);
+ tree friend_decl = TYPE_NAME (ctype);
+#if 0
+ tree t = tree_cons (NULL_TREE, ctype, DECL_UNDEFINED_FRIENDS (typedecl));
+
+ DECL_UNDEFINED_FRIENDS (typedecl) = t;
+#else
+ tree t = 0;
+#endif
+ SET_DECL_WAITING_FRIENDS (friend_decl,
+ tree_cons (type, t,
+ DECL_WAITING_FRIENDS (friend_decl)));
+ TREE_TYPE (DECL_WAITING_FRIENDS (friend_decl)) = decl;
+}
+
+/* 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 (IS_SIGNATURE (type))
+ {
+ error ("`friend' declaration in signature definition");
+ return;
+ }
+ if (IS_SIGNATURE (friend_type))
+ {
+ error ("signature type `%s' declared `friend'",
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (friend_type))));
+ return;
+ }
+ 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;
+
+ /* Every decl that gets here is a friend of something. */
+ DECL_FRIEND_P (decl) = 1;
+
+ /* 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);
+ }
+
+ /* It had extern "C" linkage, so don't overload this. */
+ if (previous_decl && TREE_CODE (previous_decl) == FUNCTION_DECL
+ && TREE_TYPE (decl) == TREE_TYPE (previous_decl)
+ && DECL_LANGUAGE (previous_decl) == lang_c)
+ 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
+ {
+ register char *classname
+ = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (ctype)));
+
+ error ("member declared as friend before type `%s' defined",
+ classname);
+ }
+ }
+ }
+ 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
+ /* Note: DECLARATOR actually has more than one; in this
+ case, we're making sure that fns with the name DECLARATOR
+ and type CTYPE know they are friends of the current
+ class type. */
+ xref_friend (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;
+ DECL_CLASS_CONTEXT (decl) = current_class_type;
+
+ /* 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));
+ cp_error_at ("after declaration of non-overloaded `%D'", IDENTIFIER_GLOBAL_VALUE (declarator));
+ }
+ 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, 1);
+ 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);
+#if 0
+ tree waiter_prev = TREE_VALUE (waiters);
+#endif
+ 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 0
+ if (TREE_CHAIN (waiter_prev))
+ TREE_CHAIN (waiter_prev) = TREE_CHAIN (TREE_CHAIN (waiter_prev));
+ else
+ DECL_UNDEFINED_FRIENDS (TYPE_NAME (waiter)) = NULL_TREE;
+#endif
+ }
+}
+\f
+/* 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;
+}
+\f
+/* 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)
+ {
+ immediate_size_expand = old_immediate_size_expand;
+ 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 (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
+ {
+ signature_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 (true_type) == ARRAY_TYPE)
+ {
+ tree this_nelts = array_type_nelts_top (true_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);
+ }
+ true_type = TREE_TYPE (true_type);
+ }
+ if (has_array)
+ size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
+ nelts, 1));
+ else
+ size = size_in_bytes (type);
+
+ if (has_call)
+ init = init1;
+
+ /* 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) || TREE_GETS_PLACED_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;
+ 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), NULL_PTR);
+ exp1 = build (MODIFY_EXPR, void_type_node,
+ build_component_ref (cookie, nc_nelts_field_id, 0, 0),
+ nelts);
+ TREE_SIDE_EFFECTS (exp1) = 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,
+ 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. If it has an initialization, we
+ need to complain if we aren't allowed to use the ctor that took
+ that argument. */
+ int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_COMPLAIN;
+
+ /* If a copy constructor might work, set things up so that we can
+ try that after this. We deliberately don't clear LOOKUP_COMPLAIN
+ any more, since that would make it impossible to rationally use
+ the access of a constructor that matches perfectly. */
+#if 0
+ if (rval != NULL_TREE)
+ flags |= LOOKUP_SPECULATIVELY;
+#endif
+
+ if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
+ {
+ init = tree_cons (NULL_TREE, integer_one_node, init);
+ flags |= LOOKUP_HAS_IN_CHARGE;
+ }
+
+ {
+ tree tmp = rval;
+
+ if (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE)
+ tmp = build_indirect_ref (tmp, NULL_PTR);
+
+ newrval = build_method_call (tmp, constructor_name_full (true_type),
+ init, NULL_TREE, flags);
+ }
+
+ if (newrval)
+ {
+ rval = newrval;
+ TREE_HAS_CONSTRUCTOR (rval) = 1;
+ }
+ else
+ rval = error_mark_node;
+ goto done;
+ }
+
+ 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))
+ {
+ if (! TYPE_NEEDS_CONSTRUCTING (type) && ! IS_AGGR_TYPE (type))
+ {
+ /* 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, NULL_PTR),
+ NOP_EXPR, init),
+ rval);
+ TREE_SIDE_EFFECTS (rval) = 1;
+ TREE_CALLS_NEW (rval) = 1;
+ }
+ else if (current_function_decl == NULL_TREE)
+ {
+ extern tree static_aggregates;
+
+ /* 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_for_rtl_expr (xval);
+
+ /* 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, NULL_PTR), 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;
+ }
+ }
+ 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);
+}
+\f
+/* `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
+ {
+ tree itype;
+
+ iterator = get_temp_regvar (integer_type_node, maxindex);
+
+ init_by_default:
+
+ /* If initializing one array from another,
+ initialize element by element. */
+ if (from_array)
+ {
+ /* We rely upon the below calls the do argument checking */
+ if (decl == NULL_TREE)
+ {
+ sorry ("initialization of array from dissimilar array type");
+ return error_mark_node;
+ }
+ if (init)
+ {
+ base2 = default_conversion (init);
+ itype = TREE_TYPE (base2);
+ base2 = get_temp_regvar (itype, base2);
+ itype = TREE_TYPE (itype);
+ }
+ 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, itype, 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 amount 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,
+ build_tree_list (NULL_TREE, addr));
+ return rval;
+}
+
+/* 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.
+
+ This function does not delete an object's virtual base classes. */
+tree
+build_delete (type, addr, auto_delete, flags, use_global_delete)
+ tree type, addr;
+ tree auto_delete;
+ int flags;
+ int use_global_delete;
+{
+ 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))
+ {
+ /* Call the builtin operator delete. */
+ return build_builtin_call (void_type_node, BID,
+ build_tree_list (NULL_TREE, addr));
+ }
+ if (TREE_SIDE_EFFECTS (addr))
+ addr = save_expr (addr);
+ ref = build_indirect_ref (addr, NULL_PTR);
+ 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 accessible, 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, NULL_PTR);
+ ptr = 0;
+ }
+
+ my_friendly_assert (IS_AGGR_TYPE (type), 220);
+
+ if (! TYPE_NEEDS_DESTRUCTOR (type))
+ {
+ tree virtual_size;
+
+ if (auto_delete == integer_zero_node)
+ return void_zero_node;
+
+ /* Pass the size of the object down to the operator delete() in
+ addition to the ADDR. */
+ if (TREE_GETS_DELETE (type) && !use_global_delete)
+ {
+ /* This is probably wrong. It should be the size of the virtual
+ object being deleted. */
+ tree virtual_size = c_sizeof_nowarn (type);
+ return build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr,
+ virtual_size, NULL_TREE);
+ }
+
+ /* Call the builtin operator delete. */
+ return build_builtin_call (void_type_node, BID,
+ build_tree_list (NULL_TREE, addr));
+ }
+ 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 access_type access = compute_access (basetypes, dtor);
+
+ if (access == access_private)
+ {
+ if (flags & LOOKUP_COMPLAIN)
+ cp_error ("destructor for type `%T' is private in this scope", type);
+ return error_mark_node;
+ }
+ else if (access == access_protected)
+ {
+ if (flags & LOOKUP_COMPLAIN)
+ cp_error ("destructor for type `%T' is protected in this scope", type);
+ 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)))
+ {
+ tree binfo, basetype;
+ /* The code below is probably all broken. See call.c for the
+ complete right way to do this. this offsets may not be right
+ in the below. (mrs) */
+ /* This destructor must be called via virtual function table. */
+ dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (DECL_CONTEXT (dtor)), 0);
+ basetype = DECL_CLASS_CONTEXT (dtor);
+ binfo = get_binfo (basetype,
+ TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))),
+ 0);
+ expr = convert_pointer_to_real (binfo, TREE_VALUE (parms));
+ if (expr != TREE_VALUE (parms))
+ {
+ expr = fold (expr);
+ ref = build_indirect_ref (expr, NULL_PTR);
+ 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,
+ build_tree_list (NULL_TREE, addr)),
+ 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, 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, 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);
+ 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),
+ 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_expr 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, NULL_PTR);
+ maxindex = build_component_ref (cookie, nc_nelts_field_id, 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),
+ 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);
+ body = build1 (NOP_EXPR, void_type_node, body);
+
+ if (controller)
+ {
+ TREE_OPERAND (controller, 1) = body;
+ return controller;
+ }
+ else
+ return convert (void_type_node, body);
+}
--- /dev/null
+/* 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;
+}
--- /dev/null
+/* Separate lexical analyzer for GNU C++.
+ Copyright (C) 1987, 1989, 1992, 1993, 1994 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 "lex.h"
+#include "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'. */
+struct obstack inline_text_obstack;
+static char *inline_text_firstobj;
+
+int end_of_file;
+
+/* Pending language change.
+ Positive is push count, negative is pop count. */
+int pending_lang_change = 0;
+
+/* Wrap the current header file in extern "C". */
+static int c_header_level = 0;
+
+extern int first_token;
+extern struct obstack token_obstack;
+
+/* ??? Don't really know where this goes yet. */
+#if 1
+#include "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;
+\f
+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 void default_copy_constructor_body ();
+static void default_assign_ref_body ();
+\f
+/* 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;
+}
+\f
+/* 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[2] != '_')
+ {
+ 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];
+}
+\f
+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 "hash.h"
+\f
+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;
+}
+\f
+/* 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 "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 "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 "tree.def"
+};
+#undef DEFTREECODE
+\f
+/* 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 ();
+ init_error ();
+ 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;
+ input_filename = "<internal>";
+ 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]));
+ /* This is for ANSI C++. */
+ ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
+ SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
+ build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
+
+ /* 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;
+
+ /* Signature handling extensions. */
+ signature_type_node = build_int_2 (signature_type, 0);
+ TREE_TYPE (signature_type_node) = signature_type_node;
+ ridpointers[(int) RID_SIGNATURE] = signature_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_handle_signatures)
+ {
+ /* Easiest way to not recognize signature
+ handling extensions... */
+ UNSET_RESERVED_WORD ("signature");
+ UNSET_RESERVED_WORD ("sigof");
+ }
+ if (flag_no_asm)
+ UNSET_RESERVED_WORD ("asm");
+ if (flag_no_asm || flag_traditional)
+ UNSET_RESERVED_WORD ("typeof");
+
+ token_count = init_parse ();
+ interface_unknown = 1;
+}
+
+void
+reinit_parse_for_function ()
+{
+ current_base_init_list = NULL_TREE;
+ current_member_init_list = NULL_TREE;
+}
+\f
+#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 SCOPED_NAME:
+ case SCSPEC:
+ case PRE_PARSED_CLASS_DECL:
+ t = yylval.ttype;
+ 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 if (yylval.ttype == signature_type_node)
+ fprintf (file, " `signature'");
+ else
+ my_friendly_abort (80);
+ break;
+ }
+}
+
+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
+\f
+/* 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 = 0;
+
+ if (flag_alt_external_templates)
+ {
+ struct tinst_level *til = tinst_for_decl ();
+
+ if (til)
+ fileinfo = get_time_identifier (til->file);
+ }
+ if (!fileinfo)
+ fileinfo = get_time_identifier (input_filename);
+ fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
+ interface_only = TREE_INT_CST_LOW (fileinfo);
+ if (!processing_template_defn || flag_external_templates)
+ 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_KNOWN (type))
+ {
+ 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;
+ }
+}
+\f
+/* Called from the top level: if there are any pending inlines to
+ do, set up to process them now. This function sets up the first function
+ to be parsed; after it has been, the rule for fndef in cp-parse.y will
+ call process_next_inline to start working on the next one. */
+void
+do_pending_inlines ()
+{
+ struct pending_inline *prev = 0, *tail;
+ struct pending_inline *t;
+
+ /* Oops, we're still dealing with the last batch. */
+ if (yychar == PRE_PARSED_FUNCTION_DECL)
+ return;
+
+ /* 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;
+
+/* Called from the fndecl rule in the parser when the function just parsed
+ was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
+ do_pending_inlines). */
+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. */
+
+static void
+consume_string (this_obstack, matching_char)
+ register struct obstack *this_obstack;
+ int matching_char;
+{
+ register int c;
+ int starting_lineno = lineno;
+ do
+ {
+ c = getch ();
+ if (c == EOF)
+ {
+ int save_lineno = lineno;
+ lineno = starting_lineno;
+ if (matching_char == '"')
+ error ("end of file encountered inside string constant");
+ else
+ error ("end of file encountered inside character constant");
+ lineno = save_lineno;
+ return;
+ }
+ if (c == '\\')
+ {
+ obstack_1grow (this_obstack, c);
+ c = getch ();
+ obstack_1grow (this_obstack, c);
+
+ /* Make sure we continue the loop */
+ c = 0;
+ continue;
+ }
+ if (c == '\n')
+ {
+ if (pedantic)
+ pedwarn ("ANSI C++ forbids newline in string constant");
+ lineno++;
+ }
+ obstack_1grow (this_obstack, c);
+ }
+ while (c != matching_char);
+}
+
+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->lineno = starting_lineno;
+ t->filename = starting_filename;
+ t->token = YYEMPTY;
+ t->token_value = 0;
+ t->buf = buf;
+ t->len = len;
+ t->can_free = 1;
+ t->deja_vu = 0;
+ if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
+ warn_if_unknown_interface ();
+ t->interface = (interface_unknown ? 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;
+ int look_for_lbrac = 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");
+ obstack_1grow (obstackp, '{');
+ }
+ else
+ {
+ obstack_1grow (obstackp, yychar);
+ look_for_lbrac = 1;
+ blev = 0;
+ }
+
+ if (nextchar != EOF)
+ {
+ c = nextchar;
+ nextchar = EOF;
+ }
+ else
+ c = getch ();
+
+ while (c != EOF)
+ {
+ int this_lineno = lineno;
+
+ c = skip_white_space (c);
+
+ /* Don't lose our cool if there are lots of comments. */
+ if (lineno == this_lineno + 1)
+ obstack_1grow (obstackp, '\n');
+ else if (lineno == this_lineno)
+ ;
+ else if (lineno - this_lineno < 10)
+ {
+ 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');
+ }
+
+ while (c > ' ') /* ASCII dependent... */
+ {
+ obstack_1grow (obstackp, c);
+ if (c == '{')
+ {
+ look_for_lbrac = 0;
+ blev++;
+ }
+ else if (c == '}')
+ {
+ blev--;
+ if (blev == 0 && !look_for_semicolon)
+ goto done;
+ }
+ else if (c == '\\')
+ {
+ /* Don't act on the next character...e.g, doing an escaped
+ double-quote. */
+ c = getch ();
+ if (c == EOF)
+ {
+ error_with_file_and_line (starting_filename,
+ starting_lineno,
+ "end of file read inside definition");
+ goto done;
+ }
+ obstack_1grow (obstackp, c);
+ }
+ else if (c == '\"')
+ consume_string (obstackp, c);
+ else if (c == '\'')
+ consume_string (obstackp, c);
+ else if (c == ';')
+ {
+ if (look_for_lbrac)
+ {
+ error (is_template
+ ? "template body missing"
+ : "function body for constructor missing");
+ obstack_1grow (obstackp, '{');
+ obstack_1grow (obstackp, '}');
+ len += 2;
+ goto done;
+ }
+ else if (look_for_semicolon && blev == 0)
+ goto done;
+ }
+ c = getch ();
+ }
+
+ if (c == EOF)
+ {
+ error_with_file_and_line (starting_filename,
+ starting_lineno,
+ "end of file read inside definition");
+ goto done;
+ }
+ else if (c != '\n')
+ {
+ obstack_1grow (obstackp, c);
+ c = getch ();
+ }
+ }
+ 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.
+ When KIND == 5, build default operator = (const X&).
+ When KIND == 6, build default operator = (X&). */
+
+tree
+cons_up_default_function (type, name, fields, kind)
+ tree type, name, fields;
+ int kind;
+{
+ extern tree void_list_node;
+ char *func_buf = NULL;
+ int func_len = 0;
+ tree declspecs = NULL_TREE;
+ tree fn, args;
+ tree argtype;
+ int retref = 0;
+
+ 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;
+ {
+ if (declspecs)
+ declspecs = decl_tree_cons (NULL_TREE,
+ ridpointers [(int) RID_INLINE],
+ declspecs);
+ else
+ declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_INLINE]);
+ }
+ break;
+
+ case 3:
+ type = build_type_variant (type, 1, 0);
+ /* Fall through... */
+ case 4:
+ /* According to ARM $12.8, the default copy ctor will be declared, but
+ not defined, unless it's needed. So we mark this as `inline'; that
+ way, if it's never used it won't be emitted. */
+ declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_INLINE]);
+
+ argtype = build_reference_type (type);
+ args = tree_cons (NULL_TREE,
+ build_tree_list (hash_tree_chain (argtype, NULL_TREE),
+ get_identifier ("_ctor_arg")),
+ void_list_node);
+ default_copy_constructor_body (&func_buf, &func_len, type, fields);
+ break;
+
+ case 5:
+ type = build_type_variant (type, 1, 0);
+ /* Fall through... */
+ case 6:
+ retref = 1;
+ declspecs =
+ decl_tree_cons (NULL_TREE, name,
+ decl_tree_cons (NULL_TREE,
+ ridpointers [(int) RID_INLINE],
+ NULL_TREE));
+
+ name = ansi_opname [(int) MODIFY_EXPR];
+
+ argtype = build_reference_type (type);
+ args = tree_cons (NULL_TREE,
+ build_tree_list (hash_tree_chain (argtype, NULL_TREE),
+ get_identifier ("_ctor_arg")),
+ void_list_node);
+ default_assign_ref_body (&func_buf, &func_len, type, fields);
+ break;
+
+ default:
+ my_friendly_abort (59);
+ }
+
+ if (!func_buf)
+ {
+ func_len = 2;
+ func_buf = obstack_alloc (&inline_text_obstack, func_len);
+ strcpy (func_buf, "{}");
+ }
+
+ TREE_PARMLIST (args) = 1;
+
+ {
+ tree declarator = build_parse_node (CALL_EXPR, name, args, NULL_TREE);
+ if (retref)
+ declarator = build_parse_node (ADDR_EXPR, declarator);
+
+ fn = start_method (declspecs, declarator, NULL_TREE);
+ }
+
+ if (fn == void_type_node)
+ return fn;
+
+ current_base_init_list = NULL_TREE;
+ current_member_init_list = NULL_TREE;
+
+ {
+ struct pending_inline *t;
+
+ t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
+ sizeof (struct pending_inline));
+ t->lineno = lineno;
+
+#if 1
+ t->filename = input_filename;
+#else /* This breaks; why? */
+#define MGMSG "(synthetic code at) "
+ t->filename = obstack_alloc (&inline_text_obstack,
+ strlen (input_filename) + sizeof (MGMSG) + 1);
+ strcpy (t->filename, MGMSG);
+ strcat (t->filename, input_filename);
+#endif
+ t->token = YYEMPTY;
+ t->token_value = 0;
+ t->buf = func_buf;
+ t->len = func_len;
+ t->can_free = 1;
+ t->deja_vu = 0;
+ if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (fn))
+ warn_if_unknown_interface ();
+ t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
+ store_pending_inline (fn, t);
+ if (interface_unknown)
+ TREE_PUBLIC (fn) = 0;
+ else
+ {
+ TREE_PUBLIC (fn) = 1;
+ DECL_EXTERNAL (fn) = interface_only;
+ }
+ }
+
+ finish_method (fn);
+
+#ifdef DEBUG_DEFAULT_FUNCTIONS
+ { char *fn_type = NULL;
+ tree t = name;
+ switch (kind)
+ {
+ case 0: fn_type = "default destructor"; break;
+ case 1: fn_type = "virtual destructor"; break;
+ case 2: fn_type = "default constructor"; break;
+ case 3: fn_type = "default X(const X&)"; break;
+ case 4: fn_type = "default X(X&)"; break;
+ }
+ if (fn_type)
+ {
+ if (TREE_CODE (name) == BIT_NOT_EXPR)
+ t = TREE_OPERAND (name, 0);
+ fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
+ IDENTIFIER_POINTER (t), func_buf);
+ }
+ }
+#endif /* DEBUG_DEFAULT_FUNCTIONS
+
+ DECL_CLASS_CONTEXT (fn) = type;
+
+ /* Show that this function was generated by the compiler. */
+#if 0
+ DECL_SOURCE_LINE (fn) = 0;
+#else
+ DECL_SYNTHESIZED (fn) = 1;
+#endif
+
+ return fn;
+}
+
+/* Used by default_copy_constructor_body. For the anonymous union
+ in TYPE, return the member that is at least as large as the rest
+ of the members, so we can copy it. */
+static tree
+largest_union_member (type)
+ tree type;
+{
+ tree f, type_size = TYPE_SIZE (type);
+
+ for (f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f))
+ if (simple_cst_equal (DECL_SIZE (f), type_size))
+ return f;
+
+ /* We should always find one. */
+ my_friendly_abort (323);
+}
+
+/* Construct the body of a default assignment operator.
+ Mostly copied directly from default_copy_constructor_body. */
+static void
+default_assign_ref_body (bufp, lenp, type, fields)
+ char **bufp;
+ int *lenp;
+ tree type, fields;
+{
+ static struct obstack body;
+ static int inited = FALSE;
+ int n_bases = CLASSTYPE_N_BASECLASSES (type);
+ char *tbuf;
+ int tgot, tneed;
+
+ if (!inited)
+ {
+ obstack_init (&body);
+ inited = TRUE;
+ }
+ body.next_free = body.object_base;
+
+ obstack_1grow (&body, '{');
+
+ /* Small buffer for sprintf(). */
+
+ tgot = 100;
+ tbuf = (char *) alloca (tgot);
+
+ /* If we don't need a real op=, just do a bitwise copy. */
+ if (! TYPE_HAS_COMPLEX_ASSIGN_REF (type))
+ {
+ tbuf = "{__builtin_memcpy(this,&_ctor_arg,sizeof(_ctor_arg));return *this;}";
+ *lenp = strlen (tbuf);
+ *bufp = obstack_alloc (&inline_text_obstack, *lenp + 1);
+ strcpy (*bufp, tbuf);
+ return;
+ }
+
+ if (TREE_CODE (type) == UNION_TYPE)
+ {
+ if (fields)
+ {
+ tree main = fields;
+ char * s;
+ tree f;
+
+ for (f = TREE_CHAIN (fields); f; f = TREE_CHAIN (f))
+ if (tree_int_cst_lt (TYPE_SIZE (TREE_TYPE (main)),
+ TYPE_SIZE (TREE_TYPE (f))))
+ main = f;
+
+ s = IDENTIFIER_POINTER (DECL_NAME (main));
+
+ tneed = (2 * strlen (s)) + 28;
+ if (tgot < tneed)
+ {
+ tgot = tneed;
+ tbuf = (char *) alloca (tgot);
+ }
+
+ sprintf (tbuf, "{%s=_ctor_arg.%s;return *this;}", s, s);
+ }
+ else
+ tbuf = "{}";
+
+ *lenp = strlen (tbuf);
+ *bufp = obstack_alloc (&inline_text_obstack, *lenp + 1);
+ strcpy (*bufp, tbuf);
+ return;
+ }
+
+ /* Construct base classes...
+ FIXME: Does not deal with multiple inheritance and virtual bases
+ correctly. See g++.old-deja/g++.jason/opeq5.C for a testcase.
+ We need to do wacky things if everything between us and the virtual
+ base (by all paths) has a "complex" op=. */
+
+ if (n_bases)
+ {
+ tree bases = TYPE_BINFO_BASETYPES (type);
+ int i = 0;
+
+ for (i = 0; i < n_bases; i++)
+ {
+ tree binfo = TREE_VEC_ELT (bases, i);
+ tree btype, name;
+ char *s, *p;
+
+ btype = BINFO_TYPE (binfo);
+ name = TYPE_NESTED_NAME (btype);
+ if (!name) name = DECL_NAME(TYPE_NAME(btype));
+ s = IDENTIFIER_POINTER (name);
+
+ tneed = (2 * strlen (s)) + 33;
+ if (tgot < tneed)
+ {
+ tgot = tneed;
+ tbuf = (char *) alloca (tgot);
+ }
+
+ sprintf (tbuf, "%s::operator=((%s%s&)_ctor_arg);", s,
+ TYPE_READONLY (type) ? "const " : "", s);
+ obstack_grow (&body, tbuf, strlen (tbuf));
+ }
+ }
+
+ /* Construct fields. */
+
+ if (fields)
+ {
+ tree f;
+
+ for (f = fields; f; f = TREE_CHAIN (f))
+ {
+ if (TREE_CODE (f) == FIELD_DECL && ! DECL_VIRTUAL_P (f))
+ {
+ char *s, *p;
+ tree x;
+ tree t = TREE_TYPE (f);
+
+ if (DECL_NAME (f))
+ x = f;
+ else if (t != NULL_TREE
+ && TREE_CODE (t) == UNION_TYPE
+ && ((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))))
+ && TYPE_FIELDS (t) != NULL_TREE)
+ x = largest_union_member (t);
+ else
+ continue;
+
+ s = IDENTIFIER_POINTER (DECL_NAME (x));
+ tneed = (2 * strlen (s)) + 13;
+ if (tgot < tneed)
+ {
+ tgot = tneed;
+ tbuf = (char *) alloca (tgot);
+ }
+
+ sprintf (tbuf, "%s=_ctor_arg.%s;", s, s);
+ obstack_grow (&body, tbuf, strlen (tbuf));
+ }
+ }
+ }
+
+ obstack_grow (&body, "return *this;}", 15);
+
+ *lenp = obstack_object_size (&body) - 1;
+ *bufp = obstack_alloc (&inline_text_obstack, *lenp);
+
+ strcpy (*bufp, body.object_base);
+}
+
+/* Construct the body of a default copy constructor. */
+static void
+default_copy_constructor_body (bufp, lenp, type, fields)
+ char **bufp;
+ int *lenp;
+ tree type, fields;
+{
+ static struct obstack prologue;
+ static int inited = FALSE;
+ int n_bases = CLASSTYPE_N_BASECLASSES (type);
+ char sep = ':';
+ char *tbuf;
+ int tgot, tneed;
+
+ /* Create a buffer to call base class constructors and construct members
+ (fields). */
+
+ if (!inited)
+ {
+ obstack_init (&prologue);
+ inited = TRUE;
+ }
+ prologue.next_free = prologue.object_base;
+
+ /* If we don't need a real copy ctor, just do a bitwise copy. */
+ if (! TYPE_HAS_COMPLEX_INIT_REF (type))
+ {
+ tbuf = "{__builtin_memcpy(this,&_ctor_arg,sizeof(_ctor_arg));}";
+ *lenp = strlen (tbuf);
+ *bufp = obstack_alloc (&inline_text_obstack, *lenp + 1);
+ strcpy (*bufp, tbuf);
+ return;
+ }
+
+ /* Small buffer for sprintf(). */
+
+ tgot = 100;
+ tbuf = (char *) alloca (tgot);
+
+ if (TREE_CODE (type) == UNION_TYPE)
+ {
+ if (fields)
+ {
+ tree main = fields;
+ char * s;
+ tree f;
+
+ for (f = TREE_CHAIN (fields); f; f = TREE_CHAIN (f))
+ if (tree_int_cst_lt (TYPE_SIZE (TREE_TYPE (main)),
+ TYPE_SIZE (TREE_TYPE (f))))
+ main = f;
+
+ s = IDENTIFIER_POINTER (DECL_NAME (main));
+ tneed = (2 * strlen (s)) + 16;
+ if (tgot < tneed)
+ {
+ tgot = tneed;
+ tbuf = (char *) alloca (tgot);
+ }
+
+ sprintf (tbuf, ":%s(_ctor_arg.%s){}", s, s);
+ }
+ else
+ tbuf = "{}";
+
+ *lenp = strlen (tbuf);
+ *bufp = obstack_alloc (&inline_text_obstack, *lenp + 1);
+ strcpy (*bufp, tbuf);
+ return;
+ }
+
+ /* Construct base classes... */
+
+ if (n_bases)
+ {
+ /* Note that CLASSTYPE_VBASECLASSES isn't set yet... */
+ tree v = get_vbase_types (type);
+ tree bases = TYPE_BINFO_BASETYPES (type);
+ int i = 0;
+
+ for (;;)
+ {
+ tree binfo, btype, name;
+ char *s, *p;
+
+ if (v)
+ {
+ binfo = v;
+ v = TREE_CHAIN (v);
+ }
+ else if (i < n_bases)
+ {
+ binfo = TREE_VEC_ELT (bases, i++);
+ if (TREE_VIA_VIRTUAL (binfo))
+ continue;
+ }
+ else
+ break;
+
+ btype = BINFO_TYPE (binfo);
+ name = TYPE_NESTED_NAME (btype);
+ if (!name) name = DECL_NAME(TYPE_NAME(btype));
+ s = IDENTIFIER_POINTER (name);
+
+ tneed = (2 * strlen (s)) + 30;
+ if (tgot < tneed)
+ {
+ tgot = tneed;
+ tbuf = (char *) alloca (tgot);
+ }
+
+ sprintf (tbuf, "%c%s((%s%s&)_ctor_arg)", sep, s,
+ TYPE_READONLY (type) ? "const " : "", s);
+ sep = ',';
+ obstack_grow (&prologue, tbuf, strlen (tbuf));
+ }
+ }
+
+ /* Construct fields. */
+
+ if (fields)
+ {
+ tree f;
+
+ for (f = fields; f; f = TREE_CHAIN (f))
+ {
+ if (TREE_CODE (f) == FIELD_DECL && ! DECL_VIRTUAL_P (f))
+ {
+ char *s, *p;
+ tree x;
+ tree t = TREE_TYPE (f);
+
+ if (DECL_NAME (f))
+ x = f;
+ else if (t != NULL_TREE
+ && TREE_CODE (t) == UNION_TYPE
+ && ((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))))
+ && TYPE_FIELDS (t) != NULL_TREE)
+ x = largest_union_member (t);
+ else
+ continue;
+
+ s = IDENTIFIER_POINTER (DECL_NAME (x));
+ tneed = (2 * strlen (s)) + 30;
+ if (tgot < tneed)
+ {
+ tgot = tneed;
+ tbuf = (char *) alloca (tgot);
+ }
+
+ sprintf (tbuf, "%c%s(_ctor_arg.%s)", sep, s, s);
+ sep = ',';
+ obstack_grow (&prologue, tbuf, strlen (tbuf));
+ }
+ }
+ }
+
+ /* Concatenate constructor body to prologue. */
+
+ *lenp = obstack_object_size (&prologue) + 2;
+ *bufp = obstack_alloc (&inline_text_obstack, *lenp + 1);
+
+ obstack_1grow (&prologue, '\0');
+
+ strcpy (*bufp, prologue.object_base);
+ strcat (*bufp, "{}");
+}
+
+/* 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 != SCSPEC
+ && 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 ();
+}
+\f
+/* 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;
+}
+\f
+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'))
+ {
+ int warned_interface = 0;
+
+ /* Read to newline. */
+
+ while (c != '\n')
+ {
+ c = getch ();
+ if (!warned_interface && extra_warnings
+ && c != ' ' && c != '\t' && c != '\n')
+ {
+ warning ("garbage after `#pragma interface' ignored");
+ warned_interface = 1;
+ }
+ }
+
+ 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;
+ enum { act_none, act_push, act_pop } action = act_none;
+ int entering_system_header = 0;
+ int entering_c_header = 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);
+
+ 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')
+ {
+ put_back (c);
+
+ token = real_yylex ();
+
+ /* `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)
+ action = act_push;
+ else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
+ action = act_pop;
+
+ if (action)
+ {
+ c = get_last_nonwhite_on_line ();
+ if (c != '\n')
+ {
+ put_back (c);
+ token = real_yylex ();
+ }
+ }
+ }
+
+ /* `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)
+ {
+ entering_system_header = 1;
+
+ c = get_last_nonwhite_on_line ();
+ if (c != '\n')
+ {
+ put_back (c);
+ token = real_yylex ();
+ }
+ }
+
+ /* `4' after file name means this is a C header file. */
+
+ if (token == CONSTANT
+ && TREE_CODE (yylval.ttype) == INTEGER_CST
+ && TREE_INT_CST_LOW (yylval.ttype) == 4)
+ {
+ entering_c_header = 1;
+
+ c = get_last_nonwhite_on_line ();
+ if (c != '\n')
+ {
+ put_back (c);
+ token = real_yylex ();
+ }
+ }
+
+ /* Do the actions implied by the preceeding numbers. */
+
+ if (action == act_push)
+ {
+ /* Pushing to a new file. */
+ struct file_stack *p;
+
+ 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 */
+ if (flag_cadillac)
+ cadillac_push_source ();
+ in_system_header = entering_system_header;
+ if (c_header_level)
+ ++c_header_level;
+ else if (entering_c_header)
+ {
+ c_header_level = 1;
+ ++pending_lang_change;
+ }
+ }
+ else if (action == act_pop)
+ {
+ /* Popping out of a file. */
+ if (input_file_stack->next)
+ {
+ struct file_stack *p;
+
+ if (c_header_level && --c_header_level == 0)
+ {
+ if (entering_c_header)
+ warning ("Badly nested C headers from preprocessor");
+ --pending_lang_change;
+ }
+ if (flag_cadillac)
+ cadillac_pop_source ();
+ in_system_header = entering_system_header;
+
+ p = input_file_stack;
+ 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");
+ }
+ else
+ {
+ in_system_header = entering_system_header;
+ if (flag_cadillac)
+ cadillac_switch_source (-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;
+}
+
+void
+do_pending_lang_change ()
+{
+ for (; pending_lang_change > 0; --pending_lang_change)
+ push_lang_context (lang_name_c);
+ for (; pending_lang_change < 0; ++pending_lang_change)
+ pop_lang_context ();
+}
+\f
+#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)))
+ pedwarn ("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 '[':
+ /* `\%' is used to prevent SCCS from getting confused. */
+ 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
+ {
+ cp_error ("invalid use of member `%D' from base class `%T'", field,
+ 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)
+ {
+ cp_error ("`%D' was not declared in this scope", 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;
+
+ cp_error ("`%D' undeclared (first use this function)", 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 access. */
+ enum access_type access
+ = compute_access (TYPE_BINFO (current_class_type), id);
+ if (access == access_private)
+ cp_error ("enum `%D' is private", id);
+ /* 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 ()
+{
+ 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 (c == '$' && ! dollars_in_ident)
+ break;
+ if (p >= token_buffer + maxtoken)
+ p = extend_token_buffer (p);
+
+ *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 (c == '$' && ! dollars_in_ident)
+ break;
+ if (p >= token_buffer + maxtoken)
+ p = extend_token_buffer (p);
+
+ *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 = access_public;
+ break;
+ case RID_PRIVATE:
+ yylval.itype = access_private;
+ break;
+ case RID_PROTECTED:
+ yylval.itype = access_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 (strcmp ("catch", token_buffer) == 0
+ || strcmp ("throw", token_buffer) == 0
+ || strcmp ("try", token_buffer) == 0)
+ pedwarn ("`catch', `throw', and `try' are all C++ reserved words");
+
+ if (value == IDENTIFIER || value == TYPESPEC)
+ GNU_xref_ref (current_function_decl, token_buffer);
+
+ if (value == IDENTIFIER)
+ {
+ register tree 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;
+
+ /* 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++). */
+ /* Note we go right after the local value for the identifier
+ (e.g., __FUNCTION__ or __PRETTY_FUNCTION__). We used to
+ call lookup_name, but that could result in an error about
+ ambiguities. */
+ tmp = IDENTIFIER_LOCAL_VALUE (yylval.ttype);
+ 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;
+ }
+ }
+ 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 actually store only HOST_BITS_PER_CHAR bits in each part.
+ The number of parts is chosen so as to be sufficient to hold
+ the enough bits to fit into the two HOST_WIDE_INTs that contain
+ the integer value (this is always at least as many bits as are
+ in a target `long long' value, but may be wider). */
+#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
+ int parts[TOTAL_PARTS];
+ int overflow = 0;
+
+ enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
+ = NOT_FLOAT;
+
+ p = token_buffer;
+ *p++ = c;
+
+ for (count = 0; count < TOTAL_PARTS; count++)
+ parts[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 < TOTAL_PARTS; count++)
+ {
+ parts[count] *= base;
+ if (count)
+ {
+ parts[count]
+ += (parts[count-1] >> HOST_BITS_PER_CHAR);
+ parts[count-1]
+ &= (1 << HOST_BITS_PER_CHAR) - 1;
+ }
+ else
+ parts[0] += c;
+ }
+
+ /* If the extra highest-order part ever gets anything in it,
+ the number is certainly too big. */
+ if (parts[TOTAL_PARTS - 1] != 0)
+ overflow = 1;
+
+ 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;
+ 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));
+ garbage_chars = -1;
+ break;
+
+ case 'l': case 'L':
+ type = long_double_type_node;
+ value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
+ garbage_chars = -1;
+ break;
+
+ default:
+ value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
+ }
+ set_float_handler (NULL_PTR);
+ }
+ if (pedantic
+ && (REAL_VALUE_ISINF (value)
+#ifdef ERANGE
+ || (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
+ && errno == ERANGE
+ /* ERANGE is also reported for underflow, so test the
+ value to distinguish overflow from that. */
+ && (REAL_VALUES_LESS (dconst1, value)
+ || REAL_VALUES_LESS (value, dconstm1)))
+#endif
+ ))
+ {
+ pedwarn ("floating point number exceeds range of `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ }
+ /* 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;
+ int bytes, warn;
+
+ 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);
+
+ /* If the constant is not long long and it won't fit in an
+ unsigned long, or if the constant is long long and won't fit
+ in an unsigned long long, then warn that the constant is out
+ of range. */
+
+ /* ??? This assumes that long long and long integer types are
+ a multiple of 8 bits. This better than the original code
+ though which assumed that long was exactly 32 bits and long
+ long was exactly 64 bits. */
+
+ if (spec_long_long)
+ bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
+ else
+ bytes = TYPE_PRECISION (long_integer_type_node) / 8;
+
+ warn = overflow;
+ for (i = bytes; i < TOTAL_PARTS; i++)
+ if (parts[i])
+ warn = 1;
+ if (warn)
+ pedwarn ("integer constant out of range");
+
+ /* This is simplified by the fact that our constant
+ is always positive. */
+ high = low = 0;
+
+ for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
+ {
+ high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
+ / HOST_BITS_PER_CHAR)]
+ << (i * HOST_BITS_PER_CHAR));
+ low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
+ }
+
+
+ yylval.ttype = build_int_2 (low, high);
+ TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
+
+#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
+ /* Verify value does not overflow into sign bit. */
+ && TREE_INT_CST_HIGH (yylval.ttype) >= 0
+ && 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");
+
+ if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
+ warning ("decimal integer constant is so large that it is unsigned");
+ }
+#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 (num_bits == 0)
+ /* We already got an error; avoid invalid shift. */
+ yylval.ttype = build_int_2 (0, 0);
+ else 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 == '*')
+ {
+ 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);
+ SET_CLASSTYPE_INTERFACE_UNKNOWN_X (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");
+}
+\f
+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);
+}
--- /dev/null
+/* 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,
+ RID_MUTABLE,
+ RID_SIGNATURE,
+ /* Before adding enough to get up to 64, the RIDBIT_* macros
+ will have to be changed a little. */
+ RID_MAX
+};
+
+#define NORID RID_UNUSED
+
+#define RID_FIRST_MODIFIER RID_EXTERN
+
+/* The type that can represent all values of RIDBIT. */
+/* We assume that we can stick in at least 32 bits into this. */
+typedef struct { unsigned long idata[2]; }
+ RID_BIT_TYPE;
+
+/* Be careful, all these modify N twice. */
+#define RIDBIT_SETP(N, V) (((unsigned long)1 << (int) ((N)%32)) \
+ & (V).idata[(N)/32])
+#define RIDBIT_NOTSETP(NN, VV) (! RIDBIT_SETP (NN, VV))
+#define RIDBIT_SET(N, V) do { \
+ (V).idata[(N)/32] \
+ |= ((unsigned long)1 << (int) ((N)%32)); \
+ } while (0)
+#define RIDBIT_RESET(N, V) do { \
+ (V).idata[(N)/32] \
+ &= ~((unsigned long)1 << (int) ((N)%32)); \
+ } while (0)
+#define RIDBIT_RESET_ALL(V) do { \
+ (V).idata[0] = 0; \
+ (V).idata[1] = 0; \
+ } while (0)
+#define RIDBIT_ANY_SET(V) ((V).idata[0] || (V).idata[1])
+
+/* 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;
+
+/* Pending language change.
+ Positive is push count, negative is pop count. */
+extern int pending_lang_change;
+
+extern tree make_pointer_declarator (), make_reference_declarator ();
+extern void reinit_parse_for_function ();
+extern void reinit_parse_for_method ();
+extern int yylex ();
--- /dev/null
+/* 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 "class.h"
+#include "obstack.h"
+#include <ctype.h>
+
+/* TREE_LIST of the current inline functions that need to be
+ processed. */
+struct pending_inline *pending_inlines;
+
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+
+/* 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'))
+
+#ifdef NO_AUTO_OVERLOAD
+int is_overloaded ();
+#endif
+
+void
+init_method ()
+{
+ gcc_obstack_init (&scratch_obstack);
+ scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
+}
+
+/* This must be large enough to hold any printed integer or floating-point
+ value. */
+static char digit_buffer[128];
+
+/* 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);
+ }
+}
+\f
+/* 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)
+ struct candidate *cp;
+ tree parmtypes;
+ char *name_kind;
+{
+ 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);
+ cp_error ("type unification failed for function template `%#D'",
+ cp->function);
+ return;
+
+ case -3:
+ if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))))
+ cp_error ("call to const %s `%#D' with non-const object", name_kind,
+ cp->function);
+ else
+ cp_error ("call to non-const %s `%#D' with const object", name_kind,
+ cp->function);
+ return;
+ case -2:
+ cp_error ("too few arguments for %s `%#D'", name_kind, cp->function);
+ return;
+ case -1:
+ cp_error ("too many arguments for %s `%#D'", name_kind, cp->function);
+ 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 `");
+ OB_PUTCP (decl_as_string (cp->function, 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);
+ OB_PUTCP (type_as_string (TREE_TYPE (TREE_VALUE (tta)), 1));
+ }
+ }
+ 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);
+}
+\f
+/* 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
+ || TREE_CODE (value) == NOP_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 template 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 (TYPE_PTRMEMFUNC_P (parmtype))
+ parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
+
+ 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');
+ if (i > 9)
+ OB_PUTC ('_');
+ icat (i);
+ if (i > 9)
+ OB_PUTC ('_');
+ 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);
+}
+\f
+/* 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));
+}
+\f
+/* 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
+ {
+ tree this_type = TREE_VALUE (parms);
+
+ if (TREE_CODE (this_type) == RECORD_TYPE) /* a signature pointer */
+ parms = temp_tree_cons (NULL_TREE, SIGNATURE_TYPE (this_type),
+ TREE_CHAIN (parms));
+ else
+ parms = temp_tree_cons (NULL_TREE, TREE_TYPE (this_type),
+ 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);
+ }
+ {
+ tree n = get_identifier (obstack_base (&scratch_obstack));
+ if (IDENTIFIER_OPNAME_P (dname))
+ IDENTIFIER_OPNAME_P (n) = 1;
+ return n;
+ }
+}
+
+/* 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
+\f
+/* 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 LOOKUP_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:
+ {
+ 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);
+
+ rval = build_method_call
+ (build_indirect_ref (build1 (NOP_EXPR, xarg1, error_mark_node),
+ "new"),
+ 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:
+ {
+ 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);
+
+ rval = build_method_call
+ (build_indirect_ref (build1 (NOP_EXPR, TREE_TYPE (xarg1),
+ error_mark_node),
+ NULL_PTR),
+ 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) || TYPE_PTRMEMFUNC_P (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,
+ (struct candidate *)0);
+ }
+
+ return rval;
+}
+\f
+/* 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
+ && !TYPE_PTRMEMFUNC_P (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_LANG_SPECIFIC (value)
+ && DECL_CLASS_CONTEXT (value) != current_class_type)
+ {
+ tree path;
+ enum access_type access;
+ 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);
+ if (path)
+ {
+ access = compute_access (path, value);
+ if (access != access_public)
+ {
+ if (TREE_CODE (value) == VAR_DECL)
+ error ("static member `%s' is %s",
+ IDENTIFIER_POINTER (name),
+ TREE_PRIVATE (value) ? "private" :
+ "from a private base class");
+ 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;
+}
+
+\f
+/* 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);
+
+ last = groktypename (build_tree_list (TREE_TYPE (component),
+ TREE_OPERAND (component, 0)));
+ name = build_typename_overload (last);
+ TREE_TYPE (name) = last;
+
+ if (TREE_OPERAND (tmp, 0)
+ && TREE_OPERAND (tmp, 0) != void_list_node)
+ {
+ cp_error ("`operator %T' requires empty parameter list", last);
+ TREE_OPERAND (tmp, 0) = NULL_TREE;
+ }
+
+ 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)
+ {
+ cp_error ("object required for `operator %T' call",
+ TREE_TYPE (name));
+ return error_mark_node;
+ }
+
+ this_this = convert_pointer_to (TREE_TYPE (of),
+ current_class_decl);
+ this_this = build_indirect_ref (this_this, NULL_PTR);
+ 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);
+
+ cp_error ("object required for `operator %T' call",
+ TREE_TYPE (name));
+ 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)
+ {
+ cp_error ("object required for `operator %T' call",
+ TREE_TYPE (name));
+ 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);
+
+ cp_error ("object required for `operator %T' member reference",
+ TREE_TYPE (name));
+ return error_mark_node;
+}
--- /dev/null
+/* YACC parser for C++ syntax.
+ Copyright (C) 1988, 1989, 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 grammar is based on the GNU CC grammar. */
+
+/* Note: Bison automatically applies a default action of "$$ = $1" for
+ all derivations; this is applied before the explicit action, if one
+ is given. Keep this in mind when reading the actions. */
+
+/* Also note: this version contains experimental exception
+ handling features. They could break, change, disappear,
+ or otherwise exhibit volatile behavior. Don't depend on
+ me (Michael Tiemann) to protect you from any negative impact
+ this may have on your professional, personal, or spiritual life.
+
+ NEWS FLASH: This version now supports the exception handling
+ syntax of Stroustrup's 2nd edition, if -fansi-exceptions is given.
+ THIS IS WORK IN PROGRESS!!! The type of the 'throw' and the
+ 'catch' much match EXACTLY (no inheritance support or coercions).
+ Also, throw-specifications of functions don't work.
+ Destructors aren't called correctly. Etc, etc. --Per Bothner.
+ */
+
+%{
+#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 "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;
+}
+%}
+
+%start program
+
+%union {long itype; tree ttype; char *strtype; enum tree_code code; }
+
+/* All identifiers that are not reserved words
+ and are not declared typedefs in the current block */
+%token IDENTIFIER
+
+/* All identifiers that are declared typedefs in the current block.
+ In some contexts, they are treated just like IDENTIFIER,
+ but they can also serve as typespecs in declarations. */
+%token TYPENAME
+
+/* Qualified identifiers that end in a TYPENAME. */
+%token SCOPED_TYPENAME
+
+/* Qualified identifiers that end in a IDENTIFIER. */
+%token SCOPED_NAME
+
+/* Reserved words that specify storage class.
+ yylval contains an IDENTIFIER_NODE which indicates which one. */
+%token SCSPEC
+
+/* Reserved words that specify type.
+ yylval contains an IDENTIFIER_NODE which indicates which one. */
+%token TYPESPEC
+
+/* Reserved words that qualify type: "const" or "volatile".
+ yylval contains an IDENTIFIER_NODE which indicates which one. */
+%token TYPE_QUAL
+
+/* Character or numeric constants.
+ yylval is the node for the constant. */
+%token CONSTANT
+
+/* String constants in raw form.
+ yylval is a STRING_CST node. */
+%token STRING
+
+/* "...", used for functions with variable arglists. */
+%token ELLIPSIS
+
+/* the reserved words */
+/* SCO include files test "ASM", so use something else. */
+%token SIZEOF ENUM /* STRUCT UNION */ IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
+%token BREAK CONTINUE RETURN GOTO ASM_KEYWORD GCC_ASM_KEYWORD TYPEOF ALIGNOF
+%token HEADOF CLASSOF SIGOF
+%token ATTRIBUTE EXTENSION LABEL
+
+/* the reserved words... C++ extensions */
+%token <ttype> AGGR
+%token <itype> VISSPEC
+%token DELETE NEW OVERLOAD THIS OPERATOR
+%token LEFT_RIGHT TEMPLATE
+%token TYPEID DYNAMIC_CAST
+%token <itype> SCOPE
+
+/* Special token created by the lexer to separate TYPENAME
+ from an ABSDCL. This allows us to parse `foo (*pf)()'. */
+
+%token START_DECLARATOR
+
+/* Define the operator tokens and their precedences.
+ The value is an integer because, if used, it is the tree code
+ to use in the expression made from the operator. */
+
+%left EMPTY /* used to resolve s/r with epsilon */
+
+%left error
+
+/* Add precedence rules to solve dangling else s/r conflict */
+%nonassoc IF
+%nonassoc ELSE
+
+%left IDENTIFIER TYPENAME PTYPENAME TYPENAME_COLON SCSPEC TYPESPEC TYPE_QUAL ENUM AGGR ELLIPSIS
+
+%left '{' ',' ';'
+
+%right <code> ASSIGN '='
+%right <code> '?' ':' RANGE
+%left <code> OROR
+%left <code> ANDAND
+%left <code> '|'
+%left <code> '^'
+%left <code> '&'
+%left <code> MIN_MAX
+%left <code> EQCOMPARE
+%left <code> ARITHCOMPARE '<' '>'
+%left <code> LSHIFT RSHIFT
+%left <code> '+' '-'
+%left <code> '*' '/' '%'
+%right <code> UNARY PLUSPLUS MINUSMINUS
+%left HYPERUNARY
+%left <ttype> PAREN_STAR_PAREN LEFT_RIGHT
+%left <code> POINTSAT POINTSAT_STAR '.' DOT_STAR '(' '['
+
+%right SCOPE /* C++ extension */
+%nonassoc NEW DELETE RAISE RAISES RERAISE TRY EXCEPT CATCH THROW
+%nonassoc ANSI_TRY ANSI_THROW
+
+%type <code> unop
+
+%type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist
+%type <ttype> optional_identifier paren_expr_or_null
+%type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
+%type <ttype> typed_declspecs reserved_declspecs
+%type <ttype> typed_typespecs reserved_typespecquals
+%type <ttype> declmods typespec typespecqual_reserved
+%type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
+%type <itype> initdecls notype_initdecls initdcl /* C++ modification */
+%type <ttype> init initlist maybeasm
+%type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
+%type <ttype> maybe_attribute attribute_list attrib
+%type <ttype> abs_member_declarator after_type_member_declarator
+
+%type <ttype> compstmt except_stmts ansi_except_stmts implicitly_scoped_stmt
+
+%type <ttype> declarator notype_declarator after_type_declarator
+
+%type <ttype> structsp opt.component_decl_list component_decl_list
+%type <ttype> component_decl components component_declarator
+%type <ttype> enumlist enumerator
+%type <ttype> typename absdcl absdcl1 type_quals abs_or_notype_decl
+%type <ttype> xexpr see_typename parmlist parms parm bad_parm
+%type <ttype> identifiers_or_typenames
+
+/* C++ extensions */
+%type <ttype> typename_scope
+%token <ttype> TYPENAME_COLON TYPENAME_ELLIPSIS
+%token <ttype> PTYPENAME SCOPED_TYPENAME SCOPED_NAME
+%token <ttype> PRE_PARSED_FUNCTION_DECL EXTERN_LANG_STRING ALL
+%token <ttype> PRE_PARSED_CLASS_DECL
+%type <ttype> fn.def1 /* Not really! */
+%type <ttype> fn.def2 return_id
+%type <ttype> named_class_head named_class_head_sans_basetype
+%type <ttype> unnamed_class_head
+%type <ttype> class_head base_class_list
+%type <itype> base_class_access_list
+%type <ttype> base_class maybe_base_class_list base_class.1
+%type <ttype> after_type_declarator_no_typename
+%type <ttype> maybe_raises raise_identifier raise_identifiers ansi_raise_identifier ansi_raise_identifiers
+%type <ttype> component_declarator0 id_scope scoped_typename scoped_base_class
+%type <ttype> forhead.1 identifier_or_opname operator_name
+%type <ttype> new delete object object_star aggr
+/* %type <ttype> primary_no_id */
+%type <ttype> nonmomentary_expr
+%type <itype> forhead.2 initdcl0 notype_initdcl0 member_init_list
+%type <itype> .scope try ansi_try
+%type <ttype> template_header template_parm_list template_parm
+%type <ttype> template_type template_arg_list template_arg
+%type <ttype> template_instantiation template_type_name tmpl.1 tmpl.2
+%type <ttype> template_instantiate_once template_instantiate_some
+%type <itype> fn_tmpl_end
+/* %type <itype> try_for_typename */
+%type <ttype> condition partially_scoped_stmt xcond paren_cond_or_null
+%type <strtype> .kindof_pushlevel
+
+/* in order to recognize aggr tags as defining and thus shadowing. */
+%token TYPENAME_DEFN IDENTIFIER_DEFN PTYPENAME_DEFN
+%type <ttype> named_class_head_sans_basetype_defn
+%type <ttype> identifier_defn IDENTIFIER_DEFN TYPENAME_DEFN PTYPENAME_DEFN
+
+%type <strtype> .pushlevel
+
+/* cp-spew.c depends on this being the last token. Define
+ any new tokens before this one! */
+%token END_OF_SAVED_INPUT
+\f
+%{
+/* 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));
+%}
+\f
+%%
+program: /* empty */
+ | extdefs
+ {
+ /* In case there were missing closebraces,
+ get us back to the global binding level. */
+ while (! global_bindings_p ())
+ poplevel (0, 0, 0);
+ finish_file ();
+ }
+ ;
+
+/* the reason for the strange actions in this rule
+ is so that notype_initdecls when reached via datadef
+ can find a valid list of type and sc specs in $0. */
+
+extdefs:
+ { $<ttype>$ = NULL_TREE; } lang_extdef
+ { $<ttype>$ = NULL_TREE; }
+ | extdefs lang_extdef
+ { $<ttype>$ = NULL_TREE; }
+ ;
+
+.hush_warning:
+ { have_extern_spec = 1;
+ used_extern_spec = 0;
+ $<ttype>$ = NULL_TREE; }
+ ;
+.warning_ok:
+ { have_extern_spec = 0; }
+ ;
+
+asm_keyword:
+ ASM_KEYWORD { if (pedantic)
+ pedwarn ("ANSI C++ forbids use of `asm' keyword"); }
+ | GCC_ASM_KEYWORD
+ ;
+
+lang_extdef:
+ { if (pending_lang_change) do_pending_lang_change(); }
+ extdef
+ ;
+
+extdef:
+ fndef
+ { if (pending_inlines) do_pending_inlines (); }
+ | datadef
+ { if (pending_inlines) do_pending_inlines (); }
+ | template_def
+ { if (pending_inlines) do_pending_inlines (); }
+ | overloaddef
+ | asm_keyword '(' string ')' ';'
+ { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
+ assemble_asm ($3); }
+ | extern_lang_string '{' extdefs '}'
+ { pop_lang_context (); }
+ | extern_lang_string '{' '}'
+ { pop_lang_context (); }
+ | extern_lang_string .hush_warning fndef .warning_ok
+ { if (pending_inlines) do_pending_inlines ();
+ pop_lang_context (); }
+ | extern_lang_string .hush_warning datadef .warning_ok
+ { if (pending_inlines) do_pending_inlines ();
+ pop_lang_context (); }
+ ;
+
+extern_lang_string:
+ EXTERN_LANG_STRING
+ { push_lang_context ($1); }
+ ;
+
+template_header:
+ TEMPLATE '<'
+ { begin_template_parm_list (); }
+ template_parm_list '>'
+ { $$ = end_template_parm_list ($4); }
+ ;
+
+template_parm_list:
+ template_parm
+ { $$ = process_template_parm (NULL_TREE, $1); }
+ | template_parm_list ',' template_parm
+ { $$ = process_template_parm ($1, $3); }
+ ;
+
+template_parm:
+ /* The following rules introduce a new reduce/reduce
+ conflict: they are valid prefixes for a `structsp',
+ which means they could match a nameless parameter.
+ By putting them before the `parm' rule, we get
+ their match before considering them nameless parameter
+ declarations. */
+ aggr identifier
+ {
+ if ($1 == signature_type_node)
+ sorry ("signature as template type parameter");
+ else if ($1 != class_type_node)
+ error ("template type parameter must use keyword `class'");
+ $$ = build_tree_list ($2, NULL_TREE);
+ }
+ | aggr identifier_defn ':' base_class.1
+ {
+ if ($1 == signature_type_node)
+ sorry ("signature as template type parameter");
+ else if ($1 != class_type_node)
+ error ("template type parameter must use keyword `class'");
+ warning ("restricted template type parameters not yet implemented");
+ $$ = build_tree_list ($2, $4);
+ }
+ | aggr TYPENAME_COLON base_class.1
+ {
+ if ($1 == signature_type_node)
+ sorry ("signature as template type parameter");
+ else if ($1 != class_type_node)
+ error ("template type parameter must use keyword `class'");
+ warning ("restricted template type parameters not yet implemented");
+ $$ = build_tree_list ($2, $3);
+ }
+ | parm
+ ;
+
+overloaddef:
+ OVERLOAD ov_identifiers ';'
+ { warning ("use of `overload' is an anachronism"); }
+ ;
+
+ov_identifiers: IDENTIFIER
+ { declare_overloaded ($1); }
+ | ov_identifiers ',' IDENTIFIER
+ { declare_overloaded ($3); }
+ ;
+
+template_def:
+ /* Class template declarations go here; they aren't normal class
+ declarations, because we can't process the bodies yet. */
+ template_header named_class_head_sans_basetype '{'
+ { yychar = '{'; goto template1; }
+ ';'
+ | template_header named_class_head_sans_basetype_defn '{'
+ { yychar = '{'; goto template1; }
+ ';'
+ | template_header named_class_head_sans_basetype ':'
+ { yychar = ':'; goto template1; }
+ ';'
+ | template_header named_class_head_sans_basetype_defn ':'
+ {
+ yychar = ':';
+ template1:
+ if (current_aggr == exception_type_node)
+ error ("template type must define an aggregate or union");
+ else if (current_aggr == signature_type_node)
+ sorry ("template type defining a signature");
+ /* Maybe pedantic warning for union?
+ How about an enum? :-) */
+ end_template_decl ($1, $2, current_aggr);
+ reinit_parse_for_template (yychar, $1, $2);
+ yychar = YYEMPTY;
+ }
+ ';'
+ | template_header named_class_head_sans_basetype ';'
+ {
+ end_template_decl ($1, $2, current_aggr);
+ /* declare $2 as template name with $1 parm list */
+ }
+ | template_header named_class_head_sans_basetype_defn ';'
+ {
+ end_template_decl ($1, $2, current_aggr);
+ /* declare $2 as template name with $1 parm list */
+ }
+ | template_header /* notype_initdcl0 ';' */
+ notype_declarator maybe_raises maybeasm maybe_attribute
+ fn_tmpl_end
+ {
+ tree d;
+ int momentary;
+ momentary = suspend_momentary ();
+ d = start_decl ($<ttype>2, /*current_declspecs*/NULL_TREE, 0, $3);
+ cplus_decl_attributes (d, $5);
+ finish_decl (d, NULL_TREE, $4, 0);
+ end_template_decl ($1, d, 0);
+ if ($6 != ';')
+ reinit_parse_for_template ((int) $6, $1, d);
+ resume_momentary (momentary);
+ }
+ | template_header typed_declspecs /*initdcl0*/
+ declarator maybe_raises maybeasm maybe_attribute
+ fn_tmpl_end
+ {
+ tree d;
+ int momentary;
+
+ current_declspecs = $2;
+ momentary = suspend_momentary ();
+ d = start_decl ($<ttype>3, current_declspecs,
+ 0, $<ttype>4);
+ cplus_decl_attributes (d, $6);
+ finish_decl (d, NULL_TREE, $5, 0);
+ end_exception_decls ();
+ end_template_decl ($1, d, 0);
+ if ($7 != ';')
+ {
+ reinit_parse_for_template ((int) $7, $1, d);
+ yychar = YYEMPTY;
+ }
+ note_list_got_semicolon ($<ttype>2);
+ resume_momentary (momentary);
+ }
+ | template_header declmods declarator fn_tmpl_end
+ {
+ tree d = start_decl ($<ttype>3, $<ttype>2, 0, NULL_TREE);
+ finish_decl (d, NULL_TREE, NULL_TREE, 0);
+ end_template_decl ($1, d, 0);
+ if ($4 != ';')
+ reinit_parse_for_template ((int) $4, $1, d);
+ }
+ /* Try to recover from syntax errors in templates. */
+ | template_header error '}' { end_template_decl ($1, 0, 0); }
+ | template_header error ';' { end_template_decl ($1, 0, 0); }
+ ;
+
+fn_tmpl_end: '{' { $$ = '{'; }
+ | ':' { $$ = ':'; }
+ | ';' { $$ = ';'; }
+ | '=' { $$ = '='; }
+ | RETURN { $$ = RETURN; }
+ ;
+
+datadef:
+ notype_initdecls ';'
+ { 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"); }
+ | declmods notype_initdecls ';'
+ {}
+ /* Normal case to make fast: "int i;". */
+ | declmods declarator ';'
+ { tree d;
+ d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE);
+ finish_decl (d, NULL_TREE, NULL_TREE, 0);
+ }
+ | typed_declspecs initdecls ';'
+ {
+ end_exception_decls ();
+ note_list_got_semicolon ($<ttype>$);
+ }
+ /* Normal case: make this fast. */
+ | typed_declspecs declarator ';'
+ { tree d;
+ d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE);
+ finish_decl (d, NULL_TREE, NULL_TREE, 0);
+ end_exception_decls ();
+ note_list_got_semicolon ($<ttype>$);
+ }
+ | declmods ';'
+ { pedwarn ("empty declaration"); }
+ | explicit_instantiation ';'
+ | typed_declspecs ';'
+ {
+ tree t = $<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");
+ }
+ else if (TREE_CODE (t) == ENUMERAL_TYPE
+ && !TYPE_SIZE (t))
+ cp_error ("forward declaration of `%#T'", t);
+ else if (TREE_CODE (t) == IDENTIFIER_NODE)
+ {
+ tree v = lookup_name (t, 1);
+ cp_error ("abstract declarator `%T' used as declaration",
+ v);
+ }
+ }
+ note_list_got_semicolon ($<ttype>$);
+ }
+ | error ';'
+ | error '}'
+ | ';'
+ ;
+
+fndef:
+ fn.def1 base_init compstmt_or_error
+ {
+ 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 ($<ttype>$) process_next_inline ($<ttype>$);
+ }
+ | fn.def1 return_init base_init compstmt_or_error
+ {
+ 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 ($<ttype>$) process_next_inline ($<ttype>$);
+ }
+ | fn.def1 nodecls compstmt_or_error
+ { finish_function (lineno, 0);
+ if ($<ttype>$) process_next_inline ($<ttype>$); }
+ | fn.def1 return_init ';' nodecls compstmt_or_error
+ { finish_function (lineno, 0);
+ if ($<ttype>$) process_next_inline ($<ttype>$); }
+ | fn.def1 return_init nodecls compstmt_or_error
+ { finish_function (lineno, 0);
+ if ($<ttype>$) process_next_inline ($<ttype>$); }
+ | typed_declspecs declarator error
+ {}
+ | declmods notype_declarator error
+ {}
+ | notype_declarator error
+ {}
+ ;
+
+fn.def1:
+ typed_declspecs declarator maybe_raises
+ { if (! start_function ($$, $2, $3, 0))
+ YYERROR1;
+ reinit_parse_for_function ();
+ $$ = NULL_TREE; }
+ | declmods notype_declarator maybe_raises
+ { if (! start_function ($$, $2, $3, 0))
+ YYERROR1;
+ reinit_parse_for_function ();
+ $$ = NULL_TREE; }
+ | notype_declarator maybe_raises
+ { if (! start_function (NULL_TREE, $$, $2, 0))
+ YYERROR1;
+ reinit_parse_for_function ();
+ $$ = NULL_TREE; }
+ | TYPENAME '(' parmlist ')' type_quals maybe_raises
+ { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, $3, $5), $6, 0))
+ YYERROR1;
+ reinit_parse_for_function ();
+ $$ = NULL_TREE; }
+ | scoped_typename '(' parmlist ')' type_quals maybe_raises
+ { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, $3, $5), $6, 0))
+ YYERROR1;
+ reinit_parse_for_function ();
+ $$ = NULL_TREE; }
+ | TYPENAME LEFT_RIGHT type_quals maybe_raises
+ { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, empty_parms (), $3), $4, 0))
+ YYERROR1;
+ reinit_parse_for_function ();
+ $$ = NULL_TREE; }
+ | scoped_typename LEFT_RIGHT type_quals maybe_raises
+ { if (! start_function (NULL_TREE, build_parse_node (CALL_EXPR, $$, empty_parms (), $3), $4, 0))
+ YYERROR1;
+ reinit_parse_for_function ();
+ $$ = NULL_TREE; }
+ | PRE_PARSED_FUNCTION_DECL
+ { start_function (NULL_TREE, TREE_VALUE ($$), NULL_TREE, 1);
+ reinit_parse_for_function (); }
+ ;
+
+/* more C++ complexity */
+fn.def2:
+ typed_declspecs '(' parmlist ')' type_quals maybe_raises
+ {
+ tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), $3, $5);
+ $$ = start_method (TREE_CHAIN ($$), decl, $6);
+ if (! $$)
+ YYERROR1;
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ reinit_parse_for_method (yychar, $$); }
+ | typed_declspecs LEFT_RIGHT type_quals maybe_raises
+ {
+ tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), empty_parms (), $3);
+ $$ = start_method (TREE_CHAIN ($$), decl, $4);
+ if (! $$)
+ YYERROR1;
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ reinit_parse_for_method (yychar, $$); }
+ | typed_declspecs declarator maybe_raises
+ { $$ = start_method ($$, $2, $3);
+ if (! $$)
+ YYERROR1;
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ reinit_parse_for_method (yychar, $$); }
+ | declmods '(' parmlist ')' type_quals maybe_raises
+ {
+ tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), $3, $5);
+ $$ = start_method (TREE_CHAIN ($$), decl, $6);
+ if (! $$)
+ YYERROR1;
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ reinit_parse_for_method (yychar, $$); }
+ | declmods LEFT_RIGHT type_quals maybe_raises
+ {
+ tree decl = build_parse_node (CALL_EXPR, TREE_VALUE ($$), empty_parms (), $3);
+ $$ = start_method (TREE_CHAIN ($$), decl, $4);
+ if (! $$)
+ YYERROR1;
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ reinit_parse_for_method (yychar, $$); }
+ | declmods declarator maybe_raises
+ { $$ = start_method ($$, $2, $3);
+ if (! $$)
+ YYERROR1;
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ reinit_parse_for_method (yychar, $$); }
+ | notype_declarator maybe_raises
+ { $$ = start_method (NULL_TREE, $$, $2);
+ if (! $$)
+ YYERROR1;
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ reinit_parse_for_method (yychar, $$); }
+ ;
+
+return_id: RETURN IDENTIFIER
+ {
+ if (! current_function_parms_stored)
+ store_parm_decls ();
+ $$ = $2;
+ }
+ ;
+
+return_init: return_id
+ { store_return_init ($<ttype>$, NULL_TREE); }
+ | return_id '=' init
+ { store_return_init ($<ttype>$, $3); }
+ | return_id '(' nonnull_exprlist ')'
+ { store_return_init ($<ttype>$, $3); }
+ | return_id LEFT_RIGHT
+ { store_return_init ($<ttype>$, NULL_TREE); }
+ ;
+
+base_init:
+ ':' .set_base_init member_init_list
+ {
+ if ($3 == 0)
+ error ("no base initializers given following ':'");
+ setup_vtbl_ptr ();
+ /* Always keep the BLOCK node associated with the outermost
+ pair of curley braces of a function. These are needed
+ for correct operation of dwarfout.c. */
+ keep_next_level ();
+ }
+ ;
+
+.set_base_init:
+ /* empty */
+ {
+ 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");
+ }
+ ;
+
+member_init_list:
+ /* empty */
+ { $$ = 0; }
+ | member_init
+ { $$ = 1; }
+ | member_init_list ',' member_init
+ | member_init_list error
+ ;
+
+member_init: '(' nonnull_exprlist ')'
+ {
+ if (current_class_name && !flag_traditional)
+ pedwarn ("anachronistic old style base class initializer");
+ expand_member_init (C_C_D, NULL_TREE, $2);
+ }
+ | LEFT_RIGHT
+ {
+ if (current_class_name && !flag_traditional)
+ pedwarn ("anachronistic old style base class initializer");
+ expand_member_init (C_C_D, NULL_TREE, void_type_node);
+ }
+ | identifier '(' nonnull_exprlist ')'
+ {
+ expand_member_init (C_C_D, $<ttype>$, $3);
+ }
+ | identifier LEFT_RIGHT
+ { expand_member_init (C_C_D, $<ttype>$, void_type_node); }
+ | template_type_name '(' nonnull_exprlist ')'
+ { expand_member_init (C_C_D, $<ttype>$, $3); }
+ | template_type_name LEFT_RIGHT
+ { expand_member_init (C_C_D, $<ttype>$, void_type_node); }
+ | scoped_typename '(' nonnull_exprlist ')'
+ { expand_member_init (C_C_D, $<ttype>$, $3); }
+ | scoped_typename LEFT_RIGHT
+ { expand_member_init (C_C_D, $<ttype>$, void_type_node); }
+ | id_scope identifier '(' nonnull_exprlist ')'
+ {
+ do_member_init ($<ttype>$, $2, $4);
+ }
+ | id_scope identifier LEFT_RIGHT
+ {
+ do_member_init ($<ttype>$, $2, void_type_node);
+ }
+ ;
+
+identifier:
+ IDENTIFIER
+ | TYPENAME
+ | PTYPENAME
+ ;
+
+identifier_defn:
+ IDENTIFIER_DEFN
+ | TYPENAME_DEFN
+ | PTYPENAME_DEFN
+ ;
+
+identifier_or_opname:
+ IDENTIFIER
+ | TYPENAME
+ | PTYPENAME
+/* | '~' TYPENAME
+ { $$ = build_parse_node (BIT_NOT_EXPR, $2); }*/
+ /* get rid of the next line, replace it with the above */
+ | '~' identifier { $$ = build_parse_node (BIT_NOT_EXPR,$2);}
+ | operator_name
+ ;
+
+explicit_instantiation:
+ TEMPLATE aggr template_type
+ | TEMPLATE typed_declspecs declarator
+ { do_function_instantiation ($2, $3); }
+ ;
+
+template_type:
+ template_type_name tmpl.1 template_instantiation
+ {
+ extern tree template_type_seen_before_scope;
+
+ if ($3)
+ $$ = $3;
+ else if ($$ != error_mark_node)
+ $$ = IDENTIFIER_TYPE_VALUE ($$);
+ /* 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 ($$ != error_mark_node)
+ template_type_seen_before_scope = TYPE_IDENTIFIER ($$);
+ else
+ template_type_seen_before_scope = error_mark_node;
+ yychar = YYLEX;
+ }
+ }
+ ;
+
+template_type_name:
+ PTYPENAME '<' template_arg_list '>'
+ { $$ = lookup_template_class ($$, $3, NULL_TREE); }
+ | TYPENAME '<' template_arg_list '>'
+ { $$ = lookup_template_class ($$, $3, NULL_TREE); }
+ ;
+
+tmpl.1:
+ /* Expansion of template may be required, unless we're followed by
+ a class definition. */
+ '{' { yyungetc ('{', 1); $$ = 0; }
+ | ':' { yyungetc (':', 1); $$ = 0; }
+ | /* empty */ %prec EMPTY
+ { $$ = instantiate_class_template ($<ttype>0, 1); }
+ ;
+
+tmpl.2:
+ /* Always do expansion if it hasn't been done already. */
+ { $$ = instantiate_class_template ($<ttype>0, 1); }
+ ;
+
+template_arg_list:
+ template_arg
+ { $$ = build_tree_list (NULL_TREE, $$); }
+ | template_arg_list ',' template_arg
+ { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
+ ;
+
+template_arg:
+ typename
+ { $$ = groktypename ($$); }
+ | expr_no_commas %prec UNARY
+ ;
+
+template_instantiate_once:
+ PRE_PARSED_CLASS_DECL maybe_base_class_list
+ {
+ tree t, decl, tmpl;
+
+ tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE ($1));
+ t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, $1, $2, 0);
+ set_current_level_tags_transparency (1);
+ my_friendly_assert (TREE_CODE (t) == RECORD_TYPE
+ || TREE_CODE (t) == UNION_TYPE, 257);
+ $<ttype>$ = t;
+
+ /* Now, put a copy of the decl in global scope, to avoid
+ recursive expansion. */
+ decl = IDENTIFIER_LOCAL_VALUE ($1);
+ if (!decl)
+ decl = IDENTIFIER_CLASS_VALUE ($1);
+ /* 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);
+ }
+ }
+ left_curly opt.component_decl_list '}'
+ {
+ $$ = finish_struct ($<ttype>3, $5, 0);
+
+ pop_obstacks ();
+ end_template_instantiation ($1);
+
+ /* Now go after the methods & class data. */
+ instantiate_member_templates ($1);
+
+ pop_tinst_level();
+
+ CLASSTYPE_GOT_SEMICOLON ($$) = 1;
+ }
+ ;
+
+template_instantiation:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | template_instantiate_once
+ { $$ = $1; }
+ ;
+
+template_instantiate_some:
+ /* empty */
+ { $$ = NULL_TREE; /* never used from here... */}
+ | template_instantiate_once template_instantiate_some
+ { $$ = $1; /*???*/ }
+ ;
+
+unop: '-'
+ { $$ = NEGATE_EXPR; }
+ | '+'
+ { $$ = CONVERT_EXPR; }
+ | PLUSPLUS
+ { $$ = PREINCREMENT_EXPR; }
+ | MINUSMINUS
+ { $$ = PREDECREMENT_EXPR; }
+ | '!'
+ { $$ = TRUTH_NOT_EXPR; }
+ ;
+
+expr: nonnull_exprlist
+ { $$ = build_x_compound_expr ($$); }
+ /* Ugly, but faster. */
+ | expr_no_commas
+ ;
+
+paren_expr_or_null:
+ LEFT_RIGHT
+ { error ("ANSI C++ forbids an empty condition for `%s'",
+ cond_stmt_keyword);
+ $$ = integer_zero_node; }
+ | '(' expr ')'
+ { $$ = $2; }
+ ;
+
+paren_cond_or_null:
+ LEFT_RIGHT
+ { error ("ANSI C++ forbids an empty condition for `%s'",
+ cond_stmt_keyword);
+ $$ = integer_zero_node; }
+ | '(' condition ')'
+ { $$ = $2; }
+ ;
+
+xcond:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | condition
+ | error
+ { $$ = NULL_TREE; }
+ ;
+
+condition:
+ typed_typespecs declarator maybe_raises maybeasm maybe_attribute '='
+ { {
+ tree d;
+ for (d = getdecls (); d; d = TREE_CHAIN (d))
+ if (TREE_CODE (d) == TYPE_DECL) {
+ tree s = TREE_TYPE (d);
+ if (TREE_CODE (s) == RECORD_TYPE)
+ cp_error ("definition of class `%T' in condition", s);
+ else if (TREE_CODE (s) == ENUMERAL_TYPE)
+ cp_error ("definition of enum `%T' in condition", s);
+ }
+ }
+ current_declspecs = $1;
+ $<itype>6 = suspend_momentary ();
+ $<ttype>$ = start_decl ($<ttype>2, current_declspecs, 1, $3);
+ cplus_decl_attributes ($<ttype>$, $5);
+ }
+ init
+ {
+ finish_decl ($<ttype>7, $8, $5, 0);
+ resume_momentary ($<itype>6);
+ $$ = $<ttype>7;
+ if (TREE_CODE (TREE_TYPE ($$)) == ARRAY_TYPE)
+ cp_error ("definition of array `%#D' in condition", $$);
+ }
+ | expr
+ ;
+
+/* Used for the blocks controlled by a condition, to add any DECLs in
+ the condition to the controlled block. */
+.kindof_pushlevel: /* empty */
+ { tree d = getdecls ();
+ emit_line_note (input_filename, lineno);
+ pushlevel (0);
+ clear_last_expr ();
+ push_momentary ();
+ expand_start_bindings (0);
+ if (d) pushdecl (d);
+ }
+ ;
+
+/* Like implicitly_scoped_stmt, but uses .kindof_pushlevel */
+partially_scoped_stmt:
+ '{' .kindof_pushlevel '}'
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ $$ = poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ finish_stmt (); }
+ | '{' .kindof_pushlevel maybe_label_decls stmts '}'
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ $$ = poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ finish_stmt (); }
+ | '{' .kindof_pushlevel maybe_label_decls error '}'
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ $$ = poplevel (kept_level_p (), 0, 0);
+ pop_momentary ();
+ finish_stmt (); }
+ | .kindof_pushlevel simple_stmt
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ $$ = poplevel (kept_level_p (), 1, 0);
+ pop_momentary (); }
+ ;
+
+already_scoped_stmt:
+ '{' '}'
+ { finish_stmt (); }
+ | '{' maybe_label_decls stmts '}'
+ { finish_stmt (); }
+ | '{' maybe_label_decls error '}'
+ { finish_stmt (); }
+ | simple_stmt
+ ;
+
+nonnull_exprlist:
+ expr_no_commas
+ { $$ = build_tree_list (NULL_TREE, $$); }
+ | nonnull_exprlist ',' expr_no_commas
+ { chainon ($$, build_tree_list (NULL_TREE, $3)); }
+ | nonnull_exprlist ',' error
+ { chainon ($$, build_tree_list (NULL_TREE, error_mark_node)); }
+ ;
+
+unary_expr:
+ primary %prec UNARY
+ {
+ if (TREE_CODE ($$) == TYPE_EXPR)
+ $$ = build_component_type_expr (C_C_D, $$, NULL_TREE, 1);
+ }
+ /* __extension__ turns off -pedantic for following primary. */
+ | EXTENSION
+ { $<itype>1 = pedantic;
+ pedantic = 0; }
+ cast_expr %prec UNARY
+ { $$ = $3;
+ pedantic = $<itype>1; }
+ | '*' cast_expr %prec UNARY
+ { $$ = build_x_indirect_ref ($2, "unary *"); }
+ | '&' cast_expr %prec UNARY
+ { $$ = build_x_unary_op (ADDR_EXPR, $2); }
+ | '~' cast_expr %prec UNARY
+ { $$ = build_x_unary_op (BIT_NOT_EXPR, $2); }
+ | unop cast_expr %prec UNARY
+ { $$ = build_x_unary_op ((enum tree_code) $$, $2);
+ if ($1 == NEGATE_EXPR && TREE_CODE ($2) == INTEGER_CST)
+ TREE_NEGATED_INT ($$) = 1;
+ overflow_warning ($$);
+ }
+ /* Refer to the address of a label as a pointer. */
+ | ANDAND identifier
+ { tree label = lookup_label ($2);
+ if (label == NULL_TREE)
+ $$ = null_pointer_node;
+ else
+ {
+ TREE_USED (label) = 1;
+ $$ = build1 (ADDR_EXPR, ptr_type_node, label);
+ TREE_CONSTANT ($$) = 1;
+ }
+ }
+ | SIZEOF unary_expr %prec UNARY
+ { if (TREE_CODE ($2) == COMPONENT_REF
+ && DECL_BIT_FIELD (TREE_OPERAND ($2, 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 ($2) == COMPOUND_EXPR
+ && (TREE_CODE (TREE_TYPE ($2)) == ARRAY_TYPE
+ || TREE_CODE (TREE_TYPE ($2)) == FUNCTION_TYPE))
+ $2 = default_conversion ($2);
+ else if (TREE_CODE ($2) == TREE_LIST)
+ {
+ tree t = TREE_VALUE ($2);
+ if (t != NULL_TREE
+ && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
+ pedwarn ("ANSI C++ forbids using sizeof() on a function");
+ }
+ $$ = c_sizeof (TREE_TYPE ($2)); }
+ | SIZEOF '(' typename ')' %prec HYPERUNARY
+ { $$ = c_sizeof (groktypename ($3)); }
+ | ALIGNOF unary_expr %prec UNARY
+ { $$ = grok_alignof ($2); }
+ | ALIGNOF '(' typename ')' %prec HYPERUNARY
+ { $$ = c_alignof (groktypename ($3)); }
+
+ | .scope new typename %prec '='
+ { $$ = build_new ($2, $3, NULL_TREE, $$ != NULL_TREE); }
+ | .scope new '(' nonnull_exprlist ')' typename %prec '='
+ { $$ = build_new ($4, $6, NULL_TREE, $$ != NULL_TREE); }
+ | .scope new typespec '(' nonnull_exprlist ')'
+ { $$ = build_new ($2, $3, $5, $$ != NULL_TREE); }
+ | .scope new typespec '(' typespec ')'
+ { cp_error ("`%T' is not a valid expression", $5);
+ $$ = error_mark_node; }
+ | .scope new '(' nonnull_exprlist ')' typespec '(' nonnull_exprlist ')'
+ { $$ = build_new ($4, $6, $8, $$ != NULL_TREE); }
+ | .scope new typespec LEFT_RIGHT
+ { $$ = build_new ($2, $3, NULL_TREE, $$ != NULL_TREE); }
+ | .scope new '(' nonnull_exprlist ')' typespec LEFT_RIGHT
+ { $$ = build_new ($4, $6, NULL_TREE, $$ != NULL_TREE); }
+ | .scope new typename '=' init %prec '='
+ { $$ = build_new ($2, $3, $5, $$ != NULL_TREE); }
+ | .scope new '(' nonnull_exprlist ')' typename '=' init %prec '='
+ { $$ = build_new ($4, $6, $8, $$ != NULL_TREE); }
+
+ /* I am not going to add placement syntax to the below complex rules
+ because Ken says the syntax is illegal. (mrs) */
+ /* I'm not sure why this is disallowed. But since it is, and it
+ doesn't seem difficult to catch it, let's give a message, so
+ the programmer can fix it. --Ken Raeburn */
+ | .scope new '(' typed_typespecs absdcl ')' '[' nonmomentary_expr ']'
+ {
+ tree absdcl, typename;
+
+ illegal_new_array:
+ absdcl = build_parse_node (ARRAY_REF, $5, $8);
+ typename = build_decl_list ($4, absdcl);
+ pedwarn ("ANSI C++ forbids array dimensions with parenthesized type");
+ $$ = build_new ($2, typename, NULL_TREE, $$ != NULL_TREE);
+ }
+ | .scope new '(' nonempty_type_quals absdcl ')' '[' nonmomentary_expr ']'
+ { goto illegal_new_array; }
+
+ | .scope new '(' typed_typespecs absdcl ')'
+ { $$ = build_new ($2, build_decl_list ($4, $5), NULL_TREE, $$ != NULL_TREE); }
+ | .scope new '(' nonnull_exprlist ')' '(' typed_typespecs absdcl ')'
+ { $$ = build_new ($4, build_decl_list ($7, $8), NULL_TREE, $$ != NULL_TREE); }
+ | .scope new '(' nonempty_type_quals absdcl ')'
+ { $$ = build_new ($2, build_decl_list ($4, $5), NULL_TREE, $$ != NULL_TREE); }
+ | .scope new '(' nonnull_exprlist ')' '(' nonempty_type_quals absdcl ')'
+ { $$ = build_new ($4, build_decl_list ($7, $8), NULL_TREE, $$ != NULL_TREE); }
+ /* Unswallow a ':' which is probably meant for ?: expression. */
+ | .scope new TYPENAME_COLON
+ { yyungetc (':', 1); $$ = build_new ($2, $3, NULL_TREE, $$ != NULL_TREE); }
+ | .scope new '(' nonnull_exprlist ')' TYPENAME_COLON
+ { yyungetc (':', 1); $$ = build_new ($4, $6, NULL_TREE, $$ != NULL_TREE); }
+
+ | delete cast_expr %prec UNARY
+ { $$ = delete_sanity ($2, NULL_TREE, 0, $$ != NULL_TREE); }
+ | delete '[' ']' cast_expr %prec UNARY
+ { $$ = delete_sanity ($4, NULL_TREE, 1, $$ != NULL_TREE);
+ if (yychar == YYEMPTY)
+ yychar = YYLEX; }
+ | delete '[' expr ']' cast_expr %prec UNARY
+ { $$ = delete_sanity ($5, $3, 2, $$ != NULL_TREE);
+ if (yychar == YYEMPTY)
+ yychar = YYLEX; }
+ ;
+
+cast_expr:
+ unary_expr
+ | '(' typename ')' expr_no_commas %prec UNARY
+ { tree type = groktypename ($2);
+ $$ = build_c_cast (type, $4); }
+ | '(' typename ')' '{' initlist maybecomma '}' %prec UNARY
+ { tree type = groktypename ($2);
+
+ if (IS_SIGNATURE (type))
+ {
+ error ("cast specifies signature type");
+ $$ = error_mark_node;
+ }
+ else
+ {
+ tree init;
+ init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($5));
+ if (pedantic)
+ pedwarn ("ANSI C++ forbids constructor-expressions");
+ /* Indicate that this was a GNU C constructor expression. */
+ TREE_HAS_CONSTRUCTOR (init) = 1;
+ $$ = digest_init (type, init, (tree *) 0);
+ if (TREE_CODE (type) == ARRAY_TYPE
+ && TYPE_SIZE (type) == 0)
+ {
+ int failure = complete_array_type (type, $$, 1);
+ if (failure)
+ my_friendly_abort (78);
+ }
+ }
+ }
+ | HEADOF '(' expr ')'
+ { $$ = build_headof ($3); }
+ | CLASSOF '(' expr ')'
+ { $$ = build_classof ($3); }
+ | CLASSOF '(' TYPENAME ')'
+ { if (is_aggr_typedef ($3, 1))
+ {
+ tree type = IDENTIFIER_TYPE_VALUE ($3);
+ if (! IS_SIGNATURE(type))
+ $$ = CLASSTYPE_DOSSIER (type);
+ else
+ {
+ sorry ("signature name as argument of `classof'");
+ $$ = error_mark_node;
+ }
+ }
+ else
+ $$ = error_mark_node;
+ }
+ ;
+
+expr_no_commas:
+ cast_expr
+ | expr_no_commas '+' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '-' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '*' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '/' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '%' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas LSHIFT expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas RSHIFT expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas ARITHCOMPARE expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '<' expr_no_commas
+ { $$ = build_x_binary_op (LT_EXPR, $$, $3); }
+ | expr_no_commas '>' expr_no_commas
+ { $$ = build_x_binary_op (GT_EXPR, $$, $3); }
+ | expr_no_commas EQCOMPARE expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas MIN_MAX expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '&' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '|' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas '^' expr_no_commas
+ { $$ = build_x_binary_op ($2, $$, $3); }
+ | expr_no_commas ANDAND expr_no_commas
+ { $$ = build_x_binary_op (TRUTH_ANDIF_EXPR, $$, $3); }
+ | expr_no_commas OROR expr_no_commas
+ { $$ = build_x_binary_op (TRUTH_ORIF_EXPR, $$, $3); }
+ | expr_no_commas '?' xexpr ':' expr_no_commas
+ { $$ = build_x_conditional_expr ($$, $3, $5); }
+ | expr_no_commas '=' expr_no_commas
+ { $$ = build_modify_expr ($$, NOP_EXPR, $3); }
+ | expr_no_commas ASSIGN expr_no_commas
+ { register tree rval;
+ if (rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, $$, $3,
+ make_node ($2)))
+ $$ = rval;
+ else
+ $$ = build_modify_expr ($$, $2, $3); }
+ | primary DOT_STAR expr_no_commas %prec UNARY
+ { $$ = build_m_component_ref ($$, $3); }
+ /* Handle general members. */
+ | object_star expr_no_commas %prec UNARY
+ { $$ = build_x_binary_op (MEMBER_REF, $$, $2); }
+/* These extensions are not defined. The second arg to build_m_component_ref
+ is old, build_m_component_ref now does an implicit
+ build_indirect_ref (x, NULL_PTR) on the second argument.
+ | object '&' expr_no_commas %prec UNARY
+ { $$ = build_m_component_ref ($$, build_x_unary_op (ADDR_EXPR, $3)); }
+ | object unop expr_no_commas %prec UNARY
+ { $$ = build_m_component_ref ($$, build_x_unary_op ($2, $3)); }
+ | object '(' typename ')' expr_no_commas %prec UNARY
+ { tree type = groktypename ($3);
+ $$ = build_m_component_ref ($$, build_c_cast (type, $5)); }
+ | object primary_no_id %prec UNARY
+ { $$ = build_m_component_ref ($$, $2); }
+*/
+ ;
+
+primary:
+ IDENTIFIER
+ { $$ = do_identifier ($$); }
+ | operator_name
+ {
+ tree op = $$;
+ if (TREE_CODE (op) != IDENTIFIER_NODE)
+ $$ = op;
+ else
+ {
+ $$ = lookup_name (op, 0);
+ if ($$ == NULL_TREE)
+ {
+ if (op != ansi_opname[ERROR_MARK])
+ error ("operator %s not defined",
+ operator_name_string (op));
+ $$ = error_mark_node;
+ }
+ }
+ }
+ | CONSTANT
+ | string
+ { $$ = combine_strings ($$); }
+ | '(' expr ')'
+ { $$ = $2; }
+ | '(' error ')'
+ { $$ = error_mark_node; }
+ | '('
+ { if (current_function_decl == 0)
+ {
+ error ("braced-group within expression allowed only inside a function");
+ YYERROR;
+ }
+ keep_next_level ();
+ $<ttype>$ = expand_start_stmt_expr (); }
+ compstmt ')'
+ { tree rtl_exp;
+ if (pedantic)
+ pedwarn ("ANSI C++ forbids braced-groups within expressions");
+ rtl_exp = expand_end_stmt_expr ($<ttype>2);
+ /* The statements have side effects, so the group does. */
+ TREE_SIDE_EFFECTS (rtl_exp) = 1;
+
+ if (TREE_CODE ($3) == BLOCK)
+ {
+ /* Make a BIND_EXPR for the BLOCK already made. */
+ $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp),
+ NULL_TREE, rtl_exp, $3);
+ /* 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 ($3);
+ }
+ else
+ $$ = $3;
+ }
+ | primary '(' nonnull_exprlist ')'
+ { /* [eichin:19911016.1902EST] */
+ $<ttype>$ = build_x_function_call ($1, $3, current_class_decl);
+ /* here we instantiate_class_template as needed... */
+ do_pending_templates ();
+ } template_instantiate_some {
+ if (TREE_CODE ($<ttype>5) == CALL_EXPR
+ && TREE_TYPE ($<ttype>5) != void_type_node)
+ $$ = require_complete_type ($<ttype>5);
+ else
+ $$ = $<ttype>5;
+ }
+ | primary LEFT_RIGHT
+ {
+ $$ = build_x_function_call ($$, NULL_TREE, current_class_decl);
+ if (TREE_CODE ($$) == CALL_EXPR
+ && TREE_TYPE ($$) != void_type_node)
+ $$ = require_complete_type ($$);
+ }
+ | primary '[' expr ']'
+ { do_array:
+ $$ = grok_array_decl ($$, $3); }
+ | object identifier_or_opname %prec UNARY
+ { $$ = build_component_ref ($$, $2, NULL_TREE, 1); }
+ | object id_scope identifier_or_opname %prec UNARY
+ { $$ = build_object_ref ($$, $2, $3); }
+ | primary PLUSPLUS
+ { /* If we get an OFFSET_REF, turn it into what it really
+ means (e.g., a COMPONENT_REF). This way if we've got,
+ say, a reference to a static member that's being operated
+ on, we don't end up trying to find a member operator for
+ the class it's in. */
+ if (TREE_CODE ($$) == OFFSET_REF)
+ $$ = resolve_offset_ref ($$);
+ $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); }
+ | primary MINUSMINUS
+ { if (TREE_CODE ($$) == OFFSET_REF)
+ $$ = resolve_offset_ref ($$);
+ $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); }
+ /* C++ extensions */
+ | THIS
+ { if (current_class_decl)
+ {
+#ifdef WARNING_ABOUT_CCD
+ TREE_USED (current_class_decl) = 1;
+#endif
+ $$ = current_class_decl;
+ }
+ else if (current_function_decl
+ && DECL_STATIC_FUNCTION_P (current_function_decl))
+ {
+ error ("`this' is unavailable for static member functions");
+ $$ = 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");
+ $$ = error_mark_node;
+ }
+ }
+ | TYPE_QUAL '(' nonnull_exprlist ')'
+ {
+ tree type;
+ tree id = $$;
+
+ /* This is a C cast in C++'s `functional' notation. */
+ if ($3 == error_mark_node)
+ {
+ $$ = error_mark_node;
+ break;
+ }
+#if 0
+ if ($3 == NULL_TREE)
+ {
+ error ("cannot cast null list to type `%s'",
+ IDENTIFIER_POINTER (TYPE_NAME (id)));
+ $$ = error_mark_node;
+ break;
+ }
+#endif
+#if 0
+ /* type is not set! (mrs) */
+ if (type == error_mark_node)
+ $$ = 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");
+ $$ = error_mark_node;
+ break;
+ }
+#endif
+ else my_friendly_abort (79);
+ $$ = build_c_cast (type, build_compound_expr ($3));
+ }
+ }
+ | typespec '(' nonnull_exprlist ')'
+ { $$ = build_functional_cast ($$, $3); }
+ | typespec LEFT_RIGHT
+ { $$ = build_functional_cast ($$, NULL_TREE); }
+ /* Stroustrup RTTI */
+ | DYNAMIC_CAST '<' typename '>' '(' expr ')'
+ { tree type = groktypename ($3);
+ $$ = build_dynamic_cast (type, $6); }
+ | TYPEID '(' expr ')'
+ { $$ = build_typeid ($3); }
+ | TYPEID '(' typename ')'
+ { tree type = groktypename ($3);
+ $$ = get_typeid (type); }
+ | SCOPE typespec '(' nonnull_exprlist ')'
+ { $$ = build_functional_cast ($2, $4); }
+ | SCOPE typespec LEFT_RIGHT
+ { $$ = build_functional_cast ($2, NULL_TREE); }
+ | SCOPE IDENTIFIER
+ {
+ do_scoped_id:
+ $$ = IDENTIFIER_GLOBAL_VALUE ($2);
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ if (! $$)
+ {
+ if (yychar == '(' || yychar == LEFT_RIGHT)
+ $$ = implicitly_declare ($2);
+ else
+ {
+ if (IDENTIFIER_GLOBAL_VALUE ($2) != error_mark_node)
+ error ("undeclared variable `%s' (first use here)",
+ IDENTIFIER_POINTER ($2));
+ $$ = error_mark_node;
+ /* Prevent repeated error messages. */
+ IDENTIFIER_GLOBAL_VALUE ($2) = error_mark_node;
+ }
+ }
+ else
+ {
+ if (TREE_CODE ($$) == ADDR_EXPR)
+ assemble_external (TREE_OPERAND ($$, 0));
+ else
+ assemble_external ($$);
+ TREE_USED ($$) = 1;
+ }
+ if (TREE_CODE ($$) == CONST_DECL)
+ {
+ /* XXX CHS - should we set TREE_USED of the constant? */
+ $$ = DECL_INITIAL ($$);
+ /* This is to prevent an enum whose value is 0
+ from being considered a null pointer constant. */
+ $$ = build1 (NOP_EXPR, TREE_TYPE ($$), $$);
+ TREE_CONSTANT ($$) = 1;
+ }
+
+ }
+ | SCOPE operator_name
+ {
+ if (TREE_CODE ($2) == IDENTIFIER_NODE)
+ goto do_scoped_id;
+ do_scoped_operator:
+ $$ = $2;
+ }
+ | id_scope identifier_or_opname %prec HYPERUNARY
+ { $$ = build_offset_ref ($$, $2); }
+ | id_scope identifier_or_opname '(' nonnull_exprlist ')'
+ { $$ = build_member_call ($$, $2, $4); }
+ | id_scope identifier_or_opname LEFT_RIGHT
+ { $$ = build_member_call ($$, $2, NULL_TREE); }
+ | object identifier_or_opname '(' nonnull_exprlist ')'
+ {
+#if 0
+ /* This is a future direction of this code, but because
+ build_x_function_call cannot always undo what is done
+ in build_component_ref entirely yet, we cannot do this. */
+ $$ = build_x_function_call (build_component_ref ($$, $2, NULL_TREE, 1), $4, $$);
+ if (TREE_CODE ($$) == CALL_EXPR
+ && TREE_TYPE ($$) != void_type_node)
+ $$ = require_complete_type ($$);
+#else
+ $$ = build_method_call ($$, $2, $4, NULL_TREE,
+ (LOOKUP_NORMAL|LOOKUP_AGGR));
+#endif
+ }
+ | object identifier_or_opname LEFT_RIGHT
+ {
+#if 0
+ /* This is a future direction of this code, but because
+ build_x_function_call cannot always undo what is done
+ in build_component_ref entirely yet, we cannot do this. */
+ $$ = build_x_function_call (build_component_ref ($$, $2, NULL_TREE, 1), NULL_TREE, $$);
+ if (TREE_CODE ($$) == CALL_EXPR
+ && TREE_TYPE ($$) != void_type_node)
+ $$ = require_complete_type ($$);
+#else
+ $$ = build_method_call ($$, $2, NULL_TREE, NULL_TREE,
+ (LOOKUP_NORMAL|LOOKUP_AGGR));
+#endif
+ }
+ | object id_scope identifier_or_opname '(' nonnull_exprlist ')'
+ {
+ if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE ($2)))
+ {
+ warning ("signature name in scope resolution ignored");
+ $$ = build_method_call ($$, $3, $5, NULL_TREE,
+ (LOOKUP_NORMAL|LOOKUP_AGGR));
+ }
+ else
+ $$ = build_scoped_method_call ($$, $2, $3, $5);
+ }
+ | object id_scope identifier_or_opname LEFT_RIGHT
+ {
+ if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE ($2)))
+ {
+ warning ("signature name in scope resolution ignored");
+ $$ = build_method_call ($$, $3, NULL_TREE, NULL_TREE,
+ (LOOKUP_NORMAL|LOOKUP_AGGR));
+ }
+ else
+ $$ = build_scoped_method_call ($$, $2, $3, NULL_TREE);
+ }
+ /* p->int::~int() is valid -- 12.4 */
+ | object '~' TYPESPEC LEFT_RIGHT
+ {
+ if (TREE_CODE (TREE_TYPE ($1))
+ != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($3))))
+ cp_error ("`%E' is not of type `%T'", $1, $3);
+ $$ = void_zero_node;
+ }
+ | object TYPESPEC SCOPE '~' TYPESPEC LEFT_RIGHT
+ {
+ if ($2 != $5)
+ cp_error ("destructor specifier `%T::~%T()' must have matching names", $2, $5);
+ if (TREE_CODE (TREE_TYPE ($1))
+ != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($2))))
+ cp_error ("`%E' is not of type `%T'", $1, $2);
+ $$ = void_zero_node;
+ }
+ ;
+
+/* Not needed for now.
+
+primary_no_id:
+ '(' expr ')'
+ { $$ = $2; }
+ | '(' error ')'
+ { $$ = error_mark_node; }
+ | '('
+ { if (current_function_decl == 0)
+ {
+ error ("braced-group within expression allowed only inside a function");
+ YYERROR;
+ }
+ $<ttype>$ = expand_start_stmt_expr (); }
+ compstmt ')'
+ { if (pedantic)
+ pedwarn ("ANSI C++ forbids braced-groups within expressions");
+ $$ = expand_end_stmt_expr ($<ttype>2); }
+ | primary_no_id '(' nonnull_exprlist ')'
+ { $$ = build_x_function_call ($$, $3, current_class_decl); }
+ | primary_no_id LEFT_RIGHT
+ { $$ = build_x_function_call ($$, NULL_TREE, current_class_decl); }
+ | primary_no_id '[' expr ']'
+ { goto do_array; }
+ | primary_no_id PLUSPLUS
+ { $$ = build_x_unary_op (POSTINCREMENT_EXPR, $$); }
+ | primary_no_id MINUSMINUS
+ { $$ = build_x_unary_op (POSTDECREMENT_EXPR, $$); }
+ | SCOPE IDENTIFIER
+ { goto do_scoped_id; }
+ | SCOPE operator_name
+ { if (TREE_CODE ($2) == IDENTIFIER_NODE)
+ goto do_scoped_id;
+ goto do_scoped_operator;
+ }
+ ;
+*/
+
+new: NEW
+ { $$ = NULL_TREE; }
+ | NEW '{' nonnull_exprlist '}'
+ {
+ $$ = $3;
+ pedwarn ("old style placement syntax, use () instead");
+ }
+ ;
+
+.scope:
+ /* empty */
+ { $$ = 0; }
+ | SCOPE
+ { $$ = 1; }
+ ;
+
+delete: DELETE
+ { $$ = NULL_TREE; }
+ | SCOPE delete
+ { if ($2)
+ error ("extra `::' before `delete' ignored");
+ $$ = error_mark_node;
+ }
+ ;
+
+/* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */
+string:
+ STRING
+ | string STRING
+ { $$ = chainon ($$, $2); }
+ ;
+
+nodecls:
+ /* empty */
+ {
+ if (! current_function_parms_stored)
+ store_parm_decls ();
+ setup_vtbl_ptr ();
+ /* Always keep the BLOCK node associated with the outermost
+ pair of curley braces of a function. These are needed
+ for correct operation of dwarfout.c. */
+ keep_next_level ();
+ }
+ ;
+
+object: primary '.'
+ | primary POINTSAT
+ {
+ $$ = build_x_arrow ($$);
+ }
+ ;
+
+object_star: primary POINTSAT_STAR
+ ;
+
+decl:
+ typed_declspecs initdecls ';'
+ {
+ resume_momentary ($2);
+ note_list_got_semicolon ($<ttype>$);
+ }
+ /* Normal case: make this fast. */
+ | typed_declspecs declarator ';'
+ { tree d;
+ int yes = suspend_momentary ();
+ d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE);
+ finish_decl (d, NULL_TREE, NULL_TREE, 0);
+ resume_momentary (yes);
+ note_list_got_semicolon ($<ttype>$);
+ }
+ | declmods notype_initdecls ';'
+ { resume_momentary ((int) $<itype>2); }
+ /* Normal case: make this fast. */
+ | declmods declarator ';'
+ { tree d;
+ int yes = suspend_momentary ();
+ d = start_decl ($<ttype>2, $<ttype>$, 0, NULL_TREE);
+ finish_decl (d, NULL_TREE, NULL_TREE, 0);
+ resume_momentary (yes);
+ }
+ | typed_declspecs ';'
+ {
+ shadow_tag ($<ttype>$);
+ note_list_got_semicolon ($<ttype>$);
+ }
+ | declmods ';'
+ { warning ("empty declaration"); }
+ ;
+
+/* Any kind of declarator (thus, all declarators allowed
+ after an explicit typespec). */
+
+declarator:
+ after_type_declarator
+ | notype_declarator
+ | START_DECLARATOR after_type_declarator
+ { $$ = $2; }
+ | START_DECLARATOR notype_declarator
+ { $$ = $2; }
+ ;
+
+/* Declspecs which contain at least one type specifier or typedef name.
+ (Just `const' or `volatile' is not enough.)
+ A typedef'd name following these is taken as a name to be declared. */
+
+typed_declspecs:
+ typespec %prec HYPERUNARY
+ { if ($$) $$ = list_hash_lookup_or_cons ($$); }
+ | declmods typespec
+ { $$ = hash_tree_chain ($2, $$); }
+ | typespec reserved_declspecs %prec HYPERUNARY
+ { $$ = hash_tree_chain ($$, $2); }
+ | declmods typespec reserved_declspecs
+ { $$ = hash_tree_chain ($2, hash_chainon ($3, $$)); }
+ ;
+
+reserved_declspecs: /* empty
+ { $$ = NULL_TREE; } */
+ typespecqual_reserved
+ { $$ = build_decl_list (NULL_TREE, $$); }
+ | SCSPEC
+ { if (extra_warnings)
+ warning ("`%s' is not at beginning of declaration",
+ IDENTIFIER_POINTER ($$));
+ $$ = build_decl_list (NULL_TREE, $$); }
+ | reserved_declspecs typespecqual_reserved
+ { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
+ | reserved_declspecs SCSPEC
+ { if (extra_warnings)
+ warning ("`%s' is not at beginning of declaration",
+ IDENTIFIER_POINTER ($2));
+ $$ = decl_tree_cons (NULL_TREE, $2, $$); }
+ ;
+
+/* List of just storage classes and type modifiers.
+ A declaration can start with just this, but then it cannot be used
+ to redeclare a typedef-name. */
+
+declmods:
+ TYPE_QUAL
+ { $$ = IDENTIFIER_AS_LIST ($$);
+ TREE_STATIC ($$) = 1; }
+ | SCSPEC
+ { $$ = IDENTIFIER_AS_LIST ($$); }
+ | declmods TYPE_QUAL
+ { $$ = hash_tree_chain ($2, $$);
+ TREE_STATIC ($$) = 1; }
+ | declmods SCSPEC
+ { if (extra_warnings && TREE_STATIC ($$))
+ warning ("`%s' is not at beginning of declaration",
+ IDENTIFIER_POINTER ($2));
+ $$ = hash_tree_chain ($2, $$);
+ TREE_STATIC ($$) = TREE_STATIC ($1); }
+ ;
+
+
+/* Used instead of declspecs where storage classes are not allowed
+ (that is, for typenames and structure components).
+
+ C++ can takes storage classes for structure components.
+ Don't accept a typedef-name if anything but a modifier precedes it. */
+
+typed_typespecs:
+ typespec %prec EMPTY
+ { $$ = get_decl_list ($$); }
+ | nonempty_type_quals typespec
+ { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
+ | typespec reserved_typespecquals
+ { $$ = decl_tree_cons (NULL_TREE, $$, $2); }
+ | nonempty_type_quals typespec reserved_typespecquals
+ { $$ = decl_tree_cons (NULL_TREE, $2, hash_chainon ($3, $$)); }
+ ;
+
+reserved_typespecquals:
+ typespecqual_reserved
+ { $$ = get_decl_list ($$); }
+ | reserved_typespecquals typespecqual_reserved
+ { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
+ ;
+
+/* A typespec (but not a type qualifier).
+ Once we have seen one of these in a declaration,
+ if a typedef name appears then it is being redeclared. */
+
+typespec: structsp
+ | TYPESPEC %prec EMPTY
+ | TYPENAME %prec EMPTY
+ | scoped_typename
+ | TYPEOF '(' expr ')'
+ { $$ = TREE_TYPE ($3);
+ if (pedantic)
+ pedwarn ("ANSI C++ forbids `typeof'"); }
+ | TYPEOF '(' typename ')'
+ { $$ = groktypename ($3);
+ if (pedantic)
+ pedwarn ("ANSI C++ forbids `typeof'"); }
+ | SIGOF '(' expr ')'
+ { tree type = TREE_TYPE ($3);
+
+ if (IS_AGGR_TYPE (type))
+ {
+ sorry ("sigof type specifier");
+ $$ = type;
+ }
+ else
+ {
+ error ("`sigof' applied to non-aggregate expression");
+ $$ = error_mark_node;
+ }
+ }
+ | SIGOF '(' typename ')'
+ { tree type = groktypename ($3);
+
+ if (IS_AGGR_TYPE (type))
+ {
+ sorry ("sigof type specifier");
+ $$ = type;
+ }
+ else
+ {
+ error("`sigof' applied to non-aggregate type");
+ $$ = error_mark_node;
+ }
+ }
+ | template_type %prec EMPTY
+ ;
+
+/* A typespec that is a reserved word, or a type qualifier. */
+
+typespecqual_reserved: TYPESPEC
+ | TYPE_QUAL
+ | structsp
+ ;
+
+initdecls:
+ initdcl0
+ | initdecls ',' initdcl
+ ;
+
+notype_initdecls:
+ notype_initdcl0
+ | notype_initdecls ',' initdcl
+ ;
+
+maybeasm:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | asm_keyword '(' string ')'
+ { if (TREE_CHAIN ($3)) $3 = combine_strings ($3); $$ = $3; }
+ ;
+
+initdcl0:
+ declarator maybe_raises maybeasm maybe_attribute '='
+ { current_declspecs = $<ttype>0;
+ $<itype>5 = suspend_momentary ();
+ $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2);
+ cplus_decl_attributes ($<ttype>$, $4); }
+ init
+/* Note how the declaration of the variable is in effect while its init is parsed! */
+ { finish_decl ($<ttype>6, $7, $3, 0);
+ $$ = $<itype>5; }
+ | declarator maybe_raises maybeasm maybe_attribute
+ { tree d;
+ current_declspecs = $<ttype>0;
+ $$ = suspend_momentary ();
+ d = start_decl ($<ttype>1, current_declspecs, 0, $2);
+ cplus_decl_attributes (d, $4);
+ finish_decl (d, NULL_TREE, $3, 0); }
+ ;
+
+initdcl:
+ declarator maybe_raises maybeasm maybe_attribute '='
+ { $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2);
+ cplus_decl_attributes ($<ttype>$, $4); }
+ init
+/* Note how the declaration of the variable is in effect while its init is parsed! */
+ { finish_decl ($<ttype>6, $7, $3, 0); }
+ | declarator maybe_raises maybeasm maybe_attribute
+ { tree d = start_decl ($<ttype>1, current_declspecs, 0, $2);
+ cplus_decl_attributes ($<ttype>$, $4);
+ finish_decl (d, NULL_TREE, $3, 0); }
+ ;
+
+notype_initdcl0:
+ notype_declarator maybe_raises maybeasm maybe_attribute '='
+ { current_declspecs = $<ttype>0;
+ $<itype>5 = suspend_momentary ();
+ $<ttype>$ = start_decl ($<ttype>1, current_declspecs, 1, $2);
+ cplus_decl_attributes ($<ttype>$, $4); }
+ init
+/* Note how the declaration of the variable is in effect while its init is parsed! */
+ { finish_decl ($<ttype>6, $7, $3, 0);
+ $$ = $<itype>5; }
+ | notype_declarator maybe_raises maybeasm maybe_attribute
+ { tree d;
+ current_declspecs = $<ttype>0;
+ $$ = suspend_momentary ();
+ d = start_decl ($<ttype>1, current_declspecs, 0, $2);
+ cplus_decl_attributes (d, $4);
+ finish_decl (d, NULL_TREE, $3, 0); }
+ ;
+
+/* the * rules are dummies to accept the Apollo extended syntax
+ so that the header files compile. */
+maybe_attribute:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | maybe_attribute ATTRIBUTE '(' '(' attribute_list ')' ')'
+ { $$ = chainon ($5, $1); }
+ ;
+
+attribute_list
+ : attrib
+ { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
+ | attribute_list ',' attrib
+ { $$ = tree_cons (NULL_TREE, $3, $1); }
+ ;
+
+attrib
+ : TYPE_QUAL
+ | IDENTIFIER
+ { if (strcmp (IDENTIFIER_POINTER ($1), "packed")
+ && strcmp (IDENTIFIER_POINTER ($1), "noreturn"))
+ warning ("`%s' attribute directive ignored",
+ IDENTIFIER_POINTER ($1));
+ $$ = $1; }
+ | IDENTIFIER '(' IDENTIFIER ')'
+ { /* If not "mode (m)", then issue warning. */
+ if (strcmp (IDENTIFIER_POINTER ($1), "mode") != 0)
+ {
+ warning ("`%s' attribute directive ignored",
+ IDENTIFIER_POINTER ($1));
+ $$ = $1;
+ }
+ else
+ $$ = tree_cons ($1, $3, NULL_TREE); }
+ | IDENTIFIER '(' CONSTANT ')'
+ { /* if not "aligned(n)", then issue warning */
+ if (strcmp (IDENTIFIER_POINTER ($1), "aligned") != 0
+ || TREE_CODE ($3) != INTEGER_CST)
+ {
+ warning ("`%s' attribute directive ignored",
+ IDENTIFIER_POINTER ($1));
+ $$ = $1;
+ }
+ else
+ $$ = tree_cons ($1, $3, NULL_TREE); }
+ | IDENTIFIER '(' IDENTIFIER ',' CONSTANT ',' CONSTANT ')'
+ { /* if not "format(...)", then issue warning */
+ if (strcmp (IDENTIFIER_POINTER ($1), "format") != 0
+ || TREE_CODE ($5) != INTEGER_CST
+ || TREE_CODE ($7) != INTEGER_CST)
+ {
+ warning ("`%s' attribute directive ignored",
+ IDENTIFIER_POINTER ($1));
+ $$ = $1;
+ }
+ else
+ $$ = tree_cons ($1, tree_cons ($3, tree_cons ($5, $7, NULL_TREE), NULL_TREE), NULL_TREE); }
+ ;
+
+/* A nonempty list of identifiers, including typenames. */
+identifiers_or_typenames:
+ identifier
+ { $$ = build_tree_list (NULL_TREE, $1); }
+ | identifiers_or_typenames ',' identifier
+ { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
+ ;
+
+init:
+ expr_no_commas %prec '='
+ | '{' '}'
+ { $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
+ TREE_HAS_CONSTRUCTOR ($$) = 1;
+ if (pedantic)
+ pedwarn ("ANSI C++ forbids empty initializer braces"); }
+ | '{' initlist '}'
+ { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2));
+ TREE_HAS_CONSTRUCTOR ($$) = 1; }
+ | '{' initlist ',' '}'
+ { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2));
+ TREE_HAS_CONSTRUCTOR ($$) = 1; }
+ | error
+ { $$ = NULL_TREE; }
+ ;
+
+/* This chain is built in reverse order,
+ and put in forward order where initlist is used. */
+initlist:
+ init
+ { $$ = build_tree_list (NULL_TREE, $$); }
+ | initlist ',' init
+ { $$ = tree_cons (NULL_TREE, $3, $$); }
+ /* These are for labeled elements. */
+ | '[' expr_no_commas ']' init
+ { $$ = build_tree_list ($2, $4); }
+ | initlist ',' CASE expr_no_commas ':' init
+ { $$ = tree_cons ($4, $6, $$); }
+ | identifier ':' init
+ { $$ = build_tree_list ($$, $3); }
+ | initlist ',' identifier ':' init
+ { $$ = tree_cons ($3, $5, $$); }
+ ;
+
+structsp:
+ ENUM identifier '{'
+ { $<itype>3 = suspend_momentary ();
+ $$ = start_enum ($2); }
+ enumlist maybecomma_warn '}'
+ { $$ = finish_enum ($<ttype>4, $5);
+ resume_momentary ((int) $<itype>3);
+ check_for_missing_semicolon ($<ttype>4); }
+ | ENUM identifier '{' '}'
+ { $$ = finish_enum (start_enum ($2), NULL_TREE);
+ check_for_missing_semicolon ($$); }
+ | ENUM '{'
+ { $<itype>2 = suspend_momentary ();
+ $$ = start_enum (make_anon_name ()); }
+ enumlist maybecomma_warn '}'
+ { $$ = finish_enum ($<ttype>3, $4);
+ resume_momentary ((int) $<itype>1);
+ check_for_missing_semicolon ($<ttype>3); }
+ | ENUM '{' '}'
+ { $$ = finish_enum (start_enum (make_anon_name()), NULL_TREE);
+ check_for_missing_semicolon ($$); }
+ | ENUM identifier
+ { $$ = xref_tag (enum_type_node, $2, NULL_TREE, 0); }
+
+ /* C++ extensions, merged with C to avoid shift/reduce conflicts */
+ | class_head left_curly opt.component_decl_list '}'
+ {
+ int semi;
+ tree id;
+
+#if 0
+ /* Need to rework class nesting in the
+ presence of nested classes, etc. */
+ shadow_tag (CLASSTYPE_AS_LIST ($$)); */
+#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 ($$);
+
+ if (TREE_CODE ($$) == ENUMERAL_TYPE)
+ /* $$ = $1 from default rule. */;
+ else if (CLASSTYPE_DECLARED_EXCEPTION ($$))
+ {
+ if (! semi)
+ $$ = finish_exception ($$, $3);
+ else
+ warning ("empty exception declaration\n");
+ }
+ else
+ {
+ $$ = finish_struct ($$, $3, semi);
+ if (semi) note_got_semicolon ($$);
+ }
+
+ pop_obstacks ();
+
+ id = TYPE_IDENTIFIER ($$);
+ if (id && 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 ($$); }
+ | class_head %prec EMPTY
+ {
+#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 ($$) && !TYPE_SIZE ($$))
+ {
+ error ("incomplete definition of type `%s'",
+ TYPE_NAME_STRING ($$));
+ $$ = error_mark_node;
+ }
+#endif
+ }
+ ;
+
+maybecomma:
+ /* empty */
+ | ','
+ ;
+
+maybecomma_warn:
+ /* empty */
+ | ','
+ { if (pedantic) pedwarn ("comma at end of enumerator list"); }
+ ;
+
+aggr: AGGR
+ | aggr SCSPEC
+ { error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); }
+ | aggr TYPESPEC
+ { error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); }
+ | aggr TYPE_QUAL
+ { error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER ($2)); }
+ | aggr AGGR
+ { error ("no body nor ';' separates two class, struct or union declarations"); }
+ ;
+
+named_class_head_sans_basetype:
+ aggr identifier
+ { aggr1: current_aggr = $$; $$ = $2; }
+ | aggr template_type_name %prec EMPTY
+ { current_aggr = $$; $$ = $2; }
+ | aggr TYPENAME_COLON
+ { yyungetc (':', 1); goto aggr1; }
+ | aggr template_type_name '{'
+ { yyungetc ('{', 1);
+ aggr2:
+ current_aggr = $$;
+ $$ = $2;
+ overload_template_name ($$, 0); }
+ | aggr template_type_name ':'
+ { yyungetc (':', 1); goto aggr2; }
+ ;
+
+named_class_head_sans_basetype_defn:
+ aggr identifier_defn
+ { current_aggr = $$; $$ = $2; }
+ ;
+
+named_class_head:
+ named_class_head_sans_basetype
+ {
+ $<ttype>$ = xref_tag (current_aggr, $1, NULL_TREE, 1);
+ }
+ maybe_base_class_list %prec EMPTY
+ {
+ if ($3)
+ $$ = xref_tag (current_aggr, $1, $3, 1);
+ else
+ $$ = $<ttype>2;
+ }
+ |
+ named_class_head_sans_basetype_defn
+ {
+ $<ttype>$ = xref_defn_tag (current_aggr, $1, NULL_TREE);
+ }
+ maybe_base_class_list %prec EMPTY
+ {
+ if ($3)
+ $$ = xref_defn_tag (current_aggr, $1, $3);
+ else
+ $$ = $<ttype>2;
+ }
+ ;
+
+unnamed_class_head: aggr '{'
+ { $$ = xref_tag ($$, make_anon_name (), NULL_TREE, 0);
+ yyungetc ('{', 1); }
+ ;
+
+class_head: unnamed_class_head | named_class_head ;
+
+maybe_base_class_list:
+ %prec EMPTY /* empty */
+ { $$ = NULL_TREE; }
+ | ':' %prec EMPTY
+ { yyungetc(':', 1); $$ = NULL_TREE; }
+ | ':' base_class_list %prec EMPTY
+ { $$ = $2; }
+ ;
+
+base_class_list:
+ base_class
+ | base_class_list ',' base_class
+ { $$ = chainon ($$, $3); }
+ ;
+
+base_class:
+ base_class.1
+ {
+ tree type;
+ do_base_class1:
+ type = IDENTIFIER_TYPE_VALUE ($$);
+ if (! is_aggr_typedef ($$, 1))
+ $$ = NULL_TREE;
+ else if (current_aggr == signature_type_node
+ && (! type) && (! IS_SIGNATURE (type)))
+ {
+ error ("class name not allowed as base signature");
+ $$ = NULL_TREE;
+ }
+ else if (current_aggr == signature_type_node)
+ {
+ sorry ("signature inheritance, base type `%s' ignored",
+ IDENTIFIER_POINTER ($$));
+ $$ = build_tree_list ((tree)access_public, $$);
+ }
+ else if (type && IS_SIGNATURE (type))
+ {
+ error ("signature name not allowed as base class");
+ $$ = NULL_TREE;
+ }
+ else
+ $$ = build_tree_list ((tree)access_default, $$);
+ }
+ | scoped_base_class
+ {
+ goto do_base_class1;
+ }
+ | base_class_access_list base_class.1
+ {
+ tree type;
+ do_base_class2:
+ type = IDENTIFIER_TYPE_VALUE ($2);
+ if (current_aggr == signature_type_node)
+ error ("access and source specifiers not allowed in signature");
+ if (! is_aggr_typedef ($2, 1))
+ $$ = NULL_TREE;
+ else if (current_aggr == signature_type_node
+ && (! type) && (! IS_SIGNATURE (type)))
+ {
+ error ("class name not allowed as base signature");
+ $$ = NULL_TREE;
+ }
+ else if (current_aggr == signature_type_node)
+ {
+ sorry ("signature inheritance, base type `%s' ignored",
+ IDENTIFIER_POINTER ($$));
+ $$ = build_tree_list ((tree)access_public, $2);
+ }
+ else if (type && IS_SIGNATURE (type))
+ {
+ error ("signature name not allowed as base class");
+ $$ = NULL_TREE;
+ }
+ else
+ $$ = build_tree_list ((tree) $$, $2);
+ }
+ | base_class_access_list scoped_base_class
+ {
+ goto do_base_class2;
+ }
+ ;
+
+scoped_base_class:
+ base_class.1 SCOPED_TYPENAME
+ {
+ /* Kludge!!! See rule "template_type" and the code
+ * dealing with "template_type_seen_before_scope" in
+ * yylex(). */
+ $$ = $2;
+ }
+ ;
+base_class.1:
+ template_type_name tmpl.2 template_instantiation
+ {
+ extern tree template_type_seen_before_scope;
+ tree id = $3 ? TYPE_IDENTIFIER ($3) : $1;
+
+ /* Check the rule template_type to get this... */
+ if (yychar == YYEMPTY)
+ yychar = YYLEX;
+ if (yychar == SCOPE) {
+ template_type_seen_before_scope = id;
+ yychar = YYLEX;
+ }
+ }
+ | identifier
+ | SIGOF '(' expr ')'
+ {
+ if (current_aggr == signature_type_node)
+ {
+ if (IS_AGGR_TYPE (TREE_TYPE ($3)))
+ {
+ sorry ("`sigof' as base signature specifier");
+ /* need to return some dummy signature identifier */
+ $$ = $3;
+ }
+ else
+ {
+ error ("`sigof' applied to non-aggregate expression");
+ $$ = error_mark_node;
+ }
+ }
+ else
+ {
+ error ("`sigof' in struct or class declaration");
+ $$ = error_mark_node;
+ }
+ }
+ | SIGOF '(' typename ')'
+ {
+ if (current_aggr == signature_type_node)
+ {
+ if (IS_AGGR_TYPE (groktypename ($3)))
+ {
+ sorry ("`sigof' as base signature specifier");
+ /* need to return some dummy signature identifier */
+ $$ = $3;
+ }
+ else
+ {
+ error ("`sigof' applied to non-aggregate expression");
+ $$ = error_mark_node;
+ }
+ }
+ else
+ {
+ error ("`sigof' in struct or class declaration");
+ $$ = error_mark_node;
+ }
+ }
+ ;
+
+base_class_access_list:
+ VISSPEC
+ | SCSPEC
+ { if ($<ttype>$ != ridpointers[(int)RID_VIRTUAL])
+ sorry ("non-virtual access");
+ $$ = access_default_virtual; }
+ | base_class_access_list VISSPEC
+ { int err = 0;
+ if ($2 == access_protected)
+ {
+ warning ("`protected' access not implemented");
+ $2 = access_public;
+ err++;
+ }
+ else if ($2 == access_public)
+ {
+ if ($1 == access_private)
+ {
+ mixed:
+ error ("base class cannot be public and private");
+ }
+ else if ($1 == access_default_virtual)
+ $$ = access_public_virtual;
+ }
+ else /* $2 == access_private */
+ {
+ if ($1 == access_public)
+ goto mixed;
+ else if ($1 == access_default_virtual)
+ $$ = access_private_virtual;
+ }
+ }
+ | base_class_access_list SCSPEC
+ { if ($2 != ridpointers[(int)RID_VIRTUAL])
+ sorry ("non-virtual access");
+ if ($$ == access_public)
+ $$ = access_public_virtual;
+ else if ($$ == access_private)
+ $$ = access_private_virtual; }
+ ;
+
+left_curly: '{'
+ { tree t;
+ push_obstacks_nochange ();
+ end_temporary_allocation ();
+
+ if (! IS_AGGR_TYPE ($<ttype>0))
+ {
+ $<ttype>0 = make_lang_type (RECORD_TYPE);
+ TYPE_NAME ($<ttype>0) = get_identifier ("erroneous type");
+ }
+ if (TYPE_SIZE ($<ttype>0))
+ duplicate_tag_error ($<ttype>0);
+ if (TYPE_SIZE ($<ttype>0) || TYPE_BEING_DEFINED ($<ttype>0))
+ {
+ t = make_lang_type (TREE_CODE ($<ttype>0));
+ pushtag (TYPE_IDENTIFIER ($<ttype>0), t, 0);
+ $<ttype>0 = t;
+ }
+ pushclass ($<ttype>0, 0);
+ TYPE_BEING_DEFINED ($<ttype>0) = 1;
+ t = TYPE_IDENTIFIER ($<ttype>0);
+ if (t && IDENTIFIER_TEMPLATE (t))
+ overload_template_name (t, 1);
+ }
+ ;
+
+opt.component_decl_list:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | component_decl_list
+ {
+ if (current_aggr == signature_type_node)
+ $$ = build_tree_list ((tree) access_public, $$);
+ else
+ $$ = build_tree_list ((tree) access_default, $$);
+ }
+ | opt.component_decl_list VISSPEC ':' component_decl_list
+ {
+ tree visspec = (tree) $2;
+
+ if (current_aggr == signature_type_node)
+ {
+ error ("access specifier not allowed in signature");
+ visspec = (tree) access_public;
+ }
+ $$ = chainon ($$, build_tree_list (visspec, $4));
+ }
+ | opt.component_decl_list VISSPEC ':'
+ {
+ if (current_aggr == signature_type_node)
+ error ("access specifier not allowed in signature");
+ }
+ ;
+
+/* Note: we no longer warn about the semicolon after a component_decl_list.
+ ARM $9.2 says that the semicolon is optional, and therefore allowed. */
+component_decl_list:
+ component_decl
+ { if ($$ == void_type_node) $$ = NULL_TREE;
+ }
+ | component_decl_list component_decl
+ { /* In pushdecl, we created a reverse list of names
+ in this binding level. Make sure that the chain
+ of what we're trying to add isn't the item itself
+ (which can happen with what pushdecl's doing). */
+ if ($2 != NULL_TREE && $2 != void_type_node)
+ {
+ if (TREE_CHAIN ($2) != $$)
+ $$ = chainon ($$, $2);
+ else
+ $$ = $2;
+ }
+ }
+ | component_decl_list ';'
+ ;
+
+component_decl:
+ typed_declspecs components ';'
+ {
+ $$ = grok_x_components ($$, $2);
+ end_exception_decls ();
+ }
+ | typed_declspecs '(' parmlist ')' ';'
+ { $$ = groktypefield ($$, $3); }
+ | typed_declspecs '(' parmlist ')' '}'
+ { error ("missing ';' before right brace");
+ yyungetc ('}', 0);
+ $$ = groktypefield ($$, $3); }
+ | typed_declspecs LEFT_RIGHT ';'
+ { $$ = groktypefield ($$, empty_parms ()); }
+ | typed_declspecs LEFT_RIGHT '}'
+ { error ("missing ';' before right brace");
+ yyungetc ('}', 0);
+ $$ = groktypefield ($$, empty_parms ()); }
+ | declmods components ';'
+ {
+ $$ = grok_x_components ($$, $2);
+ end_exception_decls ();
+ }
+ /* Normal case: make this fast. */
+ | declmods declarator ';'
+ { $$ = grokfield ($<ttype>2, $<ttype>$,
+ NULL_TREE, NULL_TREE, NULL_TREE); }
+ | declmods components '}'
+ { error ("missing ';' before right brace");
+ yyungetc ('}', 0);
+ $$ = grok_x_components ($$, $2);
+ end_exception_decls ();
+ }
+ | declmods '(' parmlist ')' ';'
+ { $$ = groktypefield ($$, $3); }
+ | declmods '(' parmlist ')' '}'
+ { error ("missing ';' before right brace");
+ yyungetc ('}', 0);
+ $$ = groktypefield ($$, $3); }
+ | declmods LEFT_RIGHT ';'
+ { $$ = groktypefield ($$, empty_parms ()); }
+ | declmods LEFT_RIGHT '}'
+ { error ("missing ';' before right brace");
+ yyungetc ('}', 0);
+ $$ = groktypefield ($$, empty_parms ()); }
+ | ':' expr_no_commas ';'
+ { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); }
+ | ':' expr_no_commas '}'
+ { error ("missing ';' before right brace");
+ yyungetc ('}', 0);
+ $$ = grokbitfield (NULL_TREE, NULL_TREE, $2); }
+ | error
+ { $$ = NULL_TREE; }
+
+ /* C++: handle constructors, destructors and inline functions */
+ /* note that INLINE is like a TYPESPEC */
+ | fn.def2 ':' /* base_init compstmt */
+ { $$ = finish_method ($$); }
+ | fn.def2 '{' /* nodecls compstmt */
+ { $$ = finish_method ($$); }
+ | notype_declarator maybe_raises ';'
+ { $$ = grokfield ($$, NULL_TREE, $2, NULL_TREE, NULL_TREE); }
+ | notype_declarator maybe_raises '}'
+ { error ("missing ';' before right brace");
+ yyungetc ('}', 0);
+ $$ = grokfield ($$, NULL_TREE, $2, NULL_TREE, NULL_TREE); }
+ ;
+
+components:
+ /* empty: possibly anonymous */
+ { $$ = NULL_TREE; }
+ | component_declarator0
+ | components ',' component_declarator
+ {
+ /* In this context, void_type_node encodes
+ friends. They have been recorded elsewhere. */
+ if ($$ == void_type_node)
+ $$ = $3;
+ else
+ $$ = chainon ($$, $3);
+ }
+ ;
+
+component_declarator0:
+ declarator maybe_raises maybeasm maybe_attribute
+ { current_declspecs = $<ttype>0;
+ $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3);
+ cplus_decl_attributes ($$, $4); }
+ | declarator maybe_raises maybeasm maybe_attribute '=' init
+ { current_declspecs = $<ttype>0;
+ $$ = grokfield ($$, current_declspecs, $2, $6, $3);
+ cplus_decl_attributes ($$, $4); }
+ | IDENTIFIER ':' expr_no_commas maybe_attribute
+ { current_declspecs = $<ttype>0;
+ $$ = grokbitfield ($$, current_declspecs, $3);
+ cplus_decl_attributes ($$, $4); }
+ | TYPENAME ':' expr_no_commas maybe_attribute
+ { current_declspecs = $<ttype>0;
+ $$ = grokbitfield ($$, current_declspecs, $3);
+ cplus_decl_attributes ($$, $4); }
+ | ':' expr_no_commas maybe_attribute
+ { current_declspecs = $<ttype>0;
+ $$ = grokbitfield (NULL_TREE, NULL_TREE, $2);
+ cplus_decl_attributes ($$, $3); }
+ ;
+
+component_declarator:
+ declarator maybe_raises maybeasm maybe_attribute
+ { $$ = grokfield ($$, current_declspecs, $2, NULL_TREE, $3);
+ cplus_decl_attributes ($$, $4); }
+ | declarator maybe_raises maybeasm maybe_attribute '=' init
+ { $$ = grokfield ($$, current_declspecs, $2, $6, $3);
+ cplus_decl_attributes ($$, $4); }
+ | IDENTIFIER ':' expr_no_commas maybe_attribute
+ { $$ = grokbitfield ($$, current_declspecs, $3);
+ cplus_decl_attributes ($$, $4); }
+ | TYPENAME ':' expr_no_commas maybe_attribute
+ { $$ = grokbitfield ($$, current_declspecs, $3);
+ cplus_decl_attributes ($$, $4); }
+ | ':' expr_no_commas maybe_attribute
+ { $$ = grokbitfield (NULL_TREE, NULL_TREE, $2);
+ cplus_decl_attributes ($$, $3); }
+ ;
+
+/* We chain the enumerators in reverse order.
+ Because of the way enums are built, the order is
+ insignificant. Take advantage of this fact. */
+
+enumlist:
+ enumerator
+ | enumlist ',' enumerator
+ { TREE_CHAIN ($3) = $$; $$ = $3; }
+ ;
+
+enumerator:
+ identifier
+ { $$ = build_enumerator ($$, NULL_TREE); }
+ | identifier '=' expr_no_commas
+ { $$ = build_enumerator ($$, $3); }
+ ;
+
+/* ANSI type-id (8.1) */
+typename:
+ typed_typespecs absdcl
+ { $$ = build_decl_list ($$, $2); }
+ | nonempty_type_quals absdcl
+ { $$ = build_decl_list ($$, $2); }
+ ;
+
+/* ANSI abstract-declarator (8.1) */
+absdcl: /* an abstract declarator */
+ /* empty */ %prec EMPTY
+ { $$ = NULL_TREE; }
+ | absdcl1 %prec EMPTY
+ | START_DECLARATOR absdcl1 %prec EMPTY
+ { $$ = $2; }
+ ;
+
+nonempty_type_quals:
+ TYPE_QUAL
+ { $$ = IDENTIFIER_AS_LIST ($$); }
+ | nonempty_type_quals TYPE_QUAL
+ { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
+ ;
+
+type_quals:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | type_quals TYPE_QUAL
+ { $$ = decl_tree_cons (NULL_TREE, $2, $$); }
+ ;
+
+/* These rules must follow the rules for function declarations
+ and component declarations. That way, longer rules are preferred. */
+
+/* An expression which will not live on the momentary obstack. */
+nonmomentary_expr:
+ { $<itype>$ = suspend_momentary (); } expr
+ { resume_momentary ((int) $<itype>1); $$ = $2; }
+
+/* A declarator that is allowed only after an explicit typespec. */
+/* may all be followed by prec '.' */
+after_type_declarator:
+ after_type_declarator '(' nonnull_exprlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
+ | after_type_declarator '(' parmlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
+ | after_type_declarator LEFT_RIGHT type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
+ | after_type_declarator '(' error ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
+ | after_type_declarator '[' nonmomentary_expr ']'
+ { $$ = build_parse_node (ARRAY_REF, $$, $3); }
+ | after_type_declarator '[' ']'
+ { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
+ | '(' after_type_declarator_no_typename ')'
+ { $$ = $2; }
+ | '(' '*' type_quals after_type_declarator ')'
+ { $$ = make_pointer_declarator ($3, $4); }
+ | PAREN_STAR_PAREN
+ { see_typename (); }
+ | after_type_member_declarator
+ | '(' '&' type_quals after_type_declarator ')'
+ { $$ = make_reference_declarator ($3, $4); }
+ | '*' type_quals after_type_declarator %prec UNARY
+ { $$ = make_pointer_declarator ($2, $3); }
+ | '&' type_quals after_type_declarator %prec UNARY
+ { $$ = make_reference_declarator ($2, $3); }
+ | TYPENAME %prec EMPTY
+ ;
+
+after_type_declarator_no_typename:
+ after_type_declarator_no_typename '(' nonnull_exprlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
+ | after_type_declarator_no_typename '(' parmlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
+ | after_type_declarator_no_typename LEFT_RIGHT type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
+ | after_type_declarator_no_typename '(' error ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
+ | after_type_declarator_no_typename '[' nonmomentary_expr ']'
+ { $$ = build_parse_node (ARRAY_REF, $$, $3); }
+ | after_type_declarator_no_typename '[' ']'
+ { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
+ | '(' after_type_declarator_no_typename ')'
+ { $$ = $2; }
+ | PAREN_STAR_PAREN
+ { see_typename (); }
+ | after_type_member_declarator
+ | '*' type_quals after_type_declarator %prec UNARY
+ { $$ = make_pointer_declarator ($2, $3); }
+ | '&' type_quals after_type_declarator %prec UNARY
+ { $$ = make_reference_declarator ($2, $3); }
+ ;
+
+/* A declarator allowed whether or not there has been
+ an explicit typespec. These cannot redeclare a typedef-name. */
+
+notype_declarator:
+ notype_declarator '(' nonnull_exprlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
+ | notype_declarator '(' parmlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
+ | notype_declarator LEFT_RIGHT type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
+ | notype_declarator '(' error ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); }
+ | '(' notype_declarator ')'
+ { $$ = $2; }
+ | '*' type_quals notype_declarator %prec UNARY
+ { $$ = make_pointer_declarator ($2, $3); }
+ | '&' type_quals notype_declarator %prec UNARY
+ { $$ = make_reference_declarator ($2, $3); }
+ | notype_declarator '[' nonmomentary_expr ']'
+ { $$ = build_parse_node (ARRAY_REF, $$, $3); }
+ | notype_declarator '[' ']'
+ { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
+ | IDENTIFIER
+ { see_typename (); }
+
+ /* C++ extensions. */
+ | operator_name
+ { see_typename (); }
+
+ | '~' TYPENAME
+ {
+ destructor_name:
+ see_typename ();
+ $$ = build_parse_node (BIT_NOT_EXPR, $2);
+ }
+ | '~' IDENTIFIER
+ { goto destructor_name; }
+ | '~' PTYPENAME
+ { goto destructor_name; }
+ | id_scope see_typename notype_declarator %prec '('
+ { see_typename ();
+ if (TREE_CODE ($$) != SCOPE_REF)
+ $$ = build_push_scope ($$, $3);
+ else if (TREE_OPERAND ($$, 1) == NULL_TREE)
+ TREE_OPERAND ($$, 1) = $3;
+ else
+ $$ = build_parse_node (SCOPE_REF, $$, $3);
+ }
+ | id_scope see_typename TYPENAME %prec '('
+ { $$ = build_push_scope ($$, $3); }
+ | id_scope see_typename TYPENAME '(' nonnull_exprlist ')' type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
+ | id_scope see_typename TYPENAME '(' parmlist ')' type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
+ | id_scope see_typename TYPENAME LEFT_RIGHT type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, empty_parms (), $5)); }
+ | id_scope see_typename TYPENAME '(' error ')' type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, NULL_TREE, NULL_TREE)); }
+ /* For constructor templates. */
+ | id_scope see_typename PTYPENAME %prec '('
+ { $$ = build_push_scope ($$, $3); }
+ | id_scope see_typename PTYPENAME '(' nonnull_exprlist ')' type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
+ | id_scope see_typename PTYPENAME '(' parmlist ')' type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, $5, $7)); }
+ | id_scope see_typename PTYPENAME LEFT_RIGHT type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, empty_parms (), $5)); }
+ | id_scope see_typename PTYPENAME '(' error ')' type_quals %prec '.'
+ { $$ = build_push_scope ($$, build_parse_node (CALL_EXPR, $3, NULL_TREE, NULL_TREE)); }
+ | SCOPE see_typename notype_declarator
+ { $$ = build_parse_node (SCOPE_REF, NULL_TREE, $3); }
+ | template_type SCOPED_NAME
+ { $$ = $2; }
+ ;
+
+id_scope: typename_scope
+ { tree t;
+ do_id_scope:
+
+ t = resolve_scope_to_name (NULL_TREE, $$);
+ if (t == NULL_TREE)
+ {
+ cp_error ("`%T' is not a valid scope", $$);
+ $$ = error_mark_node;
+ }
+ else
+ $$ = t;
+ }
+ | IDENTIFIER SCOPE
+ { goto do_id_scope; }
+ | template_type SCOPE /* try_for_typename %prec EMPTY */
+ {
+ if ($$ == error_mark_node)
+ /* leave it alone */;
+ else
+ {
+ $$ = resolve_scope_to_name (NULL_TREE, TYPE_IDENTIFIER ($$));
+ if ($$ == NULL_TREE)
+ {
+ error ("undefined explicitly scoped type");
+ $$ = error_mark_node;
+ }
+ }
+/* if ($3) popclass (1); */
+ }
+ ;
+
+typename_scope:
+ TYPENAME SCOPE;
+
+scoped_typename: SCOPED_TYPENAME
+ | template_type SCOPED_TYPENAME
+ {
+ /* Kludge!!! See rule "template_type" and the code
+ * dealing with "template_type_seen_before_scope" in
+ * yylex(). */
+ $$ = $2;
+ }
+/* | template_type SCOPE try_for_typename TYPENAME
+ {
+ if ($$ == error_mark_node)
+ ;
+ else
+ {
+ $$ = build_parse_node (SCOPE_REF,
+ TYPE_IDENTIFIER ($$),
+ $4);
+ }
+ if ($3) popclass (1);
+ } */
+ ;
+
+absdcl1: /* a nonempty abstract declarator */
+ '(' absdcl1 ')'
+ { see_typename ();
+ $$ = $2; }
+ /* `(typedef)1' is `int'. */
+ | '*' type_quals absdcl1 %prec EMPTY
+ { $$ = make_pointer_declarator ($2, $3); }
+ | '*' type_quals %prec EMPTY
+ { $$ = make_pointer_declarator ($2, NULL_TREE); }
+/*
+ | id_scope '*' type_quals absdcl1 %prec EMPTY
+ { $3 = make_pointer_declarator ($3, $4);
+ $$ = build_parse_node (SCOPE_REF, $$, $3); }
+ | id_scope '*' type_quals %prec EMPTY
+ { $3 = make_pointer_declarator ($3, NULL_TREE);
+ $$ = build_parse_node (SCOPE_REF, $$, $3); }
+*/
+ | PAREN_STAR_PAREN
+ { see_typename (); }
+ | '(' abs_member_declarator ')'
+ { $$ = $2; }
+ | '&' type_quals absdcl1 %prec EMPTY
+ { $$ = make_reference_declarator ($2, $3); }
+ | '&' type_quals %prec EMPTY
+ { $$ = make_reference_declarator ($2, NULL_TREE); }
+ | absdcl1 '(' parmlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, $3, $5); }
+ | absdcl1 LEFT_RIGHT type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, $$, empty_parms (), $3); }
+ | absdcl1 '[' nonmomentary_expr ']' %prec '.'
+ { $$ = build_parse_node (ARRAY_REF, $$, $3); }
+ | absdcl1 '[' ']' %prec '.'
+ { $$ = build_parse_node (ARRAY_REF, $$, NULL_TREE); }
+ | '(' parmlist ')' type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, NULL_TREE, $2, $4); }
+ | LEFT_RIGHT type_quals %prec '.'
+ { $$ = build_parse_node (CALL_EXPR, NULL_TREE, empty_parms (), $2); }
+ | '[' nonmomentary_expr ']' %prec '.'
+ { $$ = build_parse_node (ARRAY_REF, NULL_TREE, $2); }
+ | '[' ']' %prec '.'
+ { $$ = build_parse_node (ARRAY_REF, NULL_TREE, NULL_TREE); }
+ ;
+
+abs_member_declarator:
+ id_scope see_typename '*' type_quals
+ { tree t;
+ t = $$;
+ while (TREE_OPERAND (t, 1))
+ t = TREE_OPERAND (t, 1);
+ TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, 0);
+ }
+ | id_scope see_typename '*' type_quals absdcl1
+ { tree t;
+ t = $$;
+ while (TREE_OPERAND (t, 1))
+ t = TREE_OPERAND (t, 1);
+ TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, $5);
+ }
+ | id_scope see_typename '&' type_quals
+ { tree t;
+ t = $$;
+ while (TREE_OPERAND (t, 1))
+ t = TREE_OPERAND (t, 1);
+ TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, 0);
+ }
+ | id_scope see_typename '&' type_quals absdcl1
+ { tree t;
+ t = $$;
+ while (TREE_OPERAND (t, 1))
+ t = TREE_OPERAND (t, 1);
+ TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, $5);
+ }
+ ;
+
+after_type_member_declarator:
+ id_scope see_typename '*' type_quals after_type_declarator
+ { tree t;
+ t = $$;
+ while (TREE_OPERAND (t, 1))
+ t = TREE_OPERAND (t, 1);
+ TREE_OPERAND (t, 1) = build_parse_node (INDIRECT_REF, $5);
+ }
+ | id_scope see_typename '&' type_quals after_type_declarator
+ { tree t;
+ t = $$;
+ while (TREE_OPERAND (t, 1))
+ t = TREE_OPERAND (t, 1);
+ TREE_OPERAND (t, 1) = build_parse_node (ADDR_EXPR, $5);
+ }
+ ;
+
+/* For C++, decls and stmts can be intermixed, so we don't need to
+ have a special rule that won't start parsing the stmt section
+ until we have a stmt that parses without errors. */
+
+stmts:
+ stmt
+ | errstmt
+ | stmts stmt
+ | stmts errstmt
+ ;
+
+errstmt: error ';'
+ ;
+
+/* build the LET_STMT node before parsing its contents,
+ so that any LET_STMTs within the context can have their display pointers
+ set up to point at this one. */
+
+.pushlevel: /* empty */
+ { emit_line_note (input_filename, lineno);
+ pushlevel (0);
+ clear_last_expr ();
+ push_momentary ();
+ expand_start_bindings (0); }
+ ;
+
+/* Read zero or more forward-declarations for labels
+ that nested functions can jump to. */
+maybe_label_decls:
+ /* empty */
+ | label_decls
+ { if (pedantic)
+ pedwarn ("ANSI C++ forbids label declarations"); }
+ ;
+
+label_decls:
+ label_decl
+ | label_decls label_decl
+ ;
+
+label_decl:
+ LABEL identifiers_or_typenames ';'
+ { tree link;
+ for (link = $2; link; link = TREE_CHAIN (link))
+ {
+ tree label = shadow_label (TREE_VALUE (link));
+ C_DECLARED_LABEL_FLAG (label) = 1;
+ declare_nonlocal_label (label);
+ }
+ }
+ ;
+
+/* This is the body of a function definition.
+ It causes syntax errors to ignore to the next openbrace. */
+compstmt_or_error:
+ compstmt
+ {}
+ | error compstmt
+ ;
+
+compstmt: '{' .pushlevel '}'
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p(), 1);
+ $$ = poplevel (kept_level_p (), 1, 0);
+ pop_momentary (); }
+ | '{' .pushlevel maybe_label_decls stmts '}'
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p(), 1);
+ $$ = poplevel (kept_level_p (), 1, 0);
+ pop_momentary (); }
+ | '{' .pushlevel maybe_label_decls error '}'
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p(), 1);
+ $$ = poplevel (kept_level_p (), 0, 0);
+ pop_momentary (); }
+ ;
+
+simple_if:
+ IF
+ { cond_stmt_keyword = "if"; }
+ .pushlevel paren_cond_or_null
+ { emit_line_note (input_filename, lineno);
+ expand_start_cond (truthvalue_conversion ($4), 0); }
+ partially_scoped_stmt
+ ;
+
+implicitly_scoped_stmt:
+ compstmt
+ { finish_stmt (); }
+ | .pushlevel simple_stmt
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), getdecls() != NULL_TREE, 1);
+ $$ = poplevel (kept_level_p (), 1, 0);
+ pop_momentary (); }
+ ;
+
+stmt:
+ compstmt
+ { finish_stmt (); }
+ | simple_stmt
+ ;
+
+simple_stmt:
+ decl
+ { finish_stmt (); }
+ | expr ';'
+ {
+ tree expr = $1;
+ 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 (); }
+ | simple_if ELSE
+ { expand_start_else (); }
+ partially_scoped_stmt
+ { expand_end_cond ();
+ pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ finish_stmt (); }
+ | simple_if %prec IF
+ { expand_end_cond ();
+ pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ finish_stmt (); }
+ | WHILE
+ { emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop (1);
+ cond_stmt_keyword = "while"; }
+ .pushlevel paren_cond_or_null
+ { expand_exit_loop_if_false (0, truthvalue_conversion ($4)); }
+ already_scoped_stmt
+ { pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ expand_end_loop ();
+ finish_stmt (); }
+ | DO
+ { emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop_continue_elsewhere (1); }
+ implicitly_scoped_stmt WHILE
+ { expand_loop_continue_here ();
+ cond_stmt_keyword = "do"; }
+ paren_expr_or_null ';'
+ { emit_line_note (input_filename, lineno);
+ expand_exit_loop_if_false (0, truthvalue_conversion ($6));
+ expand_end_loop ();
+ clear_momentary ();
+ finish_stmt (); }
+ | forhead.1
+ { emit_nop ();
+ emit_line_note (input_filename, lineno);
+ if ($1) cplus_expand_expr_stmt ($1);
+ expand_start_loop_continue_elsewhere (1); }
+ .pushlevel xcond ';'
+ { emit_line_note (input_filename, lineno);
+ if ($4) expand_exit_loop_if_false (0, truthvalue_conversion ($4)); }
+ xexpr ')'
+ /* Don't let the tree nodes for $7 be discarded
+ by clear_momentary during the parsing of the next stmt. */
+ { push_momentary (); }
+ already_scoped_stmt
+ { emit_line_note (input_filename, lineno);
+ pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ expand_loop_continue_here ();
+ if ($7) cplus_expand_expr_stmt ($7);
+ pop_momentary ();
+ poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ expand_end_loop ();
+ finish_stmt (); }
+ | forhead.2
+ { emit_nop ();
+ emit_line_note (input_filename, lineno);
+ expand_start_loop_continue_elsewhere (1); }
+ .pushlevel xcond ';'
+ { emit_line_note (input_filename, lineno);
+ if ($4) expand_exit_loop_if_false (0, truthvalue_conversion ($4)); }
+ xexpr ')'
+ /* Don't let the tree nodes for $7 be discarded
+ by clear_momentary during the parsing of the next stmt. */
+ { push_momentary ();
+ $<itype>8 = lineno; }
+ already_scoped_stmt
+ { emit_line_note (input_filename, (int) $<itype>8);
+ pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ expand_loop_continue_here ();
+ if ($7) cplus_expand_expr_stmt ($7);
+ pop_momentary ();
+ poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ expand_end_loop ();
+ finish_stmt ();
+ }
+ | SWITCH .pushlevel '(' condition ')'
+ { emit_line_note (input_filename, lineno);
+ c_expand_start_case ($4);
+ /* Don't let the tree nodes for $4 be discarded by
+ clear_momentary during the parsing of the next stmt. */
+ push_momentary (); }
+ partially_scoped_stmt
+ { expand_end_case ($4);
+ pop_momentary ();
+ pop_implicit_try_blocks (NULL_TREE);
+ expand_end_bindings (getdecls (), kept_level_p (), 1);
+ poplevel (kept_level_p (), 1, 0);
+ pop_momentary ();
+ finish_stmt (); }
+ | CASE expr_no_commas ':'
+ { register tree value = $2;
+ 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)
+ {
+ cp_error ("case label `%E' does not reduce to an integer constant", $2);
+ 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, convert_and_check,
+ label, &duplicate);
+ if (success == 1)
+ cp_error ("case label `%E' not within a switch statement", $2);
+ else if (success == 2)
+ {
+ cp_error ("duplicate case value `%E'", $2);
+ cp_error_at ("`%E' previously used here", duplicate);
+ }
+ else if (success == 3)
+ warning ("case value out of range");
+ else if (success == 5)
+ cp_error ("case label `%E' within scope of cleanup or variable array", $2);
+ }
+ define_case_label (label);
+ }
+ stmt
+ | CASE expr_no_commas RANGE expr_no_commas ':'
+ { register tree value1 = $2;
+ register tree value2 = $4;
+ 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,
+ convert_and_check, 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);
+ }
+ stmt
+ | DEFAULT ':'
+ {
+ tree duplicate;
+ register tree label
+ = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ int success = pushcase (NULL_TREE, 0, 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);
+ }
+ stmt
+ | BREAK ';'
+ { emit_line_note (input_filename, lineno);
+ if ( ! expand_exit_something ())
+ error ("break statement not within loop or switch"); }
+ | CONTINUE ';'
+ { emit_line_note (input_filename, lineno);
+ if (! expand_continue_loop (0))
+ error ("continue statement not within a loop"); }
+ | RETURN ';'
+ { emit_line_note (input_filename, lineno);
+ c_expand_return (NULL_TREE); }
+ | RETURN expr ';'
+ { emit_line_note (input_filename, lineno);
+ c_expand_return ($2);
+ finish_stmt ();
+ }
+ | asm_keyword maybe_type_qual '(' string ')' ';'
+ { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
+ emit_line_note (input_filename, lineno);
+ expand_asm ($4);
+ finish_stmt ();
+ }
+ /* This is the case with just output operands. */
+ | asm_keyword maybe_type_qual '(' string ':' asm_operands ')' ';'
+ { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
+ emit_line_note (input_filename, lineno);
+ c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
+ $2 == ridpointers[(int)RID_VOLATILE],
+ input_filename, lineno);
+ finish_stmt ();
+ }
+ /* This is the case with input operands as well. */
+ | asm_keyword maybe_type_qual '(' string ':' asm_operands ':' asm_operands ')' ';'
+ { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
+ emit_line_note (input_filename, lineno);
+ c_expand_asm_operands ($4, $6, $8, NULL_TREE,
+ $2 == ridpointers[(int)RID_VOLATILE],
+ input_filename, lineno);
+ finish_stmt ();
+ }
+ /* This is the case with clobbered registers as well. */
+ | asm_keyword maybe_type_qual '(' string ':' asm_operands ':'
+ asm_operands ':' asm_clobbers ')' ';'
+ { if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
+ emit_line_note (input_filename, lineno);
+ c_expand_asm_operands ($4, $6, $8, $10,
+ $2 == ridpointers[(int)RID_VOLATILE],
+ input_filename, lineno);
+ finish_stmt ();
+ }
+ | GOTO '*' expr ';'
+ { emit_line_note (input_filename, lineno);
+ expand_computed_goto ($3); }
+ | GOTO identifier ';'
+ { tree decl;
+ emit_line_note (input_filename, lineno);
+ decl = lookup_label ($2);
+ TREE_USED (decl) = 1;
+ expand_goto (decl); }
+ | label_colon stmt
+ { finish_stmt (); }
+ | label_colon '}'
+ { error ("label must be followed by statement");
+ yyungetc ('}', 0);
+ finish_stmt (); }
+ | ';'
+ { finish_stmt (); }
+
+ /* Exception handling extensions. */
+ | ANSI_THROW ';' { cplus_expand_throw (NULL_TREE); }
+ | ANSI_THROW expr ';' { cplus_expand_throw ($2); }
+ | THROW raise_identifier '(' nonnull_exprlist ')' ';'
+ { cplus_expand_raise ($2, $4, NULL_TREE, 0);
+ finish_stmt (); }
+ | THROW raise_identifier LEFT_RIGHT ';'
+ { cplus_expand_raise ($2, NULL_TREE, NULL_TREE, 0);
+ finish_stmt (); }
+ | RAISE raise_identifier '(' nonnull_exprlist ')' ';'
+ { cplus_expand_raise ($2, $4, NULL_TREE, 0);
+ finish_stmt (); }
+ | RAISE raise_identifier LEFT_RIGHT ';'
+ { cplus_expand_raise ($2, NULL_TREE, NULL_TREE, 0);
+ finish_stmt (); }
+ | RAISE identifier ';'
+ { cplus_expand_reraise ($2);
+ finish_stmt (); }
+ | try EXCEPT identifier '{'
+ {
+ tree decl = cplus_expand_end_try ($1);
+ $<ttype>2 = current_exception_type;
+ $<ttype>4 = current_exception_decl;
+ $<ttype>$ = current_exception_object;
+ cplus_expand_start_except ($3, decl);
+ pushlevel (0);
+ clear_last_expr ();
+ push_momentary ();
+ expand_start_bindings (0);
+ }
+ except_stmts '}'
+ {
+ tree decls = getdecls ();
+ /* If there is a default exception to handle,
+ handle it here. */
+ if ($6)
+ {
+ tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0);
+ tree block;
+
+ pushlevel (1);
+ expand_start_bindings (0);
+ expand_expr ($6, 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 = $<ttype>2;
+ current_exception_decl = $<ttype>4;
+ current_exception_object = $<ttype>5;
+ cplus_expand_end_except ($6);
+ }
+ | try error
+ {
+ cplus_expand_end_try ($1);
+ /* 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);
+ }
+ | ansi_try ansi_dummy ansi_dummy
+ {
+ tree decl = cplus_expand_end_try ($1);
+ $<ttype>2 = current_exception_type;
+ $<ttype>3 = current_exception_decl;
+ $<ttype>$ = current_exception_object;
+ cplus_expand_start_except (NULL, decl);
+ pushlevel (0);
+ clear_last_expr ();
+ push_momentary ();
+ expand_start_bindings (0);
+ }
+ ansi_except_stmts
+ {
+ tree decls = getdecls ();
+ /* If there is a default exception to handle,
+ handle it here. */
+ if ($5)
+ {
+ tree decl = build_decl (CPLUS_CATCH_DECL, NULL_TREE, 0);
+ tree block;
+
+ pushlevel (1);
+ expand_start_bindings (0);
+ expand_expr ($5, 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 = $<ttype>2;
+ current_exception_decl = $<ttype>3;
+ current_exception_object = $<ttype>4;
+ cplus_expand_end_except ($5);
+ }
+ | try RERAISE raise_identifiers /* ';' checked for at bottom. */
+ { 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 ($1), 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 ($3);
+
+ 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");
+ }
+ | try %prec EMPTY
+ { 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 ($1);
+ expand_end_bindings (0, 0, 1);
+ poplevel (0, 0, 0);
+ pop_momentary ();
+ YYERROR; }
+ ;
+
+try: try_head '}'
+ /* An empty try block is degenerate, but it's better to
+ do extra work here than to do all the special-case work
+ everywhere else. */
+ {
+ $$ = 1;
+ pop_implicit_try_blocks (NULL_TREE);
+ }
+ | try_head stmts '}'
+ {
+ $$ = 1;
+ pop_implicit_try_blocks (NULL_TREE);
+ }
+ | try_head error '}'
+ {
+ $$ = 0;
+ pop_implicit_try_blocks (NULL_TREE);
+ }
+ ;
+
+label_colon:
+ IDENTIFIER ':'
+ { tree label;
+ do_label:
+ label = define_label (input_filename, lineno, $1);
+ if (label)
+ expand_label (label);
+ }
+ | PTYPENAME ':'
+ { goto do_label; }
+ | TYPENAME_COLON
+ { tree label = define_label (input_filename, lineno, $1);
+ if (label)
+ expand_label (label);
+ }
+ ;
+
+try_head: TRY '{' { cplus_expand_start_try (0); } .pushlevel
+
+ansi_try: ansi_try_head '}'
+ /* An empty try block is degenerate, but it's better to
+ do extra work here than to do all the special-case work
+ everywhere else. */
+ {
+ $$ = 1;
+ pop_implicit_try_blocks (NULL_TREE);
+ }
+ | ansi_try_head stmts '}'
+ {
+ $$ = 1;
+ pop_implicit_try_blocks (NULL_TREE);
+ }
+ | ansi_try_head error '}'
+ {
+ $$ = 0;
+ pop_implicit_try_blocks (NULL_TREE);
+ }
+ ;
+
+ansi_dummy: ; /* Temporary place-holder. */
+ansi_try_head: ANSI_TRY '{' { cplus_expand_start_try (0); } .pushlevel
+
+except_stmts:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | except_stmts raise_identifier
+ {
+ tree type = lookup_exception_type (current_class_type, current_class_name, $2);
+ if (type == NULL_TREE)
+ {
+ error ("`%s' is not an exception type",
+ IDENTIFIER_POINTER (TREE_VALUE ($2)));
+ 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;
+ }
+ $2 = cplus_expand_start_catch ($2);
+ pushlevel (1);
+ expand_start_bindings (0);
+ }
+ compstmt
+ {
+ expand_end_bindings (0, 1, 0);
+ $4 = poplevel (1, 0, 0);
+
+ cplus_expand_end_catch (0);
+
+ /* Mark this as a catch block. */
+ TREE_LANG_FLAG_2 ($4) = 1;
+ if ($2 != error_mark_node)
+ {
+ tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME ($2), 0);
+ DECL_RTL (decl) = DECL_RTL ($2);
+ TREE_CHAIN (decl) = BLOCK_VARS ($4);
+ BLOCK_VARS ($4) = decl;
+ }
+ }
+ | except_stmts DEFAULT
+ {
+ if ($1)
+ 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 ();
+ $1 = make_node (RTL_EXPR);
+ TREE_TYPE ($1) = void_type_node;
+ start_sequence_for_rtl_expr ($1);
+ }
+ compstmt
+ {
+ 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 ($1) = get_insns ();
+ if ($4)
+ {
+ /* Mark this block as the default catch block. */
+ TREE_LANG_FLAG_1 ($4) = 1;
+ TREE_LANG_FLAG_2 ($4) = 1;
+ }
+ end_sequence ();
+ }
+ ;
+
+optional_identifier:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | identifier ;
+
+ansi_except_stmts:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | ansi_except_stmts CATCH '(' typename optional_identifier ')'
+ {
+ tree type = groktypename ($4);
+ if (IS_SIGNATURE (type))
+ {
+ error ("exception cannot be of signature type");
+ type = error_mark_node;
+ }
+ current_exception_type = type;
+ /* In-place union. */
+ if ($5)
+ {
+ tree tmp;
+ tmp = pushdecl (build_decl (VAR_DECL, $5, type));
+ current_exception_object =
+ build1 (INDIRECT_REF, type, tmp);
+ }
+ $4 = ansi_expand_start_catch(type);
+ pushlevel (1);
+ expand_start_bindings (0);
+ }
+ compstmt
+ {
+ expand_end_bindings (0, 1, 0);
+ $8 = poplevel (1, 0, 0);
+
+ cplus_expand_end_catch (0);
+
+ /* Mark this as a catch block. */
+ TREE_LANG_FLAG_2 ($8) = 1;
+ if ($4 != error_mark_node)
+ {
+ tree decl = build_decl (CPLUS_CATCH_DECL, DECL_NAME ($4), 0);
+ DECL_RTL (decl) = DECL_RTL ($4);
+ TREE_CHAIN (decl) = BLOCK_VARS ($8);
+ BLOCK_VARS ($8) = decl;
+ }
+ }
+ ;
+
+forhead.1:
+ FOR '(' ';'
+ { $$ = NULL_TREE; }
+ | FOR '(' expr ';'
+ { $$ = $3; }
+ | FOR '(' '{' '}'
+ { $$ = NULL_TREE; }
+ ;
+
+forhead.2:
+ FOR '(' decl
+ { $$ = 0; }
+ | FOR '(' error ';'
+ { $$ = 0; }
+ | FOR '(' '{' .pushlevel stmts '}'
+ { $$ = 1; }
+ | FOR '(' '{' .pushlevel error '}'
+ { $$ = -1; }
+ ;
+
+/* Either a type-qualifier or nothing. First thing in an `asm' statement. */
+
+maybe_type_qual:
+ /* empty */
+ { emit_line_note (input_filename, lineno);
+ $$ = NULL_TREE; }
+ | TYPE_QUAL
+ { emit_line_note (input_filename, lineno); }
+ ;
+
+xexpr:
+ /* empty */
+ { $$ = NULL_TREE; }
+ | expr
+ | error
+ { $$ = NULL_TREE; }
+ ;
+
+/* These are the operands other than the first string and colon
+ in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */
+asm_operands: /* empty */
+ { $$ = NULL_TREE; }
+ | nonnull_asm_operands
+ ;
+
+nonnull_asm_operands:
+ asm_operand
+ | nonnull_asm_operands ',' asm_operand
+ { $$ = chainon ($$, $3); }
+ ;
+
+asm_operand:
+ STRING '(' expr ')'
+ { $$ = build_tree_list ($$, $3); }
+ ;
+
+asm_clobbers:
+ STRING
+ { $$ = tree_cons (NULL_TREE, $$, NULL_TREE); }
+ | asm_clobbers ',' STRING
+ { $$ = tree_cons (NULL_TREE, $3, $$); }
+ ;
+
+/* This is what appears inside the parens in a function declarator.
+ Its value is represented in the format that grokdeclarator expects.
+
+ In C++, declaring a function with no parameters
+ means that that function takes *no* parameters. */
+parmlist: /* empty */
+ {
+ if (strict_prototype)
+ $$ = void_list_node;
+ else
+ $$ = NULL_TREE;
+ }
+ | parms
+ {
+ $$ = chainon ($$, void_list_node);
+ TREE_PARMLIST ($$) = 1;
+ }
+ | parms ',' ELLIPSIS
+ {
+ TREE_PARMLIST ($$) = 1;
+ }
+ /* C++ allows an ellipsis without a separating ',' */
+ | parms ELLIPSIS
+ {
+ TREE_PARMLIST ($$) = 1;
+ }
+ | ELLIPSIS
+ {
+ /* ARM $8.2.5 has this as a boxed-off comment. */
+ if (pedantic)
+ warning ("use of `...' without a first argument is non-portable");
+ $$ = NULL_TREE;
+ }
+ | TYPENAME_ELLIPSIS
+ {
+ TREE_PARMLIST ($$) = 1;
+ }
+ | parms TYPENAME_ELLIPSIS
+ {
+ TREE_PARMLIST ($$) = 1;
+ }
+ | parms ':'
+ {
+ /* This helps us recover from really nasty
+ parse errors, for example, a missing right
+ parenthesis. */
+ yyerror ("possibly missing ')'");
+ $$ = chainon ($$, void_list_node);
+ TREE_PARMLIST ($$) = 1;
+ yyungetc (':', 0);
+ yychar = ')';
+ }
+ ;
+
+/* A nonempty list of parameter declarations or type names. */
+parms:
+ parm
+ { $$ = build_tree_list (NULL_TREE, $$); }
+ | parm '=' init
+ { $$ = build_tree_list ($3, $$); }
+ | parms ',' parm
+ { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
+ | parms ',' parm '=' init
+ { $$ = chainon ($$, build_tree_list ($5, $3)); }
+ | parms ',' bad_parm
+ { $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
+ | parms ',' bad_parm '=' init
+ { $$ = chainon ($$, build_tree_list ($5, $3)); }
+ ;
+
+/* A single parameter declaration or parameter type name,
+ as found in a parmlist. The first four cases make up for 10%
+ of the time spent parsing C++. We cannot use them because
+ of `int id[]' which won't get parsed properly. */
+parm:
+/*
+ typed_declspecs dont_see_typename '*' IDENTIFIER
+ { $$ = build_tree_list ($$, build_parse_node (INDIRECT_REF, $4));
+ see_typename (); }
+ | typed_declspecs dont_see_typename '&' IDENTIFIER
+ { $$ = build_tree_list ($$, build_parse_node (ADDR_EXPR, $4));
+ see_typename (); }
+ | TYPENAME IDENTIFIER
+ { $$ = build_tree_list (list_hash_lookup_or_cons ($$), $2); }
+ | TYPESPEC IDENTIFIER
+ { $$ = build_tree_list (list_hash_lookup_or_cons ($$), $2); }
+ | */
+ typed_declspecs dont_see_typename abs_or_notype_decl
+ { $$ = build_tree_list ($$, $3);
+ see_typename (); }
+ | declmods dont_see_typename abs_or_notype_decl
+ { $$ = build_tree_list ($$, $3);
+ see_typename (); }
+ ;
+
+abs_or_notype_decl: absdcl
+ | notype_declarator
+ | START_DECLARATOR notype_declarator
+ { $$ = $2; }
+ ;
+
+see_typename: type_quals
+ { see_typename (); }
+ ;
+
+dont_see_typename: %prec EMPTY /* empty */
+ { dont_see_typename (); }
+ ;
+
+/*
+try_for_typename:
+ {
+ if ($<ttype>-1 == error_mark_node)
+ $$ = 0;
+ else
+ {
+ $$ = 1;
+ pushclass ($<ttype>-1, 1);
+ }
+ }
+ ;
+*/
+
+bad_parm:
+ abs_or_notype_decl
+ {
+ warning ("type specifier omitted for parameter");
+ $$ = build_tree_list (TREE_PURPOSE (TREE_VALUE ($<ttype>-1)), $$);
+ }
+ ;
+
+maybe_raises:
+ %prec EMPTY /* empty */
+ { $$ = NULL_TREE; }
+ | RAISES raise_identifiers %prec EMPTY
+ { $$ = $2; }
+ | ANSI_THROW '(' ansi_raise_identifiers ')' %prec EMPTY
+ { $$ = $3; }
+ ;
+
+raise_identifier:
+ ALL
+ { $$ = void_list_node; }
+ | IDENTIFIER
+ { $$ = build_decl_list (NULL_TREE, $$); }
+ | TYPENAME
+ { $$ = build_decl_list (NULL_TREE, $$); }
+ | SCOPE IDENTIFIER
+ { $$ = build_decl_list (void_type_node, $2); }
+ | SCOPE TYPENAME
+ { $$ = build_decl_list (void_type_node, $2); }
+ | id_scope IDENTIFIER
+ { $$ = build_decl_list ($$, $2); }
+ | scoped_typename
+ ;
+
+ansi_raise_identifier:
+ typename
+ { $$ = build_decl_list (NULL_TREE, $$); }
+ ;
+
+raise_identifiers:
+ raise_identifier
+ | raise_identifiers ',' raise_identifier
+ {
+ TREE_CHAIN ($3) = $$;
+ $$ = $3;
+ }
+ ;
+
+ansi_raise_identifiers:
+ ansi_raise_identifier
+ | ansi_raise_identifiers ',' ansi_raise_identifier
+ {
+ TREE_CHAIN ($3) = $$;
+ $$ = $3;
+ }
+ ;
+
+operator_name:
+ OPERATOR '*'
+ { $$ = ansi_opname[MULT_EXPR]; }
+ | OPERATOR '/'
+ { $$ = ansi_opname[TRUNC_DIV_EXPR]; }
+ | OPERATOR '%'
+ { $$ = ansi_opname[TRUNC_MOD_EXPR]; }
+ | OPERATOR '+'
+ { $$ = ansi_opname[PLUS_EXPR]; }
+ | OPERATOR '-'
+ { $$ = ansi_opname[MINUS_EXPR]; }
+ | OPERATOR '&'
+ { $$ = ansi_opname[BIT_AND_EXPR]; }
+ | OPERATOR '|'
+ { $$ = ansi_opname[BIT_IOR_EXPR]; }
+ | OPERATOR '^'
+ { $$ = ansi_opname[BIT_XOR_EXPR]; }
+ | OPERATOR '~'
+ { $$ = ansi_opname[BIT_NOT_EXPR]; }
+ | OPERATOR ','
+ { $$ = ansi_opname[COMPOUND_EXPR]; }
+ | OPERATOR ARITHCOMPARE
+ { $$ = ansi_opname[$2]; }
+ | OPERATOR '<'
+ { $$ = ansi_opname[LT_EXPR]; }
+ | OPERATOR '>'
+ { $$ = ansi_opname[GT_EXPR]; }
+ | OPERATOR EQCOMPARE
+ { $$ = ansi_opname[$2]; }
+ | OPERATOR ASSIGN
+ { $$ = ansi_assopname[$2]; }
+ | OPERATOR '='
+ { $$ = ansi_opname [MODIFY_EXPR]; }
+ | OPERATOR LSHIFT
+ { $$ = ansi_opname[$2]; }
+ | OPERATOR RSHIFT
+ { $$ = ansi_opname[$2]; }
+ | OPERATOR PLUSPLUS
+ { $$ = ansi_opname[POSTINCREMENT_EXPR]; }
+ | OPERATOR MINUSMINUS
+ { $$ = ansi_opname[PREDECREMENT_EXPR]; }
+ | OPERATOR ANDAND
+ { $$ = ansi_opname[TRUTH_ANDIF_EXPR]; }
+ | OPERATOR OROR
+ { $$ = ansi_opname[TRUTH_ORIF_EXPR]; }
+ | OPERATOR '!'
+ { $$ = ansi_opname[TRUTH_NOT_EXPR]; }
+ | OPERATOR '?' ':'
+ { $$ = ansi_opname[COND_EXPR]; }
+ | OPERATOR MIN_MAX
+ { $$ = ansi_opname[$2]; }
+ | OPERATOR POINTSAT %prec EMPTY
+ { $$ = ansi_opname[COMPONENT_REF]; }
+ | OPERATOR POINTSAT_STAR %prec EMPTY
+ { $$ = ansi_opname[MEMBER_REF]; }
+ | OPERATOR LEFT_RIGHT
+ { $$ = ansi_opname[CALL_EXPR]; }
+ | OPERATOR '[' ']'
+ { $$ = ansi_opname[ARRAY_REF]; }
+ | OPERATOR NEW
+ { $$ = ansi_opname[NEW_EXPR]; }
+/*
+ | OPERATOR NEW '[' ']'
+ { $$ = ansi_opname[VEC_NEW_EXPR]; }
+*/
+ | OPERATOR DELETE
+ { $$ = ansi_opname[DELETE_EXPR]; }
+/*
+ | OPERATOR DELETE '[' ']'
+ { $$ = ansi_opname[VEC_DELETE_EXPR]; }
+*/
+
+ /* These should do `groktypename' and set up TREE_HAS_X_CONVERSION
+ here, rather than doing it in class.c . */
+ | OPERATOR typed_typespecs absdcl
+ { $$ = build1 (TYPE_EXPR, $2, $3); }
+ | OPERATOR error
+ { $$ = ansi_opname[ERROR_MARK]; }
+ ;
+
+%%
--- /dev/null
+/* 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 "flags.h"
+#include "cp-tree.h"
+#include "decl.h"
+#include "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);
+ pushlevel (0);
+}
+
+/* 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;
+ tree decl = 0;
+ 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)
+ {
+ tree tinfo = 0;
+ int idx = 0;
+ 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),
+ PARM, 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;
+ }
+ tinfo = make_node (TEMPLATE_CONST_PARM);
+ my_friendly_assert (TREE_PERMANENT (tinfo), 260.5);
+ if (TREE_PERMANENT (parm) == 0)
+ {
+ parm = copy_node (parm);
+ TREE_PERMANENT (parm) = 1;
+ }
+ TREE_TYPE (tinfo) = TREE_TYPE (parm);
+ decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
+ DECL_INITIAL (decl) = tinfo;
+ DECL_INITIAL (parm) = tinfo;
+ }
+ else
+ {
+ tree t = make_node (TEMPLATE_TYPE_PARM);
+ decl = build_lang_decl (TYPE_DECL, TREE_PURPOSE (parm), t);
+ TYPE_NAME (t) = decl;
+ TREE_VALUE (parm) = t;
+ }
+ pushdecl (decl);
+ 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);
+
+ for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++)
+ {
+ tree p = parm;
+ if (TREE_CODE (p) == TREE_LIST)
+ {
+ tree t = TREE_VALUE (p);
+ TREE_VALUE (p) = NULL_TREE;
+ p = TREE_PURPOSE (p);
+ my_friendly_assert (TREE_CODE (p) == IDENTIFIER_NODE, 261);
+ TEMPLATE_TYPE_SET_INFO (t, saved_parmlist, nparms);
+ }
+ else
+ {
+ tree tinfo = DECL_INITIAL (p);
+ DECL_INITIAL (p) = NULL_TREE;
+ TEMPLATE_CONST_SET_INFO (tinfo, saved_parmlist, nparms);
+ }
+ TREE_VEC_ELT (saved_parmlist, nparms) = p;
+ }
+ 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] */
+
+ 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);
+ if (interface_unknown && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
+ warn_if_unknown_interface ();
+ TREE_PUBLIC (decl) = TREE_PUBLIC (d2) = flag_external_templates && !interface_unknown;
+ 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 ();
+}
+
+/* If TYPE contains a template parm type, then substitute that type
+ with its actual type that is found in TVEC. */
+static void
+grok_template_type (tvec, type)
+ tree tvec;
+ tree* type;
+{
+ switch (TREE_CODE (*type))
+ {
+ case TEMPLATE_TYPE_PARM:
+ if (*type != TYPE_MAIN_VARIANT (*type))
+ {
+ /* we are here for cases like const T* etc. */
+ grok_template_type (tvec, &TYPE_MAIN_VARIANT (*type));
+ *type = build_type_variant (TYPE_MAIN_VARIANT (*type),
+ TYPE_READONLY (*type),
+ TYPE_VOLATILE (*type));
+ }
+ else
+ *type = TREE_VEC_ELT (tvec, TEMPLATE_TYPE_IDX (*type));
+ return;
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ grok_template_type (tvec, &TREE_TYPE (*type));
+ return;
+ case FUNCTION_TYPE:
+ {
+ tree p;
+
+ /* take care of function's return type first */
+ grok_template_type (tvec, &TREE_TYPE (*type));
+
+ /* take care of function's arguments */
+ for (p = TYPE_ARG_TYPES (*type); p; p = TREE_CHAIN (p))
+ grok_template_type (tvec, &TREE_VALUE (p));
+ return;
+ }
+ default:
+ break;
+ }
+ return;
+}
+
+/* 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)
+ cp_error_at ("in template expansion for decl `%D'", in_decl);
+ 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 = 0;
+ 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)
+ cp_error_at ("type/value mismatch in template parameter list for `%D'", in_decl);
+ lost++;
+ TREE_VEC_ELT (vec, i) = error_mark_node;
+ continue;
+ }
+ if (is_type)
+ val = groktypename (arg);
+ else if (TREE_CODE (arg) == STRING_CST)
+ {
+ cp_error ("string literal %E is not a valid template argument", arg);
+ error ("because it is the address of an object with static linkage");
+ val = error_mark_node;
+ }
+ else
+ {
+ grok_template_type (vec, &TREE_TYPE (parm));
+ val = digest_init (TREE_TYPE (parm), arg, (tree *) 0);
+
+ if (val == error_mark_node)
+ ;
+
+ /* 14.2: Other template-arguments must be constant-expressions,
+ addresses of objects or functions with external linkage, or of
+ static class members. */
+ else if (!TREE_CONSTANT (val))
+ {
+ cp_error ("non-const `%E' cannot be used as template argument",
+ arg);
+ val = error_mark_node;
+ }
+ else if (TREE_CODE (val) == ADDR_EXPR)
+ {
+ tree a = TREE_OPERAND (val, 0);
+ if ((TREE_CODE (a) == VAR_DECL
+ || TREE_CODE (a) == FUNCTION_DECL)
+ && !TREE_PUBLIC (a))
+ {
+ cp_error ("address of non-extern `%E' cannot be used as template argument", a);
+ val = error_mark_node;
+ }
+ }
+ }
+
+ 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. */
+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);
+
+ if (i)
+ ccat (',');
+
+ if (TREE_CODE (parm) == IDENTIFIER_NODE)
+ {
+ cat (type_as_string (arg, 0));
+ continue;
+ }
+ else
+ my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
+
+ 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);
+ }
+ /* No need to check arglist against parmlist here; we did that
+ in coerce_template_parms, called from lookup_template_class. */
+ cat (expr_as_string (arg, 0));
+ }
+ {
+ char *bufp = obstack_next_free (&scratch_obstack);
+ int offset = 0;
+ while (bufp[offset - 1] == ' ')
+ offset--;
+ obstack_blank_fast (&scratch_obstack, offset);
+
+ /* B<C<char> >, not B<C<char>> */
+ if (bufp[offset - 1] == '>')
+ ccat (' ');
+ }
+ 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)
+ {
+ cp_error ("non-template type `%T' used as a template", d1);
+ if (in_decl)
+ cp_error_at ("for template declaration `%D'", in_decl);
+ 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;
+}
+\f
+void
+push_template_decls (parmlist, arglist, class_level)
+ tree parmlist, arglist;
+ int class_level;
+{
+ int i, nparms;
+
+ /* 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);
+}
+
+void
+pop_template_decls (parmlist, arglist, class_level)
+ tree parmlist, arglist;
+ int class_level;
+{
+ if (!class_level)
+ poplevel (0, 0, 0);
+}
+\f
+/* 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 (classname)
+ tree classname;
+{
+ tree t;
+ 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 = 0, 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:
+ cp_error ("type unification error instantiating %T::%D",
+ classname, tdecl);
+ cp_error_at ("for template declaration `%D'", tdecl);
+
+ continue /* loop of members */;
+ default:
+ /* Eek, a bug. */
+ my_friendly_abort (83);
+ }
+ }
+}
+
+struct tinst_level *current_tinst_level = 0;
+struct tinst_level *free_tinst_level = 0;
+
+void
+push_tinst_level (name)
+ tree name;
+{
+ struct tinst_level *new;
+ tree global = IDENTIFIER_GLOBAL_VALUE (name);
+
+ if (free_tinst_level)
+ {
+ new = free_tinst_level;
+ free_tinst_level = new->next;
+ }
+ else
+ new = (struct tinst_level *) xmalloc (sizeof (struct tinst_level));
+
+ new->classname = name;
+ if (global)
+ {
+ new->line = DECL_SOURCE_LINE (global);
+ new->file = DECL_SOURCE_FILE (global);
+ }
+ else
+ {
+ new->line = lineno;
+ new->file = input_filename;
+ }
+ new->next = current_tinst_level;
+ current_tinst_level = new;
+}
+
+void
+pop_tinst_level ()
+{
+ struct tinst_level *old = current_tinst_level;
+
+ current_tinst_level = old->next;
+ old->next = free_tinst_level;
+ free_tinst_level = old;
+}
+
+struct tinst_level *
+tinst_for_decl ()
+{
+ struct tinst_level *p = current_tinst_level;
+
+ if (p)
+ for (; p->next ; p = p->next )
+ ;
+ return p;
+}
+
+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 IDENTIFIER_LOCAL_VALUE is already set on this template classname
+ (it's something like `foo<int>'), that means we're already working on
+ the instantiation for it. Normally, a classname comes in with nothing
+ but its IDENTIFIER_TEMPLATE slot set. If we were to try to instantiate
+ this again, we'd get a redeclaration error. Since we're already working
+ on it, we'll pass back this classname's TYPE_DECL (it's the value of
+ the classname's IDENTIFIER_LOCAL_VALUE). Only do this if we're setting
+ things up for the parser, though---if we're just trying to instantiate
+ it (e.g., via tsubst) we can trip up cuz it may not have an
+ IDENTIFIER_TYPE_VALUE when it will need one. */
+ if (setup_parse && IDENTIFIER_LOCAL_VALUE (classname))
+ return IDENTIFIER_LOCAL_VALUE (classname);
+
+ 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;
+
+ push_to_top_level ();
+ template_info = DECL_TEMPLATE_INFO (t1);
+ if (setup_parse)
+ {
+ push_tinst_level (classname);
+ push_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (template)),
+ TREE_VALUE (template), 0);
+ set_current_level_tags_transparency (1);
+ 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 = classname;
+ processing_template_defn++;
+ if (!flag_external_templates)
+ interface_unknown++;
+ }
+ 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, 0);
+ my_friendly_assert (TREE_CODE (t) == RECORD_TYPE
+ || TREE_CODE (t) == UNION_TYPE, 280);
+
+ /* 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 ();
+ }
+
+ 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
+lookup_nested_type_by_name (ctype, name)
+ tree ctype, name;
+{
+ tree t;
+
+ t = TREE_VALUE(CLASSTYPE_TAGS(ctype));
+ while (t)
+ {
+ if (strcmp(IDENTIFIER_POINTER(name), IDENTIFIER_POINTER(TYPE_IDENTIFIER(t)))
+ == 0)
+ return t;
+ else
+ t = TREE_CHAIN(t);
+ }
+ return NULL_TREE;
+}
+
+static tree
+search_nested_type_in_tmpl (tmpl, type)
+ tree tmpl, type;
+{
+ tree t;
+
+ if (tmpl == NULL || TYPE_CONTEXT(type) == NULL)
+ return tmpl;
+ t = search_nested_type_in_tmpl (tmpl, TYPE_CONTEXT(type));
+ if (t == NULL) return t;
+ t = lookup_nested_type_by_name(t, DECL_NAME(TYPE_NAME(type)));
+ return t;
+}
+
+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 RECORD_TYPE:
+ if (TYPE_PTRMEMFUNC_P (t))
+ return build_ptrmemfunc_type
+ (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, nargs, in_decl));
+
+ /* else fall through */
+
+ 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 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 = DECL_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:
+ cp_error
+ (found
+ ? "template for method `%D' doesn't match any in class `%T'"
+ : "method `%D' not found in class `%T'", name, ctx);
+ if (in_decl)
+ cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl);
+ return error_mark_node;
+ }
+ }
+ else
+ {
+ r = DECL_NAME (t);
+ {
+ tree decls;
+ int got_it = 0;
+
+ decls = IDENTIFIER_GLOBAL_VALUE (r);
+ if (decls == NULL_TREE)
+ /* no match */;
+ else if (TREE_CODE (decls) == TREE_LIST)
+ for (decls = TREE_VALUE (decls); decls ;
+ decls = DECL_CHAIN (decls))
+ {
+ if (TREE_CODE (decls) == FUNCTION_DECL
+ && TREE_TYPE (decls) == type)
+ {
+ got_it = 1;
+ r = decls;
+ break;
+ }
+ }
+ else
+ {
+ tree val = decls;
+ decls = NULL_TREE;
+ if (TREE_CODE (val) == FUNCTION_DECL
+ && TREE_TYPE (val) == type)
+ {
+ got_it = 1;
+ r = val;
+ break;
+ }
+ }
+
+ 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);
+ {
+#if 0 /* Maybe later. -jason */
+ struct tinst_level *til = tinst_for_decl();
+
+ /* should always be true under new approach */
+ if (til)
+ {
+ DECL_SOURCE_FILE (r) = til->file;
+ DECL_SOURCE_LINE (r) = til->line;
+ }
+ else
+#endif
+ {
+ 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_list_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, rt;
+ 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);
+ }
+ rt = IDENTIFIER_TYPE_VALUE (id);
+
+ /* kung: this part handles nested type in template definition */
+
+ if ( !ANON_AGGRNAME_P (DECL_NAME(TYPE_NAME(t))))
+ {
+ rt = search_nested_type_in_tmpl (rt, t);
+ }
+
+ return build_type_variant (rt, 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->buf = t->text;
+ p->len = t->length;
+ p->fndecl = fndecl;
+ {
+ int l = lineno;
+ char * f = input_filename;
+
+ lineno = p->lineno = t->lineno;
+ input_filename = p->filename = t->filename;
+
+ extract_interface_info ();
+
+ if (interface_unknown && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (tmpl))
+ warn_if_unknown_interface ();
+ if (interface_unknown || !flag_external_templates)
+ p->interface = 1; /* unknown */
+ else
+ p->interface = interface_only ? 0 : 2;
+
+ lineno = l;
+ input_filename = f;
+
+ extract_interface_info ();
+ }
+ }
+ 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;
+
+#if 0 /* not yet, should get fixed properly later */
+ poplevel (0, 0, 0);
+#endif
+#if 1 /* XXX */
+ /* This was a botch... See `overload_template_name' just below. */
+ if (!classlevel)
+ poplevel (0, 0, 0);
+#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;
+
+ template = TREE_PURPOSE (template);
+ tinfo = DECL_TEMPLATE_INFO (template);
+ template = DECL_NAME (template);
+ my_friendly_assert (template != NULL_TREE, 285);
+
+#if 1 /* XXX */
+ /* This was a botch... names of templates do not get their own private
+ scopes. Rather, the names of generated template instances should
+ just get pushed into whatever scope we happen to be in at the moment.
+ This will typically (but not always) be the global scope. (Maybe
+ what we really want to do here is a `push_to_toplevel' and then stay
+ there while we are generating the instance; popping back out to the
+ current scope when we are done generating the instance.) */
+ if (!classlevel)
+ {
+ pushlevel (1);
+ declare_pseudo_global_level ();
+ }
+#endif
+
+ t = xref_tag (tinfo->aggr, id, NULL_TREE, 0);
+ my_friendly_assert (TREE_CODE (t) == RECORD_TYPE
+ || TREE_CODE (t) == UNION_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
+
+ /* Fake this for now, just to make dwarfout.c happy. It will have to
+ be done in a proper way later on. */
+ DECL_CONTEXT (decl) = t;
+}
+
+/* NAME is the IDENTIFIER value of a PRE_PARSED_CLASS_DECL. */
+void
+end_template_instantiation (name)
+ tree name;
+{
+ extern struct pending_input *to_be_restored;
+ tree t, decl;
+
+ processing_template_defn--;
+ if (!flag_external_templates)
+ interface_unknown--;
+
+ /* 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 (name);
+ my_friendly_assert (t != NULL_TREE
+ && TREE_CODE_CLASS (TREE_CODE (t)) == 't',
+ 287);
+ CLASSTYPE_USE_TEMPLATE (t) = 2;
+ /* Make methods of template classes static, unless
+ -fexternal-templates is given. */
+ if (!flag_external_templates)
+ SET_CLASSTYPE_INTERFACE_UNKNOWN (t);
+ decl = IDENTIFIER_GLOBAL_VALUE (name);
+ my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 288);
+
+ undo_template_name_overload (name, 0);
+ t = IDENTIFIER_TEMPLATE (name);
+ pop_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (t)), TREE_VALUE (t),
+ 0);
+ /* This will fix up the type-value field. */
+ pushdecl (decl);
+ pop_from_top_level ();
+
+#ifdef DWARF_DEBUGGING_INFO
+ if (write_symbols == DWARF_DEBUG && TREE_CODE (decl) == TYPE_DECL)
+ {
+ /* We just completed the definition of a new file-scope type,
+ so we can go ahead and output debug-info for it now. */
+ TYPE_STUB_DECL (TREE_TYPE (decl)) = decl;
+ rest_of_type_compilation (TREE_TYPE (decl), 1);
+ }
+#endif /* DWARF_DEBUGGING_INFO */
+
+ /* Restore interface/implementation settings. */
+ extract_interface_info ();
+}
+\f
+/* 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;
+ extern struct obstack inline_text_obstack; /* see comment in cp-lex.c */
+
+ if (d2 == NULL_TREE || d2 == error_mark_node)
+ {
+ lose:
+ /* @@ Should use temp obstack, and discard results. */
+ reinit_parse_for_block (yychar, &inline_text_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, &inline_text_obstack, 1);
+ template_info->text = obstack_base (&inline_text_obstack);
+ template_info->length = obstack_object_size (&inline_text_obstack);
+ obstack_finish (&inline_text_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.
+
+ If SUBR is 1, we're being called recursively (to unify the arguments of
+ a function or method parameter of a function template), so don't zero
+ out targs and don't fail on an incomplete match. */
+
+int
+type_unification (tparms, targs, parms, args, nsubsts, subr)
+ tree tparms, *targs, parms, args;
+ int *nsubsts, subr;
+{
+ 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);
+
+ if (!subr)
+ bzero (targs, sizeof (tree) * ntparms);
+
+ while (parms
+ && parms != void_list_node
+ && args
+ && args != void_list_node)
+ {
+ 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
+ if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't')
+ {
+ my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293);
+ arg = TREE_TYPE (arg);
+ }
+#endif
+ if (TREE_CODE (arg) == FUNCTION_TYPE
+ || TREE_CODE (arg) == METHOD_TYPE)
+ arg = build_pointer_type (arg);
+
+ 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 && args != void_list_node && 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;
+ if (!subr)
+ 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, ntparms;
+{
+ 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;
+
+ if (TREE_CODE (arg) == REFERENCE_TYPE)
+ arg = TREE_TYPE (arg);
+
+ 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:
+ if (TYPE_PTRMEMFUNC_P (parm))
+ return unify (tparms, targs, ntparms, TYPE_PTRMEMFUNC_FN_TYPE (parm),
+ arg, nsubsts);
+
+ /* Unification of something that is not a template fails. (mrs) */
+ return 1;
+
+ case METHOD_TYPE:
+ if (TREE_CODE (arg) != METHOD_TYPE)
+ return 1;
+ goto check_args;
+
+ case FUNCTION_TYPE:
+ if (TREE_CODE (arg) != FUNCTION_TYPE)
+ return 1;
+ check_args:
+ return type_unification (tparms, targs, TYPE_ARG_TYPES (parm),
+ TYPE_ARG_TYPES (arg), nsubsts, 1);
+
+ default:
+ sorry ("use of `%s' in template type unification",
+ tree_code_name [(int) TREE_CODE (parm)]);
+ return 1;
+ }
+}
+
+\f
+#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?
+ Maybe only do this if i->interface == 1 (unknown)? */
+ context = DECL_CONTEXT (t);
+ if (context != NULL_TREE
+ && TREE_CODE_CLASS (TREE_CODE (context)) == 't')
+ {
+ /* I'm interested in the context of this version of the function,
+ not the original virtual declaration. */
+ context = DECL_CLASS_CONTEXT (t);
+
+ /* If `unknown', we might want a static copy.
+ If `implementation', we want a global one.
+ If `interface', ext ref. */
+ if (CLASSTYPE_INTERFACE_KNOWN (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
+ }
+
+ if (i->interface == 1)
+ DECIDE (TREE_USED (t));
+ else
+ DECIDE (i->interface);
+
+ 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)
+ {
+ 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;
+}
+
+\f
+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;
+}
+
+/* called from the parser. */
+void
+do_function_instantiation (declspecs, declarator)
+ tree declspecs, declarator;
+{
+ tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, 0);
+ tree name = DECL_NAME (decl);
+ tree fn = IDENTIFIER_GLOBAL_VALUE (name);
+ tree result = NULL_TREE;
+ if (fn)
+ {
+ for (fn = get_first_fn (fn); fn; fn = DECL_CHAIN (fn))
+ if (TREE_CODE (fn) == TEMPLATE_DECL)
+ {
+ int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (fn));
+ tree *targs = (tree *) malloc (sizeof (tree) * ntparms);
+ int i, dummy;
+ i = type_unification (DECL_TEMPLATE_PARMS (fn), targs,
+ TYPE_ARG_TYPES (TREE_TYPE (fn)),
+ TYPE_ARG_TYPES (TREE_TYPE (decl)),
+ &dummy, 0);
+ if (i == 0)
+ {
+ if (result)
+ cp_error ("ambiguous template instantiation for `%D' requested", decl);
+ else
+ result = instantiate_template (fn, targs);
+ }
+ }
+ }
+ if (!result)
+ cp_error ("no matching template for `%D' found", decl);
+}
--- /dev/null
+/* 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 (DECL_MUTABLE_P (node))
+ {
+ indent_to (file, indent + 3);
+ fprintf (file, " mutable ");
+ }
+ 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_CONSTRUCTING (node))
+ fputs ( "needs-constructor", file);
+ if (TYPE_NEEDS_DESTRUCTOR (node))
+ fputs (" needs-destructor", file);
+ if (TYPE_HAS_DESTRUCTOR (node))
+ fputs (" ~X()", file);
+ if (TYPE_HAS_DEFAULT_CONSTRUCTOR (node))
+ fputs (" X()", 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))
+ {
+ if (TYPE_HAS_CONST_INIT_REF (node))
+ fputs (" X(constX&)", file);
+ else
+ 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_HAS_ASSIGN_REF (node))
+ fputs (" this=(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);
+}
--- /dev/null
+/* 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. */
+
+/* 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;
+
+/* 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;
+ obstack_grow (obstack, tp, size);
+ stack = (struct stack_level *) ((char*)obstack_next_free (obstack) - 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. */
+static struct search_level *
+pop_search_level (obstack)
+ struct stack_level *obstack;
+{
+ register struct search_level *stack = pop_stack_level (obstack);
+
+ return stack;
+}
+\f
+/* 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;
+
+/* This list is used by push_class_decls to know what decls need to
+ be pushed into class scope. */
+static tree closed_envelopes = NULL_TREE;
+
+/* 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;
+}
+\f
+/* 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 an access control 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;
+}
+\f
+/* This is the newer recursive depth first search routine. */
+/* Return non-zero if PARENT is directly derived from TYPE. By directly
+ we mean it's only one step up the inheritance lattice. We check this
+ by walking horizontally across the types that TYPE directly inherits
+ from, to see if PARENT is among them. This is used by get_binfo and
+ by compute_access. */
+static int
+immediately_derived (parent, type)
+ tree parent, type;
+{
+ if (TYPE_BINFO (type))
+ {
+ tree binfos = BINFO_BASETYPES (TYPE_BINFO (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);
+
+ if (parent == BINFO_TYPE (base_binfo))
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* 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.
+
+ If PROTECT is 1, then check if access to a public field of PARENT
+ would be private. Also check for ambiguity. */
+
+tree
+get_binfo (parent, binfo, protect)
+ register tree parent, binfo;
+ int protect;
+{
+ tree type;
+ int dist;
+ 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 NULL_TREE;
+ else if (TREE_CODE (parent) != RECORD_TYPE)
+ my_friendly_abort (89);
+
+ if (TREE_CODE (binfo) == TREE_VEC)
+ type = BINFO_TYPE (binfo);
+ else if (TREE_CODE (binfo) == RECORD_TYPE)
+ type = binfo;
+ else
+ my_friendly_abort (90);
+
+ dist = get_base_distance (parent, binfo, protect, &rval);
+
+ if (dist == -3)
+ {
+ cp_error ("fields of `%T' are inaccessible in `%T' due to private inheritance",
+ parent, type);
+ return error_mark_node;
+ }
+ else if (dist == -2 && protect)
+ {
+ cp_error ("type `%T' is ambiguous base class for type `%T'", parent,
+ type);
+ return error_mark_node;
+ }
+
+ return rval;
+}
+
+/* This is the newer depth first get_base_distance routine. */
+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 || 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)
+ {
+ if (*rval_private_ptr && ! is_private)
+ {
+ *rval_private_ptr = is_private;
+ *new_binfo_ptr = binfo;
+ *via_virtual_ptr = via_virtual;
+ }
+ 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);
+
+ /* Find any specific instance of a virtual base, when searching with
+ a binfo... */
+ if (BINFO_MARKED (base_binfo) == 0 || TREE_CODE (parent) == TREE_VEC)
+ {
+ int via_private
+ = (protect
+ && (is_private
+ || (!TREE_VIA_PUBLIC (base_binfo)
+ && !is_friend (BINFO_TYPE (binfo), current_scope ()))));
+ int this_virtual = via_virtual || TREE_VIA_VIRTUAL (base_binfo);
+ int was;
+
+ /* When searching for a non-virtual, we cannot mark
+ virtually found binfos. */
+ if (! this_virtual)
+ SET_BINFO_MARKED (base_binfo);
+
+#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,
+ this_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, and PROTECT is
+ non-negative.
+ 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.
+
+ PARENT can also be a binfo, in which case that exact parent is found
+ and no other. convert_pointer_to_real uses this functionality.
+
+ If BINFO is a binfo, its BINFO_INHERITANCE_CHAIN will be left alone.
+
+ Code in prepare_fresh_vtable relies upon the path being built even
+ when -2 is returned. */
+
+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;
+ int depth = 0;
+ int rval_private = 0;
+ tree type;
+ tree new_binfo = NULL_TREE;
+ int via_virtual;
+ int watch_access = protect;
+
+ if (TREE_CODE (parent) != TREE_VEC)
+ 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);
+
+ if (path_ptr)
+ BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
+ }
+ else
+ my_friendly_abort (92);
+
+ if (parent == type || parent == binfo)
+ {
+ /* 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 = binfo;
+ return 0;
+ }
+
+ if (path_ptr)
+ watch_access = 1;
+
+ rval = get_base_distance_recursive (binfo, 0, 0, NULL_TREE, -1,
+ &rval_private, &new_binfo, parent,
+ path_ptr, watch_access, &via_virtual, 0);
+
+ dfs_walk (binfo, dfs_unmark, markedp);
+
+ /* Access restrictions don't count if we found an ambiguous basetype. */
+ if (rval == -2 && protect >= 0)
+ rval_private = 0;
+
+ if (rval && protect && rval_private)
+ return -3;
+
+ if (path_ptr)
+ *path_ptr = new_binfo;
+ return rval;
+}
+
+/* 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 can access 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;
+}
+
+tree
+current_scope ()
+{
+ if (current_function_decl == NULL_TREE)
+ return current_class_type;
+ if (current_class_type == NULL_TREE)
+ return current_function_decl;
+ if (DECL_CLASS_CONTEXT (current_function_decl) == current_class_type)
+ return current_function_decl;
+
+ return current_class_type;
+}
+
+/* Compute the access of FIELD. This is done by computing
+ the access 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
+ access defines the access for the field. Otherwise, the
+ access 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.
+
+ access_public means that the field can be accessed by the current lexical
+ scope.
+
+ access_protected means that the field cannot be accessed by the current
+ lexical scope because it is protected.
+
+ access_private means that the field cannot be accessed by the current
+ lexical scope because it is private. */
+
+#if 0
+#define PUBLIC_RETURN return (DECL_PUBLIC (field) = 1), access_public
+#define PROTECTED_RETURN return (DECL_PROTECTED (field) = 1), access_protected
+#define PRIVATE_RETURN return (DECL_PRIVATE (field) = 1), access_private
+#else
+#define PUBLIC_RETURN return access_public
+#define PROTECTED_RETURN return access_protected
+#define PRIVATE_RETURN return access_private
+#endif
+
+#if 0
+/* Disabled with DECL_PUBLIC &c. */
+static tree previous_scope = NULL_TREE;
+#endif
+
+enum access_type
+compute_access (basetype_path, field)
+ tree basetype_path, field;
+{
+ enum access_type access;
+ tree types;
+ tree context;
+ int protected_ok, via_protected;
+#if 1
+ /* Replaces static decl above. */
+ tree previous_scope;
+#endif
+
+ /* The field lives in the current class. */
+ if (BINFO_TYPE (basetype_path) == current_class_type)
+ return access_public;
+
+#if 0
+ /* Disabled until pushing function scope clears these out. If ever. */
+ /* Make these special cases fast. */
+ if (current_scope () == previous_scope)
+ {
+ if (DECL_PUBLIC (field))
+ return access_public;
+ if (DECL_PROTECTED (field))
+ return access_protected;
+ if (DECL_PRIVATE (field))
+ return access_private;
+ }
+#endif
+
+ previous_scope = current_scope ();
+
+ context = DECL_CLASS_CONTEXT (field);
+ if (context == NULL_TREE)
+ context = DECL_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)
+ PUBLIC_RETURN;
+
+ /* Member found immediately within object. */
+ if (BINFO_INHERITANCE_CHAIN (basetype_path) == NULL_TREE)
+ {
+ /* Are we (or an enclosing scope) friends with the class that has
+ FIELD? */
+ if (is_friend (context, previous_scope))
+ PUBLIC_RETURN;
+
+ /* If it's private, it's private, you letch. */
+ if (TREE_PRIVATE (field))
+ PRIVATE_RETURN;
+
+ /* ARM $11.5. Member functions of a derived class can access the
+ non-static protected members of a base class only through a
+ pointer to the derived class, a reference to it, or an object
+ of it. Also any subsequently derived classes also have
+ access. */
+ else if (TREE_PROTECTED (field))
+ {
+ if (current_class_type
+ && ((TREE_CODE (field) != FUNCTION_DECL && TREE_STATIC (field))
+ || (TREE_CODE (field) == FUNCTION_DECL
+ && DECL_STATIC_FUNCTION_P (field)))
+ && ACCESSIBLY_DERIVED_FROM_P (context, current_class_type))
+ PUBLIC_RETURN;
+ else
+ PROTECTED_RETURN;
+ }
+ else
+ PUBLIC_RETURN;
+ }
+
+ /* must reverse more than one element */
+ basetype_path = reverse_path (basetype_path);
+ types = basetype_path;
+ via_protected = 0;
+ access = access_default;
+ protected_ok = current_class_type
+ && ACCESSIBLY_UNIQUELY_DERIVED_P (BINFO_TYPE (types), current_class_type);
+
+ while (1)
+ {
+ tree member;
+ tree binfo = types;
+ tree type = BINFO_TYPE (binfo);
+ int private_ok = 0;
+
+ /* Friends of a class can see protected members of its bases.
+ Note that classes are their own friends. */
+ if (is_friend (type, previous_scope))
+ {
+ protected_ok = 1;
+ private_ok = 1;
+ }
+
+ member = purpose_member (type, DECL_ACCESS (field));
+ if (member)
+ {
+ access = (enum access_type) TREE_VALUE (member);
+ break;
+ }
+
+ types = BINFO_INHERITANCE_CHAIN (types);
+
+ /* If the next type was VIA_PROTECTED, then fields of all remaining
+ classes past that one are *at least* protected. */
+ if (types)
+ {
+ if (TREE_VIA_PROTECTED (types))
+ via_protected = 1;
+ else if (! TREE_VIA_PUBLIC (types) && ! private_ok)
+ {
+ access = access_private;
+ break;
+ }
+ }
+ else
+ break;
+ }
+ reverse_path (basetype_path);
+
+ /* No special visibilities apply. Use normal rules. */
+
+ if (access == access_default)
+ {
+ if (is_friend (context, previous_scope))
+ access = access_public;
+ else if (TREE_PRIVATE (field))
+ access = access_private;
+ else if (TREE_PROTECTED (field))
+ access = access_protected;
+ else
+ access = access_public;
+ }
+
+ if (access == access_public && via_protected)
+ access = access_protected;
+
+ if (access == access_protected && protected_ok)
+ access = access_public;
+
+#if 0
+ if (access == access_public)
+ DECL_PUBLIC (field) = 1;
+ else if (access == access_protected)
+ DECL_PROTECTED (field) = 1;
+ else if (access == access_private)
+ DECL_PRIVATE (field) = 1;
+ else my_friendly_abort (96);
+#endif
+ return access;
+}
+
+/* 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 access
+ 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 access_type this_v = access_default;
+ tree entry, binfo, binfo_h;
+ enum access_type own_access = access_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 access control. */
+ int index = MEMOIZED_HASH_FN (name);
+
+ /* If we are looking for a constructor in a templated type, use the
+ unspecialized name, as that is how we store it. */
+ if (IDENTIFIER_TEMPLATE (name))
+ name = constructor_name (name);
+
+ if (TREE_CODE (xbasetype) == TREE_VEC)
+ {
+ extern struct obstack temporary_obstack;
+ struct obstack *tmp = current_obstack;
+ current_obstack = &temporary_obstack;
+ basetype_path = copy_binfo (xbasetype);
+ current_obstack = tmp;
+ 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_access (basetype_path, rval);
+ if (TREE_CODE (rval) == CONST_DECL)
+ {
+ if (this_v == access_private)
+ errstr = "enum `%s' is a private value of class `%s'";
+ else if (this_v == access_protected)
+ errstr = "enum `%s' is a protected value of class `%s'";
+ }
+ else
+ {
+ if (this_v == access_private)
+ errstr = "member `%s' is a private member of class `%s'";
+ else if (this_v == access_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_access (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 access level, deal with that. */
+ if (rval && errstr == 0
+ && ((protect&1) || entry)
+ && DECL_LANG_SPECIFIC (rval)
+ && DECL_ACCESS (rval))
+ {
+ while (tp < search_tail)
+ {
+ /* If is possible for one of the derived types on the path to
+ have defined special access for this field. Look for such
+ declarations and report an error if a conflict is found. */
+ enum access_type new_v;
+
+ if (this_v != access_default)
+ new_v = compute_access (TREE_VALUE (TREE_CHAIN (*tp)), rval);
+ if (this_v != access_default && new_v != this_v)
+ {
+ errstr = "conflicting access to member `%s'";
+ this_v = access_default;
+ }
+ own_access = 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_access == access_private)
+ errstr = "member `%s' declared private";
+ else if (own_access == access_protected)
+ errstr = "member `%s' declared protected";
+ else if (this_v == access_private)
+ errstr = TREE_PRIVATE (rval)
+ ? "member `%s' is private"
+ : "member `%s' is from private base class";
+ else if (this_v == access_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)
+ {
+ char *p = IDENTIFIER_POINTER (name), *q = NULL;
+ if (IDENTIFIER_OPNAME_P (name))
+ {
+ q = operator_name_string (name);
+ p = (char *) xmalloc (9 + strlen (q) + 1);
+ sprintf (p, "operator %s", q);
+ }
+
+ error (errstr, p, TYPE_NAME_STRING (type));
+ if (q)
+ free (p);
+ 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 access 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 access 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 access control. */
+ int index = MEMOIZED_HASH_FN (name);
+
+ if (complain == -1)
+ {
+ find_all = 1;
+ protect = complain = 0;
+ }
+
+ /* If we are looking for a constructor in a templated type, use the
+ unspecialized name, as that is how we store it. */
+ if (IDENTIFIER_TEMPLATE (name))
+ name = constructor_name (name);
+
+ 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 access 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;
+}
+\f
+/* 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 = (HOST_WIDE_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_CONSTRUCTING (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))
+ {
+ cp_error ("conflicting return type specified for virtual function `%D'", fndecl);
+ 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 (best == NULL_TREE && warn_overloaded_virtual)
+ cp_warning_at ("conflicting specification deriving virtual function `%D'", fndecl);
+
+ 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;
+}
+\f
+/* 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))
+ {
+ 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
+ {
+ vbase_decl_ptr_intermediate
+ = convert_pointer_to_single_level (BINFO_TYPE (base_binfo),
+ vbase_decl_ptr_intermediate);
+ }
+
+ dfs_walk (base_binfo, fn, qfn);
+
+ vbase_decl_ptr_intermediate = saved_vbase_decl_ptr_intermediate;
+ } else
+ 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_KNOWN (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. */
+ if (write_symbols != DWARF_DEBUG)
+ DECL_IGNORED_P (TYPE_NAME (t)) = 0;
+ if (! TREE_ASM_WRITTEN (TYPE_NAME (t)))
+ rest_of_type_compilation (t, global_bindings_p ());
+}
+\f
+/* 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;
+
+ this_vbase_ptr = vbase_decl_ptr_intermediate;
+
+ if (TYPE_POINTER_TO (type) != TREE_TYPE (this_vbase_ptr))
+ my_friendly_abort (125);
+
+ 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, NULL_PTR), 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, NULL_PTR);
+ 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.
+
+ When USE_COMPUTED_OFFSETS is non-zero, we can assume that the
+ object was laidout by a top-level contructor and the computed
+ offsets are valid to store vtables. When zero, we must store new
+ vtables through virtual baseclass pointers. */
+
+tree
+build_vbase_vtables_init (main_binfo, binfo, true_exp, decl_ptr,
+ use_computed_offsets)
+ tree main_binfo, binfo;
+ tree true_exp, decl_ptr;
+ int use_computed_offsets;
+{
+ 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, NULL_PTR);
+
+ if (use_computed_offsets)
+ {
+ /* 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 (use_computed_offsets)
+ addr = (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (vbases));
+ else
+ addr = convert_pointer_to (vbases, vbase_decl_ptr);
+
+ if (addr)
+ {
+ tree ref = build_vfield_ref (build_indirect_ref (addr, NULL_PTR),
+ 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);
+}
+
+/* get virtual base class types.
+ This adds type to the vbase_types list in reverse dfs order.
+ Ordering is very important, so don't change it. */
+
+static void
+dfs_get_vbase_types (binfo)
+ tree binfo;
+{
+ tree binfos = BINFO_BASETYPES (binfo);
+ tree type = BINFO_TYPE (binfo);
+ tree these_vbase_types = CLASSTYPE_VBASECLASSES (type);
+ int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
+
+ 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 = 0; i < n_baselinks; 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);
+ /* Rely upon the reverse dfs ordering from dfs_get_vbase_types, and now
+ reverse it so that we get normal dfs ordering. */
+ vbase_types = nreverse (vbase_types);
+
+ /* Almost all of the below is not needed now. We should be able to just
+ return vbase_types directly... (mrs) */
+ 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 (1 /* ANSI C++ specifies dfs ordering now. */
+ || ! 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;
+}
+\f
+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 + 1) * (mi_size + 1));
+ 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
+}
+\f
+/* 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);
+}
+\f
+/* 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.
+
+ In order to know what decls are new (stemming from the current
+ invocation of push_class_decls) we enclose them in an "envelope",
+ which is a TREE_LIST node where the TREE_PURPOSE slot contains the
+ new decl (or possibly a list of competing ones), the TREE_VALUE slot
+ points to the old value and the TREE_CHAIN slot chains together all
+ envelopes which needs to be "opened" in push_class_decls. Opening an
+ envelope means: push the old value onto the class_shadowed list,
+ install the new one and if it's a TYPE_DECL do the same to the
+ IDENTIFIER_TYPE_VALUE. Such an envelope is recognized by seeing that
+ the TREE_PURPOSE slot is non-null, and that it is not an identifier.
+ Because if it is, it could be a set of overloaded methods from an
+ outer scope. */
+
+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;
+
+ /* Recurse into anonymous unions. */
+ if (DECL_NAME (fields) == NULL_TREE
+ && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
+ {
+ dfs_pushdecls (TYPE_BINFO (TREE_TYPE (fields)));
+ continue;
+ }
+
+#if 0
+ if (TREE_CODE (fields) != TYPE_DECL)
+ {
+ DECL_PUBLIC (fields) = 0;
+ DECL_PROTECTED (fields) = 0;
+ DECL_PRIVATE (fields) = 0;
+ }
+#endif
+
+ if (DECL_NAME (fields))
+ {
+ tree class_value = IDENTIFIER_CLASS_VALUE (DECL_NAME (fields));
+
+ /* If the class value is an envelope of the kind described in
+ the comment above, we try to rule out possible ambiguities.
+ If we can't do that, keep a TREE_LIST with possibly ambiguous
+ decls in there. */
+ if (class_value && TREE_CODE (class_value) == TREE_LIST
+ && TREE_PURPOSE (class_value) != NULL_TREE
+ && (TREE_CODE (TREE_PURPOSE (class_value))
+ != IDENTIFIER_NODE))
+ {
+ tree value = TREE_PURPOSE (class_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 = (TREE_CODE (value) == FUNCTION_DECL
+ && DECL_VIRTUAL_P (value))
+ ? DECL_CLASS_CONTEXT (value)
+ : DECL_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))
+ {
+ register tree list_mbr = TREE_VALUE (sub_values);
+
+ context = (TREE_CODE (list_mbr) == FUNCTION_DECL
+ && DECL_VIRTUAL_P (list_mbr))
+ ? DECL_CLASS_CONTEXT (list_mbr)
+ : DECL_CONTEXT (list_mbr);
+
+ if (! TYPE_DERIVES_FROM (context, type))
+ {
+ value = tree_cons (NULL_TREE, TREE_VALUE (values), value);
+ problem = 1;
+ break;
+ }
+ }
+ }
+ else
+ {
+ context = (TREE_CODE (sub_values) == FUNCTION_DECL
+ && DECL_VIRTUAL_P (sub_values))
+ ? DECL_CLASS_CONTEXT (sub_values)
+ : DECL_CONTEXT (sub_values);
+
+ if (context && ! 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;
+ }
+
+ /* Put the new contents in our envelope. */
+ TREE_PURPOSE (class_value) = value;
+ }
+ else
+ {
+ /* See comment above for a description of envelopes. */
+ tree envelope = tree_cons (fields, class_value,
+ closed_envelopes);
+
+ closed_envelopes = envelope;
+ IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = envelope;
+ }
+ }
+ }
+
+ 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 class_value = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
+
+ if (class_value && TREE_CODE (class_value) == TREE_LIST
+ && TREE_PURPOSE (class_value) != NULL_TREE
+ && TREE_CODE (TREE_PURPOSE (class_value)) != IDENTIFIER_NODE)
+ {
+ tree old = TREE_PURPOSE (class_value);
+
+ maybe_push_cache_obstack ();
+ if (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_LANG_SPECIFIC (old)
+ && DECL_CLASS_CONTEXT (old) == current_class_type)
+ || ! TREE_PRIVATE (old)))
+ /* Should figure out access control more accurately. */
+ cp_warning ("shadowing member `%#D' with member function `%#D'",
+ old, *methods);
+ tmp = build_tree_list (DECL_NAME (*methods), *methods);
+ }
+ pop_obstacks ();
+
+ TREE_TYPE (tmp) = unknown_type_node;
+#if 0
+ TREE_OVERLOADED (tmp) = DECL_OVERLOADED (*methods);
+#endif
+ TREE_NONLOCAL_FLAG (tmp) = 1;
+
+ /* Put the new contents in our envelope. */
+ TREE_PURPOSE (class_value) = tmp;
+ }
+ else
+ {
+ maybe_push_cache_obstack ();
+ tmp = build_tree_list (DECL_NAME (*methods), *methods);
+ pop_obstacks ();
+
+ TREE_TYPE (tmp) = unknown_type_node;
+#if 0
+ TREE_OVERLOADED (tmp) = DECL_OVERLOADED (*methods);
+#endif
+ TREE_NONLOCAL_FLAG (tmp) = 1;
+
+ /* See comment above for a description of envelopes. */
+ closed_envelopes = tree_cons (tmp, class_value,
+ closed_envelopes);
+ IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = closed_envelopes;
+ }
+#if 0
+ tmp = *methods;
+ while (tmp != 0)
+ {
+ DECL_PUBLIC (tmp) = 0;
+ DECL_PROTECTED (tmp) = 0;
+ DECL_PRIVATE (tmp) = 0;
+ tmp = DECL_CHAIN (tmp);
+ }
+#endif
+
+ 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++)
+ {
+ /* This is known to be an envelope of the kind described before
+ dfs_pushdecls. */
+ tree class_value = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
+ tree tmp = TREE_PURPOSE (class_value);
+
+ /* 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)
+ {
+ TREE_PURPOSE (class_value) = 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), 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
+
+ search_stack = push_search_level (search_stack, &search_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, 1);
+ }
+
+ /* 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);
+
+ /* Open up all the closed envelopes and push the contained decls into
+ class scope. */
+ while (closed_envelopes)
+ {
+ tree new = TREE_PURPOSE (closed_envelopes);
+ tree id;
+
+ /* This is messy because the class value may be a *_DECL, or a
+ TREE_LIST of overloaded *_DECLs or even a TREE_LIST of ambiguous
+ *_DECLs. The name is stored at different places in these three
+ cases. */
+ if (TREE_CODE (new) == TREE_LIST)
+ {
+ if (TREE_PURPOSE (new) != NULL_TREE)
+ id = TREE_PURPOSE (new);
+ else
+ {
+ tree node = TREE_VALUE (new);
+
+ while (TREE_CODE (node) == TREE_LIST)
+ node = TREE_VALUE (node);
+ id = DECL_NAME (node);
+ }
+ }
+ else
+ id = DECL_NAME (new);
+
+ /* Install the original class value in order to make
+ pushdecl_class_level work correctly. */
+ IDENTIFIER_CLASS_VALUE (id) = TREE_VALUE (closed_envelopes);
+ if (TREE_CODE (new) == TREE_LIST)
+ push_class_level_binding (id, new);
+ else
+ pushdecl_class_level (new);
+ closed_envelopes = TREE_CHAIN (closed_envelopes);
+ }
+ current_obstack = ambient_obstack;
+}
+
+/* Here's a subroutine we need because C lacks lambdas. */
+static void
+dfs_unuse_fields (binfo)
+ tree binfo;
+{
+ tree type = TREE_TYPE (binfo);
+ 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));
+ }
+}
+
+void
+unuse_fields (type)
+ tree type;
+{
+ dfs_walk (TYPE_BINFO (type), dfs_unuse_fields, unmarkedp);
+}
+
+void
+pop_class_decls (type)
+ tree type;
+{
+ /* We haven't pushed a search level when dealing with cached classes,
+ so we'd better not try to pop it. */
+ if (search_stack)
+ search_stack = pop_search_level (search_stack);
+}
+
+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);
+
+ /* 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;
+}
--- /dev/null
+/* Functions dealing with signatures and signature pointers/references.
+ Copyright (C) 1992 Free Software Foundation, Inc.
+ Contributed by Gerald Baumgartner (gb@cs.purdue.edu)
+
+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"
+#include "assert.h"
+
+extern struct obstack *current_obstack;
+extern struct obstack permanent_obstack;
+extern struct obstack *saveable_obstack;
+
+extern void error ();
+extern void sorry ();
+extern void compiler_error ();
+extern void make_decl_rtl PROTO((tree, char *, int));
+
+/* Used to help generate globally unique names for signature tables. */
+
+static int global_sigtable_name_counter;
+
+/* Build an identifier for a signature pointer or reference, so we
+ can use it's name in function name mangling. */
+
+static tree
+build_signature_pointer_or_reference_name (to_type, constp, volatilep, refp)
+ tree to_type;
+ int constp, volatilep, refp;
+{
+ char * sig_name = TYPE_NAME_STRING (to_type);
+ int name_len = TYPE_NAME_LENGTH (to_type) + constp + volatilep;
+ char * name;
+
+ if (refp)
+ {
+ name = (char *) alloca (name_len + sizeof (SIGNATURE_REFERENCE_NAME) +2);
+ sprintf (name, SIGNATURE_REFERENCE_NAME_FORMAT,
+ constp ? "C" : "", volatilep ? "V": "", sig_name);
+ }
+ else
+ {
+ name = (char *) alloca (name_len + sizeof (SIGNATURE_POINTER_NAME) + 2);
+ sprintf (name, SIGNATURE_POINTER_NAME_FORMAT,
+ constp ? "C" : "", volatilep ? "V": "", sig_name);
+ }
+ return get_identifier (name);
+}
+
+/* Build a DECL node for a signature pointer or reference, so we can
+ tell the debugger the structure of signature pointers/references.
+ This function is called at most eight times for a given signature,
+ once for each [const] [volatile] signature pointer/reference. */
+
+static void
+build_signature_pointer_or_reference_decl (type, name)
+ tree type, name;
+{
+ tree decl;
+
+ /* We don't enter this declaration in any sort of symbol table. */
+ decl = build_decl (TYPE_DECL, name, type);
+ TYPE_NAME (type) = decl;
+ TREE_CHAIN (type) = decl;
+}
+
+/* Construct, lay out and return the type of pointers or references
+ to signature TO_TYPE. If such a type has already been constructed,
+ reuse it. If CONSTP or VOLATILEP is specified, make the `optr' const
+ or volatile, respectively. If we are constructing a const/volatile
+ type variant and the main type variant doesn't exist yet, it is built
+ as well. If REFP is 1, we construct a signature reference, otherwise
+ a signature pointer is constructed.
+
+ This function is a subroutine of `build_signature_pointer_type' and
+ `build_signature_reference_type'. */
+
+static tree
+build_signature_pointer_or_reference_type (to_type, constp, volatilep, refp)
+ tree to_type;
+ int constp, volatilep, refp;
+{
+ register tree t, m;
+ register struct obstack *ambient_obstack = current_obstack;
+ register struct obstack *ambient_saveable_obstack = saveable_obstack;
+
+ m = refp ? SIGNATURE_REFERENCE_TO (to_type) : SIGNATURE_POINTER_TO (to_type);
+
+ /* If we don't have the main variant yet, construct it. */
+ if (m == NULL_TREE
+ && (constp || volatilep))
+ m = build_signature_pointer_or_reference_type (to_type, 0, 0, refp);
+
+ /* Treat any nonzero argument as 1. */
+ constp = !!constp;
+ volatilep = !!volatilep;
+ refp = !!refp;
+
+ /* If not generating auxiliary info, search the chain of variants to see
+ if there is already one there just like the one we need to have. If so,
+ use that existing one.
+
+ We don't do this in the case where we are generating aux info because
+ in that case we want each typedef names to get it's own distinct type
+ node, even if the type of this new typedef is the same as some other
+ (existing) type. */
+
+ if (m && !flag_gen_aux_info)
+ for (t = m; t; t = TYPE_NEXT_VARIANT (t))
+ if (constp == TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (t))))
+ && volatilep == TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (t)))))
+ return t;
+
+ /* We need a new one. If TO_TYPE is permanent, make this permanent too. */
+ if (TREE_PERMANENT (to_type))
+ {
+ current_obstack = &permanent_obstack;
+ saveable_obstack = &permanent_obstack;
+ }
+
+ /* A signature pointer or reference to a signature `s' looks like this:
+
+ struct {
+ void * optr;
+ const s * sptr;
+ vtbl_type_node * vptr;
+ };
+
+ A `const' signature pointer/reference is a
+
+ struct {
+ const void * optr;
+ const s * sptr;
+ vtbl_type_node * vptr;
+ };
+
+ Similarly, for `volatile' and `const volatile'.
+ */
+
+ t = make_lang_type (RECORD_TYPE);
+ {
+ tree obj_type = build_type_variant (void_type_node, constp, volatilep);
+ tree optr_type = build_pointer_type (obj_type);
+ tree optr, sptr, vptr;
+
+ optr = build_lang_field_decl (FIELD_DECL,
+ get_identifier (SIGNATURE_OPTR_NAME),
+ optr_type);
+ DECL_FIELD_CONTEXT (optr) = t;
+ DECL_CLASS_CONTEXT (optr) = t;
+
+ if (m)
+ {
+ /* We can share `sptr' and `vptr' among type variants. */
+ sptr = TREE_CHAIN (TYPE_FIELDS (m));
+ vptr = TREE_CHAIN (sptr);
+ }
+ else
+ {
+ tree sig_tbl_type = build_type_variant (to_type, 1, 0);
+
+ sptr = build_lang_field_decl (FIELD_DECL,
+ get_identifier (SIGNATURE_SPTR_NAME),
+ build_pointer_type (sig_tbl_type));
+ vptr = build_lang_field_decl (FIELD_DECL,
+ get_identifier (SIGNATURE_VPTR_NAME),
+ build_pointer_type (vtbl_type_node));
+ DECL_FIELD_CONTEXT (sptr) = t;
+ DECL_CLASS_CONTEXT (sptr) = t;
+ DECL_FIELD_CONTEXT (vptr) = t;
+ DECL_CLASS_CONTEXT (vptr) = t;
+ TREE_CHAIN (sptr) = vptr;
+ TREE_CHAIN (vptr) = NULL_TREE;
+ }
+
+ TREE_CHAIN (optr) = sptr;
+ TYPE_FIELDS (t) = optr;
+ /* To make `build_vfn_ref' work when building a signature method call. */
+ CLASSTYPE_VFIELD (t) = vptr;
+ DECL_FCONTEXT (CLASSTYPE_VFIELD (t)) = t;
+ TYPE_ALIGN (t) = TYPE_ALIGN (optr_type);
+ }
+
+ {
+ tree name = build_signature_pointer_or_reference_name (to_type, constp,
+ volatilep, refp);
+
+ /* Build a DECL node for this type, so the debugger has access to it. */
+ build_signature_pointer_or_reference_decl (t, name);
+ }
+
+ CLASSTYPE_GOT_SEMICOLON (t) = 1;
+ IS_SIGNATURE_POINTER (t) = ! refp;
+ IS_SIGNATURE_REFERENCE (t) = refp;
+ SIGNATURE_TYPE (t) = to_type;
+
+ if (m)
+ {
+ /* Add this type to the chain of variants of TYPE.
+ Every type has to be its own TYPE_MAIN_VARIANT. */
+ TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
+ TYPE_NEXT_VARIANT (m) = t;
+ }
+ else if (refp)
+ /* Record this type as the reference to TO_TYPE. */
+ SIGNATURE_REFERENCE_TO (to_type) = t;
+ else
+ /* Record this type as the pointer to TO_TYPE. */
+ SIGNATURE_POINTER_TO (to_type) = t;
+
+ /* Lay out the type. This function has many callers that are concerned
+ with expression-construction, and this simplifies them all.
+ Also, it guarantees the TYPE_SIZE is permanent if the type is. */
+ layout_type (t);
+
+ current_obstack = ambient_obstack;
+ saveable_obstack = ambient_saveable_obstack;
+
+ /* Ouput debug information for this type. */
+ rest_of_type_compilation (t, 1);
+
+ return t;
+}
+
+/* Construct, lay out and return the type of pointers to signature TO_TYPE. */
+
+tree
+build_signature_pointer_type (to_type, constp, volatilep)
+ tree to_type;
+ int constp, volatilep;
+{
+ return
+ build_signature_pointer_or_reference_type (to_type, constp, volatilep, 0);
+}
+
+/* Construct, lay out and return the type of pointers to signature TO_TYPE. */
+
+tree
+build_signature_reference_type (to_type, constp, volatilep)
+ tree to_type;
+ int constp, volatilep;
+{
+ return
+ build_signature_pointer_or_reference_type (to_type, constp, volatilep, 1);
+}
+
+/* Return the name of the signature table (as an IDENTIFIER_NODE)
+ for the given signature type SIG_TYPE and rhs type RHS_TYPE. */
+
+static tree
+get_sigtable_name (sig_type, rhs_type)
+ tree sig_type, rhs_type;
+{
+ tree sig_type_id = build_typename_overload (sig_type);
+ tree rhs_type_id = build_typename_overload (rhs_type);
+ char *buf = (char *) alloca (sizeof (SIGTABLE_NAME_FORMAT_LONG)
+ + IDENTIFIER_LENGTH (sig_type_id)
+ + IDENTIFIER_LENGTH (rhs_type_id) + 20);
+ char *sig_ptr = IDENTIFIER_POINTER (sig_type_id);
+ char *rhs_ptr = IDENTIFIER_POINTER (rhs_type_id);
+ int i, j;
+
+ for (i = 0; sig_ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++)
+ /* do nothing */;
+ while (sig_ptr[i] >= '0' && sig_ptr[i] <= '9')
+ i += 1;
+
+ for (j = 0; rhs_ptr[j] == OPERATOR_TYPENAME_FORMAT[j]; j++)
+ /* do nothing */;
+ while (rhs_ptr[j] >= '0' && rhs_ptr[j] <= '9')
+ j += 1;
+
+ if (IS_SIGNATURE (rhs_type))
+ sprintf (buf, SIGTABLE_NAME_FORMAT_LONG, sig_ptr+i, rhs_ptr+j,
+ global_sigtable_name_counter++);
+ else
+ sprintf (buf, SIGTABLE_NAME_FORMAT, sig_ptr+i, rhs_ptr+j);
+ return get_identifier (buf);
+}
+
+/* Build a field decl that points to a signature member function. */
+
+static tree
+build_member_function_pointer (member)
+ tree member;
+{
+ char *namstr = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (member));
+ int namlen = IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (member));
+ char *name;
+ tree entry;
+
+ name = (char *) alloca (namlen + sizeof (SIGNATURE_FIELD_NAME) + 2);
+ sprintf (name, SIGNATURE_FIELD_NAME_FORMAT, namstr);
+
+ /* @@ Do we really want to xref signature table fields? */
+ GNU_xref_ref (current_function_decl, name);
+
+ entry = build_lang_field_decl (FIELD_DECL, get_identifier (name),
+ TYPE_MAIN_VARIANT (sigtable_entry_type));
+ TREE_CONSTANT (entry) = 1;
+ TREE_READONLY (entry) = 1;
+
+ /* @@ Do we really want to xref signature table fields? */
+ GNU_xref_decl (current_function_decl, entry);
+
+ return entry;
+}
+
+/* For each FUNCTION_DECL in a signature we construct a member function
+ pointer of the appropriate type. We also need two flags to test
+ whether the member function pointer points to a virtual function or
+ to a default implementation. Those flags will be the two lower order
+ bits of the member function pointer (or the two higher order bits,
+ based on the configuration).
+
+ The new FIELD_DECLs are appended at the end of the last (and only)
+ sublist of `list_of_fieldlists.'
+
+ As a side effect, each member function in the signature gets the
+ `decl.ignored' bit turned on, so we don't output debug info for it. */
+
+void
+append_signature_fields (list_of_fieldlists)
+ tree list_of_fieldlists;
+{
+ tree l, x;
+ tree last_x = NULL_TREE;
+ tree mfptr;
+ tree last_mfptr;
+ tree mfptr_list = NULL_TREE;
+
+ /* For signatures it should actually be only a list with one element. */
+ for (l = list_of_fieldlists; l; l = TREE_CHAIN (l))
+ {
+ for (x = TREE_VALUE (l); x; x = TREE_CHAIN (x))
+ {
+ if (TREE_CODE (x) == FUNCTION_DECL)
+ {
+ mfptr = build_member_function_pointer (x);
+ DECL_MEMFUNC_POINTER_TO (x) = mfptr;
+ DECL_MEMFUNC_POINTING_TO (mfptr) = x;
+ DECL_IGNORED_P (x) = 1;
+ DECL_IN_AGGR_P (mfptr) = 1;
+ if (! mfptr_list)
+ mfptr_list = last_mfptr = mfptr;
+ else
+ {
+ TREE_CHAIN (last_mfptr) = mfptr;
+ last_mfptr = mfptr;
+ }
+ }
+ last_x = x;
+ }
+ }
+
+ /* Append the lists. */
+ if (last_x && mfptr_list)
+ {
+ TREE_CHAIN (last_x) = mfptr_list;
+ TREE_CHAIN (last_mfptr) = NULL_TREE;
+ }
+}
+
+/* Compare the types of a signature member function and a class member
+ function. Returns 1 if the types are in the C++ `<=' relationship.
+
+ If we have a signature pointer/reference as argument or return type
+ we don't want to do a recursive conformance check. The conformance
+ check only succeeds if both LHS and RHS refer to the same signature
+ pointer. Otherwise we need to keep information about parameter types
+ around at run time to initialize the signature table correctly. */
+
+static int
+match_method_types (sig_mtype, class_mtype)
+ tree sig_mtype, class_mtype;
+{
+ tree sig_return_type = TREE_TYPE (sig_mtype);
+ tree sig_arg_types = TYPE_ARG_TYPES (sig_mtype);
+ tree class_return_type = TREE_TYPE (class_mtype);
+ tree class_arg_types = TYPE_ARG_TYPES (class_mtype);
+
+ /* The return types have to be the same. */
+ if (! comptypes (sig_return_type, class_return_type, 1))
+ return 0;
+
+ /* Compare the first argument `this.' */
+ {
+ /* Get the type of what the `optr' is pointing to. */
+ tree sig_this =
+ TREE_TYPE (TREE_TYPE (TYPE_FIELDS (TREE_VALUE (sig_arg_types))));
+ tree class_this = TREE_VALUE (class_arg_types);
+
+ if (TREE_CODE (class_this) == RECORD_TYPE) /* Is `this' a sig ptr? */
+ class_this = TREE_TYPE (TREE_TYPE (TYPE_FIELDS (class_this)));
+ else
+ class_this = TREE_TYPE (class_this);
+
+ /* If a signature method's `this' is const or volatile, so has to be
+ the corresponding class method's `this.' */
+ if ((TYPE_READONLY (sig_this) && ! TYPE_READONLY (class_this))
+ || (TYPE_VOLATILE (sig_this) && ! TYPE_VOLATILE (class_this)))
+ return 0;
+ }
+
+ sig_arg_types = TREE_CHAIN (sig_arg_types);
+ class_arg_types = TREE_CHAIN (class_arg_types);
+
+ /* The number of arguments and the argument types have to be the same. */
+ return compparms (sig_arg_types, class_arg_types, 3);
+}
+
+/* Undo casts of opaque type variables to the RHS types. */
+static void
+undo_casts (sig_ty)
+ tree sig_ty;
+{
+ tree field = TYPE_FIELDS (sig_ty);
+
+ /* Since all the FIELD_DECLs for the signature table entries are at the end
+ of the chain (see `append_signature_fields'), we can do it this way. */
+ for (; field && TREE_CODE (field) != FIELD_DECL; field = TREE_CHAIN (field))
+ if (TYPE_MAIN_VARIANT (TREE_TYPE (field)) == opaque_type_node)
+ TREE_TYPE (TREE_TYPE (field)) = TREE_TYPE (ptr_type_node);
+}
+
+/* Do the type checking necessary to see whether the `rhs' conforms to
+ the lhs's `sig_ty'. Depending on the type of `rhs' return a NULL_TREE,
+ an integer_zero_node, a constructor, or an expression offsetting the
+ `rhs' signature table. */
+
+static tree
+build_signature_table_constructor (sig_ty, rhs)
+ tree sig_ty, rhs;
+{
+ tree rhstype = TREE_TYPE (rhs);
+ tree sig_field = TYPE_FIELDS (sig_ty);
+ tree result = NULL_TREE;
+ tree first_rhs_field = NULL_TREE;
+ tree last_rhs_field;
+ int sig_ptr_p = IS_SIGNATURE (rhstype);
+ int offset_p = sig_ptr_p;
+
+ rhstype = sig_ptr_p ? rhstype : TREE_TYPE (rhstype);
+
+ if (CLASSTYPE_TAGS (sig_ty))
+ {
+ sorry ("conformance check with signature containing class declarations");
+ return error_mark_node;
+ }
+
+ for (; sig_field; sig_field = TREE_CHAIN (sig_field))
+ {
+ tree basetype_path, baselink, basetypes;
+ tree sig_method, sig_mname, sig_mtype;
+ tree rhs_method, tbl_entry;
+
+ if (TREE_CODE (sig_field) == TYPE_DECL)
+ {
+ tree sig_field_type = TREE_TYPE (sig_field);
+
+ if (TYPE_MAIN_VARIANT (sig_field_type) == opaque_type_node)
+ {
+ /* We've got an opaque type here. */
+ tree oty_name = DECL_NAME (sig_field);
+ tree oty_type = lookup_field (rhstype, oty_name, 1, 1);
+
+ if (oty_type == NULL_TREE || oty_type == error_mark_node)
+ {
+ cp_error ("class `%T' does not contain type `%T'",
+ rhstype, oty_type);
+ undo_casts (sig_ty);
+ return error_mark_node;
+ }
+ oty_type = TREE_TYPE (oty_type);
+
+ /* Cast `sig_field' to be of type `oty_type'. This will be
+ undone in `undo_casts' by walking over all the TYPE_DECLs. */
+ TREE_TYPE (sig_field_type) = TREE_TYPE (oty_type);
+ }
+ /* If we don't have an opaque type, we can ignore the `typedef'. */
+ continue;
+ }
+
+ /* Find the signature method corresponding to `sig_field'. */
+ sig_method = DECL_MEMFUNC_POINTING_TO (sig_field);
+ sig_mname = DECL_NAME (sig_method);
+ sig_mtype = TREE_TYPE (sig_method);
+
+ basetype_path = TYPE_BINFO (rhstype);
+ baselink = lookup_fnfields (basetype_path, sig_mname, 0);
+ if (baselink == NULL_TREE || baselink == error_mark_node)
+ {
+ if (! IS_DEFAULT_IMPLEMENTATION (sig_method))
+ {
+ cp_error ("class `%T' does not contain method `%s'",
+ rhstype, (int) IDENTIFIER_POINTER (sig_mname));
+ undo_casts (sig_ty);
+ return error_mark_node;
+ }
+ else
+ {
+ /* We use the signature's default implementation. */
+ rhs_method = sig_method;
+ }
+ }
+ else
+ {
+ /* Find the class method of the correct type. */
+
+ basetypes = TREE_PURPOSE (baselink);
+ if (TREE_CODE (basetypes) == TREE_LIST)
+ basetypes = TREE_VALUE (basetypes);
+
+ rhs_method = TREE_VALUE (baselink);
+ for (; rhs_method; rhs_method = TREE_CHAIN (rhs_method))
+ if (sig_mname == DECL_NAME (rhs_method)
+ && ! DECL_STATIC_FUNCTION_P (rhs_method)
+ && match_method_types (sig_mtype, TREE_TYPE (rhs_method)))
+ break;
+
+ if (rhs_method == NULL_TREE
+ || (compute_access (basetypes, rhs_method)
+ != access_public))
+ {
+ error ("class `%s' does not contain a method conforming to `%s'",
+ TYPE_NAME_STRING (rhstype),
+ fndecl_as_string (NULL, sig_method, 1));
+ undo_casts (sig_ty);
+ return error_mark_node;
+ }
+ }
+
+ if (sig_ptr_p && rhs_method != sig_method)
+ {
+ tree rhs_field = DECL_MEMFUNC_POINTER_TO (rhs_method);
+
+ if (first_rhs_field == NULL_TREE)
+ {
+ first_rhs_field = rhs_field;
+ last_rhs_field = rhs_field;
+ }
+ else if (TREE_CHAIN (last_rhs_field) == rhs_field)
+ last_rhs_field = rhs_field;
+ else
+ offset_p = 0;
+
+ tbl_entry = build_component_ref (rhs, DECL_NAME (rhs_field),
+ NULL_TREE, 1);
+ }
+ else
+ {
+ tree code, offset, pfn;
+
+ if (rhs_method == sig_method)
+ {
+ code = integer_two_node;
+ offset = integer_zero_node;
+ pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
+ TREE_TYPE (pfn) = ptr_type_node;
+ offset_p = 0; /* we can't offset the rhs sig table */
+ }
+ else if (DECL_VINDEX (rhs_method))
+ {
+ code = integer_one_node;
+ offset = DECL_VINDEX (rhs_method);
+ pfn = null_pointer_node;
+ }
+ else
+ {
+ code = integer_zero_node;
+ offset = integer_zero_node;
+ pfn = build_unary_op (ADDR_EXPR, rhs_method, 0);
+ TREE_TYPE (pfn) = ptr_type_node;
+ }
+
+ tbl_entry = tree_cons (NULL_TREE, code,
+ tree_cons (NULL_TREE, offset,
+ build_tree_list (NULL_TREE, pfn)));
+ tbl_entry = build_nt (CONSTRUCTOR, NULL_TREE, tbl_entry);
+ TREE_HAS_CONSTRUCTOR (tbl_entry) = 1;
+ TREE_CONSTANT (tbl_entry) = 1;
+ }
+
+ /* Chain those function address expressions together. */
+ if (result)
+ result = tree_cons (NULL_TREE, tbl_entry, result);
+ else
+ result = build_tree_list (NULL_TREE, tbl_entry);
+ }
+
+ if (result == NULL_TREE)
+ {
+ undo_casts (sig_ty);
+ return NULL_TREE;
+ }
+
+ if (offset_p)
+ {
+ if (first_rhs_field == TYPE_FIELDS (rhstype))
+ {
+ undo_casts (sig_ty);
+ return integer_zero_node;
+ }
+ else
+ {
+ undo_casts (sig_ty);
+ return build_component_ref (rhs, DECL_NAME (first_rhs_field),
+ NULL_TREE, 0);
+ }
+ }
+
+ result = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (result));
+ TREE_HAS_CONSTRUCTOR (result) = 1;
+ TREE_CONSTANT (result) = !sig_ptr_p;
+
+ undo_casts (sig_ty);
+ return result;
+}
+
+/* Build a signature table declaration and initialize it or return an
+ existing one if we built one already. If we don't get a constructor
+ as initialization expression, we don't need a new signature table
+ variable and just hand back the init expression.
+
+ The declaration processing is done by hand instead of using `finish_decl'
+ so that we can make signature pointers global variables instead of
+ static ones. */
+
+static tree
+build_sigtable (sig_type, rhs_type, init_from)
+ tree sig_type, rhs_type, init_from;
+{
+ tree name = NULL_TREE;
+ tree decl = NULL_TREE;
+ tree init_expr;
+
+ push_obstacks_nochange ();
+ end_temporary_allocation ();
+
+ if (! IS_SIGNATURE (rhs_type))
+ {
+ name = get_sigtable_name (sig_type, rhs_type);
+ decl = IDENTIFIER_GLOBAL_VALUE (name);
+ }
+ if (decl == NULL_TREE)
+ {
+ tree init;
+
+ /* We allow only one signature table to be generated for signatures
+ with opaque types. Otherwise we create a loophole in the type
+ system since we could cast data from one classes implementation
+ of the opaque type to that of another class. */
+ if (SIGNATURE_HAS_OPAQUE_TYPEDECLS (sig_type)
+ && SIGTABLE_HAS_BEEN_GENERATED (sig_type))
+ {
+ error ("signature with opaque type implemented by multiple classes");
+ return error_mark_node;
+ }
+ SIGTABLE_HAS_BEEN_GENERATED (sig_type) = 1;
+
+ init_expr = build_signature_table_constructor (sig_type, init_from);
+ if (TREE_CODE (init_expr) != CONSTRUCTOR)
+ return init_expr;
+
+ if (name == NULL_TREE)
+ name = get_sigtable_name (sig_type, rhs_type);
+ {
+ tree context = current_function_decl;
+
+ /* Make the signature table global, not just static in whichever
+ function a signature pointer/ref is used for the first time. */
+ current_function_decl = NULL_TREE;
+ decl = pushdecl_top_level (build_decl (VAR_DECL, name, sig_type));
+ current_function_decl = context;
+ }
+ IDENTIFIER_GLOBAL_VALUE (name) = decl;
+ store_init_value (decl, init_expr);
+ if (IS_SIGNATURE (rhs_type))
+ {
+ init = DECL_INITIAL (decl);
+ DECL_INITIAL (decl) = error_mark_node;
+ }
+
+ DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
+ DECL_ALIGN (decl));
+#if 0
+ /* GDB-4.7 doesn't find the initialization value of a signature table
+ when it is constant. */
+ TREE_READONLY (decl) = 1;
+#endif
+ TREE_STATIC (decl) = 1;
+ TREE_USED (decl) = 1;
+
+ make_decl_rtl (decl, NULL, 1);
+ if (IS_SIGNATURE (rhs_type))
+ expand_static_init (decl, init);
+ }
+
+ pop_obstacks ();
+
+ return decl;
+}
+
+/* Create a constructor or modify expression if the LHS of an assignment
+ is a signature pointer or a signature reference. If LHS is a record
+ type node, we build a constructor, otherwise a compound expression. */
+
+tree
+build_signature_pointer_constructor (lhs, rhs)
+ tree lhs, rhs;
+{
+ register struct obstack *ambient_obstack = current_obstack;
+ register struct obstack *ambient_saveable_obstack = saveable_obstack;
+ int initp = (TREE_CODE (lhs) == RECORD_TYPE);
+ tree lhstype = initp ? lhs : TREE_TYPE (lhs);
+ tree rhstype = TREE_TYPE (rhs);
+ tree sig_ty = SIGNATURE_TYPE (lhstype);
+ tree sig_tbl, sptr_expr, optr_expr, vptr_expr;
+ tree result;
+
+ if (! ((TREE_CODE (rhstype) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (rhstype)) == RECORD_TYPE)
+ || (TYPE_LANG_SPECIFIC (rhstype) &&
+ (IS_SIGNATURE_POINTER (rhstype)
+ || IS_SIGNATURE_REFERENCE (rhstype)))))
+ {
+ error ("invalid assignment to signature pointer or reference");
+ return error_mark_node;
+ }
+
+ /* If SIG_TY is permanent, make the signature table constructor and
+ the signature pointer/reference constructor permanent too. */
+ if (TREE_PERMANENT (sig_ty))
+ {
+ current_obstack = &permanent_obstack;
+ saveable_obstack = &permanent_obstack;
+ }
+
+ if (TYPE_LANG_SPECIFIC (rhstype) &&
+ (IS_SIGNATURE_POINTER (rhstype) || IS_SIGNATURE_REFERENCE (rhstype)))
+ {
+ if (SIGNATURE_TYPE (rhstype) == sig_ty)
+ {
+ /* LHS and RHS are signature pointers/refs of the same signature. */
+ optr_expr = build_optr_ref (rhs);
+ sptr_expr = build_sptr_ref (rhs);
+ vptr_expr = build_vptr_ref (rhs);
+ }
+ else
+ {
+ /* We need to create a new signature table and copy
+ elements from the rhs signature table. */
+ tree rhs_sptr_ref = build_sptr_ref (rhs);
+ tree rhs_tbl = build1 (INDIRECT_REF, SIGNATURE_TYPE (rhstype),
+ rhs_sptr_ref);
+
+ sig_tbl = build_sigtable (sig_ty, SIGNATURE_TYPE (rhstype), rhs_tbl);
+ if (sig_tbl == error_mark_node)
+ return error_mark_node;
+
+ optr_expr = build_optr_ref (rhs);
+ if (sig_tbl == integer_zero_node)
+ sptr_expr = rhs_sptr_ref;
+ else
+ sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
+ TREE_TYPE (sptr_expr) = build_pointer_type (sig_ty);
+ vptr_expr = build_vptr_ref (rhs);
+ }
+ }
+ else
+ {
+ tree rhs_vptr;
+
+ if (TYPE_USES_COMPLEX_INHERITANCE (TREE_TYPE (rhstype)))
+ {
+ sorry ("class with multiple inheritance as implementation of signature");
+ return error_mark_node;
+ }
+
+ sig_tbl = build_sigtable (sig_ty, TREE_TYPE (rhstype), rhs);
+ if (sig_tbl == error_mark_node)
+ return error_mark_node;
+
+ optr_expr = rhs;
+ sptr_expr = build_unary_op (ADDR_EXPR, sig_tbl, 0);
+ if (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)))
+ {
+ rhs_vptr = DECL_NAME (CLASSTYPE_VFIELD (TREE_TYPE (rhstype)));
+ vptr_expr = build_component_ref (build_indirect_ref (rhs, 0),
+ rhs_vptr, NULL_TREE, 0);
+ }
+ else
+ vptr_expr = null_pointer_node;
+ TREE_TYPE (vptr_expr) = build_pointer_type (vtbl_type_node);
+ }
+
+ if (initp)
+ {
+ result = tree_cons (NULL_TREE, optr_expr,
+ tree_cons (NULL_TREE, sptr_expr,
+ build_tree_list (NULL_TREE, vptr_expr)));
+ result = build_nt (CONSTRUCTOR, NULL_TREE, result);
+ TREE_HAS_CONSTRUCTOR (result) = 1;
+ result = digest_init (lhstype, result, 0);
+ }
+ else
+ {
+ if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype))
+ readonly_error (lhs, "assignment", 0);
+
+ optr_expr = build_modify_expr (build_optr_ref (lhs), NOP_EXPR,
+ optr_expr);
+ sptr_expr = build_modify_expr (build_sptr_ref (lhs), NOP_EXPR,
+ sptr_expr);
+ vptr_expr = build_modify_expr (build_vptr_ref (lhs), NOP_EXPR,
+ vptr_expr);
+
+ result = tree_cons (NULL_TREE, optr_expr,
+ tree_cons (NULL_TREE, sptr_expr,
+ tree_cons (NULL_TREE, vptr_expr,
+ build_tree_list (NULL_TREE,
+ lhs))));
+ result = build_compound_expr (result);
+ }
+
+ current_obstack = ambient_obstack;
+ saveable_obstack = ambient_saveable_obstack;
+ return result;
+}
+
+/* Build a temporary variable declaration for the instance of a signature
+ member function call if it isn't a declaration node already. Simply
+ using a SAVE_EXPR doesn't work since we need `this' in both branches
+ of a conditional expression. */
+
+static tree
+save_this (instance)
+ tree instance;
+{
+ tree decl;
+
+ if (TREE_CODE_CLASS (TREE_CODE (instance)) == 'd')
+ decl = instance;
+ else
+ {
+ decl = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (instance));
+ DECL_REGISTER (decl) = 1;
+ layout_decl (decl, 0);
+ expand_decl (decl);
+ }
+
+ return decl;
+}
+
+/* Build a signature member function call. Looks up the signature table
+ entry corresponding to FUNCTION. Depending on the value of the CODE
+ field, either call the function in PFN directly, or use OFFSET to
+ index INSTANCE's virtual function table. */
+
+tree
+build_signature_method_call (basetype, instance, function, parms)
+ tree basetype, instance, function, parms;
+{
+ tree saved_instance = save_this (instance); /* Create temp for `this'. */
+ tree signature_tbl_ptr = build_sptr_ref (saved_instance);
+ tree sig_field_name = DECL_NAME (DECL_MEMFUNC_POINTER_TO (function));
+ tree basetype_path = TYPE_BINFO (basetype);
+ tree tbl_entry = build_component_ref (build1 (INDIRECT_REF, basetype,
+ signature_tbl_ptr),
+ sig_field_name, basetype_path, 1);
+ tree code, offset, pfn, vfn;
+ tree deflt_call = NULL_TREE, direct_call, virtual_call, result;
+
+ code = build_component_ref (tbl_entry, get_identifier (SIGTABLE_CODE_NAME),
+ NULL_TREE, 1);
+ offset = build_component_ref (tbl_entry,
+ get_identifier (SIGTABLE_OFFSET_NAME),
+ NULL_TREE, 1);
+ pfn = build_component_ref (tbl_entry, get_identifier (SIGTABLE_PFN_NAME),
+ NULL_TREE, 1);
+ TREE_TYPE (pfn) = build_pointer_type (TREE_TYPE (function));
+
+ if (IS_DEFAULT_IMPLEMENTATION (function))
+ {
+ pfn = save_expr (pfn);
+ deflt_call = build_function_call (pfn,
+ tree_cons (NULL_TREE, saved_instance,
+ TREE_CHAIN (parms)));
+ }
+
+ {
+ /* Cast the signature method to have `this' of a normal pointer type. */
+ tree old_this = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn))));
+
+ TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) =
+ build_type_variant (TYPE_POINTER_TO (basetype),
+ TYPE_READONLY (old_this),
+ TYPE_VOLATILE (old_this));
+
+ direct_call = build_function_call (pfn, parms);
+
+ vfn = build_vfn_ref (&TREE_VALUE (parms), saved_instance, offset);
+ TREE_TYPE (vfn) = build_pointer_type (TREE_TYPE (function));
+ virtual_call = build_function_call (vfn, parms);
+
+ /* Undo the cast, make `this' a signature pointer again. */
+ TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (pfn)))) = old_this;
+ }
+
+ /* Once the function was found, there should be no reason why we
+ couldn't build the member function pointer call. */
+ if (!direct_call || direct_call == error_mark_node
+ || !virtual_call || virtual_call == error_mark_node
+ || (IS_DEFAULT_IMPLEMENTATION (function)
+ && (!deflt_call || deflt_call == error_mark_node)))
+ {
+ compiler_error ("cannot build call of signature member function `%s'",
+ fndecl_as_string (NULL, function, 1));
+ return error_mark_node;
+ }
+
+ if (IS_DEFAULT_IMPLEMENTATION (function))
+ {
+ tree test = build_binary_op_nodefault (EQ_EXPR, code, integer_one_node,
+ EQ_EXPR);
+ result = build_conditional_expr (code,
+ build_conditional_expr (test,
+ virtual_call,
+ deflt_call),
+ direct_call);
+ }
+ else
+ result = build_conditional_expr (code, virtual_call, direct_call);
+
+ /* If we created a temporary variable for `this', initialize it first. */
+ if (instance != saved_instance)
+ result = build (COMPOUND_EXPR, TREE_TYPE (result),
+ build_modify_expr (saved_instance, NOP_EXPR, instance),
+ result);
+
+ return result;
+}
+
+/* Create a COMPONENT_REF expression for referencing the OPTR field
+ of a signature pointer or reference. */
+
+tree
+build_optr_ref (instance)
+ tree instance;
+{
+ tree field = get_identifier (SIGNATURE_OPTR_NAME);
+
+ return build_component_ref (instance, field, NULL_TREE, 1);
+}
+
+/* Create a COMPONENT_REF expression for referencing the SPTR field
+ of a signature pointer or reference. */
+
+tree
+build_sptr_ref (instance)
+ tree instance;
+{
+ tree field = get_identifier (SIGNATURE_SPTR_NAME);
+
+ return build_component_ref (instance, field, NULL_TREE, 1);
+}
+
+/* Create a COMPONENT_REF expression for referencing the VPTR field
+ of a signature pointer or reference. */
+
+tree
+build_vptr_ref (instance)
+ tree instance;
+{
+ tree field = get_identifier (SIGNATURE_VPTR_NAME);
+
+ return build_component_ref (instance, field, NULL_TREE, 1);
+}
--- /dev/null
+/* 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 "lex.h"
+#include "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[] =
+ { 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, SIGOF, ATTRIBUTE, AGGR, VISSPEC, DELETE, RAISE, RERAISE, TRY,
+ EXCEPT, CATCH, THROW, ANSI_TRY, ANSI_THROW, DYNAMIC_CAST, TYPEID,
+ EXTERN_LANG_STRING, ALL, END_OF_SAVED_INPUT, -1 };
+ static short toks_follow_types[] =
+ { IDENTIFIER, TYPENAME, SCOPED_TYPENAME, SCOPED_NAME, SCSPEC,
+ TYPESPEC, TYPE_QUAL,
+ ELLIPSIS, THIS, OPERATOR, 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 == ':' || 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
+ {
+ tree t = TREE_TYPE(yylval.ttype);
+ if (TREE_CODE(yylval.ttype) == SCOPE_REF &&
+ t && TREE_CODE(t) == UNINSTANTIATED_P_TYPE)
+ yychar = SCOPED_NAME;
+ 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 SCSPEC:
+ /* do_aggr needs to check if the previous token was RID_FRIEND,
+ so just increment first_token instead of calling consume_token. */
+ first_token++;
+ goto finish_typename_processing;
+ case TYPESPEC:
+ 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.
+ * It's also a definition if it's a forward declaration (as in 'struct Foo;')
+ * which we can tell lf token[2] == ';' *and* token[-1] != FRIEND.
+ */
+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 == ';')
+ {
+ /* It's a forward declaration iff we were not preceded by 'friend'. */
+ if (first_token > 0 && nth_token (-1)->yychar == SCSPEC
+ && nth_token (-1)->yylval.ttype == ridpointers[(int) RID_FRIEND])
+ return 0;
+ }
+ else if (yc2 != '{' && yc2 != ':')
+ return 0;
+
+ 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;
+ tree t;
+ char *assume;
+
+ 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:
+ if (ch == '[')
+ {
+ assume = "expression";
+ t = exp_decl;
+ }
+ else
+ {
+ assume = "type";
+ t = type_decl;
+ }
+
+ warning ("name `%s' could be type or expression; compiler assuming %s",
+ IDENTIFIER_POINTER (DECL_NAME (t)), assume);
+ return t;
+ }
+}
+
+/* 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, inner, outer_t;
+
+ scan_tokens (n + 2);
+ if (nth_token (n + 1)->yychar != SCOPE
+ || ((ch = nth_token (n + 2)->yychar) != IDENTIFIER && ch != TYPENAME))
+ return NULL_TREE;
+
+ inner = nth_token(n+2)->yylval.ttype;
+ val = build_parse_node (SCOPE_REF, outer, inner);
+ outer_t = TREE_TYPE(outer);
+ if (outer_t && TREE_CODE(outer_t) == UNINSTANTIATED_P_TYPE)
+ {
+ tree t = make_lang_type (UNINSTANTIATED_P_TYPE);
+ tree id = inner;
+ tree d = build_lang_decl (TYPE_DECL, id, t);
+
+ TYPE_NAME (t) = d;
+ TYPE_VALUES (t) = TYPE_VALUES(outer_t);
+ TYPE_CONTEXT(t) = outer_t;
+/*
+ pushdecl_top_level (d);
+*/
+ pushdecl(d);
+
+ type = val;
+ TREE_TYPE(type) = t;
+ }
+ else
+ {
+ 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
--- /dev/null
+/* 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:
+ case SAVE_EXPR:
+ 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;
+
+ case COND_EXPR:
+ return (lvalue_p (TREE_OPERAND (ref, 1))
+ && lvalue_p (TREE_OPERAND (ref, 2)));
+ }
+ 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))
+ {
+ TREE_OPERAND (rval, 2) = error_mark_node;
+ 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));
+ TREE_SIDE_EFFECTS (rval) = 1;
+ TREE_ADDRESSABLE (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))
+ {
+ 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;
+ }
+
+}
+\f
+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;
+ 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 (IS_SIGNATURE (basetype))
+ ptype = build_signature_pointer_type (TYPE_MAIN_VARIANT (basetype),
+ TYPE_READONLY (basetype),
+ TYPE_VOLATILE (basetype));
+ else
+ {
+ ptype = build_pointer_type (basetype);
+#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. */
+
+ argtypes = tree_cons (NULL_TREE, ptype, argtypes);
+ TYPE_ARG_TYPES (t) = argtypes;
+ TREE_SIDE_EFFECTS (argtypes) = 1; /* Mark first argtype as "artificial". */
+
+ /* 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;
+}
+\f
+/* 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 0
+ /* bpk: Disabled this check until someone is willing to
+ claim it as theirs and explain exactly what circumstances
+ warrant the warning. */
+ 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));
+ }
+#endif
+ }
+ 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;
+}
+\f
+/* 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)
+ {
+ register tree id;
+ tree type = IDENTIFIER_TYPE_VALUE (value);
+
+ if (TYPE_PTRMEMFUNC_P (type))
+ list = NULL_TREE;
+ else
+ {
+ /* This will return the correct thing for regular types,
+ nested types, and templates. Yay! */
+ if (DECL_NESTED_TYPENAME (TYPE_NAME (type)))
+ value = DECL_NESTED_TYPENAME (TYPE_NAME (type));
+ id = value;
+
+ if (CLASSTYPE_ID_AS_LIST (type) == NULL_TREE)
+ CLASSTYPE_ID_AS_LIST (type) = perm_tree_cons (NULL_TREE,
+ id, 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 (TYPE_PTRMEMFUNC_P (type))
+ list = NULL_TREE;
+ else
+ {
+ if (CLASSTYPE_ID_AS_LIST (type) == NULL_TREE)
+ {
+ /* Not just `value', which could be a template parm. */
+ tree id = DECL_NAME (TYPE_NAME (type));
+ CLASSTYPE_ID_AS_LIST (type) =
+ perm_tree_cons (NULL_TREE, id, 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;
+}
+\f
+/* 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);
+ if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
+ return 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
+ || TREE_CODE (t) == TEMPLATE_DECL, 300);
+ for (tail = t; tail; tail = DECL_CHAIN (tail))
+ len++;
+
+ return len;
+}
+
+int
+count_functions (t)
+ tree t;
+{
+ if (TREE_CODE (t) == FUNCTION_DECL)
+ return 1;
+
+ return decl_list_length (TREE_VALUE (t));
+}
+
+/* Like value_member, but for DECL_CHAINs. */
+tree
+decl_value_member (elem, list)
+ tree elem, list;
+{
+ while (list)
+ {
+ if (elem == list)
+ return list;
+ list = DECL_CHAIN (list);
+ }
+ return NULL_TREE;
+}
+
+int
+is_overloaded_fn (x)
+ tree x;
+{
+ if (TREE_CODE (x) == FUNCTION_DECL)
+ return 1;
+
+ if (TREE_CODE (x) == TREE_LIST
+ && (TREE_CODE (TREE_VALUE (x)) == FUNCTION_DECL
+ || TREE_CODE (TREE_VALUE (x)) == TEMPLATE_DECL))
+ return 1;
+
+ return 0;
+}
+
+tree
+get_first_fn (from)
+ tree from;
+{
+ if (TREE_CODE (from) == FUNCTION_DECL)
+ return from;
+
+ my_friendly_assert (TREE_CODE (from) == TREE_LIST, 9);
+
+ return TREE_VALUE (from);
+}
+
+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));
+}
+\f
+#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;
+
+ /* Only cache functions. */
+ if (TREE_CODE (decl) != FUNCTION_DECL
+ || DECL_LANG_SPECIFIC (decl) == 0)
+ return decl_as_string (decl, 1);
+
+ /* 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 *)decl_as_string (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];
+}
+\f
+/* 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;
+}
--- /dev/null
+/* Build expressions with type checking for C++ compiler.
+ Copyright (C) 1987, 88, 89, 92, 93, 1994 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 ();
+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
+ && ! (TYPE_LANG_SPECIFIC (type)
+ && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))
+ && TYPE_SIZE (SIGNATURE_TYPE (type)) == 0))
+ 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));
+}
+
+/* Return truthvalue of whether T is function (or pfn) type. */
+int
+fntype_p (t)
+ tree t;
+{
+ return (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE
+ || (TREE_CODE (t) == POINTER_TYPE
+ && (TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE
+ || TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE)));
+}
+
+/* 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) == NULL_TREE)
+ {
+ error ("argument list may not have an initializer list");
+ return 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);
+}
+\f
+/* 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 (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
+ || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
+ return long_unsigned_type_node;
+
+ if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
+ || TYPE_MAIN_VARIANT (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;
+ }
+}
+\f
+/* 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:
+
+ 2 : strict, except that if one type is a reference and
+ the other is not, compare the target type of the
+ reference to the type that's not a reference (ARM, p308).
+ 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);
+
+ if (t2 == error_mark_node)
+ 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))
+ {
+ if (strict == 2
+ && ((TREE_CODE (t1) == REFERENCE_TYPE)
+ ^ (TREE_CODE (t2) == REFERENCE_TYPE)))
+ {
+ if (TREE_CODE (t1) == REFERENCE_TYPE)
+ return comptypes (TREE_TYPE (t1), t2, 1);
+ return comptypes (t1, TREE_TYPE (t2), 1);
+ }
+
+ return 0;
+ }
+ if (strict > 1)
+ strict = 1;
+
+ /* Qualifiers must match. */
+
+ if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
+ return 0;
+ if (TREE_THIS_VOLATILE (t1) != TREE_THIS_VOLATILE (t2))
+ return 0;
+
+ /* Allow for two different type nodes which have essentially the same
+ definition. Note that we already checked for equality of the type
+ type qualifiers (just above). */
+
+ if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
+ return 1;
+
+ 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;
+}
+\f
+/* 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.
+ @@@ see 13.3.3 for a counterexample... */
+
+ if (t1 == 0 && t2 != 0)
+ {
+ cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'",
+ parms2);
+ 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;
+}
+\f
+/* 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);
+
+ /* We couldn't find anything in the ARM or the draft standard that says,
+ one way or the other, if doing sizeof on something that doesn't have
+ an object associated with it is correct or incorrect. For example, if
+ you declare `struct S { char str[16]; };', and in your program do
+ a `sizeof (S::str)', should we flag that as an error or should we give
+ the size of it? Since it seems like a reasonable thing to do, we'll go
+ with giving the value. */
+ if (code == OFFSET_TYPE)
+ type = TREE_TYPE (type);
+
+ /* @@ This also produces an error for a signature ref.
+ In that case we should be able to do better. */
+ if (IS_SIGNATURE (type))
+ {
+ error ("`sizeof' applied to a signature type");
+ return size_int (0);
+ }
+
+ 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)));
+ /* size_binop does not put the constant in range, so do it now. */
+ if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
+ TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
+ 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);
+
+ /* @@ This also produces an error for a signature ref.
+ In that case we should be able to do better. */
+ if (IS_SIGNATURE (type))
+ {
+ error ("`__alignof' applied to a signature type");
+ return size_int (1);
+ }
+
+ t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
+ force_fit_type (t, 0);
+ return t;
+}
+\f
+/* 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.
+ Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
+
+ /* 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
+ || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
+ && 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 ptrtype;
+ int constp, volatilep;
+
+ 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;
+ }
+
+ constp = volatilep = 0;
+ if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r'
+ || TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
+ {
+ constp = TREE_READONLY (exp);
+ volatilep = TREE_THIS_VOLATILE (exp);
+ }
+
+ restype = TREE_TYPE (type);
+ if (TYPE_READONLY (type) || TYPE_VOLATILE (type)
+ || constp || volatilep)
+ restype = build_type_variant (restype,
+ TYPE_READONLY (type) || constp,
+ TYPE_VOLATILE (type) || volatilep);
+ 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;
+}
+\f
+tree
+build_object_ref (datum, basetype, field)
+ tree datum, basetype, field;
+{
+ if (datum == error_mark_node)
+ return error_mark_node;
+ else if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (basetype)))
+ {
+ warning ("signature name in scope resolution ignored");
+ return build_component_ref (datum, field, NULL_TREE, 1);
+ }
+ else if (is_aggr_typedef (basetype, 1))
+ {
+ tree real_basetype = IDENTIFIER_TYPE_VALUE (basetype);
+ if (binfo_or_else (real_basetype, TREE_TYPE (datum)))
+ return build_component_ref (build_scoped_ref (datum, basetype),
+ field, NULL_TREE, 1);
+ }
+ return error_mark_node;
+}
+
+/* Like `build_component_ref, but uses an already found field.
+ Must compute access 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)
+ cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
+ field, datum, basetype);
+ 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)
+ {
+ enum access_type access
+ = compute_access (TYPE_BINFO (current_class_type), field);
+
+ if (access == access_private)
+ {
+ cp_error ("field `%D' is private", field);
+ return error_mark_node;
+ }
+ else if (access == access_protected)
+ {
+ cp_error ("field `%D' is protected", field);
+ 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;
+ if (DECL_MUTABLE_P (field))
+ TREE_READONLY (ref) = 0;
+
+ return ref;
+}
+
+/* Given a COND_EXPR in T, return it in a form that we can, for
+ example, use as an lvalue. This code used to be in unary_complex_lvalue,
+ but we needed it to deal with `a = (d == c) ? b : c' expressions, where
+ we're dealing with aggregates. So, we now call this in unary_complex_lvalue,
+ and in build_modify_expr. The case (in particular) that led to this was
+ with CODE == ADDR_EXPR, since it's not an lvalue when we'd get it there. */
+static tree
+rationalize_conditional_expr (code, t)
+ enum tree_code code;
+ tree t;
+{
+ return
+ build_conditional_expr (TREE_OPERAND (t, 0),
+ build_unary_op (code, TREE_OPERAND (t, 1), 0),
+ build_unary_op (code, TREE_OPERAND (t, 2), 0));
+}
+
+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)
+ cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'",
+ component, datum, basetype);
+ 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))
+ {
+ cp_error ("destructor specifier `%T::~%T' must have matching names",
+ basetype, TREE_OPERAND (component, 0));
+ return error_mark_node;
+ }
+ if (! TYPE_HAS_DESTRUCTOR (basetype))
+ {
+ cp_error ("type `%T' has no destructor", basetype);
+ 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 access_type access;
+ tree fndecl;
+
+ /* Unique, so use this one now. */
+ basetype = TREE_PURPOSE (fndecls);
+ fndecl = TREE_VALUE (fndecls);
+ access = compute_access (TREE_PURPOSE (fndecls), fndecl);
+ if (access == access_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 (access == access_protected)
+ cp_error ("member function `%D' is protected", fndecl);
+ else
+ cp_error ("member function `%D' is private", fndecl);
+ return error_mark_node;
+ }
+ else
+ return build (COMPONENT_REF, unknown_type_node, datum, fndecls);
+ }
+
+ if (component == ansi_opname[(int) TYPE_EXPR])
+ cp_error ("`%#T' has no such type conversion operator", basetype);
+ else
+ cp_error ("`%#T' has no member named `%D'", basetype, 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)
+ {
+ cp_error ("invalid use of type decl `%#D' as expression", 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;
+ if (DECL_MUTABLE_P (field))
+ TREE_READONLY (ref) = 0;
+
+ return ref;
+}
+\f
+/* 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;
+ }
+ }
+ /* `pointer' won't be an error_mark_node if we were given a
+ pointer to member, so it's cool to check for this here. */
+ else if (TYPE_PTRMEMFUNC_P (type))
+ error ("invalid use of `%s' on pointer to member function", errorstring);
+ else if (TREE_CODE (type) == RECORD_TYPE
+ && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
+ error ("cannot dereference signature pointer/reference");
+ 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 = 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, idx)
+ tree array, idx;
+{
+ tree itype;
+
+ if (idx == 0)
+ {
+ error ("subscript missing in array reference");
+ return error_mark_node;
+ }
+
+ if (TREE_TYPE (array) == error_mark_node
+ || TREE_TYPE (idx) == error_mark_node)
+ return error_mark_node;
+
+ itype = TREE_TYPE (idx);
+ /* We must check here for the reference, so we can do the possible
+ conversions immediately afterwards. */
+ if (TREE_CODE (itype) == REFERENCE_TYPE)
+ {
+ idx = convert_from_reference (idx);
+ itype = TREE_TYPE (idx);
+ }
+
+ if (IS_AGGR_TYPE (itype))
+ {
+ if (TYPE_HAS_INT_CONVERSION (itype))
+ idx = build_type_conversion (CONVERT_EXPR,
+ integer_type_node, idx, 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 (idx)) == char_type_node)
+ warning ("array subscript has type `char'");
+
+ /* Apply default promotions *after* noticing character types. */
+ idx = default_conversion (idx);
+
+ if (TREE_CODE (TREE_TYPE (idx)) != 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 (idx) != 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;
+ }
+ /* An array that is indexed by a constant value which is not within
+ the array bounds cannot be stored in a register either; because we
+ would get a crash in store_bit_field/extract_bit_field when trying
+ to access a non-existent part of the register. */
+ if (TREE_CODE (idx) == INTEGER_CST
+ && TYPE_VALUES (TREE_TYPE (array))
+ && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array))))
+ {
+ 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, idx);
+ /* 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 (idx);
+
+ /* 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");
+ }
+}
+\f
+/* 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;
+ int is_method;
+
+ if (function == error_mark_node)
+ return error_mark_node;
+
+ type = TREE_TYPE (function);
+ 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
+ || TYPE_PTRMEMFUNC_P (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)
+ {
+ if (TREE_CODE (function) == OFFSET_REF)
+ {
+ if (TREE_OPERAND (function, 0))
+ decl = TREE_OPERAND (function, 0);
+ }
+ /* 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;
+ }
+ /* What other type of POINTER_TYPE could this be? */
+ if (TREE_CODE (TREE_TYPE (function)) != POINTER_TYPE
+ && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function))
+ && TREE_CODE (function) != OFFSET_REF)
+ 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);
+ decl = build_indirect_ref (decl, NULL_PTR);
+ }
+
+ return build_method_call (decl, function, params,
+ NULL_TREE, LOOKUP_NORMAL);
+ }
+ else if (TREE_CODE (function) == COMPONENT_REF
+ && type == unknown_type_node)
+ {
+ /* Should we undo what was done in build_component_ref? */
+ if (TREE_CODE (TREE_PURPOSE (TREE_OPERAND (function, 1))) == TREE_VEC)
+ /* Get the name that build_component_ref hid. */
+ function = DECL_NAME (TREE_VALUE (TREE_OPERAND (function, 1)));
+ else
+ 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_VALUE (function) == NULL_TREE)
+ {
+ cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?",
+ TREE_PURPOSE (function));
+ return error_mark_node;
+ }
+ else
+ {
+ tree id = TREE_PURPOSE (function);
+ function = TREE_VALUE (function);
+
+ if (TREE_CODE (function) == TEMPLATE_DECL)
+ return build_overload_call_maybe
+ (id, params, LOOKUP_COMPLAIN, (struct candidate *)0);
+ else if (DECL_CHAIN (function) != NULL_TREE)
+ return build_overload_call
+ (id, params, LOOKUP_COMPLAIN, (struct candidate *)0);
+ /* else fall out */
+ }
+ }
+
+ 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_from_ptrfunc (&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 (TYPE_PTRMEMFUNC_P (fntype))
+ {
+ tree rec = TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_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
+ && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl)))
+ {
+ 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);
+}
+
+/* Resolve a pointer to member function. INSTANCE is the object
+ instance to use, if the member points to a virtual member. */
+
+tree
+get_member_function_from_ptrfunc (instance_ptrptr, instance, function)
+ tree *instance_ptrptr;
+ tree instance;
+ tree function;
+{
+ if (TREE_CODE (function) == OFFSET_REF)
+ {
+ function = TREE_OPERAND (function, 1);
+ }
+
+ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
+ {
+ tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
+ tree index = save_expr (convert (integer_type_node,
+ build_component_ref (function,
+ index_identifier,
+ 0, 0)));
+ tree e1 = build (GT_EXPR, integer_type_node, index, integer_zero_node);
+ tree delta = build_component_ref (function, delta_identifier, 0, 0);
+ tree delta2 = DELTA2_FROM_PTRMEMFUNC (function);
+ tree e2;
+ tree e3;
+ tree aref, vtbl;
+
+ vtbl = build1 (ADDR_EXPR, ptr_type_node, instance);
+ vtbl = build (PLUS_EXPR,
+ build_pointer_type (build_pointer_type (vtable_entry_type)),
+ vtbl, convert (sizetype, delta2));
+ vtbl = build_indirect_ref (vtbl, NULL_PTR);
+ aref = build_array_ref (vtbl, size_binop (MINUS_EXPR,
+ index,
+ integer_one_node));
+ aref = save_expr (aref);
+
+ /* Save the intermediate result in a SAVE_EXPR so we don't have to
+ compute each component of the virtual function pointer twice. */
+ if (/* !building_cleanup && */ TREE_CODE (aref) == INDIRECT_REF)
+ TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
+
+ delta = build (PLUS_EXPR, integer_type_node,
+ build_conditional_expr (e1, build_component_ref (aref, delta_identifier, 0, 0), integer_zero_node),
+ delta);
+
+ *instance_ptrptr = build (PLUS_EXPR, TREE_TYPE (*instance_ptrptr),
+ *instance_ptrptr,
+ convert (integer_type_node, delta));
+ e2 = build_component_ref (aref, pfn_identifier, 0, 0);
+
+ e3 = PFN_FROM_PTRMEMFUNC (function);
+ TREE_TYPE (e2) = TREE_TYPE (e3);
+ function = build_conditional_expr (e1, e2, e3);
+ }
+ return function;
+}
+
+tree
+build_function_call_real (function, params, require_complete, flags)
+ tree function, params;
+ int require_complete, flags;
+{
+ register tree fntype, fndecl;
+ register tree value_type;
+ register tree coerced_params;
+ tree name = NULL_TREE, assembler_name = NULL_TREE;
+ 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)
+ {
+ name = DECL_NAME (function);
+ assembler_name = DECL_ASSEMBLER_NAME (function);
+
+ GNU_xref_call (current_function_decl,
+ IDENTIFIER_POINTER (name ? name
+ : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function))));
+ assemble_external (function);
+ fndecl = function;
+
+ /* Convert anything with function type to a pointer-to-function. */
+ if (pedantic
+ && name
+ && IDENTIFIER_LENGTH (name) == 4
+ && ! strcmp (IDENTIFIER_POINTER (name), "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))
+ {
+ fntype = build_type_variant (TREE_TYPE (function),
+ TREE_READONLY (function),
+ TREE_THIS_VOLATILE (function));
+ function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
+ }
+ else
+ {
+ assemble_external (function);
+ TREE_USED (function) = 1;
+ function = default_conversion (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);
+
+ if (TYPE_PTRMEMFUNC_P (fntype))
+ {
+ tree instance_ptr = build_unary_op (ADDR_EXPR, C_C_D, 0);
+ fntype = TYPE_PTRMEMFUNC_FN_TYPE (fntype);
+ function = get_member_function_from_ptrfunc (&instance_ptr, C_C_D, 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. */
+
+ if (flags & LOOKUP_COMPLAIN)
+ coerced_params = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
+ params, fndecl, LOOKUP_NORMAL);
+ else
+ coerced_params = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
+ params, fndecl, 0);
+
+ /* Check for errors in format strings. */
+
+ if (warn_format && (name || assembler_name))
+ check_function_format (name, assembler_name, coerced_params);
+
+ /* 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, 0);
+}
+
+tree
+build_function_call_maybe (function, params)
+ tree function, params;
+{
+ return build_function_call_real (function, params, 0, 0);
+}
+
+\f
+/* 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
+ || TREE_CODE (type) == ENUMERAL_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
+ || TREE_CODE (type) == ENUMERAL_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_HAS_INIT_REF (TREE_TYPE (val))
+ || TYPE_HAS_ASSIGN_REF (TREE_TYPE (val))))
+ {
+ cp_warning ("cannot pass objects of type `%T' through `...'",
+ 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
+ || TREE_CODE (type) == ENUMERAL_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 `%%#D'", called_thing);
+ cp_error_at (buf, fndecl);
+ 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);
+}
+\f
+/* 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 = build_opfncall (code, LOOKUP_SPECULATIVELY,
+ arg1, arg2, NULL_TREE);
+ if (rval)
+ return build_opfncall (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE);
+ if (code == MEMBER_REF)
+ return build_m_component_ref (build_indirect_ref (arg1, NULL_PTR),
+ arg2);
+ 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) && ! TYPE_PTRMEMFUNC_P (type1))
+ {
+ /* 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) && ! TYPE_PTRMEMFUNC_P (type1))
+ || (IS_AGGR_TYPE (type2) && ! TYPE_PTRMEMFUNC_P (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)
+ {
+ cp_error ("no match for `%O(%#T, %#T)'", code,
+ types[convert_index], types[convert_index ^ 1]);
+ 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, and deal with pointer to member functions. */
+
+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
+ /* When dividing two signed integers, we have to promote to int.
+ unless we divide by a conatant != -1. Note that default
+ conversion will have been performed on the operands at this
+ point, so we have to dig out the original type to find out if
+ it was unsigned. */
+ shorten = ((TREE_CODE (op0) == NOP_EXPR
+ && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
+ || (TREE_CODE (op1) == INTEGER_CST
+ && (TREE_INT_CST_LOW (op1) != -1
+ || TREE_INT_CST_HIGH (op1) != -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)
+ {
+ /* Although it would be tempting to shorten always here, that loses
+ on some targets, since the modulo instruction is undefined if the
+ quotient can't be represented in the computation mode. We shorten
+ only if unsigned or if dividing by something we know != -1. */
+ shorten = ((TREE_CODE (op0) == NOP_EXPR
+ && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
+ || (TREE_CODE (op1) == INTEGER_CST
+ && (TREE_INT_CST_LOW (op1) != -1
+ || TREE_INT_CST_HIGH (op1) != -1)));
+ common = 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 ("right 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 ("right 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 ("left 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 ("left 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 ("%s rotate count is negative",
+ (code == LROTATE_EXPR) ? "left" : "right");
+ else if (TREE_INT_CST_HIGH (op1) != 0
+ || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
+ >= TYPE_PRECISION (type0)))
+ warning ("%s rotate count >= width of type",
+ (code == LROTATE_EXPR) ? "left" : "right");
+ }
+ /* 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 if ((TYPE_SIZE (tt0) != 0) != (TYPE_SIZE (tt1) != 0))
+ pedwarn ("comparison of complete and incomplete pointers");
+ else
+ pedwarn ("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 (TYPE_PTRMEMFUNC_P (type0) && TREE_CODE (op1) == INTEGER_CST
+ && integer_zerop (op1))
+ {
+ op0 = build_component_ref (op0, index_identifier, 0, 0);
+ op1 = integer_zero_node;
+ }
+ else if (TYPE_PTRMEMFUNC_P (type1) && TREE_CODE (op0) == INTEGER_CST
+ && integer_zerop (op0))
+ {
+ op0 = build_component_ref (op1, index_identifier, 0, 0);
+ op1 = integer_zero_node;
+ }
+ else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
+ && (TYPE_PTRMEMFUNC_FN_TYPE (type0)
+ == TYPE_PTRMEMFUNC_FN_TYPE (type1)))
+ {
+ /* The code we generate for the test is:
+
+ (op0.index == op1.index
+ && ((op1.index != -1 && op0.delta2 == op1.delta2)
+ || op0.pfn == op1.pfn)) */
+
+ tree index0 = build_component_ref (op0, index_identifier, 0, 0);
+ tree index1 = save_expr (build_component_ref (op1, index_identifier, 0, 0));
+ tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
+ tree pfn1 = PFN_FROM_PTRMEMFUNC (op1);
+ tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
+ tree delta21 = DELTA2_FROM_PTRMEMFUNC (op1);
+ tree e1, e2, e3;
+ tree integer_neg_one_node
+ = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node);
+ e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
+ e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
+ e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, build_binary_op (EQ_EXPR, delta20, delta21, 1), 1);
+ e3 = build_binary_op (EQ_EXPR, pfn0, pfn1, 1);
+ e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
+ e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
+ if (code == EQ_EXPR)
+ return e2;
+ return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
+ }
+ else if (TYPE_PTRMEMFUNC_P (type0)
+ && TYPE_PTRMEMFUNC_FN_TYPE (type0) == type1)
+ {
+ tree index0 = build_component_ref (op0, index_identifier, 0, 0);
+ tree index1;
+ tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
+ tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
+ tree delta21 = integer_zero_node;
+ tree e1, e2, e3;
+ tree integer_neg_one_node
+ = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node);
+ if (TREE_CODE (TREE_OPERAND (op1, 0)) == FUNCTION_DECL
+ && DECL_VINDEX (TREE_OPERAND (op1, 0)))
+ {
+ /* Map everything down one to make room for the null pointer to member. */
+ index1 = size_binop (PLUS_EXPR,
+ DECL_VINDEX (TREE_OPERAND (op1, 0)),
+ integer_one_node);
+ op1 = integer_zero_node;
+ delta21 = CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE (TREE_TYPE (type1)));
+ delta21 = DECL_FIELD_BITPOS (delta21);
+ delta21 = size_binop (FLOOR_DIV_EXPR, delta21, size_int (BITS_PER_UNIT));
+ }
+ else
+ index1 = integer_neg_one_node;
+ op1 = build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type0), op1);
+ e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
+ e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
+ e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, build_binary_op (EQ_EXPR, delta20, delta21, 1), 1);
+ e3 = build_binary_op (EQ_EXPR, pfn0, op1, 1);
+ e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
+ e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
+ if (code == EQ_EXPR)
+ return e2;
+ return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
+ }
+ else if (TYPE_PTRMEMFUNC_P (type1)
+ && TYPE_PTRMEMFUNC_FN_TYPE (type1) == type0)
+ {
+ return build_binary_op (code, op1, op0, 1);
+ }
+ 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))
+ pedwarn ("comparison of distinct pointer types lacks a cast");
+ else if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
+ != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
+ pedwarn ("comparison of complete and incomplete pointers");
+ 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))
+ pedwarn ("comparison of distinct pointer types lacks a cast");
+ else if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
+ != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
+ pedwarn ("comparison of complete and incomplete pointers");
+ 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 (pedantic)
+ pedwarn ("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;
+ }
+}
+\f
+/* 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);
+
+ /* This generates an error if op1 is a pointer to an incomplete type. */
+ if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
+ error ("arithmetic on pointer to an incomplete type");
+
+ 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;
+}
+\f
+/* 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)
+ cp_warning ("address of `%T::%D' taken", basetype, 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;
+{
+ /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
+ error message. */
+ if (code != ADDR_EXPR || TREE_CODE (TREE_TYPE (xarg)) != RECORD_TYPE
+ || TYPE_SIZE (TREE_TYPE (xarg)))
+ {
+ tree rval = build_opfncall (code, LOOKUP_SPECULATIVELY, xarg,
+ NULL_TREE, NULL_TREE);
+ if (rval)
+ return build_opfncall (code, LOOKUP_NORMAL, xarg,
+ NULL_TREE, NULL_TREE);
+ }
+ 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
+ {
+ cp_error ("type conversion for type `%T' not allowed",
+ TREE_TYPE (arg));
+ 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
+ {
+ cp_error ("type conversion for type `%T' not allowed",
+ TREE_TYPE (arg));
+ 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
+ {
+ cp_error ("type conversion for type `%T' not allowed",
+ TREE_TYPE (arg));
+ 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)
+ cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'",
+ ((code == PREINCREMENT_EXPR
+ || code == POSTINCREMENT_EXPR)
+ ? "increment" : "decrement"), 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);
+ }
+
+ /* For &(++foo), we are really taking the address of the variable
+ being acted upon by the increment/decrement operator. ARM $5.3.1
+ However, according to ARM $5.2.5, we don't allow postfix ++ and
+ --, since the prefix operators return lvalues, but the postfix
+ operators do not. */
+ if (TREE_CODE (arg) == PREINCREMENT_EXPR
+ || TREE_CODE (arg) == PREDECREMENT_EXPR)
+ arg = TREE_OPERAND (arg, 0);
+
+ /* 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 take 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
+ && TREE_CODE (TREE_VALUE (arg)) == TREE_LIST
+ && 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 rationalize_conditional_expr (code, arg);
+ }
+
+ 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) /* Check all this code for right semantics. */
+ return build_unary_op (ADDR_EXPR, t, 0);
+ 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");
+}
+\f
+/* 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:
+ case RESULT_DECL:
+ /* For C++, we don't warn about taking the address of a register
+ variable for CONST_DECLs; ARM p97 explicitly says it's okay. */
+ 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;
+ }
+}
+\f
+/* Build and return a conditional expression IFEXP ? OP1 : OP2. */
+
+tree
+build_x_conditional_expr (ifexp, op1, op2)
+ tree ifexp, op1, op2;
+{
+ tree rval = NULL_TREE;
+
+ /* See comments in `build_x_binary_op'. */
+ if (op1 != 0)
+ rval = build_opfncall (COND_EXPR, LOOKUP_SPECULATIVELY, ifexp, op1, op2);
+ if (rval)
+ return build_opfncall (COND_EXPR, LOOKUP_NORMAL, ifexp, op1, op2);
+
+ 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;
+ tree orig_op1 = op1, orig_op2 = op2;
+
+ /* 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
+ && TREE_CODE (orig_op1) != NOP_EXPR)
+ result_type = qualify_type (type2, type1);
+ else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
+ && TREE_CODE (orig_op2) != NOP_EXPR)
+ 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
+ {
+ pedwarn ("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)
+ {
+ cp_error ("aggregate type `%T' could not convert on lhs of `:'", type1);
+ 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)
+ {
+ cp_error ("aggregate type `%T' could not convert on rhs of `:'", type2);
+ 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_and_check (result_type, op1);
+ if (result_type != TREE_TYPE (op2))
+ op2 = convert_and_check (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));
+}
+\f
+/* 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)));
+ 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));
+
+ /* When pedantic, a compound expression can be neither an lvalue
+ nor an integer constant expression. */
+ if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)) && ! pedantic)
+ 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 [why not? -jason], 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 (IS_SIGNATURE (type))
+ {
+ error ("cast specifies signature type");
+ return error_mark_node;
+ }
+
+ 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, ovalue;
+
+ /* 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)) == METHOD_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
+
+ ovalue = value;
+ value = convert_force (type, value);
+
+ /* Ignore any integer overflow caused by the cast. */
+ if (TREE_CODE (value) == INTEGER_CST)
+ {
+ TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
+ TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
+ }
+ }
+
+ /* Always produce some operator for an explicit cast,
+ so we can tell (for -pedantic) that the cast is no lvalue.
+ Also, pedantically, don't let (void *) (FOO *) 0 be a null
+ pointer constant. */
+ if (value == expr
+ || (pedantic
+ && TREE_CODE (value) == INTEGER_CST
+ && TREE_CODE (expr) == INTEGER_CST
+ && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE))
+ {
+ tree nvalue = build1 (NOP_EXPR, type, value);
+ TREE_CONSTANT (nvalue) = TREE_CONSTANT (value);
+ return nvalue;
+ }
+
+ return value;
+}
+\f
+/* 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;
+}
+
+#if 0
+/* 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_full (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; see 13.4.3. */
+ 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 (TREE_READONLY (elt)
+ || TREE_CODE (TREE_TYPE (elt)) == REFERENCE_TYPE)
+ {
+ cp_error ("cannot generate default `%T::operator ='",
+ lhstype);
+ if (TREE_CODE (TREE_TYPE (elt)) == REFERENCE_TYPE)
+ cp_error_at ("because member `%#D' is a reference", elt);
+ else
+ cp_error_at ("because member `%#D' is const", elt);
+
+ return error_mark_node;
+ }
+
+ 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;
+}
+#endif
+
+/* Taken from expr.c:
+ Subroutine of expand_expr:
+ record the non-copied parts (LIST) of an expr (LHS), and return a list
+ which specifies the initial values of these parts. */
+
+static tree
+init_noncopied_parts (lhs, list)
+ tree lhs;
+ tree list;
+{
+ tree tail;
+ tree parts = 0;
+
+ for (tail = list; tail; tail = TREE_CHAIN (tail))
+ if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
+ parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
+ else
+ {
+ tree part = TREE_VALUE (tail);
+ tree part_type = TREE_TYPE (part);
+ tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
+ parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
+ }
+ return parts;
+}
+
+/* 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.
+*/
+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 assignment to signature pointers/refs. */
+
+ if (TYPE_LANG_SPECIFIC (lhstype) &&
+ (IS_SIGNATURE_POINTER (lhstype) || IS_SIGNATURE_REFERENCE (lhstype)))
+ {
+ return build_signature_pointer_constructor (lhs, 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);
+ newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
+ modifycode, rhs);
+ if (TREE_CODE (newrhs) == ERROR_MARK)
+ return error_mark_node;
+ return build (COMPOUND_EXPR, lhstype,
+ TREE_OPERAND (lhs, 0), newrhs);
+
+ /* 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));
+ if (TREE_CODE (cond) == ERROR_MARK)
+ return cond;
+ /* 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)
+ {
+ if (TYPE_LANG_SPECIFIC (lhstype) && TYPE_HAS_CONSTRUCTOR (lhstype))
+ {
+ result = build_method_call (lhs, constructor_name_full (lhstype),
+ build_tree_list (NULL_TREE, rhs),
+ NULL_TREE, LOOKUP_NORMAL);
+ if (result == NULL_TREE)
+ return error_mark_node;
+ return result;
+ }
+ }
+ 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_PTR);
+ if (lhs == error_mark_node)
+ {
+ cp_error ("conversion to private basetype `%T'", lhstype);
+ 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)));
+ if (TREE_CODE (result) == ERROR_MARK)
+ return result;
+ 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
+ /* For assignment to `const' signature pointer/reference fields,
+ don't warn either, we already printed a better message before. */
+ && ! (TREE_CODE (lhs) == COMPONENT_REF
+ && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs, 0)))
+ || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs, 0)))))
+ && (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_PTRMEMFUNC_P (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)))))
+ {
+ /* This was decided in finish_struct. */
+ if (modifycode == INIT_EXPR)
+ cp_error ("can't generate default copy constructor for `%T'", lhstype);
+ else
+ cp_error ("can't generate default assignment operator for `%T'",
+ lhstype);
+#if 0
+ /* This is now done by generating X(X&) and operator=(X&). */
+ 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) != COND_EXPR
+ && 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));
+
+ if (TREE_CODE (newrhs) == COND_EXPR)
+ rhs_addr = rationalize_conditional_expr (ADDR_EXPR, newrhs);
+ else
+ rhs_addr = build_unary_op (ADDR_EXPR, newrhs, 0);
+
+ result = tree_cons (NULL_TREE,
+ convert (build_reference_type (lhstype), lhs),
+ 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);
+ {
+ tree noncopied_parts = NULL_TREE;
+
+ if (TYPE_NONCOPIED_PARTS (lhstype) != 0)
+ noncopied_parts = init_noncopied_parts (lhs,
+ TYPE_NONCOPIED_PARTS (lhstype));
+ while (noncopied_parts != 0)
+ {
+ result = tree_cons (NULL_TREE,
+ build_modify_expr (convert (ptr_type_node, TREE_VALUE (noncopied_parts)),
+ NOP_EXPR,
+ TREE_PURPOSE (noncopied_parts)),
+ result);
+ noncopied_parts = TREE_CHAIN (noncopied_parts);
+ }
+ }
+ /* 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_PTR);
+
+ 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_PTR),
+ modifycode,
+ build_indirect_ref (elt_rhs, NULL_PTR),
+ 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);
+#endif
+ }
+
+ /* 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_for_rtl_expr (result);
+
+ /* 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 (result = build_opfncall (MODIFY_EXPR,
+ LOOKUP_NORMAL, lhs, newrhs,
+ make_node (NOP_EXPR)))
+ return result;
+ }
+ /* Avoid warnings on enum bit fields. */
+ if (TREE_CODE (olhstype) == ENUMERAL_TYPE
+ && TREE_CODE (lhstype) == INTEGER_TYPE)
+ {
+ newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
+ NULL_TREE, 0);
+ newrhs = convert_force (lhstype, newrhs);
+ }
+ else
+ 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;
+ /* Avoid warnings converting integral types back into enums
+ for enum bit fields. */
+ if (TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
+ && TREE_CODE (olhstype) == ENUMERAL_TYPE)
+ return convert_force (olhstype, 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;
+}
+\f
+/* Build a constructor for a pointer to member function. It can be
+ used to initialize global variables, local variable, or used
+ as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
+ want to be.
+
+ If FORCE is non-zero, then force this conversion, even if
+ we would rather not do it. Usually set when using an explicit
+ cast. */
+
+tree
+build_ptrmemfunc (type, pfn, force)
+ tree type, pfn;
+ int force;
+{
+ tree index;
+ tree delta = integer_zero_node;
+ tree delta2 = integer_zero_node;
+ tree vfield_offset;
+ tree npfn;
+ tree u;
+
+ /* Handle null pointer to member function conversions. */
+ if (integer_zerop (pfn))
+ {
+ pfn = build_c_cast (type, integer_zero_node);
+ u = build_nt (CONSTRUCTOR, 0, tree_cons (pfn_identifier, pfn, NULL_TREE));
+ return build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, integer_zero_node,
+ tree_cons (NULL_TREE, integer_zero_node,
+ tree_cons (NULL_TREE, u, NULL_TREE))));
+ }
+
+ /* Allow pointer to member conversions here. */
+ if (type != TREE_TYPE (pfn))
+ {
+ tree binfo
+ = get_binfo (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn))),
+ TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
+ 1);
+ if (binfo == error_mark_node)
+ {
+ error (" in pointer to member function conversion");
+ return NULL_TREE;
+ }
+ if (binfo == 0)
+ {
+ if (!force)
+ {
+ error_not_base_type (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn))),
+ TYPE_METHOD_BASETYPE (TREE_TYPE (type)));
+ error (" in pointer to member function conversion");
+ return NULL_TREE;
+ }
+ /* Just something handy with an offset of zero. */
+ binfo = TYPE_BINFO (TYPE_METHOD_BASETYPE (TREE_TYPE (type)));
+ }
+ if (TREE_VIA_VIRTUAL (binfo))
+ {
+ sorry ("pointer to member conversion from virtual base class");
+ }
+ delta = BINFO_OFFSET (binfo);
+ delta2 = size_binop (PLUS_EXPR, delta2, delta);
+ }
+
+
+ if (TREE_CODE (TREE_OPERAND (pfn, 0)) != FUNCTION_DECL)
+ warning ("assuming pointer to member function is non-virtual");
+
+ if (TREE_CODE (TREE_OPERAND (pfn, 0)) == FUNCTION_DECL
+ && DECL_VINDEX (TREE_OPERAND (pfn, 0)))
+ {
+ /* Find the offset to the vfield pointer in the object. */
+ vfield_offset = TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn)));
+ vfield_offset = CLASSTYPE_VFIELD (vfield_offset);
+ vfield_offset = DECL_FIELD_BITPOS (vfield_offset);
+ vfield_offset = size_binop (FLOOR_DIV_EXPR, vfield_offset, size_int (BITS_PER_UNIT));
+ delta2 = size_binop (PLUS_EXPR, vfield_offset, delta2);
+
+ /* Map everything down one to make room for the null pointer to member. */
+ index = size_binop (PLUS_EXPR,
+ DECL_VINDEX (TREE_OPERAND (pfn, 0)),
+ integer_one_node);
+ u = build_nt (CONSTRUCTOR, 0, tree_cons (delta2_identifier, delta2, NULL_TREE));
+
+ return build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, delta,
+ tree_cons (NULL_TREE, index,
+ tree_cons (NULL_TREE, u, NULL_TREE))));
+ }
+ else
+ index = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node);
+
+ npfn = build1 (NOP_EXPR, type, pfn);
+ TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn);
+
+ u = build_nt (CONSTRUCTOR, 0, tree_cons (pfn_identifier, npfn, NULL_TREE));
+
+ return build_nt (CONSTRUCTOR, 0, tree_cons (NULL_TREE, delta,
+ tree_cons (NULL_TREE, index,
+ tree_cons (NULL_TREE, u, NULL_TREE))));
+}
+
+/* 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_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 (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)
+ {
+ overflow_warning (rhs);
+ 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)
+ {
+ if (fndecl)
+ cp_warning ("`%T' used for argument %P of `%D'",
+ rhstype, parmnum, fndecl);
+ else
+ cp_warning ("%s to `%T' from `%T'", errtype, type, rhstype);
+ }
+ /* 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))
+ {
+ if (fndecl)
+ cp_warning ("negative value `%E' passed as argument %P of `%D'",
+ rhs, parmnum, fndecl);
+ else
+ cp_warning ("%s of negative value `%E' to `%T'",
+ errtype, rhs, type);
+ }
+ overflow_warning (rhs);
+ if (TREE_CONSTANT (rhs))
+ rhs = fold (rhs);
+ }
+
+ return convert_and_check (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)))
+ {
+ return convert (type, rhs);
+ }
+ /* Conversions among pointers */
+ else if (codel == POINTER_TYPE
+ && (coder == POINTER_TYPE
+ || (coder == RECORD_TYPE
+ && (IS_SIGNATURE_POINTER (rhstype)
+ || IS_SIGNATURE_REFERENCE (rhstype)))))
+ {
+ register tree ttl = TREE_TYPE (type);
+ register tree ttr;
+
+ if (coder == RECORD_TYPE)
+ {
+ rhs = build_optr_ref (rhs);
+ rhstype = TREE_TYPE (rhs);
+ }
+ 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 error_not_base_type (ttl, ttr);
+
+ if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
+ {
+ if (fndecl)
+ cp_warning ("passing `%T' as argument %P of `%D' discards const",
+ rhstype, parmnum, fndecl);
+ else
+ cp_warning ("%s to `%T' from `%T' discards const",
+ errtype, type, rhstype);
+ }
+ if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
+ {
+ if (fndecl)
+ cp_warning ("passing `%T' as argument %P of `%D' discards volatile",
+ rhstype, parmnum, fndecl);
+ else
+ cp_warning ("%s to `%T' from `%T' discards volatile",
+ errtype, type, rhstype);
+ }
+ }
+
+ /* 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)
+ || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
+ == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
+ {
+ /* ARM $4.8, commentary on p39. */
+ if (TYPE_MAIN_VARIANT (ttl) == void_type_node
+ && TREE_CODE (ttr) == OFFSET_TYPE)
+ {
+ error ("no standard conversion from pointer to member to `void *'");
+ return error_mark_node;
+ }
+
+ if (TYPE_MAIN_VARIANT (ttl) != void_type_node
+ && TYPE_MAIN_VARIANT (ttr) == void_type_node
+ && rhs != null_pointer_node)
+ if (coder == RECORD_TYPE)
+ pedwarn ("implicit conversion of signature pointer to type `%s'",
+ type_as_string (type, 0));
+ else
+ 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))))
+ {
+ if (fndecl)
+ cp_pedwarn ("passing `%T' as argument %P of `%D'",
+ rhstype, parmnum, fndecl);
+ else
+ cp_pedwarn ("%s to `void *' from `%T'", errtype, rhstype);
+ }
+ /* 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))
+ {
+ if (fndecl)
+ cp_warning ("passing `%T' as argument %P of `%D' discards const",
+ rhstype, parmnum, fndecl);
+ else
+ cp_warning ("%s to `%T' from `%T' discards const",
+ errtype, type, rhstype);
+ }
+ if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
+ {
+ if (fndecl)
+ cp_warning ("passing `%T' as argument %P of `%D' discards volatile",
+ rhstype, parmnum, fndecl);
+ else
+ cp_warning ("%s to `%T' from `%T' discards volatile",
+ errtype, type, rhstype);
+ }
+ }
+ }
+ 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)
+ {
+ if (fndecl)
+ cp_warning ("passing `%T' as argument %P of `%D' discards const",
+ rhstype, parmnum, fndecl);
+ else
+ cp_warning ("%s to `%T' from `%T' discards const",
+ errtype, type, rhstype);
+ }
+ if (volatile_parity)
+ {
+ if (fndecl)
+ cp_warning ("passing `%T' as argument %P of `%D' discards volatile",
+ rhstype, parmnum, fndecl);
+ else
+ cp_warning ("%s to `%T' from `%T' discards volatile",
+ errtype, type, rhstype);
+ }
+ if (unsigned_parity > 0)
+ {
+ if (fndecl)
+ cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned",
+ rhstype, parmnum, fndecl);
+ else
+ cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned",
+ errtype, type, rhstype);
+ }
+ else if (unsigned_parity < 0)
+ {
+ if (fndecl)
+ cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed",
+ rhstype, parmnum, fndecl);
+ else
+ cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed",
+ errtype, type, rhstype);
+ }
+
+ /* 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))
+ {
+ warning ("conflicting function types in %s:", errtype);
+ cp_warning ("\t`%T' != `%T'", type, rhstype);
+ }
+ }
+ 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)
+ cp_error ("passing `%T' as argument %P of `%D'",
+ rhstype, parmnum, fndecl);
+ else
+ cp_error ("%s to `%T' from `%T'", errtype, type, rhstype);
+ return error_mark_node;
+ }
+ }
+ return convert (type, rhs);
+ }
+ else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
+ {
+ /* An explicit constant 0 can convert to a pointer,
+ but not a 0 that results from casting or folding. */
+ if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs)))
+ {
+ if (fndecl)
+ cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
+ rhstype, parmnum, fndecl);
+ else
+ cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
+ errtype, type, rhstype);
+ return convert (type, rhs);
+ }
+ return null_pointer_node;
+ }
+ else if (codel == INTEGER_TYPE
+ && (coder == POINTER_TYPE
+ || (coder == RECORD_TYPE
+ && (IS_SIGNATURE_POINTER (rhstype)
+ || IS_SIGNATURE_REFERENCE (rhstype)))))
+ {
+ if (fndecl)
+ cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast",
+ rhstype, parmnum, fndecl);
+ else
+ cp_pedwarn ("%s to `%T' from `%T' lacks a cast",
+ errtype, type, rhstype);
+ return convert (type, rhs);
+ }
+
+ /* C++ */
+ else if (((coder == POINTER_TYPE && TREE_CODE (rhs) == ADDR_EXPR
+ && TREE_CODE (rhstype) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (rhstype)) == METHOD_TYPE)
+ || integer_zerop (rhs))
+ && TYPE_PTRMEMFUNC_P (type))
+ {
+ /* compatible pointer to member functions. */
+ rhs = build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), rhs, 0);
+ if (rhs == 0)
+ return error_mark_node;
+ return digest_init (type, rhs, (tree *)0);
+ }
+ 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);
+
+ cp_error ("%s to `%T' from `%T'", errtype, type, rhstype);
+ return error_mark_node;
+}
+
+/* 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 (TYPE_LANG_SPECIFIC (type)
+ && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
+ return build_signature_pointer_constructor (type, rhs);
+
+ if (IS_AGGR_TYPE (type) && TYPE_NEEDS_CONSTRUCTING (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))
+ {
+ tree init = build_method_call (exp, constructor_name_full (type),
+ 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);
+ }
+
+ /* ??? The following warnings are turned off because
+ this is another place where the default X(X&) constructor
+ is implemented. */
+ if (TYPE_HAS_ASSIGNMENT (type))
+ cp_warning ("bitwise copy: `%T' defines operator=", type);
+
+ 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 (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);
+}
+\f
+/* 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 ();
+}
+\f
+/* 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;
+ int returns_value = 1;
+
+ if (TREE_THIS_VOLATILE (current_function_decl))
+ warning ("function declared `noreturn' 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) != NULL_TREE
+ && TREE_CODE (valtype) != VOID_TYPE)
+ retval = result;
+ else
+ {
+ current_function_returns_null = 1;
+
+ if (valtype != NULL_TREE && TREE_CODE (valtype) != VOID_TYPE)
+ {
+ if (DECL_NAME (DECL_RESULT (current_function_decl)) == NULL_TREE)
+ {
+ pedwarn ("`return' with no value, in function returning non-void");
+ /* Clear this, so finish_function won't say that we
+ reach the end of a non-void function (which we don't,
+ we gave a return!). */
+ current_function_returns_null = 0;
+ }
+ }
+
+ 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 == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE)
+ {
+ current_function_returns_null = 1;
+ /* We do this here so we'll avoid a warning about how the function
+ "may or may not return a value" in finish_function. */
+ returns_value = 0;
+
+ if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
+ pedwarn ("`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)))
+ cp_warning_at ("reference to local variable `%D' returned", whats_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))
+ cp_warning_at ("address of local variable `%D' returned", whats_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_CONSTRUCTING (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 = returns_value;
+ 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);
+}
+\f
+/* 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;
+ register enum tree_code code;
+
+ /* Convert from references, etc. */
+ exp = default_conversion (exp);
+ type = TREE_TYPE (exp);
+ code = TREE_CODE (type);
+
+ if (IS_AGGR_TYPE_CODE (code))
+ exp = build_type_conversion (CONVERT_EXPR, integer_type_node, exp, 1);
+
+ 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;
+}
--- /dev/null
+/* Report error messages, build initializers, and perform
+ some front-end optimizations for C++ compiler.
+ Copyright (C) '87, '88, '89, '92, 1993, 1994 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;
+{
+ if (TREE_CODE (basetype) == FUNCTION_DECL)
+ basetype = DECL_CLASS_CONTEXT (basetype);
+ cp_error ("type `%T' is not a base type for type `%T'", basetype, type);
+ 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 if (TREE_CODE (arg) == RESULT_DECL)
+ (*fn) ("%s of read-only named return value `%s'",
+ string, lang_printable_name (arg));
+ 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;
+{
+ tree u = CLASSTYPE_ABSTRACT_VIRTUALS (type);
+
+ if (decl)
+ {
+ if (TREE_CODE (decl) == RESULT_DECL)
+ return;
+
+ if (TREE_CODE (decl) == VAR_DECL)
+ cp_error ("cannot declare variable `%D' to be of type `%T'",
+ decl, type);
+ else if (TREE_CODE (decl) == PARM_DECL)
+ cp_error ("cannot declare parameter `%D' to be of type `%T'",
+ decl, type);
+ else if (TREE_CODE (decl) == FIELD_DECL)
+ cp_error ("cannot declare field `%D' to be of type `%T'",
+ decl, type);
+ else if (TREE_CODE (decl) == FUNCTION_DECL
+ && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
+ cp_error ("invalid return type for method `%#D'", decl);
+ else if (TREE_CODE (decl) == FUNCTION_DECL)
+ cp_error ("invalid return type for function `%#D'", decl);
+ }
+ else cp_error ("cannot allocate an object of type `%T'", type);
+ /* 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)
+ {
+ cp_error ("\t%#D", TREE_VALUE (u));
+ u = TREE_CHAIN (u);
+ }
+ }
+ else cp_error (" since type `%T' has abstract virtual functions", type);
+}
+
+/* Print an error message for invalid use of a signature type.
+ Signatures are treated similar to abstract classes here, they
+ cannot be instantiated. */
+void
+signature_error (decl, type)
+ tree decl;
+ tree type;
+{
+ if (decl)
+ {
+ if (TREE_CODE (decl) == RESULT_DECL)
+ return;
+
+ if (TREE_CODE (decl) == VAR_DECL)
+ cp_error ("cannot declare variable `%D' to be of signature type `%T'",
+ decl, type);
+ else if (TREE_CODE (decl) == PARM_DECL)
+ cp_error ("cannot declare parameter `%D' to be of signature type `%T'",
+ decl, type);
+ else if (TREE_CODE (decl) == FIELD_DECL)
+ cp_error ("cannot declare field `%D' to be of signature type `%T'",
+ decl, type);
+ else if (TREE_CODE (decl) == FUNCTION_DECL
+ && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
+ cp_error ("invalid return type for method `%#D'", decl);
+ else if (TREE_CODE (decl) == FUNCTION_DECL)
+ cp_error ("invalid return type for function `%#D'", decl);
+ }
+ else
+ error ("cannot allocate an object of signature type `%T'", type);
+}
+
+/* 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);
+ }
+}
+
+/* Like error(), but don't call report_error_function(). */
+static void
+ack (s, v, v2)
+ char *s;
+ HOST_WIDE_INT v;
+ HOST_WIDE_INT v2;
+{
+ extern char * progname;
+
+ if (input_filename)
+ fprintf (stderr, "%s:%d: ", input_filename, lineno);
+ else
+ fprintf (stderr, "%s: ", progname);
+
+ fprintf (stderr, s, v, v2);
+ fprintf (stderr, "\n");
+}
+
+/* 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: 355. Free: 5. */
+
+static int abortcount = 0;
+
+void
+my_friendly_abort (i)
+ int i;
+{
+ /* if the previous error came through here, i.e. report_error_function
+ ended up calling us again, don't just exit; we want a diagnostic of
+ some kind. */
+ if (abortcount == 1)
+ current_function_decl = NULL_TREE;
+ else if (errorcount > 0 || sorrycount > 0)
+ {
+ if (abortcount > 1)
+ {
+ if (i == 0)
+ ack ("Internal compiler error.");
+ else
+ ack ("Internal compiler error %d.", i);
+ ack ("Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.");
+ }
+ else
+ error ("confused by earlier errors, bailing out");
+
+ exit (34);
+ }
+ ++abortcount;
+
+ 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);
+}
+\f
+/* 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 provided int is as wide as a pointer. */
+ if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
+ && ! tree_int_cst_lt (TYPE_SIZE (TREE_TYPE (value)),
+ TYPE_SIZE (TREE_TYPE (TREE_OPERAND (value, 0)))))
+ 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;
+}
+\f
+/* 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) && TREE_CODE (init) != CONSTRUCTOR)
+ my_friendly_abort (109);
+ else if (IS_AGGR_TYPE (type))
+ {
+ /* Although we are not allowed to declare variables of signature
+ type, we complain about a possible constructor call in such a
+ declaration as well. */
+ if (TREE_CODE (init) == TREE_LIST
+ && IS_SIGNATURE (type))
+ {
+ cp_error ("constructor syntax cannot be used with signature type `%T'",
+ type);
+ init = error_mark_node;
+ }
+ else if (TREE_CODE (init) == TREE_LIST)
+ {
+ cp_error ("constructor syntax used, but no constructor declared for type `%T'", type);
+ init = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (init));
+ }
+#if 0
+ if (TREE_CODE (init) == CONSTRUCTOR)
+ {
+ tree field;
+ tree funcs;
+ int func;
+
+ /* Check that we're really an aggregate as ARM 8.4.1 defines it. */
+ if (CLASSTYPE_N_BASECLASSES (type))
+ cp_error_at ("initializer list construction illegal for derived class object `%D'", decl);
+ if (CLASSTYPE_VTBL_PTR (type))
+ cp_error_at ("initializer list construction illegal for polymorphic class object `%D'", decl);
+ if (TYPE_NEEDS_CONSTRUCTING (type))
+ {
+ cp_error_at ("initializer list construction illegal for `%D'", decl);
+ error ("due to the presence of a constructor");
+ }
+ for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+ if (TREE_PRIVATE (field) || TREE_PROTECTED (field))
+ {
+ cp_error_at ("initializer list construction illegal for `%D'", decl);
+ cp_error_at ("due to non-public access of member `%D'", field);
+ }
+ funcs = TYPE_METHODS (type);
+ if (funcs)
+ for (func = 0; func < TREE_VEC_LENGTH (funcs); func++)
+ {
+ field = TREE_VEC_ELT (funcs, func);
+ if (field && (TREE_PRIVATE (field) || TREE_PROTECTED (field)))
+ {
+ cp_error_at ("initializer list construction illegal for `%D'", decl);
+ cp_error_at ("due to non-public access of member `%D'", field);
+ }
+ }
+ }
+#endif
+ }
+ 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
+ {
+ /* We get here with code like `int a (2);' */
+
+ if (TREE_CHAIN (init) != NULL_TREE)
+ {
+ pedwarn ("initializer list being treated as compound expression");
+ init = build_compound_expr (init);
+ }
+ else
+ init = TREE_VALUE (init);
+ }
+ }
+
+ /* 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;
+}
+\f
+/* 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;
+
+ /* 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 && TYPE_PTRMEMFUNC_P (type)
+ && ((TREE_CODE (init) == ADDR_EXPR
+ && TREE_CODE (TREE_TYPE (init)) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (TREE_TYPE (init))) == METHOD_TYPE)
+ || integer_zerop (init)))
+ {
+ init = build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), init, 0);
+ }
+
+ raw_constructor = TREE_CODE (init) == CONSTRUCTOR && TREE_TYPE (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,
+ and signature pointers and references. */
+
+ if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
+ || code == ENUMERAL_TYPE || code == REFERENCE_TYPE
+ || (code == RECORD_TYPE && ! raw_constructor
+ && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_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, (tree *)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;
+}
+\f
+/* 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 (warn_missing_braces)
+ 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 member 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;
+
+ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (field)))
+ {
+ tree t
+ = build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (field)),
+ default_conversion (TREE_VALUE (tail)),
+ 0);
+ if (t == NULL_TREE)
+ return error_mark_node;
+ next1 = digest_init (TREE_TYPE (field), t, &tail1);
+ }
+ else
+ next1 = digest_init (TREE_TYPE (field),
+ TREE_VALUE (tail), &tail1);
+ my_friendly_assert (tail1 == 0
+ || TREE_CODE (tail1) == TREE_LIST, 320);
+ 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 && init != empty_init_node)
+ {
+ 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);
+
+ /* 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;
+}
+\f
+/* 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;
+
+ if (TREE_CODE (type) == REFERENCE_TYPE)
+ type = TREE_TYPE (type);
+
+ 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:
+ /* Signature pointers are not dereferenced. */
+ if (TYPE_LANG_SPECIFIC (TREE_TYPE (last_rval))
+ && IS_SIGNATURE_POINTER (TREE_TYPE (last_rval)))
+ return last_rval;
+
+ if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
+ return build_indirect_ref (last_rval, NULL_PTR);
+
+ 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 not 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 objtype = TREE_TYPE (datum);
+ tree rettype;
+
+ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
+ {
+ type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (component)));
+ rettype = type;
+ }
+ else
+ {
+ component = build_indirect_ref (component, NULL_PTR);
+ type = TREE_TYPE (component);
+ rettype = TREE_TYPE (TREE_TYPE (component));
+ }
+
+ if (datum == error_mark_node || component == error_mark_node)
+ return error_mark_node;
+
+ if (! IS_AGGR_TYPE (objtype))
+ {
+ cp_error ("cannot apply member pointer `%D' to `%E'", component, datum);
+ cp_error ("which is of non-aggregate type `%T'", objtype);
+ 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))
+ {
+ cp_error ("member type `%T::' incompatible with object type `%T'",
+ TYPE_METHOD_BASETYPE (type), objtype);
+ return error_mark_node;
+ }
+
+ return build (OFFSET_REF, rettype, 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)
+ {
+ cp_error ("`%T' fails to be a typedef or built-in type", name);
+ return error_mark_node;
+ }
+ type = TREE_TYPE (type);
+ }
+ }
+ else
+ type = exp;
+
+ if (IS_SIGNATURE (type))
+ {
+ error ("signature type not allowed in cast or constructor expression");
+ return error_mark_node;
+ }
+
+ /* 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)
+ && (TREE_CODE (IDENTIFIER_CLASS_VALUE (name)) == TREE_LIST
+ || TREE_CODE (IDENTIFIER_CLASS_VALUE (name)) == FUNCTION_DECL))
+ {
+ expr_as_method = build_method_call (current_class_decl, name, parms,
+ NULL_TREE, LOOKUP_SPECULATIVELY);
+ if (expr_as_method == error_mark_node)
+ expr_as_method = NULL_TREE;
+ }
+
+ 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;
+
+ return build1 (NOP_EXPR, type, integer_zero_node);
+ }
+ if (expr_as_method
+ || (expr_as_fncall && expr_as_fncall != error_mark_node))
+ {
+ cp_error ("ambiguity between cast to `%#T' and function call", type);
+ 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;
+ cp_error ("type `%T' is not yet defined", type);
+ 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_CONSTRUCTING (type) && parms != NULL_TREE)
+ {
+ char *msg = 0;
+
+ if (parms == NULL_TREE)
+ msg = "argument missing in cast to `%T' type";
+ else if (TREE_CHAIN (parms) == NULL_TREE)
+ {
+ if (expr_as_conversion == NULL_TREE)
+ msg = "conversion to type `%T' failed";
+ }
+ else msg = "type `%T' does not have a constructor";
+
+ if ((expr_as_method || expr_as_fncall) && expr_as_conversion)
+ msg = "ambiguity between conversion to `%T' and function call";
+ else if (expr_as_method || expr_as_fncall)
+ goto return_function;
+ else if (expr_as_conversion)
+ return expr_as_conversion;
+
+ cp_error (msg, type);
+ return error_mark_node;
+ }
+
+#if 0
+ /* Constructors are not inherited... --jason */
+ 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);
+#endif
+
+ {
+ 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
+ {
+ cp_warning ("function hides constructor for class `%T'", type);
+ return expr_as_fncall;
+ }
+ else if (expr_as_conversion && expr_as_conversion != error_mark_node)
+ {
+ /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
+ cp_error ("ambiguity between conversion to `%T' and constructor",
+ type);
+ return error_mark_node;
+ }
+
+ if (current_function_decl)
+ return build_cplus_new (type, expr_as_ctor, 0);
+
+ {
+ 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);
+#if 0
+ /* The following assertion fails in cases where we are initializing
+ a static member variable of a particular instance of a template
+ class with a call to a constructor of the given instance, as in:
+
+ TMPL<int> object = TMPL<int>();
+
+ Curiously, the assertion does not fail if we do the same thing
+ for a static member of a non-template class, as in:
+
+ T object = T();
+
+ I can't see why we should care here whether or not the initializer
+ expression involves a call to `new', so for the time being, it
+ seems best to just avoid doing this assertion. */
+ my_friendly_assert (TREE_CALLS_NEW (TREE_VALUE (parm)), 323);
+#endif
+ TREE_VALUE (parm) = NULL_TREE;
+ expr_as_ctor = build_indirect_ref (expr_as_ctor, NULL_PTR);
+ 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)
+ {
+ cp_error ("ambiguity between conversion to `%T' and function call",
+ type);
+ 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, LOOKUP_COMPLAIN, (struct candidate *)0)
+ : expr_as_fncall;
+ cp_error ("no suitable conversion to `%T' exists", type);
+ return error_mark_node;
+ }
+}
+\f
+/* 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");
+ }
+}
--- /dev/null
+/* 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 if (IS_SIGNATURE (decl)) cls = "SIGNATUREID";
+ 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), 0));
+ 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")
+ || STREQL (cls, "SIGNATUREID"))
+ {
+ 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 access 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;
+ }
+}
OSDN Git Service
